000457a0 <_API_Mutex_Allocate>:
#include <rtems/score/apimutex.h>

void _API_Mutex_Allocate(
  API_Mutex_Control **the_mutex
)
{
   457a0:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   457a4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   457a6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  CORE_mutex_Attributes attr =  {
    CORE_MUTEX_NESTING_IS_ERROR,
    FALSE,
    CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT,
    0
  };
   457a8:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   457aa:	4878 000e      	pea e <OPER1+0x2>                                 	<== NOT EXECUTED
   457ae:	0682 ffff fff2 	addil #-14,%d2                                    	<== NOT EXECUTED
   457b4:	4879 0005 41aa 	pea 541aa <C.26.3475>                             	<== NOT EXECUTED
   457ba:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   457bc:	4eb9 0004 b3f4 	jsr 4b3f4 <memcpy>                                	<== NOT EXECUTED

  mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information );
   457c2:	4879 0005 6d8c 	pea 56d8c <_API_Mutex_Information>                	<== NOT EXECUTED
   457c8:	4eb9 0004 600c 	jsr 4600c <_Objects_Allocate>                     	<== NOT EXECUTED

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

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

  _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED );
   457d4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   457d6:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   457da:	4eb9 0004 58ec 	jsr 458ec <_CORE_mutex_Initialize>                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   457e0:	2079 0005 6da6 	moveal 56da6 <_API_Mutex_Information+0x1a>,%a0    	<== NOT EXECUTED
   457e6:	4280           	clrl %d0                                          	<== NOT EXECUTED
   457e8:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   457ec:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
    _Objects_Get_index( the_object->id ),
    the_object
  );

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

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

  *the_mutex = mutex;
   457f2:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   457f8:	2540 000c      	movel %d0,%a2@(12)                                	<== NOT EXECUTED
   457fc:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   45800:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
}
   45802:	242e ffe8      	movel %fp@(-24),%d2                               	<== NOT EXECUTED
   45806:	246e ffec      	moveal %fp@(-20),%a2                              	<== NOT EXECUTED
   4580a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4580c:	4e75           	rts                                               	<== NOT EXECUTED
	...

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

void _API_Mutex_Initialization(
  uint32_t maximum_mutexes
)
{
   45844:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   45848:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4584a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4584c:	4878 0072      	pea 72 <FP_REGS_SAVED+0x32>                       	<== NOT EXECUTED
   45850:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45854:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   45858:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4585c:	4879 0005 6d8c 	pea 56d8c <_API_Mutex_Information>                	<== NOT EXECUTED
   45862:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   45868:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    TRUE,                        /* TRUE if this is a global object class */
    NULL                         /* Proxy extraction support callout */
#endif
  );
}
   4586e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45870:	4e75           	rts                                               	<== NOT EXECUTED
	...

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

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

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

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

  _ISR_Disable( level );
   4581e:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   45820:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   45822:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _CORE_mutex_Seize(
   45824:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45826:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45828:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4582c:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   45830:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   45834:	4eb9 0004 5a00 	jsr 45a00 <_CORE_mutex_Seize>                     	<== NOT EXECUTED
   4583a:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    the_mutex->Object.id,
    TRUE,
    0,
    level
  );
}
   45840:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45842:	4e75           	rts

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

  _Thread_Dispatch_disable_level += 1;
   45874:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
#include <rtems/score/apimutex.h>

void _API_Mutex_Unlock(
  API_Mutex_Control *the_mutex
)
{
   4587a:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4587e:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45880:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   45886:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  _Thread_Disable_dispatch();
    _CORE_mutex_Surrender(
   4588a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4588c:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   45890:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   45894:	4eb9 0004 5aa8 	jsr 45aa8 <_CORE_mutex_Surrender>                 	<== NOT EXECUTED
      &the_mutex->Mutex,
      the_mutex->Object.id,
      NULL
   );
  _Thread_Enable_dispatch();
   4589a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
}
   458a0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    _CORE_mutex_Surrender(
      &the_mutex->Mutex,
      the_mutex->Object.id,
      NULL
   );
  _Thread_Enable_dispatch();
   458a2:	4ef9 0004 6c4e 	jmp 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED

00045786 <_API_extensions_Add>:
 */

void _API_extensions_Add(
  API_extensions_Control *the_extension
)
{
   45786:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Chain_Append( &_API_extensions_List, &the_extension->Node );
   4578a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4578e:	4879 0005 6e4e 	pea 56e4e <_API_extensions_List>                  	<== NOT EXECUTED
   45794:	4eb9 0004 58a8 	jsr 458a8 <_Chain_Append>                         	<== NOT EXECUTED
   4579a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   4579c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4579e:	4e75           	rts

000456e0 <_API_extensions_Initialization>:
 *
 *  _API_extensions_Initialization
 */

void _API_extensions_Initialization( void )
{
   456e0:	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);
   456e4:	41f9 0005 6e4e 	lea 56e4e <_API_extensions_List>,%a0              	<== NOT EXECUTED
 _Chain_Initialize_empty( &_API_extensions_List );
}
   456ea:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   456ec:	23c8 0005 6e56 	movel %a0,56e56 <_API_extensions_List+0x8>        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   456f2:	20bc 0005 6e52 	movel #355922,%a0@                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   456f8:	42b9 0005 6e52 	clrl 56e52 <_API_extensions_List+0x4>             	<== NOT EXECUTED
   456fe:	4e75           	rts

0004572a <_API_extensions_Run_postdriver>:
 *
 *  _API_extensions_Run_postdriver
 */

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

  for ( the_node = _API_extensions_List.first ;
   45730:	2479 0005 6e4e 	moveal 56e4e <_API_extensions_List>,%a2           	<== NOT EXECUTED
   45736:	600c           	bras 45744 <_API_extensions_Run_postdriver+0x1a>  	<== NOT EXECUTED
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->postdriver_hook )
   45738:	206a 000c      	moveal %a2@(12),%a0                               	<== NOT EXECUTED
   4573c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4573e:	6702           	beqs 45742 <_API_extensions_Run_postdriver+0x18>  	<== NOT EXECUTED
      (*the_extension->postdriver_hook)();
   45740:	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 ) {
   45742:	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 ) ;
   45744:	b5fc 0005 6e52 	cmpal #355922,%a2                                 	<== NOT EXECUTED
   4574a:	66ec           	bnes 45738 <_API_extensions_Run_postdriver+0xe>   	<== NOT EXECUTED
    the_extension = (API_extensions_Control *) the_node;

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

00045754 <_API_extensions_Run_postswitch>:
 *
 *  _API_extensions_Run_postswitch
 */

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

  for ( the_node = _API_extensions_List.first ;
   4575a:	2479 0005 6e4e 	moveal 56e4e <_API_extensions_List>,%a2           	<== NOT EXECUTED
   45760:	6014           	bras 45776 <_API_extensions_Run_postswitch+0x22>  	<== NOT EXECUTED
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->postswitch_hook )
   45762:	206a 0010      	moveal %a2@(16),%a0                               	<== NOT EXECUTED
   45766:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   45768:	670a           	beqs 45774 <_API_extensions_Run_postswitch+0x20>  	<== NOT EXECUTED
      (*the_extension->postswitch_hook)( _Thread_Executing );
   4576a:	2f39 0005 6d62 	movel 56d62 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   45770:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   45772:	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 ) {
   45774:	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 ) ;
   45776:	b5fc 0005 6e52 	cmpal #355922,%a2                                 	<== NOT EXECUTED
   4577c:	66e4           	bnes 45762 <_API_extensions_Run_postswitch+0xe>   	<== NOT EXECUTED
    the_extension = (API_extensions_Control *) the_node;

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

00045700 <_API_extensions_Run_predriver>:
 *
 *  _API_extensions_Run_predriver
 */

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

  for ( the_node = _API_extensions_List.first ;
   45706:	2479 0005 6e4e 	moveal 56e4e <_API_extensions_List>,%a2           	<== NOT EXECUTED
   4570c:	600c           	bras 4571a <_API_extensions_Run_predriver+0x1a>   	<== NOT EXECUTED
        !_Chain_Is_tail( &_API_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (API_extensions_Control *) the_node;

    if ( the_extension->predriver_hook )
   4570e:	206a 0008      	moveal %a2@(8),%a0                                	<== NOT EXECUTED
   45712:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   45714:	6702           	beqs 45718 <_API_extensions_Run_predriver+0x18>   	<== NOT EXECUTED
      (*the_extension->predriver_hook)();
   45716:	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 ) {
   45718:	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 ) ;
   4571a:	b5fc 0005 6e52 	cmpal #355922,%a2                                 	<== NOT EXECUTED
   45720:	66ec           	bnes 4570e <_API_extensions_Run_predriver+0xe>    	<== NOT EXECUTED
    the_extension = (API_extensions_Control *) the_node;

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

000495b8 <_Barrier_Manager_initialization>:
 */

void _Barrier_Manager_initialization(
  uint32_t   maximum_barriers
)
{
   495b8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   495bc:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   495c0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   495c2:	4878 0060      	pea 60 <FP_REGS_SAVED+0x20>                       	<== NOT EXECUTED
   495c6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   495ca:	4878 000a      	pea a <LASTO>                                     	<== NOT EXECUTED
   495ce:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   495d2:	4879 0005 6f26 	pea 56f26 <_Barrier_Information>                  	<== NOT EXECUTED
   495d8:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   495de:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    FALSE,                         /* TRUE if this is a global object class */
    NULL                           /* Proxy extraction support callout */
#endif
  );
}
   495e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   495e6:	4e75           	rts

0004a354 <_Barrier_Translate_core_barrier_return_code>:
};

rtems_status_code _Barrier_Translate_core_barrier_return_code (
  CORE_barrier_Status  the_barrier_status
)
{
   4a354:	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];
}
   4a358:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
};

rtems_status_code _Barrier_Translate_core_barrier_return_code (
  CORE_barrier_Status  the_barrier_status
)
{
   4a35c:	41f9 0005 76e8 	lea 576e8 <_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];
}
   4a362:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4a366:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a368:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046548 <_CORE_barrier_Initialize>:

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

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

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

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

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

  _Thread_queue_Initialize(
   46558:	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;
   4655e:	2011           	movel %a1@,%d0                                    	<== NOT EXECUTED
   46560:	2169 0004 0044 	movel %a1@(4),%a0@(68)                            	<== NOT EXECUTED
  the_barrier->number_of_waiting_threads = 0;

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

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

  _Thread_queue_Initialize(
   4656c:	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;
   4656e:	42a8 0048      	clrl %a0@(72)                                     	<== NOT EXECUTED

  _Thread_queue_Initialize(
   46572:	4eb9 0004 806c 	jsr 4806c <_Thread_queue_Initialize>              	<== NOT EXECUTED
   46578:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    &the_barrier->Wait_queue,
    THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_BARRIER,
    CORE_BARRIER_TIMEOUT
  );
}
   4657e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46580:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046584 <_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
)
{
   46584:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   46588:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   4658c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  Thread_Control *the_thread;
  uint32_t        count;

  count = 0;
  while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) {
   46590:	4282           	clrl %d2                                          	<== NOT EXECUTED
   46592:	47f9 0004 7cdc 	lea 47cdc <_Thread_queue_Dequeue>,%a3             	<== NOT EXECUTED
   46598:	6002           	bras 4659c <_CORE_barrier_Release+0x18>           	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_barrier_mp_support) ( the_thread, id );
#endif
    count++;
   4659a:	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)) ) {
   4659c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4659e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   465a0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   465a2:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   465a4:	66f4           	bnes 4659a <_CORE_barrier_Release+0x16>           	<== NOT EXECUTED
#endif
    count++;
  }
  the_barrier->number_of_waiting_threads = 0;
  return count;
}
   465a6:	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;
   465a8:	42aa 0048      	clrl %a2@(72)                                     	<== NOT EXECUTED
  return count;
}
   465ac:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   465b2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465b4:	4e75           	rts                                               	<== NOT EXECUTED
	...

000465b8 <_CORE_barrier_Wait>:
  Objects_Id                           id,
  bool                                 wait,
  Watchdog_Interval                    timeout,
  CORE_barrier_API_mp_support_callout  api_barrier_mp_support
)
{
   465b8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   465bc:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   465c0:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   465c4:	282e 0014      	movel %fp@(20),%d4                                	<== NOT EXECUTED
  Thread_Control *executing;
  ISR_Level       level;

  executing = _Thread_Executing;
   465c8:	2279 0005 8e9a 	moveal 58e9a <_Thread_Executing>,%a1              	<== NOT EXECUTED
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   465ce:	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;
   465d4:	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
)
{
   465d8:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   465dc:	242e 0018      	movel %fp@(24),%d2                                	<== NOT EXECUTED
  Thread_Control *executing;
  ISR_Level       level;

  executing = _Thread_Executing;
  executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   465e0:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   465e2:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   465e4:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  the_barrier->number_of_waiting_threads++;
   465e6:	2028 0048      	movel %a0@(72),%d0                                	<== NOT EXECUTED
   465ea:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   465ec:	2140 0048      	movel %d0,%a0@(72)                                	<== NOT EXECUTED
  if ( the_barrier->number_of_waiting_threads ==
   465f0:	b0a8 0044      	cmpl %a0@(68),%d0                                 	<== NOT EXECUTED
   465f4:	6626           	bnes 4661c <_CORE_barrier_Wait+0x64>              	<== NOT EXECUTED
       the_barrier->Attributes.maximum_count) {
    if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) {
   465f6:	4aa8 0040      	tstl %a0@(64)                                     	<== NOT EXECUTED
   465fa:	6620           	bnes 4661c <_CORE_barrier_Wait+0x64>              	<== NOT EXECUTED
      executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
   465fc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   465fe:	2340 0034      	movel %d0,%a1@(52)                                	<== NOT EXECUTED
      _ISR_Enable( level );
   46602:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support );
   46604:	2d42 0010      	movel %d2,%fp@(16)                                	<== NOT EXECUTED
   46608:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4660c:	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 );
}
   46610:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   46614:	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 );
   46616:	4ef9 0004 6584 	jmp 46584 <_CORE_barrier_Release>                 	<== 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;
   4661c:	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;
   4661e:	2343 0020      	movel %d3,%a1@(32)                                	<== NOT EXECUTED
   46622:	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;
   46626:	2348 0044      	movel %a0,%a1@(68)                                	<== NOT EXECUTED
  executing->Wait.id             = id;
  _ISR_Enable( level );
   4662a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout );
   4662c:	2d44 000c      	movel %d4,%fp@(12)                                	<== NOT EXECUTED
   46630:	203c 0004 8158 	movel #295256,%d0                                 	<== NOT EXECUTED
   46636:	2d40 0010      	movel %d0,%fp@(16)                                	<== NOT EXECUTED
   4663a:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
}
   4663e:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   46642:	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 );
   46644:	4ef9 0004 7e20 	jmp 47e20 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
	...

000500b8 <_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
)
{
   500b8:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   500bc:	48d7 3c0c      	moveml %d2-%d3/%a2-%a5,%sp@                       	<== NOT EXECUTED
   500c0:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   500c4:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
   500c8:	b6ab 004c      	cmpl %a3@(76),%d3                                 	<== NOT EXECUTED
   500cc:	6304           	blss 500d2 <_CORE_message_queue_Broadcast+0x1a>   	<== NOT EXECUTED
   500ce:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   500d0:	604e           	bras 50120 <_CORE_message_queue_Broadcast+0x68>   	<== 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 ) {
   500d2:	4aab 0048      	tstl %a3@(72)                                     	<== NOT EXECUTED
   500d6:	6610           	bnes 500e8 <_CORE_message_queue_Broadcast+0x30>   	<== 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))) {
   500d8:	4282           	clrl %d2                                          	<== NOT EXECUTED
   500da:	4bf9 0005 2214 	lea 52214 <_Thread_queue_Dequeue>,%a5             	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   500e0:	49f9 0005 67b4 	lea 567b4 <memcpy>,%a4                            	<== NOT EXECUTED
   500e6:	6024           	bras 5010c <_CORE_message_queue_Broadcast+0x54>   	<== 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;
   500e8:	206e 001c      	moveal %fp@(28),%a0                               	<== NOT EXECUTED
   500ec:	4290           	clrl %a0@                                         	<== NOT EXECUTED
   500ee:	4280           	clrl %d0                                          	<== NOT EXECUTED
   500f0:	602e           	bras 50120 <_CORE_message_queue_Broadcast+0x68>   	<== NOT EXECUTED
   500f2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   */

  number_broadcasted = 0;
  while ((the_thread = _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
    waitp = &the_thread->Wait;
    number_broadcasted += 1;
   500f4:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   500f6:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   500fa:	2f2a 002c      	movel %a2@(44),%sp@-                              	<== NOT EXECUTED
   500fe:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
      buffer,
      waitp->return_argument_second.mutable_object,
      size
    );

    *(size_t *) the_thread->Wait.return_argument = size;
   50100:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
   50104:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5010a:	2083           	movel %d3,%a0@                                    	<== 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))) {
   5010c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5010e:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   50110:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   50112:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   50114:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   50116:	66da           	bnes 500f2 <_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;
   50118:	206e 001c      	moveal %fp@(28),%a0                               	<== NOT EXECUTED
   5011c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5011e:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   50120:	4cee 3c0c ffe8 	moveml %fp@(-24),%d2-%d3/%a2-%a5                  	<== NOT EXECUTED
   50126:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50128:	4e75           	rts                                               	<== NOT EXECUTED
	...

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

  _Thread_queue_Flush(
   4f41a:	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
)
{
   4f41e:	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(
   4f422:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4f426:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f428:	4eb9 0004 af30 	jsr 4af30 <_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 )
   4f42e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f434:	4aaa 0048      	tstl %a2@(72)                                     	<== NOT EXECUTED
   4f438:	670a           	beqs 4f444 <_CORE_message_queue_Close+0x30>       	<== NOT EXECUTED
    (void) _CORE_message_queue_Flush_support( the_message_queue );
   4f43a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f43c:	4eb9 0004 f458 	jsr 4f458 <_CORE_message_queue_Flush_support>     	<== NOT EXECUTED
   4f442:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

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

}
   4f44a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4f44e:	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 );
   4f450:	4ef9 0004 bad4 	jmp 4bad4 <_Workspace_Free>                       	<== NOT EXECUTED
	...

00050170 <_CORE_message_queue_Flush>:
 */

uint32_t   _CORE_message_queue_Flush(
  CORE_message_queue_Control *the_message_queue
)
{
   50170:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   50174:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  if ( the_message_queue->number_of_pending_messages != 0 )
   50178:	4aa8 0048      	tstl %a0@(72)                                     	<== NOT EXECUTED
   5017c:	6606           	bnes 50184 <_CORE_message_queue_Flush+0x14>       	<== NOT EXECUTED
    return _CORE_message_queue_Flush_support( the_message_queue );
  else
    return 0;
}
   5017e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   50180:	4280           	clrl %d0                                          	<== NOT EXECUTED
   50182:	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 );
   50184:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
  else
    return 0;
}
   50188:	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 );
   5018a:	4ef9 0005 0190 	jmp 50190 <_CORE_message_queue_Flush_support>     	<== NOT EXECUTED

0004f458 <_CORE_message_queue_Flush_support>:
 */

uint32_t   _CORE_message_queue_Flush_support(
  CORE_message_queue_Control *the_message_queue
)
{
   4f458:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4f45c:	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 );
   4f460:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

uint32_t   _CORE_message_queue_Flush_support(
  CORE_message_queue_Control *the_message_queue
)
{
   4f466:	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 );
   4f46a:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4f46c:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4f46e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    inactive_first      = the_message_queue->Inactive_messages.first;
    message_queue_first = the_message_queue->Pending_messages.first;
   4f470:	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;
   4f474:	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;
   4f478:	2268 0058      	moveal %a0@(88),%a1                               	<== NOT EXECUTED

    the_message_queue->Inactive_messages.first = message_queue_first;
   4f47c:	214a 0068      	movel %a2,%a0@(104)                               	<== NOT EXECUTED
    message_queue_last->next = inactive_first;
    inactive_first->previous = message_queue_last;
    message_queue_first->previous          =
   4f480:	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;
   4f484:	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;
   4f488:	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;
   4f48c:	228b           	movel %a3,%a1@                                    	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4f48e:	43e8 0054      	lea %a0@(84),%a1                                  	<== NOT EXECUTED
    inactive_first->previous = message_queue_last;
    message_queue_first->previous          =
   4f492:	254c 0004      	movel %a4,%a2@(4)                                 	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f496:	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);
   4f49a:	2149 0050      	movel %a1,%a0@(80)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f49e:	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;
   4f4a2:	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;
   4f4a6:	42a8 0054      	clrl %a0@(84)                                     	<== NOT EXECUTED
  _ISR_Enable( level );
   4f4aa:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  return count;
}
   4f4ac:	4cd7 1c00      	moveml %sp@,%a2-%a4                               	<== NOT EXECUTED
   4f4b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f4b2:	4e75           	rts

000501ec <_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
)
{
   501ec:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   501f0:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   501f4:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   501f8:	222e 0014      	movel %fp@(20),%d1                                	<== NOT EXECUTED
   501fc:	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)) {
   50200:	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;
   50202:	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)) {
   50206:	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;
   50208:	42aa 0048      	clrl %a2@(72)                                     	<== NOT EXECUTED
  the_message_queue->maximum_message_size       = maximum_message_size;
   5020c:	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;
   50210:	42aa 0060      	clrl %a2@(96)                                     	<== NOT EXECUTED
  the_message_queue->notify_argument = the_argument;
   50214:	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)) {
   50218:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5021a:	6604           	bnes 50220 <_CORE_message_queue_Initialize+0x34>  	<== NOT EXECUTED
   5021c:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   5021e:	600c           	bras 5022c <_CORE_message_queue_Initialize+0x40>  	<== NOT EXECUTED
      allocated_message_size += sizeof(uint32_t);
   50220:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   50222:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
      allocated_message_size &= ~(sizeof(uint32_t) - 1);
   50224:	74fc           	moveq #-4,%d2                                     	<== NOT EXECUTED
   50226:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
  }

  if (allocated_message_size < maximum_message_size)
   50228:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   5022a:	6270           	bhis 5029c <_CORE_message_queue_Initialize+0xb0>  	<== 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 *
   5022c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   5022e:	0682 0000 0014 	addil #20,%d2                                     	<== NOT EXECUTED
   50234:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   50236:	4c03 1800      	mulsl %d3,%d1                                     	<== NOT EXECUTED
       (allocated_message_size + sizeof(CORE_message_queue_Buffer_control));

  if (message_buffering_required < allocated_message_size)
   5023a:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   5023c:	625e           	bhis 5029c <_CORE_message_queue_Initialize+0xb0>  	<== NOT EXECUTED
    return false;

  /*
   *  Attempt to allocate the message memory
   */
  the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
   5023e:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   50240:	4eb9 0005 33a0 	jsr 533a0 <_Workspace_Allocate>                   	<== NOT EXECUTED
     _Workspace_Allocate( message_buffering_required );

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

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

  if (the_message_queue->message_buffers == 0)
   5024c:	674e           	beqs 5029c <_CORE_message_queue_Initialize+0xb0>  	<== NOT EXECUTED

  /*
   *  Initialize the pool of inactive messages, pending messages,
   *  and set of waiting threads.
   */
  _Chain_Initialize (
   5024e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   50250:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   50252:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   50254:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   50258:	4eb9 0005 007c 	jsr 5007c <_Chain_Initialize>                     	<== NOT EXECUTED
    allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
  );

  _Chain_Initialize_empty( &the_message_queue->Pending_messages );

  _Thread_queue_Initialize(
   5025e:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   50262:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   50266:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   50268:	b090           	cmpl %a0@,%d0                                     	<== NOT EXECUTED
   5026a:	57c0           	seq %d0                                           	<== NOT EXECUTED
   5026c:	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);
   50270:	41ea 0054      	lea %a2@(84),%a0                                  	<== NOT EXECUTED
   50274:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   50276:	2548 0050      	movel %a0,%a2@(80)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   5027a:	41ea 0050      	lea %a2@(80),%a0                                  	<== NOT EXECUTED
   5027e:	4480           	negl %d0                                          	<== NOT EXECUTED
   50280:	2548 0058      	movel %a0,%a2@(88)                                	<== NOT EXECUTED
   50284:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   50286:	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;
   50288:	42aa 0054      	clrl %a2@(84)                                     	<== NOT EXECUTED
   5028c:	4eb9 0005 25a4 	jsr 525a4 <_Thread_queue_Initialize>              	<== NOT EXECUTED
   50292:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   50298:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   5029a:	6002           	bras 5029e <_CORE_message_queue_Initialize+0xb2>  	<== NOT EXECUTED
       THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
    STATES_WAITING_FOR_MESSAGE,
    CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
  );

  return true;
   5029c:	4200           	clrb %d0                                          	<== NOT EXECUTED
}
   5029e:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   502a4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   502a6:	4e75           	rts

00051dd8 <_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
)
{
   51dd8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   51ddc:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   51de0:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   51de4:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   51de8:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  ISR_Level  level;
  bool       notify = false;

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

  switch ( submit_type ) {
   51df0:	0c80 8000 0000 	cmpil #-2147483648,%d0                            	<== NOT EXECUTED
   51df6:	673e           	beqs 51e36 <_CORE_message_queue_Insert_message+0x5e>	<== NOT EXECUTED
   51df8:	0c80 7fff ffff 	cmpil #2147483647,%d0                             	<== NOT EXECUTED
   51dfe:	666a           	bnes 51e6a <_CORE_message_queue_Insert_message+0x92>	<== NOT EXECUTED
    case CORE_MESSAGE_QUEUE_SEND_REQUEST:
      _ISR_Disable( level );
   51e00:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   51e06:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   51e08:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   51e0a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   51e0c:	41eb 0054      	lea %a3@(84),%a0                                  	<== NOT EXECUTED
   51e10:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   51e12:	206b 0058      	moveal %a3@(88),%a0                               	<== NOT EXECUTED
        if ( the_message_queue->number_of_pending_messages++ == 0 )
   51e16:	202b 0048      	movel %a3@(72),%d0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   51e1a:	274a 0058      	movel %a2,%a3@(88)                                	<== NOT EXECUTED
   51e1e:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   51e20:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
   51e22:	2749 0048      	movel %a1,%a3@(72)                                	<== NOT EXECUTED
   51e26:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   51e28:	57c0           	seq %d0                                           	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   51e2a:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   51e2e:	4480           	negl %d0                                          	<== 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;
   51e30:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
          notify = true;
        _CORE_message_queue_Append_unprotected(the_message_queue, the_message);
      _ISR_Enable( level );
   51e32:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   51e34:	607e           	bras 51eb4 <_CORE_message_queue_Insert_message+0xdc>	<== NOT EXECUTED
      break;
    case CORE_MESSAGE_QUEUE_URGENT_REQUEST:
      _ISR_Disable( level );
   51e36:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   51e3c:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   51e3e:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   51e40:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) the_chain;
   51e42:	41eb 0050      	lea %a3@(80),%a0                                  	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   51e46:	2250           	moveal %a0@,%a1                                   	<== NOT EXECUTED
        if ( the_message_queue->number_of_pending_messages++ == 0 )
   51e48:	202b 0048      	movel %a3@(72),%d0                                	<== NOT EXECUTED
  after_node->next      = the_node;
   51e4c:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
   51e4e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   51e50:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   51e52:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   51e56:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   51e58:	57c0           	seq %d0                                           	<== NOT EXECUTED
   51e5a:	2742 0048      	movel %d2,%a3@(72)                                	<== NOT EXECUTED
   51e5e:	4480           	negl %d0                                          	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
  the_node->next        = before_node;
  before_node->previous = the_node;
   51e60:	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;
   51e64:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
          notify = true;
        _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message);
      _ISR_Enable( level );
   51e66:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   51e68:	604a           	bras 51eb4 <_CORE_message_queue_Insert_message+0xdc>	<== 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;
   51e6a:	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;
   51e6e:	220b           	movel %a3,%d1                                     	<== NOT EXECUTED
   51e70:	0681 0000 0054 	addil #84,%d1                                     	<== NOT EXECUTED
   51e76:	6008           	bras 51e80 <_CORE_message_queue_Insert_message+0xa8>	<== NOT EXECUTED
        while ( !_Chain_Is_tail( the_header, the_node ) ) {

          this_message = (CORE_message_queue_Buffer_control *) the_node;

          if ( this_message->priority <= the_message->priority ) {
   51e78:	b0a8 0008      	cmpl %a0@(8),%d0                                  	<== NOT EXECUTED
   51e7c:	6d06           	blts 51e84 <_CORE_message_queue_Insert_message+0xac>	<== NOT EXECUTED
            the_node = the_node->next;
   51e7e:	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 ) ) {
   51e80:	b288           	cmpl %a0,%d1                                      	<== NOT EXECUTED
   51e82:	66f4           	bnes 51e78 <_CORE_message_queue_Insert_message+0xa0>	<== NOT EXECUTED
            continue;
          }

          break;
        }
        _ISR_Disable( level );
   51e84:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   51e8a:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   51e8c:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   51e8e:	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 );
   51e90:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

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

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

  the_node->previous    = after_node;
   51ea0:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   51ea4:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   51ea6:	4480           	negl %d0                                          	<== NOT EXECUTED
   51ea8:	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;
   51eac:	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;
   51eb0:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
            notify = true;
          _Chain_Insert_unprotected( the_node->previous, &the_message->Node );
        _ISR_Enable( level );
   51eb2:	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 )
   51eb4:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   51eb6:	6716           	beqs 51ece <_CORE_message_queue_Insert_message+0xf6>	<== NOT EXECUTED
   51eb8:	202b 0060      	movel %a3@(96),%d0                                	<== NOT EXECUTED
   51ebc:	6710           	beqs 51ece <_CORE_message_queue_Insert_message+0xf6>	<== NOT EXECUTED
    (*the_message_queue->notify_handler)( the_message_queue->notify_argument );
   51ebe:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   51ec0:	2d6b 0064 0008 	movel %a3@(100),%fp@(8)                           	<== NOT EXECUTED
}
   51ec6:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   51eca:	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 );
   51ecc:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   51ece:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   51ed2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   51ed4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004f4b4 <_CORE_message_queue_Seize>:
  void                            *buffer,
  size_t                          *size_p,
  bool                             wait,
  Watchdog_Interval                timeout
)
{
   4f4b4:	4e56 ffe0      	linkw %fp,#-32                                    	<== NOT EXECUTED
   4f4b8:	48d7 3c3c      	moveml %d2-%d5/%a2-%a5,%sp@                       	<== NOT EXECUTED
   4f4bc:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
   4f4c0:	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;
   4f4c4:	2279 0006 2a4a 	moveal 62a4a <_Thread_Executing>,%a1              	<== NOT EXECUTED
  executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
  _ISR_Disable( level );
   4f4ca:	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;
   4f4d0:	42a9 0034      	clrl %a1@(52)                                     	<== NOT EXECUTED
  void                            *buffer,
  size_t                          *size_p,
  bool                             wait,
  Watchdog_Interval                timeout
)
{
   4f4d4:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4f4d8:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   4f4dc:	286e 0014      	moveal %fp@(20),%a4                               	<== NOT EXECUTED
   4f4e0:	142e 001b      	moveb %fp@(27),%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 );
   4f4e4:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4f4e6:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4f4e8:	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));
   4f4ea:	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))
   4f4ee:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   4f4f0:	0680 0000 0054 	addil #84,%d0                                     	<== NOT EXECUTED
   4f4f6:	b08a           	cmpl %a2,%d0                                      	<== NOT EXECUTED
   4f4f8:	6700 00ac      	beqw 4f5a6 <_CORE_message_queue_Seize+0xf2>       	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   4f4fc:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   4f4fe:	2748 0050      	movel %a0,%a3@(80)                                	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   4f502:	4beb 0050      	lea %a3@(80),%a5                                  	<== NOT EXECUTED
   4f506:	214d 0004      	movel %a5,%a0@(4)                                 	<== NOT EXECUTED
  the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
  if ( the_message != NULL ) {
   4f50a:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4f50c:	6700 0098      	beqw 4f5a6 <_CORE_message_queue_Seize+0xf2>       	<== NOT EXECUTED
    the_message_queue->number_of_pending_messages -= 1;
   4f510:	53ab 0048      	subql #1,%a3@(72)                                 	<== NOT EXECUTED
    _ISR_Enable( level );
   4f514:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

    *size_p = the_message->Contents.size;
    _Thread_Executing->Wait.count = the_message->priority;
   4f516:	2079 0006 2a4a 	moveal 62a4a <_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;
   4f51c:	28aa 000c      	movel %a2@(12),%a4@                               	<== NOT EXECUTED
    _Thread_Executing->Wait.count = the_message->priority;
    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
   4f520:	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;
   4f522:	216a 0008 0024 	movel %a2@(8),%a0@(36)                            	<== NOT EXECUTED
    _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p);
   4f528:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   4f52e:	2f14           	movel %a4@,%sp@-                                  	<== NOT EXECUTED
   4f530:	4bf9 0005 39b8 	lea 539b8 <memcpy>,%a5                            	<== NOT EXECUTED
   4f536:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f538:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f53a:	4e95           	jsr %a5@                                          	<== 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 );
   4f53c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4f53e:	4eb9 0004 abcc 	jsr 4abcc <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
    if ( !the_thread ) {
   4f544:	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 );
   4f54a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
    if ( !the_thread ) {
   4f54c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f54e:	661c           	bnes 4f56c <_CORE_message_queue_Seize+0xb8>       	<== 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 );
   4f550:	d7fc 0000 0068 	addal #104,%a3                                    	<== NOT EXECUTED
   4f556:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
   4f55a:	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 );
}
   4f55e:	4cee 3c3c ffe0 	moveml %fp@(-32),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
   4f564:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f566:	4ef9 0004 9430 	jmp 49430 <_Chain_Append>                         	<== 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;
   4f56c:	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;
   4f570:	2568 0024 0008 	movel %a0@(36),%a2@(8)                            	<== NOT EXECUTED
    the_message->Contents.size = (size_t) the_thread->Wait.option;
   4f576:	2540 000c      	movel %d0,%a2@(12)                                	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   4f57a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4f57c:	2f28 002c      	movel %a0@(44),%sp@-                              	<== NOT EXECUTED
   4f580:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f582:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
      the_thread->Wait.return_argument_second.immutable_object,
      the_message->Contents.buffer,
      the_message->Contents.size
    );

    _CORE_message_queue_Insert_message(
   4f584:	2d6a 0008 0010 	movel %a2@(8),%fp@(16)                            	<== NOT EXECUTED
   4f58a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f590:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
   4f594:	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 );
}
   4f598:	4cee 3c3c ffe0 	moveml %fp@(-32),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
   4f59e:	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(
   4f5a0:	4ef9 0005 1dd8 	jmp 51dd8 <_CORE_message_queue_Insert_message>    	<== NOT EXECUTED
       the_message->priority
    );
    return;
  }

  if ( !wait ) {
   4f5a6:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4f5a8:	6612           	bnes 4f5bc <_CORE_message_queue_Seize+0x108>      	<== NOT EXECUTED
    _ISR_Enable( level );
   4f5aa:	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 );
}
   4f5ac:	4cee 3c3c ffe0 	moveml %fp@(-32),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
    return;
  }

  if ( !wait ) {
    _ISR_Enable( level );
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
   4f5b2:	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 );
}
   4f5b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    return;
  }

  if ( !wait ) {
    _ISR_Enable( level );
    executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
   4f5b6:	2340 0034      	movel %d0,%a1@(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 );
}
   4f5ba:	4e75           	rts                                               	<== NOT EXECUTED
   4f5bc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4f5be:	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;
   4f5c2:	234c 0028      	movel %a4,%a1@(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;
   4f5c6:	2345 0020      	movel %d5,%a1@(32)                                	<== NOT EXECUTED
  executing->Wait.return_argument_second.mutable_object = buffer;
   4f5ca:	2343 002c      	movel %d3,%a1@(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;
   4f5ce:	234b 0044      	movel %a3,%a1@(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 );
   4f5d2:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
   4f5d4:	4bf9 0004 b048 	lea 4b048 <_Thread_queue_Timeout>,%a5             	<== NOT EXECUTED
   4f5da:	2d44 000c      	movel %d4,%fp@(12)                                	<== NOT EXECUTED
   4f5de:	2d4d 0010      	movel %a5,%fp@(16)                                	<== NOT EXECUTED
   4f5e2:	2d4b 0008      	movel %a3,%fp@(8)                                 	<== NOT EXECUTED
}
   4f5e6:	4cee 3c3c ffe0 	moveml %fp@(-32),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
   4f5ec:	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 );
   4f5ee:	4ef9 0004 ad10 	jmp 4ad10 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED

0004f5f4 <_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
)
{
   4f5f4:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4f5f8:	48d7 0c3c      	moveml %d2-%d5/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4f5fc:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4f600:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   4f604:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
   4f608:	282e 001c      	movel %fp@(28),%d4                                	<== NOT EXECUTED
   4f60c:	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 ) {
   4f610:	b6ab 004c      	cmpl %a3@(76),%d3                                 	<== NOT EXECUTED
   4f614:	6306           	blss 4f61c <_CORE_message_queue_Submit+0x28>      	<== NOT EXECUTED
   4f616:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4f618:	6000 00e4      	braw 4f6fe <_CORE_message_queue_Submit+0x10a>     	<== NOT EXECUTED

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

  if ( the_message_queue->number_of_pending_messages == 0 ) {
   4f61c:	4aab 0048      	tstl %a3@(72)                                     	<== NOT EXECUTED
   4f620:	6634           	bnes 4f656 <_CORE_message_queue_Submit+0x62>      	<== NOT EXECUTED
    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
   4f622:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4f624:	4eb9 0004 abcc 	jsr 4abcc <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
    if ( the_thread ) {
   4f62a:	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 );
   4f62c:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
    if ( the_thread ) {
   4f62e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f630:	6724           	beqs 4f656 <_CORE_message_queue_Submit+0x62>      	<== NOT EXECUTED
   4f632:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f634:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4f636:	2f2a 002c      	movel %a2@(44),%sp@-                              	<== NOT EXECUTED
   4f63a:	4eb9 0005 39b8 	jsr 539b8 <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;
   4f640:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
   4f644:	2083           	movel %d3,%a0@                                    	<== NOT EXECUTED
      the_thread->Wait.count = submit_type;
   4f646:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f64c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4f64e:	2544 0024      	movel %d4,%a2@(36)                                	<== NOT EXECUTED
   4f652:	6000 00aa      	braw 4f6fe <_CORE_message_queue_Submit+0x10a>     	<== 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 <
   4f656:	202b 0044      	movel %a3@(68),%d0                                	<== NOT EXECUTED
   4f65a:	b0ab 0048      	cmpl %a3@(72),%d0                                 	<== NOT EXECUTED
   4f65e:	6340           	blss 4f6a0 <_CORE_message_queue_Submit+0xac>      	<== 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 *)
   4f660:	486b 0068      	pea %a3@(104)                                     	<== NOT EXECUTED
   4f664:	4eb9 0004 9468 	jsr 49468 <_Chain_Get>                            	<== NOT EXECUTED

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

    if ( !the_message ) {
   4f66a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4f66c:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f66e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f670:	6700 008a      	beqw 4f6fc <_CORE_message_queue_Submit+0x108>     	<== NOT EXECUTED
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   4f674:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f676:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4f678:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4f67c:	4eb9 0005 39b8 	jsr 539b8 <memcpy>                                	<== NOT EXECUTED
    _CORE_message_queue_Copy_buffer(
      buffer,
      the_message->Contents.buffer,
      size
    );
    the_message->Contents.size = size;
   4f682:	2543 000c      	movel %d3,%a2@(12)                                	<== NOT EXECUTED
    the_message->priority  = submit_type;
   4f686:	2544 0008      	movel %d4,%a2@(8)                                 	<== NOT EXECUTED

    _CORE_message_queue_Insert_message(
   4f68a:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4f68c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f68e:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4f690:	4eb9 0005 1dd8 	jsr 51dd8 <_CORE_message_queue_Insert_message>    	<== NOT EXECUTED
   4f696:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   4f69c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4f69e:	605e           	bras 4f6fe <_CORE_message_queue_Submit+0x10a>     	<== 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 ) {
   4f6a0:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4f6a2:	6604           	bnes 4f6a8 <_CORE_message_queue_Submit+0xb4>      	<== NOT EXECUTED
   4f6a4:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4f6a6:	6056           	bras 4f6fe <_CORE_message_queue_Submit+0x10a>     	<== 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() ) {
   4f6a8:	2039 0006 2a2a 	movel 62a2a <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
   4f6ae:	664c           	bnes 4f6fc <_CORE_message_queue_Submit+0x108>     	<== NOT EXECUTED
   */

  {
    Thread_Control  *executing = _Thread_Executing;

    _ISR_Disable( level );
   4f6b0:	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;
   4f6b6:	2079 0006 2a4a 	moveal 62a4a <_Thread_Executing>,%a0              	<== NOT EXECUTED

    _ISR_Disable( level );
   4f6bc:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4f6be:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4f6c0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4f6c2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
    _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue );
    executing->Wait.queue = &the_message_queue->Wait_queue;
    executing->Wait.id = id;
   4f6c4:	216e 0014 0020 	movel %fp@(20),%a0@(32)                           	<== NOT EXECUTED
   4f6ca:	2741 0030      	movel %d1,%a3@(48)                                	<== NOT EXECUTED
    executing->Wait.return_argument_second.immutable_object = buffer;
    executing->Wait.option = (uint32_t) size;
    executing->Wait.count = submit_type;
   4f6ce:	2144 0024      	movel %d4,%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;
   4f6d2:	2145 002c      	movel %d5,%a0@(44)                                	<== NOT EXECUTED
    executing->Wait.option = (uint32_t) size;
   4f6d6:	2143 0030      	movel %d3,%a0@(48)                                	<== 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;
   4f6da:	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 );
   4f6de:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout );
   4f6e0:	4879 0004 b048 	pea 4b048 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
   4f6e6:	2f2e 0024      	movel %fp@(36),%sp@-                              	<== NOT EXECUTED
   4f6ea:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4f6ec:	4eb9 0004 ad10 	jsr 4ad10 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
   4f6f2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f6f8:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
   4f6fa:	6002           	bras 4f6fe <_CORE_message_queue_Submit+0x10a>     	<== NOT EXECUTED
  }

  return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
   4f6fc:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
}
   4f6fe:	4cee 0c3c ffe8 	moveml %fp@(-24),%d2-%d5/%a2-%a3                  	<== NOT EXECUTED
   4f704:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f706:	4e75           	rts

000458e0 <_CORE_mutex_Flush>:
void _CORE_mutex_Flush(
  CORE_mutex_Control         *the_mutex,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
   458e0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Thread_queue_Flush(
    &the_mutex->Wait_queue,
    remote_extract_callout,
    status
  );
}
   458e4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  CORE_mutex_Control         *the_mutex,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
  _Thread_queue_Flush(
   458e6:	4ef9 0004 72d4 	jmp 472d4 <_Thread_queue_Flush>                   	<== NOT EXECUTED

000458ec <_CORE_mutex_Initialize>:
CORE_mutex_Status _CORE_mutex_Initialize(
  CORE_mutex_Control           *the_mutex,
  CORE_mutex_Attributes        *the_mutex_attributes,
  uint32_t                      initial_lock
)
{
   458ec:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   458f0:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== 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;
   458f4:	4878 000e      	pea e <OPER1+0x2>                                 	<== NOT EXECUTED
CORE_mutex_Status _CORE_mutex_Initialize(
  CORE_mutex_Control           *the_mutex,
  CORE_mutex_Attributes        *the_mutex_attributes,
  uint32_t                      initial_lock
)
{
   458f8:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
   458fc:	246e 0008      	moveal %fp@(8),%a2                                	<== 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;
   45900:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
CORE_mutex_Status _CORE_mutex_Initialize(
  CORE_mutex_Control           *the_mutex,
  CORE_mutex_Attributes        *the_mutex_attributes,
  uint32_t                      initial_lock
)
{
   45902:	242e 0010      	movel %fp@(16),%d2                                	<== 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;
   45906:	486a 0040      	pea %a2@(64)                                      	<== NOT EXECUTED
   4590a:	4eb9 0004 b3f4 	jsr 4b3f4 <memcpy>                                	<== NOT EXECUTED
  the_mutex->lock          = initial_lock;
   45910:	2542 004e      	movel %d2,%a2@(78)                                	<== NOT EXECUTED
  the_mutex->blocked_count = 0;

  if ( initial_lock == CORE_MUTEX_LOCKED ) {
   45914:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
                initial_lock == CORE_MUTEX_UNLOCKED );
 */

  the_mutex->Attributes    = *the_mutex_attributes;
  the_mutex->lock          = initial_lock;
  the_mutex->blocked_count = 0;
   4591a:	42aa 0056      	clrl %a2@(86)                                     	<== NOT EXECUTED

  if ( initial_lock == CORE_MUTEX_LOCKED ) {
   4591e:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   45920:	663c           	bnes 4595e <_CORE_mutex_Initialize+0x72>          	<== NOT EXECUTED
    the_mutex->nest_count = 1;
    the_mutex->holder     = _Thread_Executing;
   45922:	2079 0005 6d62 	moveal 56d62 <_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;
   45928:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4592a:	2540 0052      	movel %d0,%a2@(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;
   4592e:	202a 0046      	movel %a2@(70),%d0                                	<== NOT EXECUTED
    the_mutex->holder     = _Thread_Executing;
    the_mutex->holder_id  = _Thread_Executing->Object.id;
   45932:	2568 0008 005e 	movel %a0@(8),%a2@(94)                            	<== NOT EXECUTED
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   45938:	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;
   4593a:	2548 005a      	movel %a0,%a2@(90)                                	<== NOT EXECUTED
    the_mutex->holder_id  = _Thread_Executing->Object.id;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   4593e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45940:	6708           	beqs 4594a <_CORE_mutex_Initialize+0x5e>          	<== NOT EXECUTED
   45942:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   45946:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45948:	6620           	bnes 4596a <_CORE_mutex_Initialize+0x7e>          	<== NOT EXECUTED
         _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {

      if ( _Thread_Executing->current_priority <
   4594a:	202a 004a      	movel %a2@(74),%d0                                	<== NOT EXECUTED
   4594e:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   45952:	6304           	blss 45958 <_CORE_mutex_Initialize+0x6c>          	<== NOT EXECUTED
   45954:	7006           	moveq #6,%d0                                      	<== NOT EXECUTED
   45956:	6036           	bras 4598e <_CORE_mutex_Initialize+0xa2>          	<== 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++;
   45958:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
   4595c:	600c           	bras 4596a <_CORE_mutex_Initialize+0x7e>          	<== NOT EXECUTED
    }
  } else {
    the_mutex->nest_count = 0;
   4595e:	42aa 0052      	clrl %a2@(82)                                     	<== NOT EXECUTED
    the_mutex->holder     = NULL;
   45962:	42aa 005a      	clrl %a2@(90)                                     	<== NOT EXECUTED
    the_mutex->holder_id  = 0;
   45966:	42aa 005e      	clrl %a2@(94)                                     	<== NOT EXECUTED
  }

  _Thread_queue_Initialize(
   4596a:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   4596e:	4aab 0006      	tstl %a3@(6)                                      	<== NOT EXECUTED
   45972:	56c0           	sne %d0                                           	<== NOT EXECUTED
   45974:	4878 0400      	pea 400 <D_BIAS+0x2>                              	<== NOT EXECUTED
   45978:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4597a:	4480           	negl %d0                                          	<== NOT EXECUTED
   4597c:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4597e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45980:	4eb9 0004 7300 	jsr 47300 <_Thread_queue_Initialize>              	<== NOT EXECUTED
   45986:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4598c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    STATES_WAITING_FOR_MUTEX,
    CORE_MUTEX_TIMEOUT
  );

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   4598e:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   45994:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45996:	4e75           	rts

00045a00 <_CORE_mutex_Seize>:
  Objects_Id           _id,
  bool                 _wait,
  Watchdog_Interval    _timeout,
  ISR_Level            _level
)
{
   45a00:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45a04:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45a06:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   45a0a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
   45a0e:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
  Objects_Id           _id,
  bool                 _wait,
  Watchdog_Interval    _timeout,
  ISR_Level            _level
)
{
   45a14:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45a16:	1401           	moveb %d1,%d2                                     	<== NOT EXECUTED
  _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level );
   45a18:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45a1a:	671c           	beqs 45a38 <_CORE_mutex_Seize+0x38>               	<== NOT EXECUTED
   45a1c:	4a01           	tstb %d1                                          	<== NOT EXECUTED
   45a1e:	6718           	beqs 45a38 <_CORE_mutex_Seize+0x38>               	<== NOT EXECUTED
   45a20:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45a22:	b0b9 0005 6e36 	cmpl 56e36 <_System_state_Current>,%d0            	<== NOT EXECUTED
   45a28:	640e           	bccs 45a38 <_CORE_mutex_Seize+0x38>               	<== NOT EXECUTED
   45a2a:	4878 0013      	pea 13 <FP_STATE_SAVED+0x3>                       	<== NOT EXECUTED
   45a2e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45a30:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45a32:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
   45a38:	486e 0018      	pea %fp@(24)                                      	<== NOT EXECUTED
   45a3c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45a3e:	4eb9 0004 9acc 	jsr 49acc <_CORE_mutex_Seize_interrupt_trylock>   	<== NOT EXECUTED
   45a44:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45a46:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45a48:	6750           	beqs 45a9a <_CORE_mutex_Seize+0x9a>               	<== NOT EXECUTED
   45a4a:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   45a4c:	6614           	bnes 45a62 <_CORE_mutex_Seize+0x62>               	<== NOT EXECUTED
   45a4e:	202e 0018      	movel %fp@(24),%d0                                	<== NOT EXECUTED
   45a52:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   45a54:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45a5a:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45a5c:	2141 0034      	movel %d1,%a0@(52)                                	<== NOT EXECUTED
   45a60:	6038           	bras 45a9a <_CORE_mutex_Seize+0x9a>               	<== NOT EXECUTED
   45a62:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   45a68:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45a6e:	216e 000c 0020 	movel %fp@(12),%a0@(32)                           	<== NOT EXECUTED
   45a74:	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;
   45a76:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45a78:	2541 0030      	movel %d1,%a2@(48)                                	<== NOT EXECUTED
   45a7c:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   45a82:	214a 0044      	movel %a2,%a0@(68)                                	<== NOT EXECUTED
   45a86:	202e 0018      	movel %fp@(24),%d0                                	<== NOT EXECUTED
   45a8a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   45a8c:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   45a90:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45a92:	4eb9 0004 5998 	jsr 45998 <_CORE_mutex_Seize_interrupt_blocking>  	<== NOT EXECUTED
   45a98:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   45a9a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   45a9e:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   45aa2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45aa4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045998 <_CORE_mutex_Seize_interrupt_blocking>:

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

  executing = _Thread_Executing;
   459a8:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
  if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) {
   459ae:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   459b0:	b0aa 0046      	cmpl %a2@(70),%d0                                 	<== NOT EXECUTED
   459b4:	6620           	bnes 459d6 <_CORE_mutex_Seize_interrupt_blocking+0x3e>	<== NOT EXECUTED
    if ( the_mutex->holder->current_priority > executing->current_priority ) {
   459b6:	2028 0014      	movel %a0@(20),%d0                                	<== NOT EXECUTED
   459ba:	206a 005a      	moveal %a2@(90),%a0                               	<== NOT EXECUTED
   459be:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   459c2:	6412           	bccs 459d6 <_CORE_mutex_Seize_interrupt_blocking+0x3e>	<== NOT EXECUTED
      _Thread_Change_priority(
   459c4:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   459c6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   459c8:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   459ca:	4eb9 0004 6748 	jsr 46748 <_Thread_Change_priority>               	<== NOT EXECUTED
   459d0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
      );
    }
  }

  the_mutex->blocked_count++;
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
   459d6:	4879 0004 73ec 	pea 473ec <_Thread_queue_Timeout>                 	<== NOT EXECUTED
        FALSE
      );
    }
  }

  the_mutex->blocked_count++;
   459dc:	52aa 0056      	addql #1,%a2@(86)                                 	<== NOT EXECUTED
  _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout );
   459e0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   459e2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   459e4:	4eb9 0004 70b4 	jsr 470b4 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED

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

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

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

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

  _Thread_Enable_dispatch();
   459fa:	4ef9 0004 6c4e 	jmp 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED

00049acc <_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
)
{
   49acc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49ad0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49ad2:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   49ad6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  CORE_mutex_Control  *the_mutex,
  ISR_Level           *level_p
)
{
  Thread_Control   *executing;
  ISR_Level         level = *level_p;
   49ad8:	2410           	movel %a0@,%d2                                    	<== NOT EXECUTED

  /* disabled when you get here */

  executing = _Thread_Executing;
   49ada:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   49ae0:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
   49ae4:	42a8 0034      	clrl %a0@(52)                                     	<== NOT EXECUTED
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
   49ae8:	4aa9 004e      	tstl %a1@(78)                                     	<== NOT EXECUTED
   49aec:	6700 0096      	beqw 49b84 <_CORE_mutex_Seize_interrupt_trylock+0xb8>	<== NOT EXECUTED
    the_mutex->lock       = CORE_MUTEX_LOCKED;
   49af0:	42a9 004e      	clrl %a1@(78)                                     	<== NOT EXECUTED
    the_mutex->holder     = executing;
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
   49af4:	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;
   49af6:	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;
   49afc:	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;
   49b00:	2341 0052      	movel %d1,%a1@(82)                                	<== NOT EXECUTED
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   49b04:	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;
   49b08:	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 ) ||
   49b0c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49b0e:	6708           	beqs 49b18 <_CORE_mutex_Seize_interrupt_trylock+0x4c>	<== NOT EXECUTED
   49b10:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   49b14:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49b16:	6604           	bnes 49b1c <_CORE_mutex_Seize_interrupt_trylock+0x50>	<== 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++;
   49b18:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
   49b1c:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   49b1e:	b0a9 0046      	cmpl %a1@(70),%d0                                 	<== NOT EXECUTED
   49b22:	6706           	beqs 49b2a <_CORE_mutex_Seize_interrupt_trylock+0x5e>	<== NOT EXECUTED
        _ISR_Enable( level );
   49b24:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   49b26:	6000 0084      	braw 49bac <_CORE_mutex_Seize_interrupt_trylock+0xe0>	<== NOT EXECUTED
       */
    {
      Priority_Control  ceiling;
      Priority_Control  current;

      ceiling = the_mutex->Attributes.priority_ceiling;
   49b2a:	2229 004a      	movel %a1@(74),%d1                                	<== NOT EXECUTED
      current = executing->current_priority;
   49b2e:	2028 0014      	movel %a0@(20),%d0                                	<== NOT EXECUTED
      if ( current == ceiling ) {
   49b32:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49b34:	6604           	bnes 49b3a <_CORE_mutex_Seize_interrupt_trylock+0x6e>	<== NOT EXECUTED
        _ISR_Enable( level );
   49b36:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   49b38:	6066           	bras 49ba0 <_CORE_mutex_Seize_interrupt_trylock+0xd4>	<== NOT EXECUTED
        return 0;
      }

      if ( current > ceiling ) {
   49b3a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49b3c:	642e           	bccs 49b6c <_CORE_mutex_Seize_interrupt_trylock+0xa0>	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   49b3e:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   49b44:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   49b46:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
        _Thread_Disable_dispatch();
        _ISR_Enable( level );
   49b4c:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
        _Thread_Change_priority(
   49b4e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   49b50:	2f29 004a      	movel %a1@(74),%sp@-                              	<== NOT EXECUTED
   49b54:	2f29 005a      	movel %a1@(90),%sp@-                              	<== NOT EXECUTED
   49b58:	4eb9 0004 6748 	jsr 46748 <_Thread_Change_priority>               	<== NOT EXECUTED
          the_mutex->holder,
          the_mutex->Attributes.priority_ceiling,
         FALSE
        );
        _Thread_Enable_dispatch();
   49b5e:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   49b64:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   49b6a:	6034           	bras 49ba0 <_CORE_mutex_Seize_interrupt_trylock+0xd4>	<== NOT EXECUTED
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
   49b6c:	7206           	moveq #6,%d1                                      	<== NOT EXECUTED
   49b6e:	2141 0034      	movel %d1,%a0@(52)                                	<== NOT EXECUTED
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
   49b72:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        the_mutex->nest_count = 0;     /* undo locking above */
   49b74:	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;
   49b78:	2340 004e      	movel %d0,%a1@(78)                                	<== NOT EXECUTED
        the_mutex->nest_count = 0;     /* undo locking above */
        executing->resource_count--;   /* undo locking above */
   49b7c:	53a8 001c      	subql #1,%a0@(28)                                 	<== NOT EXECUTED
        _ISR_Enable( level );
   49b80:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   49b82:	6028           	bras 49bac <_CORE_mutex_Seize_interrupt_trylock+0xe0>	<== 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 ) ) {
   49b84:	2469 005a      	moveal %a1@(90),%a2                               	<== NOT EXECUTED
   49b88:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   49b8a:	6624           	bnes 49bb0 <_CORE_mutex_Seize_interrupt_trylock+0xe4>	<== NOT EXECUTED
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
   49b8c:	2029 0040      	movel %a1@(64),%d0                                	<== NOT EXECUTED
   49b90:	6708           	beqs 49b9a <_CORE_mutex_Seize_interrupt_trylock+0xce>	<== NOT EXECUTED
   49b92:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49b94:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49b96:	6618           	bnes 49bb0 <_CORE_mutex_Seize_interrupt_trylock+0xe4>	<== NOT EXECUTED
   49b98:	600a           	bras 49ba4 <_CORE_mutex_Seize_interrupt_trylock+0xd8>	<== NOT EXECUTED
      case CORE_MUTEX_NESTING_ACQUIRES:
        the_mutex->nest_count++;
   49b9a:	52a9 0052      	addql #1,%a1@(82)                                 	<== NOT EXECUTED
        _ISR_Enable( level );
   49b9e:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   49ba0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   49ba2:	600e           	bras 49bb2 <_CORE_mutex_Seize_interrupt_trylock+0xe6>	<== NOT EXECUTED
        return 0;
      case CORE_MUTEX_NESTING_IS_ERROR:
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
   49ba4:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   49ba6:	2540 0034      	movel %d0,%a2@(52)                                	<== NOT EXECUTED
        _ISR_Enable( level );
   49baa:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   49bac:	4200           	clrb %d0                                          	<== NOT EXECUTED
   49bae:	6002           	bras 49bb2 <_CORE_mutex_Seize_interrupt_trylock+0xe6>	<== NOT EXECUTED
   49bb0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
   49bb2:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   49bb6:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   49bba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49bbc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045aa8 <_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
)
{
   45aa8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45aac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45aae:	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;
   45ab2:	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 ) {
   45ab6:	4a2a 0044      	tstb %a2@(68)                                     	<== NOT EXECUTED
   45aba:	670e           	beqs 45aca <_CORE_mutex_Surrender+0x22>           	<== NOT EXECUTED
    if ( !_Thread_Is_executing( holder ) )
   45abc:	b1f9 0005 6d62 	cmpal 56d62 <_Thread_Executing>,%a0               	<== NOT EXECUTED
   45ac2:	6706           	beqs 45aca <_CORE_mutex_Surrender+0x22>           	<== NOT EXECUTED
   45ac4:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45ac6:	6000 00e4      	braw 45bac <_CORE_mutex_Surrender+0x104>          	<== NOT EXECUTED
      return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
  }

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

  if ( !the_mutex->nest_count )
   45aca:	202a 0052      	movel %a2@(82),%d0                                	<== NOT EXECUTED
   45ace:	6700 00da      	beqw 45baa <_CORE_mutex_Surrender+0x102>          	<== NOT EXECUTED
    return CORE_MUTEX_STATUS_SUCCESSFUL;

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

  if ( the_mutex->nest_count != 0 ) {
   45ad8:	6714           	beqs 45aee <_CORE_mutex_Surrender+0x46>           	<== NOT EXECUTED
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
   45ada:	202a 0040      	movel %a2@(64),%d0                                	<== NOT EXECUTED
   45ade:	6700 00ca      	beqw 45baa <_CORE_mutex_Surrender+0x102>          	<== NOT EXECUTED
   45ae2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45ae4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45ae6:	6606           	bnes 45aee <_CORE_mutex_Surrender+0x46>           	<== NOT EXECUTED
   45ae8:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   45aea:	6000 00c0      	braw 45bac <_CORE_mutex_Surrender+0x104>          	<== NOT EXECUTED
   45aee:	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 ) ||
   45af2:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   45af4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45af6:	6708           	beqs 45b00 <_CORE_mutex_Surrender+0x58>           	<== NOT EXECUTED
   45af8:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   45afc:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45afe:	6604           	bnes 45b04 <_CORE_mutex_Surrender+0x5c>           	<== 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--;
   45b00:	53a8 001c      	subql #1,%a0@(28)                                 	<== NOT EXECUTED
   45b04:	202a 0046      	movel %a2@(70),%d0                                	<== NOT EXECUTED
  }
  the_mutex->holder    = NULL;
   45b08:	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 ) ||
   45b0c:	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;
   45b0e:	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 ) ||
   45b12:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45b14:	6708           	beqs 45b1e <_CORE_mutex_Surrender+0x76>           	<== NOT EXECUTED
   45b16:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   45b1a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45b1c:	6624           	bnes 45b42 <_CORE_mutex_Surrender+0x9a>           	<== 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 &&
   45b1e:	4aa8 001c      	tstl %a0@(28)                                     	<== NOT EXECUTED
   45b22:	661e           	bnes 45b42 <_CORE_mutex_Surrender+0x9a>           	<== NOT EXECUTED
   45b24:	2028 0018      	movel %a0@(24),%d0                                	<== NOT EXECUTED
   45b28:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   45b2c:	6714           	beqs 45b42 <_CORE_mutex_Surrender+0x9a>           	<== NOT EXECUTED
         holder->real_priority != holder->current_priority ) {
      _Thread_Change_priority( holder, holder->real_priority, TRUE );
   45b2e:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   45b32:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45b34:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   45b36:	4eb9 0004 6748 	jsr 46748 <_Thread_Change_priority>               	<== NOT EXECUTED
   45b3c:	dffc 0000 000c 	addal #12,%sp                                     	<== 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 ) ) ) {
   45b42:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45b44:	4eb9 0004 6f70 	jsr 46f70 <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
   45b4a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45b4c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   45b4e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45b50:	674e           	beqs 45ba0 <_CORE_mutex_Surrender+0xf8>           	<== NOT EXECUTED
#endif
    {

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

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

      switch ( the_mutex->Attributes.discipline ) {
   45b5a:	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;
   45b5e:	2541 0052      	movel %d1,%a2@(82)                                	<== NOT EXECUTED

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

    } else
#endif
    {

      the_mutex->holder     = the_thread;
   45b66:	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 ) {
   45b6a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45b6c:	670a           	beqs 45b78 <_CORE_mutex_Surrender+0xd0>           	<== NOT EXECUTED
   45b6e:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   45b72:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45b74:	6634           	bnes 45baa <_CORE_mutex_Surrender+0x102>          	<== NOT EXECUTED
   45b76:	6006           	bras 45b7e <_CORE_mutex_Surrender+0xd6>           	<== 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++;
   45b78:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
   45b7c:	602c           	bras 45baa <_CORE_mutex_Surrender+0x102>          	<== 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++;
   45b7e:	52a8 001c      	addql #1,%a0@(28)                                 	<== NOT EXECUTED
          if (the_mutex->Attributes.priority_ceiling <
   45b82:	202a 004a      	movel %a2@(74),%d0                                	<== NOT EXECUTED
   45b86:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   45b8a:	641e           	bccs 45baa <_CORE_mutex_Surrender+0x102>          	<== NOT EXECUTED
              the_thread->current_priority){
              _Thread_Change_priority(
   45b8c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45b8e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45b90:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   45b92:	4eb9 0004 6748 	jsr 46748 <_Thread_Change_priority>               	<== NOT EXECUTED
   45b98:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45b9e:	600a           	bras 45baa <_CORE_mutex_Surrender+0x102>          	<== NOT EXECUTED
          }
          break;
      }
    }
  } else
    the_mutex->lock = CORE_MUTEX_UNLOCKED;
   45ba0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45ba2:	2540 004e      	movel %d0,%a2@(78)                                	<== NOT EXECUTED
   45ba6:	4200           	clrb %d0                                          	<== NOT EXECUTED
   45ba8:	6002           	bras 45bac <_CORE_mutex_Surrender+0x104>          	<== NOT EXECUTED
   45baa:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return CORE_MUTEX_STATUS_SUCCESSFUL;
}
   45bac:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   45bb0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45bb2:	4e75           	rts

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

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

  _Thread_queue_Flush(
   45bba:	4ef9 0004 72d4 	jmp 472d4 <_Thread_queue_Flush>                   	<== NOT EXECUTED

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

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

  _Thread_queue_Initialize(
   45bc4:	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
)
{
   45bc8:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   45bcc:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED

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

  _Thread_queue_Initialize(
   45bd6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45bd8:	b0a8 0004      	cmpl %a0@(4),%d0                                  	<== NOT EXECUTED
   45bdc:	57c0           	seq %d0                                           	<== NOT EXECUTED
  CORE_semaphore_Attributes    *the_semaphore_attributes,
  uint32_t                      initial_value
)
{

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

  _Thread_queue_Initialize(
   45be0:	4878 0200      	pea 200 <FP_REGS_SAVED+0x1c0>                     	<== NOT EXECUTED
   45be4:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   45be6:	4480           	negl %d0                                          	<== NOT EXECUTED
   45be8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
  uint32_t                      initial_value
)
{

  the_semaphore->Attributes = *the_semaphore_attributes;
  the_semaphore->count      = initial_value;
   45bea:	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;
   45bf0:	2341 0040      	movel %d1,%a1@(64)                                	<== NOT EXECUTED
  the_semaphore->count      = initial_value;

  _Thread_queue_Initialize(
   45bf4:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   45bf6:	4eb9 0004 7300 	jsr 47300 <_Thread_queue_Initialize>              	<== NOT EXECUTED
   45bfc:	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
  );
}
   45c02:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45c04:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045c08 <_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
)
{
   45c08:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45c0c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45c0e:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   45c12:	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)) ) {
   45c14:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45c16:	4eb9 0004 6f70 	jsr 46f70 <_Thread_queue_Dequeue>                 	<== NOT EXECUTED
   45c1c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45c1e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45c20:	6704           	beqs 45c26 <_CORE_semaphore_Surrender+0x1e>       	<== NOT EXECUTED
   45c22:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45c24:	6024           	bras 45c4a <_CORE_semaphore_Surrender+0x42>       	<== NOT EXECUTED
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_semaphore_mp_support) ( the_thread, id );
#endif

  } else {
    _ISR_Disable( level );
   45c26:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   45c2c:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   45c2e:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   45c30:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
   45c32:	222a 0048      	movel %a2@(72),%d1                                	<== NOT EXECUTED
   45c36:	b2aa 0040      	cmpl %a2@(64),%d1                                 	<== NOT EXECUTED
   45c3a:	6504           	bcss 45c40 <_CORE_semaphore_Surrender+0x38>       	<== NOT EXECUTED
   45c3c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   45c3e:	6008           	bras 45c48 <_CORE_semaphore_Surrender+0x40>       	<== NOT EXECUTED
        the_semaphore->count += 1;
   45c40:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   45c42:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45c44:	2541 0048      	movel %d1,%a2@(72)                                	<== NOT EXECUTED
      else
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
    _ISR_Enable( level );
   45c48:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  }

  return status;
}
   45c4a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   45c4e:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   45c52:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45c54:	4e75           	rts                                               	<== NOT EXECUTED
	...

000458a8 <_Chain_Append>:

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

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

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

  _ISR_Disable( level );
   458bc:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   458be:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   458c0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   458c2:	2209           	movel %a1,%d1                                     	<== NOT EXECUTED
   458c4:	5881           	addql #4,%d1                                      	<== NOT EXECUTED
   458c6:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   458c8:	2469 0008      	moveal %a1@(8),%a2                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   458cc:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   458d0:	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;
   458d4:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
    _Chain_Append_unprotected( the_chain, node );
  _ISR_Enable( level );
   458d6:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   458d8:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   458da:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   458dc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049a34 <_Chain_Extract>:
 */

void _Chain_Extract(
  Chain_Node *node
)
{
   49a34:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  ISR_Level level;

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

void _Chain_Extract(
  Chain_Node *node
)
{
   49a3e:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   49a42:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   49a44:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   49a46:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
   49a48:	2268 0004      	moveal %a0@(4),%a1                                	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   49a4c:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
  next->previous = previous;
  previous->next = next;
   49a4e:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   49a50:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
    _Chain_Extract_unprotected( node );
  _ISR_Enable( level );
   49a54:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   49a56:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49a58:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049a5c <_Chain_Get>:
 */

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

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

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

  return_node = NULL;
  _ISR_Disable( level );
   49a6c:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   49a6e:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49a70:	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));
   49a72:	204a           	moveal %a2,%a0                                    	<== NOT EXECUTED
   49a74:	2258           	moveal %a0@+,%a1                                  	<== NOT EXECUTED
    if ( !_Chain_Is_empty( the_chain ) )
   49a76:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   49a78:	6604           	bnes 49a7e <_Chain_Get+0x22>                      	<== NOT EXECUTED
   49a7a:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   49a7c:	6008           	bras 49a86 <_Chain_Get+0x2a>                      	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   49a7e:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   49a80:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   49a82:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
      return_node = _Chain_Get_first_unprotected( the_chain );
  _ISR_Enable( level );
   49a86:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  return return_node;
}
   49a88:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   49a8a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49a8c:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   49a8e:	4e75           	rts

00049a90 <_Chain_Initialize>:
  Chain_Control *the_chain,
  void           *starting_address,
  size_t         number_nodes,
  size_t         node_size
)
{
   49a90:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49a94:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49a96:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   49a9a:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
  Chain_Node *current;
  Chain_Node *next;

  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
   49a9e:	42aa 0004      	clrl %a2@(4)                                      	<== NOT EXECUTED
  next                      = starting_address;
   49aa2:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) the_chain;
   49aa6:	224a           	moveal %a2,%a1                                    	<== NOT EXECUTED
   49aa8:	600e           	bras 49ab8 <_Chain_Initialize+0x28>               	<== NOT EXECUTED
  while ( count-- ) {
    current->next  = next;
    next->previous = current;
   49aaa:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
  Chain_Control *the_chain,
  void           *starting_address,
  size_t         number_nodes,
  size_t         node_size
)
{
   49aae:	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;
   49ab0:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Control *the_chain,
  void           *starting_address,
  size_t         number_nodes,
  size_t         node_size
)
{
   49ab2:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   49ab4:	d1ee 0014      	addal %fp@(20),%a0                                	<== NOT EXECUTED

  count                     = number_nodes;
  current                   = _Chain_Head( the_chain );
  the_chain->permanent_null = NULL;
  next                      = starting_address;
  while ( count-- ) {
   49ab8:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49aba:	66ee           	bnes 49aaa <_Chain_Initialize+0x1a>               	<== NOT EXECUTED
    next->previous = current;
    current        = next;
    next           = (Chain_Node *)
                        _Addresses_Add_offset( (void *) next, node_size );
  }
  current->next    = _Chain_Tail( the_chain );
   49abc:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   49abe:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   49ac0:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
  the_chain->last  = current;
   49ac2:	2549 0008      	movel %a1,%a2@(8)                                 	<== NOT EXECUTED
}
   49ac6:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   49ac8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49aca:	4e75           	rts

0005d9b4 <_Chain_Insert>:

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

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

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

  _ISR_Disable( level );
   5d9c8:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   5d9ca:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   5d9cc:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

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

  the_node->previous    = after_node;
   5d9d0:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
   5d9d4:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  the_node->next        = before_node;
  before_node->previous = the_node;
   5d9d6:	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;
   5d9da:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
    _Chain_Insert_unprotected( after_node, node );
  _ISR_Enable( level );
   5d9dc:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   5d9de:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   5d9e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d9e2:	4e75           	rts

000499cc <_Debug_Is_enabled>:
 */

bool _Debug_Is_enabled(
  rtems_debug_control  level
)
{
   499cc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   499d0:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   499d4:	c0b9 0005 6d66 	andl 56d66 <_Debug_Level>,%d0                     	<== NOT EXECUTED
   499da:	56c0           	sne %d0                                           	<== NOT EXECUTED
  return (_Debug_Level & level) ? true : false;
}
   499dc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   499de:	4480           	negl %d0                                          	<== NOT EXECUTED
   499e0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049998 <_Debug_Manager_initialization>:
 *
 *  _Debug_Manager_initialization
 */

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

void rtems_debug_disable (
  rtems_debug_control  to_be_disabled
)
{
  _Debug_Level &= ~to_be_disabled;
   4999e:	42b9 0005 6d66 	clrl 56d66 <_Debug_Level>                         	<== NOT EXECUTED
 */

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

000495e8 <_Dual_ported_memory_Manager_initialization>:
 */

void _Dual_ported_memory_Manager_initialization(
  uint32_t   maximum_ports
)
{
   495e8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   495ec:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   495f0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   495f2:	4878 001c      	pea 1c <OPER2+0x8>                                	<== NOT EXECUTED
   495f6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   495fa:	4878 0007      	pea 7 <TRUNCDFSF>                                 	<== NOT EXECUTED
   495fe:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   49602:	4879 0005 6f62 	pea 56f62 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   49608:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   4960e:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    FALSE,                        /* TRUE if this is a global object class */
    NULL                          /* Proxy extraction support callout */
#endif
  );
}
   49614:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49616:	4e75           	rts

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

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

#if defined(RTEMS_MULTIPROCESSING)
  _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet );
#endif
}
   4961c:	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;
   4961e:	42b9 0005 6ede 	clrl 56ede <_Event_Sync_state>                    	<== NOT EXECUTED
   */

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

000448e0 <_Event_Seize>:
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   448e0:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   448e4:	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;
   448e8:	2479 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   448ee:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   448f2:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   448f6:	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 );
   448fa:	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;
   44900:	42aa 0034      	clrl %a2@(52)                                     	<== NOT EXECUTED
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   44904:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
  Thread_blocking_operation_States  sync_state;

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

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

  _ISR_Disable( level );
   4490c:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   4490e:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   44910:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  pending_events = api->pending_events;
   44912:	2a11           	movel %a1@,%d5                                    	<== 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 );
   44914:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
   44916:	c285           	andl %d5,%d1                                      	<== NOT EXECUTED
  seized_events  = _Event_sets_Get( pending_events, event_in );

  if ( !_Event_sets_Is_empty( seized_events ) &&
   44918:	6716           	beqs 44930 <_Event_Seize+0x50>                    	<== NOT EXECUTED
   4491a:	b681           	cmpl %d1,%d3                                      	<== NOT EXECUTED
   4491c:	6706           	beqs 44924 <_Event_Seize+0x44>                    	<== NOT EXECUTED
   4491e:	0802 0001      	btst #1,%d2                                       	<== NOT EXECUTED
   44922:	670c           	beqs 44930 <_Event_Seize+0x50>                    	<== NOT EXECUTED
       (seized_events == event_in || _Options_Is_any( option_set )) ) {
    api->pending_events =
   44924:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   44926:	4680           	notl %d0                                          	<== NOT EXECUTED
   44928:	c085           	andl %d5,%d0                                      	<== NOT EXECUTED
   4492a:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
      _Event_sets_Clear( pending_events, seized_events );
    _ISR_Enable( level );
   4492c:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   4492e:	600e           	bras 4493e <_Event_Seize+0x5e>                    	<== NOT EXECUTED
    *event_out = seized_events;
    return;
  }

  if ( _Options_Is_no_wait( option_set ) ) {
   44930:	0802 0000      	btst #0,%d2                                       	<== NOT EXECUTED
   44934:	670e           	beqs 44944 <_Event_Seize+0x64>                    	<== NOT EXECUTED
    _ISR_Enable( level );
   44936:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
    executing->Wait.return_code = RTEMS_UNSATISFIED;
   44938:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
   4493a:	2540 0034      	movel %d0,%a2@(52)                                	<== NOT EXECUTED
    *event_out = seized_events;
   4493e:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
   44940:	6000 0096      	braw 449d8 <_Event_Seize+0xf8>                    	<== NOT EXECUTED
    return;
  }

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

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

  _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   4494a:	23c1 0005 6ede 	movel %d1,56ede <_Event_Sync_state>               	<== NOT EXECUTED

  executing->Wait.option            = (uint32_t) option_set;
  executing->Wait.count             = (uint32_t) event_in;
   44950:	2543 0024      	movel %d3,%a2@(36)                                	<== NOT EXECUTED
  executing->Wait.return_argument   = event_out;
   44954:	2548 0028      	movel %a0,%a2@(40)                                	<== NOT EXECUTED

  _ISR_Enable( level );
   44958:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED

  if ( ticks ) {
   4495a:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   4495c:	6730           	beqs 4498e <_Event_Seize+0xae>                    	<== NOT EXECUTED
    _Watchdog_Initialize(
   4495e:	202a 0008      	movel %a2@(8),%d0                                 	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   44962:	243c 0004 4b3c 	movel #281404,%d2                                 	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   44968:	2546 0054      	movel %d6,%a2@(84)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4496c:	2542 0064      	movel %d2,%a2@(100)                               	<== NOT EXECUTED
  the_watchdog->id        = id;
   44970:	2540 0068      	movel %d0,%a2@(104)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   44974:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   44978:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   4497c:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   44980:	4879 0005 6d80 	pea 56d80 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   44986:	4eb9 0004 7bc4 	jsr 47bc4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   4498c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      NULL
    );
    _Watchdog_Insert_ticks( &executing->Timer, ticks );
  }

  _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT );
   4498e:	4878 0100      	pea 100 <FP_REGS_SAVED+0xc0>                      	<== NOT EXECUTED
   44992:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44994:	4eb9 0004 7490 	jsr 47490 <_Thread_Set_state>                     	<== NOT EXECUTED

  _ISR_Disable( level );
   4499a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   449a0:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   449a2:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   449a4:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  sync_state = _Event_Sync_state;
   449a6:	2039 0005 6ede 	movel 56ede <_Event_Sync_state>,%d0               	<== NOT EXECUTED
  _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
   449ac:	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;
   449ae:	42b9 0005 6ede 	clrl 56ede <_Event_Sync_state>                    	<== NOT EXECUTED
  if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) {
   449b4:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   449b6:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   449b8:	6604           	bnes 449be <_Event_Seize+0xde>                    	<== NOT EXECUTED
    _ISR_Enable( level );
   449ba:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   449bc:	601a           	bras 449d8 <_Event_Seize+0xf8>                    	<== 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 );
   449be:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
}
   449c2:	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 );
   449c8:	2d41 0010      	movel %d1,%fp@(16)                                	<== NOT EXECUTED
   449cc:	2d40 0008      	movel %d0,%fp@(8)                                 	<== NOT EXECUTED
}
   449d0:	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 );
   449d2:	4ef9 0004 66f8 	jmp 466f8 <_Thread_blocking_operation_Cancel>     	<== NOT EXECUTED
}
   449d8:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   449de:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   449e0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044a34 <_Event_Surrender>:
 */

void _Event_Surrender(
  Thread_Control *the_thread
)
{
   44a34:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   44a38:	48d7 0c7c      	moveml %d2-%d6/%a2-%a3,%sp@                       	<== NOT EXECUTED
   44a3c:	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 );
   44a40:	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 ];
   44a46:	206a 010c      	moveal %a2@(268),%a0                              	<== NOT EXECUTED

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

  _ISR_Disable( level );
   44a4e:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   44a50:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   44a52:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  pending_events  = api->pending_events;
  event_condition = (rtems_event_set) the_thread->Wait.count;
   44a54:	242a 0024      	movel %a2@(36),%d2                                	<== 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;
   44a58:	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 );
   44a5a:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   44a5c:	c283           	andl %d3,%d1                                      	<== 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 ) ) {
   44a5e:	6606           	bnes 44a66 <_Event_Surrender+0x32>                	<== NOT EXECUTED
    _ISR_Enable( level );
   44a60:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   44a62:	6000 00cc      	braw 44b30 <_Event_Surrender+0xfc>                	<== 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() &&
   44a66:	2039 0005 6d42 	movel 56d42 <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
   44a6c:	674a           	beqs 44ab8 <_Event_Surrender+0x84>                	<== NOT EXECUTED
   44a6e:	b5f9 0005 6d62 	cmpal 56d62 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   44a74:	6642           	bnes 44ab8 <_Event_Surrender+0x84>                	<== NOT EXECUTED
   44a76:	2039 0005 6ede 	movel 56ede <_Event_Sync_state>,%d0               	<== NOT EXECUTED
   44a7c:	7c01           	moveq #1,%d6                                      	<== NOT EXECUTED
   44a7e:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   44a80:	670e           	beqs 44a90 <_Event_Surrender+0x5c>                	<== NOT EXECUTED
   44a82:	2039 0005 6ede 	movel 56ede <_Event_Sync_state>,%d0               	<== NOT EXECUTED
   44a88:	1c3c 0002      	moveb #2,%d6                                      	<== NOT EXECUTED
   44a8c:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   44a8e:	6628           	bnes 44ab8 <_Event_Surrender+0x84>                	<== 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) ) {
   44a90:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   44a92:	6706           	beqs 44a9a <_Event_Surrender+0x66>                	<== NOT EXECUTED
   44a94:	0805 0001      	btst #1,%d5                                       	<== NOT EXECUTED
   44a98:	671a           	beqs 44ab4 <_Event_Surrender+0x80>                	<== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events,seized_events );
   44a9a:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   44a9c:	4680           	notl %d0                                          	<== NOT EXECUTED
   44a9e:	c083           	andl %d3,%d0                                      	<== NOT EXECUTED
   44aa0:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
      the_thread->Wait.count = 0;
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   44aa2:	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;
   44aa6:	42aa 0024      	clrl %a2@(36)                                     	<== NOT EXECUTED
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
   44aaa:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   44aac:	23c0 0005 6ede 	movel %d0,56ede <_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;
   44ab2:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
      _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
    }
    _ISR_Enable( level );
   44ab4:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   44ab6:	6078           	bras 44b30 <_Event_Surrender+0xfc>                	<== NOT EXECUTED
  }

  /*
   *  Otherwise, this is a normal send to another thread
   */
  if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
   44ab8:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   44abc:	0280 0000 0100 	andil #256,%d0                                    	<== NOT EXECUTED
   44ac2:	676a           	beqs 44b2e <_Event_Surrender+0xfa>                	<== NOT EXECUTED
    if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
   44ac4:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   44ac6:	6706           	beqs 44ace <_Event_Surrender+0x9a>                	<== NOT EXECUTED
   44ac8:	0805 0001      	btst #1,%d5                                       	<== NOT EXECUTED
   44acc:	6760           	beqs 44b2e <_Event_Surrender+0xfa>                	<== NOT EXECUTED
      api->pending_events = _Event_sets_Clear( pending_events, seized_events );
   44ace:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   44ad0:	4680           	notl %d0                                          	<== NOT EXECUTED
   44ad2:	c083           	andl %d3,%d0                                      	<== NOT EXECUTED
   44ad4:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
      the_thread->Wait.count = 0;
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   44ad6:	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;
   44ada:	42aa 0024      	clrl %a2@(36)                                     	<== NOT EXECUTED
      *(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
   44ade:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED

      _ISR_Flash( level );
   44ae0:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   44ae6:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   44ae8:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   44aea:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   44aec:	47f9 0004 688c 	lea 4688c <_Thread_Clear_state>,%a3               	<== NOT EXECUTED

      if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   44af2:	7c02           	moveq #2,%d6                                      	<== NOT EXECUTED
   44af4:	bcaa 0050      	cmpl %a2@(80),%d6                                 	<== NOT EXECUTED
   44af8:	6710           	beqs 44b0a <_Event_Surrender+0xd6>                	<== NOT EXECUTED
        _ISR_Enable( level );
   44afa:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   44afc:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   44b02:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44b04:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   44b06:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   44b08:	6026           	bras 44b30 <_Event_Surrender+0xfc>                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   44b0a:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   44b0c:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
        _Thread_Unblock( the_thread );
      } else {
        _Watchdog_Deactivate( &the_thread->Timer );
        _ISR_Enable( level );
   44b10:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
        (void) _Watchdog_Remove( &the_thread->Timer );
   44b12:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   44b16:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   44b1c:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   44b22:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44b24:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   44b26:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   44b2c:	6002           	bras 44b30 <_Event_Surrender+0xfc>                	<== NOT EXECUTED
        _Thread_Unblock( the_thread );
      }
      return;
    }
  }
  _ISR_Enable( level );
   44b2e:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   44b30:	4cee 0c7c ffe4 	moveml %fp@(-28),%d2-%d6/%a2-%a3                  	<== NOT EXECUTED
   44b36:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44b38:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044b3c <_Event_Timeout>:

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

  the_thread = _Thread_Get( id, &location );
   44b42:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   44b46:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   44b4a:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   44b50:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
{
  Thread_Control    *the_thread;
  Objects_Locations  location;
  ISR_Level          level;

  the_thread = _Thread_Get( id, &location );
   44b52:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   44b54:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   44b58:	666a           	bnes 44bc4 <_Event_Timeout+0x88>                  	<== NOT EXECUTED
       *  this is the "timeout" transition.  After a request is satisfied,
       *  a timeout is not allowed to occur.
       */


      _ISR_Disable( level );
   44b5a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   44b60:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   44b62:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   44b64:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
        if ( !the_thread->Wait.count ) {  /* verify thread is waiting */
   44b66:	4aa8 0024      	tstl %a0@(36)                                     	<== NOT EXECUTED
   44b6a:	6612           	bnes 44b7e <_Event_Timeout+0x42>                  	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   44b6c:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   44b72:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   44b74:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
          _Thread_Unnest_dispatch();
          _ISR_Enable( level );
   44b7a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   44b7c:	6046           	bras 44bc4 <_Event_Timeout+0x88>                  	<== NOT EXECUTED
          return;
        }

        the_thread->Wait.count = 0;
   44b7e:	42a8 0024      	clrl %a0@(36)                                     	<== NOT EXECUTED
        if ( _Thread_Is_executing( the_thread ) ) {
   44b82:	b1f9 0005 6d62 	cmpal 56d62 <_Thread_Executing>,%a0               	<== NOT EXECUTED
   44b88:	6614           	bnes 44b9e <_Event_Timeout+0x62>                  	<== NOT EXECUTED
          Thread_blocking_operation_States sync = _Event_Sync_state;
   44b8a:	2039 0005 6ede 	movel 56ede <_Event_Sync_state>,%d0               	<== NOT EXECUTED
          if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) ||
   44b90:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   44b92:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   44b94:	6508           	bcss 44b9e <_Event_Timeout+0x62>                  	<== NOT EXECUTED
               (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
            _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   44b96:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   44b98:	23c0 0005 6ede 	movel %d0,56ede <_Event_Sync_state>               	<== NOT EXECUTED
          }
        }

        the_thread->Wait.return_code = RTEMS_TIMEOUT;
   44b9e:	7406           	moveq #6,%d2                                      	<== NOT EXECUTED
   44ba0:	2142 0034      	movel %d2,%a0@(52)                                	<== NOT EXECUTED
      _ISR_Enable( level );
   44ba4:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   44ba6:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   44bac:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   44bae:	4eb9 0004 688c 	jsr 4688c <_Thread_Clear_state>                   	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   44bb4:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   44bba:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   44bbc:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   44bbe:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */
#endif
    case OBJECTS_ERROR:
      break;
  }
}
   44bc4:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   44bc8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44bca:	4e75           	rts

00045540 <_Extension_Manager_initialization>:
 */

void _Extension_Manager_initialization(
  uint32_t   maximum_extensions
)
{
   45540:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   45544:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   45548:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4554a:	4878 0044      	pea 44 <FP_REGS_SAVED+0x4>                        	<== NOT EXECUTED
   4554e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45552:	4878 0009      	pea 9 <DIVIDE_BY_ZERO+0x1>                        	<== NOT EXECUTED
   45556:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4555a:	4879 0005 6ee2 	pea 56ee2 <_Extension_Information>                	<== NOT EXECUTED
   45560:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   45566:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    false,                     /* true if this is a global object class */
    NULL                       /* Proxy extraction support callout */
#endif
  );
}
   4556c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4556e:	4e75           	rts

00049c20 <_Heap_Allocate>:

void *_Heap_Allocate(
  Heap_Control        *the_heap,
  size_t               size
)
{
   49c20:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   49c24:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   49c28:	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 =
   49c2c:	2f2b 0014      	movel %a3@(20),%sp@-                              	<== NOT EXECUTED
   49c30:	2f2b 0010      	movel %a3@(16),%sp@-                              	<== NOT EXECUTED
   49c34:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   49c38:	4eb9 0004 5e74 	jsr 45e74 <_Heap_Calc_block_size>                 	<== NOT EXECUTED
    _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size);
  if(the_size == 0)
   49c3e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   49c44:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49c46:	674c           	beqs 49c94 <_Heap_Allocate+0x74>                  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   49c48:	246b 0008      	moveal %a3@(8),%a2                                	<== NOT EXECUTED
   49c4c:	4282           	clrl %d2                                          	<== NOT EXECUTED
   49c4e:	6034           	bras 49c84 <_Heap_Allocate+0x64>                  	<== 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) {
   49c50:	b0aa 0004      	cmpl %a2@(4),%d0                                  	<== NOT EXECUTED
   49c54:	6228           	bhis 49c7e <_Heap_Allocate+0x5e>                  	<== NOT EXECUTED
      (void)_Heap_Block_allocate(the_heap, the_block, the_size );
   49c56:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   49c58:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49c5a:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   49c5c:	4eb9 0004 5eb2 	jsr 45eb2 <_Heap_Block_allocate>                  	<== NOT EXECUTED

      ptr = _Heap_User_area(the_block);

      stats->allocs += 1;
      stats->searches += search_count + 1;
   49c62:	202b 004c      	movel %a3@(76),%d0                                	<== 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;
   49c66:	52ab 0048      	addql #1,%a3@(72)                                 	<== NOT EXECUTED
      stats->searches += search_count + 1;
   49c6a:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   49c6c:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
   49c6e:	2740 004c      	movel %d0,%a3@(76)                                	<== NOT EXECUTED
   49c72:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   49c74:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
   49c76:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   49c7c:	600c           	bras 49c8a <_Heap_Allocate+0x6a>                  	<== 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)
   49c7e:	246a 0008      	moveal %a2@(8),%a2                                	<== NOT EXECUTED
   49c82:	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;
   49c84:	b7ca           	cmpal %a2,%a3                                     	<== NOT EXECUTED
   49c86:	66c8           	bnes 49c50 <_Heap_Allocate+0x30>                  	<== NOT EXECUTED
   49c88:	4280           	clrl %d0                                          	<== NOT EXECUTED
      _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size));
      break;
    }
  }

  if(stats->max_search < search_count)
   49c8a:	b4ab 0044      	cmpl %a3@(68),%d2                                 	<== NOT EXECUTED
   49c8e:	6304           	blss 49c94 <_Heap_Allocate+0x74>                  	<== NOT EXECUTED
    stats->max_search = search_count;
   49c90:	2742 0044      	movel %d2,%a3@(68)                                	<== NOT EXECUTED

  return ptr;
}
   49c94:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   49c9a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49c9c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048738 <_Heap_Allocate_aligned>:
void *_Heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   48738:	4e56 ffd4      	linkw %fp,#-44                                    	<== NOT EXECUTED
   4873c:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   48740:	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);
   48744:	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;
   48748:	2c2b 0010      	movel %a3@(16),%d6                                	<== NOT EXECUTED
void *_Heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   4874c:	202e 000c      	movel %fp@(12),%d0                                	<== 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);
   48750:	2f06           	movel %d6,%sp@-                                   	<== NOT EXECUTED
void *_Heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   48752:	282e 0010      	movel %fp@(16),%d4                                	<== 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);
   48756:	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;
   48758:	5980           	subql #4,%d0                                      	<== NOT EXECUTED
   4875a:	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);
   4875e:	4eb9 0004 8b90 	jsr 48b90 <_Heap_Calc_block_size>                 	<== NOT EXECUTED

  if(the_size == 0)
   48764:	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);
   4876a:	2a40           	moveal %d0,%a5                                    	<== NOT EXECUTED

  if(the_size == 0)
   4876c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4876e:	6606           	bnes 48776 <_Heap_Allocate_aligned+0x3e>          	<== NOT EXECUTED
   48770:	4280           	clrl %d0                                          	<== NOT EXECUTED
   48772:	6000 0104      	braw 48878 <_Heap_Allocate_aligned+0x140>         	<== NOT EXECUTED
    return NULL;

  if(alignment == 0)
   48776:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   48778:	6604           	bnes 4877e <_Heap_Allocate_aligned+0x46>          	<== NOT EXECUTED
   4877a:	183c 0004      	moveb #4,%d4                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   4877e:	246b 0008      	moveal %a3@(8),%a2                                	<== NOT EXECUTED
   48782:	4287           	clrl %d7                                          	<== NOT EXECUTED
   48784:	6000 00e0      	braw 48866 <_Heap_Allocate_aligned+0x12e>         	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   48788:	7afe           	moveq #-2,%d5                                     	<== NOT EXECUTED
   4878a:	caaa 0004      	andl %a2@(4),%d5                                  	<== 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. */
   4878e:	bbc5           	cmpal %d5,%a5                                     	<== NOT EXECUTED
   48790:	6200 00ce      	bhiw 48860 <_Heap_Allocate_aligned+0x128>         	<== 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;
   48794:	49f2 5800      	lea %a2@(00000000,%d5:l),%a4                      	<== NOT EXECUTED
      aligned_user_addr = block_end - end_to_user_offs;
   48798:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   4879a:	90ae fffc      	subl %fp@(-4),%d0                                 	<== NOT EXECUTED
  _H_uptr_t *value,
  uint32_t  alignment
)
{
  _H_uptr_t v = *value;
  *value = v - (v % alignment);
   4879e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   487a0:	4c44 2001      	remul %d4,%d1,%d2                                 	<== NOT EXECUTED
   487a4:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
   487a6:	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));
   487a8:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
   487aa:	4c46 1000      	remul %d6,%d0,%d1                                 	<== NOT EXECUTED
   487ae:	2403           	movel %d3,%d2                                     	<== NOT EXECUTED
   487b0:	220a           	movel %a2,%d1                                     	<== NOT EXECUTED
   487b2:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   487b4:	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) {
   487b6:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   487b8:	6200 00a6      	bhiw 48860 <_Heap_Allocate_aligned+0x128>         	<== 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) {
   487bc:	226b 0014      	moveal %a3@(20),%a1                               	<== NOT EXECUTED
   487c0:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   487c2:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   487c4:	b3c0           	cmpal %d0,%a1                                     	<== NOT EXECUTED
   487c6:	632c           	blss 487f4 <_Heap_Allocate_aligned+0xbc>          	<== 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) {
   487c8:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   487ca:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   487cc:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   487ce:	6304           	blss 487d4 <_Heap_Allocate_aligned+0x9c>          	<== NOT EXECUTED
   487d0:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   487d2:	6020           	bras 487f4 <_Heap_Allocate_aligned+0xbc>          	<== NOT EXECUTED
  uint32_t  alignment
)
{
  _H_uptr_t v = *value;
  uint32_t a = alignment;
  _H_uptr_t r = v % a;
   487d4:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   487d6:	4c44 2000      	remul %d4,%d0,%d2                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   487da:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   487dc:	6604           	bnes 487e2 <_Heap_Allocate_aligned+0xaa>          	<== NOT EXECUTED
   487de:	2041           	moveal %d1,%a0                                    	<== NOT EXECUTED
   487e0:	6006           	bras 487e8 <_Heap_Allocate_aligned+0xb0>          	<== NOT EXECUTED
   487e2:	2041           	moveal %d1,%a0                                    	<== NOT EXECUTED
   487e4:	d1c4           	addal %d4,%a0                                     	<== NOT EXECUTED
   487e6:	91c0           	subal %d0,%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) {
   487e8:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   487ea:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   487ec:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   487ee:	6370           	blss 48860 <_Heap_Allocate_aligned+0x128>         	<== NOT EXECUTED
   487f0:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   487f2:	2608           	movel %a0,%d3                                     	<== NOT EXECUTED
              aligned_user_addr = 0;
            }
          }
        }

        if(aligned_user_addr) {
   487f4:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   487f6:	6768           	beqs 48860 <_Heap_Allocate_aligned+0x128>         	<== NOT EXECUTED

          /* The block is indeed acceptable: calculate the size of the block
             to be allocated and perform allocation. */
          uint32_t const alloc_size =
            block_end - user_addr + HEAP_BLOCK_USER_OFFSET;
   487f8:	200c           	movel %a4,%d0                                     	<== NOT EXECUTED
   487fa:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
   487fc:	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;
   487fe:	2205           	movel %d5,%d1                                     	<== NOT EXECUTED
   48800:	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) {
   48802:	b3c1           	cmpal %d1,%a1                                     	<== NOT EXECUTED
   48804:	6212           	bhis 48818 <_Heap_Allocate_aligned+0xe0>          	<== 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;
   48806:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   48808:	8481           	orl %d1,%d2                                       	<== NOT EXECUTED
   4880a:	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);
   4880e:	d5c1           	addal %d1,%a2                                     	<== NOT EXECUTED
    the_block = _Heap_Block_at(the_block, the_rest);
    the_block->prev_size = the_rest;
   48810:	2481           	movel %d1,%a2@                                    	<== NOT EXECUTED
    the_block->size = alloc_size;
   48812:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
   48816:	6016           	bras 4882e <_Heap_Allocate_aligned+0xf6>          	<== NOT EXECUTED
  Heap_Block *the_block
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
   48818:	226a 0008      	moveal %a2@(8),%a1                                	<== NOT EXECUTED
  Heap_Block *prev = block->prev;
   4881c:	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;
   48820:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
  prev->next = next;
  next->prev = prev;
   48822:	2348 000c      	movel %a0,%a1@(12)                                	<== NOT EXECUTED
   48826:	53ab 0038      	subql #1,%a3@(56)                                 	<== NOT EXECUTED
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
  prev->next = next;
   4882a:	2149 0008      	movel %a1,%a0@(8)                                 	<== NOT EXECUTED
  }
  /* Mark the block as used (in the next block). */
  _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED;
   4882e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   48830:	83b2 0804      	orl %d1,%a2@(00000004,%d0:l)                      	<== NOT EXECUTED
  /* Update statistics */
  stats->free_size -= alloc_size;
   48834:	242b 0030      	movel %a3@(48),%d2                                	<== NOT EXECUTED
   48838:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   4883a:	2742 0030      	movel %d2,%a3@(48)                                	<== NOT EXECUTED
  if(stats->min_free_size > stats->free_size)
   4883e:	b4ab 0034      	cmpl %a3@(52),%d2                                 	<== NOT EXECUTED
   48842:	6404           	bccs 48848 <_Heap_Allocate_aligned+0x110>         	<== NOT EXECUTED
    stats->min_free_size = stats->free_size;
   48844:	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;
   48848:	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;
   4884c:	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;
   48850:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
          stats->allocs += 1;
   48852:	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;
   48856:	d087           	addl %d7,%d0                                      	<== NOT EXECUTED
   48858:	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;
   4885c:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   4885e:	600e           	bras 4886e <_Heap_Allocate_aligned+0x136>         	<== 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)
   48860:	246a 0008      	moveal %a2@(8),%a2                                	<== NOT EXECUTED
   48864:	5287           	addql #1,%d7                                      	<== 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;
   48866:	b7ca           	cmpal %a2,%a3                                     	<== NOT EXECUTED
   48868:	6600 ff1e      	bnew 48788 <_Heap_Allocate_aligned+0x50>          	<== NOT EXECUTED
   4886c:	4280           	clrl %d0                                          	<== NOT EXECUTED
        }
      }
    }
  }

  if(stats->max_search < search_count)
   4886e:	beab 0044      	cmpl %a3@(68),%d7                                 	<== NOT EXECUTED
   48872:	6304           	blss 48878 <_Heap_Allocate_aligned+0x140>         	<== NOT EXECUTED
    stats->max_search = search_count;
   48874:	2747 0044      	movel %d7,%a3@(68)                                	<== NOT EXECUTED

  return user_ptr;
}
   48878:	4cee 3cfc ffd4 	moveml %fp@(-44),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   4887e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48880:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045eb2 <_Heap_Block_allocate>:
uint32_t _Heap_Block_allocate(
  Heap_Control* the_heap,
  Heap_Block*   the_block,
  uint32_t      alloc_size
)
{
   45eb2:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   45eb6:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   45eba:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   45ebe:	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);
   45ec2:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   45ec4:	c0a9 0004      	andl %a1@(4),%d0                                  	<== NOT EXECUTED
   45ec8:	266e 0008      	moveal %fp@(8),%a3                                	<== 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;
   45ecc:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   45ece:	2869 0008      	moveal %a1@(8),%a4                                	<== NOT EXECUTED
   45ed2:	2469 000c      	moveal %a1@(12),%a2                               	<== NOT EXECUTED
   45ed6:	9282           	subl %d2,%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) {
   45ed8:	b2ab 0014      	cmpl %a3@(20),%d1                                 	<== NOT EXECUTED
   45edc:	652a           	bcss 45f08 <_Heap_Block_allocate+0x56>            	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   45ede:	41f1 2800      	lea %a1@(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;
   45ee2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45ee4:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   45ee6:	2340 0004      	movel %d0,%a1@(4)                                 	<== NOT EXECUTED
    next_block->size = the_rest | HEAP_PREV_USED;
   45eea:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45eec:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;

  block = new_block;
  block->next = next;
   45eee:	214c 0008      	movel %a4,%a0@(8)                                 	<== NOT EXECUTED
    _Heap_Block_at(next_block, the_rest)->prev_size = the_rest;
   45ef2:	2181 1800      	movel %d1,%a0@(00000000,%d1:l)                    	<== NOT EXECUTED
  block->prev = prev;
   45ef6:	214a 000c      	movel %a2,%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;
   45efa:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED
  next->prev = prev->next = block;
   45efe:	2548 0008      	movel %a0,%a2@(8)                                 	<== NOT EXECUTED
   45f02:	2948 000c      	movel %a0,%a4@(12)                                	<== NOT EXECUTED
   45f06:	6014           	bras 45f1c <_Heap_Block_allocate+0x6a>            	<== 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;
   45f08:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45f0a:	83b1 0804      	orl %d1,%a1@(00000004,%d0:l)                      	<== NOT EXECUTED
    stats->free_blocks -= 1;
   45f0e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
  prev->next = next;
  next->prev = prev;
   45f10:	294a 000c      	movel %a2,%a4@(12)                                	<== NOT EXECUTED
   45f14:	53ab 0038      	subql #1,%a3@(56)                                 	<== NOT EXECUTED
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
  prev->next = next;
   45f18:	254c 0008      	movel %a4,%a2@(8)                                 	<== NOT EXECUTED
  }
  /* Update statistics */
  stats->free_size -= alloc_size;
   45f1c:	222b 0030      	movel %a3@(48),%d1                                	<== NOT EXECUTED
   45f20:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED
   45f22:	2741 0030      	movel %d1,%a3@(48)                                	<== NOT EXECUTED
  if(stats->min_free_size > stats->free_size)
   45f26:	b2ab 0034      	cmpl %a3@(52),%d1                                 	<== NOT EXECUTED
   45f2a:	6404           	bccs 45f30 <_Heap_Block_allocate+0x7e>            	<== NOT EXECUTED
    stats->min_free_size = stats->free_size;
   45f2c:	2741 0034      	movel %d1,%a3@(52)                                	<== NOT EXECUTED
  stats->used_blocks += 1;
   45f30:	52ab 0040      	addql #1,%a3@(64)                                 	<== NOT EXECUTED
  return alloc_size;
}
   45f34:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   45f36:	4cd7 1c04      	moveml %sp@,%d2/%a2-%a4                           	<== NOT EXECUTED
   45f3a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45f3c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045e74 <_Heap_Calc_block_size>:
 */
size_t _Heap_Calc_block_size(
  size_t   size,
  uint32_t page_size,
  uint32_t min_size)
{
   45e74:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45e78:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45e7a:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   45e7e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45e80:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD;
   45e84:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   45e86:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
 */
size_t _Heap_Calc_block_size(
  size_t   size,
  uint32_t page_size,
  uint32_t min_size)
{
   45e88:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   45e8c:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
   45e8e:	4c42 3001      	remul %d2,%d1,%d3                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   45e92:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   45e94:	6704           	beqs 45e9a <_Heap_Calc_block_size+0x26>           	<== NOT EXECUTED
   45e96:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
   45e98:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   45e9a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   45e9c:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   45e9e:	6302           	blss 45ea2 <_Heap_Calc_block_size+0x2e>           	<== NOT EXECUTED
   45ea0:	2208           	movel %a0,%d1                                     	<== 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;
}
   45ea2:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   45ea4:	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;
   45ea6:	b3c1           	cmpal %d1,%a1                                     	<== NOT EXECUTED
   45ea8:	55c0           	scs %d0                                           	<== NOT EXECUTED
   45eaa:	49c0           	extbl %d0                                         	<== NOT EXECUTED
}
   45eac:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45eae:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   45eb0:	4e75           	rts

0004cbf8 <_Heap_Extend>:
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t               size,
  uint32_t            *amount_extended
)
{
   4cbf8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4cbfc:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   4cc00:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   4cc04:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   4cc08:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
   *    5. non-contiguous higher address    (NOT SUPPORTED)
   *
   *  As noted, this code only supports (4).
   */

  if ( starting_address >= the_heap->begin &&        /* case 3 */
   4cc0c:	b0a9 0018      	cmpl %a1@(24),%d0                                 	<== NOT EXECUTED
   4cc10:	650a           	bcss 4cc1c <_Heap_Extend+0x24>                    	<== NOT EXECUTED
   4cc12:	b0a9 001c      	cmpl %a1@(28),%d0                                 	<== NOT EXECUTED
   4cc16:	6404           	bccs 4cc1c <_Heap_Extend+0x24>                    	<== NOT EXECUTED
   4cc18:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4cc1a:	6066           	bras 4cc82 <_Heap_Extend+0x8a>                    	<== NOT EXECUTED
       starting_address < the_heap->end
     )
    return HEAP_EXTEND_ERROR;

  if ( starting_address != the_heap->end )
   4cc1c:	b0a9 001c      	cmpl %a1@(28),%d0                                 	<== NOT EXECUTED
   4cc20:	6704           	beqs 4cc26 <_Heap_Extend+0x2e>                    	<== NOT EXECUTED
   4cc22:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4cc24:	605c           	bras 4cc82 <_Heap_Extend+0x8a>                    	<== 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;
   4cc26:	2469 0024      	moveal %a1@(36),%a2                               	<== NOT EXECUTED
   4cc2a:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
  the_heap->end = _Addresses_Add_offset( the_heap->end, size );
   4cc2c:	2340 001c      	movel %d0,%a1@(28)                                	<== NOT EXECUTED
  the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD;
   4cc30:	908a           	subl %a2,%d0                                      	<== NOT EXECUTED
   4cc32:	5180           	subql #8,%d0                                      	<== NOT EXECUTED
  uint32_t *value,
  uint32_t  alignment
)
{
  uint32_t v = *value;
  *value = v - (v % alignment);
   4cc34:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
  _Heap_Align_down( &the_size, the_heap->page_size );

  *amount_extended = size;
   4cc36:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   4cc3a:	4c69 3001 0010 	remul %a1@(16),%d1,%d3                            	<== NOT EXECUTED
   4cc40:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   4cc42:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4cc44:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED

  if( the_size < the_heap->min_block_size )
   4cc46:	b0a9 0014      	cmpl %a1@(20),%d0                                 	<== NOT EXECUTED
   4cc4a:	6534           	bcss 4cc80 <_Heap_Extend+0x88>                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   4cc4c:	41f2 0800      	lea %a2@(00000000,%d0:l),%a0                      	<== NOT EXECUTED
    return HEAP_EXTEND_SUCCESSFUL;

  old_final->size = the_size | (old_final->size & HEAP_PREV_USED);
   4cc50:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4cc52:	c0aa 0004      	andl %a2@(4),%d0                                  	<== NOT EXECUTED
   4cc56:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4cc58:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
  new_final = _Heap_Block_at( old_final, the_size );
  new_final->size = HEAP_PREV_USED;
   4cc5c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4cc5e:	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 ) );
   4cc62:	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;
   4cc66:	d5a9 002c      	addl %d2,%a1@(44)                                 	<== NOT EXECUTED
  stats->used_blocks += 1;
   4cc6a:	52a9 0040      	addql #1,%a1@(64)                                 	<== NOT EXECUTED
  stats->frees -= 1;    /* Don't count subsequent call as actual free() */
   4cc6e:	53a9 0050      	subql #1,%a1@(80)                                 	<== NOT EXECUTED

  _Heap_Free( the_heap, _Heap_User_area( old_final ) );
   4cc72:	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;
   4cc74:	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 ) );
   4cc78:	4eb9 0004 8904 	jsr 48904 <_Heap_Free>                            	<== NOT EXECUTED
   4cc7e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4cc80:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return HEAP_EXTEND_SUCCESSFUL;
}
   4cc82:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   4cc88:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cc8a:	4e75           	rts

00049ca0 <_Heap_Free>:

bool _Heap_Free(
  Heap_Control        *the_heap,
  void                *starting_address
)
{
   49ca0:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   49ca4:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   49ca8:	286e 0008      	moveal %fp@(8),%a4                                	<== NOT EXECUTED
   49cac:	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(
   49cb0:	206c 0024      	moveal %a4@(36),%a0                               	<== NOT EXECUTED
   49cb4:	226c 0020      	moveal %a4@(32),%a1                               	<== NOT EXECUTED
  void *address,
  void *base,
  void *limit
)
{
  return (address >= base && address <= limit);
   49cb8:	b3c1           	cmpal %d1,%a1                                     	<== NOT EXECUTED
   49cba:	6200 015e      	bhiw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
   49cbe:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   49cc0:	54c0           	scc %d0                                           	<== NOT EXECUTED
   49cc2:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   49cc4:	4480           	negl %d0                                          	<== NOT EXECUTED
   49cc6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49cc8:	6700 0150      	beqw 49e1a <_Heap_Free+0x17a>                     	<== 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);
   49ccc:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   49cce:	2441           	moveal %d1,%a2                                    	<== NOT EXECUTED
   49cd0:	4c6c 2000 0010 	remul %a4@(16),%d0,%d2                            	<== NOT EXECUTED
   49cd6:	518a           	subql #8,%a2                                      	<== NOT EXECUTED
   49cd8:	95c0           	subal %d0,%a2                                     	<== NOT EXECUTED
   49cda:	b3ca           	cmpal %a2,%a1                                     	<== NOT EXECUTED
   49cdc:	6200 013c      	bhiw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
   49ce0:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   49ce2:	54c0           	scc %d0                                           	<== NOT EXECUTED
   49ce4:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   49ce6:	4480           	negl %d0                                          	<== NOT EXECUTED
    return( FALSE );
  }

  _Heap_Start_of_block( the_heap, starting_address, &the_block );

  if ( !_Heap_Is_block_in( the_heap, the_block ) ) {
   49ce8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49cea:	6700 012e      	beqw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   49cee:	242a 0004      	movel %a2@(4),%d2                                 	<== NOT EXECUTED
   49cf2:	78fe           	moveq #-2,%d4                                     	<== NOT EXECUTED
   49cf4:	c882           	andl %d2,%d4                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   49cf6:	47f2 4800      	lea %a2@(00000000,%d4:l),%a3                      	<== NOT EXECUTED
   49cfa:	b3cb           	cmpal %a3,%a1                                     	<== NOT EXECUTED
   49cfc:	6200 011c      	bhiw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
   49d00:	b1cb           	cmpal %a3,%a0                                     	<== NOT EXECUTED
   49d02:	54c0           	scc %d0                                           	<== NOT EXECUTED
   49d04:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   49d06:	4480           	negl %d0                                          	<== NOT EXECUTED
  }

  the_size = _Heap_Block_size( the_block );
  next_block = _Heap_Block_at( the_block, the_size );

  if ( !_Heap_Is_block_in( the_heap, next_block ) ) {
   49d08:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49d0a:	6700 010e      	beqw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   49d0e:	222b 0004      	movel %a3@(4),%d1                                 	<== NOT EXECUTED
    _HAssert( FALSE );
    return( FALSE );
  }

  if ( !_Heap_Is_prev_used( next_block ) ) {
   49d12:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49d14:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   49d16:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49d18:	6700 0100      	beqw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   49d1c:	7afe           	moveq #-2,%d5                                     	<== NOT EXECUTED
   49d1e:	ca81           	andl %d1,%d5                                      	<== NOT EXECUTED
    _HAssert( FALSE );
    return( FALSE );
  }

  next_size = _Heap_Block_size( next_block );
  next_is_free = next_block < the_heap->final &&
   49d20:	b1cb           	cmpal %a3,%a0                                     	<== NOT EXECUTED
   49d22:	6204           	bhis 49d28 <_Heap_Free+0x88>                      	<== NOT EXECUTED
   49d24:	4283           	clrl %d3                                          	<== NOT EXECUTED
   49d26:	600e           	bras 49d36 <_Heap_Free+0x96>                      	<== NOT EXECUTED
   49d28:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49d2a:	c0b3 5804      	andl %a3@(00000004,%d5:l),%d0                     	<== NOT EXECUTED
   49d2e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49d30:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   49d32:	4283           	clrl %d3                                          	<== NOT EXECUTED
   49d34:	1600           	moveb %d0,%d3                                     	<== NOT EXECUTED
    !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size));

  if ( !_Heap_Is_prev_used( the_block ) ) {
   49d36:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49d38:	c480           	andl %d0,%d2                                      	<== NOT EXECUTED
   49d3a:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   49d3c:	6666           	bnes 49da4 <_Heap_Free+0x104>                     	<== NOT EXECUTED
    uint32_t const prev_size = the_block->prev_size;
   49d3e:	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 );
   49d40:	95c1           	subal %d1,%a2                                     	<== NOT EXECUTED
   49d42:	b3ca           	cmpal %a2,%a1                                     	<== NOT EXECUTED
   49d44:	6200 00d4      	bhiw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
   49d48:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   49d4a:	54c0           	scc %d0                                           	<== NOT EXECUTED
   49d4c:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   49d4e:	4480           	negl %d0                                          	<== NOT EXECUTED
    Heap_Block *const prev_block = _Heap_Block_at( the_block, -prev_size );

    if ( !_Heap_Is_block_in( the_heap, prev_block ) ) {
   49d50:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49d52:	6700 00c6      	beqw 49e1a <_Heap_Free+0x17a>                     	<== 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) ) {
   49d56:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49d58:	c0aa 0004      	andl %a2@(4),%d0                                  	<== NOT EXECUTED
   49d5c:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   49d5e:	6700 00ba      	beqw 49e1a <_Heap_Free+0x17a>                     	<== NOT EXECUTED
      _HAssert( FALSE );
      return( FALSE );
    }

    if ( next_is_free ) {       /* coalesce both */
   49d62:	4a03           	tstb %d3                                          	<== NOT EXECUTED
   49d64:	6728           	beqs 49d8e <_Heap_Free+0xee>                      	<== NOT EXECUTED
      uint32_t const size = the_size + prev_size + next_size;
      _Heap_Block_remove( next_block );
      stats->free_blocks -= 1;
   49d66:	53ac 0038      	subql #1,%a4@(56)                                 	<== NOT EXECUTED
      _HAssert( FALSE );
      return( FALSE );
    }

    if ( next_is_free ) {       /* coalesce both */
      uint32_t const size = the_size + prev_size + next_size;
   49d6a:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   49d6c:	d085           	addl %d5,%d0                                      	<== NOT EXECUTED
   49d6e:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
   49d70:	226b 000c      	moveal %a3@(12),%a1                               	<== NOT EXECUTED
  Heap_Block *the_block
)
{
  Heap_Block *block = the_block;

  Heap_Block *next = block->next;
   49d74:	206b 0008      	moveal %a3@(8),%a0                                	<== NOT EXECUTED
      _Heap_Block_remove( next_block );
      stats->free_blocks -= 1;
      prev_block->size = size | HEAP_PREV_USED;
   49d78:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49d7a:	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;
   49d7c:	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;
   49d80:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
  Heap_Block *prev = block->prev;
  prev->next = next;
  next->prev = prev;
   49d84:	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;
   49d88:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
   49d8c:	607c           	bras 49e0a <_Heap_Free+0x16a>                     	<== 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;
   49d8e:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   49d90:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
      prev_block->size = size | HEAP_PREV_USED;
   49d92:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   49d94:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
      next_block->size &= ~HEAP_PREV_USED;
      next_block->prev_size = size;
   49d96:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
      next_block->prev_size = size;
    }
    else {                      /* coalesce prev */
      uint32_t const size = the_size + prev_size;
      prev_block->size = size | HEAP_PREV_USED;
      next_block->size &= ~HEAP_PREV_USED;
   49d98:	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;
   49d9a:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
      next_block->size &= ~HEAP_PREV_USED;
   49d9e:	c1ab 0004      	andl %d0,%a3@(4)                                  	<== NOT EXECUTED
   49da2:	6066           	bras 49e0a <_Heap_Free+0x16a>                     	<== NOT EXECUTED
      next_block->prev_size = size;
    }
  }
  else if ( next_is_free ) {    /* coalesce next */
   49da4:	4a03           	tstb %d3                                          	<== NOT EXECUTED
   49da6:	672a           	beqs 49dd2 <_Heap_Free+0x132>                     	<== NOT EXECUTED
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
  Heap_Block *prev = block->prev;
   49da8:	206b 000c      	moveal %a3@(12),%a0                               	<== NOT EXECUTED
  Heap_Block *old_block,
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
   49dac:	226b 0008      	moveal %a3@(8),%a1                                	<== NOT EXECUTED
    uint32_t const size = the_size + next_size;
   49db0:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
  Heap_Block *prev = block->prev;

  block = new_block;
  block->next = next;
   49db2:	2549 0008      	movel %a1,%a2@(8)                                 	<== NOT EXECUTED
   49db6:	d084           	addl %d4,%d0                                      	<== NOT EXECUTED
    _Heap_Block_replace( next_block, the_block );
    the_block->size = size | HEAP_PREV_USED;
   49db8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  block->prev = prev;
   49dba:	2548 000c      	movel %a0,%a2@(12)                                	<== NOT EXECUTED
   49dbe:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
    next_block  = _Heap_Block_at( the_block, size );
    next_block->prev_size = size;
   49dc0:	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;
   49dc4:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
  next->prev = prev->next = block;
   49dc8:	214a 0008      	movel %a2,%a0@(8)                                 	<== NOT EXECUTED
   49dcc:	234a 000c      	movel %a2,%a1@(12)                                	<== NOT EXECUTED
   49dd0:	6038           	bras 49e0a <_Heap_Free+0x16a>                     	<== 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;
   49dd2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49dd4:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
)
{
  Heap_Block *prev = prev_block;
  Heap_Block *block = the_block;

  Heap_Block *next = prev->next;
   49dd6:	206c 0008      	moveal %a4@(8),%a0                                	<== NOT EXECUTED
   49dda:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
    next_block->size &= ~HEAP_PREV_USED;
   49dde:	72fe           	moveq #-2,%d1                                     	<== NOT EXECUTED
   49de0:	c3ab 0004      	andl %d1,%a3@(4)                                  	<== NOT EXECUTED
    next_block->prev_size = the_size;
   49de4:	2684           	movel %d4,%a3@                                    	<== NOT EXECUTED

    stats->free_blocks += 1;
   49de6:	202c 0038      	movel %a4@(56),%d0                                	<== NOT EXECUTED
  block->next  = next;
   49dea:	2548 0008      	movel %a0,%a2@(8)                                 	<== NOT EXECUTED
   49dee:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
  block->prev  = prev;
   49df0:	254c 000c      	movel %a4,%a2@(12)                                	<== NOT EXECUTED
  next->prev = prev->next = block;
   49df4:	294a 0008      	movel %a2,%a4@(8)                                 	<== NOT EXECUTED
   49df8:	214a 000c      	movel %a2,%a0@(12)                                	<== NOT EXECUTED
   49dfc:	2940 0038      	movel %d0,%a4@(56)                                	<== NOT EXECUTED
    if ( stats->max_free_blocks < stats->free_blocks )
   49e00:	b0ac 003c      	cmpl %a4@(60),%d0                                 	<== NOT EXECUTED
   49e04:	6304           	blss 49e0a <_Heap_Free+0x16a>                     	<== NOT EXECUTED
      stats->max_free_blocks = stats->free_blocks;
   49e06:	2940 003c      	movel %d0,%a4@(60)                                	<== NOT EXECUTED
  }

  stats->used_blocks -= 1;
  stats->free_size += the_size;
   49e0a:	d9ac 0030      	addl %d4,%a4@(48)                                 	<== NOT EXECUTED
  stats->frees += 1;
   49e0e:	52ac 0050      	addql #1,%a4@(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;
   49e12:	53ac 0040      	subql #1,%a4@(64)                                 	<== NOT EXECUTED
  stats->free_size += the_size;
  stats->frees += 1;
   49e16:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49e18:	6002           	bras 49e1c <_Heap_Free+0x17c>                     	<== NOT EXECUTED

  return( TRUE );
   49e1a:	4200           	clrb %d0                                          	<== NOT EXECUTED
}
   49e1c:	4cd7 1c3c      	moveml %sp@,%d2-%d5/%a2-%a4                       	<== NOT EXECUTED
   49e20:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49e22:	4e75           	rts

0005dde4 <_Heap_Get_free_information>:

void _Heap_Get_free_information(
  Heap_Control        *the_heap,
  Heap_Information    *info
)
{
   5dde4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5dde8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5ddea:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   5ddee:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  Heap_Block *the_block;
  Heap_Block *const tail = _Heap_Tail(the_heap);

  info->number = 0;
   5ddf2:	4290           	clrl %a0@                                         	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   5ddf4:	226a 0008      	moveal %a2@(8),%a1                                	<== NOT EXECUTED
  info->largest = 0;
   5ddf8:	42a8 0004      	clrl %a0@(4)                                      	<== NOT EXECUTED
  info->total = 0;
   5ddfc:	42a8 0008      	clrl %a0@(8)                                      	<== NOT EXECUTED
   5de00:	601a           	bras 5de1c <_Heap_Get_free_information+0x38>      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   5de02:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   5de04:	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++;
   5de08:	5290           	addql #1,%a0@                                     	<== NOT EXECUTED
    info->total += the_size;
   5de0a:	d1a8 0008      	addl %d0,%a0@(8)                                  	<== NOT EXECUTED
    if ( info->largest < the_size )
   5de0e:	b0a8 0004      	cmpl %a0@(4),%d0                                  	<== NOT EXECUTED
   5de12:	6304           	blss 5de18 <_Heap_Get_free_information+0x34>      	<== NOT EXECUTED
        info->largest = the_size;
   5de14:	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)
   5de18:	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;
   5de1c:	b5c9           	cmpal %a1,%a2                                     	<== NOT EXECUTED
   5de1e:	66e2           	bnes 5de02 <_Heap_Get_free_information+0x1e>      	<== NOT EXECUTED
    info->number++;
    info->total += the_size;
    if ( info->largest < the_size )
        info->largest = the_size;
  }
}
   5de20:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   5de22:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5de24:	4e75           	rts                                               	<== NOT EXECUTED
	...

000668b0 <_Heap_Get_information>:

Heap_Get_information_status _Heap_Get_information(
  Heap_Control            *the_heap,
  Heap_Information_block  *the_info
)
{
   668b0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   668b4:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   668b8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   668ba:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
  Heap_Block *the_block = the_heap->start;
  Heap_Block *const end = the_heap->final;
   668be:	2428 0024      	movel %a0@(36),%d2                                	<== NOT EXECUTED

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

  the_info->Free.number  = 0;
   668c2:	4291           	clrl %a1@                                         	<== NOT EXECUTED
Heap_Get_information_status _Heap_Get_information(
  Heap_Control            *the_heap,
  Heap_Information_block  *the_info
)
{
  Heap_Block *the_block = the_heap->start;
   668c4:	2068 0020      	moveal %a0@(32),%a0                               	<== NOT EXECUTED

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

  the_info->Free.number  = 0;
  the_info->Free.total   = 0;
   668c8:	42a9 0008      	clrl %a1@(8)                                      	<== NOT EXECUTED
  the_info->Free.largest = 0;
   668cc:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  the_info->Used.number  = 0;
   668d0:	42a9 000c      	clrl %a1@(12)                                     	<== NOT EXECUTED
  the_info->Used.total   = 0;
   668d4:	42a9 0014      	clrl %a1@(20)                                     	<== NOT EXECUTED
  the_info->Used.largest = 0;
   668d8:	42a9 0010      	clrl %a1@(16)                                     	<== NOT EXECUTED
   668dc:	603c           	bras 6691a <_Heap_Get_information+0x6a>           	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   668de:	72fe           	moveq #-2,%d1                                     	<== NOT EXECUTED
   668e0:	c2a8 0004      	andl %a0@(4),%d1                                  	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   668e4:	d1c1           	addal %d1,%a0                                     	<== NOT EXECUTED

  while ( the_block != end ) {
    uint32_t const the_size = _Heap_Block_size(the_block);
    Heap_Block *const next_block = _Heap_Block_at(the_block, the_size);

    if ( _Heap_Is_prev_used(next_block) ) {
   668e6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   668e8:	c0a8 0004      	andl %a0@(4),%d0                                  	<== NOT EXECUTED
   668ec:	6714           	beqs 66902 <_Heap_Get_information+0x52>           	<== NOT EXECUTED
      the_info->Used.number++;
   668ee:	52a9 000c      	addql #1,%a1@(12)                                 	<== NOT EXECUTED
      the_info->Used.total += the_size;
   668f2:	d3a9 0014      	addl %d1,%a1@(20)                                 	<== NOT EXECUTED
      if ( the_info->Used.largest < the_size )
   668f6:	b2a9 0010      	cmpl %a1@(16),%d1                                 	<== NOT EXECUTED
   668fa:	631e           	blss 6691a <_Heap_Get_information+0x6a>           	<== NOT EXECUTED
        the_info->Used.largest = the_size;
   668fc:	2341 0010      	movel %d1,%a1@(16)                                	<== NOT EXECUTED
   66900:	6018           	bras 6691a <_Heap_Get_information+0x6a>           	<== NOT EXECUTED
    } else {
      the_info->Free.number++;
   66902:	5291           	addql #1,%a1@                                     	<== NOT EXECUTED
      the_info->Free.total += the_size;
   66904:	d3a9 0008      	addl %d1,%a1@(8)                                  	<== NOT EXECUTED
      if ( the_info->Free.largest < the_size )
   66908:	b2a9 0004      	cmpl %a1@(4),%d1                                  	<== NOT EXECUTED
   6690c:	6304           	blss 66912 <_Heap_Get_information+0x62>           	<== NOT EXECUTED
        the_info->Free.largest = the_size;
   6690e:	2341 0004      	movel %d1,%a1@(4)                                 	<== NOT EXECUTED
      if ( the_size != next_block->prev_size )
   66912:	b290           	cmpl %a0@,%d1                                     	<== NOT EXECUTED
   66914:	6704           	beqs 6691a <_Heap_Get_information+0x6a>           	<== NOT EXECUTED
   66916:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   66918:	600a           	bras 66924 <_Heap_Get_information+0x74>           	<== 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 ) {
   6691a:	b488           	cmpl %a0,%d2                                      	<== NOT EXECUTED
   6691c:	66c0           	bnes 668de <_Heap_Get_information+0x2e>           	<== 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;
   6691e:	4280           	clrl %d0                                          	<== NOT EXECUTED
   66920:	50a9 0014      	addql #8,%a1@(20)                                 	<== NOT EXECUTED

  return HEAP_GET_INFORMATION_SUCCESSFUL;
}
   66924:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   66926:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   66928:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045d6c <_Heap_Initialize>:
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t               size,
  uint32_t             page_size
)
{
   45d6c:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   45d70:	48d7 043c      	moveml %d2-%d5/%a2,%sp@                           	<== NOT EXECUTED
   45d74:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   45d78:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   45d7c:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   45d80:	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)
   45d84:	6606           	bnes 45d8c <_Heap_Initialize+0x20>                	<== NOT EXECUTED
   45d86:	143c 0004      	moveb #4,%d2                                      	<== NOT EXECUTED
   45d8a:	600a           	bras 45d96 <_Heap_Initialize+0x2a>                	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   45d8c:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45d8e:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   45d90:	6704           	beqs 45d96 <_Heap_Initialize+0x2a>                	<== NOT EXECUTED
   45d92:	5882           	addql #4,%d2                                      	<== NOT EXECUTED
   45d94:	9480           	subl %d0,%d2                                      	<== 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;
   45d96:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   45d98:	5080           	addql #8,%d0                                      	<== NOT EXECUTED
  uint32_t  alignment
)
{
  _H_uptr_t v = *value;
  uint32_t a = alignment;
  _H_uptr_t r = v % a;
   45d9a:	2a00           	movel %d0,%d5                                     	<== NOT EXECUTED
   45d9c:	4c42 5001      	remul %d2,%d1,%d5                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   45da0:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   45da2:	6704           	beqs 45da8 <_Heap_Initialize+0x3c>                	<== NOT EXECUTED
   45da4:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
   45da6:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
  _Heap_Align_up_uptr ( &aligned_start, page_size );
  aligned_start -= HEAP_BLOCK_USER_OFFSET;
   45da8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   45daa:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   45dac:	518a           	subql #8,%a2                                      	<== NOT EXECUTED
   45dae:	4c42 1000      	remul %d2,%d0,%d1                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   45db2:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45db4:	6604           	bnes 45dba <_Heap_Initialize+0x4e>                	<== NOT EXECUTED
   45db6:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   45db8:	600a           	bras 45dc4 <_Heap_Initialize+0x58>                	<== NOT EXECUTED
   45dba:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   45dbc:	0681 0000 0010 	addil #16,%d1                                     	<== NOT EXECUTED
   45dc2:	9280           	subl %d0,%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);
   45dc4:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
   45dc6:	9084           	subl %d4,%d0                                      	<== NOT EXECUTED
   45dc8:	d08a           	addl %a2,%d0                                      	<== NOT EXECUTED
   45dca:	2341 0014      	movel %d1,%a1@(20)                                	<== NOT EXECUTED
  if ( size < overhead )
   45dce:	b083           	cmpl %d3,%d0                                      	<== NOT EXECUTED
   45dd0:	6200 0096      	bhiw 45e68 <_Heap_Initialize+0xfc>                	<== NOT EXECUTED
    return 0;   /* Too small area for the heap */
  the_size = size - overhead;
   45dd4:	2203           	movel %d3,%d1                                     	<== NOT EXECUTED
   45dd6:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   45dd8:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
  uint32_t *value,
  uint32_t  alignment
)
{
  uint32_t v = *value;
  *value = v - (v % alignment);
   45dda:	2a01           	movel %d1,%d5                                     	<== NOT EXECUTED
   45ddc:	4c42 5001      	remul %d2,%d1,%d5                                 	<== NOT EXECUTED
   45de0:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   45de2:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
  _Heap_Align_down ( &the_size, page_size );
  if ( the_size == 0 )
   45de4:	6700 0082      	beqw 45e68 <_Heap_Initialize+0xfc>                	<== NOT EXECUTED
    return 0;   /* Too small area for the heap */

  the_heap->page_size = page_size;
   45de8:	2342 0010      	movel %d2,%a1@(16)                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
  void       *base,
  uint32_t    offset
)
{
  return (void *)((char *)base + offset);
   45dec:	41f2 0800      	lea %a2@(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;
   45df0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45df2:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   45df4:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
  stats->max_search = 0;
  stats->allocs = 0;
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;
   45df8:	2039 0005 6450 	movel 56450 <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;
   45dfe:	2482           	movel %d2,%a2@                                    	<== 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;
   45e00:	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;
   45e04:	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 */
   45e06:	2081           	movel %d1,%a0@                                    	<== 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 );
   45e08:	2549 0008      	movel %a1,%a2@(8)                                 	<== NOT EXECUTED
  the_block->prev = _Heap_Head( the_heap );
   45e0c:	2549 000c      	movel %a1,%a2@(12)                                	<== 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;
   45e10:	2342 0038      	movel %d2,%a1@(56)                                	<== NOT EXECUTED
  stats->max_free_blocks = 1;
   45e14:	2342 003c      	movel %d2,%a1@(60)                                	<== NOT EXECUTED
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;

  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
   45e18:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   45e1a:	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;
   45e1c:	2343 002c      	movel %d3,%a1@(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;
   45e20:	d684           	addl %d4,%d3                                      	<== NOT EXECUTED
  stats->max_search = 0;
  stats->allocs = 0;
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;
   45e22:	2340 0028      	movel %d0,%a1@(40)                                	<== NOT EXECUTED
   45e26:	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;
   45e28:	2341 0030      	movel %d1,%a1@(48)                                	<== NOT EXECUTED
  stats->min_free_size = the_size;
   45e2c:	2341 0034      	movel %d1,%a1@(52)                                	<== NOT EXECUTED
  stats->free_blocks = 1;
  stats->max_free_blocks = 1;
  stats->used_blocks = 0;
   45e30:	42a9 0040      	clrl %a1@(64)                                     	<== NOT EXECUTED
  stats->max_search = 0;
   45e34:	42a9 0044      	clrl %a1@(68)                                     	<== NOT EXECUTED
  stats->allocs = 0;
   45e38:	42a9 0048      	clrl %a1@(72)                                     	<== NOT EXECUTED
  stats->searches = 0;
   45e3c:	42a9 004c      	clrl %a1@(76)                                     	<== NOT EXECUTED
  stats->frees = 0;
   45e40:	42a9 0050      	clrl %a1@(80)                                     	<== NOT EXECUTED
  stats->resizes = 0;
   45e44:	42a9 0054      	clrl %a1@(84)                                     	<== 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;
   45e48:	2343 001c      	movel %d3,%a1@(28)                                	<== NOT EXECUTED
  stats->max_search = 0;
  stats->allocs = 0;
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;
   45e4c:	23c0 0005 6450 	movel %d0,56450 <instance>                        	<== 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;
   45e52:	2344 0018      	movel %d4,%a1@(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;
   45e56:	234a 0008      	movel %a2,%a1@(8)                                 	<== NOT EXECUTED
  _Heap_Tail(the_heap)->prev = the_block;
   45e5a:	234a 000c      	movel %a2,%a1@(12)                                	<== NOT EXECUTED
  the_heap->start = the_block;
   45e5e:	234a 0020      	movel %a2,%a1@(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 */
   45e62:	2348 0024      	movel %a0,%a1@(36)                                	<== NOT EXECUTED
   45e66:	6002           	bras 45e6a <_Heap_Initialize+0xfe>                	<== NOT EXECUTED
  stats->searches = 0;
  stats->frees = 0;
  stats->resizes = 0;
  stats->instance = instance++;

  return ( the_size - HEAP_BLOCK_USED_OVERHEAD );
   45e68:	4282           	clrl %d2                                          	<== NOT EXECUTED
}
   45e6a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   45e6c:	4cd7 043c      	moveml %sp@,%d2-%d5/%a2                           	<== NOT EXECUTED
   45e70:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45e72:	4e75           	rts

000536dc <_Heap_Resize_block>:
  void         *starting_address,
  size_t        size,
  uint32_t     *old_mem_size,
  uint32_t     *avail_mem_size
)
{
   536dc:	4e56 ffd4      	linkw %fp,#-44                                    	<== NOT EXECUTED
   536e0:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   536e4:	266e 0008      	moveal %fp@(8),%a3                                	<== 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;
   536e8:	206e 0014      	moveal %fp@(20),%a0                               	<== 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;
   536ec:	2a2b 0014      	movel %a3@(20),%d5                                	<== NOT EXECUTED
  uint32_t const page_size = the_heap->page_size;
   536f0:	242b 0010      	movel %a3@(16),%d2                                	<== NOT EXECUTED

  *old_mem_size = 0;
  *avail_mem_size = 0;
   536f4:	286e 0018      	moveal %fp@(24),%a4                               	<== 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;
   536f8:	4290           	clrl %a0@                                         	<== NOT EXECUTED
  void         *starting_address,
  size_t        size,
  uint32_t     *old_mem_size,
  uint32_t     *avail_mem_size
)
{
   536fa:	282e 000c      	movel %fp@(12),%d4                                	<== 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;
   536fe:	4294           	clrl %a4@                                         	<== 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);
   53700:	2444           	moveal %d4,%a2                                    	<== NOT EXECUTED
   53702:	2604           	movel %d4,%d3                                     	<== NOT EXECUTED
  void         *starting_address,
  size_t        size,
  uint32_t     *old_mem_size,
  uint32_t     *avail_mem_size
)
{
   53704:	2a6e 0010      	moveal %fp@(16),%a5                               	<== 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 );
   53708:	206b 0024      	moveal %a3@(36),%a0                               	<== NOT EXECUTED
   5370c:	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);
   53710:	518a           	subql #8,%a2                                      	<== NOT EXECUTED
   53712:	4c6b 3000 0010 	remul %a3@(16),%d0,%d3                            	<== NOT EXECUTED
   53718:	95c0           	subal %d0,%a2                                     	<== NOT EXECUTED
   5371a:	b28a           	cmpl %a2,%d1                                      	<== NOT EXECUTED
   5371c:	6200 0156      	bhiw 53874 <_Heap_Resize_block+0x198>             	<== NOT EXECUTED
   53720:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   53722:	54c0           	scc %d0                                           	<== NOT EXECUTED
   53724:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   53726:	4480           	negl %d0                                          	<== NOT EXECUTED
  *old_mem_size = 0;
  *avail_mem_size = 0;

  _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))
   53728:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   5372a:	6700 0148      	beqw 53874 <_Heap_Resize_block+0x198>             	<== NOT EXECUTED
    return HEAP_RESIZE_FATAL_ERROR;

  prev_used_flag = the_block->size & HEAP_PREV_USED;
   5372e:	2e2a 0004      	movel %a2@(4),%d7                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   53732:	7cfe           	moveq #-2,%d6                                     	<== NOT EXECUTED
   53734:	cc87           	andl %d7,%d6                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   53736:	43f2 6800      	lea %a2@(00000000,%d6:l),%a1                      	<== NOT EXECUTED
   5373a:	b289           	cmpl %a1,%d1                                      	<== NOT EXECUTED
   5373c:	6200 0136      	bhiw 53874 <_Heap_Resize_block+0x198>             	<== NOT EXECUTED
   53740:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   53742:	54c0           	scc %d0                                           	<== NOT EXECUTED
   53744:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   53746:	4480           	negl %d0                                          	<== 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) ||
   53748:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   5374a:	6700 0128      	beqw 53874 <_Heap_Resize_block+0x198>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used (
  Heap_Block *the_block
)
{
  return (the_block->size & HEAP_PREV_USED);
   5374e:	2229 0004      	movel %a1@(4),%d1                                 	<== NOT EXECUTED
   53752:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   53754:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   53756:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   53758:	6700 011a      	beqw 53874 <_Heap_Resize_block+0x198>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   5375c:	76fe           	moveq #-2,%d3                                     	<== NOT EXECUTED
   5375e:	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 );
   53760:	49f1 3800      	lea %a1@(00000000,%d3:l),%a4                      	<== 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) ||
   53764:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   53766:	6604           	bnes 5376c <_Heap_Resize_block+0x90>              	<== NOT EXECUTED
   53768:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   5376a:	6006           	bras 53772 <_Heap_Resize_block+0x96>              	<== NOT EXECUTED
   5376c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   5376e:	c2ac 0004      	andl %a4@(4),%d1                                  	<== 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)
   53772:	2049           	moveal %a1,%a0                                    	<== NOT EXECUTED
   53774:	91c4           	subal %d4,%a0                                     	<== NOT EXECUTED
   53776:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
    + HEAP_BLOCK_HEADER_OFFSET;

  *old_mem_size = old_user_size;
   53778:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
  next_next_block = _Heap_Block_at(next_block, next_block_size);
  next_is_used    = (next_block == the_heap->final) ||
                     _Heap_Is_prev_used(next_next_block);

  /* See _Heap_Size_of_user_area() source for explanations */
  old_user_size = _Addresses_Subtract(next_block, starting_address)
   5377c:	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;
   5377e:	7801           	moveq #1,%d4                                      	<== 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;
   53780:	2080           	movel %d0,%a0@                                    	<== 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;
   53782:	c887           	andl %d7,%d4                                      	<== 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) ||
   53784:	1d41 ffff      	moveb %d1,%fp@(-1)                                	<== 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) {
   53788:	b08d           	cmpl %a5,%d0                                      	<== NOT EXECUTED
   5378a:	6446           	bccs 537d2 <_Heap_Resize_block+0xf6>              	<== 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 */
   5378c:	4a01           	tstb %d1                                          	<== NOT EXECUTED
   5378e:	6600 00e8      	bnew 53878 <_Heap_Resize_block+0x19c>             	<== NOT EXECUTED
      return HEAP_RESIZE_UNSATISFIED;
    else {
      uint32_t add_block_size = size - old_user_size;
   53792:	9bc0           	subal %d0,%a5                                     	<== NOT EXECUTED
  uint32_t  alignment
)
{
  uint32_t v = *value;
  uint32_t a = alignment;
  uint32_t r = v % a;
   53794:	2e0d           	movel %a5,%d7                                     	<== NOT EXECUTED
   53796:	200d           	movel %a5,%d0                                     	<== NOT EXECUTED
   53798:	4c42 7001      	remul %d2,%d1,%d7                                 	<== NOT EXECUTED
  *value = r ? v - r + a : v;
   5379c:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   5379e:	6704           	beqs 537a4 <_Heap_Resize_block+0xc8>              	<== NOT EXECUTED
   537a0:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
   537a2:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   537a4:	ba80           	cmpl %d0,%d5                                      	<== NOT EXECUTED
   537a6:	6302           	blss 537aa <_Heap_Resize_block+0xce>              	<== NOT EXECUTED
   537a8:	2005           	movel %d5,%d0                                     	<== 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)
   537aa:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   537ac:	6500 00ca      	bcsw 53878 <_Heap_Resize_block+0x19c>             	<== NOT EXECUTED
        return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */
      add_block_size =
   537b0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   537b2:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   537b4:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   537b6:	4eb9 0004 5eb2 	jsr 45eb2 <_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;
   537bc:	d086           	addl %d6,%d0                                      	<== NOT EXECUTED
   537be:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   537c0:	2540 0004      	movel %d0,%a2@(4)                                 	<== NOT EXECUTED
      --stats->used_blocks;
   537c4:	53ab 0040      	subql #1,%a3@(64)                                 	<== NOT EXECUTED
   537c8:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   537ce:	6000 009c      	braw 5386c <_Heap_Resize_block+0x190>             	<== NOT EXECUTED
    }
  } else {

    /* Calculate how much memory we could free */
    uint32_t free_block_size = old_user_size - size;
   537d2:	908d           	subl %a5,%d0                                      	<== NOT EXECUTED
  uint32_t *value,
  uint32_t  alignment
)
{
  uint32_t v = *value;
  *value = v - (v % alignment);
   537d4:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   537d6:	4c42 1007      	remul %d2,%d7,%d1                                 	<== NOT EXECUTED
   537da:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   537dc:	9487           	subl %d7,%d2                                      	<== NOT EXECUTED
    _Heap_Align_down(&free_block_size, page_size);

    if (free_block_size > 0) {
   537de:	6700 008c      	beqw 5386c <_Heap_Resize_block+0x190>             	<== 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;
   537e2:	2206           	movel %d6,%d1                                     	<== NOT EXECUTED
   537e4:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED

      if (new_block_size < min_block_size) {
   537e6:	ba81           	cmpl %d1,%d5                                      	<== NOT EXECUTED
   537e8:	630a           	blss 537f4 <_Heap_Resize_block+0x118>             	<== NOT EXECUTED
        uint32_t delta = min_block_size - new_block_size;
   537ea:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   537ec:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
        _HAssert(free_block_size >= delta);
        free_block_size -= delta;
   537ee:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
        if (free_block_size == 0) {
   537f0:	677a           	beqs 5386c <_Heap_Resize_block+0x190>             	<== NOT EXECUTED
          ++stats->resizes;
          return HEAP_RESIZE_SUCCESSFUL;
        }
        new_block_size += delta;
   537f2:	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) {
   537f4:	4a2e ffff      	tstb %fp@(-1)                                     	<== NOT EXECUTED
   537f8:	663e           	bnes 53838 <_Heap_Resize_block+0x15c>             	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   537fa:	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;
   537fe:	8284           	orl %d4,%d1                                       	<== NOT EXECUTED
   53800:	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;
   53804:	2469 000c      	moveal %a1@(12),%a2                               	<== 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;
   53808:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   5380a:	d083           	addl %d3,%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;
   5380c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   5380e:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
        next_next_block->prev_size = new_next_block_size;
   53810:	2880           	movel %d0,%a4@                                    	<== NOT EXECUTED
  Heap_Block *old_block,
  Heap_Block *new_block
)
{
  Heap_Block *block = old_block;
  Heap_Block *next = block->next;
   53812:	2269 0008      	moveal %a1@(8),%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;
   53816:	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;
   5381a:	d5ab 0030      	addl %d2,%a3@(48)                                 	<== NOT EXECUTED
        *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD;
   5381e:	286e 0018      	moveal %fp@(24),%a4                               	<== NOT EXECUTED
  Heap_Block *prev = block->prev;

  block = new_block;
  block->next = next;
   53822:	2149 0008      	movel %a1,%a0@(8)                                 	<== NOT EXECUTED
   53826:	5980           	subql #4,%d0                                      	<== NOT EXECUTED
  block->prev = prev;
   53828:	214a 000c      	movel %a2,%a0@(12)                                	<== NOT EXECUTED
   5382c:	2880           	movel %d0,%a4@                                    	<== NOT EXECUTED
  next->prev = prev->next = block;
   5382e:	2348 000c      	movel %a0,%a1@(12)                                	<== NOT EXECUTED
   53832:	2548 0008      	movel %a0,%a2@(8)                                 	<== NOT EXECUTED
   53836:	6034           	bras 5386c <_Heap_Resize_block+0x190>             	<== NOT EXECUTED

      } else if (free_block_size >= min_block_size) {
   53838:	ba82           	cmpl %d2,%d5                                      	<== NOT EXECUTED
   5383a:	6230           	bhis 5386c <_Heap_Resize_block+0x190>             	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   5383c:	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;
   53840:	8284           	orl %d4,%d1                                       	<== NOT EXECUTED
   53842:	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;
   53846:	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));
   53848:	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;
   5384c:	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;
   5384e:	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;
   53850:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED
        ++stats->used_blocks; /* We have created used block */
   53854:	52ab 0040      	addql #1,%a3@(64)                                 	<== NOT EXECUTED
        --stats->frees;       /* Don't count next call in stats */
   53858:	53ab 0050      	subql #1,%a3@(80)                                 	<== NOT EXECUTED
        _Heap_Free(the_heap, _Heap_User_area(next_block));
   5385c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   5385e:	4eb9 0004 9ca0 	jsr 49ca0 <_Heap_Free>                            	<== NOT EXECUTED
        *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD;
   53864:	206e 0018      	moveal %fp@(24),%a0                               	<== NOT EXECUTED
   53868:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   5386a:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
      }
    }
  }

  ++stats->resizes;
   5386c:	52ab 0054      	addql #1,%a3@(84)                                 	<== NOT EXECUTED
   53870:	4280           	clrl %d0                                          	<== NOT EXECUTED
   53872:	6006           	bras 5387a <_Heap_Resize_block+0x19e>             	<== NOT EXECUTED
  return HEAP_RESIZE_SUCCESSFUL;
   53874:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   53876:	6002           	bras 5387a <_Heap_Resize_block+0x19e>             	<== NOT EXECUTED
   53878:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
}
   5387a:	4cee 3cfc ffd4 	moveml %fp@(-44),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   53880:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   53882:	4e75           	rts

00053884 <_Heap_Size_of_user_area>:
bool _Heap_Size_of_user_area(
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t              *size
)
{
   53884:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   53888:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   5388c:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   53890:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
  Heap_Block        *the_block;
  Heap_Block        *next_block;
  uint32_t           the_size;

  if ( !_Addresses_Is_in_range(
   53894:	2428 0024      	movel %a0@(36),%d2                                	<== NOT EXECUTED
   53898:	2228 0020      	movel %a0@(32),%d1                                	<== NOT EXECUTED
   5389c:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   5389e:	625c           	bhis 538fc <_Heap_Size_of_user_area+0x78>         	<== NOT EXECUTED
   538a0:	b483           	cmpl %d3,%d2                                      	<== NOT EXECUTED
   538a2:	54c0           	scc %d0                                           	<== NOT EXECUTED
   538a4:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   538a6:	4480           	negl %d0                                          	<== NOT EXECUTED
   538a8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   538aa:	6750           	beqs 538fc <_Heap_Size_of_user_area+0x78>         	<== 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);
   538ac:	2803           	movel %d3,%d4                                     	<== NOT EXECUTED
   538ae:	4c68 4000 0010 	remul %a0@(16),%d0,%d4                            	<== NOT EXECUTED
   538b4:	2043           	moveal %d3,%a0                                    	<== NOT EXECUTED
   538b6:	5188           	subql #8,%a0                                      	<== NOT EXECUTED
   538b8:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   538ba:	b288           	cmpl %a0,%d1                                      	<== NOT EXECUTED
   538bc:	623e           	bhis 538fc <_Heap_Size_of_user_area+0x78>         	<== NOT EXECUTED
   538be:	b488           	cmpl %a0,%d2                                      	<== NOT EXECUTED
   538c0:	54c0           	scc %d0                                           	<== NOT EXECUTED
   538c2:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   538c4:	4480           	negl %d0                                          	<== NOT EXECUTED
    return( FALSE );

  _Heap_Start_of_block( the_heap, starting_address, &the_block );

  _HAssert(_Heap_Is_block_in( the_heap, the_block ));
  if ( !_Heap_Is_block_in( the_heap, the_block ) )
   538c6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   538c8:	6732           	beqs 538fc <_Heap_Size_of_user_area+0x78>         	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   538ca:	70fe           	moveq #-2,%d0                                     	<== NOT EXECUTED
   538cc:	c0a8 0004      	andl %a0@(4),%d0                                  	<== NOT EXECUTED
   538d0:	43f0 0800      	lea %a0@(00000000,%d0:l),%a1                      	<== NOT EXECUTED
   538d4:	b289           	cmpl %a1,%d1                                      	<== NOT EXECUTED
   538d6:	6224           	bhis 538fc <_Heap_Size_of_user_area+0x78>         	<== NOT EXECUTED
   538d8:	b489           	cmpl %a1,%d2                                      	<== NOT EXECUTED
   538da:	54c0           	scc %d0                                           	<== NOT EXECUTED
   538dc:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   538de:	4480           	negl %d0                                          	<== 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 (
   538e0:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   538e2:	6718           	beqs 538fc <_Heap_Size_of_user_area+0x78>         	<== NOT EXECUTED
   538e4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   538e6:	c0a9 0004      	andl %a1@(4),%d0                                  	<== NOT EXECUTED
   538ea:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   538ec:	670e           	beqs 538fc <_Heap_Size_of_user_area+0x78>         	<== 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 )
   538ee:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   538f2:	93c3           	subal %d3,%a1                                     	<== NOT EXECUTED
   538f4:	5889           	addql #4,%a1                                      	<== NOT EXECUTED
   538f6:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
   538f8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   538fa:	6002           	bras 538fe <_Heap_Size_of_user_area+0x7a>         	<== NOT EXECUTED
    + HEAP_BLOCK_HEADER_OFFSET;

  return( TRUE );
   538fc:	4200           	clrb %d0                                          	<== NOT EXECUTED
}
   538fe:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   53902:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   53904:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004cdd0 <_Heap_Walk>:
bool _Heap_Walk(
  Heap_Control  *the_heap,
  int            source,
  bool           do_dump
)
{
   4cdd0:	4e56 ffdc      	linkw %fp,#-36                                    	<== NOT EXECUTED
   4cdd4:	48d7 3c7c      	moveml %d2-%d6/%a2-%a5,%sp@                       	<== NOT EXECUTED
   4cdd8:	286e 0008      	moveal %fp@(8),%a4                                	<== NOT EXECUTED
   4cddc:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
  Heap_Block *the_block = the_heap->start;
   4cde0:	246c 0020      	moveal %a4@(32),%a2                               	<== NOT EXECUTED
  Heap_Block *const end = the_heap->final;
   4cde4:	2c2c 0024      	movel %a4@(36),%d6                                	<== NOT EXECUTED
/*
  if ( !_System_state_Is_up( _System_state_Get() ) )
    return TRUE;
*/

  if (source < 0)
   4cde8:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4cdea:	6c04           	bges 4cdf0 <_Heap_Walk+0x20>                      	<== NOT EXECUTED
    source = the_heap->stats.instance;
   4cdec:	282c 0028      	movel %a4@(40),%d4                                	<== NOT EXECUTED

  /*
   * Handle the 1st block
   */

  if (!_Heap_Is_prev_used(the_block)) {
   4cdf0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4cdf2:	c0aa 0004      	andl %a2@(4),%d0                                  	<== NOT EXECUTED
   4cdf6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4cdf8:	6704           	beqs 4cdfe <_Heap_Walk+0x2e>                      	<== NOT EXECUTED
   4cdfa:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4cdfc:	6012           	bras 4ce10 <_Heap_Walk+0x40>                      	<== NOT EXECUTED
    printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source);
   4cdfe:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4ce00:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4ce02:	4879 0005 77fe 	pea 577fe <status_flags_assoc+0x30>               	<== NOT EXECUTED
   4ce08:	4eb9 0004 522e 	jsr 4522e <printk>                                	<== NOT EXECUTED
   4ce0e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    error = 1;
  }

  if (the_block->prev_size != the_heap->page_size) {
   4ce10:	202c 0010      	movel %a4@(16),%d0                                	<== NOT EXECUTED
   4ce14:	b092           	cmpl %a2@,%d0                                     	<== NOT EXECUTED
   4ce16:	6700 0106      	beqw 4cf1e <_Heap_Walk+0x14e>                     	<== NOT EXECUTED
    printk("PASS: %d !prev_size of 1st block isn't page_size\n", source);
   4ce1a:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4ce1c:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4ce1e:	4879 0005 7834 	pea 57834 <status_flags_assoc+0x66>               	<== NOT EXECUTED
   4ce24:	4eb9 0004 522e 	jsr 4522e <printk>                                	<== NOT EXECUTED
   4ce2a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ce2c:	6000 00f0      	braw 4cf1e <_Heap_Walk+0x14e>                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4ce30:	262a 0004      	movel %a2@(4),%d3                                 	<== NOT EXECUTED
   4ce34:	7afe           	moveq #-2,%d5                                     	<== NOT EXECUTED
   4ce36:	ca83           	andl %d3,%d5                                      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  void     *base,
  uint32_t  offset
)
{
  return (Heap_Block *) _Addresses_Add_offset( base, offset );
   4ce38:	47f2 5800      	lea %a2@(00000000,%d5: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 );
   4ce3c:	202c 0024      	movel %a4@(36),%d0                                	<== NOT EXECUTED
   4ce40:	b7ec 0020      	cmpal %a4@(32),%a3                                	<== NOT EXECUTED
   4ce44:	650c           	bcss 4ce52 <_Heap_Walk+0x82>                      	<== NOT EXECUTED
   4ce46:	b08b           	cmpl %a3,%d0                                      	<== NOT EXECUTED
   4ce48:	54c0           	scc %d0                                           	<== NOT EXECUTED
   4ce4a:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4ce4c:	4480           	negl %d0                                          	<== NOT EXECUTED
        printk(" prev_size %d", the_block->prev_size);
      else
        printk(" (prev_size) %d", the_block->prev_size);
    }

    if (!_Heap_Is_block_in(the_heap, next_block)) {
   4ce4e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4ce50:	661a           	bnes 4ce6c <_Heap_Walk+0x9c>                      	<== NOT EXECUTED
      if (do_dump) printk("\n");
      printk("PASS: %d !block %p is out of heap\n", source, next_block);
   4ce52:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4ce54:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4ce56:	4879 0005 7866 	pea 57866 <status_flags_assoc+0x98>               	<== NOT EXECUTED
   4ce5c:	4eb9 0004 522e 	jsr 4522e <printk>                                	<== NOT EXECUTED
   4ce62:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4ce68:	6000 00c2      	braw 4cf2c <_Heap_Walk+0x15c>                     	<== NOT EXECUTED
      error = 1;
      break;
    }

    if (!_Heap_Is_prev_used(next_block)) {
   4ce6c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4ce6e:	c0ab 0004      	andl %a3@(4),%d0                                  	<== NOT EXECUTED
   4ce72:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4ce74:	6666           	bnes 4cedc <_Heap_Walk+0x10c>                     	<== 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) {
   4ce76:	ba93           	cmpl %a3@,%d5                                     	<== NOT EXECUTED
   4ce78:	670e           	beqs 4ce88 <_Heap_Walk+0xb8>                      	<== NOT EXECUTED
        if (do_dump) printk("\n");
        printk("PASS: %d !front and back sizes don't match", source);
   4ce7a:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4ce7c:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4ce7e:	4879 0005 7889 	pea 57889 <status_flags_assoc+0xbb>               	<== NOT EXECUTED
   4ce84:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ce86:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
        error = 1;
      }
      if (!prev_used) {
   4ce88:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4ce8a:	c680           	andl %d0,%d3                                      	<== NOT EXECUTED
   4ce8c:	4a03           	tstb %d3                                          	<== NOT EXECUTED
   4ce8e:	661c           	bnes 4ceac <_Heap_Walk+0xdc>                      	<== NOT EXECUTED
        if (do_dump || error) printk("\n");
   4ce90:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4ce92:	670a           	beqs 4ce9e <_Heap_Walk+0xce>                      	<== NOT EXECUTED
   4ce94:	4879 0005 72fd 	pea 572fd <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4ce9a:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ce9c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
        printk("PASS: %d !two consecutive blocks are free", source);
   4ce9e:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4cea0:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4cea2:	4879 0005 78b4 	pea 578b4 <status_flags_assoc+0xe6>               	<== NOT EXECUTED
   4cea8:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ceaa:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_First (
  Heap_Control *the_heap
)
{
  return _Heap_Head(the_heap)->next;
   4ceac:	206c 0008      	moveal %a4@(8),%a0                                	<== NOT EXECUTED
   4ceb0:	6004           	bras 4ceb6 <_Heap_Walk+0xe6>                      	<== 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;
   4ceb2:	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)
   4ceb6:	b5c8           	cmpal %a0,%a2                                     	<== NOT EXECUTED
   4ceb8:	6722           	beqs 4cedc <_Heap_Walk+0x10c>                     	<== NOT EXECUTED
   4ceba:	b9c8           	cmpal %a0,%a4                                     	<== NOT EXECUTED
   4cebc:	66f4           	bnes 4ceb2 <_Heap_Walk+0xe2>                      	<== NOT EXECUTED
          block = block->next;
        if(block != the_block) {
          if (do_dump || error) printk("\n");
   4cebe:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4cec0:	670a           	beqs 4cecc <_Heap_Walk+0xfc>                      	<== NOT EXECUTED
   4cec2:	4879 0005 72fd 	pea 572fd <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4cec8:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ceca:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
          printk("PASS: %d !the_block not in the free list", source);
   4cecc:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4cece:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4ced0:	4879 0005 78de 	pea 578de <status_flags_assoc+0x110>              	<== NOT EXECUTED
   4ced6:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4ced8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ceda:	6004           	bras 4cee0 <_Heap_Walk+0x110>                     	<== NOT EXECUTED
          error = 1;
        }
      }

    }
    if (do_dump || error) printk("\n");
   4cedc:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4cede:	670a           	beqs 4ceea <_Heap_Walk+0x11a>                     	<== NOT EXECUTED
   4cee0:	4879 0005 72fd 	pea 572fd <rtems_status_assoc+0x1a1>              	<== NOT EXECUTED
   4cee6:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4cee8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

    if (the_size < the_heap->min_block_size) {
   4ceea:	baac 0014      	cmpl %a4@(20),%d5                                 	<== NOT EXECUTED
   4ceee:	640a           	bccs 4cefa <_Heap_Walk+0x12a>                     	<== NOT EXECUTED
      printk("PASS: %d !block size is too small\n", source);
   4cef0:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4cef2:	4879 0005 7907 	pea 57907 <status_flags_assoc+0x139>              	<== NOT EXECUTED
   4cef8:	6012           	bras 4cf0c <_Heap_Walk+0x13c>                     	<== NOT EXECUTED
      error = 1;
      break;
    }
    if (!_Heap_Is_aligned( the_size, the_heap->page_size)) {
   4cefa:	4c6c 5000 0010 	remul %a4@(16),%d0,%d5                            	<== NOT EXECUTED
   4cf00:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4cf02:	6712           	beqs 4cf16 <_Heap_Walk+0x146>                     	<== NOT EXECUTED
      printk("PASS: %d !block size is misaligned\n", source);
   4cf04:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4cf06:	4879 0005 792a 	pea 5792a <status_flags_assoc+0x15c>              	<== NOT EXECUTED
   4cf0c:	4eb9 0004 522e 	jsr 4522e <printk>                                	<== NOT EXECUTED
   4cf12:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4cf14:	6016           	bras 4cf2c <_Heap_Walk+0x15c>                     	<== NOT EXECUTED
      error = 1;
    }

    if (++passes > (do_dump ? 10 : 0) && error)
   4cf16:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4cf18:	6612           	bnes 4cf2c <_Heap_Walk+0x15c>                     	<== NOT EXECUTED
      break;
   4cf1a:	244b           	moveal %a3,%a2                                    	<== NOT EXECUTED
   4cf1c:	6006           	bras 4cf24 <_Heap_Walk+0x154>                     	<== NOT EXECUTED
          error = 1;
        }
      }

    }
    if (do_dump || error) printk("\n");
   4cf1e:	4bf9 0004 522e 	lea 4522e <printk>,%a5                            	<== 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 ) {
   4cf24:	bc8a           	cmpl %a2,%d6                                      	<== NOT EXECUTED
   4cf26:	6600 ff08      	bnew 4ce30 <_Heap_Walk+0x60>                      	<== NOT EXECUTED
   4cf2a:	601a           	bras 4cf46 <_Heap_Walk+0x176>                     	<== NOT EXECUTED

    the_block = next_block;
  }

  if (the_block != end) {
    printk("PASS: %d !last block address isn't equal to 'final' %p %p\n",
   4cf2c:	2f06           	movel %d6,%sp@-                                   	<== NOT EXECUTED
   4cf2e:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4cf30:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4cf32:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4cf34:	4879 0005 794e 	pea 5794e <status_flags_assoc+0x180>              	<== NOT EXECUTED
   4cf3a:	4eb9 0004 522e 	jsr 4522e <printk>                                	<== NOT EXECUTED
   4cf40:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
      source, the_block, end);
    error = 1;
  }

  if (_Heap_Block_size(the_block) != the_heap->page_size) {
   4cf46:	202c 0010      	movel %a4@(16),%d0                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Heap_Block_size (
  Heap_Block *the_block
)
{
  return (the_block->size & ~HEAP_PREV_USED);
   4cf4a:	72fe           	moveq #-2,%d1                                     	<== NOT EXECUTED
   4cf4c:	c2aa 0004      	andl %a2@(4),%d1                                  	<== NOT EXECUTED
   4cf50:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4cf52:	671a           	beqs 4cf6e <_Heap_Walk+0x19e>                     	<== NOT EXECUTED
    printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source,
   4cf54:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4cf56:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4cf58:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   4cf5a:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4cf5c:	4879 0005 7989 	pea 57989 <status_flags_assoc+0x1bb>              	<== NOT EXECUTED
   4cf62:	4eb9 0004 522e 	jsr 4522e <printk>                                	<== NOT EXECUTED
   4cf68:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4cf6e:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4cf70:	56c0           	sne %d0                                           	<== NOT EXECUTED
  if(do_dump && error)
    _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 );

  return error;

}
   4cf72:	4cee 3c7c ffdc 	moveml %fp@(-36),%d2-%d6/%a2-%a5                  	<== NOT EXECUTED
   4cf78:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cf7a:	4480           	negl %d0                                          	<== NOT EXECUTED
   4cf7c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045584 <_IO_Initialize_all_drivers>:
 *
 *  Output Parameters: NONE
 */

void _IO_Initialize_all_drivers( void )
{
   45584:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45588:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   rtems_device_major_number major;

   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
     (void) rtems_io_initialize( major, 0, NULL );
   4558a:	45f9 0004 99e4 	lea 499e4 <rtems_io_initialize>,%a2               	<== NOT EXECUTED
 *
 *  Output Parameters: NONE
 */

void _IO_Initialize_all_drivers( void )
{
   45590:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45592:	4282           	clrl %d2                                          	<== NOT EXECUTED
   45594:	6010           	bras 455a6 <_IO_Initialize_all_drivers+0x22>      	<== NOT EXECUTED
   rtems_device_major_number major;

   for ( major=0 ; major < _IO_Number_of_drivers ; major ++ )
     (void) rtems_io_initialize( major, 0, NULL );
   45596:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45598:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4559a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4559c:	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 ++ )
   4559e:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   455a0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   455a6:	b4b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   455ac:	65e8           	bcss 45596 <_IO_Initialize_all_drivers+0x12>      	<== NOT EXECUTED
     (void) rtems_io_initialize( major, 0, NULL );
}
   455ae:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   455b2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   455b6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   455b8:	4e75           	rts

000455ba <_IO_Manager_initialization>:
void _IO_Manager_initialization(
  rtems_driver_address_table *driver_table,
  uint32_t                    drivers_in_table,
  uint32_t                    number_of_drivers
)
{
   455ba:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   455be:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   455c2:	286e 0008      	moveal %fp@(8),%a4                                	<== NOT EXECUTED
   455c6:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
   455ca:	282e 0010      	movel %fp@(16),%d4                                	<== 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 )
   455ce:	ba84           	cmpl %d4,%d5                                      	<== NOT EXECUTED
   455d0:	6442           	bccs 45614 <_IO_Manager_initialization+0x5a>      	<== 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 *)
   455d2:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   455d4:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   455d6:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   455d8:	eb8a           	lsll #5,%d2                                       	<== NOT EXECUTED
   455da:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   455dc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   455de:	4eb9 0004 7e08 	jsr 47e08 <_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(
   455e4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
    _IO_Driver_address_table[index] = driver_table[index];
   455e6:	4283           	clrl %d3                                          	<== NOT EXECUTED
   455e8:	4282           	clrl %d2                                          	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )
      );
  _IO_Number_of_drivers = number_of_drivers;

  memset(
   455ea:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
   455ec:	47f9 0004 b3f4 	lea 4b3f4 <memcpy>,%a3                            	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        sizeof( rtems_driver_address_table ) * ( number_of_drivers )
      );
  _IO_Number_of_drivers = number_of_drivers;

  memset(
   455f2:	2f00           	movel %d0,%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;
   455f4:	23c4 0005 6f1e 	movel %d4,56f1e <_IO_Number_of_drivers>           	<== 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 *)
   455fa:	23c0 0005 6f22 	movel %d0,56f22 <_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(
   45600:	4eb9 0004 b464 	jsr 4b464 <memset>                                	<== NOT EXECUTED
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
    _IO_Driver_address_table[index] = driver_table[index];
   45606:	2479 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a2       	<== NOT EXECUTED
   4560c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45612:	602a           	bras 4563e <_IO_Manager_initialization+0x84>      	<== 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;
   45614:	23cc 0005 6f22 	movel %a4,56f22 <_IO_Driver_address_table>        	<== NOT EXECUTED
    _IO_Number_of_drivers = number_of_drivers;
   4561a:	23c5 0005 6f1e 	movel %d5,56f1e <_IO_Number_of_drivers>           	<== NOT EXECUTED
   45620:	6020           	bras 45642 <_IO_Manager_initialization+0x88>      	<== NOT EXECUTED
  memset(
    _IO_Driver_address_table, 0,
    sizeof( rtems_driver_address_table ) * ( number_of_drivers )
  );

  for ( index = 0 ; index < drivers_in_table ; index++ )
   45622:	4878 0018      	pea 18 <OPER2+0x4>                                	<== NOT EXECUTED
   45626:	4874 2800      	pea %a4@(00000000,%d2:l)                          	<== NOT EXECUTED
   4562a:	4872 2800      	pea %a2@(00000000,%d2:l)                          	<== NOT EXECUTED
   4562e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   45630:	5283           	addql #1,%d3                                      	<== NOT EXECUTED
   45632:	0682 0000 0018 	addil #24,%d2                                     	<== NOT EXECUTED
   45638:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4563e:	ba83           	cmpl %d3,%d5                                      	<== NOT EXECUTED
   45640:	62e0           	bhis 45622 <_IO_Manager_initialization+0x68>      	<== NOT EXECUTED
    _IO_Driver_address_table[index] = driver_table[index];
  number_of_drivers = drivers_in_table;
}
   45642:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   45648:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4564a:	4e75           	rts

00045f9c <_ISR_Handler_initialization>:
 *
 *  Output parameters: NONE
 */

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

  _ISR_Nest_level = 0;
   45fa4:	42b9 0005 6d42 	clrl 56d42 <_ISR_Nest_level>                      	<== NOT EXECUTED

#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
  _ISR_Vector_table = _Workspace_Allocate_or_fatal_error(
   45faa:	45f9 0004 7e08 	lea 47e08 <_Workspace_Allocate_or_fatal_error>,%a2	<== NOT EXECUTED
 *  Output parameters: NONE
 */

void _ISR_Handler_initialization( void )
{
  _ISR_Signals_to_thread_executing = FALSE;
   45fb0:	13c0 0005 6df0 	moveb %d0,56df0 <_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(
   45fb6:	4878 0400      	pea 400 <D_BIAS+0x2>                              	<== NOT EXECUTED
   45fba:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

  _CPU_Initialize_vectors();

#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )

  if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) )
   45fbc:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   45fc2:	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(
   45fc6:	23c0 0005 6d1e 	movel %d0,56d1e <_ISR_Vector_table>               	<== NOT EXECUTED

  _CPU_Initialize_vectors();

#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )

  if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) )
   45fcc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45fce:	b2b9 0005 518e 	cmpl 5518e <rtems_minimum_stack_size>,%d1         	<== NOT EXECUTED
   45fd4:	6410           	bccs 45fe6 <_ISR_Handler_initialization+0x4a>     	<== NOT EXECUTED
    _Internal_error_Occurred(
   45fd6:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   45fda:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   45fde:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45fe0:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL
    );

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

  _CPU_Interrupt_stack_high = _Addresses_Add_offset(
   45fea:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   45ff0:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   45ff2:	d2a8 001c      	addl %a0@(28),%d1                                 	<== NOT EXECUTED

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

}
   45ff6:	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(
   45ffa:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

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

}
   45ffc:	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(
   45ffe:	23c1 0005 6c58 	movel %d1,56c58 <_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(
   46004:	23c0 0005 6cb4 	movel %d0,56cb4 <_CPU_Interrupt_stack_low>        	<== NOT EXECUTED

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

}
   4600a:	4e75           	rts

00045f40 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   45f40:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45f44:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45f46:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   45f4a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45f4c:	242e 000c      	movel %fp@(12),%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 );
   45f50:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45f52:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45f54:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   45f56:	222e 0008      	movel %fp@(8),%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 );
   45f5a:	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;
   45f5c:	13c2 0005 6d52 	moveb %d2,56d52 <_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 );
   45f62:	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 );
   45f68:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
  bool                    is_internal,
  uint32_t                the_error
)
{

  _Internal_errors_What_happened.the_source  = the_source;
   45f6a:	23c1 0005 6d4e 	movel %d1,56d4e <_Internal_errors_What_happened>  	<== NOT EXECUTED
  _Internal_errors_What_happened.is_internal = is_internal;
  _Internal_errors_What_happened.the_error   = the_error;
   45f70:	23c3 0005 6d54 	movel %d3,56d54 <_Internal_errors_What_happened+0x6>	<== NOT EXECUTED

  _User_extensions_Fatal( the_source, is_internal, the_error );
   45f76:	4eb9 0004 7a9e 	jsr 47a9e <_User_extensions_Fatal>                	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   45f7c:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   45f7e:	23c0 0005 6e36 	movel %d0,56e36 <_System_state_Current>           	<== NOT EXECUTED

  _System_state_Set( SYSTEM_STATE_FAILED );

  _CPU_Fatal_halt( the_error );
   45f84:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   45f86:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   45f88:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   45f8a:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   45f8c:	223c dead beef 	movel #-559038737,%d1                             	<== NOT EXECUTED
   45f92:	4ac8           	halt                                              	<== NOT EXECUTED
   45f94:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45f9a:	60fe           	bras 45f9a <_Internal_error_Occurred+0x5a>        	<== NOT EXECUTED

00049628 <_Interrupt_Manager_initialization>:
 *
 *  Output parameters: NONE
 */

void _Interrupt_Manager_initialization( void )
{
   49628:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
}
   4962c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4962e:	4e75           	rts

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

Message_queue_Control *_Message_queue_Allocate(void)
{
   54c10:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return (Message_queue_Control *)
   54c14:	4879 0006 ca76 	pea 6ca76 <_Message_queue_Information>            	<== NOT EXECUTED
   54c1a:	4eb9 0005 1278 	jsr 51278 <_Objects_Allocate>                     	<== NOT EXECUTED
    _Objects_Allocate(&_Message_queue_Information);
}
   54c20:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   54c22:	4e75           	rts

00049630 <_Message_queue_Manager_initialization>:
 */

void _Message_queue_Manager_initialization(
  uint32_t   maximum_message_queues
)
{
   49630:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   49634:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   49638:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4963a:	4878 0088      	pea 88 <FP_REGS_SAVED+0x48>                       	<== NOT EXECUTED
   4963e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49642:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   49646:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4964a:	4879 0005 6f9e 	pea 56f9e <_Message_queue_Information>            	<== NOT EXECUTED
   49650:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   49656:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_MESSAGE_QUEUE,
    _Message_queue_MP_Process_packet
  );
#endif

}
   4965c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4965e:	4e75           	rts

0004efb8 <_Message_queue_Translate_core_message_queue_return_code>:
};

rtems_status_code _Message_queue_Translate_core_message_queue_return_code (
  uint32_t   status
)
{
   4efb8:	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];
}
   4efbc:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
};

rtems_status_code _Message_queue_Translate_core_message_queue_return_code (
  uint32_t   status
)
{
   4efc0:	41f9 0006 0a5c 	lea 60a5c <_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];
}
   4efc6:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4efca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4efcc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049e24 <_Objects_API_maximum_class>:
#include <rtems/score/object.h>

int _Objects_API_maximum_class(
  uint32_t api
)
{
   49e24:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49e28:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  switch (api) {
   49e2c:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   49e2e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49e30:	671c           	beqs 49e4e <_Objects_API_maximum_class+0x2a>      	<== NOT EXECUTED
   49e32:	650a           	bcss 49e3e <_Objects_API_maximum_class+0x1a>      	<== NOT EXECUTED
   49e34:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   49e38:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49e3a:	6622           	bnes 49e5e <_Objects_API_maximum_class+0x3a>      	<== NOT EXECUTED
   49e3c:	6014           	bras 49e52 <_Objects_API_maximum_class+0x2e>      	<== NOT EXECUTED
   49e3e:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   49e40:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49e42:	6712           	beqs 49e56 <_Objects_API_maximum_class+0x32>      	<== NOT EXECUTED
   49e44:	123c 0004      	moveb #4,%d1                                      	<== NOT EXECUTED
   49e48:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49e4a:	6612           	bnes 49e5e <_Objects_API_maximum_class+0x3a>      	<== NOT EXECUTED
   49e4c:	600c           	bras 49e5a <_Objects_API_maximum_class+0x36>      	<== NOT EXECUTED
   49e4e:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   49e50:	600e           	bras 49e60 <_Objects_API_maximum_class+0x3c>      	<== NOT EXECUTED
   49e52:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   49e54:	600a           	bras 49e60 <_Objects_API_maximum_class+0x3c>      	<== NOT EXECUTED
   49e56:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
   49e58:	6006           	bras 49e60 <_Objects_API_maximum_class+0x3c>      	<== 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;
   49e5a:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
   49e5c:	6002           	bras 49e60 <_Objects_API_maximum_class+0x3c>      	<== NOT EXECUTED
    case OBJECTS_ITRON_API:
      return OBJECTS_ITRON_CLASSES_LAST;
   49e5e:	70ff           	moveq #-1,%d0                                     	<== NOT EXECUTED
    case OBJECTS_NO_API:
    default:
      break;
  }
  return -1;
}
   49e60:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49e62:	4e75           	rts

0004600c <_Objects_Allocate>:
 */

Objects_Control *_Objects_Allocate(
  Objects_Information *information
)
{
   4600c:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   46010:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   46014:	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 )
   46018:	4aaa 0016      	tstl %a2@(22)                                     	<== NOT EXECUTED
   4601c:	6604           	bnes 46022 <_Objects_Allocate+0x16>               	<== NOT EXECUTED
   4601e:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   46020:	6064           	bras 46086 <_Objects_Allocate+0x7a>               	<== 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 );
   46022:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
   46024:	0682 0000 001e 	addil #30,%d2                                     	<== NOT EXECUTED
   4602a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4602c:	47f9 0004 9a5c 	lea 49a5c <_Chain_Get>,%a3                        	<== NOT EXECUTED
   46032:	4e93           	jsr %a3@                                          	<== NOT EXECUTED

  if ( information->auto_extend ) {
   46034:	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 );
   46036:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED

  if ( information->auto_extend ) {
   46038:	4a2a 0010      	tstb %a2@(16)                                     	<== NOT EXECUTED
   4603c:	6748           	beqs 46086 <_Objects_Allocate+0x7a>               	<== NOT EXECUTED
    /*
     *  If the list is empty then we are out of objects and need to
     *  extend information base.
     */

    if ( !the_object ) {
   4603e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46040:	6614           	bnes 46056 <_Objects_Allocate+0x4a>               	<== NOT EXECUTED
      _Objects_Extend_information( information );
   46042:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46044:	4eb9 0004 60c0 	jsr 460c0 <_Objects_Extend_information>           	<== NOT EXECUTED
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
   4604a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4604c:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
    }

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

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

    if ( the_object ) {
   46052:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46054:	6730           	beqs 46086 <_Objects_Allocate+0x7a>               	<== NOT EXECUTED
      uint32_t   block;

      block = _Objects_Get_index( the_object->id ) -
   46056:	2029 0008      	movel %a1@(8),%d0                                 	<== NOT EXECUTED
   4605a:	222a 0006      	movel %a2@(6),%d1                                 	<== NOT EXECUTED
   4605e:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   46064:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   4606a:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   4606c:	4c6a 0000 0012 	remul %a2@(18),%d0,%d0                            	<== NOT EXECUTED
   46072:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
      information->inactive--;
   46076:	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 ]--;
   4607a:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
      information->inactive--;
   4607c:	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 ]--;
   4607e:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
      information->inactive--;
   46080:	3541 002a      	movew %d1,%a2@(42)                                	<== NOT EXECUTED

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

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

  return the_object;
}
   46086:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   4608c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4608e:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   46090:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046094 <_Objects_Close>:

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

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

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

  _Objects_Namespace_remove( information, the_object );
   460b8:	4ef9 0004 65a0 	jmp 465a0 <_Objects_Namespace_remove>             	<== NOT EXECUTED
	...

000460c0 <_Objects_Extend_information>:
 */

void _Objects_Extend_information(
  Objects_Information *information
)
{
   460c0:	4e56 ffc8      	linkw %fp,#-56                                    	<== NOT EXECUTED
   460c4:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   460c8:	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;
   460cc:	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 )
   460d0:	4281           	clrl %d1                                          	<== NOT EXECUTED
   460d2:	0283 0000 ffff 	andil #65535,%d3                                  	<== NOT EXECUTED
   460d8:	322b 000e      	movew %a3@(14),%d1                                	<== NOT EXECUTED
   460dc:	b681           	cmpl %d1,%d3                                      	<== NOT EXECUTED
   460de:	6308           	blss 460e8 <_Objects_Extend_information+0x28>     	<== NOT EXECUTED
   460e0:	2803           	movel %d3,%d4                                     	<== NOT EXECUTED
   460e2:	4287           	clrl %d7                                          	<== NOT EXECUTED
   460e4:	4285           	clrl %d5                                          	<== NOT EXECUTED
   460e6:	6024           	bras 4610c <_Objects_Extend_information+0x4c>     	<== NOT EXECUTED
    block_count = 0;
  else {
    block_count = information->maximum / information->allocation_size;
   460e8:	202b 0012      	movel %a3@(18),%d0                                	<== NOT EXECUTED
   460ec:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   460ee:	4c40 2002      	remul %d0,%d2,%d2                                 	<== NOT EXECUTED
   460f2:	2e02           	movel %d2,%d7                                     	<== NOT EXECUTED
   460f4:	2803           	movel %d3,%d4                                     	<== NOT EXECUTED
   460f6:	4285           	clrl %d5                                          	<== NOT EXECUTED
   460f8:	600e           	bras 46108 <_Objects_Extend_information+0x48>     	<== NOT EXECUTED

    for ( ; block < block_count; block++ ) {
      if ( information->object_blocks[ block ] == NULL )
   460fa:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED
   460fe:	4ab0 5c00      	tstl %a0@(00000000,%d5:l:4)                       	<== NOT EXECUTED
   46102:	6708           	beqs 4610c <_Objects_Extend_information+0x4c>     	<== NOT EXECUTED
        break;
      else
        index_base += information->allocation_size;
   46104:	d880           	addl %d0,%d4                                      	<== NOT EXECUTED
  if ( information->maximum < minimum_index )
    block_count = 0;
  else {
    block_count = information->maximum / information->allocation_size;

    for ( ; block < block_count; block++ ) {
   46106:	5285           	addql #1,%d5                                      	<== NOT EXECUTED
   46108:	b485           	cmpl %d5,%d2                                      	<== NOT EXECUTED
   4610a:	62ee           	bhis 460fa <_Objects_Extend_information+0x3a>     	<== NOT EXECUTED

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

  if (index_base >= information->maximum ) {
   4610c:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   4610e:	6200 011c      	bhiw 4622c <_Objects_Extend_information+0x16c>    	<== NOT EXECUTED
     *  Up the block count and maximum
     */

    block_count++;

    maximum = information->maximum + information->allocation_size;
   46112:	d2ab 0012      	addl %a3@(18),%d1                                 	<== NOT EXECUTED

    /*
     *  Up the block count and maximum
     */

    block_count++;
   46116:	2407           	movel %d7,%d2                                     	<== NOT EXECUTED
   46118:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED

    maximum = information->maximum + information->allocation_size;
   4611a:	2d41 fff0      	movel %d1,%fp@(-16)                               	<== NOT EXECUTED

    /*
     *  Up the block count and maximum
     */

    block_count++;
   4611e:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   46120:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   46122:	4c02 1800      	mulsl %d2,%d1                                     	<== NOT EXECUTED
   46126:	d083           	addl %d3,%d0                                      	<== NOT EXECUTED

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

    if ( information->auto_extend ) {
   46128:	4a2b 0010      	tstb %a3@(16)                                     	<== NOT EXECUTED
   4612c:	6718           	beqs 46146 <_Objects_Extend_information+0x86>     	<== NOT EXECUTED
      object_blocks = (void**)
   4612e:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   46130:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   46132:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46134:	4eb9 0004 7df0 	jsr 47df0 <_Workspace_Allocate>                   	<== NOT EXECUTED
          block_count *
             (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
          ((maximum + minimum_index) * sizeof(Objects_Control *))
          );

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

    if ( information->auto_extend ) {
      object_blocks = (void**)
   4613c:	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 )
   4613e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46140:	6614           	bnes 46156 <_Objects_Extend_information+0x96>     	<== NOT EXECUTED
   46142:	6000 01be      	braw 46302 <_Objects_Extend_information+0x242>    	<== NOT EXECUTED
        return;
    }
    else {
      object_blocks = (void**)
   46146:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   46148:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   4614a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4614c:	4eb9 0004 7e08 	jsr 47e08 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
   46152:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46154:	2840           	moveal %d0,%a4                                    	<== NOT EXECUTED
    /*
     *  Break the block into the various sections.
     *
     */

    inactive_per_block = (uint32_t *) _Addresses_Add_offset(
   46156:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46158:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   4615a:	2c0c           	movel %a4,%d6                                     	<== NOT EXECUTED
   4615c:	dc80           	addl %d0,%d6                                      	<== NOT EXECUTED
   4615e:	2a46           	moveal %d6,%a5                                    	<== NOT EXECUTED
   46160:	dbc0           	addal %d0,%a5                                     	<== NOT EXECUTED
     *  in the copies.
     */

    block_count--;

    if ( information->maximum > minimum_index ) {
   46162:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46164:	302b 000e      	movew %a3@(14),%d0                                	<== NOT EXECUTED
   46168:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   4616a:	6506           	bcss 46172 <_Objects_Extend_information+0xb2>     	<== NOT EXECUTED
   4616c:	204d           	moveal %a5,%a0                                    	<== NOT EXECUTED
   4616e:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46170:	603e           	bras 461b0 <_Objects_Extend_information+0xf0>     	<== 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,
   46172:	2407           	movel %d7,%d2                                     	<== NOT EXECUTED
   46174:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   46176:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46178:	45f9 0004 b3f4 	lea 4b3f4 <memcpy>,%a2                            	<== NOT EXECUTED
   4617e:	2f2b 0030      	movel %a3@(48),%sp@-                              	<== NOT EXECUTED
   46182:	2f0c           	movel %a4,%sp@-                                   	<== NOT EXECUTED
   46184:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
              information->object_blocks,
              block_count * sizeof(void*) );
      memcpy( inactive_per_block,
   46186:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46188:	2f2b 002c      	movel %a3@(44),%sp@-                              	<== NOT EXECUTED
   4618c:	2f06           	movel %d6,%sp@-                                   	<== NOT EXECUTED
   4618e:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
              information->inactive_per_block,
              block_count * sizeof(uint32_t) );
      memcpy( local_table,
   46190:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46192:	302b 000e      	movew %a3@(14),%d0                                	<== NOT EXECUTED
   46196:	d083           	addl %d3,%d0                                      	<== NOT EXECUTED
   46198:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   4619a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4619c:	2f2b 001a      	movel %a3@(26),%sp@-                              	<== NOT EXECUTED
   461a0:	2f0d           	movel %a5,%sp@-                                   	<== NOT EXECUTED
   461a2:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   461a4:	dffc 0000 0024 	addal #36,%sp                                     	<== NOT EXECUTED
   461aa:	6008           	bras 461b4 <_Objects_Extend_information+0xf4>     	<== NOT EXECUTED
    else {

      /*
       *  Deal with the special case of the 0 to minimum_index
       */
      for ( index = 0; index < minimum_index; index++ ) {
   461ac:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
        local_table[ index ] = NULL;
   461ae:	4298           	clrl %a0@+                                        	<== NOT EXECUTED
    else {

      /*
       *  Deal with the special case of the 0 to minimum_index
       */
      for ( index = 0; index < minimum_index; index++ ) {
   461b0:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   461b2:	62f8           	bhis 461ac <_Objects_Extend_information+0xec>     	<== NOT EXECUTED

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

    object_blocks[block_count] = NULL;
   461b4:	2007           	movel %d7,%d0                                     	<== NOT EXECUTED
   461b6:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
    inactive_per_block[block_count] = 0;
   461b8:	2046           	moveal %d6,%a0                                    	<== NOT EXECUTED
   461ba:	42b0 0800      	clrl %a0@(00000000,%d0:l)                         	<== NOT EXECUTED

    for ( index=index_base ;
          index < ( information->allocation_size + index_base );
   461be:	2204           	movel %d4,%d1                                     	<== NOT EXECUTED

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

    object_blocks[block_count] = NULL;
   461c0:	42b4 0800      	clrl %a4@(00000000,%d0:l)                         	<== NOT EXECUTED
    inactive_per_block[block_count] = 0;

    for ( index=index_base ;
          index < ( information->allocation_size + index_base );
   461c4:	d2ab 0012      	addl %a3@(18),%d1                                 	<== NOT EXECUTED
   461c8:	41f5 4c00      	lea %a5@(00000000,%d4:l:4),%a0                    	<== NOT EXECUTED
   461cc:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   461ce:	6004           	bras 461d4 <_Objects_Extend_information+0x114>    	<== NOT EXECUTED
          index++ ) {
   461d0:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
      local_table[ index ] = NULL;
   461d2:	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 );
   461d4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   461d6:	62f8           	bhis 461d0 <_Objects_Extend_information+0x110>    	<== NOT EXECUTED
          index++ ) {
      local_table[ index ] = NULL;
    }

    _ISR_Disable( level );
   461d8:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   461de:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   461e0:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   461e2:	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(
   461e4:	2013           	movel %a3@,%d0                                    	<== NOT EXECUTED
   461e6:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   461e8:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   461ea:	4281           	clrl %d1                                          	<== NOT EXECUTED
   461ec:	322b 0004      	movew %a3@(4),%d1                                 	<== NOT EXECUTED
   461f0:	761b           	moveq #27,%d3                                     	<== NOT EXECUTED
   461f2:	e7a9           	lsll %d3,%d1                                      	<== NOT EXECUTED
   461f4:	08c0 0010      	bset #16,%d0                                      	<== NOT EXECUTED
   461f8:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   461fa:	326e fff2      	moveaw %fp@(-14),%a1                              	<== NOT EXECUTED
      local_table[ index ] = NULL;
    }

    _ISR_Disable( level );

    old_tables = information->object_blocks;
   461fe:	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(
   46202:	4281           	clrl %d1                                          	<== NOT EXECUTED
   46204:	3209           	movew %a1,%d1                                     	<== NOT EXECUTED
   46206:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   46208:	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;
   4620c:	3749 000e      	movew %a1,%a3@(14)                                	<== NOT EXECUTED

    _ISR_Disable( level );

    old_tables = information->object_blocks;

    information->object_blocks = object_blocks;
   46210:	274c 0030      	movel %a4,%a3@(48)                                	<== NOT EXECUTED
    information->inactive_per_block = inactive_per_block;
   46214:	2746 002c      	movel %d6,%a3@(44)                                	<== NOT EXECUTED
    information->local_table = local_table;
   46218:	274d 001a      	movel %a5,%a3@(26)                                	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        information->maximum
      );

    _ISR_Enable( level );
   4621c:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

    if ( old_tables )
   4621e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46220:	670a           	beqs 4622c <_Objects_Extend_information+0x16c>    	<== NOT EXECUTED
      _Workspace_Free( old_tables );
   46222:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46224:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
   4622a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4622c:	202b 0016      	movel %a3@(22),%d0                                	<== NOT EXECUTED
   46230:	41eb 0012      	lea %a3@(18),%a0                                  	<== NOT EXECUTED
   46234:	4c10 0800      	mulsl %a0@,%d0                                    	<== NOT EXECUTED
   46238:	2405           	movel %d5,%d2                                     	<== NOT EXECUTED
   4623a:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED

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

  if ( information->auto_extend ) {
   4623c:	4a2b 0010      	tstb %a3@(16)                                     	<== NOT EXECUTED
   46240:	6720           	beqs 46262 <_Objects_Extend_information+0x1a2>    	<== NOT EXECUTED
    information->object_blocks[ block ] =
   46242:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46244:	246b 0030      	moveal %a3@(48),%a2                               	<== NOT EXECUTED
   46248:	4eb9 0004 7df0 	jsr 47df0 <_Workspace_Allocate>                   	<== NOT EXECUTED
      _Workspace_Allocate(
        (information->allocation_size * information->size)
      );

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

  if ( information->auto_extend ) {
    information->object_blocks[ block ] =
   46252:	d5c2           	addal %d2,%a2                                     	<== NOT EXECUTED
   46254:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      _Workspace_Allocate(
        (information->allocation_size * information->size)
      );

    if ( !information->object_blocks[ block ] )
   46256:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46258:	4ab0 2800      	tstl %a0@(00000000,%d2:l)                         	<== NOT EXECUTED
   4625c:	6616           	bnes 46274 <_Objects_Extend_information+0x1b4>    	<== NOT EXECUTED
   4625e:	6000 00a2      	braw 46302 <_Objects_Extend_information+0x242>    	<== NOT EXECUTED
      return;
  }
  else {
    information->object_blocks[ block ] =
   46262:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46264:	246b 0030      	moveal %a3@(48),%a2                               	<== NOT EXECUTED
   46268:	4eb9 0004 7e08 	jsr 47e08 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
   4626e:	d5c2           	addal %d2,%a2                                     	<== NOT EXECUTED
   46270:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46272:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED

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

  _Chain_Initialize(
   46274:	2f2b 0016      	movel %a3@(22),%sp@-                              	<== NOT EXECUTED
   46278:	206b 0030      	moveal %a3@(48),%a0                               	<== NOT EXECUTED
   4627c:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   4627e:	2f2b 0012      	movel %a3@(18),%sp@-                              	<== NOT EXECUTED
   46282:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   46284:	2f30 3800      	movel %a0@(00000000,%d3:l),%sp@-                  	<== NOT EXECUTED
   46288:	200e           	movel %fp,%d0                                     	<== NOT EXECUTED
   4628a:	0680 ffff fff4 	addil #-12,%d0                                    	<== NOT EXECUTED
   46290:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   46292:	2404           	movel %d4,%d2                                     	<== 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 ) {
   46294:	2a00           	movel %d0,%d5                                     	<== NOT EXECUTED

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

  _Chain_Initialize(
   46296:	4eb9 0004 9a90 	jsr 49a90 <_Chain_Initialize>                     	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   4629c:	280b           	movel %a3,%d4                                     	<== NOT EXECUTED
   4629e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   462a4:	0684 0000 001e 	addil #30,%d4                                     	<== 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 ) {
   462aa:	49f9 0004 9a5c 	lea 49a5c <_Chain_Get>,%a4                        	<== NOT EXECUTED
        information->the_class,
        _Objects_Local_node,
        index
      );

    _Chain_Append( &information->Inactive, &the_object->Node );
   462b0:	45f9 0004 58a8 	lea 458a8 <_Chain_Append>,%a2                     	<== NOT EXECUTED
   462b6:	6026           	bras 462de <_Objects_Extend_information+0x21e>    	<== NOT EXECUTED

  index = index_base;

  while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) {

    the_object->id = _Objects_Build_id(
   462b8:	2013           	movel %a3@,%d0                                    	<== NOT EXECUTED
   462ba:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   462bc:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   462be:	4281           	clrl %d1                                          	<== NOT EXECUTED
   462c0:	322b 0004      	movew %a3@(4),%d1                                 	<== NOT EXECUTED
   462c4:	7c1b           	moveq #27,%d6                                     	<== NOT EXECUTED
   462c6:	eda9           	lsll %d6,%d1                                      	<== NOT EXECUTED
   462c8:	08c0 0010      	bset #16,%d0                                      	<== NOT EXECUTED
   462cc:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   462ce:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   462d0:	2140 0008      	movel %d0,%a0@(8)                                 	<== NOT EXECUTED
        index
      );

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

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

    _Chain_Append( &information->Inactive, &the_object->Node );
   462d6:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   462d8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   462da:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

    index++;
   462dc:	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 ) {
   462de:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   462e0:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   462e2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   462e4:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   462e6:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   462e8:	66ce           	bnes 462b8 <_Objects_Extend_information+0x1f8>    	<== NOT EXECUTED
    _Chain_Append( &information->Inactive, &the_object->Node );

    index++;
  }

  information->inactive_per_block[ block ] = information->allocation_size;
   462ea:	206b 002c      	moveal %a3@(44),%a0                               	<== NOT EXECUTED
   462ee:	43eb 0012      	lea %a3@(18),%a1                                  	<== NOT EXECUTED
   462f2:	2191 3800      	movel %a1@,%a0@(00000000,%d3:l)                   	<== NOT EXECUTED
  information->inactive += information->allocation_size;
   462f6:	302b 002a      	movew %a3@(42),%d0                                	<== NOT EXECUTED
   462fa:	d0ab 0012      	addl %a3@(18),%d0                                 	<== NOT EXECUTED
   462fe:	3740 002a      	movew %d0,%a3@(42)                                	<== NOT EXECUTED
}
   46302:	4cee 3cfc ffc8 	moveml %fp@(-56),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   46308:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4630a:	4e75           	rts

0004630c <_Objects_Free>:

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

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

  _Chain_Append( &information->Inactive, &the_object->Node );
   46322:	486a 001e      	pea %a2@(30)                                      	<== NOT EXECUTED
   46326:	4eb9 0004 58a8 	jsr 458a8 <_Chain_Append>                         	<== NOT EXECUTED

  if ( information->auto_extend ) {
   4632c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4632e:	4a2a 0010      	tstb %a2@(16)                                     	<== NOT EXECUTED
   46332:	6752           	beqs 46386 <_Objects_Free+0x7a>                   	<== NOT EXECUTED
    uint32_t    block;

    block =
   46334:	202b 0008      	movel %a3@(8),%d0                                 	<== NOT EXECUTED
   46338:	222a 0006      	movel %a2@(6),%d1                                 	<== NOT EXECUTED
   4633c:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   46342:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   46348:	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 ]++;
   4634a:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
   4634e:	4c6a 0000 0012 	remul %a2@(18),%d0,%d0                            	<== NOT EXECUTED
   46354:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   46356:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
    information->inactive++;
   46358:	302a 002a      	movew %a2@(42),%d0                                	<== NOT EXECUTED
   4635c:	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 ) ) ) {
   4635e:	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 ]++;
   46360:	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 ) ) ) {
   46362:	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++;
   46364:	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 ) ) ) {
   46368:	d282           	addl %d2,%d1                                      	<== NOT EXECUTED
   4636a:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   46370:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46372:	6412           	bccs 46386 <_Objects_Free+0x7a>                   	<== NOT EXECUTED
      _Objects_Shrink_information( information );
   46374:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
    }
  }
}
   46378:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   4637e:	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 );
   46380:	4ef9 0004 6648 	jmp 46648 <_Objects_Shrink_information>           	<== NOT EXECUTED
    }
  }
}
   46386:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   4638c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4638e:	4e75           	rts

0004646c <_Objects_Get>:
Objects_Control *_Objects_Get(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   4646c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46470:	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;
   46474:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46476:	92a8 0006      	subl %a0@(6),%d1                                  	<== NOT EXECUTED
Objects_Control *_Objects_Get(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   4647a:	2f0a           	movel %a2,%sp@-                                   	<== 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;
   4647c:	d2ae 000c      	addl %fp@(12),%d1                                 	<== NOT EXECUTED
Objects_Control *_Objects_Get(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   46480:	246e 0010      	moveal %fp@(16),%a2                               	<== 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 ) {
   46484:	4280           	clrl %d0                                          	<== NOT EXECUTED
Objects_Control *_Objects_Get(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   46486:	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 ) {
   46488:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   4648c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4648e:	6524           	bcss 464b4 <_Objects_Get+0x48>                    	<== NOT EXECUTED
   46490:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46496:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46498:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    _Thread_Disable_dispatch();
    if ( (the_object = information->local_table[ index ]) != NULL ) {
   4649e:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   464a2:	2430 1c00      	movel %a0@(00000000,%d1:l:4),%d2                  	<== NOT EXECUTED
   464a6:	6704           	beqs 464ac <_Objects_Get+0x40>                    	<== NOT EXECUTED
      *location = OBJECTS_LOCAL;
   464a8:	4292           	clrl %a2@                                         	<== NOT EXECUTED
   464aa:	600e           	bras 464ba <_Objects_Get+0x4e>                    	<== NOT EXECUTED

    /*
     *  Valid Id for this API, Class and Node but the object has not
     *  been allocated yet.
     */
    _Thread_Enable_dispatch();
   464ac:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   464b2:	6002           	bras 464b6 <_Objects_Get+0x4a>                    	<== 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;
   464b4:	4282           	clrl %d2                                          	<== NOT EXECUTED
   464b6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   464b8:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   464ba:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   464bc:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   464c0:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   464c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   464c6:	4e75           	rts

000463bc <_Objects_Get_information>:

Objects_Information *_Objects_Get_information(
  Objects_APIs   the_api,
  uint32_t       the_class
)
{
   463bc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   463c0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   463c2:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   463c6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   463c8:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
  uint32_t   the_api
)
{
  if ( !the_api || the_api > OBJECTS_APIS_LAST )
   463cc:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   463ce:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   463d0:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   463d2:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   463d4:	6530           	bcss 46406 <_Objects_Get_information+0x4a>        	<== NOT EXECUTED
   463d6:	603e           	bras 46416 <_Objects_Get_information+0x5a>        	<== NOT EXECUTED
    return NULL;

  if ( !the_class )
    return NULL;

  the_class_api_maximum = _Objects_API_maximum_class( the_api );
   463d8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   463da:	4eb9 0004 9e24 	jsr 49e24 <_Objects_API_maximum_class>            	<== NOT EXECUTED
  if ( the_class_api_maximum < 0 ||
   463e0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   463e2:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   463e4:	6d20           	blts 46406 <_Objects_Get_information+0x4a>        	<== NOT EXECUTED
   463e6:	b083           	cmpl %d3,%d0                                      	<== NOT EXECUTED
   463e8:	651c           	bcss 46406 <_Objects_Get_information+0x4a>        	<== NOT EXECUTED
       the_class > (uint32_t) the_class_api_maximum )
    return NULL;

  if ( !_Objects_Information_table[ the_api ] )
   463ea:	41f9 0005 6c5c 	lea 56c5c <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   463f0:	2070 2c00      	moveal %a0@(00000000,%d2:l:4),%a0                 	<== NOT EXECUTED
   463f4:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   463f6:	670e           	beqs 46406 <_Objects_Get_information+0x4a>        	<== NOT EXECUTED
    return NULL;

  info = _Objects_Information_table[ the_api ][ the_class ];
   463f8:	2070 3c00      	moveal %a0@(00000000,%d3:l:4),%a0                 	<== NOT EXECUTED
  if ( !info )
   463fc:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   463fe:	6708           	beqs 46408 <_Objects_Get_information+0x4c>        	<== 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 )
   46400:	4a68 000e      	tstw %a0@(14)                                     	<== NOT EXECUTED
   46404:	6602           	bnes 46408 <_Objects_Get_information+0x4c>        	<== NOT EXECUTED
   46406:	91c8           	subal %a0,%a0                                     	<== NOT EXECUTED
      return NULL;
  #endif

  return info;
}
   46408:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4640c:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
   46410:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46412:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   46414:	4e75           	rts                                               	<== NOT EXECUTED
  int the_class_api_maximum;

  if ( !_Objects_Is_api_valid( the_api ) )
    return NULL;

  if ( !the_class )
   46416:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   46418:	67ec           	beqs 46406 <_Objects_Get_information+0x4a>        	<== NOT EXECUTED
   4641a:	60bc           	bras 463d8 <_Objects_Get_information+0x1c>        	<== NOT EXECUTED

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

Objects_Information *_Objects_Get_information_id(
  Objects_Id  id
)
{
   46390:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46394:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   46398:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  return _Objects_Get_information(
   4639a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4639c:	741b           	moveq #27,%d2                                     	<== NOT EXECUTED
   4639e:	e4a9           	lsrl %d2,%d1                                      	<== NOT EXECUTED
   463a0:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   463a2:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   463a4:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   463a6:	143c 0007      	moveb #7,%d2                                      	<== NOT EXECUTED
   463aa:	c480           	andl %d0,%d2                                      	<== NOT EXECUTED
   463ac:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   463ae:	4eb9 0004 63bc 	jsr 463bc <_Objects_Get_information>              	<== NOT EXECUTED
    _Objects_Get_API( id ),
    _Objects_Get_class( id )
  );
}
   463b4:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   463b8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   463ba:	4e75           	rts

0004641c <_Objects_Get_isr_disable>:
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location,
  ISR_Level           *level_p
)
{
   4641c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46420:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46422:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   46426:	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;
   4642a:	4282           	clrl %d2                                          	<== NOT EXECUTED
  /* This should work but doesn't always :( */
  /* index = (uint16_t  ) id; */
#endif

  _ISR_Disable( level );
   4642c:	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;
   46432:	342e 000e      	movew %fp@(14),%d2                                	<== NOT EXECUTED
  /* This should work but doesn't always :( */
  /* index = (uint16_t  ) id; */
#endif

  _ISR_Disable( level );
   46436:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   46438:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4643a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  if ( information->maximum >= index ) {
   4643c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4643e:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   46442:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   46444:	6218           	bhis 4645e <_Objects_Get_isr_disable+0x42>        	<== NOT EXECUTED
    if ( (the_object = information->local_table[ index ]) != NULL ) {
   46446:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   4644a:	2030 2c00      	movel %a0@(00000000,%d2:l:4),%d0                  	<== NOT EXECUTED
   4644e:	670a           	beqs 4645a <_Objects_Get_isr_disable+0x3e>        	<== NOT EXECUTED
      *location = OBJECTS_LOCAL;
      *level_p = level;
   46450:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
#endif

  _ISR_Disable( level );
  if ( information->maximum >= index ) {
    if ( (the_object = information->local_table[ index ]) != NULL ) {
      *location = OBJECTS_LOCAL;
   46454:	4291           	clrl %a1@                                         	<== NOT EXECUTED
      *level_p = level;
   46456:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
   46458:	600c           	bras 46466 <_Objects_Get_isr_disable+0x4a>        	<== NOT EXECUTED
      return the_object;
    }
    _ISR_Enable( level );
   4645a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4645c:	6004           	bras 46462 <_Objects_Get_isr_disable+0x46>        	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
    return NULL;
  }
  _ISR_Enable( level );
   4645e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  *location = OBJECTS_ERROR;
   46460:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46462:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46464:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
  _Objects_MP_Is_remote( information, id, location, &the_object );
  return the_object;
#else
  return NULL;
#endif
}
   46466:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   46468:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4646a:	4e75           	rts

0004faa0 <_Objects_Get_name_as_string>:
char *_Objects_Get_name_as_string(
  Objects_Id        id,
  size_t            length,
  char             *name
)
{
   4faa0:	4e56 ffdc      	linkw %fp,#-36                                    	<== NOT EXECUTED
   4faa4:	48d7 0c3c      	moveml %d2-%d5/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4faa8:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4faac:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
   4fab0:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
  char                   lname[5];
  Objects_Control       *the_object;
  Objects_Locations      location;
  Objects_Id             tmpId;

  if ( length == 0 )
   4fab4:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   4fab6:	6700 00c6      	beqw 4fb7e <_Objects_Get_name_as_string+0xde>     	<== NOT EXECUTED
    return NULL;

  if ( name == NULL )
   4faba:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4fabc:	6700 00c2      	beqw 4fb80 <_Objects_Get_name_as_string+0xe0>     	<== NOT EXECUTED
    return NULL;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   4fac0:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4fac2:	6704           	beqs 4fac8 <_Objects_Get_name_as_string+0x28>     	<== NOT EXECUTED
   4fac4:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4fac6:	600a           	bras 4fad2 <_Objects_Get_name_as_string+0x32>     	<== NOT EXECUTED
   4fac8:	2079 0006 2a4a 	moveal 62a4a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   4face:	2428 0008      	movel %a0@(8),%d2                                 	<== NOT EXECUTED

  information = _Objects_Get_information_id( tmpId );
   4fad2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4fad4:	4eb9 0004 9f4c 	jsr 49f4c <_Objects_Get_information_id>           	<== NOT EXECUTED
  if ( !information )
   4fada:	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 );
   4fadc:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
  if ( !information )
   4fade:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4fae0:	6700 009c      	beqw 4fb7e <_Objects_Get_name_as_string+0xde>     	<== NOT EXECUTED
    return NULL;

  the_object = _Objects_Get( information, tmpId, &location );
   4fae4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4fae8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4faea:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4faec:	4eb9 0004 a028 	jsr 4a028 <_Objects_Get>                          	<== NOT EXECUTED
  switch ( location ) {
   4faf2:	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 );
   4faf8:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   4fafa:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4fafe:	667e           	bnes 4fb7e <_Objects_Get_name_as_string+0xde>     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      return NULL;

    case OBJECTS_LOCAL:

      if ( information->is_string ) {
   4fb00:	4a2a 0034      	tstb %a2@(52)                                     	<== NOT EXECUTED
   4fb04:	670c           	beqs 4fb12 <_Objects_Get_name_as_string+0x72>     	<== NOT EXECUTED
        s = the_object->name.name_p;
   4fb06:	2668 000c      	moveal %a0@(12),%a3                               	<== NOT EXECUTED
        lname[ 4 ] = '\0';
        s = lname;
      }

      d = name;
      if ( s ) {
   4fb0a:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4fb0c:	6632           	bnes 4fb40 <_Objects_Get_name_as_string+0xa0>     	<== NOT EXECUTED
   4fb0e:	2444           	moveal %d4,%a2                                    	<== NOT EXECUTED
   4fb10:	6062           	bras 4fb74 <_Objects_Get_name_as_string+0xd4>     	<== 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;
   4fb12:	2028 000c      	movel %a0@(12),%d0                                	<== NOT EXECUTED

        lname[ 0 ] = (u32_name >> 24) & 0xff;
   4fb16:	7418           	moveq #24,%d2                                     	<== NOT EXECUTED
   4fb18:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4fb1a:	e4a9           	lsrl %d2,%d1                                      	<== NOT EXECUTED
        lname[ 1 ] = (u32_name >> 16) & 0xff;
   4fb1c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;
   4fb1e:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;
   4fb20:	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;
   4fb24:	4242           	clrw %d2                                          	<== NOT EXECUTED
   4fb26:	4842           	swap %d2                                          	<== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;
   4fb28:	e08b           	lsrl #8,%d3                                       	<== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;
        lname[ 4 ] = '\0';
   4fb2a:	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;
   4fb2c:	1d41 fff7      	moveb %d1,%fp@(-9)                                	<== NOT EXECUTED
        lname[ 1 ] = (u32_name >> 16) & 0xff;
   4fb30:	1d42 fff8      	moveb %d2,%fp@(-8)                                	<== NOT EXECUTED
        lname[ 2 ] = (u32_name >>  8) & 0xff;
   4fb34:	1d43 fff9      	moveb %d3,%fp@(-7)                                	<== NOT EXECUTED
        lname[ 3 ] = (u32_name >>  0) & 0xff;
        lname[ 4 ] = '\0';
   4fb38:	1d40 fffb      	moveb %d0,%fp@(-5)                                	<== NOT EXECUTED
   4fb3c:	47ee fff7      	lea %fp@(-9),%a3                                  	<== NOT EXECUTED
        s = lname;
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   4fb40:	2405           	movel %d5,%d2                                     	<== NOT EXECUTED
   4fb42:	5382           	subql #1,%d2                                      	<== NOT EXECUTED

        lname[ 0 ] = (u32_name >> 24) & 0xff;
        lname[ 1 ] = (u32_name >> 16) & 0xff;
        lname[ 2 ] = (u32_name >>  8) & 0xff;
        lname[ 3 ] = (u32_name >>  0) & 0xff;
        lname[ 4 ] = '\0';
   4fb44:	2444           	moveal %d4,%a2                                    	<== NOT EXECUTED
   4fb46:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   4fb48:	601a           	bras 4fb64 <_Objects_Get_name_as_string+0xc4>     	<== NOT EXECUTED
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
          *d = (isprint(*s)) ? *s : '*';
   4fb4a:	2079 0006 0c5c 	moveal 60c5c <__ctype_ptr>,%a0                    	<== NOT EXECUTED
   4fb50:	1030 0800      	moveb %a0@(00000000,%d0:l),%d0                    	<== NOT EXECUTED
   4fb54:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4fb56:	0280 0000 0097 	andil #151,%d0                                    	<== NOT EXECUTED
   4fb5c:	6602           	bnes 4fb60 <_Objects_Get_name_as_string+0xc0>     	<== NOT EXECUTED
   4fb5e:	722a           	moveq #42,%d1                                     	<== NOT EXECUTED
   4fb60:	14c1           	moveb %d1,%a2@+                                   	<== NOT EXECUTED
        s = lname;
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   4fb62:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
   4fb64:	b489           	cmpl %a1,%d2                                      	<== NOT EXECUTED
   4fb66:	630c           	blss 4fb74 <_Objects_Get_name_as_string+0xd4>     	<== NOT EXECUTED
   4fb68:	1233 9800      	moveb %a3@(00000000,%a1:l),%d1                    	<== NOT EXECUTED
          *d = (isprint(*s)) ? *s : '*';
   4fb6c:	1001           	moveb %d1,%d0                                     	<== NOT EXECUTED
   4fb6e:	49c0           	extbl %d0                                         	<== NOT EXECUTED
        s = lname;
      }

      d = name;
      if ( s ) {
        for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) {
   4fb70:	4a01           	tstb %d1                                          	<== NOT EXECUTED
   4fb72:	66d6           	bnes 4fb4a <_Objects_Get_name_as_string+0xaa>     	<== NOT EXECUTED
          *d = (isprint(*s)) ? *s : '*';
        }
      }
      *d = '\0';
   4fb74:	4212           	clrb %a2@                                         	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   4fb76:	4eb9 0004 a87a 	jsr 4a87a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4fb7c:	6002           	bras 4fb80 <_Objects_Get_name_as_string+0xe0>     	<== NOT EXECUTED
      return name;
   4fb7e:	4284           	clrl %d4                                          	<== NOT EXECUTED
  }
  return NULL;                  /* unreachable path */
}
   4fb80:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   4fb82:	4cee 0c3c ffdc 	moveml %fp@(-36),%d2-%d5/%a2-%a3                  	<== NOT EXECUTED
   4fb88:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4fb8a:	4e75           	rts

00052104 <_Objects_Get_next>:
    Objects_Information *information,
    Objects_Id           id,
    Objects_Locations   *location_p,
    Objects_Id          *next_id_p
)
{
   52104:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   52108:	48d7 3c04      	moveml %d2/%a2-%a5,%sp@                           	<== NOT EXECUTED
   5210c:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   52110:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   52114:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   52118:	2a6e 0014      	moveal %fp@(20),%a5                               	<== NOT EXECUTED
    Objects_Control *object;
    Objects_Id       next_id;

    if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX)
   5211c:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   5211e:	6704           	beqs 52124 <_Objects_Get_next+0x20>               	<== NOT EXECUTED
   52120:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   52122:	6004           	bras 52128 <_Objects_Get_next+0x24>               	<== NOT EXECUTED
        next_id = information->minimum_id;
   52124:	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);
   52128:	49f9 0004 a028 	lea 4a028 <_Objects_Get>,%a4                      	<== NOT EXECUTED
    else
        next_id = id;

    do {
        /* walked off end of list? */
        if (_Objects_Get_index(next_id) > information->maximum)
   5212e:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   52130:	4280           	clrl %d0                                          	<== NOT EXECUTED
   52132:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   52138:	302b 000e      	movew %a3@(14),%d0                                	<== NOT EXECUTED
   5213c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   5213e:	640c           	bccs 5214c <_Objects_Get_next+0x48>               	<== NOT EXECUTED
        {
            *location_p = OBJECTS_ERROR;
   52140:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED

    *next_id_p = next_id;
    return object;

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

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

    *next_id_p = next_id;
    return object;

final:
    *next_id_p = OBJECTS_ID_FINAL;
   52146:	4280           	clrl %d0                                          	<== NOT EXECUTED
   52148:	2a81           	movel %d1,%a5@                                    	<== NOT EXECUTED
   5214a:	6016           	bras 52162 <_Objects_Get_next+0x5e>               	<== NOT EXECUTED
            *location_p = OBJECTS_ERROR;
            goto final;
        }

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

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

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

        next_id++;

    } while (*location_p != OBJECTS_LOCAL);
   52156:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5215c:	4a92           	tstl %a2@                                         	<== NOT EXECUTED
   5215e:	66ce           	bnes 5212e <_Objects_Get_next+0x2a>               	<== NOT EXECUTED

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

final:
    *next_id_p = OBJECTS_ID_FINAL;
    return 0;
}
   52162:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   52168:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5216a:	4e75           	rts

000516d8 <_Objects_Get_no_protection>:
Objects_Control *_Objects_Get_no_protection(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   516d8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   516dc:	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;
   516e0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   516e2:	92a8 0006      	subl %a0@(6),%d1                                  	<== NOT EXECUTED
   516e6:	d2ae 000c      	addl %fp@(12),%d1                                 	<== NOT EXECUTED
Objects_Control *_Objects_Get_no_protection(
  Objects_Information *information,
  Objects_Id           id,
  Objects_Locations   *location
)
{
   516ea:	226e 0010      	moveal %fp@(16),%a1                               	<== 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;

  if ( information->maximum >= index ) {
   516ee:	4280           	clrl %d0                                          	<== NOT EXECUTED
   516f0:	3028 000e      	movew %a0@(14),%d0                                	<== NOT EXECUTED
   516f4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   516f6:	620e           	bhis 51706 <_Objects_Get_no_protection+0x2e>      	<== NOT EXECUTED
    if ( (the_object = information->local_table[ index ]) != NULL ) {
   516f8:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   516fc:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   51700:	6704           	beqs 51706 <_Objects_Get_no_protection+0x2e>      	<== NOT EXECUTED
      *location = OBJECTS_LOCAL;
   51702:	4291           	clrl %a1@                                         	<== NOT EXECUTED
   51704:	6006           	bras 5170c <_Objects_Get_no_protection+0x34>      	<== 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;
   51706:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   51708:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5170a:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
  return NULL;
}
   5170c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5170e:	4e75           	rts

00046640 <_Objects_Handler_initialization>:
  uint32_t   maximum_nodes,
  uint32_t   maximum_global_objects )
#else
void _Objects_Handler_initialization(void)
#endif
{
   46640:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
    node,
    maximum_nodes,
    maximum_global_objects
  );
#endif
}
   46644:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46646:	4e75           	rts

000471a0 <_Objects_Id_to_name>:

Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
  Objects_Id      id,
  Objects_Name   *name
)
{
   471a0:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   471a4:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   471a8:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   471ac:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Objects_Id           tmpId;
  Objects_Information *information;
  Objects_Control     *the_object = (Objects_Control *) 0;
  Objects_Locations    ignored_location;

  if ( !name )
   471b0:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   471b2:	6604           	bnes 471b8 <_Objects_Id_to_name+0x18>             	<== NOT EXECUTED
   471b4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   471b6:	6068           	bras 47220 <_Objects_Id_to_name+0x80>             	<== NOT EXECUTED
    return OBJECTS_INVALID_NAME;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   471b8:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   471ba:	6704           	beqs 471c0 <_Objects_Id_to_name+0x20>             	<== NOT EXECUTED
   471bc:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   471be:	600a           	bras 471ca <_Objects_Id_to_name+0x2a>             	<== NOT EXECUTED
   471c0:	2079 0005 8e5a 	moveal 58e5a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   471c6:	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);
   471ca:	7018           	moveq #24,%d0                                     	<== NOT EXECUTED
   471cc:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   471ce:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   471d0:	7607           	moveq #7,%d3                                      	<== NOT EXECUTED
   471d2:	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 )
   471d4:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   471d6:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   471d8:	163c 0003      	moveb #3,%d3                                      	<== NOT EXECUTED
   471dc:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   471de:	653e           	bcss 4721e <_Objects_Id_to_name+0x7e>             	<== NOT EXECUTED
   471e0:	6048           	bras 4722a <_Objects_Id_to_name+0x8a>             	<== NOT EXECUTED
  if ( !_Objects_Information_table[ the_api ] )
    return OBJECTS_INVALID_ID;

  the_class = _Objects_Get_class( tmpId );

  information = _Objects_Information_table[ the_api ][ the_class ];
   471e2:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   471e4:	721b           	moveq #27,%d1                                     	<== NOT EXECUTED
   471e6:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   471e8:	2070 0c00      	moveal %a0@(00000000,%d0:l:4),%a0                 	<== NOT EXECUTED
  if ( !information )
   471ec:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   471ee:	672e           	beqs 4721e <_Objects_Id_to_name+0x7e>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  if ( information->is_string )
   471f0:	4a28 0034      	tstb %a0@(52)                                     	<== NOT EXECUTED
   471f4:	6628           	bnes 4721e <_Objects_Id_to_name+0x7e>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  the_object = _Objects_Get( information, tmpId, &ignored_location );
   471f6:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   471fa:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   471fc:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   471fe:	4eb9 0004 7144 	jsr 47144 <_Objects_Get>                          	<== NOT EXECUTED
  if ( !the_object )
   47204:	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 );
   4720a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( !the_object )
   4720c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4720e:	670e           	beqs 4721e <_Objects_Id_to_name+0x7e>             	<== NOT EXECUTED
    return OBJECTS_INVALID_ID;

  *name = the_object->name;
   47210:	24a8 000c      	movel %a0@(12),%a2@                               	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   47214:	4eb9 0004 79c2 	jsr 479c2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4721a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4721c:	6002           	bras 47220 <_Objects_Id_to_name+0x80>             	<== NOT EXECUTED
  return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
   4721e:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
}
   47220:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   47226:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47228:	4e75           	rts                                               	<== 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 ] )
   4722a:	41f9 0005 8d54 	lea 58d54 <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   47230:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
   47234:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47236:	66aa           	bnes 471e2 <_Objects_Id_to_name+0x42>             	<== NOT EXECUTED
   47238:	60e4           	bras 4721e <_Objects_Id_to_name+0x7e>             	<== NOT EXECUTED
	...

000464c8 <_Objects_Initialize_information>:
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   464c8:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   464cc:	48d7 007c      	moveml %d2-%d6,%sp@                               	<== NOT EXECUTED
   464d0:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   464d4:	282e 0014      	movel %fp@(20),%d4                                	<== NOT EXECUTED
   464d8:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED

  /*
   *  Set the entry in the object information table.
   */

  _Objects_Information_table[ the_api ][ the_class ] = information;
   464dc:	41f9 0005 6c5c 	lea 56c5c <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   464e2:	2070 0c00      	moveal %a0@(00000000,%d0:l:4),%a0                 	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   464e6:	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;
   464ea:	2c04           	movel %d4,%d6                                     	<== NOT EXECUTED
   464ec:	0886 001f      	bclr #31,%d6                                      	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   464f0:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
  uint32_t                name_length;
#if defined(RTEMS_MULTIPROCESSING)
  uint32_t                index;
#endif

  information->the_api            = the_api;
   464f2:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   464f4:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   464f6:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   464f8:	56c3           	sne %d3                                           	<== NOT EXECUTED
   464fa:	123c 001b      	moveb #27,%d1                                     	<== NOT EXECUTED

  /*
   *  Set the entry in the object information table.
   */

  _Objects_Information_table[ the_api ][ the_class ] = information;
   464fe:	2189 2c00      	movel %a1,%a0@(00000000,%d2:l:4)                  	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  uint32_t                index;
#endif

  information->the_api            = the_api;
  information->the_class          = the_class;
   46502:	3342 0004      	movew %d2,%a1@(4)                                 	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   46506:	2a2e 0020      	movel %fp@(32),%d5                                	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   4650a:	e3aa           	lsll %d1,%d2                                      	<== NOT EXECUTED
   4650c:	08c0 0010      	bset #16,%d0                                      	<== NOT EXECUTED
   46510:	49c3           	extbl %d3                                         	<== NOT EXECUTED
   46512:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46514:	4483           	negl %d3                                          	<== NOT EXECUTED
   46516:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   46518:	4281           	clrl %d1                                          	<== NOT EXECUTED
   */

  if ( maximum == 0 ) minimum_index = 0;
  else                minimum_index = 1;

  information->minimum_id =
   4651a:	2340 0006      	movel %d0,%a1@(6)                                 	<== NOT EXECUTED
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   4651e:	322e 001a      	movew %fp@(26),%d1                                	<== NOT EXECUTED

  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;

  information->inactive           = 0;
   46522:	4240           	clrw %d0                                          	<== NOT EXECUTED

  /*
   *  Set the size of the object
   */

  information->size = size;
   46524:	2341 0016      	movel %d1,%a1@(22)                                	<== NOT EXECUTED

  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;

  information->inactive           = 0;
   46528:	3340 002a      	movew %d0,%a1@(42)                                	<== NOT EXECUTED

  /*
   *  Are we operating in unlimited, or auto-extend mode
   */

  information->auto_extend =
   4652c:	d884           	addl %d4,%d4                                      	<== NOT EXECUTED
   4652e:	9984           	subxl %d4,%d4                                     	<== NOT EXECUTED
   46530:	4484           	negl %d4                                          	<== NOT EXECUTED
  uint32_t                index;
#endif

  information->the_api            = the_api;
  information->the_class          = the_class;
  information->is_string          = is_string;
   46532:	136e 001f 0034 	moveb %fp@(31),%a1@(52)                           	<== NOT EXECUTED
   *  Calculate the maximum name length
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   46538:	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;
   4653a:	223c 0005 6454 	movel #353364,%d1                                 	<== NOT EXECUTED

  /*
   *  Are we operating in unlimited, or auto-extend mode
   */

  information->auto_extend =
   46540:	1344 0010      	moveb %d4,%a1@(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;
   46544:	42a9 002c      	clrl %a1@(44)                                     	<== NOT EXECUTED
   *  Calculate the maximum name length
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   46548:	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;
   4654a:	2341 001a      	movel %d1,%a1@(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;
   4654e:	42a9 0030      	clrl %a1@(48)                                     	<== NOT EXECUTED

  /*
   *  The allocation unit is the maximum value
   */

  information->allocation_size = maximum;
   46552:	2346 0012      	movel %d6,%a1@(18)                                	<== NOT EXECUTED
   *  Calculate the maximum name length
   */

  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   46556:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46558:	6604           	bnes 4655e <_Objects_Initialize_information+0x96> 	<== NOT EXECUTED
   4655a:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4655c:	6008           	bras 46566 <_Objects_Initialize_information+0x9e> 	<== NOT EXECUTED
    name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
   4655e:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   46560:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   46562:	72fc           	moveq #-4,%d1                                     	<== NOT EXECUTED
   46564:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   46566:	41e9 0022      	lea %a1@(34),%a0                                  	<== NOT EXECUTED
   4656a:	2348 001e      	movel %a0,%a1@(30)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4656e:	41e9 001e      	lea %a1@(30),%a0                                  	<== NOT EXECUTED
                  ~(OBJECTS_NAME_ALIGNMENT-1);

  information->name_length = name_length;
   46572:	3340 0036      	movew %d0,%a1@(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;
   46576:	42a9 0022      	clrl %a1@(34)                                     	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   4657a:	2348 0026      	movel %a0,%a1@(38)                                	<== NOT EXECUTED

  /*
   *  Initialize objects .. if there are any
   */

  if ( maximum ) {
   4657e:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   46580:	6716           	beqs 46598 <_Objects_Initialize_information+0xd0> 	<== 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 );
   46582:	2d49 0008      	movel %a1,%fp@(8)                                 	<== NOT EXECUTED
      _Chain_Initialize_empty( &information->global_table[ index ] );
   }
   else
     information->global_table = NULL;
#endif
}
   46586:	4cd7 007c      	moveml %sp@,%d2-%d6                               	<== NOT EXECUTED
   4658a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    /*
     *  Reset the maximum value. It will be updated when the information is
     *  extended.
     */

    information->maximum = 0;
   4658c:	4240           	clrw %d0                                          	<== NOT EXECUTED
   4658e:	3340 000e      	movew %d0,%a1@(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 );
   46592:	4ef9 0004 60c0 	jmp 460c0 <_Objects_Extend_information>           	<== NOT EXECUTED
      _Chain_Initialize_empty( &information->global_table[ index ] );
   }
   else
     information->global_table = NULL;
#endif
}
   46598:	4cd7 007c      	moveml %sp@,%d2-%d6                               	<== NOT EXECUTED
   4659c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4659e:	4e75           	rts

000465d0 <_Objects_Name_to_id_u32>:
  Objects_Information *information,
  uint32_t             name,
  uint32_t             node,
  Objects_Id          *id
)
{
   465d0:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   465d4:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   465d8:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   465dc:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   465e0:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   465e4:	226e 0014      	moveal %fp@(20),%a1                               	<== NOT EXECUTED
  Objects_Name               name_for_mp;
#endif

  /* ASSERT: information->is_string == FALSE */

  if ( !id )
   465e8:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   465ea:	6604           	bnes 465f0 <_Objects_Name_to_id_u32+0x20>         	<== NOT EXECUTED
   465ec:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   465ee:	6048           	bras 46638 <_Objects_Name_to_id_u32+0x68>         	<== NOT EXECUTED
    return OBJECTS_INVALID_ADDRESS;

  if ( name == 0 )
   465f0:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   465f2:	6742           	beqs 46636 <_Objects_Name_to_id_u32+0x66>         	<== NOT EXECUTED
    return OBJECTS_INVALID_NAME;

  search_local_node = FALSE;

  if ( information->maximum != 0 &&
   465f4:	322a 000e      	movew %a2@(14),%d1                                	<== NOT EXECUTED
   465f8:	673c           	beqs 46636 <_Objects_Name_to_id_u32+0x66>         	<== NOT EXECUTED
   465fa:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   465fc:	672c           	beqs 4662a <_Objects_Name_to_id_u32+0x5a>         	<== NOT EXECUTED
   465fe:	0c80 7fff ffff 	cmpil #2147483647,%d0                             	<== NOT EXECUTED
   46604:	6724           	beqs 4662a <_Objects_Name_to_id_u32+0x5a>         	<== NOT EXECUTED
   46606:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   46608:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   4660a:	662a           	bnes 46636 <_Objects_Name_to_id_u32+0x66>         	<== NOT EXECUTED
   4660c:	601c           	bras 4662a <_Objects_Name_to_id_u32+0x5a>         	<== NOT EXECUTED

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
      the_object = information->local_table[ index ];
   4660e:	206a 001a      	moveal %a2@(26),%a0                               	<== NOT EXECUTED
   46612:	2070 0c00      	moveal %a0@(00000000,%d0:l:4),%a0                 	<== NOT EXECUTED
   search_local_node = TRUE;

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
   46616:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
      the_object = information->local_table[ index ];
      if ( !the_object )
   46618:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4661a:	6716           	beqs 46632 <_Objects_Name_to_id_u32+0x62>         	<== NOT EXECUTED
        continue;

      if ( name == the_object->name.name_u32 ) {
   4661c:	b4a8 000c      	cmpl %a0@(12),%d2                                 	<== NOT EXECUTED
   46620:	6610           	bnes 46632 <_Objects_Name_to_id_u32+0x62>         	<== NOT EXECUTED
        *id = the_object->id;
   46622:	22a8 0008      	movel %a0@(8),%a1@                                	<== NOT EXECUTED
   46626:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46628:	600e           	bras 46638 <_Objects_Name_to_id_u32+0x68>         	<== NOT EXECUTED
   search_local_node = TRUE;

  if ( search_local_node ) {
    name_length = information->name_length;

    for ( index = 1; index <= information->maximum; index++ ) {
   4662a:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   46630:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46632:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46634:	64d8           	bccs 4660e <_Objects_Name_to_id_u32+0x3e>         	<== NOT EXECUTED
   46636:	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
}
   46638:	4cd7 040c      	moveml %sp@,%d2-%d3/%a2                           	<== NOT EXECUTED
   4663c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4663e:	4e75           	rts

000465a0 <_Objects_Namespace_remove>:

void _Objects_Namespace_remove(
  Objects_Information  *information,
  Objects_Control      *the_object
)
{
   465a0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   465a4:	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 )
   465a6:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

void _Objects_Namespace_remove(
  Objects_Information  *information,
  Objects_Control      *the_object
)
{
   465aa:	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 )
   465ae:	4a28 0034      	tstb %a0@(52)                                     	<== NOT EXECUTED
   465b2:	6710           	beqs 465c4 <_Objects_Namespace_remove+0x24>       	<== NOT EXECUTED
   465b4:	202a 000c      	movel %a2@(12),%d0                                	<== NOT EXECUTED
   465b8:	670a           	beqs 465c4 <_Objects_Namespace_remove+0x24>       	<== NOT EXECUTED
     _Workspace_Free( (void *)the_object->name.name_p );
   465ba:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   465bc:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
   465c2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  /*
   * Clear out either format.
   */
  the_object->name.name_p   = NULL;
  the_object->name.name_u32 = 0;
   465c4:	42aa 000c      	clrl %a2@(12)                                     	<== NOT EXECUTED
}
   465c8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   465cc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   465ce:	4e75           	rts

00047e88 <_Objects_Set_name>:
bool _Objects_Set_name(
  Objects_Information *information,
  Objects_Control     *the_object,
  const char          *name
)
{
   47e88:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   47e8c:	48d7 1c1c      	moveml %d2-%d4/%a2-%a4,%sp@                       	<== NOT EXECUTED
   47e90:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  size_t                 length;
  const char            *s;

  s      = name;
  length = strnlen( name, information->name_length ) + 1;
   47e94:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47e96:	302a 0036      	movew %a2@(54),%d0                                	<== NOT EXECUTED
   47e9a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
bool _Objects_Set_name(
  Objects_Information *information,
  Objects_Control     *the_object,
  const char          *name
)
{
   47e9c:	266e 0010      	moveal %fp@(16),%a3                               	<== NOT EXECUTED
   47ea0:	286e 000c      	moveal %fp@(12),%a4                               	<== NOT EXECUTED
  size_t                 length;
  const char            *s;

  s      = name;
  length = strnlen( name, information->name_length ) + 1;
   47ea4:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   47ea6:	4eb9 0004 de68 	jsr 4de68 <strnlen>                               	<== NOT EXECUTED
   47eac:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED

  if ( information->is_string ) {
   47eae:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
{
  size_t                 length;
  const char            *s;

  s      = name;
  length = strnlen( name, information->name_length ) + 1;
   47eb0:	5283           	addql #1,%d3                                      	<== NOT EXECUTED

  if ( information->is_string ) {
   47eb2:	4a2a 0034      	tstb %a2@(52)                                     	<== NOT EXECUTED
   47eb6:	6748           	beqs 47f00 <_Objects_Set_name+0x78>               	<== NOT EXECUTED
    char *d;

    d = _Workspace_Allocate( length );
   47eb8:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47eba:	4eb9 0004 9718 	jsr 49718 <_Workspace_Allocate>                   	<== NOT EXECUTED
    if ( !d )
   47ec0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  length = strnlen( name, information->name_length ) + 1;

  if ( information->is_string ) {
    char *d;

    d = _Workspace_Allocate( length );
   47ec2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
    if ( !d )
   47ec4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47ec6:	6606           	bnes 47ece <_Objects_Set_name+0x46>               	<== NOT EXECUTED
   47ec8:	4200           	clrb %d0                                          	<== NOT EXECUTED
   47eca:	6000 0088      	braw 47f54 <_Objects_Set_name+0xcc>               	<== NOT EXECUTED
      return FALSE;

    if ( the_object->name.name_p ) {
   47ece:	202c 000c      	movel %a4@(12),%d0                                	<== NOT EXECUTED
   47ed2:	670e           	beqs 47ee2 <_Objects_Set_name+0x5a>               	<== NOT EXECUTED
      _Workspace_Free( (void *)the_object->name.name_p );
   47ed4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47ed6:	4eb9 0004 9700 	jsr 49700 <_Workspace_Free>                       	<== NOT EXECUTED
      the_object->name.name_p = NULL;
   47edc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47ede:	42ac 000c      	clrl %a4@(12)                                     	<== NOT EXECUTED
    }

    strncpy( d, name, length );
   47ee2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47ee4:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   47ee6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47ee8:	4eb9 0004 dddc 	jsr 4dddc <strncpy>                               	<== NOT EXECUTED
    d[ length ] = '\0';
   47eee:	4200           	clrb %d0                                          	<== NOT EXECUTED
   47ef0:	1580 3800      	moveb %d0,%a2@(00000000,%d3:l)                    	<== NOT EXECUTED
    the_object->name.name_p = d;
   47ef4:	294a 000c      	movel %a2,%a4@(12)                                	<== NOT EXECUTED
   47ef8:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47efe:	6052           	bras 47f52 <_Objects_Set_name+0xca>               	<== NOT EXECUTED
  } else {
    the_object->name.name_u32 =  _Objects_Build_name(
   47f00:	203c 2000 0000 	movel #536870912,%d0                              	<== NOT EXECUTED
   47f06:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   47f08:	675e           	beqs 47f68 <_Objects_Set_name+0xe0>               	<== NOT EXECUTED
   47f0a:	1013           	moveb %a3@,%d0                                    	<== NOT EXECUTED
   47f0c:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   47f0e:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   47f10:	e3a8           	lsll %d1,%d0                                      	<== NOT EXECUTED
   47f12:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   47f16:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   47f18:	674e           	beqs 47f68 <_Objects_Set_name+0xe0>               	<== NOT EXECUTED
   47f1a:	182b 0001      	moveb %a3@(1),%d4                                 	<== NOT EXECUTED
   47f1e:	49c4           	extbl %d4                                         	<== NOT EXECUTED
   47f20:	4844           	swap %d4                                          	<== NOT EXECUTED
   47f22:	4244           	clrw %d4                                          	<== NOT EXECUTED
   47f24:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   47f28:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   47f2a:	6432           	bccs 47f5e <_Objects_Set_name+0xd6>               	<== NOT EXECUTED
   47f2c:	142b 0002      	moveb %a3@(2),%d2                                 	<== NOT EXECUTED
   47f30:	49c2           	extbl %d2                                         	<== NOT EXECUTED
   47f32:	e18a           	lsll #8,%d2                                       	<== NOT EXECUTED
   47f34:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   47f38:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   47f3a:	6506           	bcss 47f42 <_Objects_Set_name+0xba>               	<== NOT EXECUTED
   47f3c:	123c 0020      	moveb #32,%d1                                     	<== NOT EXECUTED
   47f40:	6006           	bras 47f48 <_Objects_Set_name+0xc0>               	<== NOT EXECUTED
   47f42:	122b 0003      	moveb %a3@(3),%d1                                 	<== NOT EXECUTED
   47f46:	49c1           	extbl %d1                                         	<== NOT EXECUTED
   47f48:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   47f4a:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47f4c:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   47f4e:	2940 000c      	movel %d0,%a4@(12)                                	<== NOT EXECUTED
   47f52:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
    );

  }

  return TRUE;
}
   47f54:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   47f5a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47f5c:	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(
   47f5e:	7220           	moveq #32,%d1                                     	<== NOT EXECUTED
   47f60:	243c 0000 2000 	movel #8192,%d2                                   	<== NOT EXECUTED
   47f66:	60e0           	bras 47f48 <_Objects_Set_name+0xc0>               	<== NOT EXECUTED
   47f68:	7820           	moveq #32,%d4                                     	<== NOT EXECUTED
   47f6a:	4844           	swap %d4                                          	<== NOT EXECUTED
   47f6c:	60f0           	bras 47f5e <_Objects_Set_name+0xd6>               	<== NOT EXECUTED
	...

00046648 <_Objects_Shrink_information>:
 */

void _Objects_Shrink_information(
  Objects_Information *information
)
{
   46648:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4664c:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
   46650:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE uint32_t _Objects_Get_index(
  Objects_Id id
)
{
  return (id >> OBJECTS_INDEX_START_BIT) & OBJECTS_INDEX_VALID_BITS;
   46654:	262a 0006      	movel %a2@(6),%d3                                 	<== 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;
   46658:	242a 0012      	movel %a2@(18),%d2                                	<== NOT EXECUTED
   4665c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4665e:	0283 0000 ffff 	andil #65535,%d3                                  	<== NOT EXECUTED
   46664:	302a 000e      	movew %a2@(14),%d0                                	<== NOT EXECUTED
   46668:	9083           	subl %d3,%d0                                      	<== NOT EXECUTED
   4666a:	4c42 0000      	remul %d2,%d0,%d0                                 	<== NOT EXECUTED
   4666e:	4281           	clrl %d1                                          	<== NOT EXECUTED
   46670:	6074           	bras 466e6 <_Objects_Shrink_information+0x9e>     	<== NOT EXECUTED

  for ( block = 0; block < block_count; block++ ) {
    if ( information->inactive_per_block[ block ] == information->allocation_size ) {
   46672:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
   46676:	b4b0 4800      	cmpl %a0@(00000000,%d4:l),%d2                     	<== NOT EXECUTED
   4667a:	6666           	bnes 466e2 <_Objects_Shrink_information+0x9a>     	<== 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;
   4667c:	206a 001e      	moveal %a2@(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 );
   46680:	47f9 0004 9a34 	lea 49a34 <_Chain_Extract>,%a3                    	<== NOT EXECUTED
   46686:	2228 0008      	movel %a0@(8),%d1                                 	<== NOT EXECUTED
   4668a:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
       */

      do {
        index = _Objects_Get_index( the_object->id );

        if ((index >= index_base) &&
   46690:	b681           	cmpl %d1,%d3                                      	<== NOT EXECUTED
   46692:	6216           	bhis 466aa <_Objects_Shrink_information+0x62>     	<== NOT EXECUTED
   46694:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   46696:	d0aa 0012      	addl %a2@(18),%d0                                 	<== NOT EXECUTED
   4669a:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4669c:	630c           	blss 466aa <_Objects_Shrink_information+0x62>     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_last(
  const Chain_Node *the_node
)
{
  return (the_node->next == NULL);
   4669e:	2410           	movel %a0@,%d2                                    	<== 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 );
   466a0:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   466a2:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   466a4:	2042           	moveal %d2,%a0                                    	<== NOT EXECUTED
   466a6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   466a8:	6002           	bras 466ac <_Objects_Shrink_information+0x64>     	<== NOT EXECUTED
        }
        else {
          the_object = (Objects_Control *) the_object->Node.next;
   466aa:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
        }
      }
      while ( the_object && !_Chain_Is_last( &the_object->Node ) );
   466ac:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   466ae:	6704           	beqs 466b4 <_Objects_Shrink_information+0x6c>     	<== NOT EXECUTED
   466b0:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   466b2:	66d2           	bnes 46686 <_Objects_Shrink_information+0x3e>     	<== NOT EXECUTED

      /*
       *  Free the memory and reset the structures in the object' information
       */

      _Workspace_Free( information->object_blocks[ block ] );
   466b4:	206a 0030      	moveal %a2@(48),%a0                               	<== NOT EXECUTED
   466b8:	2f30 4800      	movel %a0@(00000000,%d4:l),%sp@-                  	<== NOT EXECUTED
   466bc:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
      information->object_blocks[ block ] = NULL;
      information->inactive_per_block[ block ] = 0;
   466c2:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
   466c6:	42b0 4800      	clrl %a0@(00000000,%d4:l)                         	<== NOT EXECUTED
      /*
       *  Free the memory and reset the structures in the object' information
       */

      _Workspace_Free( information->object_blocks[ block ] );
      information->object_blocks[ block ] = NULL;
   466ca:	206a 0030      	moveal %a2@(48),%a0                               	<== NOT EXECUTED
      information->inactive_per_block[ block ] = 0;

      information->inactive -= information->allocation_size;
   466ce:	302a 002a      	movew %a2@(42),%d0                                	<== NOT EXECUTED
   466d2:	90aa 0012      	subl %a2@(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;
   466d6:	42b0 4800      	clrl %a0@(00000000,%d4:l)                         	<== NOT EXECUTED
      information->inactive_per_block[ block ] = 0;

      information->inactive -= information->allocation_size;
   466da:	3540 002a      	movew %d0,%a2@(42)                                	<== NOT EXECUTED
   466de:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   466e0:	600c           	bras 466ee <_Objects_Shrink_information+0xa6>     	<== NOT EXECUTED

      return;
    }

    index_base += information->allocation_size;
   466e2:	d682           	addl %d2,%d3                                      	<== 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++ ) {
   466e4:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   466e6:	2801           	movel %d1,%d4                                     	<== NOT EXECUTED
   466e8:	e58c           	lsll #2,%d4                                       	<== NOT EXECUTED
   466ea:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   466ec:	6284           	bhis 46672 <_Objects_Shrink_information+0x2a>     	<== NOT EXECUTED
      return;
    }

    index_base += information->allocation_size;
  }
}
   466ee:	4cee 0c1c ffec 	moveml %fp@(-20),%d2-%d4/%a2-%a3                  	<== NOT EXECUTED
   466f4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   466f6:	4e75           	rts

00049660 <_Partition_Manager_initialization>:
 */

void _Partition_Manager_initialization(
  uint32_t   maximum_partitions
)
{
   49660:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   49664:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   49668:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4966a:	4878 0030      	pea 30 <OPER2+0x1c>                               	<== NOT EXECUTED
   4966e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49672:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   49676:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4967a:	4879 0005 6fda 	pea 56fda <_Partition_Information>                	<== NOT EXECUTED
   49680:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   49686:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_PARTITION,
    _Partition_MP_Process_packet
  );
#endif

}
   4968c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4968e:	4e75           	rts

00049e64 <_Protected_heap_Allocate>:

void *_Protected_heap_Allocate(
  Heap_Control *the_heap,
  size_t        size
)
{
   49e64:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49e68:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  void *p;

  _RTEMS_Lock_allocator();
   49e6a:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   49e70:	4eb9 0004 5810 	jsr 45810 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    p = _Heap_Allocate( the_heap, size );
   49e76:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   49e7a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49e7e:	4eb9 0004 9c20 	jsr 49c20 <_Heap_Allocate>                        	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   49e84:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  void *p;

  _RTEMS_Lock_allocator();
    p = _Heap_Allocate( the_heap, size );
   49e8a:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   49e8c:	4eb9 0004 5874 	jsr 45874 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return p;
}
   49e92:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   49e94:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   49e98:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49e9a:	4e75           	rts

000495bc <_Protected_heap_Allocate_aligned>:
void *_Protected_heap_Allocate_aligned(
  Heap_Control *the_heap,
  size_t        size,
  uint32_t      alignment
)
{
   495bc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   495c0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  void *p;

  _RTEMS_Lock_allocator();
   495c2:	2f39 0005 a6de 	movel 5a6de <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   495c8:	4eb9 0004 813c 	jsr 4813c <_API_Mutex_Lock>                       	<== NOT EXECUTED
    p = _Heap_Allocate_aligned( the_heap, size, alignment );
   495ce:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   495d2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   495d6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   495da:	4eb9 0004 8738 	jsr 48738 <_Heap_Allocate_aligned>                	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   495e0:	2f39 0005 a6de 	movel 5a6de <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  void *p;

  _RTEMS_Lock_allocator();
    p = _Heap_Allocate_aligned( the_heap, size, alignment );
   495e6:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   495e8:	4eb9 0004 81a0 	jsr 481a0 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return p;
}
   495ee:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   495f0:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   495f4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   495f6:	4e75           	rts

00049630 <_Protected_heap_Extend>:
bool _Protected_heap_Extend(
  Heap_Control *the_heap,
  void         *starting_address,
  size_t        size
)
{
   49630:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   49634:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Heap_Extend_status status;
  uint32_t           amount_extended;

  _RTEMS_Lock_allocator();
   49636:	2f39 0005 a6de 	movel 5a6de <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4963c:	4eb9 0004 813c 	jsr 4813c <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Extend(the_heap, starting_address, size, &amount_extended);
   49642:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   49646:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4964a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4964e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49652:	4eb9 0004 cbf8 	jsr 4cbf8 <_Heap_Extend>                          	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   49658:	2f39 0005 a6de 	movel 5a6de <_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);
   4965e:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   49660:	4eb9 0004 81a0 	jsr 481a0 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   49666:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   49668:	57c0           	seq %d0                                           	<== NOT EXECUTED
  return (status == HEAP_EXTEND_SUCCESSFUL);
}
   4966a:	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();
   4966e:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
  return (status == HEAP_EXTEND_SUCCESSFUL);
}
   49674:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49676:	4480           	negl %d0                                          	<== NOT EXECUTED
   49678:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049e9c <_Protected_heap_Free>:

bool _Protected_heap_Free(
  Heap_Control *the_heap,
  void         *start_address
)
{
   49e9c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49ea0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  bool    status;

  _RTEMS_Lock_allocator();
   49ea2:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   49ea8:	4eb9 0004 5810 	jsr 45810 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Free( the_heap, start_address );
   49eae:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   49eb2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49eb6:	4eb9 0004 9ca0 	jsr 49ca0 <_Heap_Free>                            	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   49ebc:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  bool    status;

  _RTEMS_Lock_allocator();
    status = _Heap_Free( the_heap, start_address );
   49ec2:	1400           	moveb %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   49ec4:	4eb9 0004 5874 	jsr 45874 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return status;
}
   49eca:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   49ecc:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   49ed0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49ed2:	4e75           	rts

00053650 <_Protected_heap_Get_block_size>:
bool _Protected_heap_Get_block_size(
  Heap_Control        *the_heap,
  void                *starting_address,
  size_t              *size
)
{
   53650:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   53654:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  bool    status;

  _RTEMS_Lock_allocator();
   53656:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   5365c:	4eb9 0004 5810 	jsr 45810 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Size_of_user_area( the_heap, starting_address, size );
   53662:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   53666:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   5366a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5366e:	4eb9 0005 3884 	jsr 53884 <_Heap_Size_of_user_area>               	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   53674:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
)
{
  bool    status;

  _RTEMS_Lock_allocator();
    status = _Heap_Size_of_user_area( the_heap, starting_address, size );
   5367a:	1400           	moveb %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   5367c:	4eb9 0004 5874 	jsr 45874 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return status;
}
   53682:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   53684:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   53688:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5368a:	4e75           	rts

0004a458 <_Protected_heap_Get_free_information>:

bool _Protected_heap_Get_free_information(
  Heap_Control        *the_heap,
  Heap_Information    *info
)
{
   4a458:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  /*
   * TBD: _Heap_Get_free_information does not error check or return status.
   */

  _RTEMS_Lock_allocator();
   4a45c:	2f39 0009 2716 	movel 92716 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4a462:	4eb9 0004 93bc 	jsr 493bc <_API_Mutex_Lock>                       	<== NOT EXECUTED
    _Heap_Get_free_information( the_heap, info );
   4a468:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4a46c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4a470:	4eb9 0005 dde4 	jsr 5dde4 <_Heap_Get_free_information>            	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   4a476:	2f39 0009 2716 	movel 92716 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4a47c:	4eb9 0004 9420 	jsr 49420 <_API_Mutex_Unlock>                     	<== NOT EXECUTED

  return true;
}
   4a482:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a484:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4a486:	4e75           	rts

0005df5c <_Protected_heap_Get_information>:

bool _Protected_heap_Get_information(
  Heap_Control            *the_heap,
  Heap_Information_block  *the_info
)
{
   5df5c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5df60:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5df62:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   5df66:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5df68:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Heap_Get_information_status status;

  if ( !the_heap )
   5df6c:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   5df6e:	6736           	beqs 5dfa6 <_Protected_heap_Get_information+0x4a> 	<== NOT EXECUTED
    return false;

  if ( !the_info )
   5df70:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   5df72:	6732           	beqs 5dfa6 <_Protected_heap_Get_information+0x4a> 	<== NOT EXECUTED
    return false;

  _RTEMS_Lock_allocator();
   5df74:	2f39 0009 2716 	movel 92716 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   5df7a:	4eb9 0004 93bc 	jsr 493bc <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Get_information( the_heap, the_info );
   5df80:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5df82:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5df84:	4eb9 0006 68b0 	jsr 668b0 <_Heap_Get_information>                 	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   5df8a:	2f39 0009 2716 	movel 92716 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED

  if ( !the_info )
    return false;

  _RTEMS_Lock_allocator();
    status = _Heap_Get_information( the_heap, the_info );
   5df90:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  _RTEMS_Unlock_allocator();
   5df92:	4eb9 0004 9420 	jsr 49420 <_API_Mutex_Unlock>                     	<== NOT EXECUTED

  if ( status == HEAP_GET_INFORMATION_SUCCESSFUL )
   5df98:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   5df9a:	57c0           	seq %d0                                           	<== NOT EXECUTED
   5df9c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   5dfa2:	4480           	negl %d0                                          	<== NOT EXECUTED
   5dfa4:	6002           	bras 5dfa8 <_Protected_heap_Get_information+0x4c> 	<== NOT EXECUTED
   5dfa6:	4200           	clrb %d0                                          	<== NOT EXECUTED
    return true;

  return false;
}
   5dfa8:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   5dfac:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
   5dfb0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5dfb2:	4e75           	rts

0005368c <_Protected_heap_Resize_block>:
bool _Protected_heap_Resize_block(
  Heap_Control *the_heap,
  void         *starting_address,
  size_t        size
)
{
   5368c:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   53690:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  Heap_Resize_status status;
  uint32_t           old_mem_size;
  uint32_t           avail_mem_size;

  _RTEMS_Lock_allocator();
   53692:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   53698:	4eb9 0004 5810 	jsr 45810 <_API_Mutex_Lock>                       	<== NOT EXECUTED
    status = _Heap_Resize_block(
   5369e:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   536a2:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   536a6:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   536aa:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   536ae:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   536b2:	4eb9 0005 36dc 	jsr 536dc <_Heap_Resize_block>                    	<== NOT EXECUTED
      the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
  _RTEMS_Unlock_allocator();
   536b8:	2f39 0005 6d5a 	movel 56d5a <_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(
   536be:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
      the_heap, starting_address, size, &old_mem_size, &avail_mem_size );
  _RTEMS_Unlock_allocator();
   536c0:	4eb9 0004 5874 	jsr 45874 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   536c6:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   536c8:	57c0           	seq %d0                                           	<== NOT EXECUTED
  return (status == HEAP_RESIZE_SUCCESSFUL);
}
   536ca:	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();
   536ce:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
  return (status == HEAP_RESIZE_SUCCESSFUL);
}
   536d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   536d6:	4480           	negl %d0                                          	<== NOT EXECUTED
   536d8:	4e75           	rts                                               	<== NOT EXECUTED
	...

000497c8 <_Protected_heap_Walk>:
bool _Protected_heap_Walk(
  Heap_Control *the_heap,
  int           source,
  bool          do_dump
)
{
   497c8:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   497cc:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   497d0:	282e 0008      	movel %fp@(8),%d4                                 	<== NOT EXECUTED
   497d4:	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 ) {
   497d8:	2039 0005 a628 	movel 5a628 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   497de:	4282           	clrl %d2                                          	<== NOT EXECUTED
   497e0:	142e 0013      	moveb %fp@(19),%d2                                	<== NOT EXECUTED
   497e4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   497e6:	6638           	bnes 49820 <_Protected_heap_Walk+0x58>            	<== NOT EXECUTED
    _RTEMS_Lock_allocator();
   497e8:	2f39 0005 a6de 	movel 5a6de <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   497ee:	4eb9 0004 813c 	jsr 4813c <_API_Mutex_Lock>                       	<== NOT EXECUTED
      status = _Heap_Walk( the_heap, source, do_dump );
   497f4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   497f6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   497f8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   497fa:	4eb9 0004 cdd0 	jsr 4cdd0 <_Heap_Walk>                            	<== NOT EXECUTED
    _RTEMS_Unlock_allocator();
   49800:	2f39 0005 a6de 	movel 5a6de <_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 );
   49806:	1400           	moveb %d0,%d2                                     	<== NOT EXECUTED
    _RTEMS_Unlock_allocator();
   49808:	4eb9 0004 81a0 	jsr 481a0 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  } else {
    status = _Heap_Walk( the_heap, source, do_dump );
  }
  return status;
}
   4980e:	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();
   49810:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
  } else {
    status = _Heap_Walk( the_heap, source, do_dump );
  }
  return status;
}
   49816:	4cee 001c fff4 	moveml %fp@(-12),%d2-%d4                          	<== NOT EXECUTED
   4981c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4981e:	4e75           	rts                                               	<== 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 );
   49820:	2d42 0010      	movel %d2,%fp@(16)                                	<== NOT EXECUTED
   49824:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   49828:	2d44 0008      	movel %d4,%fp@(8)                                 	<== NOT EXECUTED
  }
  return status;
}
   4982c:	4cee 001c fff4 	moveml %fp@(-12),%d2-%d4                          	<== NOT EXECUTED
   49832:	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 );
   49834:	4ef9 0004 cdd0 	jmp 4cdd0 <_Heap_Walk>                            	<== NOT EXECUTED
	...

0004564c <_RTEMS_API_Initialize>:
 */

void _RTEMS_API_Initialize(
  rtems_configuration_table *configuration_table
)
{
   4564c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45650:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   45654:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  rtems_api_configuration_table *api_configuration;

  api_configuration = configuration_table->RTEMS_api_configuration;
   45656:	2468 003e      	moveal %a0@(62),%a2                               	<== NOT EXECUTED

  _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects;
   4565a:	203c 0005 6e5a 	movel #355930,%d0                                 	<== NOT EXECUTED
   45660:	23c0 0005 6c64 	movel %d0,56c64 <_Objects_Information_table+0x8>  	<== NOT EXECUTED

  _Attributes_Handler_initialization();

  _Interrupt_Manager_initialization();
   45666:	4eb9 0004 9628 	jsr 49628 <_Interrupt_Manager_initialization>     	<== NOT EXECUTED

#if defined(RTEMS_MULTIPROCESSING)
  _Multiprocessing_Manager_initialization();
#endif

  _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks );
   4566c:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   4566e:	4eb9 0004 97ce 	jsr 497ce <_RTEMS_tasks_Manager_initialization>   	<== NOT EXECUTED

  _Timer_Manager_initialization( api_configuration->maximum_timers );
   45674:	2f2a 0006      	movel %a2@(6),%sp@-                               	<== NOT EXECUTED
   45678:	4eb9 0004 96f0 	jsr 496f0 <_Timer_Manager_initialization>         	<== NOT EXECUTED

  _Signal_Manager_initialization();
   4567e:	4eb9 0004 975c 	jsr 4975c <_Signal_Manager_initialization>        	<== NOT EXECUTED

  _Event_Manager_initialization();
   45684:	4eb9 0004 9618 	jsr 49618 <_Event_Manager_initialization>         	<== NOT EXECUTED

  _Message_queue_Manager_initialization(
   4568a:	2f2a 000e      	movel %a2@(14),%sp@-                              	<== NOT EXECUTED
   4568e:	4eb9 0004 9630 	jsr 49630 <_Message_queue_Manager_initialization> 	<== NOT EXECUTED
    api_configuration->maximum_message_queues
  );

  _Semaphore_Manager_initialization( api_configuration->maximum_semaphores );
   45694:	2f2a 000a      	movel %a2@(10),%sp@-                              	<== NOT EXECUTED
   45698:	4eb9 0004 972c 	jsr 4972c <_Semaphore_Manager_initialization>     	<== NOT EXECUTED

  _Partition_Manager_initialization( api_configuration->maximum_partitions );
   4569e:	2f2a 0012      	movel %a2@(18),%sp@-                              	<== NOT EXECUTED
   456a2:	4eb9 0004 9660 	jsr 49660 <_Partition_Manager_initialization>     	<== NOT EXECUTED

  _Region_Manager_initialization( api_configuration->maximum_regions );
   456a8:	2f2a 0016      	movel %a2@(22),%sp@-                              	<== NOT EXECUTED
   456ac:	4eb9 0004 96c0 	jsr 496c0 <_Region_Manager_initialization>        	<== NOT EXECUTED

  _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports);
   456b2:	2f2a 001a      	movel %a2@(26),%sp@-                              	<== NOT EXECUTED
   456b6:	4eb9 0004 95e8 	jsr 495e8 <_Dual_ported_memory_Manager_initialization>	<== NOT EXECUTED

  _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods );
   456bc:	2f2a 001e      	movel %a2@(30),%sp@-                              	<== NOT EXECUTED
   456c0:	4eb9 0004 9690 	jsr 49690 <_Rate_monotonic_Manager_initialization>	<== NOT EXECUTED

  _Barrier_Manager_initialization( api_configuration->maximum_barriers );
   456c6:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   456cc:	2d6a 0022 0008 	movel %a2@(34),%fp@(8)                            	<== NOT EXECUTED
}
   456d2:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   456d6:	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 );
   456d8:	4ef9 0004 95b8 	jmp 495b8 <_Barrier_Manager_initialization>       	<== NOT EXECUTED
	...

00049954 <_RTEMS_Tasks_Invoke_task_variable_dtor>:

void _RTEMS_Tasks_Invoke_task_variable_dtor(
  Thread_Control        *the_thread,
  rtems_task_variable_t *tvp
)
{
   49954:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49958:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4995a:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  void (*dtor)(void *);
  void *value;

  dtor = tvp->dtor;
  if (_Thread_Is_executing(the_thread)) {
   4995e:	2039 0005 6d62 	movel 56d62 <_Thread_Executing>,%d0               	<== NOT EXECUTED
)
{
  void (*dtor)(void *);
  void *value;

  dtor = tvp->dtor;
   49964:	226a 0010      	moveal %a2@(16),%a1                               	<== NOT EXECUTED
  if (_Thread_Is_executing(the_thread)) {
   49968:	b0ae 0008      	cmpl %fp@(8),%d0                                  	<== NOT EXECUTED
   4996c:	660c           	bnes 4997a <_RTEMS_Tasks_Invoke_task_variable_dtor+0x26>	<== NOT EXECUTED
    value = *tvp->ptr;
   4996e:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
   49972:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
    *tvp->ptr = tvp->gval;
   49974:	20aa 0008      	movel %a2@(8),%a0@                                	<== NOT EXECUTED
   49978:	6004           	bras 4997e <_RTEMS_Tasks_Invoke_task_variable_dtor+0x2a>	<== NOT EXECUTED
  } else {
    value = tvp->tval;
   4997a:	202a 000c      	movel %a2@(12),%d0                                	<== NOT EXECUTED
  }

  if ( dtor )
   4997e:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   49980:	6706           	beqs 49988 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x34>	<== NOT EXECUTED
    (*dtor)(value);
   49982:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   49984:	4e91           	jsr %a1@                                          	<== NOT EXECUTED
   49986:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

  _Workspace_Free(tvp);
   49988:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
}
   4998c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   49990:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  }

  if ( dtor )
    (*dtor)(value);

  _Workspace_Free(tvp);
   49992:	4ef9 0004 7dd8 	jmp 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED

000498d2 <_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() )
   498d2:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED

bool _RTEMS_tasks_Create_extension(
  Thread_Control *executing,
  Thread_Control *created
)
{
   498d8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   498dc:	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() )
   498de:	2068 003e      	moveal %a0@(62),%a0                               	<== NOT EXECUTED

bool _RTEMS_tasks_Create_extension(
  Thread_Control *executing,
  Thread_Control *created
)
{
   498e2:	246e 000c      	moveal %fp@(12),%a2                               	<== 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() )
   498e6:	4a28 0004      	tstb %a0@(4)                                      	<== NOT EXECUTED
   498ea:	6604           	bnes 498f0 <_RTEMS_tasks_Create_extension+0x1e>   	<== NOT EXECUTED
   498ec:	701e           	moveq #30,%d0                                     	<== NOT EXECUTED
   498ee:	6002           	bras 498f2 <_RTEMS_tasks_Create_extension+0x20>   	<== NOT EXECUTED
   498f0:	705e           	moveq #94,%d0                                     	<== NOT EXECUTED
    to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t));

  api = _Workspace_Allocate( to_allocate );
   498f2:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   498f4:	4eb9 0004 7df0 	jsr 47df0 <_Workspace_Allocate>                   	<== NOT EXECUTED

  if ( !api )
   498fa:	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 );
   498fc:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED

  if ( !api )
   498fe:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49900:	6604           	bnes 49906 <_RTEMS_tasks_Create_extension+0x34>   	<== NOT EXECUTED
   49902:	4200           	clrb %d0                                          	<== NOT EXECUTED
   49904:	6046           	bras 4994c <_RTEMS_tasks_Create_extension+0x7a>   	<== NOT EXECUTED

  api->pending_events = EVENT_SETS_NONE_PENDING;
  _ASR_Initialize( &api->Signal );
  created->task_variables = NULL;

  if ( rtems_configuration_get_notepads_enabled() ) {
   49906:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   4990c:	2068 003e      	moveal %a0@(62),%a0                               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
  ASR_Information *information
)
{
  information->is_enabled      = true;
   49910:	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;
   49912:	42aa 011c      	clrl %a2@(284)                                    	<== NOT EXECUTED
   49916:	1340 0008      	moveb %d0,%a1@(8)                                 	<== NOT EXECUTED
  api = _Workspace_Allocate( to_allocate );

  if ( !api )
    return false;

  created->API_Extensions[ THREAD_API_RTEMS ] = api;
   4991a:	2549 010c      	movel %a1,%a2@(268)                               	<== NOT EXECUTED

  api->pending_events = EVENT_SETS_NONE_PENDING;
   4991e:	4291           	clrl %a1@                                         	<== NOT EXECUTED
  information->handler         = NULL;
   49920:	42a9 000a      	clrl %a1@(10)                                     	<== NOT EXECUTED
  information->mode_set        = RTEMS_DEFAULT_MODES;
   49924:	42a9 000e      	clrl %a1@(14)                                     	<== NOT EXECUTED
  information->signals_posted  = 0;
   49928:	42a9 0012      	clrl %a1@(18)                                     	<== NOT EXECUTED
  information->signals_pending = 0;
   4992c:	42a9 0016      	clrl %a1@(22)                                     	<== NOT EXECUTED
  information->nest_level      = 0;
   49930:	42a9 001a      	clrl %a1@(26)                                     	<== NOT EXECUTED
  _ASR_Initialize( &api->Signal );
  created->task_variables = NULL;

  if ( rtems_configuration_get_notepads_enabled() ) {
   49934:	4a28 0004      	tstb %a0@(4)                                      	<== NOT EXECUTED
   49938:	6710           	beqs 4994a <_RTEMS_tasks_Create_extension+0x78>   	<== NOT EXECUTED
   4993a:	41e9 001e      	lea %a1@(30),%a0                                  	<== NOT EXECUTED
   4993e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++)
      api->Notepads[i] = 0;
   49940:	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++)
   49942:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   49944:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   49946:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   49948:	66f6           	bnes 49940 <_RTEMS_tasks_Create_extension+0x6e>   	<== NOT EXECUTED
   4994a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
      api->Notepads[i] = 0;
  }

  return true;
}
   4994c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   49950:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49952:	4e75           	rts

0004988c <_RTEMS_tasks_Delete_extension>:

User_extensions_routine _RTEMS_tasks_Delete_extension(
  Thread_Control *executing,
  Thread_Control *deleted
)
{
   4988c:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   49890:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   49894:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED

  /*
   *  Free per task variable memory
   */

  tvp = deleted->task_variables;
   49898:	206a 011c      	moveal %a2@(284),%a0                              	<== NOT EXECUTED
  deleted->task_variables = NULL;
   4989c:	42aa 011c      	clrl %a2@(284)                                    	<== NOT EXECUTED
  while (tvp) {
    next = (rtems_task_variable_t *)tvp->next;
    _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
   498a0:	47f9 0004 9954 	lea 49954 <_RTEMS_Tasks_Invoke_task_variable_dtor>,%a3	<== NOT EXECUTED
   498a6:	600c           	bras 498b4 <_RTEMS_tasks_Delete_extension+0x28>   	<== NOT EXECUTED
   */

  tvp = deleted->task_variables;
  deleted->task_variables = NULL;
  while (tvp) {
    next = (rtems_task_variable_t *)tvp->next;
   498a8:	2410           	movel %a0@,%d2                                    	<== NOT EXECUTED
    _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp );
   498aa:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   498ac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   498ae:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   498b0:	2042           	moveal %d2,%a0                                    	<== NOT EXECUTED
   498b2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   *  Free per task variable memory
   */

  tvp = deleted->task_variables;
  deleted->task_variables = NULL;
  while (tvp) {
   498b4:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   498b6:	66f0           	bnes 498a8 <_RTEMS_tasks_Delete_extension+0x1c>   	<== NOT EXECUTED

  /*
   *  Free API specific memory
   */

  (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] );
   498b8:	2f2a 010c      	movel %a2@(268),%sp@-                             	<== NOT EXECUTED
   498bc:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
  deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL;
   498c2:	42aa 010c      	clrl %a2@(268)                                    	<== NOT EXECUTED
   498c6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
}
   498c8:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   498ce:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   498d0:	4e75           	rts

000497b6 <_RTEMS_tasks_Initialize_user_tasks>:
 *  Output parameters:  NONE
 */

void _RTEMS_tasks_Initialize_user_tasks( void )
{
  if ( _RTEMS_tasks_Initialize_user_tasks_p )
   497b6:	2039 0005 51de 	movel 551de <_RTEMS_tasks_Initialize_user_tasks_p>,%d0	<== NOT EXECUTED
 *
 *  Output parameters:  NONE
 */

void _RTEMS_tasks_Initialize_user_tasks( void )
{
   497bc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  if ( _RTEMS_tasks_Initialize_user_tasks_p )
   497c0:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   497c2:	6706           	beqs 497ca <_RTEMS_tasks_Initialize_user_tasks+0x14>	<== NOT EXECUTED
    (*_RTEMS_tasks_Initialize_user_tasks_p)();
}
   497c4:	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)();
   497c6:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   497c8:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   497ca:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   497cc:	4e75           	rts

0004520c <_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;
   4520c:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   45212:	2068 003e      	moveal %a0@(62),%a0                               	<== NOT EXECUTED
 *
 *  Output parameters:  NONE
 */

void _RTEMS_tasks_Initialize_user_tasks_body( void )
{
   45216:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4521a:	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;
   4521e:	2628 0026      	movel %a0@(38),%d3                                	<== NOT EXECUTED

  /*
   *  NOTE:  This is slightly different from the Ada implementation.
   */

  user_tasks = api_configuration->User_initialization_tasks_table;
   45222:	2028 002a      	movel %a0@(42),%d0                                	<== NOT EXECUTED
  maximum    = api_configuration->number_of_initialization_tasks;

  if ( !user_tasks || maximum == 0 )
   45226:	676e           	beqs 45296 <_RTEMS_tasks_Initialize_user_tasks_body+0x8a>	<== NOT EXECUTED
   45228:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4522a:	676a           	beqs 45296 <_RTEMS_tasks_Initialize_user_tasks_body+0x8a>	<== NOT EXECUTED
    return;

  for ( index=0 ; index < maximum ; index++ ) {
    return_value = rtems_task_create(
   4522c:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   */

  user_tasks = api_configuration->User_initialization_tasks_table;
  maximum    = api_configuration->number_of_initialization_tasks;

  if ( !user_tasks || maximum == 0 )
   4522e:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   45230:	4282           	clrl %d2                                          	<== NOT EXECUTED
    return;

  for ( index=0 ; index < maximum ; index++ ) {
    return_value = rtems_task_create(
   45232:	5984           	subql #4,%d4                                      	<== NOT EXECUTED
   45234:	49f9 0004 5008 	lea 45008 <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(
   4523a:	47f9 0004 52a0 	lea 452a0 <rtems_task_start>,%a3                  	<== NOT EXECUTED
   45240:	6050           	bras 45292 <_RTEMS_tasks_Initialize_user_tasks_body+0x86>	<== NOT EXECUTED

  if ( !user_tasks || maximum == 0 )
    return;

  for ( index=0 ; index < maximum ; index++ ) {
    return_value = rtems_task_create(
   45242:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   45244:	2f2a 000c      	movel %a2@(12),%sp@-                              	<== NOT EXECUTED
   45248:	2f2a 0014      	movel %a2@(20),%sp@-                              	<== NOT EXECUTED
   4524c:	2f2a 0004      	movel %a2@(4),%sp@-                               	<== NOT EXECUTED
   45250:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   45254:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   45256:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
      user_tasks[ index ].mode_set,
      user_tasks[ index ].attribute_set,
      &id
    );

    if ( !rtems_is_status_successful( return_value ) )
   45258:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   4525e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45260:	661e           	bnes 45280 <_RTEMS_tasks_Initialize_user_tasks_body+0x74>	<== NOT EXECUTED
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );

    return_value = rtems_task_start(
   45262:	2f2a 0018      	movel %a2@(24),%sp@-                              	<== NOT EXECUTED
   45266:	2f2a 0010      	movel %a2@(16),%sp@-                              	<== NOT EXECUTED
   4526a:	d5fc 0000 001c 	addal #28,%a2                                     	<== NOT EXECUTED
   45270:	2f2e fffc      	movel %fp@(-4),%sp@-                              	<== NOT EXECUTED
   45274:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
      id,
      user_tasks[ index ].entry_point,
      user_tasks[ index ].argument
    );

    if ( !rtems_is_status_successful( return_value ) )
   45276:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4527c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4527e:	6710           	beqs 45290 <_RTEMS_tasks_Initialize_user_tasks_body+0x84>	<== NOT EXECUTED
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
   45280:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45282:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   45286:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4528a:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
  maximum    = api_configuration->number_of_initialization_tasks;

  if ( !user_tasks || maximum == 0 )
    return;

  for ( index=0 ; index < maximum ; index++ ) {
   45290:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   45292:	b682           	cmpl %d2,%d3                                      	<== NOT EXECUTED
   45294:	62ac           	bhis 45242 <_RTEMS_tasks_Initialize_user_tasks_body+0x36>	<== NOT EXECUTED
    );

    if ( !rtems_is_status_successful( return_value ) )
      _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value );
  }
}
   45296:	4cee 1c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   4529c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4529e:	4e75           	rts

000497ce <_RTEMS_tasks_Manager_initialization>:
 */

void _RTEMS_tasks_Manager_initialization(
  uint32_t                          maximum_tasks
)
{
   497ce:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED

  _Objects_Initialize_information(
   497d2:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   497d6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   497d8:	4878 0120      	pea 120 <FP_REGS_SAVED+0xe0>                      	<== NOT EXECUTED
   497dc:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   497e0:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   497e4:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   497e8:	4879 0005 6c14 	pea 56c14 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   497ee:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED

  /*
   *  Add all the extensions for this API
   */

  _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions );
   497f4:	4879 0005 561c 	pea 5561c <_RTEMS_tasks_User_extensions>          	<== NOT EXECUTED
   497fa:	4eb9 0004 a2b4 	jsr 4a2b4 <_User_extensions_Add_API_set>          	<== NOT EXECUTED

  _API_extensions_Add( &_RTEMS_tasks_API_extensions );
   49800:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   49806:	203c 0005 5608 	movel #349704,%d0                                 	<== NOT EXECUTED
   4980c:	2d40 0008      	movel %d0,%fp@(8)                                 	<== NOT EXECUTED
    MP_PACKET_TASKS,
    _RTEMS_tasks_MP_Process_packet
  );
#endif

}
   49810:	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 );
   49812:	4ef9 0004 5786 	jmp 45786 <_API_extensions_Add>                   	<== NOT EXECUTED

00049818 <_RTEMS_tasks_Post_switch_extension>:
 */

void _RTEMS_tasks_Post_switch_extension(
  Thread_Control *executing
)
{
   49818:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4981c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   49820:	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 ];
   49824:	2668 010c      	moveal %a0@(268),%a3                              	<== NOT EXECUTED
  if ( !api )
   49828:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4982a:	6756           	beqs 49882 <_RTEMS_tasks_Post_switch_extension+0x6a>	<== NOT EXECUTED
   *  Signal Processing
   */

  asr = &api->Signal;

  _ISR_Disable( level );
   4982c:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   49832:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   49834:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   49836:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    signal_set = asr->signals_posted;
   49838:	262b 0012      	movel %a3@(18),%d3                                	<== NOT EXECUTED
    asr->signals_posted = 0;
   4983c:	42ab 0012      	clrl %a3@(18)                                     	<== NOT EXECUTED
  _ISR_Enable( level );
   49840:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED


  if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */
   49842:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   49844:	673c           	beqs 49882 <_RTEMS_tasks_Post_switch_extension+0x6a>	<== NOT EXECUTED
    return;

  asr->nest_level += 1;
   49846:	52ab 001a      	addql #1,%a3@(26)                                 	<== NOT EXECUTED
  rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode );
   4984a:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   4984c:	5982           	subql #4,%d2                                      	<== NOT EXECUTED
   4984e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   49850:	45f9 0004 a7b8 	lea 4a7b8 <rtems_task_mode>,%a2                   	<== NOT EXECUTED
   49856:	2f3c 0000 ffff 	movel #65535,%sp@-                                	<== NOT EXECUTED
   4985c:	2f2b 000e      	movel %a3@(14),%sp@-                              	<== NOT EXECUTED
   49860:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

  (*asr->handler)( signal_set );
   49862:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   49864:	206b 000a      	moveal %a3@(10),%a0                               	<== NOT EXECUTED
   49868:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

  asr->nest_level -= 1;
   4986a:	53ab 001a      	subql #1,%a3@(26)                                 	<== NOT EXECUTED
  rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode );
   4986e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   49870:	2f3c 0000 ffff 	movel #65535,%sp@-                                	<== NOT EXECUTED
   49876:	2f2e fffc      	movel %fp@(-4),%sp@-                              	<== NOT EXECUTED
   4987a:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4987c:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED

}
   49882:	4cee 0c0c ffec 	moveml %fp@(-20),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   49888:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4988a:	4e75           	rts

00049764 <_RTEMS_tasks_Start_extension>:

User_extensions_routine _RTEMS_tasks_Start_extension(
  Thread_Control *executing,
  Thread_Control *started
)
{
   49764:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49768:	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;
   4976c:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
}
   49770:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
{
  RTEMS_API_Control *api;

  api = started->API_Extensions[ THREAD_API_RTEMS ];

  api->pending_events = EVENT_SETS_NONE_PENDING;
   49772:	4290           	clrl %a0@                                         	<== NOT EXECUTED
}
   49774:	4e75           	rts

00049776 <_RTEMS_tasks_Switch_extension>:

void _RTEMS_tasks_Switch_extension(
  Thread_Control *executing,
  Thread_Control *heir
)
{
   49776:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4977a:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

  /*
   *  Per Task Variables
   */

  tvp = executing->task_variables;
   4977e:	2268 011c      	moveal %a0@(284),%a1                              	<== NOT EXECUTED
   49782:	600e           	bras 49792 <_RTEMS_tasks_Switch_extension+0x1c>   	<== NOT EXECUTED
  while (tvp) {
    tvp->tval = *tvp->ptr;
   49784:	2069 0004      	moveal %a1@(4),%a0                                	<== NOT EXECUTED
   49788:	2350 000c      	movel %a0@,%a1@(12)                               	<== NOT EXECUTED
    *tvp->ptr = tvp->gval;
   4978c:	20a9 0008      	movel %a1@(8),%a0@                                	<== NOT EXECUTED
    tvp = (rtems_task_variable_t *)tvp->next;
   49790:	2251           	moveal %a1@,%a1                                   	<== NOT EXECUTED
  /*
   *  Per Task Variables
   */

  tvp = executing->task_variables;
  while (tvp) {
   49792:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   49794:	66ee           	bnes 49784 <_RTEMS_tasks_Switch_extension+0xe>    	<== NOT EXECUTED
    tvp->tval = *tvp->ptr;
    *tvp->ptr = tvp->gval;
    tvp = (rtems_task_variable_t *)tvp->next;
  }

  tvp = heir->task_variables;
   49796:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   4979a:	2268 011c      	moveal %a0@(284),%a1                              	<== NOT EXECUTED
   4979e:	600e           	bras 497ae <_RTEMS_tasks_Switch_extension+0x38>   	<== NOT EXECUTED
  while (tvp) {
    tvp->gval = *tvp->ptr;
   497a0:	2069 0004      	moveal %a1@(4),%a0                                	<== NOT EXECUTED
   497a4:	2350 0008      	movel %a0@,%a1@(8)                                	<== NOT EXECUTED
    *tvp->ptr = tvp->tval;
   497a8:	20a9 000c      	movel %a1@(12),%a0@                               	<== NOT EXECUTED
    tvp = (rtems_task_variable_t *)tvp->next;
   497ac:	2251           	moveal %a1@,%a1                                   	<== NOT EXECUTED
    *tvp->ptr = tvp->gval;
    tvp = (rtems_task_variable_t *)tvp->next;
  }

  tvp = heir->task_variables;
  while (tvp) {
   497ae:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   497b0:	66ee           	bnes 497a0 <_RTEMS_tasks_Switch_extension+0x2a>   	<== NOT EXECUTED
    tvp->gval = *tvp->ptr;
    *tvp->ptr = tvp->tval;
    tvp = (rtems_task_variable_t *)tvp->next;
  }
}
   497b2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   497b4:	4e75           	rts

000459f0 <_Rate_monotonic_Initiate_statistics>:
#endif

void _Rate_monotonic_Initiate_statistics(
  Rate_monotonic_Control *the_period
)
{
   459f0:	4e56 ffe0      	linkw %fp,#-32                                    	<== NOT EXECUTED
   459f4:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
   459f8:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  Thread_Control *owning_thread = the_period->owner;
   459fc:	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 );
   45a00:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
   45a02:	5183           	subql #8,%d3                                      	<== NOT EXECUTED
   45a04:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45a06:	4eb9 0004 71ec 	jsr 471ec <_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;
   45a0c:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   45a10:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   45a14:	2740 0044      	movel %d0,%a3@(68)                                	<== NOT EXECUTED
   45a18:	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;
   45a1c:	202a 0084      	movel %a2@(132),%d0                               	<== NOT EXECUTED
   45a20:	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) {
   45a26:	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;
   45a28:	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) {
   45a2c:	b5f9 0005 985e 	cmpal 5985e <_Thread_Executing>,%a2               	<== NOT EXECUTED
   45a32:	662a           	bnes 45a5e <_Rate_monotonic_Initiate_statistics+0x6e>	<== NOT EXECUTED

      /*
       *  Adjust the CPU time used to account for the time since last
       *  context switch.
       */
      _Timespec_Subtract(
   45a34:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   45a36:	0682 ffff fff0 	addil #-16,%d2                                    	<== NOT EXECUTED
   45a3c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45a3e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45a40:	4879 0005 9866 	pea 59866 <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED
   45a46:	4eb9 0004 90e4 	jsr 490e4 <_Timespec_Subtract>                    	<== NOT EXECUTED
	&_Thread_Time_of_last_context_switch, &uptime, &ran
      );

      _Timespec_Add_to( &the_period->owner_executed_at_period, &ran );
   45a4c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45a4e:	486b 003c      	pea %a3@(60)                                      	<== NOT EXECUTED
   45a52:	4eb9 0004 8fbc 	jsr 48fbc <_Timespec_Add_to>                      	<== NOT EXECUTED
   45a58:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    }
  #endif
}
   45a5e:	4cee 0c0c ffe0 	moveml %fp@(-32),%d2-%d3/%a2-%a3                  	<== NOT EXECUTED
   45a64:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45a66:	4e75           	rts

00049690 <_Rate_monotonic_Manager_initialization>:
 */

void _Rate_monotonic_Manager_initialization(
  uint32_t   maximum_periods
)
{
   49690:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   49694:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   49698:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4969a:	4878 008c      	pea 8c <FP_REGS_SAVED+0x4c>                       	<== NOT EXECUTED
   4969e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   496a2:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   496a6:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   496aa:	4879 0005 7016 	pea 57016 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   496b0:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   496b6:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    ,
    FALSE,                     /* TRUE if this is a global object class */
    NULL                       /* Proxy extraction support callout */
#endif
  );
}
   496bc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   496be:	4e75           	rts

00045f94 <_Rate_monotonic_Timeout>:

void _Rate_monotonic_Timeout(
  Objects_Id  id,
  void       *ignored
)
{
   45f94:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45f98:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45f9a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45f9e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45fa2:	4879 0005 9698 	pea 59698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   45fa8:	4eb9 0004 7aec 	jsr 47aec <_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 ) {
   45fae:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45fb4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   45fb6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45fba:	6600 009a      	bnew 46056 <_Rate_monotonic_Timeout+0xc2>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_thread = the_period->owner;
   45fbe:	206a 0050      	moveal %a2@(80),%a0                               	<== NOT EXECUTED
      if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
   45fc2:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
   45fc6:	0280 0000 4000 	andil #16384,%d0                                  	<== NOT EXECUTED
   45fcc:	673e           	beqs 4600c <_Rate_monotonic_Timeout+0x78>         	<== NOT EXECUTED
   45fce:	202a 0008      	movel %a2@(8),%d0                                 	<== NOT EXECUTED
   45fd2:	b0a8 0020      	cmpl %a0@(32),%d0                                 	<== NOT EXECUTED
   45fd6:	6634           	bnes 4600c <_Rate_monotonic_Timeout+0x78>         	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   45fd8:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   45fde:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   45fe0:	4eb9 0004 7f0c 	jsr 47f0c <_Thread_Clear_state>                   	<== NOT EXECUTED
            the_thread->Wait.id == the_period->Object.id ) {
        _Thread_Unblock( the_thread );

        _Rate_monotonic_Initiate_statistics( the_period );
   45fe6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45fe8:	4eb9 0004 59f0 	jsr 459f0 <_Rate_monotonic_Initiate_statistics>   	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45fee:	256a 004c 001c 	movel %a2@(76),%a2@(28)                           	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   45ff4:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   45ff8:	4879 0005 987c 	pea 5987c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   45ffe:	4eb9 0004 9364 	jsr 49364 <_Watchdog_Insert>                      	<== NOT EXECUTED
   46004:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   4600a:	603c           	bras 46048 <_Rate_monotonic_Timeout+0xb4>         	<== NOT EXECUTED

        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) {
   4600c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4600e:	b0aa 0038      	cmpl %a2@(56),%d0                                 	<== NOT EXECUTED
   46012:	662e           	bnes 46042 <_Rate_monotonic_Timeout+0xae>         	<== NOT EXECUTED
        the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
   46014:	103c 0003      	moveb #3,%d0                                      	<== NOT EXECUTED
   46018:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED

        _Rate_monotonic_Initiate_statistics( the_period );
   4601c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4601e:	4eb9 0004 59f0 	jsr 459f0 <_Rate_monotonic_Initiate_statistics>   	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   46024:	256a 004c 001c 	movel %a2@(76),%a2@(28)                           	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   4602a:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4602e:	4879 0005 987c 	pea 5987c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   46034:	4eb9 0004 9364 	jsr 49364 <_Watchdog_Insert>                      	<== NOT EXECUTED
   4603a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46040:	6006           	bras 46048 <_Rate_monotonic_Timeout+0xb4>         	<== NOT EXECUTED

        _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
      } else
        the_period->state = RATE_MONOTONIC_EXPIRED;
   46042:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   46044:	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;
   46048:	2039 0005 97a0 	movel 597a0 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4604e:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46050:	23c0 0005 97a0 	movel %d0,597a0 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    case OBJECTS_REMOTE:  /* impossible */
#endif
    case OBJECTS_ERROR:
      break;
  }
}
   46056:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4605a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4605c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045a68 <_Rate_monotonic_Update_statistics>:

void _Rate_monotonic_Update_statistics(
  Rate_monotonic_Control    *the_period
)
{
   45a68:	4e56 ffb8      	linkw %fp,#-72                                    	<== NOT EXECUTED
   45a6c:	48d7 3c3c      	moveml %d2-%d5/%a2-%a5,%sp@                       	<== NOT EXECUTED
   45a70:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
    struct timespec  uptime;

    /*
     * Obtain the current time since boot
     */
    _TOD_Get_uptime( &uptime );
   45a74:	486e ffe8      	pea %fp@(-24)                                     	<== NOT EXECUTED
   45a78:	4eb9 0004 71ec 	jsr 471ec <_TOD_Get_uptime>                       	<== NOT EXECUTED

  /*
   *  Update the counts.
   */
  stats = &the_period->Statistics;
  stats->count++;
   45a7e:	52aa 0054      	addql #1,%a2@(84)                                 	<== NOT EXECUTED

  if ( the_period->state == RATE_MONOTONIC_EXPIRED )
   45a82:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45a84:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   45a86:	b0aa 0038      	cmpl %a2@(56),%d0                                 	<== NOT EXECUTED
   45a8a:	6604           	bnes 45a90 <_Rate_monotonic_Update_statistics+0x28>	<== NOT EXECUTED
    stats->missed_count++;
   45a8c:	52aa 0058      	addql #1,%a2@(88)                                 	<== NOT EXECUTED

  /*
   *  Grab basic information for time statistics.
   */
  #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
    _Timespec_Subtract(
   45a90:	486e fff0      	pea %fp@(-16)                                     	<== NOT EXECUTED
   45a94:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   45a96:	0682 ffff ffe8 	addil #-24,%d2                                    	<== NOT EXECUTED
   45a9c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45a9e:	47f9 0004 90e4 	lea 490e4 <_Timespec_Subtract>,%a3                	<== NOT EXECUTED
   45aa4:	486a 0044      	pea %a2@(68)                                      	<== NOT EXECUTED
   45aa8:	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;
   45aaa:	2079 0005 985e 	moveal 5985e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45ab0:	2d68 0088 ffdc 	movel %a0@(136),%fp@(-36)                         	<== NOT EXECUTED
   45ab6:	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);
   45aba:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
   45abc:	0683 ffff ffe0 	addil #-32,%d3                                    	<== NOT EXECUTED
   45ac2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   45ac4:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
   45ac6:	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);
   45acc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED

      /* executed += ran */
      _Timespec_Add_to( &used, &ran );
   45ace:	4bf9 0004 8fbc 	lea 48fbc <_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);
   45ad4:	4879 0005 9866 	pea 59866 <_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))
   45ada:	2a0a           	movel %a2,%d5                                     	<== NOT EXECUTED
   45adc:	0685 0000 003c 	addil #60,%d5                                     	<== 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;
   45ae2:	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);
   45ae6:	4e93           	jsr %a3@                                          	<== 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))
   45ae8:	49f9 0004 90b4 	lea 490b4 <_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 );
   45aee:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   45af0:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   45af2:	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))
   45af4:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   45afa:	2e85           	movel %d5,%sp@                                    	<== NOT EXECUTED
   45afc:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   45afe:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   45b00:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45b02:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45b04:	6600 00bc      	bnew 45bc2 <_Rate_monotonic_Update_statistics+0x15a>	<== NOT EXECUTED
        return;

       /* executed = current cpu usage - value at start of period */
      _Timespec_Subtract(
   45b08:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   45b0e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45b10:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   45b12:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   45b14:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
  /*
   *  Update CPU time
   */

  #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
    _Timespec_Add_to( &stats->total_cpu_time, &executed );
   45b16:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45b18:	486a 006c      	pea %a2@(108)                                     	<== NOT EXECUTED
   45b1c:	4e95           	jsr %a5@                                          	<== NOT EXECUTED

    if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) )
   45b1e:	486a 005c      	pea %a2@(92)                                      	<== NOT EXECUTED
   45b22:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45b24:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   45b26:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   45b2c:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45b2e:	6710           	beqs 45b40 <_Rate_monotonic_Update_statistics+0xd8>	<== NOT EXECUTED
      stats->min_cpu_time = executed;
   45b30:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   45b34:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   45b38:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
   45b3c:	2541 0060      	movel %d1,%a2@(96)                                	<== NOT EXECUTED

    if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) )
   45b40:	486a 0064      	pea %a2@(100)                                     	<== NOT EXECUTED
   45b44:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   45b48:	4eb9 0004 9084 	jsr 49084 <_Timespec_Greater_than>                	<== NOT EXECUTED
   45b4e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45b50:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45b52:	6710           	beqs 45b64 <_Rate_monotonic_Update_statistics+0xfc>	<== NOT EXECUTED
      stats->max_cpu_time = executed;
   45b54:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   45b58:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   45b5c:	2540 0064      	movel %d0,%a2@(100)                               	<== NOT EXECUTED
   45b60:	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 );
   45b64:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   45b66:	0682 ffff fff0 	addil #-16,%d2                                    	<== NOT EXECUTED
   45b6c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45b6e:	486a 0084      	pea %a2@(132)                                     	<== NOT EXECUTED
   45b72:	4eb9 0004 8fbc 	jsr 48fbc <_Timespec_Add_to>                      	<== NOT EXECUTED

    if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) )
   45b78:	486a 0074      	pea %a2@(116)                                     	<== NOT EXECUTED
   45b7c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45b7e:	4eb9 0004 90b4 	jsr 490b4 <_Timespec_Less_than>                   	<== NOT EXECUTED
   45b84:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45b8a:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45b8c:	6710           	beqs 45b9e <_Rate_monotonic_Update_statistics+0x136>	<== NOT EXECUTED
      stats->min_wall_time = since_last_period;
   45b8e:	202e fff0      	movel %fp@(-16),%d0                               	<== NOT EXECUTED
   45b92:	222e fff4      	movel %fp@(-12),%d1                               	<== NOT EXECUTED
   45b96:	2540 0074      	movel %d0,%a2@(116)                               	<== NOT EXECUTED
   45b9a:	2541 0078      	movel %d1,%a2@(120)                               	<== NOT EXECUTED

    if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) )
   45b9e:	486a 007c      	pea %a2@(124)                                     	<== NOT EXECUTED
   45ba2:	486e fff0      	pea %fp@(-16)                                     	<== NOT EXECUTED
   45ba6:	4eb9 0004 9084 	jsr 49084 <_Timespec_Greater_than>                	<== NOT EXECUTED
   45bac:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45bae:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45bb0:	6710           	beqs 45bc2 <_Rate_monotonic_Update_statistics+0x15a>	<== NOT EXECUTED
      stats->max_wall_time = since_last_period;
   45bb2:	202e fff0      	movel %fp@(-16),%d0                               	<== NOT EXECUTED
   45bb6:	222e fff4      	movel %fp@(-12),%d1                               	<== NOT EXECUTED
   45bba:	2540 007c      	movel %d0,%a2@(124)                               	<== NOT EXECUTED
   45bbe:	2541 0080      	movel %d1,%a2@(128)                               	<== NOT EXECUTED
  #endif
}
   45bc2:	4cee 3c3c ffb8 	moveml %fp@(-72),%d2-%d5/%a2-%a5                  	<== NOT EXECUTED
   45bc8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45bca:	4e75           	rts

000496c0 <_Region_Manager_initialization>:
 */

void _Region_Manager_initialization(
  uint32_t   maximum_regions
)
{
   496c0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   496c4:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   496c8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   496ca:	4878 00c0      	pea c0 <FP_REGS_SAVED+0x80>                       	<== NOT EXECUTED
   496ce:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   496d2:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   496d6:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   496da:	4879 0005 7052 	pea 57052 <_Region_Information>                   	<== NOT EXECUTED
   496e0:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   496e6:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_REGION,
    0  /* XXX _Region_MP_Process_packet */
  );
#endif

}
   496ec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   496ee:	4e75           	rts

00054cb4 <_Region_Process_queue>:
   54cb4:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
 */

void _Region_Process_queue(
  Region_Control *the_region
)
{
   54cba:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   54cbe:	48d7 3c1c      	moveml %d2-%d4/%a2-%a5,%sp@                       	<== NOT EXECUTED
   54cc2:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   54cc4:	23c0 0006 c830 	movel %d0,6c830 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   54cca:	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();
   54cce:	2f39 0006 c8e6 	movel 6c8e6 <_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 );
   54cd4:	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 );
   54cd6:	260b           	movel %a3,%d3                                     	<== NOT EXECUTED
   54cd8:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   54cde:	0683 0000 0068 	addil #104,%d3                                    	<== NOT EXECUTED
   54ce4:	4bf9 0005 0a54 	lea 50a54 <_Heap_Allocate>,%a5                    	<== 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 );
   54cea:	49f9 0005 540c 	lea 5540c <_Thread_queue_Extract>,%a4             	<== 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();
   54cf0:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  /*
   *  NOTE: The following loop is O(n) where n is the number of
   *        threads whose memory request is satisfied.
   */
  for ( ; ; ) {
    the_thread = _Thread_queue_First( &the_region->Wait_queue );
   54cf6:	283c 0005 5518 	movel #349464,%d4                                 	<== NOT EXECUTED
   54cfc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   54cfe:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   54d00:	2044           	moveal %d4,%a0                                    	<== NOT EXECUTED
   54d02:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

    if ( the_thread == NULL )
   54d04:	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 );
   54d06:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    if ( the_thread == NULL )
   54d08:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   54d0a:	6726           	beqs 54d32 <_Region_Process_queue+0x7e>           	<== NOT EXECUTED
   54d0c:	2f2a 0024      	movel %a2@(36),%sp@-                              	<== NOT EXECUTED
   54d10:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   54d12:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
    the_segment = (void **) _Region_Allocate_segment(
      the_region,
      the_thread->Wait.count
    );

    if ( the_segment == NULL )
   54d14:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   54d16:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   54d18:	6718           	beqs 54d32 <_Region_Process_queue+0x7e>           	<== NOT EXECUTED
      break;

    *(void **)the_thread->Wait.return_argument = the_segment;
   54d1a:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
    the_region->number_of_used_blocks += 1;
   54d1e:	52ab 0064      	addql #1,%a3@(100)                                	<== NOT EXECUTED
    );

    if ( the_segment == NULL )
      break;

    *(void **)the_thread->Wait.return_argument = the_segment;
   54d22:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
    the_region->number_of_used_blocks += 1;
    _Thread_queue_Extract( &the_region->Wait_queue, the_thread );
   54d24:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   54d26:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   54d28:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
    the_thread->Wait.return_code = RTEMS_SUCCESSFUL;
   54d2a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   54d2c:	42aa 0034      	clrl %a2@(52)                                     	<== NOT EXECUTED
   54d30:	60cc           	bras 54cfe <_Region_Process_queue+0x4a>           	<== NOT EXECUTED
  }
  _Thread_Enable_dispatch();
}
   54d32:	4cee 3c1c ffe4 	moveml %fp@(-28),%d2-%d4/%a2-%a5                  	<== NOT EXECUTED
   54d38:	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();
   54d3a:	4ef9 0005 1ef2 	jmp 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

0004972c <_Semaphore_Manager_initialization>:
 */

void _Semaphore_Manager_initialization(
  uint32_t   maximum_semaphores
)
{
   4972c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   49730:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   49734:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   49736:	4878 0076      	pea 76 <FP_REGS_SAVED+0x36>                       	<== NOT EXECUTED
   4973a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4973e:	4878 0003      	pea 3 <DIVIDE>                                    	<== NOT EXECUTED
   49742:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   49746:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   4974c:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
   49752:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    MP_PACKET_SEMAPHORE,
    _Semaphore_MP_Process_packet
  );
#endif

}
   49758:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4975a:	4e75           	rts

00044fdc <_Semaphore_Translate_core_mutex_return_code>:
};

rtems_status_code _Semaphore_Translate_core_mutex_return_code (
  uint32_t   status
)
{
   44fdc:	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];
}
   44fe0:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
};

rtems_status_code _Semaphore_Translate_core_mutex_return_code (
  uint32_t   status
)
{
   44fe4:	41f9 0005 411a 	lea 5411a <_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];
}
   44fea:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   44fee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44ff0:	4e75           	rts

00044ff2 <_Semaphore_Translate_core_semaphore_return_code>:
};

rtems_status_code _Semaphore_Translate_core_semaphore_return_code (
  uint32_t   status
)
{
   44ff2:	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];
}
   44ff6:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
};

rtems_status_code _Semaphore_Translate_core_semaphore_return_code (
  uint32_t   status
)
{
   44ffa:	41f9 0005 4136 	lea 54136 <_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];
}
   45000:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   45004:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45006:	4e75           	rts

0004975c <_Signal_Manager_initialization>:
 *
 *  Output parameters:  NONE
 */

void _Signal_Manager_initialization( void )
{
   4975c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _MPCI_Register_packet_processor(
    MP_PACKET_SIGNAL,
    _Signal_MP_Process_packet
  );
#endif
}
   49760:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49762:	4e75           	rts

00045c58 <_TOD_Get>:
 */

void _TOD_Get(
  struct timespec *time
)
{
   45c58:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   45c5c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED

  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  /* _TOD_Now is a proper POSIX time */
  _ISR_Disable( level );
   45c5e:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

void _TOD_Get(
  struct timespec *time
)
{
   45c64:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45c66:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level level;
  struct timespec offset;

  /* assume time checked by caller */

  offset.tv_sec = 0;
   45c6a:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
  offset.tv_nsec = 0;
   45c6e:	42ae fffc      	clrl %fp@(-4)                                     	<== NOT EXECUTED

  /* _TOD_Now is a proper POSIX time */
  _ISR_Disable( level );
   45c72:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   45c74:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   45c76:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    *time = _TOD_Now;
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   45c78:	2079 0005 6e3a 	moveal 56e3a <_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;
   45c7e:	2039 0005 6d36 	movel 56d36 <_TOD_Now>,%d0                        	<== NOT EXECUTED
   45c84:	2239 0005 6d3a 	movel 56d3a <_TOD_Now+0x4>,%d1                    	<== NOT EXECUTED
   45c8a:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
   45c8c:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   45c90:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   45c92:	6706           	beqs 45c9a <_TOD_Get+0x42>                        	<== NOT EXECUTED
      offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)();
   45c94:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   45c96:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
  _ISR_Enable( level );
   45c9a:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  _Timespec_Add_to( time, &offset );
   45c9c:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   45ca0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45ca2:	4eb9 0004 790c 	jsr 4790c <_Timespec_Add_to>                      	<== NOT EXECUTED
}
   45ca8:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   45cac:	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 );
   45cb0:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   45cb2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45cb4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049bc0 <_TOD_Get_uptime>:
 */

void _TOD_Get_uptime(
  struct timespec *uptime
)
{
   49bc0:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   49bc4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  /* assume uptime checked by caller */

  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  _ISR_Disable( level );
   49bc6:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

void _TOD_Get_uptime(
  struct timespec *uptime
)
{
   49bcc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   49bce:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level level;
  struct timespec offset;

  /* assume uptime checked by caller */

  offset.tv_sec = 0;
   49bd2:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
  offset.tv_nsec = 0;
   49bd6:	42ae fffc      	clrl %fp@(-4)                                     	<== NOT EXECUTED

  _ISR_Disable( level );
   49bda:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   49bdc:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   49bde:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    *uptime = _TOD_Uptime;
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   49be0:	2079 0005 6e3a 	moveal 56e3a <_Watchdog_Nanoseconds_since_tick_handler>,%a0	<== NOT EXECUTED

  offset.tv_sec = 0;
  offset.tv_nsec = 0;

  _ISR_Disable( level );
    *uptime = _TOD_Uptime;
   49be6:	2039 0005 6d22 	movel 56d22 <_TOD_Uptime>,%d0                     	<== NOT EXECUTED
   49bec:	2239 0005 6d26 	movel 56d26 <_TOD_Uptime+0x4>,%d1                 	<== NOT EXECUTED
   49bf2:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
   49bf4:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
    if ( _Watchdog_Nanoseconds_since_tick_handler )
   49bf8:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   49bfa:	6706           	beqs 49c02 <_TOD_Get_uptime+0x42>                 	<== NOT EXECUTED
      offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)();
   49bfc:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   49bfe:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
  _ISR_Enable( level );
   49c02:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  _Timespec_Add_to( uptime, &offset );
   49c04:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   49c08:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49c0a:	4eb9 0004 790c 	jsr 4790c <_Timespec_Add_to>                      	<== NOT EXECUTED
}
   49c10:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   49c14:	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 );
   49c18:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   49c1a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49c1c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045cb8 <_TOD_Handler_initialization>:
 */

void _TOD_Handler_initialization(
  uint32_t   microseconds_per_tick
)
{
   45cb8:	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;
   45cbc:	4200           	clrb %d0                                          	<== NOT EXECUTED

void _TOD_Handler_initialization(
  uint32_t   microseconds_per_tick
)
{
  _TOD_Microseconds_per_tick = microseconds_per_tick;
   45cbe:	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;
   45cc2:	13c0 0005 6cb8 	moveb %d0,56cb8 <_TOD_Is_set>                     	<== NOT EXECUTED

void _TOD_Handler_initialization(
  uint32_t   microseconds_per_tick
)
{
  _TOD_Microseconds_per_tick = microseconds_per_tick;
   45cc8:	23d0 0005 6e32 	movel %a0@,56e32 <_TOD_Microseconds_per_tick>     	<== NOT EXECUTED
  _TOD_Uptime.tv_nsec = 0;

  /* TOD has not been set */
  _TOD_Is_set = FALSE;
  _TOD_Activate();
}
   45cce:	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;
   45cd0:	203c 21da e500 	movel #567993600,%d0                              	<== NOT EXECUTED
  _TOD_Now.tv_nsec = 0;
   45cd6:	42b9 0005 6d3a 	clrl 56d3a <_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;
   45cdc:	23c0 0005 6d36 	movel %d0,56d36 <_TOD_Now>                        	<== NOT EXECUTED
  _TOD_Now.tv_nsec = 0;

  /* Uptime (timespec) */
  _TOD_Uptime.tv_sec  = 0;
   45ce2:	42b9 0005 6d22 	clrl 56d22 <_TOD_Uptime>                          	<== NOT EXECUTED
  _TOD_Uptime.tv_nsec = 0;
   45ce8:	42b9 0005 6d26 	clrl 56d26 <_TOD_Uptime+0x4>                      	<== NOT EXECUTED

  /* TOD has not been set */
  _TOD_Is_set = FALSE;
  _TOD_Activate();
}
   45cee:	4e75           	rts

00046d48 <_TOD_Set>:
   46d48:	2039 0006 0fcc 	movel 60fcc <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
 */

void _TOD_Set(
  const struct timespec *time
)
{
   46d4e:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46d52:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46d54:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46d56:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   46d5a:	23c0 0006 0fcc 	movel %d0,60fcc <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
  _Thread_Disable_dispatch();
  _TOD_Deactivate();

  if ( time->tv_sec < _TOD_Seconds_since_epoch )
   46d60:	2239 0006 105e 	movel 6105e <_TOD_Now>,%d1                        	<== NOT EXECUTED
   46d66:	2012           	movel %a2@,%d0                                    	<== NOT EXECUTED
   46d68:	41f9 0004 8ff8 	lea 48ff8 <_Watchdog_Adjust>,%a0                  	<== NOT EXECUTED
   46d6e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   46d70:	6f0a           	bles 46d7c <_TOD_Set+0x34>                        	<== NOT EXECUTED
  Watchdog_Adjust_directions direction,
  Watchdog_Interval          units
)
{

  _Watchdog_Adjust( &_Watchdog_Seconds_chain, direction, units );
   46d72:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   46d74:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   46d76:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46d7a:	6006           	bras 46d82 <_TOD_Set+0x3a>                        	<== NOT EXECUTED
  else
    _Watchdog_Adjust_seconds( WATCHDOG_FORWARD,
       time->tv_sec - _TOD_Seconds_since_epoch );

  /* POSIX format TOD (timespec) */
  _TOD_Now                 = *time;
   46d7c:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   46d7e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46d80:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46d82:	4879 0006 109c 	pea 6109c <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   46d88:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   46d8a:	2012           	movel %a2@,%d0                                    	<== NOT EXECUTED
   46d8c:	588a           	addql #4,%a2                                      	<== NOT EXECUTED
   46d8e:	23d2 0006 1062 	movel %a2@,61062 <_TOD_Now+0x4>                   	<== NOT EXECUTED
  _TOD_Is_set              = TRUE;

  _TOD_Activate();

  _Thread_Enable_dispatch();
}
   46d94:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46d98:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46d9e:	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;
   46da0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46da2:	13c1 0006 0fe0 	moveb %d1,60fe0 <_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;
   46da8:	23c0 0006 105e 	movel %d0,6105e <_TOD_Now>                        	<== NOT EXECUTED
  _TOD_Is_set              = TRUE;

  _TOD_Activate();

  _Thread_Enable_dispatch();
   46dae:	4ef9 0004 7de6 	jmp 47de6 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

00045cf0 <_TOD_Tickle_ticks>:
{
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   45cf0:	2239 0005 6e32 	movel 56e32 <_TOD_Microseconds_per_tick>,%d1      	<== NOT EXECUTED
 *
 *  Output parameters: NONE
 */

void _TOD_Tickle_ticks( void )
{
   45cf6:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   45cfa:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
  struct timespec tick;
  uint32_t        seconds;

  /* Convert the tick quantum to a timespec */
  tick.tv_nsec = _TOD_Microseconds_per_tick * 1000;
   45cfe:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   45d00:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   45d02:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   45d04:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
  tick.tv_sec  = 0;

  /* Update the counter of ticks since boot */
  _Watchdog_Ticks_since_boot += 1;
   45d06:	2079 0005 6dec 	moveal 56dec <_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;
   45d0c:	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 );
   45d0e:	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;
   45d10:	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 );
   45d12:	5182           	subql #8,%d2                                      	<== NOT EXECUTED
   45d14:	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;
   45d16:	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;
   45d18:	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 );
   45d1a:	45f9 0004 790c 	lea 4790c <_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;
   45d20:	23c8 0005 6dec 	movel %a0,56dec <_Watchdog_Ticks_since_boot>      	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_seconds( void )
{

  _Watchdog_Tickle( &_Watchdog_Seconds_chain );
   45d26:	47f9 0004 7d5c 	lea 47d5c <_Watchdog_Tickle>,%a3                  	<== NOT EXECUTED

  /* Update the timespec format uptime */
  (void) _Timespec_Add_to( &_TOD_Uptime, &tick );
   45d2c:	4879 0005 6d22 	pea 56d22 <_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;
   45d32:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED
  tick.tv_sec  = 0;
   45d36:	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 );
   45d3a:	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 );
   45d3c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45d3e:	4879 0005 6d36 	pea 56d36 <_TOD_Now>                              	<== NOT EXECUTED
   45d44:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   45d46:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45d4c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   45d4e:	600c           	bras 45d5c <_TOD_Tickle_ticks+0x6c>               	<== NOT EXECUTED
   45d50:	4879 0005 6d74 	pea 56d74 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   45d56:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
  while ( seconds ) {
    _Watchdog_Tickle_seconds();
    seconds--;
   45d58:	5382           	subql #1,%d2                                      	<== NOT EXECUTED
   45d5a:	588f           	addql #4,%sp                                      	<== 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 ) {
   45d5c:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   45d5e:	66f0           	bnes 45d50 <_TOD_Tickle_ticks+0x60>               	<== NOT EXECUTED
    _Watchdog_Tickle_seconds();
    seconds--;
  }
}
   45d60:	4cee 0c04 ffec 	moveml %fp@(-20),%d2/%a2-%a3                      	<== NOT EXECUTED
   45d66:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45d68:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045588 <_TOD_To_seconds>:
 */

uint32_t   _TOD_To_seconds(
  rtems_time_of_day *the_tod
)
{
   45588:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4558c:	48d7 043c      	moveml %d2-%d5/%a2,%sp@                           	<== NOT EXECUTED
   45590:	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;
   45594:	2412           	movel %a2@,%d2                                    	<== NOT EXECUTED
)
{
  uint32_t   time;
  uint32_t   year_mod_4;

  time = the_tod->day - 1;
   45596:	222a 0008      	movel %a2@(8),%d1                                 	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;
   4559a:	7a03           	moveq #3,%d5                                      	<== NOT EXECUTED
)
{
  uint32_t   time;
  uint32_t   year_mod_4;

  time = the_tod->day - 1;
   4559c:	5381           	subql #1,%d1                                      	<== NOT EXECUTED
  year_mod_4 = the_tod->year & 3;
   4559e:	ca82           	andl %d2,%d5                                      	<== NOT EXECUTED
   455a0:	41f9 0005 660e 	lea 5660e <_TOD_Days_to_date>,%a0                 	<== NOT EXECUTED

  if ( year_mod_4 == 0 )
   455a6:	660c           	bnes 455b4 <_TOD_To_seconds+0x2c>                 	<== NOT EXECUTED
    time += _TOD_Days_to_date[ 1 ][ the_tod->month ];
   455a8:	202a 0004      	movel %a2@(4),%d0                                 	<== NOT EXECUTED
   455ac:	0680 0000 000d 	addil #13,%d0                                     	<== NOT EXECUTED
   455b2:	6004           	bras 455b8 <_TOD_To_seconds+0x30>                 	<== NOT EXECUTED
  else
    time += _TOD_Days_to_date[ 0 ][ the_tod->month ];
   455b4:	202a 0004      	movel %a2@(4),%d0                                 	<== NOT EXECUTED
   455b8:	3030 0a00      	movew %a0@(00000000,%d0:l:2),%d0                  	<== NOT EXECUTED
   455bc:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   455c2:	2800           	movel %d0,%d4                                     	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   455c4:	0682 ffff f83c 	addil #-1988,%d2                                  	<== NOT EXECUTED
   455ca:	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 ];
   455cc:	d881           	addl %d1,%d4                                      	<== NOT EXECUTED

  time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) *
   455ce:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   455d0:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   455d2:	ed89           	lsll #6,%d1                                       	<== NOT EXECUTED
   455d4:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   455d6:	d081           	addl %d1,%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;
   455d8:	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 ) *
   455dc:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   455de:	43f9 0005 6642 	lea 56642 <_TOD_Days_since_last_leap_year>,%a1    	<== NOT EXECUTED
   455e4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   455e6:	3031 5a00      	movew %a1@(00000000,%d5:l:2),%d0                  	<== NOT EXECUTED
   455ea:	d1c2           	addal %d2,%a0                                     	<== NOT EXECUTED
   455ec:	2242           	moveal %d2,%a1                                    	<== 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;
   455ee:	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 ) *
   455f0:	41f0 8c00      	lea %a0@(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;
   455f4:	e58b           	lsll #2,%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 ) *
   455f6:	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;
   455fa:	ed89           	lsll #6,%d1                                       	<== NOT EXECUTED
   455fc:	9283           	subl %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 ) *
   455fe:	d088           	addl %a0,%d0                                      	<== NOT EXECUTED
            ( (TOD_DAYS_PER_YEAR * 4) + 1);

  time += _TOD_Days_since_last_leap_year[ year_mod_4 ];
   45600:	d084           	addl %d4,%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;
   45602:	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;
   45606:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   45608:	7609           	moveq #9,%d3                                      	<== NOT EXECUTED
   4560a:	e7aa           	lsll %d3,%d2                                      	<== NOT EXECUTED
   4560c:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
   4560e:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
             * TOD_SECONDS_PER_MINUTE;

  time += the_tod->second;
   45610:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   45612:	e589           	lsll #2,%d1                                       	<== NOT EXECUTED
   45614:	ed88           	lsll #6,%d0                                       	<== NOT EXECUTED
   45616:	9081           	subl %d1,%d0                                      	<== 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)
   45618:	222a 0014      	movel %a2@(20),%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;
   4561c:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
   4561e:	e98b           	lsll #4,%d3                                       	<== NOT EXECUTED

  time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute)
   45620:	0681 21da e500 	addil #567993600,%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;
   45626:	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;
   45628:	d280           	addl %d0,%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;
   4562a:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   4562c:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   4562e:	9083           	subl %d3,%d0                                      	<== NOT EXECUTED
  time += the_tod->second;

  time += TOD_SECONDS_1970_THROUGH_1988;

  return( time );
}
   45630:	4cd7 043c      	moveml %sp@,%d2-%d5/%a2                           	<== NOT EXECUTED
   45634:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45636:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   45638:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004563c <_TOD_Validate>:
 */

bool _TOD_Validate(
  rtems_time_of_day *the_tod
)
{
   4563c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45640:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   45644:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t   days_in_month;

  if ((!the_tod)                                  ||
   45646:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   45648:	676c           	beqs 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   4564a:	43f9 0006 115a 	lea 6115a <_TOD_Microseconds_per_tick>,%a1        	<== NOT EXECUTED
   45650:	203c 000f 4240 	movel #1000000,%d0                                	<== NOT EXECUTED
   45656:	4c51 0000      	remul %a1@,%d0,%d0                                	<== NOT EXECUTED
   4565a:	b0a8 0018      	cmpl %a0@(24),%d0                                 	<== NOT EXECUTED
   4565e:	6356           	blss 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   45660:	703b           	moveq #59,%d0                                     	<== NOT EXECUTED
   45662:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   45666:	654e           	bcss 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   45668:	b0a8 0010      	cmpl %a0@(16),%d0                                 	<== NOT EXECUTED
   4566c:	6548           	bcss 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   4566e:	7417           	moveq #23,%d2                                     	<== NOT EXECUTED
   45670:	b4a8 000c      	cmpl %a0@(12),%d2                                 	<== NOT EXECUTED
   45674:	6540           	bcss 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   45676:	2228 0004      	movel %a0@(4),%d1                                 	<== NOT EXECUTED
   4567a:	673a           	beqs 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   4567c:	103c 000c      	moveb #12,%d0                                     	<== NOT EXECUTED
   45680:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   45682:	6532           	bcss 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   45684:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   45686:	0c80 0000 07c3 	cmpil #1987,%d0                                   	<== NOT EXECUTED
   4568c:	6328           	blss 456b6 <_TOD_Validate+0x7a>                   	<== NOT EXECUTED
   4568e:	2268 0008      	moveal %a0@(8),%a1                                	<== NOT EXECUTED
   45692:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   45694:	6720           	beqs 456b6 <_TOD_Validate+0x7a>                   	<== 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 )
   45696:	143c 0003      	moveb #3,%d2                                      	<== NOT EXECUTED
   4569a:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   4569c:	41f9 0005 664a 	lea 5664a <_TOD_Days_per_month>,%a0               	<== NOT EXECUTED
   456a2:	6606           	bnes 456aa <_TOD_Validate+0x6e>                   	<== NOT EXECUTED
    days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
   456a4:	2030 1c34      	movel %a0@(00000034,%d1:l:4),%d0                  	<== NOT EXECUTED
   456a8:	6004           	bras 456ae <_TOD_Validate+0x72>                   	<== NOT EXECUTED
  else
    days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
   456aa:	2030 1c00      	movel %a0@(00000000,%d1:l:4),%d0                  	<== NOT EXECUTED
   456ae:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   456b0:	54c0           	scc %d0                                           	<== NOT EXECUTED
   456b2:	4480           	negl %d0                                          	<== NOT EXECUTED
   456b4:	6002           	bras 456b8 <_TOD_Validate+0x7c>                   	<== NOT EXECUTED
   456b6:	4200           	clrb %d0                                          	<== NOT EXECUTED

  if ( the_tod->day > days_in_month )
    return false;

  return true;
}
   456b8:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   456ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   456bc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046748 <_Thread_Change_priority>:
void _Thread_Change_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority,
  bool              prepend_it
)
{
   46748:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4674c:	48d7 041c      	moveml %d2-%d4/%a2,%sp@                           	<== NOT EXECUTED
   46750:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   46754:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
*/

  /*
   * Save original state
   */
  original_state = the_thread->current_state;
   46758:	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 );
   4675c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
void _Thread_Change_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority,
  bool              prepend_it
)
{
   4675e:	182e 0013      	moveb %fp@(19),%d4                                	<== 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 );
   46762:	4eb9 0004 757c 	jsr 4757c <_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 )
   46768:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4676a:	b4aa 0014      	cmpl %a2@(20),%d2                                 	<== NOT EXECUTED
   4676e:	670c           	beqs 4677c <_Thread_Change_priority+0x34>         	<== NOT EXECUTED
    _Thread_Set_priority( the_thread, new_priority );
   46770:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46772:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46774:	4eb9 0004 7424 	jsr 47424 <_Thread_Set_priority>                  	<== NOT EXECUTED
   4677a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED

  _ISR_Disable( level );
   4677c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46782:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46784:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46786:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   46788:	7204           	moveq #4,%d1                                      	<== 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;
   4678a:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4678e:	c283           	andl %d3,%d1                                      	<== NOT EXECUTED
  if ( state != STATES_TRANSIENT ) {
   46790:	7604           	moveq #4,%d3                                      	<== NOT EXECUTED
   46792:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   46794:	6730           	beqs 467c6 <_Thread_Change_priority+0x7e>         	<== NOT EXECUTED
    /* Only clear the transient state if it wasn't set already */
    if ( ! _States_Is_transient( original_state ) )
   46796:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   46798:	6608           	bnes 467a2 <_Thread_Change_priority+0x5a>         	<== NOT EXECUTED
      the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
   4679a:	72fb           	moveq #-5,%d1                                     	<== NOT EXECUTED
   4679c:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
   4679e:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED
    _ISR_Enable( level );
   467a2:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( state ) ) {
   467a4:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   467aa:	6700 00d4      	beqw 46880 <_Thread_Change_priority+0x138>        	<== NOT EXECUTED
      _Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
   467ae:	2d4a 000c      	movel %a2,%fp@(12)                                	<== NOT EXECUTED
   467b2:	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 );
}
   467b8:	4cee 041c fff0 	moveml %fp@(-16),%d2-%d4/%a2                      	<== NOT EXECUTED
   467be:	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 );
   467c0:	4ef9 0004 7384 	jmp 47384 <_Thread_queue_Requeue>                 	<== NOT EXECUTED
    }
    return;
  }

  /* Only clear the transient state if it wasn't set already */
  if ( ! _States_Is_transient( original_state ) ) {
   467c6:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   467c8:	6650           	bnes 4681a <_Thread_Change_priority+0xd2>         	<== 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;
   467ca:	206a 0090      	moveal %a2@(144),%a0                              	<== NOT EXECUTED
   467ce:	322a 0096      	movew %a2@(150),%d1                               	<== NOT EXECUTED
   467d2:	3010           	movew %a0@,%d0                                    	<== NOT EXECUTED
   467d4:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   467d6:	3080           	movew %d0,%a0@                                    	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   467d8:	3239 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   467de:	302a 0094      	movew %a2@(148),%d0                               	<== NOT EXECUTED
   467e2:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
   467e6:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   467e8:	33c0 0005 6d58 	movew %d0,56d58 <_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 );
   467ee:	42aa 0010      	clrl %a2@(16)                                     	<== NOT EXECUTED

    _Priority_Add_to_bit_map( &the_thread->Priority_map );
    if ( prepend_it )
   467f2:	4a04           	tstb %d4                                          	<== NOT EXECUTED
   467f4:	6710           	beqs 46806 <_Thread_Change_priority+0xbe>         	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
  before_node           = after_node->next;
   467f6:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   467f8:	2549 0004      	movel %a1,%a2@(4)                                 	<== NOT EXECUTED
  before_node           = after_node->next;
  after_node->next      = the_node;
   467fc:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
  the_node->next        = before_node;
  before_node->previous = the_node;
   467fe:	214a 0004      	movel %a2,%a0@(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;
   46802:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
   46804:	6014           	bras 4681a <_Thread_Change_priority+0xd2>         	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   46806:	2609           	movel %a1,%d3                                     	<== NOT EXECUTED
   46808:	5883           	addql #4,%d3                                      	<== NOT EXECUTED
   4680a:	2483           	movel %d3,%a2@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   4680c:	2069 0008      	moveal %a1@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   46810:	234a 0008      	movel %a2,%a1@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   46814:	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;
   46818:	208a           	movel %a2,%a0@                                    	<== 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 );
   4681a:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46820:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   46822:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46824:	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 );
   46826:	3039 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   4682c:	4840           	swap %d0                                          	<== NOT EXECUTED
   4682e:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   46830:	41f9 0005 6dc8 	lea 56dc8 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   46836:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   4683c:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   46840:	4841           	swap %d1                                          	<== NOT EXECUTED
   46842:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   46844:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   4684a:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   4684c:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4684e:	2079 0005 6c50 	moveal 56c50 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   46854:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   46856:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   46858:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   4685a:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
   4685c:	2030 1800      	movel %a0@(00000000,%d1:l),%d0                    	<== 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 );
   46860:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   46866:	23c0 0005 6d32 	movel %d0,56d32 <_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() &&
   4686c:	b088           	cmpl %a0,%d0                                      	<== NOT EXECUTED
   4686e:	670e           	beqs 4687e <_Thread_Change_priority+0x136>        	<== NOT EXECUTED
   46870:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   46874:	6708           	beqs 4687e <_Thread_Change_priority+0x136>        	<== NOT EXECUTED
       _Thread_Executing->is_preemptible )
    _Context_Switch_necessary = TRUE;
   46876:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46878:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED
  _ISR_Enable( level );
   4687e:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   46880:	4cee 041c fff0 	moveml %fp@(-16),%d2-%d4/%a2                      	<== NOT EXECUTED
   46886:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46888:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004688c <_Thread_Clear_state>:

void _Thread_Clear_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   4688c:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   46890:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
  ISR_Level       level;
  States_Control  current_state;

  _ISR_Disable( level );
   46894:	283c 0000 0700 	movel #1792,%d4                                   	<== NOT EXECUTED

void _Thread_Clear_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   4689a:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4689e:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  ISR_Level       level;
  States_Control  current_state;

  _ISR_Disable( level );
   468a2:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   468a4:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   468a6:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   468a8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    current_state = the_thread->current_state;
   468aa:	222b 0010      	movel %a3@(16),%d1                                	<== NOT EXECUTED

    if ( current_state & state ) {
   468ae:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   468b0:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   468b2:	677a           	beqs 4692e <_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);
   468b4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   468b6:	4680           	notl %d0                                          	<== NOT EXECUTED
   468b8:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
      current_state =
   468ba:	2740 0010      	movel %d0,%a3@(16)                                	<== NOT EXECUTED
      the_thread->current_state = _States_Clear( state, current_state );

      if ( _States_Is_ready( current_state ) ) {
   468be:	666e           	bnes 4692e <_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);
   468c0:	206b 008c      	moveal %a3@(140),%a0                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   468c4:	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;
   468c6:	226b 0090      	moveal %a3@(144),%a1                              	<== NOT EXECUTED
   468ca:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   468cc:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   468ce:	2468 0008      	moveal %a0@(8),%a2                                	<== NOT EXECUTED
   468d2:	322b 0096      	movew %a3@(150),%d1                               	<== NOT EXECUTED
   468d6:	3011           	movew %a1@,%d0                                    	<== NOT EXECUTED
   468d8:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   468da:	3280           	movew %d0,%a1@                                    	<== NOT EXECUTED
  the_chain->last     = the_node;
   468dc:	214b 0008      	movel %a3,%a0@(8)                                 	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   468e0:	3239 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   468e6:	302b 0094      	movew %a3@(148),%d0                               	<== NOT EXECUTED
   468ea:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   468ec:	33c0 0005 6d58 	movew %d0,56d58 <_Priority_Major_bit_map>         	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   468f2:	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;
   468f6:	248b           	movel %a3,%a2@                                    	<== NOT EXECUTED

        _ISR_Flash( level );
   468f8:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   468fa:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   468fc:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   468fe:	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 ) {
   46900:	2079 0005 6d32 	moveal 56d32 <_Thread_Heir>,%a0                   	<== NOT EXECUTED
   46906:	202b 0014      	movel %a3@(20),%d0                                	<== NOT EXECUTED
   4690a:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   4690e:	641e           	bccs 4692e <_Thread_Clear_state+0xa2>             	<== NOT EXECUTED
          _Thread_Heir = the_thread;
          if ( _Thread_Executing->is_preemptible ||
   46910:	2079 0005 6d62 	moveal 56d62 <_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;
   46916:	23cb 0005 6d32 	movel %a3,56d32 <_Thread_Heir>                    	<== NOT EXECUTED
          if ( _Thread_Executing->is_preemptible ||
   4691c:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   46920:	6604           	bnes 46926 <_Thread_Clear_state+0x9a>             	<== NOT EXECUTED
   46922:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46924:	6608           	bnes 4692e <_Thread_Clear_state+0xa2>             	<== NOT EXECUTED
               the_thread->current_priority == 0 )
            _Context_Switch_necessary = TRUE;
   46926:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46928:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED
        }
      }
  }
  _ISR_Enable( level );
   4692e:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
}
   46930:	4cd7 0c1c      	moveml %sp@,%d2-%d4/%a2-%a3                       	<== NOT EXECUTED
   46934:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46936:	4e75           	rts

00046938 <_Thread_Close>:

void _Thread_Close(
  Objects_Information  *information,
  Thread_Control       *the_thread
)
{
   46938:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4693c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4693e:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
   46942:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46944:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   46948:	206a 001a      	moveal %a2@(26),%a0                               	<== NOT EXECUTED
   4694c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4694e:	302b 000a      	movew %a3@(10),%d0                                	<== NOT EXECUTED
   46952:	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;
   46956:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4695c:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4695e:	23c0 0005 6ca4 	movel %d0,56ca4 <_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 );
   46964:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   46966:	4eb9 0004 7b24 	jsr 47b24 <_User_extensions_Thread_delete>        	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4696c:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46972:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46974:	23c0 0005 6ca4 	movel %d0,56ca4 <_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 );
   4697a:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4697c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4697e:	4eb9 0004 6094 	jsr 46094 <_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 );
   46984:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46988:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4698a:	4eb9 0004 7490 	jsr 47490 <_Thread_Set_state>                     	<== NOT EXECUTED

  if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) {
   46990:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   46992:	4eb9 0004 72ac 	jsr 472ac <_Thread_queue_Extract_with_proxy>      	<== NOT EXECUTED
   46998:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   4699e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   469a0:	6614           	bnes 469b6 <_Thread_Close+0x7e>                   	<== NOT EXECUTED
    if ( _Watchdog_Is_active( &the_thread->Timer ) )
   469a2:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   469a4:	b0ab 0050      	cmpl %a3@(80),%d0                                 	<== NOT EXECUTED
   469a8:	660c           	bnes 469b6 <_Thread_Close+0x7e>                   	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );
   469aa:	486b 0048      	pea %a3@(72)                                      	<== NOT EXECUTED
   469ae:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   469b4:	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 ) )
   469b6:	b7f9 0005 6d2a 	cmpal 56d2a <_Thread_Allocated_fp>,%a3            	<== NOT EXECUTED
   469bc:	6606           	bnes 469c4 <_Thread_Close+0x8c>                   	<== NOT EXECUTED
 */

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE void _Thread_Deallocate_fp( void )
{
  _Thread_Allocated_fp = NULL;
   469be:	42b9 0005 6d2a 	clrl 56d2a <_Thread_Allocated_fp>                 	<== NOT EXECUTED
    _Thread_Deallocate_fp();
#endif
  the_thread->fp_context = NULL;

  if ( the_thread->Start.fp_context )
   469c4:	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;
   469c8:	42ab 0104      	clrl %a3@(260)                                    	<== NOT EXECUTED

  if ( the_thread->Start.fp_context )
   469cc:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   469ce:	670a           	beqs 469da <_Thread_Close+0xa2>                   	<== NOT EXECUTED
    (void) _Workspace_Free( the_thread->Start.fp_context );
   469d0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   469d2:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
   469d8:	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 );
   469da:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   469dc:	4eb9 0004 7648 	jsr 47648 <_Thread_Stack_Free>                    	<== NOT EXECUTED
  the_thread->Start.stack = NULL;

  if ( the_thread->extensions )
   469e2:	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;
   469e6:	42ab 00cc      	clrl %a3@(204)                                    	<== NOT EXECUTED

  if ( the_thread->extensions )
   469ea:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   469ec:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   469ee:	670a           	beqs 469fa <_Thread_Close+0xc2>                   	<== NOT EXECUTED
    (void) _Workspace_Free( the_thread->extensions );
   469f0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   469f2:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
   469f8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  the_thread->extensions = NULL;
   469fa:	42ab 0118      	clrl %a3@(280)                                    	<== NOT EXECUTED
}
   469fe:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46a02:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   46a06:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46a08:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046a0c <_Thread_Create_idle>:
 *
 *  _Thread_Create_idle
 */

void _Thread_Create_idle( void )
{
   46a0c:	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 );
   46a10:	4879 0005 6df6 	pea 56df6 <_Thread_Internal_information>          	<== NOT EXECUTED
   46a16:	4eb9 0004 600c 	jsr 4600c <_Objects_Allocate>                     	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   46a1c:	2239 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d1  	<== NOT EXECUTED
   46a22:	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();
   46a24:	23c0 0005 6e3e 	movel %d0,56e3e <_Thread_Idle>                    	<== NOT EXECUTED
   46a2a:	23c1 0005 6ca4 	movel %d1,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   *  that when _Thread_Initialize unnests dispatch that we do not
   *  do anything stupid.
   */
  _Thread_Disable_dispatch();

  _Thread_Initialize(
   46a30:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   46a36:	2068 0018      	moveal %a0@(24),%a0                               	<== NOT EXECUTED
   46a3a:	4879 0005 41b8 	pea 541b8 <C.26.3475+0xe>                         	<== NOT EXECUTED
   46a40:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46a42:	1039 0005 5192 	moveb 55192 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   46a48:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a4a:	2239 0005 518e 	movel 5518e <rtems_minimum_stack_size>,%d1        	<== NOT EXECUTED
   46a50:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a52:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a54:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46a58:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46a5a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a5c:	b1c1           	cmpal %d1,%a0                                     	<== NOT EXECUTED
   46a5e:	6302           	blss 46a62 <_Thread_Create_idle+0x56>             	<== NOT EXECUTED
   46a60:	2208           	movel %a0,%d1                                     	<== NOT EXECUTED
   46a62:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   46a64:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a66:	2f39 0005 6e3e 	movel 56e3e <_Thread_Idle>,%sp@-                  	<== NOT EXECUTED
   46a6c:	4879 0005 6df6 	pea 56df6 <_Thread_Internal_information>          	<== NOT EXECUTED
   46a72:	4eb9 0004 6d0c 	jsr 46d0c <_Thread_Initialize>                    	<== NOT EXECUTED
   *             MUST be done before _Thread_Start is invoked.
   */
  _Thread_Heir      =
  _Thread_Executing = _Thread_Idle;

  _Thread_Start(
   46a78:	dffc 0000 002c 	addal #44,%sp                                     	<== NOT EXECUTED
   46a7e:	4297           	clrl %sp@                                         	<== NOT EXECUTED
   46a80:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   46a86:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   46a88:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46a8e:	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      =
   46a92:	2239 0005 6e3e 	movel 56e3e <_Thread_Idle>,%d1                    	<== NOT EXECUTED
  _Thread_Executing = _Thread_Idle;

  _Thread_Start(
   46a98:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46a9a:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46a9c:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   46a9e:	23c0 0005 6ca4 	movel %d0,56ca4 <_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      =
   46aa4:	23c1 0005 6d62 	movel %d1,56d62 <_Thread_Executing>               	<== NOT EXECUTED
   46aaa:	23c1 0005 6d32 	movel %d1,56d32 <_Thread_Heir>                    	<== NOT EXECUTED
  _Thread_Executing = _Thread_Idle;

  _Thread_Start(
   46ab0:	4eb9 0004 76dc 	jsr 476dc <_Thread_Start>                         	<== NOT EXECUTED
   46ab6:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
    _Configuration_Table->idle_task,
    NULL,
    0
  );

}
   46abc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46abe:	4e75           	rts

00046ac0 <_Thread_Delay_ended>:

void _Thread_Delay_ended(
  Objects_Id  id,
  void       *ignored
)
{
   46ac0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  Thread_Control    *the_thread;
  Objects_Locations  location;

  the_thread = _Thread_Get( id, &location );
   46ac4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46ac8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46acc:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   46ad2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46ad4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   46ad8:	661e           	bnes 46af8 <_Thread_Delay_ended+0x38>             	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   46ada:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   46ae0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46ae2:	4eb9 0004 688c 	jsr 4688c <_Thread_Clear_state>                   	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   46ae8:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46aee:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46af0:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46af2:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      _Thread_Unblock( the_thread );
      _Thread_Unnest_dispatch();
      break;
  }
}
   46af8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46afa:	4e75           	rts

00046afc <_Thread_Dispatch>:
 *    dispatch thread
 *    no dispatch thread
 */

void _Thread_Dispatch( void )
{
   46afc:	4e56 ffc8      	linkw %fp,#-56                                    	<== NOT EXECUTED
   46b00:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
  Thread_Control   *executing;
  Thread_Control   *heir;
  ISR_Level         level;

  executing   = _Thread_Executing;
  _ISR_Disable( level );
   46b04:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
{
  Thread_Control   *executing;
  Thread_Control   *heir;
  ISR_Level         level;

  executing   = _Thread_Executing;
   46b0a:	2679 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a3              	<== NOT EXECUTED
  _ISR_Disable( level );
   46b10:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   46b12:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46b14:	8282           	orl %d2,%d1                                       	<== NOT EXECUTED
   46b16:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    _ISR_Enable( level );

    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      {
        struct timespec uptime, ran;
        _TOD_Get_uptime( &uptime );
   46b18:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46b1a:	260e           	movel %fp,%d3                                     	<== NOT EXECUTED
    _ISR_Enable( level );

    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      {
        struct timespec uptime, ran;
        _TOD_Get_uptime( &uptime );
   46b1c:	5184           	subql #8,%d4                                      	<== NOT EXECUTED
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46b1e:	0683 ffff fff0 	addil #-16,%d3                                    	<== NOT EXECUTED
        _Timespec_Add_to( &executing->cpu_time_used, &ran );
   46b24:	2e3c 0004 790c 	movel #293132,%d7                                 	<== NOT EXECUTED
    if ( _Thread_libc_reent ) {
      executing->libc_reent = *_Thread_libc_reent;
      *_Thread_libc_reent = heir->libc_reent;
    }

    _User_extensions_Thread_switch( executing, heir );
   46b2a:	2c3c 0004 7b94 	movel #293780,%d6                                 	<== NOT EXECUTED
    if ( executing->fp_context != NULL )
      _Context_Save_fp( &executing->fp_context );
#endif
#endif

    _Context_Switch( &executing->Registers, &heir->Registers );
   46b30:	2a3c 0004 7eac 	movel #294572,%d5                                 	<== NOT EXECUTED
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
    if ( (executing->fp_context != NULL) &&
         !_Thread_Is_allocated_fp( executing ) ) {
      if ( _Thread_Allocated_fp != NULL )
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
      _Context_Restore_fp( &executing->fp_context );
   46b36:	4bf9 0004 7ec8 	lea 47ec8 <_CPU_Context_restore_fp>,%a5           	<== NOT EXECUTED
#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 ) ) {
      if ( _Thread_Allocated_fp != NULL )
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
   46b3c:	49f9 0004 7ec4 	lea 47ec4 <_CPU_Context_save_fp>,%a4              	<== NOT EXECUTED
   46b42:	6000 00d4      	braw 46c18 <_Thread_Dispatch+0x11c>               	<== NOT EXECUTED
  ISR_Level         level;

  executing   = _Thread_Executing;
  _ISR_Disable( level );
  while ( _Context_Switch_necessary == TRUE ) {
    heir = _Thread_Heir;
   46b46:	2479 0005 6d32 	moveal 56d32 <_Thread_Heir>,%a2                   	<== NOT EXECUTED
    _Thread_Dispatch_disable_level = 1;
   46b4c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46b4e:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    _Context_Switch_necessary = FALSE;
   46b54:	4201           	clrb %d1                                          	<== NOT EXECUTED
   46b56:	13c1 0005 6d72 	moveb %d1,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED
    _Thread_Executing = heir;
   46b5c:	23ca 0005 6d62 	movel %a2,56d62 <_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 )
   46b62:	b0aa 007c      	cmpl %a2@(124),%d0                                	<== NOT EXECUTED
   46b66:	660a           	bnes 46b72 <_Thread_Dispatch+0x76>                	<== NOT EXECUTED
      heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
   46b68:	41f9 0005 6c54 	lea 56c54 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
   46b6e:	2550 0078      	movel %a0@,%a2@(120)                              	<== NOT EXECUTED
    _ISR_Enable( level );
   46b72:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      {
        struct timespec uptime, ran;
        _TOD_Get_uptime( &uptime );
   46b74:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46b76:	4eb9 0004 9bc0 	jsr 49bc0 <_TOD_Get_uptime>                       	<== NOT EXECUTED
        _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran);
   46b7c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46b7e:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   46b80:	4879 0005 6d6a 	pea 56d6a <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED
   46b86:	4eb9 0004 7944 	jsr 47944 <_Timespec_Subtract>                    	<== NOT EXECUTED
        _Timespec_Add_to( &executing->cpu_time_used, &ran );
   46b8c:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
   46b8e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46b90:	486b 0084      	pea %a3@(132)                                     	<== NOT EXECUTED
   46b94:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
    #endif

    /*
     * Switch libc's task specific data.
     */
    if ( _Thread_libc_reent ) {
   46b96:	2079 0005 6d2e 	moveal 56d2e <_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;
   46b9c:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   46ba0:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   46ba4:	23c0 0005 6d6a 	movel %d0,56d6a <_Thread_Time_of_last_context_switch>	<== NOT EXECUTED
   46baa:	23c1 0005 6d6e 	movel %d1,56d6e <_Thread_Time_of_last_context_switch+0x4>	<== NOT EXECUTED
    #endif

    /*
     * Switch libc's task specific data.
     */
    if ( _Thread_libc_reent ) {
   46bb0:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   46bb6:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46bb8:	6708           	beqs 46bc2 <_Thread_Dispatch+0xc6>                	<== NOT EXECUTED
      executing->libc_reent = *_Thread_libc_reent;
   46bba:	2750 0108      	movel %a0@,%a3@(264)                              	<== NOT EXECUTED
      *_Thread_libc_reent = heir->libc_reent;
   46bbe:	20aa 0108      	movel %a2@(264),%a0@                              	<== NOT EXECUTED
    }

    _User_extensions_Thread_switch( executing, heir );
   46bc2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46bc4:	2046           	moveal %d6,%a0                                    	<== NOT EXECUTED
   46bc6:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   46bc8:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
    if ( executing->fp_context != NULL )
      _Context_Save_fp( &executing->fp_context );
#endif
#endif

    _Context_Switch( &executing->Registers, &heir->Registers );
   46bca:	486a 00d0      	pea %a2@(208)                                     	<== NOT EXECUTED
   46bce:	2045           	moveal %d5,%a0                                    	<== NOT EXECUTED
   46bd0:	486b 00d0      	pea %a3@(208)                                     	<== NOT EXECUTED
   46bd4:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
    if ( (executing->fp_context != NULL) &&
   46bd6:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   46bdc:	4aab 0104      	tstl %a3@(260)                                    	<== NOT EXECUTED
   46be0:	6724           	beqs 46c06 <_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 );
   46be2:	2079 0005 6d2a 	moveal 56d2a <_Thread_Allocated_fp>,%a0           	<== NOT EXECUTED
   46be8:	b1cb           	cmpal %a3,%a0                                     	<== NOT EXECUTED
   46bea:	671a           	beqs 46c06 <_Thread_Dispatch+0x10a>               	<== NOT EXECUTED
         !_Thread_Is_allocated_fp( executing ) ) {
      if ( _Thread_Allocated_fp != NULL )
   46bec:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46bee:	6708           	beqs 46bf8 <_Thread_Dispatch+0xfc>                	<== NOT EXECUTED
        _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
   46bf0:	4868 0104      	pea %a0@(260)                                     	<== NOT EXECUTED
   46bf4:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   46bf6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      _Context_Restore_fp( &executing->fp_context );
   46bf8:	486b 0104      	pea %a3@(260)                                     	<== NOT EXECUTED
   46bfc:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
      _Thread_Allocated_fp = executing;
   46bfe:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46c00:	23cb 0005 6d2a 	movel %a3,56d2a <_Thread_Allocated_fp>            	<== NOT EXECUTED
    if ( executing->fp_context != NULL )
      _Context_Restore_fp( &executing->fp_context );
#endif
#endif

    executing = _Thread_Executing;
   46c06:	2679 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a3              	<== NOT EXECUTED

    _ISR_Disable( level );
   46c0c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46c12:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46c14:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46c16:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  Thread_Control   *heir;
  ISR_Level         level;

  executing   = _Thread_Executing;
  _ISR_Disable( level );
  while ( _Context_Switch_necessary == TRUE ) {
   46c18:	1039 0005 6d72 	moveb 56d72 <_Context_Switch_necessary>,%d0       	<== NOT EXECUTED
   46c1e:	6600 ff26      	bnew 46b46 <_Thread_Dispatch+0x4a>                	<== NOT EXECUTED
    executing = _Thread_Executing;

    _ISR_Disable( level );
  }

  _Thread_Dispatch_disable_level = 0;
   46c22:	42b9 0005 6ca4 	clrl 56ca4 <_Thread_Dispatch_disable_level>       	<== NOT EXECUTED

  _ISR_Enable( level );
   46c28:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Do_post_task_switch_extension ||
   46c2a:	4ab9 0005 6d4a 	tstl 56d4a <_Thread_Do_post_task_switch_extension>	<== NOT EXECUTED
   46c30:	6606           	bnes 46c38 <_Thread_Dispatch+0x13c>               	<== NOT EXECUTED
   46c32:	4a2b 0075      	tstb %a3@(117)                                    	<== NOT EXECUTED
   46c36:	670c           	beqs 46c44 <_Thread_Dispatch+0x148>               	<== NOT EXECUTED
       executing->do_post_task_switch_extension ) {
    executing->do_post_task_switch_extension = false;
   46c38:	4200           	clrb %d0                                          	<== NOT EXECUTED
   46c3a:	1740 0075      	moveb %d0,%a3@(117)                               	<== NOT EXECUTED
    _API_extensions_Run_postswitch();
   46c3e:	4eb9 0004 5754 	jsr 45754 <_API_extensions_Run_postswitch>        	<== NOT EXECUTED
  }

}
   46c44:	4cee 3cfc ffc8 	moveml %fp@(-56),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   46c4a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46c4c:	4e75           	rts

00046c4e <_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 )
   46c4e:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46c54:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46c56:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   46c5c:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
 */

#if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \
      (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) )
void _Thread_Enable_dispatch( void )
{
   46c62:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  if ( --_Thread_Dispatch_disable_level )
   46c66:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46c68:	6608           	bnes 46c72 <_Thread_Enable_dispatch+0x24>         	<== NOT EXECUTED
    return;
  _Thread_Dispatch();
}
   46c6a:	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();
   46c6c:	4ef9 0004 6afc 	jmp 46afc <_Thread_Dispatch>                      	<== NOT EXECUTED
}
   46c72:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46c74:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004aa7c <_Thread_Evaluate_mode>:

bool _Thread_Evaluate_mode( void )
{
  Thread_Control     *executing;

  executing = _Thread_Executing;
   4aa7c:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
 *
 *  XXX
 */

bool _Thread_Evaluate_mode( void )
{
   4aa82:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Thread_Control     *executing;

  executing = _Thread_Executing;

  if ( !_States_Is_ready( executing->current_state ) ||
   4aa86:	4aa8 0010      	tstl %a0@(16)                                     	<== NOT EXECUTED
   4aa8a:	660e           	bnes 4aa9a <_Thread_Evaluate_mode+0x1e>           	<== NOT EXECUTED
   4aa8c:	b1f9 0005 6d32 	cmpal 56d32 <_Thread_Heir>,%a0                    	<== NOT EXECUTED
   4aa92:	6710           	beqs 4aaa4 <_Thread_Evaluate_mode+0x28>           	<== NOT EXECUTED
   4aa94:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   4aa98:	670a           	beqs 4aaa4 <_Thread_Evaluate_mode+0x28>           	<== NOT EXECUTED
       ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) {
    _Context_Switch_necessary = TRUE;
   4aa9a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4aa9c:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED
   4aaa2:	6002           	bras 4aaa6 <_Thread_Evaluate_mode+0x2a>           	<== NOT EXECUTED
    return TRUE;
   4aaa4:	4200           	clrb %d0                                          	<== NOT EXECUTED
  }

  return FALSE;
}
   4aaa6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4aaa8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046c78 <_Thread_Get>:

Thread_Control *_Thread_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
   46c78:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46c7c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46c7e:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   46c82:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46c84:	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 ) ) {
   46c88:	6618           	bnes 46ca2 <_Thread_Get+0x2a>                     	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   46c8a:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   46c90:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46c92:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    _Thread_Disable_dispatch();
    *location = OBJECTS_LOCAL;
    tp = _Thread_Executing;
   46c98:	2039 0005 6d62 	movel 56d62 <_Thread_Executing>,%d0               	<== 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;
   46c9e:	4291           	clrl %a1@                                         	<== NOT EXECUTED
   46ca0:	604c           	bras 46cee <_Thread_Get+0x76>                     	<== 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);
   46ca2:	7018           	moveq #24,%d0                                     	<== NOT EXECUTED
   46ca4:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   46ca6:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   46ca8:	7607           	moveq #7,%d3                                      	<== NOT EXECUTED
   46caa:	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 )
   46cac:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   46cae:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46cb0:	163c 0003      	moveb #3,%d3                                      	<== NOT EXECUTED
   46cb4:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   46cb6:	6442           	bccs 46cfa <_Thread_Get+0x82>                     	<== NOT EXECUTED
   46cb8:	600e           	bras 46cc8 <_Thread_Get+0x50>                     	<== NOT EXECUTED
  if ( the_class != 1 ) {       /* threads are always first class :) */
    *location = OBJECTS_ERROR;
    goto done;
  }

  api_information = _Objects_Information_table[ the_api ];
   46cba:	41f9 0005 6c5c 	lea 56c5c <_Objects_Information_table>,%a0        	<== NOT EXECUTED
   46cc0:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
  if ( !api_information ) {
   46cc4:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46cc6:	6608           	bnes 46cd0 <_Thread_Get+0x58>                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
   46cc8:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   46cca:	2282           	movel %d2,%a1@                                    	<== NOT EXECUTED
   46ccc:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46cce:	601e           	bras 46cee <_Thread_Get+0x76>                     	<== NOT EXECUTED
    goto done;
  }

  information = api_information[ the_class ];
   46cd0:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
  if ( !information ) {
   46cd4:	6606           	bnes 46cdc <_Thread_Get+0x64>                     	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
   46cd6:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   46cd8:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
   46cda:	6012           	bras 46cee <_Thread_Get+0x76>                     	<== NOT EXECUTED
    goto done;
  }

  tp = (Thread_Control *) _Objects_Get( information, id, location );
   46cdc:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   46cde:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46ce0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46ce2:	4eb9 0004 646c 	jsr 4646c <_Objects_Get>                          	<== NOT EXECUTED
   46ce8:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

done:
  return tp;
}
   46cee:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46cf2:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
   46cf6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46cf8:	4e75           	rts                                               	<== NOT EXECUTED
    *location = OBJECTS_ERROR;
    goto done;
  }

  the_class = _Objects_Get_class( id );
  if ( the_class != 1 ) {       /* threads are always first class :) */
   46cfa:	761b           	moveq #27,%d3                                     	<== NOT EXECUTED
   46cfc:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46cfe:	e6a8           	lsrl %d3,%d0                                      	<== NOT EXECUTED
   46d00:	163c 0001      	moveb #1,%d3                                      	<== NOT EXECUTED
   46d04:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   46d06:	67b2           	beqs 46cba <_Thread_Get+0x42>                     	<== NOT EXECUTED
   46d08:	60be           	bras 46cc8 <_Thread_Get+0x50>                     	<== NOT EXECUTED
	...

0004aaac <_Thread_Handler>:
 *
 *  Output parameters:  NONE
 */

void _Thread_Handler( void )
{
   4aaac:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4aab0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
  static char doneConstructors;
  char doneCons;
#endif

  executing = _Thread_Executing;
   4aab2:	2479 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a2              	<== NOT EXECUTED
 *
 *  Output parameters:  NONE
 */

void _Thread_Handler( void )
{
   4aab8:	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;
   4aaba:	222a 00b6      	movel %a2@(182),%d1                               	<== NOT EXECUTED
  _ISR_Set_level(level);
   4aabe:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4aac0:	e189           	lsll #8,%d1                                       	<== NOT EXECUTED
   4aac2:	0280 0000 f8ff 	andil #63743,%d0                                  	<== NOT EXECUTED
   4aac8:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4aaca:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

#if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__)
  doneCons = doneConstructors;
   4aacc:	1439 0005 6494 	moveb 56494 <doneConstructors.4030>,%d2           	<== NOT EXECUTED
  doneConstructors = 1;
   4aad2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4aad4:	13c0 0005 6494 	moveb %d0,56494 <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 ) ) {
   4aada:	4aaa 0104      	tstl %a2@(260)                                    	<== NOT EXECUTED
   4aade:	6720           	beqs 4ab00 <_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 );
   4aae0:	2079 0005 6d2a 	moveal 56d2a <_Thread_Allocated_fp>,%a0           	<== NOT EXECUTED
   4aae6:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   4aae8:	6716           	beqs 4ab00 <_Thread_Handler+0x54>                 	<== NOT EXECUTED
    if ( _Thread_Allocated_fp != NULL )
   4aaea:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4aaec:	670c           	beqs 4aafa <_Thread_Handler+0x4e>                 	<== NOT EXECUTED
      _Context_Save_fp( &_Thread_Allocated_fp->fp_context );
   4aaee:	4868 0104      	pea %a0@(260)                                     	<== NOT EXECUTED
   4aaf2:	4eb9 0004 7ec4 	jsr 47ec4 <_CPU_Context_save_fp>                  	<== NOT EXECUTED
   4aaf8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    _Thread_Allocated_fp = executing;
   4aafa:	23ca 0005 6d2a 	movel %a2,56d2a <_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 );
   4ab00:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4ab02:	4eb9 0004 7a3c 	jsr 47a3c <_User_extensions_Thread_begin>         	<== NOT EXECUTED

  /*
   *  At this point, the dispatch disable level BETTER be 1.
   */

  _Thread_Enable_dispatch();
   4ab08:	4eb9 0004 6c4e 	jsr 46c4e <_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) */
   4ab0e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4ab10:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4ab12:	6606           	bnes 4ab1a <_Thread_Handler+0x6e>                 	<== NOT EXECUTED
  {
    _init ();
   4ab14:	4eb9 0005 393c 	jsr 5393c <_init>                                 	<== NOT EXECUTED
#if defined(__USE__MAIN__)
  if (!doneCons && _main)
    __main ();
#endif

  switch ( executing->Start.prototype ) {
   4ab1a:	202a 00a0      	movel %a2@(160),%d0                               	<== NOT EXECUTED
   4ab1e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4ab20:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4ab22:	671a           	beqs 4ab3e <_Thread_Handler+0x92>                 	<== NOT EXECUTED
   4ab24:	6212           	bhis 4ab38 <_Thread_Handler+0x8c>                 	<== NOT EXECUTED
   4ab26:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   4ab2a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4ab2c:	6722           	beqs 4ab50 <_Thread_Handler+0xa4>                 	<== NOT EXECUTED
   4ab2e:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   4ab32:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4ab34:	6644           	bnes 4ab7a <_Thread_Handler+0xce>                 	<== NOT EXECUTED
   4ab36:	602e           	bras 4ab66 <_Thread_Handler+0xba>                 	<== NOT EXECUTED
    case THREAD_START_NUMERIC:
      executing->Wait.return_argument =
   4ab38:	2f2a 00a8      	movel %a2@(168),%sp@-                             	<== NOT EXECUTED
   4ab3c:	6004           	bras 4ab42 <_Thread_Handler+0x96>                 	<== NOT EXECUTED
        (*(Thread_Entry_numeric) executing->Start.entry_point)(
          executing->Start.numeric_argument
      );
      break;
    case THREAD_START_POINTER:
      executing->Wait.return_argument =
   4ab3e:	2f2a 00a4      	movel %a2@(164),%sp@-                             	<== NOT EXECUTED
   4ab42:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4ab46:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4ab48:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   4ab4c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4ab4e:	602a           	bras 4ab7a <_Thread_Handler+0xce>                 	<== NOT EXECUTED
        (*(Thread_Entry_pointer) executing->Start.entry_point)(
          executing->Start.pointer_argument
        );
      break;
    case THREAD_START_BOTH_POINTER_FIRST:
      executing->Wait.return_argument =
   4ab50:	2f2a 00a8      	movel %a2@(168),%sp@-                             	<== NOT EXECUTED
   4ab54:	2f2a 00a4      	movel %a2@(164),%sp@-                             	<== NOT EXECUTED
   4ab58:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4ab5c:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4ab5e:	2540 0028      	movel %d0,%a2@(40)                                	<== NOT EXECUTED
   4ab62:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ab64:	6014           	bras 4ab7a <_Thread_Handler+0xce>                 	<== NOT EXECUTED
           executing->Start.pointer_argument,
           executing->Start.numeric_argument
         );
      break;
    case THREAD_START_BOTH_NUMERIC_FIRST:
      executing->Wait.return_argument =
   4ab66:	2f2a 00a4      	movel %a2@(164),%sp@-                             	<== NOT EXECUTED
   4ab6a:	2f2a 00a8      	movel %a2@(168),%sp@-                             	<== NOT EXECUTED
   4ab6e:	206a 009c      	moveal %a2@(156),%a0                              	<== NOT EXECUTED
   4ab72:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4ab74:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ab76:	2540 0028      	movel %d0,%a2@(40)                                	<== 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 );
   4ab7a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4ab7c:	4eb9 0004 7a6c 	jsr 47a6c <_User_extensions_Thread_exitted>       	<== NOT EXECUTED

  _Internal_error_Occurred(
   4ab82:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4ab86:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4ab8a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ab8c:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
	...

00046e90 <_Thread_Handler_initialization>:

  /*
   * BOTH stacks hooks must be set or both must be NULL.
   * Do not allow mixture.
   */
    if ( !( (!_Configuration_Table->stack_allocate_hook)
   46e90:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   46e96:	4aa8 0024      	tstl %a0@(36)                                     	<== NOT EXECUTED
   46e9a:	57c1           	seq %d1                                           	<== NOT EXECUTED
   46e9c:	4aa8 0020      	tstl %a0@(32)                                     	<== NOT EXECUTED
   46ea0:	57c0           	seq %d0                                           	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  ,
  uint32_t     maximum_proxies
#endif
)
{
   46ea2:	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)
   46ea6:	4480           	negl %d0                                          	<== NOT EXECUTED
   46ea8:	4481           	negl %d1                                          	<== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
  ,
  uint32_t     maximum_proxies
#endif
)
{
   46eaa:	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)
   46eac:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   46eae:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46eb0:	6710           	beqs 46ec2 <_Thread_Handler_initialization+0x32>  	<== NOT EXECUTED
            == (!_Configuration_Table->stack_free_hook) ) )
    _Internal_error_Occurred(
   46eb2:	4878 000f      	pea f <FPTRAP>                                    	<== NOT EXECUTED
   46eb6:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46eba:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   46ebc:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED

  _Thread_Maximum_extensions = maximum_extensions;

  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;

  _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error(
   46ec2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46ec4:	1039 0005 5192 	moveb 55192 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   46eca:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46ecc:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   46ece:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   46ed0:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
   46ed2:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   46ed4:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
  _Thread_Allocated_fp      = NULL;
#endif

  _Thread_Do_post_task_switch_extension = 0;

  _Thread_Maximum_extensions = maximum_extensions;
   46ed6:	41ee 000c      	lea %fp@(12),%a0                                  	<== NOT EXECUTED
   46eda:	23d0 0005 6d46 	movel %a0@,56d46 <_Thread_Maximum_extensions>     	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_BAD_STACK_HOOK
    );

  _Context_Switch_necessary = FALSE;
   46ee0:	4200           	clrb %d0                                          	<== NOT EXECUTED

  _Thread_Do_post_task_switch_extension = 0;

  _Thread_Maximum_extensions = maximum_extensions;

  _Thread_Ticks_per_timeslice  = ticks_per_timeslice;
   46ee2:	41ee 0008      	lea %fp@(8),%a0                                   	<== NOT EXECUTED
   46ee6:	23d0 0005 6c54 	movel %a0@,56c54 <_Thread_Ticks_per_timeslice>    	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_BAD_STACK_HOOK
    );

  _Context_Switch_necessary = FALSE;
   46eec:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED
  _Thread_Executing         = NULL;
   46ef2:	42b9 0005 6d62 	clrl 56d62 <_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++ )
   46ef8:	4282           	clrl %d2                                          	<== NOT EXECUTED
      INTERNAL_ERROR_BAD_STACK_HOOK
    );

  _Context_Switch_necessary = FALSE;
  _Thread_Executing         = NULL;
  _Thread_Heir              = NULL;
   46efa:	42b9 0005 6d32 	clrl 56d32 <_Thread_Heir>                         	<== NOT EXECUTED
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  _Thread_Allocated_fp      = NULL;
   46f00:	42b9 0005 6d2a 	clrl 56d2a <_Thread_Allocated_fp>                 	<== NOT EXECUTED
#endif

  _Thread_Do_post_task_switch_extension = 0;
   46f06:	42b9 0005 6d4a 	clrl 56d4a <_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(
   46f0c:	4eb9 0004 7e08 	jsr 47e08 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
    (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control)
  );

  for ( index=0; index <= PRIORITY_MAXIMUM ; index++ )
   46f12:	1439 0005 5192 	moveb 55192 <rtems_maximum_priority>,%d2          	<== NOT EXECUTED
   46f18:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   46f1a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46f1c:	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(
   46f1e:	23c0 0005 6c50 	movel %d0,56c50 <_Thread_Ready_chain>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   46f24:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   46f26:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   46f28:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
    (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control)
  );

  for ( index=0; index <= PRIORITY_MAXIMUM ; index++ )
   46f2a:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   46f2c:	42a8 0004      	clrl %a0@(4)                                      	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   46f30:	2148 0008      	movel %a0,%a0@(8)                                 	<== NOT EXECUTED
   46f34:	d1fc 0000 000c 	addal #12,%a0                                     	<== NOT EXECUTED
   46f3a:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   46f3c:	64e6           	bccs 46f24 <_Thread_Handler_initialization+0x94>  	<== NOT EXECUTED

  /*
   *  Initialize this class of objects.
   */

  _Objects_Initialize_information(
   46f3e:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   46f42:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46f46:	4878 0120      	pea 120 <FP_REGS_SAVED+0xe0>                      	<== NOT EXECUTED
   46f4a:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46f4e:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46f52:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   46f56:	4879 0005 6df6 	pea 56df6 <_Thread_Internal_information>          	<== NOT EXECUTED
   46f5c:	4eb9 0004 64c8 	jsr 464c8 <_Objects_Initialize_information>       	<== NOT EXECUTED
    FALSE,                      /* TRUE if this is a global object class */
    NULL                        /* Proxy extraction support callout */
#endif
  );

}
   46f62:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED

  /*
   *  Initialize this class of objects.
   */

  _Objects_Initialize_information(
   46f66:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
    FALSE,                      /* TRUE if this is a global object class */
    NULL                        /* Proxy extraction support callout */
#endif
  );

}
   46f6c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46f6e:	4e75           	rts

00046d0c <_Thread_Initialize>:
  Thread_CPU_budget_algorithms          budget_algorithm,
  Thread_CPU_budget_algorithm_callout   budget_callout,
  uint32_t                              isr_level,
  Objects_Name                          name
)
{
   46d0c:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   46d10:	48d7 047c      	moveml %d2-%d6/%a2,%sp@                           	<== NOT EXECUTED
   46d14:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   46d18:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   46d1c:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
   46d20:	282e 001c      	movel %fp@(28),%d4                                	<== NOT EXECUTED
   46d24:	2c2e 0024      	movel %fp@(36),%d6                                	<== NOT EXECUTED
   46d28:	162e 001b      	moveb %fp@(27),%d3                                	<== NOT EXECUTED
   46d2c:	1a2e 0023      	moveb %fp@(35),%d5                                	<== NOT EXECUTED
  /*
   *  Allocate and Initialize the stack for this thread.
   */


  if ( !stack_area ) {
   46d30:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   46d32:	6620           	bnes 46d54 <_Thread_Initialize+0x48>              	<== NOT EXECUTED

    actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
   46d34:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46d36:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46d38:	4eb9 0004 75fc 	jsr 475fc <_Thread_Stack_Allocate>                	<== NOT EXECUTED

    if ( !actual_stack_size || actual_stack_size < stack_size )
   46d3e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46d40:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46d42:	6700 013e      	beqw 46e82 <_Thread_Initialize+0x176>             	<== NOT EXECUTED
   46d46:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   46d48:	6200 0138      	bhiw 46e82 <_Thread_Initialize+0x176>             	<== NOT EXECUTED
      return FALSE;                     /* stack allocation failed */

    stack = the_thread->Start.stack;
   46d4c:	222a 00cc      	movel %a2@(204),%d1                               	<== NOT EXECUTED
    the_thread->Start.core_allocated_stack = TRUE;
   46d50:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   46d52:	6004           	bras 46d58 <_Thread_Initialize+0x4c>              	<== NOT EXECUTED
  } else {
    stack = stack_area;
    actual_stack_size = stack_size;
    the_thread->Start.core_allocated_stack = FALSE;
   46d54:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46d56:	4202           	clrb %d2                                          	<== NOT EXECUTED
   46d58:	1542 00be      	moveb %d2,%a2@(190)                               	<== NOT EXECUTED
  Stack_Control *the_stack,
  void          *starting_address,
  size_t         size
)
{
  the_stack->area = starting_address;
   46d5c:	2541 00c4      	movel %d1,%a2@(196)                               	<== NOT EXECUTED
  the_stack->size = size;
   46d60:	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 ) {
   46d64:	4a03           	tstb %d3                                          	<== NOT EXECUTED
   46d66:	6714           	beqs 46d7c <_Thread_Initialize+0x70>              	<== NOT EXECUTED

    fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
   46d68:	4878 001c      	pea 1c <OPER2+0x8>                                	<== NOT EXECUTED
   46d6c:	4eb9 0004 7df0 	jsr 47df0 <_Workspace_Allocate>                   	<== NOT EXECUTED
    if ( !fp_area ) {
   46d72:	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 );
   46d74:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
    if ( !fp_area ) {
   46d76:	6606           	bnes 46d7e <_Thread_Initialize+0x72>              	<== NOT EXECUTED
   46d78:	6000 00fe      	braw 46e78 <_Thread_Initialize+0x16c>             	<== NOT EXECUTED
      _Thread_Stack_Free( the_thread );
      return FALSE;
   46d7c:	4282           	clrl %d2                                          	<== NOT EXECUTED

  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
   46d7e:	2039 0005 6d46 	movel 56d46 <_Thread_Maximum_extensions>,%d0      	<== NOT EXECUTED
    fp_area = _Context_Fp_start( fp_area, 0 );

  } else
    fp_area = NULL;

  the_thread->fp_context       = fp_area;
   46d84:	2542 0104      	movel %d2,%a2@(260)                               	<== NOT EXECUTED
  the_thread->Start.fp_context = fp_area;
   46d88:	2542 00c8      	movel %d2,%a2@(200)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   46d8c:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   46d90:	42aa 0064      	clrl %a2@(100)                                    	<== NOT EXECUTED
  the_watchdog->id        = id;
   46d94:	42aa 0068      	clrl %a2@(104)                                    	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   46d98:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED

  /*
   * Clear the libc reent hook.
   */

  the_thread->libc_reent = NULL;
   46d9c:	42aa 0108      	clrl %a2@(264)                                    	<== NOT EXECUTED

  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
   46da0:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46da2:	6718           	beqs 46dbc <_Thread_Initialize+0xb0>              	<== NOT EXECUTED
    extensions_area = _Workspace_Allocate(
   46da4:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   46da6:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   46da8:	4868 0004      	pea %a0@(4)                                       	<== NOT EXECUTED
   46dac:	4eb9 0004 7df0 	jsr 47df0 <_Workspace_Allocate>                   	<== NOT EXECUTED
      (_Thread_Maximum_extensions + 1) * sizeof( void * )
    );

    if ( !extensions_area ) {
   46db2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  /*
   *  Allocate the extensions area for this thread
   */

  if ( _Thread_Maximum_extensions ) {
    extensions_area = _Workspace_Allocate(
   46db4:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
      (_Thread_Maximum_extensions + 1) * sizeof( void * )
    );

    if ( !extensions_area ) {
   46db6:	6606           	bnes 46dbe <_Thread_Initialize+0xb2>              	<== NOT EXECUTED
   46db8:	6000 00b0      	braw 46e6a <_Thread_Initialize+0x15e>             	<== NOT EXECUTED
        (void) _Workspace_Free( fp_area );
#endif

      _Thread_Stack_Free( the_thread );

      return FALSE;
   46dbc:	4283           	clrl %d3                                          	<== NOT EXECUTED
    }
  } else
    extensions_area = NULL;

  the_thread->extensions = (void **) extensions_area;
   46dbe:	2543 0118      	movel %d3,%a2@(280)                               	<== NOT EXECUTED
   * create the extension long after tasks have been created
   * so they cannot rely on the thread create user extension
   * call.
   */

  if ( the_thread->extensions ) {
   46dc2:	671a           	beqs 46dde <_Thread_Initialize+0xd2>              	<== NOT EXECUTED
   46dc4:	4281           	clrl %d1                                          	<== NOT EXECUTED
   46dc6:	600a           	bras 46dd2 <_Thread_Initialize+0xc6>              	<== NOT EXECUTED
    uint32_t i;
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
      the_thread->extensions[i] = NULL;
   46dc8:	206a 0118      	moveal %a2@(280),%a0                              	<== NOT EXECUTED
   46dcc:	42b0 1c00      	clrl %a0@(00000000,%d1:l:4)                       	<== NOT EXECUTED
   * call.
   */

  if ( the_thread->extensions ) {
    uint32_t i;
    for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ )
   46dd0:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   46dd2:	2039 0005 6d46 	movel 56d46 <_Thread_Maximum_extensions>,%d0      	<== NOT EXECUTED
   46dd8:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46dda:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   46ddc:	62ea           	bhis 46dc8 <_Thread_Initialize+0xbc>              	<== NOT EXECUTED

  /*
   *  General initialization
   */

  the_thread->Start.is_preemptible   = is_preemptible;
   46dde:	1545 00ac      	moveb %d5,%a2@(172)                               	<== NOT EXECUTED
  the_thread->Start.budget_algorithm = budget_algorithm;
   46de2:	2546 00ae      	movel %d6,%a2@(174)                               	<== NOT EXECUTED
  the_thread->Start.budget_callout   = budget_callout;

  switch ( budget_algorithm ) {
   46de6:	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;
   46de8:	256e 0028 00b2 	movel %fp@(40),%a2@(178)                          	<== NOT EXECUTED

  switch ( budget_algorithm ) {
   46dee:	b086           	cmpl %d6,%d0                                      	<== NOT EXECUTED
   46df0:	660a           	bnes 46dfc <_Thread_Initialize+0xf0>              	<== NOT EXECUTED
    case THREAD_CPU_BUDGET_ALGORITHM_NONE:
    case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE:
      break;
    case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE:
      the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
   46df2:	41f9 0005 6c54 	lea 56c54 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
   46df8:	2550 0078      	movel %a0@,%a2@(120)                              	<== 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 );
   46dfc:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
      break;
  }

  the_thread->Start.isr_level         = isr_level;

  the_thread->current_state           = STATES_DORMANT;
   46dfe:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
      break;
    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      break;
  }

  the_thread->Start.isr_level         = isr_level;
   46e00:	256e 002c 00b6 	movel %fp@(44),%a2@(182)                          	<== NOT EXECUTED

  the_thread->current_state           = STATES_DORMANT;
   46e06:	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 );
   46e0a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  }

  the_thread->Start.isr_level         = isr_level;

  the_thread->current_state           = STATES_DORMANT;
  the_thread->Wait.queue              = NULL;
   46e0c:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED
  the_thread->resource_count          = 0;
   46e10:	42aa 001c      	clrl %a2@(28)                                     	<== NOT EXECUTED
  the_thread->suspend_count           = 0;
   46e14:	42aa 0070      	clrl %a2@(112)                                    	<== NOT EXECUTED
  the_thread->real_priority           = priority;
   46e18:	2544 0018      	movel %d4,%a2@(24)                                	<== NOT EXECUTED
  the_thread->Start.initial_priority  = priority;
   46e1c:	2544 00ba      	movel %d4,%a2@(186)                               	<== NOT EXECUTED
  _Thread_Set_priority( the_thread, priority );
   46e20:	4eb9 0004 7424 	jsr 47424 <_Thread_Set_priority>                  	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   46e26:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   46e2a:	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;
   46e30:	2068 001a      	moveal %a0@(26),%a0                               	<== NOT EXECUTED
   46e34:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46e36:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   46e3a:	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;
   46e3e:	42aa 0084      	clrl %a2@(132)                                    	<== NOT EXECUTED
    the_thread->cpu_time_used.tv_nsec = 0;
   46e42:	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 );
   46e46:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46e48:	4eb9 0004 7ae8 	jsr 47ae8 <_User_extensions_Thread_create>        	<== NOT EXECUTED

  if ( !extension_status ) {
   46e4e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   46e54:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   46e56:	6704           	beqs 46e5c <_Thread_Initialize+0x150>             	<== NOT EXECUTED
   46e58:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46e5a:	6028           	bras 46e84 <_Thread_Initialize+0x178>             	<== NOT EXECUTED

    if ( extensions_area )
   46e5c:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   46e5e:	670a           	beqs 46e6a <_Thread_Initialize+0x15e>             	<== NOT EXECUTED
      (void) _Workspace_Free( extensions_area );
   46e60:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46e62:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
   46e68:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
    if ( fp_area )
   46e6a:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   46e6c:	670a           	beqs 46e78 <_Thread_Initialize+0x16c>             	<== NOT EXECUTED
      (void) _Workspace_Free( fp_area );
   46e6e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   46e70:	4eb9 0004 7dd8 	jsr 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
   46e76:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
#endif

    _Thread_Stack_Free( the_thread );
   46e78:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46e7a:	4eb9 0004 7648 	jsr 47648 <_Thread_Stack_Free>                    	<== NOT EXECUTED
   46e80:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

    return FALSE;
   46e82:	4200           	clrb %d0                                          	<== NOT EXECUTED
  }

  return TRUE;

}
   46e84:	4cee 047c ffe8 	moveml %fp@(-24),%d2-%d6/%a2                      	<== NOT EXECUTED
   46e8a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46e8c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049ed4 <_Thread_Load_environment>:
 */

void _Thread_Load_environment(
  Thread_Control *the_thread
)
{
   49ed4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49ed8:	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 ) {
   49edc:	2069 00c8      	moveal %a1@(200),%a0                              	<== NOT EXECUTED
   49ee0:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   49ee2:	6734           	beqs 49f18 <_Thread_Load_environment+0x44>        	<== NOT EXECUTED
    the_thread->fp_context = the_thread->Start.fp_context;
   49ee4:	2348 0104      	movel %a0,%a1@(260)                               	<== NOT EXECUTED
    _Context_Initialize_fp( &the_thread->fp_context );
   49ee8:	4281           	clrl %d1                                          	<== NOT EXECUTED
   49eea:	4280           	clrl %d0                                          	<== NOT EXECUTED
   49eec:	2141 0018      	movel %d1,%a0@(24)                                	<== NOT EXECUTED
   49ef0:	4241           	clrw %d1                                          	<== NOT EXECUTED
   49ef2:	2140 0014      	movel %d0,%a0@(20)                                	<== NOT EXECUTED
   49ef6:	3141 0002      	movew %d1,%a0@(2)                                 	<== NOT EXECUTED
   49efa:	3141 0004      	movew %d1,%a0@(4)                                 	<== NOT EXECUTED
   49efe:	3141 0006      	movew %d1,%a0@(6)                                 	<== NOT EXECUTED
   49f02:	3141 0008      	movew %d1,%a0@(8)                                 	<== NOT EXECUTED
   49f06:	3141 000a      	movew %d1,%a0@(10)                                	<== NOT EXECUTED
   49f0a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   49f0c:	4281           	clrl %d1                                          	<== NOT EXECUTED
   49f0e:	4250           	clrw %a0@                                         	<== NOT EXECUTED
   49f10:	2140 000c      	movel %d0,%a0@(12)                                	<== NOT EXECUTED
   49f14:	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(
   49f18:	2069 00c0      	moveal %a1@(192),%a0                              	<== NOT EXECUTED
   49f1c:	5988           	subql #4,%a0                                      	<== NOT EXECUTED
   49f1e:	d1e9 00c4      	addal %a1@(196),%a0                               	<== NOT EXECUTED
   49f22:	2029 00b6      	movel %a1@(182),%d0                               	<== NOT EXECUTED
   49f26:	2348 0100      	movel %a0,%a1@(256)                               	<== NOT EXECUTED
   49f2a:	e188           	lsll #8,%d0                                       	<== NOT EXECUTED
   49f2c:	0080 0000 3000 	oril #12288,%d0                                   	<== NOT EXECUTED
  } else
#endif
    is_fp = false;


  the_thread->do_post_task_switch_extension = false;
   49f32:	4201           	clrb %d1                                          	<== NOT EXECUTED
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
  the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
   49f34:	2369 00ae 007c 	movel %a1@(174),%a1@(124)                         	<== NOT EXECUTED
    the_thread->Start.isr_level,
    _Thread_Handler,
    is_fp
  );

}
   49f3a:	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;
   49f3c:	2369 00b2 0080 	movel %a1@(178),%a1@(128)                         	<== NOT EXECUTED
  } else
#endif
    is_fp = false;


  the_thread->do_post_task_switch_extension = false;
   49f42:	1341 0075      	moveb %d1,%a1@(117)                               	<== NOT EXECUTED
  the_thread->is_preemptible   = the_thread->Start.is_preemptible;
   49f46:	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(
   49f4c:	2340 00d0      	movel %d0,%a1@(208)                               	<== NOT EXECUTED
   49f50:	20bc 0004 aaac 	movel #305836,%a0@                                	<== NOT EXECUTED
    the_thread->Start.isr_level,
    _Thread_Handler,
    is_fp
  );

}
   49f56:	4e75           	rts

0004a180 <_Thread_Ready>:
 */

void _Thread_Ready(
  Thread_Control *the_thread
)
{
   4a180:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4a184:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@                       	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *heir;

  _ISR_Disable( level );
   4a188:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
 */

void _Thread_Ready(
  Thread_Control *the_thread
)
{
   4a18e:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *heir;

  _ISR_Disable( level );
   4a192:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a194:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   4a196:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   4a198:	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 );
   4a19a:	2268 008c      	moveal %a0@(140),%a1                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4a19e:	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;
   4a1a0:	2468 0090      	moveal %a0@(144),%a2                              	<== NOT EXECUTED
   4a1a4:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4a1a6:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   4a1a8:	2669 0008      	moveal %a1@(8),%a3                                	<== NOT EXECUTED
   4a1ac:	3228 0096      	movew %a0@(150),%d1                               	<== NOT EXECUTED
   4a1b0:	3012           	movew %a2@,%d0                                    	<== NOT EXECUTED
   4a1b2:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a1b4:	3480           	movew %d0,%a2@                                    	<== NOT EXECUTED
  the_chain->last     = the_node;
   4a1b6:	2348 0008      	movel %a0,%a1@(8)                                 	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   4a1ba:	3239 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   4a1c0:	3028 0094      	movew %a0@(148),%d0                               	<== NOT EXECUTED
   4a1c4:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4a1c6:	214b 0004      	movel %a3,%a0@(4)                                 	<== NOT EXECUTED
   4a1ca:	33c0 0005 6d58 	movew %d0,56d58 <_Priority_Major_bit_map>         	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *heir;

  _ISR_Disable( level );

  the_thread->current_state = STATES_READY;
   4a1d0:	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;
   4a1d4:	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 );
   4a1d6:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   4a1d8:	8483           	orl %d3,%d2                                       	<== NOT EXECUTED
   4a1da:	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 );
   4a1dc:	3039 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   4a1e2:	4840           	swap %d0                                          	<== NOT EXECUTED
   4a1e4:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   4a1e6:	41f9 0005 6dc8 	lea 56dc8 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   4a1ec:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   4a1f2:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   4a1f6:	4841           	swap %d1                                          	<== NOT EXECUTED
   4a1f8:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   4a1fa:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   4a200:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   4a202:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4a204:	2079 0005 6c50 	moveal 56c50 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   4a20a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4a20c:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   4a20e:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   4a210:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
   4a212:	2030 1800      	movel %a0@(00000000,%d1:l),%d0                    	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
  const Thread_Control *the_thread
)
{
  return ( the_thread == _Thread_Executing );
   4a216:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   4a21c:	23c0 0005 6d32 	movel %d0,56d32 <_Thread_Heir>                    	<== NOT EXECUTED

  _Thread_Calculate_heir();

  heir = _Thread_Heir;

  if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible )
   4a222:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   4a224:	670e           	beqs 4a234 <_Thread_Ready+0xb4>                   	<== NOT EXECUTED
   4a226:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   4a22a:	6708           	beqs 4a234 <_Thread_Ready+0xb4>                   	<== NOT EXECUTED
    _Context_Switch_necessary = TRUE;
   4a22c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4a22e:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   4a234:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
}
   4a236:	4cd7 0c0c      	moveml %sp@,%d2-%d3/%a2-%a3                       	<== NOT EXECUTED
   4a23a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a23c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004aa7c <_Thread_Reset>:
void _Thread_Reset(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   4aa7c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4aa80:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4aa82:	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;
   4aa86:	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;
   4aa8c:	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;
   4aa92:	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;
   4aa98:	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;
   4aa9c:	256a 00ae 007c 	movel %a2@(174),%a2@(124)                         	<== NOT EXECUTED
  the_thread->budget_callout   = the_thread->Start.budget_callout;
   4aaa2:	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;
   4aaa8:	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 ) ) {
   4aaac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4aaae:	4eb9 0004 7a14 	jsr 47a14 <_Thread_queue_Extract_with_proxy>      	<== NOT EXECUTED
   4aab4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4aab6:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4aab8:	6614           	bnes 4aace <_Thread_Reset+0x52>                   	<== NOT EXECUTED

    if ( _Watchdog_Is_active( &the_thread->Timer ) )
   4aaba:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4aabc:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4aac0:	660c           	bnes 4aace <_Thread_Reset+0x52>                   	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );
   4aac2:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4aac6:	4eb9 0004 851c 	jsr 4851c <_Watchdog_Remove>                      	<== NOT EXECUTED
   4aacc:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  }

  if ( the_thread->current_priority != the_thread->Start.initial_priority ) {
   4aace:	202a 00ba      	movel %a2@(186),%d0                               	<== NOT EXECUTED
   4aad2:	b0aa 0014      	cmpl %a2@(20),%d0                                 	<== NOT EXECUTED
   4aad6:	6718           	beqs 4aaf0 <_Thread_Reset+0x74>                   	<== NOT EXECUTED
    the_thread->real_priority = the_thread->Start.initial_priority;
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
   4aad8:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
   4aadc:	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;
   4aae0:	2540 0018      	movel %d0,%a2@(24)                                	<== NOT EXECUTED
    _Thread_Set_priority( the_thread, the_thread->Start.initial_priority );
  }
}
   4aae4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4aae8:	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 );
   4aaea:	4ef9 0004 7c28 	jmp 47c28 <_Thread_Set_priority>                  	<== NOT EXECUTED
  }
}
   4aaf0:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4aaf4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4aaf6:	4e75           	rts

0004a240 <_Thread_Reset_timeslice>:
 *    ready chain
 *    select heir
 */

void _Thread_Reset_timeslice( void )
{
   4a240:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4a244:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
   4a248:	2479 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  ready     = executing->ready;
  _ISR_Disable( level );
   4a24e:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
  ready     = executing->ready;
   4a254:	266a 008c      	moveal %a2@(140),%a3                              	<== NOT EXECUTED
  _ISR_Disable( level );
   4a258:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a25a:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4a25c:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a25e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( _Chain_Has_only_one_node( ready ) ) {
   4a260:	202b 0008      	movel %a3@(8),%d0                                 	<== NOT EXECUTED
   4a264:	b093           	cmpl %a3@,%d0                                     	<== NOT EXECUTED
   4a266:	6604           	bnes 4a26c <_Thread_Reset_timeslice+0x2c>         	<== NOT EXECUTED
      _ISR_Enable( level );
   4a268:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4a26a:	6040           	bras 4a2ac <_Thread_Reset_timeslice+0x6c>         	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   4a26c:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   4a26e:	226a 0004      	moveal %a2@(4),%a1                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   4a272:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4a274:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   4a276:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4a278:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   4a27a:	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;
   4a27e:	206b 0008      	moveal %a3@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   4a282:	274a 0008      	movel %a2,%a3@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4a286:	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;
   4a28a:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
      return;
    }
    _Chain_Extract_unprotected( &executing->Object.Node );
    _Chain_Append_unprotected( ready, &executing->Object.Node );

  _ISR_Flash( level );
   4a28c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a28e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4a290:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a292:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    if ( _Thread_Is_heir( executing ) )
   4a294:	b5f9 0005 6d32 	cmpal 56d32 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   4a29a:	6606           	bnes 4a2a2 <_Thread_Reset_timeslice+0x62>         	<== NOT EXECUTED
      _Thread_Heir = (Thread_Control *) ready->first;
   4a29c:	23d3 0005 6d32 	movel %a3@,56d32 <_Thread_Heir>                   	<== NOT EXECUTED

    _Context_Switch_necessary = TRUE;
   4a2a2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4a2a4:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   4a2aa:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
}
   4a2ac:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   4a2b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a2b2:	4e75           	rts

00047b8c <_Thread_Restart>:
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   47b8c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47b90:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47b92:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
   47b96:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   47b98:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
   47b9a:	c0aa 0010      	andl %a2@(16),%d0                                 	<== NOT EXECUTED
   47b9e:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   47ba0:	6704           	beqs 47ba6 <_Thread_Restart+0x1a>                 	<== NOT EXECUTED
   47ba2:	4202           	clrb %d2                                          	<== NOT EXECUTED
   47ba4:	6072           	bras 47c18 <_Thread_Restart+0x8c>                 	<== NOT EXECUTED

    _Thread_Set_transient( the_thread );
   47ba6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47ba8:	4eb9 0004 7d80 	jsr 47d80 <_Thread_Set_transient>                 	<== NOT EXECUTED

    _Thread_Reset( the_thread, pointer_argument, numeric_argument );
   47bae:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   47bb2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   47bb6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47bb8:	4eb9 0004 aa7c 	jsr 4aa7c <_Thread_Reset>                         	<== NOT EXECUTED

    _Thread_Load_environment( the_thread );
   47bbe:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47bc0:	4eb9 0004 a710 	jsr 4a710 <_Thread_Load_environment>              	<== NOT EXECUTED

    _Thread_Ready( the_thread );
   47bc6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47bc8:	4eb9 0004 a9bc 	jsr 4a9bc <_Thread_Ready>                         	<== NOT EXECUTED

    _User_extensions_Thread_restart( the_thread );
   47bce:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47bd0:	4eb9 0004 8360 	jsr 48360 <_User_extensions_Thread_restart>       	<== NOT EXECUTED

    if ( _Thread_Is_executing ( the_thread ) )
   47bd6:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   47bdc:	b5f9 0005 86aa 	cmpal 586aa <_Thread_Executing>,%a2               	<== NOT EXECUTED
   47be2:	6704           	beqs 47be8 <_Thread_Restart+0x5c>                 	<== NOT EXECUTED
   47be4:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   47be6:	6030           	bras 47c18 <_Thread_Restart+0x8c>                 	<== 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 )
   47be8:	4aaa 0104      	tstl %a2@(260)                                    	<== NOT EXECUTED
   47bec:	670c           	beqs 47bfa <_Thread_Restart+0x6e>                 	<== NOT EXECUTED
    _Context_Restore_fp( &_Thread_Executing->fp_context );
   47bee:	486a 0104      	pea %a2@(260)                                     	<== NOT EXECUTED
   47bf2:	4eb9 0004 8704 	jsr 48704 <_CPU_Context_restore_fp>               	<== NOT EXECUTED
   47bf8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
#endif

  _CPU_Context_Restart_self( &_Thread_Executing->Registers );
   47bfa:	2079 0005 86aa 	moveal 586aa <_Thread_Executing>,%a0              	<== NOT EXECUTED
   47c00:	2228 00d0      	movel %a0@(208),%d1                               	<== NOT EXECUTED
   47c04:	2028 0100      	movel %a0@(256),%d0                               	<== NOT EXECUTED
   47c08:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   47c0a:	2e40           	moveal %d0,%sp                                    	<== NOT EXECUTED
   47c0c:	4e75           	rts                                               	<== NOT EXECUTED
   47c0e:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   47c10:	2140 0100      	movel %d0,%a0@(256)                               	<== NOT EXECUTED
   47c14:	2141 00d0      	movel %d1,%a0@(208)                               	<== NOT EXECUTED

    return TRUE;
  }

  return FALSE;
}
   47c18:	1002           	moveb %d2,%d0                                     	<== NOT EXECUTED
   47c1a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47c1e:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47c22:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47c24:	4e75           	rts                                               	<== NOT EXECUTED
	...

000485ec <_Thread_Resume>:

void _Thread_Resume(
  Thread_Control   *the_thread,
  bool              force
)
{
   485ec:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   485f0:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   485f4:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   485f8:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED

  ISR_Level       level;
  States_Control  current_state;

  _ISR_Disable( level );
   485fc:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   48602:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   48604:	8282           	orl %d2,%d1                                       	<== NOT EXECUTED
   48606:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  if ( force == TRUE )
   48608:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4860a:	6706           	beqs 48612 <_Thread_Resume+0x26>                  	<== NOT EXECUTED
    the_thread->suspend_count = 0;
   4860c:	42ab 0070      	clrl %a3@(112)                                    	<== NOT EXECUTED
   48610:	6004           	bras 48616 <_Thread_Resume+0x2a>                  	<== NOT EXECUTED
  else
    the_thread->suspend_count--;
   48612:	53ab 0070      	subql #1,%a3@(112)                                	<== NOT EXECUTED

  if ( the_thread->suspend_count > 0 ) {
   48616:	4aab 0070      	tstl %a3@(112)                                    	<== NOT EXECUTED
   4861a:	6706           	beqs 48622 <_Thread_Resume+0x36>                  	<== NOT EXECUTED
    _ISR_Enable( level );
   4861c:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   4861e:	6000 008a      	braw 486aa <_Thread_Resume+0xbe>                  	<== NOT EXECUTED
    return;
  }

  current_state = the_thread->current_state;
   48622:	202b 0010      	movel %a3@(16),%d0                                	<== NOT EXECUTED
  if ( current_state & STATES_SUSPENDED ) {
   48626:	0800 0001      	btst #1,%d0                                       	<== NOT EXECUTED
   4862a:	677c           	beqs 486a8 <_Thread_Resume+0xbc>                  	<== NOT EXECUTED
   4862c:	72fd           	moveq #-3,%d1                                     	<== NOT EXECUTED
   4862e:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
    current_state =
   48630:	2740 0010      	movel %d0,%a3@(16)                                	<== NOT EXECUTED
    the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state);

    if ( _States_Is_ready( current_state ) ) {
   48634:	6672           	bnes 486a8 <_Thread_Resume+0xbc>                  	<== NOT EXECUTED

      _Priority_Add_to_bit_map( &the_thread->Priority_map );

      _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node);
   48636:	206b 008c      	moveal %a3@(140),%a0                              	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4863a:	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;
   4863c:	226b 0090      	moveal %a3@(144),%a1                              	<== NOT EXECUTED
   48640:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   48642:	2680           	movel %d0,%a3@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   48644:	2468 0008      	moveal %a0@(8),%a2                                	<== NOT EXECUTED
   48648:	322b 0096      	movew %a3@(150),%d1                               	<== NOT EXECUTED
   4864c:	3011           	movew %a1@,%d0                                    	<== NOT EXECUTED
   4864e:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   48650:	3280           	movew %d0,%a1@                                    	<== NOT EXECUTED
  the_chain->last     = the_node;
   48652:	214b 0008      	movel %a3,%a0@(8)                                 	<== NOT EXECUTED
  _Priority_Major_bit_map  |= the_priority_map->ready_major;
   48656:	3239 0006 1080 	movew 61080 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   4865c:	302b 0094      	movew %a3@(148),%d0                               	<== NOT EXECUTED
   48660:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   48662:	33c0 0006 1080 	movew %d0,61080 <_Priority_Major_bit_map>         	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   48668:	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;
   4866c:	248b           	movel %a3,%a2@                                    	<== NOT EXECUTED

      _ISR_Flash( level );
   4866e:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   48674:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   48676:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   48678:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      if ( the_thread->current_priority < _Thread_Heir->current_priority ) {
   4867a:	2079 0006 105a 	moveal 6105a <_Thread_Heir>,%a0                   	<== NOT EXECUTED
   48680:	202b 0014      	movel %a3@(20),%d0                                	<== NOT EXECUTED
   48684:	b0a8 0014      	cmpl %a0@(20),%d0                                 	<== NOT EXECUTED
   48688:	641e           	bccs 486a8 <_Thread_Resume+0xbc>                  	<== NOT EXECUTED
        _Thread_Heir = the_thread;
        if ( _Thread_Executing->is_preemptible ||
   4868a:	2079 0006 108a 	moveal 6108a <_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;
   48690:	23cb 0006 105a 	movel %a3,6105a <_Thread_Heir>                    	<== NOT EXECUTED
        if ( _Thread_Executing->is_preemptible ||
   48696:	4a28 0076      	tstb %a0@(118)                                    	<== NOT EXECUTED
   4869a:	6604           	bnes 486a0 <_Thread_Resume+0xb4>                  	<== NOT EXECUTED
   4869c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4869e:	6608           	bnes 486a8 <_Thread_Resume+0xbc>                  	<== NOT EXECUTED
             the_thread->current_priority == 0 )
          _Context_Switch_necessary = TRUE;
   486a0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   486a2:	13c1 0006 109a 	moveb %d1,6109a <_Context_Switch_necessary>       	<== NOT EXECUTED
      }
    }
  }

  _ISR_Enable( level );
   486a8:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   486aa:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   486ae:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   486b0:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047424 <_Thread_Set_priority>:

void _Thread_Set_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority
)
{
   47424:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   47428:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   4742c:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   47430:	48d7 003c      	moveml %d2-%d5,%sp@                               	<== NOT EXECUTED
  the_thread->current_priority = new_priority;
  the_thread->ready            = &_Thread_Ready_chain[ new_priority ];
   47434:	2800           	movel %d0,%d4                                     	<== NOT EXECUTED
   47436:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
{
  Priority_Bit_map_control major;
  Priority_Bit_map_control minor;
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
   47438:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   4743a:	720f           	moveq #15,%d1                                     	<== NOT EXECUTED
void _Thread_Set_priority(
  Thread_Control   *the_thread,
  Priority_Control  new_priority
)
{
  the_thread->current_priority = new_priority;
   4743c:	2140 0014      	movel %d0,%a0@(20)                                	<== NOT EXECUTED
   47440:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
  the_thread->ready            = &_Thread_Ready_chain[ new_priority ];
   47442:	e58c           	lsll #2,%d4                                       	<== NOT EXECUTED
   47444:	e98b           	lsll #4,%d3                                       	<== NOT EXECUTED
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
   47446:	323c 8000      	movew #-32768,%d1                                 	<== NOT EXECUTED
   4744a:	9684           	subl %d4,%d3                                      	<== NOT EXECUTED
{
  Priority_Bit_map_control major;
  Priority_Bit_map_control minor;
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
   4744c:	e88a           	lsrl #4,%d2                                       	<== NOT EXECUTED
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   4744e:	0282 0000 ffff 	andil #65535,%d2                                  	<== NOT EXECUTED

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   47454:	2a01           	movel %d1,%d5                                     	<== NOT EXECUTED
   47456:	d6b9 0005 6c50 	addl 56c50 <_Thread_Ready_chain>,%d3              	<== NOT EXECUTED
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
   4745c:	e4a1           	asrl %d2,%d1                                      	<== NOT EXECUTED
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   4745e:	d482           	addl %d2,%d2                                      	<== NOT EXECUTED

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   47460:	e0a5           	asrl %d0,%d5                                      	<== NOT EXECUTED
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   47462:	0682 0005 6dc8 	addil #355784,%d2                                 	<== NOT EXECUTED

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;

  mask = _Priority_Mask( minor );
   47468:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
  the_priority_map->ready_minor = mask;
   4746a:	3145 0096      	movew %d5,%a0@(150)                               	<== NOT EXECUTED
   4746e:	2143 008c      	movel %d3,%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;
   47472:	3141 0094      	movew %d1,%a0@(148)                               	<== NOT EXECUTED
  the_priority_map->block_major = ~mask;
   47476:	4681           	notl %d1                                          	<== NOT EXECUTED
  Priority_Bit_map_control mask;

  major = _Priority_Major( new_priority );
  minor = _Priority_Minor( new_priority );

  the_priority_map->minor =
   47478:	2142 0090      	movel %d2,%a0@(144)                               	<== NOT EXECUTED

  _Priority_Initialize_information( &the_thread->Priority_map, new_priority );
}
   4747c:	4cd7 003c      	moveml %sp@,%d2-%d5                               	<== 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;
   47480:	4680           	notl %d0                                          	<== NOT EXECUTED
   47482:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47484:	3140 009a      	movew %d0,%a0@(154)                               	<== NOT EXECUTED
  the_priority_map->minor =
    &_Priority_Bit_map[ _Priority_Bits_index(major) ];

  mask = _Priority_Mask( major );
  the_priority_map->ready_major = mask;
  the_priority_map->block_major = ~mask;
   47488:	3141 0098      	movew %d1,%a0@(152)                               	<== NOT EXECUTED
   4748c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047490 <_Thread_Set_state>:

void _Thread_Set_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   47490:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47494:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47496:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4749a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
   4749c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED

void _Thread_Set_state(
  Thread_Control *the_thread,
  States_Control  state
)
{
   474a2:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
   474a6:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
  _ISR_Disable( level );
   474aa:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   474ac:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   474ae:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  if ( !_States_Is_ready( the_thread->current_state ) ) {
   474b0:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   474b4:	670c           	beqs 474c2 <_Thread_Set_state+0x32>               	<== NOT EXECUTED
    the_thread->current_state =
   474b6:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   474b8:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED
       _States_Set( state, the_thread->current_state );
    _ISR_Enable( level );
   474bc:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   474be:	6000 00b2      	braw 47572 <_Thread_Set_state+0xe2>               	<== NOT EXECUTED
    return;
  }

  the_thread->current_state = state;

  if ( _Chain_Has_only_one_node( ready ) ) {
   474c2:	2029 0008      	movel %a1@(8),%d0                                 	<== NOT EXECUTED
       _States_Set( state, the_thread->current_state );
    _ISR_Enable( level );
    return;
  }

  the_thread->current_state = state;
   474c6:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED

  if ( _Chain_Has_only_one_node( ready ) ) {
   474ca:	b091           	cmpl %a1@,%d0                                     	<== NOT EXECUTED
   474cc:	6634           	bnes 47502 <_Thread_Set_state+0x72>               	<== 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;
   474ce:	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);
   474d2:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   474d4:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   474d6:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
   474d8:	3210           	movew %a0@,%d1                                    	<== NOT EXECUTED
   474da:	302a 009a      	movew %a2@(154),%d0                               	<== NOT EXECUTED
   474de:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   474e0:	2349 0008      	movel %a1,%a1@(8)                                 	<== NOT EXECUTED
   474e4:	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;
   474e6:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )
   474ea:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   474ec:	6620           	bnes 4750e <_Thread_Set_state+0x7e>               	<== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;
   474ee:	3239 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   474f4:	302a 0098      	movew %a2@(152),%d0                               	<== NOT EXECUTED
   474f8:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   474fa:	33c0 0005 6d58 	movew %d0,56d58 <_Priority_Major_bit_map>         	<== NOT EXECUTED
   47500:	600c           	bras 4750e <_Thread_Set_state+0x7e>               	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   47502:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   47504:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   47508:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   4750a:	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 );
   4750e:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   47514:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   47516:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47518:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
   4751a:	b5f9 0005 6d32 	cmpal 56d32 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   47520:	663e           	bnes 47560 <_Thread_Set_state+0xd0>               	<== 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 );
   47522:	3039 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   47528:	4840           	swap %d0                                          	<== NOT EXECUTED
   4752a:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   4752c:	41f9 0005 6dc8 	lea 56dc8 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   47532:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   47538:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   4753c:	4841           	swap %d1                                          	<== NOT EXECUTED
   4753e:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
 *  ready thread.
 */

RTEMS_INLINE_ROUTINE void _Thread_Calculate_heir( void )
{
  _Thread_Heir = (Thread_Control *)
   47540:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   47546:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   47548:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4754a:	2079 0005 6c50 	moveal 56c50 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   47550:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   47552:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   47554:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
   47556:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   47558:	d1c1           	addal %d1,%a0                                     	<== NOT EXECUTED
   4755a:	23d0 0005 6d32 	movel %a0@,56d32 <_Thread_Heir>                   	<== NOT EXECUTED
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
   47560:	b5f9 0005 6d62 	cmpal 56d62 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   47566:	6608           	bnes 47570 <_Thread_Set_state+0xe0>               	<== NOT EXECUTED
    _Context_Switch_necessary = TRUE;
   47568:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4756a:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   47570:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   47572:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47574:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   47576:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47578:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004757c <_Thread_Set_transient>:
 */

void _Thread_Set_transient(
  Thread_Control *the_thread
)
{
   4757c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47580:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47582:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   47586:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level             level;
  uint32_t              old_state;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
   47588:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
{
  ISR_Level             level;
  uint32_t              old_state;
  Chain_Control *ready;

  ready = the_thread->ready;
   4758e:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
  _ISR_Disable( level );
   47592:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   47594:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47596:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  old_state = the_thread->current_state;
   47598:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
  the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
   4759c:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
   4759e:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   475a0:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED

  if ( _States_Is_ready( old_state ) ) {
   475a4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   475a6:	6648           	bnes 475f0 <_Thread_Set_transient+0x74>           	<== NOT EXECUTED
    if ( _Chain_Has_only_one_node( ready ) ) {
   475a8:	2029 0008      	movel %a1@(8),%d0                                 	<== NOT EXECUTED
   475ac:	b091           	cmpl %a1@,%d0                                     	<== NOT EXECUTED
   475ae:	6634           	bnes 475e4 <_Thread_Set_transient+0x68>           	<== 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;
   475b0:	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);
   475b4:	2209           	movel %a1,%d1                                     	<== NOT EXECUTED
   475b6:	5881           	addql #4,%d1                                      	<== NOT EXECUTED
   475b8:	2281           	movel %d1,%a1@                                    	<== NOT EXECUTED
   475ba:	3210           	movew %a0@,%d1                                    	<== NOT EXECUTED
   475bc:	302a 009a      	movew %a2@(154),%d0                               	<== NOT EXECUTED
   475c0:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   475c2:	2349 0008      	movel %a1,%a1@(8)                                 	<== NOT EXECUTED
   475c6:	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;
   475c8:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )
   475cc:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   475ce:	6620           	bnes 475f0 <_Thread_Set_transient+0x74>           	<== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;
   475d0:	302a 0098      	movew %a2@(152),%d0                               	<== NOT EXECUTED
   475d4:	3239 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   475da:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   475dc:	33c0 0005 6d58 	movew %d0,56d58 <_Priority_Major_bit_map>         	<== NOT EXECUTED
   475e2:	600c           	bras 475f0 <_Thread_Set_transient+0x74>           	<== NOT EXECUTED
{
  Chain_Node *next;
  Chain_Node *previous;

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

  next           = the_node->next;
   475e8:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
  next->previous = previous;
  previous->next = next;
   475ea:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   475ec:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED

    } else
      _Chain_Extract_unprotected( &the_thread->Object.Node );
  }

  _ISR_Enable( level );
   475f0:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

}
   475f2:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   475f4:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   475f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   475f8:	4e75           	rts                                               	<== NOT EXECUTED
	...

000475fc <_Thread_Stack_Allocate>:

size_t _Thread_Stack_Allocate(
  Thread_Control *the_thread,
  size_t          stack_size
)
{
   475fc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47600:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47602:	2039 0005 518e 	movel 5518e <rtems_minimum_stack_size>,%d0        	<== NOT EXECUTED
   47608:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   4760c:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   4760e:	6302           	blss 47612 <_Thread_Stack_Allocate+0x16>          	<== NOT EXECUTED
   47610:	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 ) {
   47612:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47618:	2068 0020      	moveal %a0@(32),%a0                               	<== NOT EXECUTED
   4761c:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4761e:	6706           	beqs 47626 <_Thread_Stack_Allocate+0x2a>          	<== NOT EXECUTED
    stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size );
   47620:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47622:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47624:	6008           	bras 4762e <_Thread_Stack_Allocate+0x32>          	<== NOT EXECUTED
     *  get and keep the stack adjust factor, the stack alignment, and
     *  the context initialization sequence in sync.
     */

    the_stack_size = _Stack_Adjust_size( the_stack_size );
    stack_addr = _Workspace_Allocate( the_stack_size );
   47626:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47628:	4eb9 0004 7df0 	jsr 47df0 <_Workspace_Allocate>                   	<== NOT EXECUTED
   4762e:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
  }

  if ( !stack_addr )
   47630:	56c0           	sne %d0                                           	<== NOT EXECUTED
   47632:	49c0           	extbl %d0                                         	<== NOT EXECUTED
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;

  return the_stack_size;
}
   47634:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
  }

  if ( !stack_addr )
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;
   47636:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED

  return the_stack_size;
}
   4763a:	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 );
   4763e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;

  return the_stack_size;
}
   47640:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  }

  if ( !stack_addr )
    the_stack_size = 0;

  the_thread->Start.stack = stack_addr;
   47642:	2141 00cc      	movel %d1,%a0@(204)                               	<== NOT EXECUTED

  return the_stack_size;
}
   47646:	4e75           	rts

00047648 <_Thread_Stack_Free>:
 */

void _Thread_Stack_Free(
  Thread_Control *the_thread
)
{
   47648:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4764c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4764e:	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 )
   47652:	4a2a 00be      	tstb %a2@(190)                                    	<== NOT EXECUTED
   47656:	672a           	beqs 47682 <_Thread_Stack_Free+0x3a>              	<== 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 )
   47658:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   4765e:	2028 0024      	movel %a0@(36),%d0                                	<== NOT EXECUTED
   47662:	670e           	beqs 47672 <_Thread_Stack_Free+0x2a>              	<== NOT EXECUTED
      (*_Configuration_Table->stack_free_hook)(
   47664:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   47666:	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 );
}
   4766c:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4766e:	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)(
   47670:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
        the_thread->Start.Initial_stack.area
      );
    else
        _Workspace_Free( the_thread->Start.Initial_stack.area );
   47672:	2d6a 00c4 0008 	movel %a2@(196),%fp@(8)                           	<== NOT EXECUTED
}
   47678:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4767a:	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 );
   4767c:	4ef9 0004 7dd8 	jmp 47dd8 <_Workspace_Free>                       	<== NOT EXECUTED
}
   47682:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   47684:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47686:	4e75           	rts

000476dc <_Thread_Start>:
  Thread_Start_types         the_prototype,
  void                      *entry_point,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   476dc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   476e0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   476e2:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  if ( _States_Is_dormant( the_thread->current_state ) ) {
   476e6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   476e8:	c0aa 0010      	andl %a2@(16),%d0                                 	<== NOT EXECUTED
   476ec:	6738           	beqs 47726 <_Thread_Start+0x4a>                   	<== 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 );
   476ee:	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;
   476f0:	256e 0010 009c 	movel %fp@(16),%a2@(156)                          	<== NOT EXECUTED

    the_thread->Start.prototype        = the_prototype;
   476f6:	256e 000c 00a0 	movel %fp@(12),%a2@(160)                          	<== NOT EXECUTED
    the_thread->Start.pointer_argument = pointer_argument;
   476fc:	256e 0014 00a4 	movel %fp@(20),%a2@(164)                          	<== NOT EXECUTED
    the_thread->Start.numeric_argument = numeric_argument;
   47702:	256e 0018 00a8 	movel %fp@(24),%a2@(168)                          	<== NOT EXECUTED

    _Thread_Load_environment( the_thread );
   47708:	4eb9 0004 9ed4 	jsr 49ed4 <_Thread_Load_environment>              	<== NOT EXECUTED

    _Thread_Ready( the_thread );
   4770e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47710:	4eb9 0004 a180 	jsr 4a180 <_Thread_Ready>                         	<== NOT EXECUTED

    _User_extensions_Thread_start( the_thread );
   47716:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47718:	4eb9 0004 7b5c 	jsr 47b5c <_User_extensions_Thread_start>         	<== NOT EXECUTED
   4771e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   47724:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

    return true;
  }

  return false;
}
   47726:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4772a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4772c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047688 <_Thread_Start_multitasking>:
   47688:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED

  _System_state_Set( SYSTEM_STATE_UP );

  _Context_Switch_necessary = FALSE;

  _Thread_Executing = _Thread_Heir;
   4768a:	2079 0005 6d32 	moveal 56d32 <_Thread_Heir>,%a0                   	<== NOT EXECUTED
   47690:	23c0 0005 6e36 	movel %d0,56e36 <_System_state_Current>           	<== NOT EXECUTED
   *  the system is shut down.
   */

  _System_state_Set( SYSTEM_STATE_UP );

  _Context_Switch_necessary = FALSE;
   47696:	4200           	clrb %d0                                          	<== NOT EXECUTED
 *    ready chain
 *    select heir
 */

void _Thread_Start_multitasking( void )
{
   47698:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   *  the system is shut down.
   */

  _System_state_Set( SYSTEM_STATE_UP );

  _Context_Switch_necessary = FALSE;
   4769c:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _Thread_Executing = _Thread_Heir;
   476a2:	23c8 0005 6d62 	movel %a0,56d62 <_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 )
   476a8:	4aa8 0104      	tstl %a0@(260)                                    	<== NOT EXECUTED
   476ac:	670c           	beqs 476ba <_Thread_Start_multitasking+0x32>      	<== NOT EXECUTED
     _Context_Restore_fp( &_Thread_Heir->fp_context );
   476ae:	4868 0104      	pea %a0@(260)                                     	<== NOT EXECUTED
   476b2:	4eb9 0004 7ec8 	jsr 47ec8 <_CPU_Context_restore_fp>               	<== NOT EXECUTED
   476b8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
#endif

  _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers );
   476ba:	2039 0005 6d32 	movel 56d32 <_Thread_Heir>,%d0                    	<== NOT EXECUTED
   476c0:	0680 0000 00d0 	addil #208,%d0                                    	<== NOT EXECUTED
   476c6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   476c8:	4879 0005 6c70 	pea 56c70 <_Thread_BSP_context>                   	<== NOT EXECUTED
   476ce:	4eb9 0004 7eac 	jsr 47eac <_CPU_Context_switch>                   	<== NOT EXECUTED
   476d4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   476d6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   476d8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047730 <_Thread_Suspend>:
 */

void _Thread_Suspend(
  Thread_Control   *the_thread
)
{
   47730:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47734:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47736:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4773a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
  _ISR_Disable( level );
   4773c:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
)
{
  ISR_Level      level;
  Chain_Control *ready;

  ready = the_thread->ready;
   47742:	226a 008c      	moveal %a2@(140),%a1                              	<== NOT EXECUTED
  _ISR_Disable( level );
   47746:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   47748:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   4774a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  the_thread->suspend_count++;
   4774c:	52aa 0070      	addql #1,%a2@(112)                                	<== NOT EXECUTED
  if ( !_States_Is_ready( the_thread->current_state ) ) {
   47750:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   47754:	670e           	beqs 47764 <_Thread_Suspend+0x34>                 	<== NOT EXECUTED
    the_thread->current_state =
   47756:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   47758:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4775a:	2541 0010      	movel %d1,%a2@(16)                                	<== NOT EXECUTED
       _States_Set( STATES_SUSPENDED, the_thread->current_state );
    _ISR_Enable( level );
   4775e:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   47760:	6000 00b4      	braw 47816 <_Thread_Suspend+0xe6>                 	<== NOT EXECUTED
    return;
  }

  the_thread->current_state = STATES_SUSPENDED;

  if ( _Chain_Has_only_one_node( ready ) ) {
   47764:	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;
   47768:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4776a:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED

  if ( _Chain_Has_only_one_node( ready ) ) {
   4776e:	b291           	cmpl %a1@,%d1                                     	<== NOT EXECUTED
   47770:	6634           	bnes 477a6 <_Thread_Suspend+0x76>                 	<== 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;
   47772:	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);
   47776:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   47778:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   4777a:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
   4777c:	3210           	movew %a0@,%d1                                    	<== NOT EXECUTED
   4777e:	302a 009a      	movew %a2@(154),%d0                               	<== NOT EXECUTED
   47782:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   47784:	2349 0008      	movel %a1,%a1@(8)                                 	<== NOT EXECUTED
   47788:	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;
   4778a:	42a9 0004      	clrl %a1@(4)                                      	<== NOT EXECUTED
  if ( *the_priority_map->minor == 0 )
   4778e:	4a41           	tstw %d1                                          	<== NOT EXECUTED
   47790:	6620           	bnes 477b2 <_Thread_Suspend+0x82>                 	<== NOT EXECUTED
    _Priority_Major_bit_map &= the_priority_map->block_major;
   47792:	3239 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d1         	<== NOT EXECUTED
   47798:	302a 0098      	movew %a2@(152),%d0                               	<== NOT EXECUTED
   4779c:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4779e:	33c0 0005 6d58 	movew %d0,56d58 <_Priority_Major_bit_map>         	<== NOT EXECUTED
   477a4:	600c           	bras 477b2 <_Thread_Suspend+0x82>                 	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   477a6:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   477a8:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   477ac:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   477ae:	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 );
   477b2:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   477b8:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   477ba:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   477bc:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( _Thread_Is_heir( the_thread ) )
   477be:	b5f9 0005 6d32 	cmpal 56d32 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   477c4:	663e           	bnes 47804 <_Thread_Suspend+0xd4>                 	<== 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 );
   477c6:	3039 0005 6d58 	movew 56d58 <_Priority_Major_bit_map>,%d0         	<== NOT EXECUTED
   477cc:	4840           	swap %d0                                          	<== NOT EXECUTED
   477ce:	04c0           	ff1 %d0                                           	<== NOT EXECUTED
  _Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
   477d0:	41f9 0005 6dc8 	lea 56dc8 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
   477d6:	0280 0000 ffff 	andil #65535,%d0                                  	<== NOT EXECUTED
   477dc:	3230 0a00      	movew %a0@(00000000,%d0:l:2),%d1                  	<== NOT EXECUTED
   477e0:	4841           	swap %d1                                          	<== NOT EXECUTED
   477e2:	04c1           	ff1 %d1                                           	<== NOT EXECUTED
   477e4:	0281 0000 ffff 	andil #65535,%d1                                  	<== NOT EXECUTED
   477ea:	e988           	lsll #4,%d0                                       	<== NOT EXECUTED
   477ec:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   477ee:	2079 0005 6c50 	moveal 56c50 <_Thread_Ready_chain>,%a0            	<== NOT EXECUTED
   477f4:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   477f6:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   477f8:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
   477fa:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   477fc:	d1c1           	addal %d1,%a0                                     	<== NOT EXECUTED
   477fe:	23d0 0005 6d32 	movel %a0@,56d32 <_Thread_Heir>                   	<== NOT EXECUTED
     _Thread_Calculate_heir();

  if ( _Thread_Is_executing( the_thread ) )
   47804:	b5f9 0005 6d62 	cmpal 56d62 <_Thread_Executing>,%a2               	<== NOT EXECUTED
   4780a:	6608           	bnes 47814 <_Thread_Suspend+0xe4>                 	<== NOT EXECUTED
    _Context_Switch_necessary = TRUE;
   4780c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4780e:	13c1 0005 6d72 	moveb %d1,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   47814:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   47816:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47818:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4781a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4781c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047820 <_Thread_Tickle_timeslice>:
 *
 *  Output parameters:  NONE
 */

void _Thread_Tickle_timeslice( void )
{
   47820:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47824:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Thread_Control *executing;

  executing = _Thread_Executing;
   47826:	2479 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  /*
   *  If the thread is not preemptible or is not ready, then
   *  just return.
   */

  if ( !executing->is_preemptible )
   4782c:	4a2a 0076      	tstb %a2@(118)                                    	<== NOT EXECUTED
   47830:	6756           	beqs 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED
    return;

  if ( !_States_Is_ready( executing->current_state ) )
   47832:	4aaa 0010      	tstl %a2@(16)                                     	<== NOT EXECUTED
   47836:	6650           	bnes 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED

  /*
   *  The cpu budget algorithm determines what happens next.
   */

  switch ( executing->budget_algorithm ) {
   47838:	202a 007c      	movel %a2@(124),%d0                               	<== NOT EXECUTED
   4783c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4783e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47840:	6246           	bhis 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED
   47842:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   47846:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47848:	640a           	bccs 47854 <_Thread_Tickle_timeslice+0x34>        	<== NOT EXECUTED
   4784a:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   4784e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47850:	6636           	bnes 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED
   47852:	601e           	bras 47872 <_Thread_Tickle_timeslice+0x52>        	<== 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 ) {
   47854:	202a 0078      	movel %a2@(120),%d0                               	<== NOT EXECUTED
   47858:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4785a:	2540 0078      	movel %d0,%a2@(120)                               	<== NOT EXECUTED
   4785e:	6e28           	bgts 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED
        _Thread_Reset_timeslice();
   47860:	4eb9 0004 a240 	jsr 4a240 <_Thread_Reset_timeslice>               	<== NOT EXECUTED
        executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
   47866:	41f9 0005 6c54 	lea 56c54 <_Thread_Ticks_per_timeslice>,%a0       	<== NOT EXECUTED
   4786c:	2550 0078      	movel %a0@,%a2@(120)                              	<== NOT EXECUTED
   47870:	6016           	bras 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED
      }
      break;

    case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
      if ( --executing->cpu_time_budget == 0 )
   47872:	202a 0078      	movel %a2@(120),%d0                               	<== NOT EXECUTED
   47876:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47878:	2540 0078      	movel %d0,%a2@(120)                               	<== NOT EXECUTED
   4787c:	660a           	bnes 47888 <_Thread_Tickle_timeslice+0x68>        	<== NOT EXECUTED
        (*executing->budget_callout)( executing );
   4787e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47880:	206a 0080      	moveal %a2@(128),%a0                              	<== NOT EXECUTED
   47884:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47886:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      break;
  }
}
   47888:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4788c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4788e:	4e75           	rts

00047890 <_Thread_Yield_processor>:
 *    ready chain
 *    select heir
 */

void _Thread_Yield_processor( void )
{
   47890:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   47894:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
   47898:	2479 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a2              	<== NOT EXECUTED
  ready     = executing->ready;
  _ISR_Disable( level );
   4789e:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
  ISR_Level       level;
  Thread_Control *executing;
  Chain_Control  *ready;

  executing = _Thread_Executing;
  ready     = executing->ready;
   478a4:	266a 008c      	moveal %a2@(140),%a3                              	<== NOT EXECUTED
  _ISR_Disable( level );
   478a8:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   478aa:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   478ac:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   478ae:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !_Chain_Has_only_one_node( ready ) ) {
   478b0:	202b 0008      	movel %a3@(8),%d0                                 	<== NOT EXECUTED
   478b4:	b093           	cmpl %a3@,%d0                                     	<== NOT EXECUTED
   478b6:	6738           	beqs 478f0 <_Thread_Yield_processor+0x60>         	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   478b8:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   478ba:	226a 0004      	moveal %a2@(4),%a1                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   478be:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   478c0:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   478c2:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   478c4:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   478c6:	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;
   478ca:	206b 0008      	moveal %a3@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   478ce:	274a 0008      	movel %a2,%a3@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   478d2:	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;
   478d6:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
      _Chain_Extract_unprotected( &executing->Object.Node );
      _Chain_Append_unprotected( ready, &executing->Object.Node );

      _ISR_Flash( level );
   478d8:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   478da:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   478dc:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   478de:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      if ( _Thread_Is_heir( executing ) )
   478e0:	b5f9 0005 6d32 	cmpal 56d32 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   478e6:	6610           	bnes 478f8 <_Thread_Yield_processor+0x68>         	<== NOT EXECUTED
        _Thread_Heir = (Thread_Control *) ready->first;
   478e8:	23d3 0005 6d32 	movel %a3@,56d32 <_Thread_Heir>                   	<== NOT EXECUTED
   478ee:	6008           	bras 478f8 <_Thread_Yield_processor+0x68>         	<== NOT EXECUTED
      _Context_Switch_necessary = TRUE;
    }
    else if ( !_Thread_Is_heir( executing ) )
   478f0:	b5f9 0005 6d32 	cmpal 56d32 <_Thread_Heir>,%a2                    	<== NOT EXECUTED
   478f6:	6708           	beqs 47900 <_Thread_Yield_processor+0x70>         	<== NOT EXECUTED
      _Context_Switch_necessary = TRUE;
   478f8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   478fa:	13c0 0005 6d72 	moveb %d0,56d72 <_Context_Switch_necessary>       	<== NOT EXECUTED

  _ISR_Enable( level );
   47900:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
}
   47902:	4cd7 0c04      	moveml %sp@,%d2/%a2-%a3                           	<== NOT EXECUTED
   47906:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47908:	4e75           	rts                                               	<== NOT EXECUTED
	...

000466f8 <_Thread_blocking_operation_Cancel>:
void _Thread_blocking_operation_Cancel(
  Thread_blocking_operation_States  sync_state,
  Thread_Control                   *the_thread,
  ISR_Level                         level
)
{
   466f8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   466fc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   466fe:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   46702:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
  #endif

  /*
   * The thread is not waiting on anything after this completes.
   */
  the_thread->Wait.queue = NULL;
   46706:	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 ) ) {
   4670a:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   4670c:	b2aa 0050      	cmpl %a2@(80),%d1                                 	<== NOT EXECUTED
   46710:	6618           	bnes 4672a <_Thread_blocking_operation_Cancel+0x32>	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   46712:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   46716:	2541 0050      	movel %d1,%a2@(80)                                	<== NOT EXECUTED
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4671a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4671c:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   46720:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   46726:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46728:	6002           	bras 4672c <_Thread_blocking_operation_Cancel+0x34>	<== NOT EXECUTED
  } else
    _ISR_Enable( level );
   4672a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   4672c:	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

}
   46730:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46734:	203c 1003 fff8 	movel #268697592,%d0                              	<== NOT EXECUTED
   4673a:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
   4673e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46740:	4ef9 0004 688c 	jmp 4688c <_Thread_Clear_state>                   	<== NOT EXECUTED
	...

00046f70 <_Thread_queue_Dequeue>:
 */

Thread_Control *_Thread_queue_Dequeue(
  Thread_queue_Control *the_thread_queue
)
{
   46f70:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   46f74:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   46f78:	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 )
   46f7c:	41f9 0004 6fd0 	lea 46fd0 <_Thread_queue_Dequeue_priority>,%a0    	<== NOT EXECUTED
   46f82:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   46f84:	b0aa 0034      	cmpl %a2@(52),%d0                                 	<== NOT EXECUTED
   46f88:	6706           	beqs 46f90 <_Thread_queue_Dequeue+0x20>           	<== NOT EXECUTED
   46f8a:	41f9 0004 9f58 	lea 49f58 <_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 );
   46f90:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   46f92:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   46f94:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
  _ISR_Disable( level );
   46f96:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   46f9c:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   46f9e:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   46fa0:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !the_thread ) {
   46fa2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   46fa4:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   46fa6:	6618           	bnes 46fc0 <_Thread_queue_Dequeue+0x50>           	<== NOT EXECUTED
      sync_state = the_thread_queue->sync_state;
      if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
   46fa8:	202a 0030      	movel %a2@(48),%d0                                	<== NOT EXECUTED
   46fac:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   46fae:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   46fb0:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   46fb2:	650c           	bcss 46fc0 <_Thread_queue_Dequeue+0x50>           	<== NOT EXECUTED
           (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) {
        the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
        the_thread = _Thread_Executing;
   46fb4:	2239 0005 6d62 	movel 56d62 <_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;
   46fba:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   46fbc:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
        the_thread = _Thread_Executing;
      }
    }
  _ISR_Enable( level );
   46fc0:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return the_thread;
}
   46fc2:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   46fc8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46fca:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   46fcc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00049f58 <_Thread_queue_Dequeue_fifo>:
 */

Thread_Control *_Thread_queue_Dequeue_fifo(
  Thread_queue_Control *the_thread_queue
)
{
   49f58:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   49f5c:	48d7 1c00      	moveml %a2-%a4,%sp@                               	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *the_thread;

  _ISR_Disable( level );
   49f60:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Thread_Control *_Thread_queue_Dequeue_fifo(
  Thread_queue_Control *the_thread_queue
)
{
   49f66:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  ISR_Level              level;
  Thread_Control *the_thread;

  _ISR_Disable( level );
   49f6a:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   49f6c:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49f6e:	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));
   49f70:	2049           	moveal %a1,%a0                                    	<== NOT EXECUTED
   49f72:	2458           	moveal %a0@+,%a2                                  	<== NOT EXECUTED
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) {
   49f74:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   49f76:	6750           	beqs 49fc8 <_Thread_queue_Dequeue_fifo+0x70>      	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   49f78:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   49f7a:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED

    the_thread = (Thread_Control *)
   49f7c:	264a           	moveal %a2,%a3                                    	<== NOT EXECUTED
   49f7e:	49f9 0004 688c 	lea 4688c <_Thread_Clear_state>,%a4               	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   49f84:	2149 0004      	movel %a1,%a0@(4)                                 	<== NOT EXECUTED
       _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo );

    the_thread->Wait.queue = NULL;
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   49f88:	7002           	moveq #2,%d0                                      	<== 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;
   49f8a:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED
    if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   49f8e:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   49f92:	6710           	beqs 49fa4 <_Thread_queue_Dequeue_fifo+0x4c>      	<== NOT EXECUTED
      _ISR_Enable( level );
   49f94:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   49f96:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   49f9c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49f9e:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   49fa0:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   49fa2:	6028           	bras 49fcc <_Thread_queue_Dequeue_fifo+0x74>      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   49fa4:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   49fa6:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
      _Thread_Unblock( the_thread );
    } else {
      _Watchdog_Deactivate( &the_thread->Timer );
      _ISR_Enable( level );
   49faa:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_thread->Timer );
   49fac:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   49fb0:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   49fb6:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   49fbc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49fbe:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   49fc0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   49fc6:	6004           	bras 49fcc <_Thread_queue_Dequeue_fifo+0x74>      	<== NOT EXECUTED
#endif

    return the_thread;
  }

  _ISR_Enable( level );
   49fc8:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   49fca:	97cb           	subal %a3,%a3                                     	<== NOT EXECUTED
  return NULL;
}
   49fcc:	200b           	movel %a3,%d0                                     	<== NOT EXECUTED
   49fce:	4cee 1c00 fff4 	moveml %fp@(-12),%a2-%a4                          	<== NOT EXECUTED
   49fd4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49fd6:	4e75           	rts

00046fd0 <_Thread_queue_Dequeue_priority>:
 */

Thread_Control *_Thread_queue_Dequeue_priority(
  Thread_queue_Control *the_thread_queue
)
{
   46fd0:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   46fd4:	48d7 3c04      	moveml %d2/%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 );
   46fd8:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Thread_Control *_Thread_queue_Dequeue_priority(
  Thread_queue_Control *the_thread_queue
)
{
   46fde:	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 );
   46fe2:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   46fe4:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   46fe6:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   46fe8:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   46fea:	264c           	moveal %a4,%a3                                    	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   46fec:	2453           	moveal %a3@,%a2                                   	<== NOT EXECUTED
  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
       index++ ) {
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
   46fee:	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++ ) {
   46ff2:	d7fc 0000 000c 	addal #12,%a3                                     	<== NOT EXECUTED
   46ff8:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) {
   46ffa:	41f4 8c00      	lea %a4@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   46ffe:	b1ca           	cmpal %a2,%a0                                     	<== NOT EXECUTED
   47000:	671e           	beqs 47020 <_Thread_queue_Dequeue_priority+0x50>  	<== NOT EXECUTED
  _ISR_Enable( level );
  return NULL;

dequeue:
  the_thread->Wait.queue = NULL;
  new_first_node   = the_thread->Wait.Block2n.first;
   47002:	206a 0038      	moveal %a2@(56),%a0                               	<== NOT EXECUTED
  new_first_thread = (Thread_Control *) new_first_node;
  next_node        = the_thread->Object.Node.next;
   47006:	2652           	moveal %a2@,%a3                                   	<== NOT EXECUTED
  previous_node    = the_thread->Object.Node.previous;
   47008:	226a 0004      	moveal %a2@(4),%a1                                	<== NOT EXECUTED

  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
   4700c:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   */
  _ISR_Enable( level );
  return NULL;

dequeue:
  the_thread->Wait.queue = NULL;
   4700e:	42aa 0044      	clrl %a2@(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 *)
   47012:	240a           	movel %a2,%d2                                     	<== 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 ) ) {
   47014:	0680 0000 003c 	addil #60,%d0                                     	<== NOT EXECUTED
   4701a:	b088           	cmpl %a0,%d0                                      	<== NOT EXECUTED
   4701c:	660e           	bnes 4702c <_Thread_queue_Dequeue_priority+0x5c>  	<== NOT EXECUTED
   4701e:	6042           	bras 47062 <_Thread_queue_Dequeue_priority+0x92>  	<== NOT EXECUTED
  Chain_Node     *next_node;
  Chain_Node     *previous_node;

  _ISR_Disable( level );
  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
   47020:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   47022:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   47024:	66c6           	bnes 46fec <_Thread_queue_Dequeue_priority+0x1c>  	<== NOT EXECUTED
  }

  /*
   * We did not find a thread to unblock.
   */
  _ISR_Enable( level );
   47026:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   47028:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4702a:	607c           	bras 470a8 <_Thread_queue_Dequeue_priority+0xd8>  	<== NOT EXECUTED
  new_first_thread = (Thread_Control *) new_first_node;
  next_node        = the_thread->Object.Node.next;
  previous_node    = the_thread->Object.Node.previous;

  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
    last_node       = the_thread->Wait.Block2n.last;
   4702c:	2a6a 0040      	moveal %a2@(64),%a5                               	<== NOT EXECUTED
    new_second_node = new_first_node->next;
   47030:	2850           	moveal %a0@,%a4                                   	<== NOT EXECUTED

    previous_node->next      = new_first_node;
    next_node->previous      = new_first_node;
   47032:	2748 0004      	movel %a0,%a3@(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;
   47036:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
    next_node->previous      = new_first_node;
    new_first_node->next     = next_node;
    new_first_node->previous = previous_node;
   47038:	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;
   4703c:	208b           	movel %a3,%a0@                                    	<== NOT EXECUTED
    new_first_node->previous = previous_node;

    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
   4703e:	226a 0040      	moveal %a2@(64),%a1                               	<== NOT EXECUTED
   47042:	b3ea 0038      	cmpal %a2@(56),%a1                                	<== NOT EXECUTED
   47046:	6720           	beqs 47068 <_Thread_queue_Dequeue_priority+0x98>  	<== NOT EXECUTED
                                                /* > two threads on 2-n */
      new_second_node->previous =
   47048:	43e8 0038      	lea %a0@(56),%a1                                  	<== NOT EXECUTED
   4704c:	2949 0004      	movel %a1,%a4@(4)                                 	<== NOT EXECUTED
                _Chain_Head( &new_first_thread->Wait.Block2n );

      new_first_thread->Wait.Block2n.first = new_second_node;
   47050:	214c 0038      	movel %a4,%a0@(56)                                	<== NOT EXECUTED
      new_first_thread->Wait.Block2n.last  = last_node;
   47054:	214d 0040      	movel %a5,%a0@(64)                                	<== NOT EXECUTED

      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
   47058:	d1fc 0000 003c 	addal #60,%a0                                     	<== NOT EXECUTED
   4705e:	2a88           	movel %a0,%a5@                                    	<== NOT EXECUTED
   47060:	6006           	bras 47068 <_Thread_queue_Dequeue_priority+0x98>  	<== NOT EXECUTED
    }
  } else {
    previous_node->next = next_node;
    next_node->previous = previous_node;
   47062:	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;
   47066:	228b           	movel %a3,%a1@                                    	<== NOT EXECUTED
   47068:	47f9 0004 688c 	lea 4688c <_Thread_Clear_state>,%a3               	<== NOT EXECUTED
    next_node->previous = previous_node;
  }

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4706e:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   47070:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   47074:	6710           	beqs 47086 <_Thread_queue_Dequeue_priority+0xb6>  	<== NOT EXECUTED
    _ISR_Enable( level );
   47076:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   47078:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   4707e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47080:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   47082:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47084:	6022           	bras 470a8 <_Thread_queue_Dequeue_priority+0xd8>  	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_REMOVE_IT;
   47086:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   47088:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
    _Thread_Unblock( the_thread );
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4708c:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4708e:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   47092:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   47098:	2f3c 1003 fff8 	movel #268697592,%sp@-                            	<== NOT EXECUTED
   4709e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   470a0:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   470a2:	dffc 0000 000c 	addal #12,%sp                                     	<== 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 );
}
   470a8:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   470aa:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   470b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   470b2:	4e75           	rts

00049fd8 <_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
)
{
   49fd8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49fdc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Thread_blocking_operation_States sync_state;
  ISR_Level                        level;

  _ISR_Disable( level );
   49fde:	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
)
{
   49fe4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   49fe6:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   49fea:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Thread_blocking_operation_States sync_state;
  ISR_Level                        level;

  _ISR_Disable( level );
   49fee:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   49ff0:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49ff2:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

    sync_state = the_thread_queue->sync_state;
   49ff4:	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) {
   49ff8:	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;
   49ffa:	42a9 0030      	clrl %a1@(48)                                     	<== NOT EXECUTED
    if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) {
   49ffe:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   4a000:	661c           	bnes 4a01e <_Thread_queue_Enqueue_fifo+0x46>      	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   4a002:	2049           	moveal %a1,%a0                                    	<== NOT EXECUTED
   4a004:	5888           	addql #4,%a0                                      	<== NOT EXECUTED
   4a006:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   4a008:	2069 0008      	moveal %a1@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   4a00c:	234a 0008      	movel %a2,%a1@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   4a010:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
      _Chain_Append_unprotected(
        &the_thread_queue->Queues.Fifo,
        &the_thread->Object.Node
      );
      the_thread->Wait.queue = the_thread_queue;
   4a014:	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;
   4a018:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED

      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
      _ISR_Enable( level );
   4a01a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4a01c:	6006           	bras 4a024 <_Thread_queue_Enqueue_fifo+0x4c>      	<== 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;
   4a01e:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   4a022:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  return sync_state;
}
   4a024:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a026:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   4a028:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a02a:	4e75           	rts

00047150 <_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
)
{
   47150:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   47154:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   47158:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Priority_Control     priority;
  States_Control       block_state;

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
   4715c:	282a 0014      	movel %a2@(20),%d4                                	<== NOT EXECUTED
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_Level            *level_p
)
{
   47160:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE uint32_t   _Thread_queue_Header_number (
  Priority_Control the_priority
)
{
  return (the_priority / TASK_QUEUE_DATA_PRIORITIES_PER_HEADER);
   47164:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   47166:	ec8a           	lsrl #6,%d2                                       	<== NOT EXECUTED

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
  header_index = _Thread_queue_Header_number( priority );
  header       = &the_thread_queue->Queues.Priority[ header_index ];
   47168:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4716a:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4716c:	41ea 003c      	lea %a2@(60),%a0                                  	<== NOT EXECUTED
   47170:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   47172:	e989           	lsll #4,%d1                                       	<== NOT EXECUTED
  block_state  = the_thread_queue->state;
   47174:	2a2b 0038      	movel %a3@(56),%d5                                	<== NOT EXECUTED
   47178:	2548 0038      	movel %a0,%a2@(56)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4717c:	43ea 0038      	lea %a2@(56),%a1                                  	<== NOT EXECUTED

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
  header_index = _Thread_queue_Header_number( priority );
  header       = &the_thread_queue->Queues.Priority[ header_index ];
   47180:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   47182:	2549 0040      	movel %a1,%a2@(64)                                	<== NOT EXECUTED
   47186:	41f3 1800      	lea %a3@(00000000,%d1:l),%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;
   4718a:	42aa 003c      	clrl %a2@(60)                                     	<== NOT EXECUTED
  block_state  = the_thread_queue->state;

  if ( _Thread_queue_Is_reverse_search( priority ) )
   4718e:	0804 0005      	btst #5,%d4                                       	<== NOT EXECUTED
   47192:	6674           	bnes 47208 <_Thread_queue_Enqueue_priority+0xb8>  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   47194:	2242           	moveal %d2,%a1                                    	<== NOT EXECUTED
   47196:	41f1 2a01      	lea %a1@(00000001,%d2:l:2),%a0                    	<== NOT EXECUTED
   4719a:	49f3 8c00      	lea %a3@(00000000,%a0:l:4),%a4                    	<== NOT EXECUTED
    goto restart_reverse_search;

restart_forward_search:
  search_priority = PRIORITY_MINIMUM - 1;
  _ISR_Disable( level );
  search_thread = (Thread_Control *) header->first;
   4719e:	2041           	moveal %d1,%a0                                    	<== NOT EXECUTED
  if ( _Thread_queue_Is_reverse_search( priority ) )
    goto restart_reverse_search;

restart_forward_search:
  search_priority = PRIORITY_MINIMUM - 1;
  _ISR_Disable( level );
   471a0:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
   471a6:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   471a8:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   471aa:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   471ac:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->first;
   471ae:	72ff           	moveq #-1,%d1                                     	<== NOT EXECUTED
   471b0:	2270 b800      	moveal %a0@(00000000,%a3:l),%a1                   	<== NOT EXECUTED
   471b4:	601e           	bras 471d4 <_Thread_queue_Enqueue_priority+0x84>  	<== NOT EXECUTED
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
    search_priority = search_thread->current_priority;
   471b6:	2229 0014      	movel %a1@(20),%d1                                	<== NOT EXECUTED
    if ( priority <= search_priority )
   471ba:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   471bc:	641a           	bccs 471d8 <_Thread_queue_Enqueue_priority+0x88>  	<== NOT EXECUTED
      break;
    search_priority = search_thread->current_priority;
    if ( priority <= search_priority )
      break;
#endif
    _ISR_Flash( level );
   471be:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   471c0:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   471c2:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   471c4:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
   471c6:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   471c8:	c0a9 0010      	andl %a1@(16),%d0                                 	<== NOT EXECUTED
   471cc:	6604           	bnes 471d2 <_Thread_queue_Enqueue_priority+0x82>  	<== NOT EXECUTED
      _ISR_Enable( level );
   471ce:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   471d0:	60d4           	bras 471a6 <_Thread_queue_Enqueue_priority+0x56>  	<== NOT EXECUTED
      goto restart_forward_search;
    }
    search_thread =
   471d2:	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 ) ) {
   471d4:	b9c9           	cmpal %a1,%a4                                     	<== NOT EXECUTED
   471d6:	66de           	bnes 471b6 <_Thread_queue_Enqueue_priority+0x66>  	<== NOT EXECUTED
   471d8:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   471da:	2403           	movel %d3,%d2                                     	<== NOT EXECUTED
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
   471dc:	7a01           	moveq #1,%d5                                      	<== NOT EXECUTED
   471de:	baab 0030      	cmpl %a3@(48),%d5                                 	<== NOT EXECUTED
   471e2:	6600 00b6      	bnew 4729a <_Thread_queue_Enqueue_priority+0x14a> 	<== NOT EXECUTED
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   471e6:	42ab 0030      	clrl %a3@(48)                                     	<== NOT EXECUTED

  if ( priority == search_priority )
   471ea:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   471ec:	6700 008c      	beqw 4727a <_Thread_queue_Enqueue_priority+0x12a> 	<== NOT EXECUTED
    goto equal_priority;

  search_node   = (Chain_Node *) search_thread;
  previous_node = search_node->previous;
   471f0:	2069 0004      	moveal %a1@(4),%a0                                	<== NOT EXECUTED
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
   471f4:	2489           	movel %a1,%a2@                                    	<== NOT EXECUTED
  the_node->previous     = previous_node;
   471f6:	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;
   471fa:	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;
   471fe:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
  search_node->previous  = the_node;
   47200:	234a 0004      	movel %a2,%a1@(4)                                 	<== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   47204:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   47206:	606e           	bras 47276 <_Thread_queue_Enqueue_priority+0x126> 	<== NOT EXECUTED
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;

  _ISR_Disable( level );
   47208:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->last;
   4720e:	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;
   47212:	4280           	clrl %d0                                          	<== NOT EXECUTED
   47214:	1039 0005 5192 	moveb 55192 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   4721a:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4721c:	5281           	addql #1,%d1                                      	<== NOT EXECUTED

  _ISR_Disable( level );
   4721e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   47220:	40c3           	movew %sr,%d3                                     	<== NOT EXECUTED
   47222:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   47224:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  search_thread = (Thread_Control *) header->last;
   47226:	2254           	moveal %a4@,%a1                                   	<== NOT EXECUTED
   47228:	6020           	bras 4724a <_Thread_queue_Enqueue_priority+0xfa>  	<== NOT EXECUTED
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
    search_priority = search_thread->current_priority;
   4722a:	2229 0014      	movel %a1@(20),%d1                                	<== NOT EXECUTED
    if ( priority >= search_priority )
   4722e:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   47230:	631c           	blss 4724e <_Thread_queue_Enqueue_priority+0xfe>  	<== NOT EXECUTED
      break;
    search_priority = search_thread->current_priority;
    if ( priority >= search_priority )
      break;
#endif
    _ISR_Flash( level );
   47232:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   47234:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   47236:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   47238:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
   4723a:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4723c:	c0a9 0010      	andl %a1@(16),%d0                                 	<== NOT EXECUTED
   47240:	6604           	bnes 47246 <_Thread_queue_Enqueue_priority+0xf6>  	<== NOT EXECUTED
      _ISR_Enable( level );
   47242:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   47244:	60cc           	bras 47212 <_Thread_queue_Enqueue_priority+0xc2>  	<== NOT EXECUTED
      goto restart_reverse_search;
    }
    search_thread = (Thread_Control *)
   47246:	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 ) ) {
   4724a:	b1c9           	cmpal %a1,%a0                                     	<== NOT EXECUTED
   4724c:	66dc           	bnes 4722a <_Thread_queue_Enqueue_priority+0xda>  	<== NOT EXECUTED
   4724e:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   47250:	2403           	movel %d3,%d2                                     	<== NOT EXECUTED
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
   47252:	7a01           	moveq #1,%d5                                      	<== NOT EXECUTED
   47254:	baab 0030      	cmpl %a3@(48),%d5                                 	<== NOT EXECUTED
   47258:	6640           	bnes 4729a <_Thread_queue_Enqueue_priority+0x14a> 	<== NOT EXECUTED
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   4725a:	42ab 0030      	clrl %a3@(48)                                     	<== NOT EXECUTED

  if ( priority == search_priority )
   4725e:	b284           	cmpl %d4,%d1                                      	<== NOT EXECUTED
   47260:	6718           	beqs 4727a <_Thread_queue_Enqueue_priority+0x12a> 	<== NOT EXECUTED
    goto equal_priority;

  search_node = (Chain_Node *) search_thread;
  next_node   = search_node->next;
   47262:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
  the_node->previous      = search_node;
   47264:	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;
   47268:	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;
   4726a:	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;
   4726e:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
  next_node->previous    = the_node;
   47270:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   47274:	46c3           	movew %d3,%sr                                     	<== NOT EXECUTED
   47276:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47278:	602a           	bras 472a4 <_Thread_queue_Enqueue_priority+0x154> 	<== NOT EXECUTED
   4727a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4727c:	d1fc 0000 003c 	addal #60,%a0                                     	<== NOT EXECUTED
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

equal_priority:               /* add at end of priority group */
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );
  previous_node = search_node->previous;
   47282:	2268 0004      	moveal %a0@(4),%a1                                	<== NOT EXECUTED
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
   47286:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  the_node->previous     = previous_node;
   47288:	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;
   4728c:	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;
   47290:	228a           	movel %a2,%a1@                                    	<== NOT EXECUTED
  search_node->previous  = the_node;
   47292:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   47296:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
   47298:	60dc           	bras 47276 <_Thread_queue_Enqueue_priority+0x126> 	<== 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;
   4729a:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  return the_thread_queue->sync_state;
   4729e:	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;
   472a2:	2082           	movel %d2,%a0@                                    	<== NOT EXECUTED
  return the_thread_queue->sync_state;
}
   472a4:	4cd7 1c3c      	moveml %sp@,%d2-%d5/%a2-%a4                       	<== NOT EXECUTED
   472a8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472aa:	4e75           	rts

000470b4 <_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
)
{
   470b4:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   470b8:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   470bc:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  else
#endif
  /*
   *  Set the blocking state for this thread queue in the thread.
   */
  _Thread_Set_state( the_thread, the_thread_queue->state );
   470c0:	2f2b 0038      	movel %a3@(56),%sp@-                              	<== NOT EXECUTED
    Thread_queue_Control *,
    Thread_Control *,
    ISR_Level *
  );

  the_thread = _Thread_Executing;
   470c4:	2479 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a2              	<== NOT EXECUTED
void _Thread_queue_Enqueue_with_handler(
  Thread_queue_Control         *the_thread_queue,
  Watchdog_Interval             timeout,
  Thread_queue_Timeout_callout  handler
)
{
   470ca:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  else
#endif
  /*
   *  Set the blocking state for this thread queue in the thread.
   */
  _Thread_Set_state( the_thread, the_thread_queue->state );
   470ce:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   470d0:	4eb9 0004 7490 	jsr 47490 <_Thread_Set_state>                     	<== NOT EXECUTED

  /*
   *  If the thread wants to timeout, then schedule its timer.
   */
  if ( timeout ) {
   470d6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   470d8:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   470da:	672c           	beqs 47108 <_Thread_queue_Enqueue_with_handler+0x54>	<== NOT EXECUTED
    _Watchdog_Initialize(
   470dc:	202a 0008      	movel %a2@(8),%d0                                 	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   470e0:	256e 0010 0064 	movel %fp@(16),%a2@(100)                          	<== NOT EXECUTED
  the_watchdog->id        = id;
   470e6:	2540 0068      	movel %d0,%a2@(104)                               	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   470ea:	2542 0054      	movel %d2,%a2@(84)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   470ee:	42aa 0050      	clrl %a2@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   470f2:	42aa 006c      	clrl %a2@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   470f6:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   470fa:	4879 0005 6d80 	pea 56d80 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   47100:	4eb9 0004 7bc4 	jsr 47bc4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   47106:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  }

  /*
   *  Now enqueue the thread per the discipline for this thread queue.
   */
  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
   47108:	41f9 0004 7150 	lea 47150 <_Thread_queue_Enqueue_priority>,%a0    	<== NOT EXECUTED
   4710e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47110:	b0ab 0034      	cmpl %a3@(52),%d0                                 	<== NOT EXECUTED
   47114:	6706           	beqs 4711c <_Thread_queue_Enqueue_with_handler+0x68>	<== NOT EXECUTED
   47116:	41f9 0004 9fd8 	lea 49fd8 <_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 );
   4711c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   47120:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47122:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   47124:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
  if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
   47126:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4712c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4712e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47130:	6714           	beqs 47146 <_Thread_queue_Enqueue_with_handler+0x92>	<== NOT EXECUTED
    _Thread_blocking_operation_Cancel( sync_state, the_thread, level );
   47132:	2f2e fffc      	movel %fp@(-4),%sp@-                              	<== NOT EXECUTED
   47136:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47138:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4713a:	4eb9 0004 66f8 	jsr 466f8 <_Thread_blocking_operation_Cancel>     	<== NOT EXECUTED
   47140:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
}
   47146:	4cee 0c04 fff0 	moveml %fp@(-16),%d2/%a2-%a3                      	<== NOT EXECUTED
   4714c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4714e:	4e75           	rts

0004a02c <_Thread_queue_Extract>:

void _Thread_queue_Extract(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
)
{
   4a02c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a030:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   4a034:	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 )
   4a038:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4a03a:	b2a8 0034      	cmpl %a0@(52),%d1                                 	<== NOT EXECUTED
   4a03e:	6616           	bnes 4a056 <_Thread_queue_Extract+0x2a>           	<== NOT EXECUTED
    _Thread_queue_Extract_priority( the_thread_queue, the_thread );
   4a040:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4a042:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4a044:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   4a046:	4eb9 0004 a068 	jsr 4a068 <_Thread_queue_Extract_priority_helper> 	<== NOT EXECUTED
   4a04c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */
    _Thread_queue_Extract_fifo( the_thread_queue, the_thread );

}
   4a052:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a054:	4e75           	rts                                               	<== 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 );
   4a056:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
   4a05a:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED

}
   4a05e:	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 );
   4a060:	4ef9 0004 ab94 	jmp 4ab94 <_Thread_queue_Extract_fifo>            	<== NOT EXECUTED
	...

0004ab94 <_Thread_queue_Extract_fifo>:

void _Thread_queue_Extract_fifo(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
)
{
   4ab94:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4ab98:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4ab9a:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   4ab9e:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4aba4:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4aba6:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4aba8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
   4abaa:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4abae:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   4abb4:	660a           	bnes 4abc0 <_Thread_queue_Extract_fifo+0x2c>      	<== NOT EXECUTED
    _ISR_Enable( level );
   4abb6:	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

}
   4abb8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4abbc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4abbe:	4e75           	rts                                               	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   4abc0:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   4abc2:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
    return;
  }

  _Chain_Extract_unprotected( &the_thread->Object.Node );

  the_thread->Wait.queue = NULL;
   4abc6:	42aa 0044      	clrl %a2@(68)                                     	<== NOT EXECUTED

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4abca:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   4abcc:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   4abce:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED
   4abd2:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4abd6:	6704           	beqs 4abdc <_Thread_queue_Extract_fifo+0x48>      	<== NOT EXECUTED
    _ISR_Enable( level );
   4abd8:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4abda:	6014           	bras 4abf0 <_Thread_queue_Extract_fifo+0x5c>      	<== NOT EXECUTED
   4abdc:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4abde:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4abe2:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4abe4:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4abe8:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   4abee:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Thread_Unblock (
  Thread_Control *the_thread
)
{
  _Thread_Clear_state( the_thread, STATES_BLOCKED );
   4abf0:	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

}
   4abf4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4abf8:	203c 1003 fff8 	movel #268697592,%d0                              	<== NOT EXECUTED
   4abfe:	2d40 000c      	movel %d0,%fp@(12)                                	<== NOT EXECUTED
   4ac02:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ac04:	4ef9 0004 688c 	jmp 4688c <_Thread_Clear_state>                   	<== NOT EXECUTED
	...

0004a068 <_Thread_queue_Extract_priority_helper>:
void _Thread_queue_Extract_priority_helper(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  bool                  requeuing
)
{
   4a068:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4a06c:	48d7 3c04      	moveml %d2/%a2-%a5,%sp@                           	<== NOT EXECUTED
   4a070:	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 );
   4a074:	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
)
{
   4a07a:	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 );
   4a07e:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4a080:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a082:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
   4a084:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4a088:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   4a08e:	6606           	bnes 4a096 <_Thread_queue_Extract_priority_helper+0x2e>	<== NOT EXECUTED
    _ISR_Enable( level );
   4a090:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4a092:	6000 0098      	braw 4a12c <_Thread_queue_Extract_priority_helper+0xc4>	<== NOT EXECUTED

  /*
   *  The thread was actually waiting on a thread queue so let's remove it.
   */

  next_node     = the_node->next;
   4a096:	2652           	moveal %a2@,%a3                                   	<== NOT EXECUTED
  previous_node = the_node->previous;
   4a098:	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));
   4a09c:	206a 0038      	moveal %a2@(56),%a0                               	<== NOT EXECUTED

  if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) {
   4a0a0:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   4a0a2:	0680 0000 003c 	addil #60,%d0                                     	<== NOT EXECUTED
   4a0a8:	b088           	cmpl %a0,%d0                                      	<== NOT EXECUTED
   4a0aa:	6736           	beqs 4a0e2 <_Thread_queue_Extract_priority_helper+0x7a>	<== 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;
   4a0ac:	2a6a 0040      	moveal %a2@(64),%a5                               	<== NOT EXECUTED
    new_second_node  = new_first_node->next;
   4a0b0:	2850           	moveal %a0@,%a4                                   	<== NOT EXECUTED

    previous_node->next      = new_first_node;
    next_node->previous      = new_first_node;
   4a0b2:	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;
   4a0b6:	2288           	movel %a0,%a1@                                    	<== NOT EXECUTED
    next_node->previous      = new_first_node;
    new_first_node->next     = next_node;
    new_first_node->previous = previous_node;
   4a0b8:	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;
   4a0bc:	208b           	movel %a3,%a0@                                    	<== NOT EXECUTED
    new_first_node->previous = previous_node;

    if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) {
   4a0be:	202a 0040      	movel %a2@(64),%d0                                	<== NOT EXECUTED
   4a0c2:	b0aa 0038      	cmpl %a2@(56),%d0                                 	<== NOT EXECUTED
   4a0c6:	6720           	beqs 4a0e8 <_Thread_queue_Extract_priority_helper+0x80>	<== NOT EXECUTED
                                        /* > two threads on 2-n */
      new_second_node->previous =
   4a0c8:	43e8 0038      	lea %a0@(56),%a1                                  	<== NOT EXECUTED
   4a0cc:	2949 0004      	movel %a1,%a4@(4)                                 	<== NOT EXECUTED
                _Chain_Head( &new_first_thread->Wait.Block2n );
      new_first_thread->Wait.Block2n.first = new_second_node;
   4a0d0:	214c 0038      	movel %a4,%a0@(56)                                	<== NOT EXECUTED

      new_first_thread->Wait.Block2n.last = last_node;
   4a0d4:	214d 0040      	movel %a5,%a0@(64)                                	<== NOT EXECUTED
      last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n );
   4a0d8:	d1fc 0000 003c 	addal #60,%a0                                     	<== NOT EXECUTED
   4a0de:	2a88           	movel %a0,%a5@                                    	<== NOT EXECUTED
   4a0e0:	6006           	bras 4a0e8 <_Thread_queue_Extract_priority_helper+0x80>	<== NOT EXECUTED
    }
  } else {
    previous_node->next = next_node;
    next_node->previous = previous_node;
   4a0e2:	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;
   4a0e6:	228b           	movel %a3,%a1@                                    	<== NOT EXECUTED

  /*
   *  If we are not supposed to touch timers or the thread's state, return.
   */

  if ( requeuing ) {
   4a0e8:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4a0ea:	6704           	beqs 4a0f0 <_Thread_queue_Extract_priority_helper+0x88>	<== NOT EXECUTED
    _ISR_Enable( level );
   4a0ec:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4a0ee:	603c           	bras 4a12c <_Thread_queue_Extract_priority_helper+0xc4>	<== NOT EXECUTED
    return;
  }

  if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
   4a0f0:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   4a0f2:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4a0f6:	6704           	beqs 4a0fc <_Thread_queue_Extract_priority_helper+0x94>	<== NOT EXECUTED
    _ISR_Enable( level );
   4a0f8:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4a0fa:	6014           	bras 4a110 <_Thread_queue_Extract_priority_helper+0xa8>	<== NOT EXECUTED
   4a0fc:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4a0fe:	2540 0050      	movel %d0,%a2@(80)                                	<== NOT EXECUTED
  } else {
    _Watchdog_Deactivate( &the_thread->Timer );
    _ISR_Enable( level );
   4a102:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    (void) _Watchdog_Remove( &the_thread->Timer );
   4a104:	486a 0048      	pea %a2@(72)                                      	<== NOT EXECUTED
   4a108:	4eb9 0004 7ce0 	jsr 47ce0 <_Watchdog_Remove>                      	<== NOT EXECUTED
   4a10e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4a110:	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
}
   4a114:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   4a11a:	227c 1003 fff8 	moveal #268697592,%a1                             	<== NOT EXECUTED
   4a120:	2d49 000c      	movel %a1,%fp@(12)                                	<== NOT EXECUTED
   4a124:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a126:	4ef9 0004 688c 	jmp 4688c <_Thread_Clear_state>                   	<== NOT EXECUTED
   4a12c:	4cee 3c04 ffec 	moveml %fp@(-20),%d2/%a2-%a5                      	<== NOT EXECUTED
   4a132:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a134:	4e75           	rts                                               	<== NOT EXECUTED
	...

000472ac <_Thread_queue_Extract_with_proxy>:
 */

bool _Thread_queue_Extract_with_proxy(
  Thread_Control       *the_thread
)
{
   472ac:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   472b0:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  States_Control                state;

  state = the_thread->current_state;

  if ( _States_Is_waiting_on_thread_queue( state ) ) {
   472b4:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
   472b8:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   472be:	6710           	beqs 472d0 <_Thread_queue_Extract_with_proxy+0x24>	<== NOT EXECUTED

        if ( proxy_extract_callout )
          (*proxy_extract_callout)( the_thread );
      }
    #endif
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
   472c0:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   472c2:	2f28 0044      	movel %a0@(68),%sp@-                              	<== NOT EXECUTED
   472c6:	4eb9 0004 a02c 	jsr 4a02c <_Thread_queue_Extract>                 	<== NOT EXECUTED
   472cc:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   472ce:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED

    return TRUE;
  }
  return FALSE;
}
   472d0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472d2:	4e75           	rts

00055518 <_Thread_queue_First>:
 */

Thread_Control *_Thread_queue_First(
  Thread_queue_Control *the_thread_queue
)
{
   55518:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5551c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  Thread_Control * (*first_p)(Thread_queue_Control *);

  if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY )
   55520:	203c 0005 5540 	movel #349504,%d0                                 	<== NOT EXECUTED
   55526:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   55528:	b2a8 0034      	cmpl %a0@(52),%d1                                 	<== NOT EXECUTED
   5552c:	6706           	beqs 55534 <_Thread_queue_First+0x1c>             	<== NOT EXECUTED
   5552e:	203c 0005 5f24 	movel #352036,%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 );
   55534:	2d48 0008      	movel %a0,%fp@(8)                                 	<== NOT EXECUTED
}
   55538:	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 );
   5553a:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   5553c:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
	...

00055f24 <_Thread_queue_First_fifo>:
 */

Thread_Control *_Thread_queue_First_fifo(
  Thread_queue_Control *the_thread_queue
)
{
   55f24:	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));
   55f28:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
   55f2c:	2018           	movel %a0@+,%d0                                   	<== NOT EXECUTED
  if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) )
   55f2e:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   55f30:	6602           	bnes 55f34 <_Thread_queue_First_fifo+0x10>        	<== NOT EXECUTED
   55f32:	4280           	clrl %d0                                          	<== NOT EXECUTED
    return (Thread_Control *) the_thread_queue->Queues.Fifo.first;

  return NULL;
}
   55f34:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   55f36:	4e75           	rts

00055540 <_Thread_queue_First_priority>:
 */

Thread_Control *_Thread_queue_First_priority (
  Thread_queue_Control *the_thread_queue
)
{
   55540:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   55544:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   55546:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   5554a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5554c:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   5554e:	244b           	moveal %a3,%a2                                    	<== NOT EXECUTED
   55550:	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 ] ) )
   55552:	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++ ) {
   55556:	d5fc 0000 000c 	addal #12,%a2                                     	<== NOT EXECUTED
   5555c:	5289           	addql #1,%a1                                      	<== NOT EXECUTED
    if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) )
   5555e:	41f3 8c00      	lea %a3@(00000000,%a0:l:4),%a0                    	<== NOT EXECUTED
   55562:	b1c0           	cmpal %d0,%a0                                     	<== NOT EXECUTED
   55564:	6608           	bnes 5556e <_Thread_queue_First_priority+0x2e>    	<== NOT EXECUTED
)
{
  uint32_t   index;

  for( index=0 ;
       index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ;
   55566:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   55568:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   5556a:	66e4           	bnes 55550 <_Thread_queue_First_priority+0x10>    	<== NOT EXECUTED
   5556c:	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;
}
   5556e:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   55570:	265f           	moveal %sp@+,%a3                                  	<== NOT EXECUTED
   55572:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   55574:	4e75           	rts                                               	<== NOT EXECUTED
	...

000472d4 <_Thread_queue_Flush>:
void _Thread_queue_Flush(
  Thread_queue_Control       *the_thread_queue,
  Thread_queue_Flush_callout  remote_extract_callout,
  uint32_t                    status
)
{
   472d4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   472d8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Thread_Control *the_thread;

  while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
   472da:	45f9 0004 6f70 	lea 46f70 <_Thread_queue_Dequeue>,%a2             	<== NOT EXECUTED
   472e0:	6008           	bras 472ea <_Thread_queue_Flush+0x16>             	<== 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;
   472e2:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   472e6:	2140 0034      	movel %d0,%a0@(52)                                	<== NOT EXECUTED
  uint32_t                    status
)
{
  Thread_Control *the_thread;

  while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) {
   472ea:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   472ee:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   472f0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   472f2:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   472f4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   472f6:	66ea           	bnes 472e2 <_Thread_queue_Flush+0xe>              	<== NOT EXECUTED
      ( *remote_extract_callout )( the_thread );
    else
#endif
      the_thread->Wait.return_code = status;
  }
}
   472f8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   472fc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   472fe:	4e75           	rts

00047300 <_Thread_queue_Initialize>:
  Thread_queue_Control         *the_thread_queue,
  Thread_queue_Disciplines      the_discipline,
  States_Control                state,
  uint32_t                      timeout_status
)
{
   47300:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47304:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  the_thread_queue->state          = state;
   47308:	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
)
{
   4730e:	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;
   47312:	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 ) {
   47318:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
  States_Control                state,
  uint32_t                      timeout_status
)
{
  the_thread_queue->state          = state;
  the_thread_queue->discipline     = the_discipline;
   4731a:	2140 0034      	movel %d0,%a0@(52)                                	<== NOT EXECUTED
  the_thread_queue->timeout_status = timeout_status;
  the_thread_queue->sync_state     = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   4731e:	42a8 0030      	clrl %a0@(48)                                     	<== NOT EXECUTED

  if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) {
   47322:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47324:	664c           	bnes 47372 <_Thread_queue_Initialize+0x72>        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47326:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   47328:	5889           	addql #4,%a1                                      	<== NOT EXECUTED
   4732a:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4732c:	43e8 0024      	lea %a0@(36),%a1                                  	<== NOT EXECUTED
   47330:	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);
   47334:	43e8 0010      	lea %a0@(16),%a1                                  	<== NOT EXECUTED
   47338:	2149 000c      	movel %a1,%a0@(12)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4733c:	43e8 000c      	lea %a0@(12),%a1                                  	<== NOT EXECUTED
   47340:	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);
   47344:	43e8 001c      	lea %a0@(28),%a1                                  	<== NOT EXECUTED
   47348:	2149 0018      	movel %a1,%a0@(24)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4734c:	43e8 0018      	lea %a0@(24),%a1                                  	<== NOT EXECUTED
   47350:	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);
   47354:	43e8 0028      	lea %a0@(40),%a1                                  	<== NOT EXECUTED
   47358:	2149 0024      	movel %a1,%a0@(36)                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   4735c:	42a8 0004      	clrl %a0@(4)                                      	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   47360:	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;
   47364:	42a8 0010      	clrl %a0@(16)                                     	<== NOT EXECUTED
   47368:	42a8 001c      	clrl %a0@(28)                                     	<== NOT EXECUTED
   4736c:	42a8 0028      	clrl %a0@(40)                                     	<== NOT EXECUTED
   47370:	600e           	bras 47380 <_Thread_queue_Initialize+0x80>        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47372:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   47374:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   47376:	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);
   4737a:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   4737c:	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 );
  }

}
   47380:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47382:	4e75           	rts

0004a138 <_Thread_queue_Process_timeout>:
#include <rtems/score/tqdata.h>

void _Thread_queue_Process_timeout(
  Thread_Control *the_thread
)
{
   4a138:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a13c:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  Thread_queue_Control *the_thread_queue = the_thread->Wait.queue;
   4a140:	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 &&
   4a144:	2028 0030      	movel %a0@(48),%d0                                	<== NOT EXECUTED
   4a148:	671c           	beqs 4a166 <_Thread_queue_Process_timeout+0x2e>   	<== NOT EXECUTED
   4a14a:	b3f9 0005 6d62 	cmpal 56d62 <_Thread_Executing>,%a1               	<== NOT EXECUTED
   4a150:	6614           	bnes 4a166 <_Thread_queue_Process_timeout+0x2e>   	<== NOT EXECUTED
       _Thread_Is_executing( the_thread ) ) {
    if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) {
   4a152:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4a154:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4a156:	6722           	beqs 4a17a <_Thread_queue_Process_timeout+0x42>   	<== NOT EXECUTED
      the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   4a158:	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;
   4a15a:	2368 003c 0034 	movel %a0@(60),%a1@(52)                           	<== NOT EXECUTED
      the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
   4a160:	2140 0030      	movel %d0,%a0@(48)                                	<== NOT EXECUTED
   4a164:	6014           	bras 4a17a <_Thread_queue_Process_timeout+0x42>   	<== NOT EXECUTED
    }
  } else {
    the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status;
   4a166:	2368 003c 0034 	movel %a0@(60),%a1@(52)                           	<== NOT EXECUTED
    _Thread_queue_Extract( the_thread->Wait.queue, the_thread );
   4a16c:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   4a16e:	2f29 0044      	movel %a1@(68),%sp@-                              	<== NOT EXECUTED
   4a172:	4eb9 0004 a02c 	jsr 4a02c <_Thread_queue_Extract>                 	<== NOT EXECUTED
   4a178:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  }
}
   4a17a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a17c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047384 <_Thread_queue_Requeue>:

void _Thread_queue_Requeue(
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread
)
{
   47384:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   47388:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   4738c:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   47390:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
  /*
   * Just in case the thread really wasn't blocked on a thread queue
   * when we get here.
   */
  if ( !the_thread_queue )
   47394:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   47396:	6748           	beqs 473e0 <_Thread_queue_Requeue+0x5c>           	<== 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 ) {
   47398:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4739a:	b0aa 0034      	cmpl %a2@(52),%d0                                 	<== NOT EXECUTED
   4739e:	6640           	bnes 473e0 <_Thread_queue_Requeue+0x5c>           	<== NOT EXECUTED
    Thread_queue_Control *tq = the_thread_queue;
    ISR_Level             level;
    ISR_Level             level_ignored;

    _ISR_Disable( level );
   473a0:	303c 0700      	movew #1792,%d0                                   	<== NOT EXECUTED
   473a4:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   473a6:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   473a8:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
   473aa:	202b 0010      	movel %a3@(16),%d0                                	<== NOT EXECUTED
   473ae:	0280 0003 bee0 	andil #245472,%d0                                 	<== NOT EXECUTED
   473b4:	6728           	beqs 473de <_Thread_queue_Requeue+0x5a>           	<== NOT EXECUTED
      _Thread_queue_Enter_critical_section( tq );
      _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE );
   473b6:	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;
   473ba:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   473bc:	2540 0030      	movel %d0,%a2@(48)                                	<== NOT EXECUTED
   473c0:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   473c2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   473c4:	4eb9 0004 a068 	jsr 4a068 <_Thread_queue_Extract_priority_helper> 	<== NOT EXECUTED
      (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
   473ca:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   473ce:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   473d0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   473d2:	4eb9 0004 7150 	jsr 47150 <_Thread_queue_Enqueue_priority>        	<== NOT EXECUTED
   473d8:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
    }
    _ISR_Enable( level );
   473de:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  }
}
   473e0:	4cee 0c04 fff0 	moveml %fp@(-16),%d2/%a2-%a3                      	<== NOT EXECUTED
   473e6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   473e8:	4e75           	rts                                               	<== NOT EXECUTED
	...

000473ec <_Thread_queue_Timeout>:

void _Thread_queue_Timeout(
  Objects_Id  id,
  void       *ignored
)
{
   473ec:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  Thread_Control       *the_thread;
  Objects_Locations     location;

  the_thread = _Thread_Get( id, &location );
   473f0:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   473f4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   473f8:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   473fe:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47400:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   47404:	6618           	bnes 4741e <_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 );
   47406:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47408:	4eb9 0004 a138 	jsr 4a138 <_Thread_queue_Process_timeout>         	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
   4740e:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   47414:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47416:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47418:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
      _Thread_Unnest_dispatch();
      break;
  }
}
   4741e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47420:	4e75           	rts                                               	<== NOT EXECUTED
	...

000496f0 <_Timer_Manager_initialization>:
 */

void _Timer_Manager_initialization(
  uint32_t   maximum_timers
)
{
   496f0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Objects_Initialize_information(
   496f4:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   496f8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   496fa:	4878 003c      	pea 3c <DBL_MANT_DIG+0x7>                         	<== NOT EXECUTED
   496fe:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   49702:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   49706:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   4970a:	4879 0005 708e 	pea 5708e <_Timer_Information>                    	<== NOT EXECUTED
   49710:	4eb9 0004 64c8 	jsr 464c8 <_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;
   49716:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
}
   4971c:	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;
   4971e:	42b9 0005 70ce 	clrl 570ce <_Timer_Server>                        	<== NOT EXECUTED
  _Timer_Server_schedule_operation = NULL;
   49724:	42b9 0005 70ca 	clrl 570ca <_Timer_Server_schedule_operation>     	<== NOT EXECUTED
}
   4972a:	4e75           	rts

0004f726 <_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;
   4f726:	2039 0006 c978 	movel 6c978 <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
 *  @param[in] ignored is the the task argument that is ignored
 */
Thread _Timer_Server_body(
  uint32_t   ignored
)
{
   4f72c:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
   4f730:	2239 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d1  	<== NOT EXECUTED
   4f736:	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;
   4f73a:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   4f73c:	2a0e           	movel %fp,%d5                                     	<== NOT EXECUTED
   4f73e:	5281           	addql #1,%d1                                      	<== NOT EXECUTED
   4f740:	0682 ffff fff4 	addil #-12,%d2                                    	<== NOT EXECUTED
   4f746:	5185           	subql #8,%d5                                      	<== 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;
   4f748:	41f9 0006 c8c2 	lea 6c8c2 <_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;
   4f74e:	23c0 0006 c798 	movel %d0,6c798 <_Timer_Server_ticks_last_time>   	<== NOT EXECUTED
  _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch;
   4f754:	23d0 0006 c794 	movel %a0@,6c794 <_Timer_Server_seconds_last_time>	<== NOT EXECUTED
   4f75a:	23c1 0006 c830 	movel %d1,6c830 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4f760:	2d45 fff4      	movel %d5,%fp@(-12)                               	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   4f764:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   4f768:	2d42 fffc      	movel %d2,%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();
   4f76c:	45f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
     */
    _Thread_Disable_dispatch();
      _Thread_Set_state( _Timer_Server, STATES_DELAYING );
      _Timer_Server_reset_ticks_timer();
      _Timer_Server_reset_seconds_timer();
    _Thread_Enable_dispatch();
   4f772:	280a           	movel %a2,%d4                                     	<== 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();
   4f774:	4eba ff50      	jsr %pc@(4f6c6 <_Timer_Server_process_insertions>)	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   4f778:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   4f77a:	4bf9 0005 3174 	lea 53174 <_Watchdog_Insert>,%a5                  	<== 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();
   4f780:	49f9 0005 3290 	lea 53290 <_Watchdog_Remove>,%a4                  	<== 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 );
   4f786:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
   4f788:	47f9 0005 30e8 	lea 530e8 <_Watchdog_Adjust_to_chain>,%a3         	<== 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 );
   4f78e:	2e3c 0005 3064 	movel #340068,%d7                                 	<== NOT EXECUTED
   4f794:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4f79a:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4f79c:	23c0 0006 c830 	movel %d0,6c830 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

    /*
     *  Block until there is something to do.
     */
    _Thread_Disable_dispatch();
      _Thread_Set_state( _Timer_Server, STATES_DELAYING );
   4f7a2:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   4f7a6:	2f39 0006 caf2 	movel 6caf2 <_Timer_Server>,%sp@-                 	<== NOT EXECUTED
   4f7ac:	4eb9 0005 2898 	jsr 52898 <_Thread_Set_state>                     	<== NOT EXECUTED
      _Timer_Server_reset_ticks_timer();
   4f7b2:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   4f7b4:	2279 0006 c788 	moveal 6c788 <_Timer_Ticks_chain>,%a1             	<== NOT EXECUTED
   4f7ba:	b3fc 0006 c78c 	cmpal #444300,%a1                                 	<== NOT EXECUTED
   4f7c0:	671a           	beqs 4f7dc <_Timer_Server_body+0xb6>              	<== NOT EXECUTED
   4f7c2:	2079 0006 caf2 	moveal 6caf2 <_Timer_Server>,%a0                  	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   4f7c8:	2169 0010 0054 	movel %a1@(16),%a0@(84)                           	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   4f7ce:	4868 0048      	pea %a0@(72)                                      	<== NOT EXECUTED
   4f7d2:	4879 0006 c90c 	pea 6c90c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   4f7d8:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4f7da:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4f7dc:	2079 0006 c79c 	moveal 6c79c <_Timer_Seconds_chain>,%a0           	<== NOT EXECUTED
      _Timer_Server_reset_seconds_timer();
   4f7e2:	b1fc 0006 c7a0 	cmpal #444320,%a0                                 	<== NOT EXECUTED
   4f7e8:	671c           	beqs 4f806 <_Timer_Server_body+0xe0>              	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   4f7ea:	d1fc 0000 0010 	addal #16,%a0                                     	<== NOT EXECUTED
   4f7f0:	23d0 0006 c7c0 	movel %a0@,6c7c0 <_Timer_Seconds_timer+0xc>       	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
   4f7f6:	4879 0006 c7b4 	pea 6c7b4 <_Timer_Seconds_timer>                  	<== NOT EXECUTED
   4f7fc:	4879 0006 c900 	pea 6c900 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   4f802:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
   4f804:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   4f806:	2044           	moveal %d4,%a0                                    	<== NOT EXECUTED
   4f808:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4f80a:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4f810:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4f812:	23c0 0006 c830 	movel %d0,6c830 <_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();
   4f818:	2039 0006 caf2 	movel 6caf2 <_Timer_Server>,%d0                   	<== NOT EXECUTED
   4f81e:	0680 0000 0048 	addil #72,%d0                                     	<== NOT EXECUTED
   4f824:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4f826:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
    _Timer_Server_stop_seconds_timer();
   4f828:	4879 0006 c7b4 	pea 6c7b4 <_Timer_Seconds_timer>                  	<== NOT EXECUTED
   4f82e:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
)
{
  Watchdog_Interval snapshot;
  Watchdog_Interval ticks;

  snapshot = _Watchdog_Ticks_since_boot;
   4f830:	2239 0006 c978 	movel 6c978 <_Watchdog_Ticks_since_boot>,%d1      	<== NOT EXECUTED
  if ( snapshot >= _Timer_Server_ticks_last_time )
   4f836:	2039 0006 c798 	movel 6c798 <_Timer_Server_ticks_last_time>,%d0   	<== NOT EXECUTED
   4f83c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4f83e:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4f840:	6208           	bhis 4f84a <_Timer_Server_body+0x124>             	<== NOT EXECUTED
     ticks = snapshot - _Timer_Server_ticks_last_time;
   4f842:	2c01           	movel %d1,%d6                                     	<== NOT EXECUTED
   4f844:	9c80           	subl %d0,%d6                                      	<== NOT EXECUTED
   4f846:	2006           	movel %d6,%d0                                     	<== NOT EXECUTED
   4f848:	6004           	bras 4f84e <_Timer_Server_body+0x128>             	<== NOT EXECUTED
  else
     ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot;
   4f84a:	4680           	notl %d0                                          	<== NOT EXECUTED
   4f84c:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED

  _Timer_Server_ticks_last_time = snapshot;
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
   4f84e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f850:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4f852:	4879 0006 c788 	pea 6c788 <_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;
   4f858:	23c1 0006 c798 	movel %d1,6c798 <_Timer_Server_ticks_last_time>   	<== NOT EXECUTED
  _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire );
   4f85e:	4e93           	jsr %a3@                                          	<== 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;
   4f860:	2479 0006 c8c2 	moveal 6c8c2 <_TOD_Now>,%a2                       	<== NOT EXECUTED
  if ( snapshot > _Timer_Server_seconds_last_time ) {
   4f866:	2039 0006 c794 	movel 6c794 <_Timer_Server_seconds_last_time>,%d0 	<== NOT EXECUTED
   4f86c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f872:	b08a           	cmpl %a2,%d0                                      	<== NOT EXECUTED
   4f874:	6412           	bccs 4f888 <_Timer_Server_body+0x162>             	<== 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 );
   4f876:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f878:	220a           	movel %a2,%d1                                     	<== NOT EXECUTED
   4f87a:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4f87c:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   4f87e:	4879 0006 c79c 	pea 6c79c <_Timer_Seconds_chain>                  	<== NOT EXECUTED
   4f884:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4f886:	6016           	bras 4f89e <_Timer_Server_body+0x178>             	<== NOT EXECUTED

  } else if ( snapshot < _Timer_Server_seconds_last_time ) {
   4f888:	b08a           	cmpl %a2,%d0                                      	<== NOT EXECUTED
   4f88a:	6318           	blss 4f8a4 <_Timer_Server_body+0x17e>             	<== 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 );
   4f88c:	908a           	subl %a2,%d0                                      	<== NOT EXECUTED
   4f88e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4f890:	2047           	moveal %d7,%a0                                    	<== NOT EXECUTED
   4f892:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4f896:	4879 0006 c79c 	pea 6c79c <_Timer_Seconds_chain>                  	<== NOT EXECUTED
   4f89c:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4f89e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  }
  _Timer_Server_seconds_last_time = snapshot;
   4f8a4:	23ca 0006 c794 	movel %a2,6c794 <_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();
   4f8aa:	4eba fe1a      	jsr %pc@(4f6c6 <_Timer_Server_process_insertions>)	<== NOT EXECUTED

    /*
     * Enable dispatching to process the set that are ready "to fire."
     */
    _Thread_Enable_dispatch();
   4f8ae:	2044           	moveal %d4,%a0                                    	<== NOT EXECUTED
   4f8b0:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
     */
    while (1) {
      Watchdog_Control *watch;
      ISR_Level         level;

      _ISR_Disable( level );
   4f8b2:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4f8b8:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4f8ba:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4f8bc:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4f8be:	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))
   4f8c2:	ba89           	cmpl %a1,%d5                                      	<== NOT EXECUTED
   4f8c4:	670e           	beqs 4f8d4 <_Timer_Server_body+0x1ae>             	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   4f8c6:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   4f8c8:	2d48 fff4      	movel %a0,%fp@(-12)                               	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   4f8cc:	2142 0004      	movel %d2,%a0@(4)                                 	<== NOT EXECUTED
      watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire );
      if ( watch == NULL ) {
   4f8d0:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4f8d2:	6606           	bnes 4f8da <_Timer_Server_body+0x1b4>             	<== NOT EXECUTED
        _ISR_Enable( level );
   4f8d4:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   4f8d6:	6000 febc      	braw 4f794 <_Timer_Server_body+0x6e>              	<== NOT EXECUTED
        break;
      }

      watch->state = WATCHDOG_INACTIVE;
   4f8da:	42a9 0008      	clrl %a1@(8)                                      	<== NOT EXECUTED
      _ISR_Enable( level );
   4f8de:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

      (*watch->routine)( watch->id, watch->user_data );
   4f8e0:	2f29 0024      	movel %a1@(36),%sp@-                              	<== NOT EXECUTED
   4f8e4:	2f29 0020      	movel %a1@(32),%sp@-                              	<== NOT EXECUTED
   4f8e8:	2069 001c      	moveal %a1@(28),%a0                               	<== NOT EXECUTED
   4f8ec:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4f8ee:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4f8f0:	60c0           	bras 4f8b2 <_Timer_Server_body+0x18c>             	<== NOT EXECUTED
	...

0004f6c6 <_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)
{
   4f6c6:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4f6ca:	48d7 1c00      	moveml %a2-%a4,%sp@                               	<== NOT EXECUTED
  Timer_Control *the_timer;

  while ( 1 ) {
    the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted );
   4f6ce:	49f9 0005 0048 	lea 50048 <_Chain_Get>,%a4                        	<== 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 );
   4f6d4:	45f9 0005 3174 	lea 53174 <_Watchdog_Insert>,%a2                  	<== NOT EXECUTED
    }

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   4f6da:	47fa ffea      	lea %pc@(4f6c6 <_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 );
   4f6de:	4879 0006 c7a8 	pea 6c7a8 <_Timer_To_be_inserted>                 	<== NOT EXECUTED
   4f6e4:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
    if ( the_timer == NULL )
   4f6e6:	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 );
   4f6e8:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
    if ( the_timer == NULL )
   4f6ea:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f6ec:	672e           	beqs 4f71c <_Timer_Server_process_insertions+0x56>	<== NOT EXECUTED
      break;

    if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) {
   4f6ee:	2028 0038      	movel %a0@(56),%d0                                	<== NOT EXECUTED
   4f6f2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4f6f4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4f6f6:	660c           	bnes 4f704 <_Timer_Server_process_insertions+0x3e>	<== NOT EXECUTED
      _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker );
   4f6f8:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   4f6fc:	4879 0006 c788 	pea 6c788 <_Timer_Ticks_chain>                    	<== NOT EXECUTED
   4f702:	6010           	bras 4f714 <_Timer_Server_process_insertions+0x4e>	<== NOT EXECUTED
    } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
   4f704:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4f706:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4f708:	660e           	bnes 4f718 <_Timer_Server_process_insertions+0x52>	<== NOT EXECUTED
      _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker );
   4f70a:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   4f70e:	4879 0006 c79c 	pea 6c79c <_Timer_Seconds_chain>                  	<== NOT EXECUTED
   4f714:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4f716:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    }

    /*
     *  Insert the timers that have been requested to be inserted.
     */
    _Timer_Server_process_insertions();
   4f718:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4f71a:	60c2           	bras 4f6de <_Timer_Server_process_insertions+0x18>	<== NOT EXECUTED
  }

}
   4f71c:	4cee 1c00 fff4 	moveml %fp@(-12),%a2-%a4                          	<== NOT EXECUTED
   4f722:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f724:	4e75           	rts

0004f682 <_Timer_Server_schedule_operation_method>:
 *        the directive invoking this is executed.
 */
static void _Timer_Server_schedule_operation_method(
  Timer_Control     *the_timer
)
{
   4f682:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node );
   4f686:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4f68a:	4879 0006 c7a8 	pea 6c7a8 <_Timer_To_be_inserted>                 	<== NOT EXECUTED
   4f690:	4eb9 0005 0010 	jsr 50010 <_Chain_Append>                         	<== NOT EXECUTED
  _Watchdog_Remove( &_Timer_Server->Timer );
   4f696:	2039 0006 caf2 	movel 6caf2 <_Timer_Server>,%d0                   	<== NOT EXECUTED
   4f69c:	0680 0000 0048 	addil #72,%d0                                     	<== NOT EXECUTED
   4f6a2:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4f6a4:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
  _Thread_Delay_ended( _Timer_Server->Object.id, NULL );
   4f6aa:	2079 0006 caf2 	moveal 6caf2 <_Timer_Server>,%a0                  	<== NOT EXECUTED
   4f6b0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4f6b2:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   4f6b6:	4eb9 0005 1d64 	jsr 51d64 <_Thread_Delay_ended>                   	<== NOT EXECUTED
   4f6bc:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
}
   4f6c2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f6c4:	4e75           	rts

0004790c <_Timespec_Add_to>:

uint32_t _Timespec_Add_to(
  struct timespec       *time,
  const struct timespec *add
)
{
   4790c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47910:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   47914:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
  uint32_t seconds = add->tv_sec;
   47918:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED

  /* Add the basics */
  time->tv_sec += add->tv_sec;
  time->tv_nsec += add->tv_nsec;
   4791a:	2228 0004      	movel %a0@(4),%d1                                 	<== NOT EXECUTED
)
{
  uint32_t seconds = add->tv_sec;

  /* Add the basics */
  time->tv_sec += add->tv_sec;
   4791e:	d191           	addl %d0,%a1@                                     	<== NOT EXECUTED
  time->tv_nsec += add->tv_nsec;
   47920:	d3a9 0004      	addl %d1,%a1@(4)                                  	<== NOT EXECUTED
   47924:	600e           	bras 47934 <_Timespec_Add_to+0x28>                	<== NOT EXECUTED

  /* Now adjust it so nanoseconds is in range */
  while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
    time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
    time->tv_sec++;
    seconds++;
   47926:	5280           	addql #1,%d0                                      	<== 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;
   47928:	0681 c465 3600 	addil #-1000000000,%d1                            	<== NOT EXECUTED
   4792e:	2341 0004      	movel %d1,%a1@(4)                                 	<== NOT EXECUTED
    time->tv_sec++;
   47932:	5291           	addql #1,%a1@                                     	<== 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 ) {
   47934:	2229 0004      	movel %a1@(4),%d1                                 	<== NOT EXECUTED
   47938:	0c81 3b9a c9ff 	cmpil #999999999,%d1                              	<== NOT EXECUTED
   4793e:	62e6           	bhis 47926 <_Timespec_Add_to+0x1a>                	<== NOT EXECUTED
    time->tv_sec++;
    seconds++;
  }

  return seconds;
}
   47940:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47942:	4e75           	rts

00048bd4 <_Timespec_Divide>:
  const struct timespec *lhs,
  const struct timespec *rhs,
  uint32_t              *ival_percentage,
  uint32_t              *fval_percentage
)
{
   48bd4:	4e56 ffd8      	linkw %fp,#-40                                    	<== NOT EXECUTED
   48bd8:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%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;
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
   48bdc:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
  const struct timespec *lhs,
  const struct timespec *rhs,
  uint32_t              *ival_percentage,
  uint32_t              *fval_percentage
)
{
   48be2:	206e 0008      	moveal %fp@(8),%a0                                	<== 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;
   48be6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
  const struct timespec *lhs,
  const struct timespec *rhs,
  uint32_t              *ival_percentage,
  uint32_t              *fval_percentage
)
{
   48be8:	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;
   48bec:	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;
   48bf0:	2810           	movel %a0@,%d4                                    	<== NOT EXECUTED
  left  += lhs->tv_nsec;
  right  = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
   48bf2:	4bf9 0005 4618 	lea 54618 <__muldi3>,%a5                          	<== NOT EXECUTED
   48bf8:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   48bfa:	5bc0           	smi %d0                                           	<== NOT EXECUTED
   48bfc:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   48bfe:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   48c00:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
  right += rhs->tv_nsec;
   48c02:	262a 0004      	movel %a2@(4),%d3                                 	<== NOT EXECUTED
   48c06:	5bc2           	smi %d2                                           	<== NOT EXECUTED
   48c08:	49c2           	extbl %d2                                         	<== NOT EXECUTED
   48c0a:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   48c0c:	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;
   48c0e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  right += rhs->tv_nsec;
   48c14:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
   48c16:	2841           	moveal %d1,%a4                                    	<== NOT EXECUTED

  if ( right == 0 ) {
   48c18:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   48c1a:	6614           	bnes 48c30 <_Timespec_Divide+0x5c>                	<== NOT EXECUTED
   48c1c:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   48c1e:	6610           	bnes 48c30 <_Timespec_Divide+0x5c>                	<== NOT EXECUTED
    *ival_percentage = 0;
   48c20:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
   48c24:	4290           	clrl %a0@                                         	<== NOT EXECUTED
    *fval_percentage = 0;
   48c26:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   48c2a:	4290           	clrl %a0@                                         	<== NOT EXECUTED
   48c2c:	6000 00d4      	braw 48d02 <_Timespec_Divide+0x12e>               	<== NOT EXECUTED
   *  Put it back in the timespec result.
   *
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;
   48c30:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   48c32:	5bc2           	smi %d2                                           	<== NOT EXECUTED
   48c34:	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;
   48c36:	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;
   48c3c:	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;
   48c3e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   48c40:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   48c42:	5bc0           	smi %d0                                           	<== NOT EXECUTED
   48c44:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   48c46:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   48c48:	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;
   48c4a:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   48c4c:	d182           	addxl %d2,%d0                                     	<== NOT EXECUTED
   48c4e:	2801           	movel %d1,%d4                                     	<== NOT EXECUTED
   48c50:	741e           	moveq #30,%d2                                     	<== NOT EXECUTED
   48c52:	e4ac           	lsrl %d2,%d4                                      	<== NOT EXECUTED
   48c54:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   48c56:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED
   48c58:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   48c5a:	8484           	orl %d4,%d2                                       	<== NOT EXECUTED
   48c5c:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   48c5e:	2803           	movel %d3,%d4                                     	<== NOT EXECUTED
   48c60:	2c02           	movel %d2,%d6                                     	<== NOT EXECUTED
   48c62:	eaac           	lsrl %d5,%d4                                      	<== NOT EXECUTED
   48c64:	2e03           	movel %d3,%d7                                     	<== NOT EXECUTED
   48c66:	eb8e           	lsll #5,%d6                                       	<== NOT EXECUTED
   48c68:	8c84           	orl %d4,%d6                                       	<== NOT EXECUTED
   48c6a:	eb8f           	lsll #5,%d7                                       	<== NOT EXECUTED
   48c6c:	2806           	movel %d6,%d4                                     	<== NOT EXECUTED
   48c6e:	2a07           	movel %d7,%d5                                     	<== NOT EXECUTED
   48c70:	9a83           	subl %d3,%d5                                      	<== NOT EXECUTED
   48c72:	9982           	subxl %d2,%d4                                     	<== NOT EXECUTED
   48c74:	da81           	addl %d1,%d5                                      	<== NOT EXECUTED
   48c76:	d980           	addxl %d0,%d4                                     	<== NOT EXECUTED
   48c78:	721e           	moveq #30,%d1                                     	<== NOT EXECUTED
   48c7a:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48c7c:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   48c7e:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   48c80:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   48c82:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   48c84:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
   48c86:	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;
   48c88:	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;
   48c8e:	da83           	addl %d3,%d5                                      	<== NOT EXECUTED
   48c90:	d982           	addxl %d2,%d4                                     	<== NOT EXECUTED
   48c92:	2f0c           	movel %a4,%sp@-                                   	<== NOT EXECUTED
   48c94:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48c96:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   48c98:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   48c9a:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   48c9c:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   48c9e:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
   48ca0:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   48ca2:	da83           	addl %d3,%d5                                      	<== NOT EXECUTED
   48ca4:	d982           	addxl %d2,%d4                                     	<== NOT EXECUTED
   48ca6:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   48ca8:	741b           	moveq #27,%d2                                     	<== NOT EXECUTED
   48caa:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   48cac:	2605           	movel %d5,%d3                                     	<== NOT EXECUTED
   48cae:	e4a8           	lsrl %d2,%d0                                      	<== NOT EXECUTED
   48cb0:	eb8b           	lsll #5,%d3                                       	<== NOT EXECUTED
   48cb2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   48cb4:	2404           	movel %d4,%d2                                     	<== NOT EXECUTED
   48cb6:	eb8a           	lsll #5,%d2                                       	<== NOT EXECUTED
   48cb8:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
   48cba:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48cbc:	45f9 0005 4680 	lea 54680 <__udivdi3>,%a2                         	<== NOT EXECUTED
   48cc2:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   48cc4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED

  *ival_percentage = answer / 1000;
   48cca:	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;
   48cce:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   48cd0:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED

  *ival_percentage = answer / 1000;
   48cd2:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   48cd4:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   48cd6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   48cd8:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   48cda:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  *fval_percentage = answer % 1000;
   48ce0:	4878 03e8      	pea 3e8 <FP_REGS_SAVED+0x3a8>                     	<== NOT EXECUTED
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;

  *ival_percentage = answer / 1000;
   48ce4:	206e 0010      	moveal %fp@(16),%a0                               	<== NOT EXECUTED
  *fval_percentage = answer % 1000;
   48ce8:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   *  TODO: Rounding on the last digit of the fval.
   */

  answer = (left * 100000) / right;

  *ival_percentage = answer / 1000;
   48cea:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
  *fval_percentage = answer % 1000;
   48cec:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   48cee:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48cf0:	4eb9 0005 4a34 	jsr 54a34 <__umoddi3>                             	<== NOT EXECUTED
   48cf6:	206e 0014      	moveal %fp@(20),%a0                               	<== NOT EXECUTED
   48cfa:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   48d00:	2081           	movel %d1,%a0@                                    	<== NOT EXECUTED
}
   48d02:	4cee 3cfc ffd8 	moveml %fp@(-40),%d2-%d7/%a2-%a5                  	<== NOT EXECUTED
   48d08:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48d0a:	4e75           	rts

0005e414 <_Timespec_Divide_by_integer>:
void _Timespec_Divide_by_integer(
  const struct timespec *time,
  uint32_t               iterations,
  struct timespec       *result
)
{
   5e414:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   5e418:	48d7 040c      	moveml %d2-%d3/%a2,%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;
   5e41c:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
void _Timespec_Divide_by_integer(
  const struct timespec *time,
  uint32_t               iterations,
  struct timespec       *result
)
{
   5e422:	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;
   5e426:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5e428:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   5e42a:	5bc0           	smi %d0                                           	<== NOT EXECUTED
   5e42c:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   5e42e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5e430:	4eb9 0007 6c58 	jsr 76c58 <__muldi3>                              	<== NOT EXECUTED

  /*
   *  Divide to get nanoseconds per iteration
   */

  t /= iterations;
   5e436:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5e43c:	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;
   5e440:	262a 0004      	movel %a2@(4),%d3                                 	<== NOT EXECUTED
   5e444:	5bc2           	smi %d2                                           	<== NOT EXECUTED
   5e446:	49c2           	extbl %d2                                         	<== NOT EXECUTED

  /*
   *  Divide to get nanoseconds per iteration
   */

  t /= iterations;
   5e448:	d283           	addl %d3,%d1                                      	<== NOT EXECUTED
   5e44a:	d182           	addxl %d2,%d0                                     	<== NOT EXECUTED
   5e44c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5e44e:	45f9 0007 6d3c 	lea 76d3c <__udivdi3>,%a2                         	<== NOT EXECUTED
   5e454:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   5e456:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5e458:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   5e45a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED

  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
   5e460:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED

  /*
   *  Divide to get nanoseconds per iteration
   */

  t /= iterations;
   5e466:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   5e468:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED

  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
   5e46a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5e46c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5e46e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5e470:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   5e472:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
   5e478:	2f3c 3b9a ca00 	movel #1000000000,%sp@-                           	<== NOT EXECUTED
void _Timespec_Divide_by_integer(
  const struct timespec *time,
  uint32_t               iterations,
  struct timespec       *result
)
{
   5e47e:	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;
   5e482:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED

  /*
   *  Put it back in the timespec result
   */

  result->tv_sec  = t / TOD_NANOSECONDS_PER_SECOND;
   5e484:	2481           	movel %d1,%a2@                                    	<== NOT EXECUTED
  result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND;
   5e486:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5e488:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5e48a:	4eb9 0007 70f0 	jsr 770f0 <__umoddi3>                             	<== NOT EXECUTED
   5e490:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
   5e494:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
}
   5e49a:	4cee 040c fff4 	moveml %fp@(-12),%d2-%d3/%a2                      	<== NOT EXECUTED
   5e4a0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5e4a2:	4e75           	rts

0004fff8 <_Timespec_From_ticks>:

void _Timespec_From_ticks(
  uint32_t         ticks,
  struct timespec *time
)
{
   4fff8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  uint32_t    usecs;

  usecs = ticks * _TOD_Microseconds_per_tick;
   4fffc:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   50000:	43f9 0006 2b1a 	lea 62b1a <_TOD_Microseconds_per_tick>,%a1        	<== NOT EXECUTED
   50006:	4c11 0800      	mulsl %a1@,%d0                                    	<== NOT EXECUTED

void _Timespec_From_ticks(
  uint32_t         ticks,
  struct timespec *time
)
{
   5000a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5000c:	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;
   50010:	243c 000f 4240 	movel #1000000,%d2                                	<== NOT EXECUTED
   50016:	4c42 0001      	remul %d2,%d1,%d0                                 	<== NOT EXECUTED
   5001a:	4c42 0000      	remul %d2,%d0,%d0                                 	<== NOT EXECUTED
   5001e:	2080           	movel %d0,%a0@                                    	<== NOT EXECUTED
  time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) *
   50020:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   50022:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   50024:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   50026:	ef88           	lsll #7,%d0                                       	<== NOT EXECUTED
   50028:	9082           	subl %d2,%d0                                      	<== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;
}
   5002a:	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) *
   5002c:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   5002e:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;
}
   50030:	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) *
   50032:	2140 0004      	movel %d0,%a0@(4)                                 	<== NOT EXECUTED
                    TOD_NANOSECONDS_PER_MICROSECOND;
}
   50036:	4e75           	rts

00049084 <_Timespec_Greater_than>:

bool _Timespec_Greater_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
   49084:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   49088:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   4908c:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  if ( lhs->tv_sec > rhs->tv_sec )
   49090:	2211           	movel %a1@,%d1                                    	<== NOT EXECUTED
   49092:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   49094:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   49096:	6c04           	bges 4909c <_Timespec_Greater_than+0x18>          	<== NOT EXECUTED
   49098:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4909a:	6014           	bras 490b0 <_Timespec_Greater_than+0x2c>          	<== NOT EXECUTED
    return TRUE;

  if ( lhs->tv_sec < rhs->tv_sec )
   4909c:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4909e:	6f04           	bles 490a4 <_Timespec_Greater_than+0x20>          	<== NOT EXECUTED
   490a0:	4200           	clrb %d0                                          	<== NOT EXECUTED
   490a2:	600c           	bras 490b0 <_Timespec_Greater_than+0x2c>          	<== NOT EXECUTED
    return FALSE;

  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec > rhs->tv_nsec )
   490a4:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
   490a8:	b1e9 0004      	cmpal %a1@(4),%a0                                 	<== NOT EXECUTED
   490ac:	5dc0           	slt %d0                                           	<== NOT EXECUTED
   490ae:	4480           	negl %d0                                          	<== NOT EXECUTED
    return TRUE;

  return FALSE;
}
   490b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   490b2:	4e75           	rts

00050038 <_Timespec_Is_valid>:
#include <rtems/score/tod.h>

bool _Timespec_Is_valid(
  const struct timespec *time
)
{
   50038:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5003c:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  if ( !time )
   50040:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   50042:	6716           	beqs 5005a <_Timespec_Is_valid+0x22>              	<== NOT EXECUTED
    return FALSE;

  if ( time->tv_sec < 0 )
   50044:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   50046:	6d12           	blts 5005a <_Timespec_Is_valid+0x22>              	<== NOT EXECUTED
    return FALSE;

  if ( time->tv_nsec < 0 )
   50048:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
   5004c:	6d0c           	blts 5005a <_Timespec_Is_valid+0x22>              	<== NOT EXECUTED
   5004e:	0c80 3b9a c9ff 	cmpil #999999999,%d0                              	<== NOT EXECUTED
   50054:	53c0           	sls %d0                                           	<== NOT EXECUTED
   50056:	4480           	negl %d0                                          	<== NOT EXECUTED
   50058:	6002           	bras 5005c <_Timespec_Is_valid+0x24>              	<== NOT EXECUTED
   5005a:	4200           	clrb %d0                                          	<== NOT EXECUTED

  if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND )
    return FALSE;

  return TRUE;
}
   5005c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5005e:	4e75           	rts

000490b4 <_Timespec_Less_than>:

bool _Timespec_Less_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
   490b4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   490b8:	226e 0008      	moveal %fp@(8),%a1                                	<== NOT EXECUTED
   490bc:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
  if ( lhs->tv_sec < rhs->tv_sec )
   490c0:	2211           	movel %a1@,%d1                                    	<== NOT EXECUTED
   490c2:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   490c4:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   490c6:	6f04           	bles 490cc <_Timespec_Less_than+0x18>             	<== NOT EXECUTED
   490c8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   490ca:	6014           	bras 490e0 <_Timespec_Less_than+0x2c>             	<== NOT EXECUTED
    return TRUE;

  if ( lhs->tv_sec > rhs->tv_sec )
   490cc:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   490ce:	6c04           	bges 490d4 <_Timespec_Less_than+0x20>             	<== NOT EXECUTED
   490d0:	4200           	clrb %d0                                          	<== NOT EXECUTED
   490d2:	600c           	bras 490e0 <_Timespec_Less_than+0x2c>             	<== NOT EXECUTED
    return FALSE;

  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec < rhs->tv_nsec )
   490d4:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
   490d8:	b1e9 0004      	cmpal %a1@(4),%a0                                 	<== NOT EXECUTED
   490dc:	5ec0           	sgt %d0                                           	<== NOT EXECUTED
   490de:	4480           	negl %d0                                          	<== NOT EXECUTED
    return TRUE;

  return FALSE;
}
   490e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   490e2:	4e75           	rts

00047944 <_Timespec_Subtract>:
void _Timespec_Subtract(
  const struct timespec *start,
  const struct timespec *end,
  struct timespec       *result
)
{
   47944:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47948:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4794a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   4794e:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED

  if (end->tv_nsec < start->tv_nsec) {
   47952:	202a 0004      	movel %a2@(4),%d0                                 	<== NOT EXECUTED
void _Timespec_Subtract(
  const struct timespec *start,
  const struct timespec *end,
  struct timespec       *result
)
{
   47956:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED

  if (end->tv_nsec < start->tv_nsec) {
   4795a:	b0a8 0004      	cmpl %a0@(4),%d0                                  	<== NOT EXECUTED
   4795e:	6f1c           	bles 4797c <_Timespec_Subtract+0x38>              	<== NOT EXECUTED
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
   47960:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
    result->tv_nsec =
   47962:	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;
   47966:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
    result->tv_nsec =
   47968:	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;
   4796e:	9092           	subl %a2@,%d0                                     	<== NOT EXECUTED
    result->tv_nsec =
   47970:	92aa 0004      	subl %a2@(4),%d1                                  	<== NOT EXECUTED
  struct timespec       *result
)
{

  if (end->tv_nsec < start->tv_nsec) {
    result->tv_sec  = end->tv_sec - start->tv_sec - 1;
   47974:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
    result->tv_nsec =
   47976:	2341 0004      	movel %d1,%a1@(4)                                 	<== NOT EXECUTED
   4797a:	6012           	bras 4798e <_Timespec_Subtract+0x4a>              	<== NOT EXECUTED
      (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec;
  } else {
    result->tv_sec  = end->tv_sec - start->tv_sec;
   4797c:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
   4797e:	9092           	subl %a2@,%d0                                     	<== NOT EXECUTED
   47980:	2280           	movel %d0,%a1@                                    	<== NOT EXECUTED
    result->tv_nsec = end->tv_nsec - start->tv_nsec;
   47982:	2028 0004      	movel %a0@(4),%d0                                 	<== NOT EXECUTED
   47986:	90aa 0004      	subl %a2@(4),%d0                                  	<== NOT EXECUTED
   4798a:	2340 0004      	movel %d0,%a1@(4)                                 	<== NOT EXECUTED
  }
}
   4798e:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   47990:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47992:	4e75           	rts

00050060 <_Timespec_To_ticks>:
 */

uint32_t _Timespec_To_ticks(
  const struct timespec *time
)
{
   50060:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   50064:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  uint32_t  ticks;

  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
   50068:	2210           	movel %a0@,%d1                                    	<== NOT EXECUTED
 */

uint32_t _Timespec_To_ticks(
  const struct timespec *time
)
{
   5006a:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
  uint32_t  ticks;

  if ( (time->tv_sec == 0) && (time->tv_nsec == 0) )
   5006e:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   50070:	660a           	bnes 5007c <_Timespec_To_ticks+0x1c>              	<== NOT EXECUTED
   50072:	4aa8 0004      	tstl %a0@(4)                                      	<== NOT EXECUTED
   50076:	6604           	bnes 5007c <_Timespec_To_ticks+0x1c>              	<== NOT EXECUTED
   50078:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5007a:	6030           	bras 500ac <_Timespec_To_ticks+0x4c>              	<== NOT EXECUTED
    return 0;

  ticks  = time->tv_sec * TOD_TICKS_PER_SECOND;
   5007c:	2039 0006 2b1a 	movel 62b1a <_TOD_Microseconds_per_tick>,%d0      	<== NOT EXECUTED
   50082:	243c 000f 4240 	movel #1000000,%d2                                	<== NOT EXECUTED
   50088:	4c40 2002      	remul %d0,%d2,%d2                                 	<== NOT EXECUTED
   5008c:	4c01 2800      	mulsl %d1,%d2                                     	<== NOT EXECUTED

  ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) /
   50090:	2228 0004      	movel %a0@(4),%d1                                 	<== NOT EXECUTED
   50094:	283c 0000 03e8 	movel #1000,%d4                                   	<== NOT EXECUTED
   5009a:	4c44 1001      	remul %d4,%d1,%d1                                 	<== NOT EXECUTED
   5009e:	4c40 1001      	remul %d0,%d1,%d1                                 	<== NOT EXECUTED
   500a2:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   500a4:	d082           	addl %d2,%d0                                      	<== NOT EXECUTED
             _TOD_Microseconds_per_tick;

  if (ticks)
   500a6:	6604           	bnes 500ac <_Timespec_To_ticks+0x4c>              	<== NOT EXECUTED
   500a8:	103c 0001      	moveb #1,%d0                                      	<== NOT EXECUTED
    return ticks;

  return 1;
}
   500ac:	4cd7 001c      	moveml %sp@,%d2-%d4                               	<== NOT EXECUTED
   500b0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   500b2:	4e75           	rts

0004a2b4 <_User_extensions_Add_API_set>:
 */

void _User_extensions_Add_API_set (
  User_extensions_Control *the_extension
)
{
   4a2b4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a2b8:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
  _Chain_Append( &_User_extensions_List, &the_extension->Node );
   4a2ba:	47f9 0004 58a8 	lea 458a8 <_Chain_Append>,%a3                     	<== NOT EXECUTED
 */

void _User_extensions_Add_API_set (
  User_extensions_Control *the_extension
)
{
   4a2c0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4a2c2:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  _Chain_Append( &_User_extensions_List, &the_extension->Node );
   4a2c6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4a2c8:	4879 0005 6e42 	pea 56e42 <_User_extensions_List>                 	<== NOT EXECUTED
   4a2ce:	4e93           	jsr %a3@                                          	<== NOT EXECUTED

  /*
   *  If a switch handler is present, append it to the switch chain.
   */

  if ( the_extension->Callouts.thread_switch != NULL ) {
   4a2d0:	202a 0024      	movel %a2@(36),%d0                                	<== NOT EXECUTED
   4a2d4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4a2d6:	6712           	beqs 4a2ea <_User_extensions_Add_API_set+0x36>    	<== NOT EXECUTED
    the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch;
    _Chain_Append(
   4a2d8:	486a 0008      	pea %a2@(8)                                       	<== NOT EXECUTED
   4a2dc:	4879 0005 6ca8 	pea 56ca8 <_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;
   4a2e2:	2540 0010      	movel %d0,%a2@(16)                                	<== NOT EXECUTED
    _Chain_Append(
   4a2e6:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4a2e8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      &_User_extensions_Switches_list, &the_extension->Switch.Node );
  }
}
   4a2ea:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4a2ee:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4a2f2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a2f4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004a2f8 <_User_extensions_Add_set>:

void _User_extensions_Add_set (
  User_extensions_Control *the_extension,
  User_extensions_Table   *extension_table
)
{
   4a2f8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a2fc:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4a2fe:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  the_extension->Callouts = *extension_table;
   4a300:	4878 0020      	pea 20 <OPER2+0xc>                                	<== NOT EXECUTED

void _User_extensions_Add_set (
  User_extensions_Control *the_extension,
  User_extensions_Table   *extension_table
)
{
   4a304:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   4a308:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
  the_extension->Callouts = *extension_table;
   4a30c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4a30e:	486b 0014      	pea %a3@(20)                                      	<== NOT EXECUTED
   4a312:	4eb9 0004 b3f4 	jsr 4b3f4 <memcpy>                                	<== NOT EXECUTED

  _Chain_Append( &_User_extensions_List, &the_extension->Node );
   4a318:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4a31a:	4879 0005 6e42 	pea 56e42 <_User_extensions_List>                 	<== NOT EXECUTED
   4a320:	4eb9 0004 58a8 	jsr 458a8 <_Chain_Append>                         	<== NOT EXECUTED

  /*
   * If a switch handler is present, append it to the switch chain.
   */

  if ( extension_table->thread_switch != NULL ) {
   4a326:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   4a32a:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   4a330:	6726           	beqs 4a358 <_User_extensions_Add_set+0x60>        	<== NOT EXECUTED
    the_extension->Switch.thread_switch = extension_table->thread_switch;
    _Chain_Append(
   4a332:	220b           	movel %a3,%d1                                     	<== NOT EXECUTED
   4a334:	5081           	addql #8,%d1                                      	<== NOT EXECUTED
   4a336:	2d41 000c      	movel %d1,%fp@(12)                                	<== NOT EXECUTED
   4a33a:	223c 0005 6ca8 	movel #355496,%d1                                 	<== NOT EXECUTED
   4a340:	2d41 0008      	movel %d1,%fp@(8)                                 	<== NOT EXECUTED
      &_User_extensions_Switches_list,
      &the_extension->Switch.Node
    );
  }
}
   4a344:	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;
   4a348:	2740 0010      	movel %d0,%a3@(16)                                	<== NOT EXECUTED
    _Chain_Append(
      &_User_extensions_Switches_list,
      &the_extension->Switch.Node
    );
  }
}
   4a34c:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4a350:	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(
   4a352:	4ef9 0004 58a8 	jmp 458a8 <_Chain_Append>                         	<== NOT EXECUTED
      &_User_extensions_Switches_list,
      &the_extension->Switch.Node
    );
  }
}
   4a358:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4a35c:	266e fffc      	moveal %fp@(-4),%a3                               	<== NOT EXECUTED
   4a360:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a362:	4e75           	rts

00047a9e <_User_extensions_Fatal>:
void _User_extensions_Fatal (
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   47a9e:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47aa2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   47aa4:	2479 0005 6e4a 	moveal 56e4a <_User_extensions_List+0x8>,%a2      	<== NOT EXECUTED
void _User_extensions_Fatal (
  Internal_errors_Source  the_source,
  bool                    is_internal,
  uint32_t                the_error
)
{
   47aaa:	2f02           	movel %d2,%sp@-                                   	<== 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 );
   47aac:	4282           	clrl %d2                                          	<== NOT EXECUTED
   47aae:	142e 000f      	moveb %fp@(15),%d2                                	<== NOT EXECUTED
   47ab2:	601e           	bras 47ad2 <_User_extensions_Fatal+0x34>          	<== 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 )
   47ab4:	206a 0030      	moveal %a2@(48),%a0                               	<== NOT EXECUTED
   47ab8:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47aba:	6712           	beqs 47ace <_User_extensions_Fatal+0x30>          	<== NOT EXECUTED
      (*the_extension->Callouts.fatal)( the_source, is_internal, the_error );
   47abc:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   47ac0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47ac2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47ac6:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47ac8:	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 ) {
   47ace:	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 ) ;
   47ad2:	b5fc 0005 6e42 	cmpal #355906,%a2                                 	<== NOT EXECUTED
   47ad8:	66da           	bnes 47ab4 <_User_extensions_Fatal+0x16>          	<== 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 );
  }
}
   47ada:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47ade:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47ae2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47ae4:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047994 <_User_extensions_Handler_initialization>:

void _User_extensions_Handler_initialization (
  uint32_t                number_of_extensions,
  User_extensions_Table  *initial_extensions
)
{
   47994:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   47998:	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);
   4799c:	203c 0005 6e46 	movel #355910,%d0                                 	<== NOT EXECUTED
   479a2:	23c0 0005 6e42 	movel %d0,56e42 <_User_extensions_List>           	<== NOT EXECUTED
   479a8:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   479ac:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   479b0:	203c 0005 6e42 	movel #355906,%d0                                 	<== NOT EXECUTED
   479b6:	23c0 0005 6e4a 	movel %d0,56e4a <_User_extensions_List+0x8>       	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   479bc:	203c 0005 6cac 	movel #355500,%d0                                 	<== NOT EXECUTED
   479c2:	23c0 0005 6ca8 	movel %d0,56ca8 <_User_extensions_Switches_list>  	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   479c8:	203c 0005 6ca8 	movel #355496,%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;
   479ce:	42b9 0005 6e46 	clrl 56e46 <_User_extensions_List+0x4>            	<== NOT EXECUTED
   479d4:	42b9 0005 6cac 	clrl 56cac <_User_extensions_Switches_list+0x4>   	<== NOT EXECUTED
  the_chain->last           = _Chain_Head(the_chain);
   479da:	23c0 0005 6cb0 	movel %d0,56cb0 <_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 ) {
   479e0:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   479e2:	674e           	beqs 47a32 <_User_extensions_Handler_initialization+0x9e>	<== NOT EXECUTED
    extension = (User_extensions_Control *)
   479e4:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   479e6:	2405           	movel %d5,%d2                                     	<== NOT EXECUTED
   479e8:	e588           	lsll #2,%d0                                       	<== NOT EXECUTED
   479ea:	e98a           	lsll #4,%d2                                       	<== NOT EXECUTED
   479ec:	9480           	subl %d0,%d2                                      	<== NOT EXECUTED
   479ee:	d485           	addl %d5,%d2                                      	<== NOT EXECUTED
   479f0:	e58a           	lsll #2,%d2                                       	<== NOT EXECUTED
   479f2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   479f4:	4eb9 0004 7e08 	jsr 47e08 <_Workspace_Allocate_or_fatal_error>    	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        number_of_extensions * sizeof( User_extensions_Control )
      );

    memset (
   479fa:	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 *)
   479fc:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
      _Workspace_Allocate_or_fatal_error(
        number_of_extensions * sizeof( User_extensions_Control )
      );

    memset (
   479fe:	4282           	clrl %d2                                          	<== NOT EXECUTED
   47a00:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
      _User_extensions_Add_set (extension, &initial_extensions[i]);
   47a02:	45f9 0004 a2f8 	lea 4a2f8 <_User_extensions_Add_set>,%a2          	<== NOT EXECUTED
    extension = (User_extensions_Control *)
      _Workspace_Allocate_or_fatal_error(
        number_of_extensions * sizeof( User_extensions_Control )
      );

    memset (
   47a08:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47a0a:	4eb9 0004 b464 	jsr 4b464 <memset>                                	<== NOT EXECUTED
   47a10:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   47a16:	6016           	bras 47a2e <_User_extensions_Handler_initialization+0x9a>	<== NOT EXECUTED
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
      _User_extensions_Add_set (extension, &initial_extensions[i]);
   47a18:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   47a1a:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   47a1c:	0684 0000 0020 	addil #32,%d4                                     	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
   47a22:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47a24:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   47a26:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
      extension++;
   47a28:	0683 0000 0034 	addil #52,%d3                                     	<== NOT EXECUTED
      extension,
      0,
      number_of_extensions * sizeof( User_extensions_Control )
    );

    for ( i = 0 ; i < number_of_extensions ; i++ ) {
   47a2e:	ba82           	cmpl %d2,%d5                                      	<== NOT EXECUTED
   47a30:	62e6           	bhis 47a18 <_User_extensions_Handler_initialization+0x84>	<== NOT EXECUTED
      _User_extensions_Add_set (extension, &initial_extensions[i]);
      extension++;
    }
  }
}
   47a32:	4cee 043c ffec 	moveml %fp@(-20),%d2-%d5/%a2                      	<== NOT EXECUTED
   47a38:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47a3a:	4e75           	rts

0004b704 <_User_extensions_Remove_set>:
 */

void _User_extensions_Remove_set (
  User_extensions_Control  *the_extension
)
{
   4b704:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4b708:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b70a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  _Chain_Extract( &the_extension->Node );
   4b70e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4b710:	4eb9 0004 f3b0 	jsr 4f3b0 <_Chain_Extract>                        	<== NOT EXECUTED

  /*
   * If a switch handler is present, remove it.
   */

  if ( the_extension->Callouts.thread_switch != NULL )
   4b716:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4b718:	4aaa 0024      	tstl %a2@(36)                                     	<== NOT EXECUTED
   4b71c:	6712           	beqs 4b730 <_User_extensions_Remove_set+0x2c>     	<== NOT EXECUTED
    _Chain_Extract( &the_extension->Switch.Node );
   4b71e:	508a           	addql #8,%a2                                      	<== NOT EXECUTED
   4b720:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
}
   4b724:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4b728:	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 );
   4b72a:	4ef9 0004 f3b0 	jmp 4f3b0 <_Chain_Extract>                        	<== NOT EXECUTED
}
   4b730:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   4b734:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4b736:	4e75           	rts

00047a3c <_User_extensions_Thread_begin>:
 */

void _User_extensions_Thread_begin (
  Thread_Control *executing
)
{
   47a3c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47a40:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.first ;
   47a42:	2479 0005 6e42 	moveal 56e42 <_User_extensions_List>,%a2          	<== NOT EXECUTED
   47a48:	6012           	bras 47a5c <_User_extensions_Thread_begin+0x20>   	<== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_begin != NULL )
   47a4a:	206a 0028      	moveal %a2@(40),%a0                               	<== NOT EXECUTED
   47a4e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47a50:	6708           	beqs 47a5a <_User_extensions_Thread_begin+0x1e>   	<== NOT EXECUTED
      (*the_extension->Callouts.thread_begin)( executing );
   47a52:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47a56:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47a58:	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 ) {
   47a5a:	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 ) ;
   47a5c:	b5fc 0005 6e46 	cmpal #355910,%a2                                 	<== NOT EXECUTED
   47a62:	66e6           	bnes 47a4a <_User_extensions_Thread_begin+0xe>    	<== NOT EXECUTED
    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_begin != NULL )
      (*the_extension->Callouts.thread_begin)( executing );
  }
}
   47a64:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47a68:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47a6a:	4e75           	rts

00047ae8 <_User_extensions_Thread_create>:
 */

bool _User_extensions_Thread_create (
  Thread_Control *the_thread
)
{
   47ae8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47aec:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;
  bool                     status;

  for ( the_node = _User_extensions_List.first ;
   47aee:	2479 0005 6e42 	moveal 56e42 <_User_extensions_List>,%a2          	<== NOT EXECUTED
   47af4:	601c           	bras 47b12 <_User_extensions_Thread_create+0x2a>  	<== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_create != NULL ) {
   47af6:	206a 0014      	moveal %a2@(20),%a0                               	<== NOT EXECUTED
   47afa:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47afc:	6712           	beqs 47b10 <_User_extensions_Thread_create+0x28>  	<== NOT EXECUTED
      status = (*the_extension->Callouts.thread_create)(
   47afe:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47b02:	2f39 0005 6d62 	movel 56d62 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   47b08:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
        _Thread_Executing,
        the_thread
      );
      if ( !status )
   47b0a:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47b0c:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   47b0e:	670c           	beqs 47b1c <_User_extensions_Thread_create+0x34>  	<== 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 ) {
   47b10:	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 ) ;
   47b12:	b5fc 0005 6e46 	cmpal #355910,%a2                                 	<== NOT EXECUTED
   47b18:	66dc           	bnes 47af6 <_User_extensions_Thread_create+0xe>   	<== NOT EXECUTED
   47b1a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
        return FALSE;
    }
  }

  return TRUE;
}
   47b1c:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47b20:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47b22:	4e75           	rts

00047b24 <_User_extensions_Thread_delete>:
 */

void _User_extensions_Thread_delete (
  Thread_Control *the_thread
)
{
   47b24:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47b28:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   47b2a:	2479 0005 6e4a 	moveal 56e4a <_User_extensions_List+0x8>,%a2      	<== NOT EXECUTED
   47b30:	601a           	bras 47b4c <_User_extensions_Thread_delete+0x28>  	<== NOT EXECUTED
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;
        the_node = the_node->previous ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_delete != NULL )
   47b32:	206a 0020      	moveal %a2@(32),%a0                               	<== NOT EXECUTED
   47b36:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47b38:	670e           	beqs 47b48 <_User_extensions_Thread_delete+0x24>  	<== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(
   47b3a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47b3e:	2f39 0005 6d62 	movel 56d62 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   47b44:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47b46:	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 ) {
   47b48:	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 ) ;
   47b4c:	b5fc 0005 6e42 	cmpal #355906,%a2                                 	<== NOT EXECUTED
   47b52:	66de           	bnes 47b32 <_User_extensions_Thread_delete+0xe>   	<== NOT EXECUTED
      (*the_extension->Callouts.thread_delete)(
        _Thread_Executing,
        the_thread
      );
  }
}
   47b54:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47b58:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47b5a:	4e75           	rts

00047a6c <_User_extensions_Thread_exitted>:
 */

void _User_extensions_Thread_exitted (
  Thread_Control *executing
)
{
   47a6c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47a70:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   47a72:	2479 0005 6e4a 	moveal 56e4a <_User_extensions_List+0x8>,%a2      	<== NOT EXECUTED
   47a78:	6014           	bras 47a8e <_User_extensions_Thread_exitted+0x22> 	<== NOT EXECUTED
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;
        the_node = the_node->previous ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_exitted != NULL )
   47a7a:	206a 002c      	moveal %a2@(44),%a0                               	<== NOT EXECUTED
   47a7e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47a80:	6708           	beqs 47a8a <_User_extensions_Thread_exitted+0x1e> 	<== NOT EXECUTED
      (*the_extension->Callouts.thread_exitted)( executing );
   47a82:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47a86:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47a88:	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 ) {
   47a8a:	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 ) ;
   47a8e:	b5fc 0005 6e42 	cmpal #355906,%a2                                 	<== NOT EXECUTED
   47a94:	66e4           	bnes 47a7a <_User_extensions_Thread_exitted+0xe>  	<== NOT EXECUTED
    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_exitted != NULL )
      (*the_extension->Callouts.thread_exitted)( executing );
  }
}
   47a96:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47a9a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47a9c:	4e75           	rts

00048360 <_User_extensions_Thread_restart>:
 */

void _User_extensions_Thread_restart (
  Thread_Control *the_thread
)
{
   48360:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   48364:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.first ;
   48366:	2479 0005 878a 	moveal 5878a <_User_extensions_List>,%a2          	<== NOT EXECUTED
   4836c:	6018           	bras 48386 <_User_extensions_Thread_restart+0x26> 	<== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_restart != NULL )
   4836e:	206a 001c      	moveal %a2@(28),%a0                               	<== NOT EXECUTED
   48372:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   48374:	670e           	beqs 48384 <_User_extensions_Thread_restart+0x24> 	<== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(
   48376:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4837a:	2f39 0005 86aa 	movel 586aa <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   48380:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   48382:	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 ) {
   48384:	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 ) ;
   48386:	b5fc 0005 878e 	cmpal #362382,%a2                                 	<== NOT EXECUTED
   4838c:	66e0           	bnes 4836e <_User_extensions_Thread_restart+0xe>  	<== NOT EXECUTED
      (*the_extension->Callouts.thread_restart)(
        _Thread_Executing,
        the_thread
      );
  }
}
   4838e:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   48392:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48394:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047b5c <_User_extensions_Thread_start>:
 */

void _User_extensions_Thread_start (
  Thread_Control *the_thread
)
{
   47b5c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47b60:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.first ;
   47b62:	2479 0005 6e42 	moveal 56e42 <_User_extensions_List>,%a2          	<== NOT EXECUTED
   47b68:	6018           	bras 47b82 <_User_extensions_Thread_start+0x26>   	<== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_List, the_node ) ;
        the_node = the_node->next ) {

    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_start != NULL )
   47b6a:	206a 0018      	moveal %a2@(24),%a0                               	<== NOT EXECUTED
   47b6e:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   47b70:	670e           	beqs 47b80 <_User_extensions_Thread_start+0x24>   	<== NOT EXECUTED
      (*the_extension->Callouts.thread_start)(
   47b72:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47b76:	2f39 0005 6d62 	movel 56d62 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   47b7c:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47b7e:	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 ) {
   47b80:	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 ) ;
   47b82:	b5fc 0005 6e46 	cmpal #355910,%a2                                 	<== NOT EXECUTED
   47b88:	66e0           	bnes 47b6a <_User_extensions_Thread_start+0xe>    	<== NOT EXECUTED
      (*the_extension->Callouts.thread_start)(
        _Thread_Executing,
        the_thread
      );
  }
}
   47b8a:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47b8e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47b90:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047b94 <_User_extensions_Thread_switch>:
 */
void _User_extensions_Thread_switch (
  Thread_Control *executing,
  Thread_Control *heir
)
{
   47b94:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47b98:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  Chain_Node                     *the_node;
  User_extensions_Switch_control *the_extension_switch;

  for ( the_node = _User_extensions_Switches_list.first ;
   47b9a:	2479 0005 6ca8 	moveal 56ca8 <_User_extensions_Switches_list>,%a2 	<== NOT EXECUTED
   47ba0:	6012           	bras 47bb4 <_User_extensions_Thread_switch+0x20>  	<== NOT EXECUTED
        !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ;
        the_node = the_node->next ) {

    the_extension_switch = (User_extensions_Switch_control *) the_node;

    (*the_extension_switch->thread_switch)( executing, heir );
   47ba2:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   47ba6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47baa:	206a 0008      	moveal %a2@(8),%a0                                	<== NOT EXECUTED
   47bae:	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 ) {
   47bb0:	2452           	moveal %a2@,%a2                                   	<== NOT EXECUTED
   47bb2:	508f           	addql #8,%sp                                      	<== 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 ) ;
   47bb4:	b5fc 0005 6cac 	cmpal #355500,%a2                                 	<== NOT EXECUTED
   47bba:	66e6           	bnes 47ba2 <_User_extensions_Thread_switch+0xe>   	<== NOT EXECUTED

    the_extension_switch = (User_extensions_Switch_control *) the_node;

    (*the_extension_switch->thread_switch)( executing, heir );
  }
}
   47bbc:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   47bc0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47bc2:	4e75           	rts

00048ff8 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
  Chain_Control               *header,
  Watchdog_Adjust_directions   direction,
  Watchdog_Interval            units
)
{
   48ff8:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   48ffc:	48d7 1c1c      	moveml %d2-%d4/%a2-%a4,%sp@                       	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   49000:	243c 0000 0700 	movel #1792,%d2                                   	<== NOT EXECUTED
void _Watchdog_Adjust(
  Chain_Control               *header,
  Watchdog_Adjust_directions   direction,
  Watchdog_Interval            units
)
{
   49006:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   4900a:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   4900e:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
  ISR_Level level;

  _ISR_Disable( level );
   49012:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   49014:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   49016:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49018:	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));
   4901a:	244b           	moveal %a3,%a2                                    	<== NOT EXECUTED
   4901c:	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 ) ) {
   4901e:	b5c8           	cmpal %a0,%a2                                     	<== NOT EXECUTED
   49020:	674c           	beqs 4906e <_Watchdog_Adjust+0x76>                	<== NOT EXECUTED
    switch ( direction ) {
   49022:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   49024:	673c           	beqs 49062 <_Watchdog_Adjust+0x6a>                	<== NOT EXECUTED
   49026:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49028:	b089           	cmpl %a1,%d0                                      	<== NOT EXECUTED
   4902a:	6642           	bnes 4906e <_Watchdog_Adjust+0x76>                	<== NOT EXECUTED
      case WATCHDOG_BACKWARD:
        _Watchdog_First( header )->delta_interval += units;
   4902c:	d7a8 0010      	addl %d3,%a0@(16)                                 	<== NOT EXECUTED
   49030:	603c           	bras 4906e <_Watchdog_Adjust+0x76>                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
  Chain_Control *header
)
{

  return ( (Watchdog_Control *) header->first );
   49032:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
        break;
      case WATCHDOG_FORWARD:
        while ( units ) {
          if ( units < _Watchdog_First( header )->delta_interval ) {
   49034:	2428 0010      	movel %a0@(16),%d2                                	<== NOT EXECUTED
   49038:	b483           	cmpl %d3,%d2                                      	<== NOT EXECUTED
   4903a:	6308           	blss 49044 <_Watchdog_Adjust+0x4c>                	<== NOT EXECUTED
            _Watchdog_First( header )->delta_interval -= units;
   4903c:	9483           	subl %d3,%d2                                      	<== NOT EXECUTED
   4903e:	2142 0010      	movel %d2,%a0@(16)                                	<== NOT EXECUTED
   49042:	602a           	bras 4906e <_Watchdog_Adjust+0x76>                	<== NOT EXECUTED
            break;
          } else {
            units -= _Watchdog_First( header )->delta_interval;
            _Watchdog_First( header )->delta_interval = 1;
   49044:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   49046:	2140 0010      	movel %d0,%a0@(16)                                	<== NOT EXECUTED

			_ISR_Enable( level );
   4904a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

            _Watchdog_Tickle( header );
   4904c:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4904e:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

			_ISR_Disable( level );
   49050:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   49052:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   49054:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   49056:	46c0           	movew %d0,%sr                                     	<== 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;
   49058:	9682           	subl %d2,%d3                                      	<== NOT EXECUTED

            _Watchdog_Tickle( header );

			_ISR_Disable( level );

            if ( _Chain_Is_empty( header ) )
   4905a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4905c:	b5d3           	cmpal %a3@,%a2                                    	<== NOT EXECUTED
   4905e:	660a           	bnes 4906a <_Watchdog_Adjust+0x72>                	<== NOT EXECUTED
   49060:	600c           	bras 4906e <_Watchdog_Adjust+0x76>                	<== NOT EXECUTED

			_ISR_Enable( level );

            _Watchdog_Tickle( header );

			_ISR_Disable( level );
   49062:	2802           	movel %d2,%d4                                     	<== NOT EXECUTED
            units -= _Watchdog_First( header )->delta_interval;
            _Watchdog_First( header )->delta_interval = 1;

			_ISR_Enable( level );

            _Watchdog_Tickle( header );
   49064:	49f9 0004 9214 	lea 49214 <_Watchdog_Tickle>,%a4                  	<== NOT EXECUTED
    switch ( direction ) {
      case WATCHDOG_BACKWARD:
        _Watchdog_First( header )->delta_interval += units;
        break;
      case WATCHDOG_FORWARD:
        while ( units ) {
   4906a:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4906c:	66c4           	bnes 49032 <_Watchdog_Adjust+0x3a>                	<== NOT EXECUTED
        }
        break;
    }
  }

  _ISR_Enable( level );
   4906e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

}
   49070:	4cee 1c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a4                  	<== NOT EXECUTED
   49076:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49078:	4e75           	rts                                               	<== NOT EXECUTED
	...

000530e8 <_Watchdog_Adjust_to_chain>:
  Chain_Control               *header,
  Watchdog_Interval            units_arg,
  Chain_Control               *to_fire

)
{
   530e8:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   530ec:	48d7 0c7c      	moveml %d2-%d6/%a2-%a3,%sp@                       	<== NOT EXECUTED
   530f0:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   530f4:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   530f8:	266e 0010      	moveal %fp@(16),%a3                               	<== NOT EXECUTED
  Watchdog_Interval  units = units_arg;
  ISR_Level          level;
  Chain_Node        *node;

  if ( !units ) {
   530fc:	676c           	beqs 5316a <_Watchdog_Adjust_to_chain+0x82>       	<== NOT EXECUTED
    return;
  }
  _ISR_Disable( level );
   530fe:	307c 0700      	moveaw #1792,%a0                                  	<== NOT EXECUTED
   53102:	2008           	movel %a0,%d0                                     	<== NOT EXECUTED
   53104:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   53106:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   53108:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   5310a:	260a           	movel %a2,%d3                                     	<== NOT EXECUTED
   5310c:	5883           	addql #4,%d3                                      	<== NOT EXECUTED

  if ( !_Chain_Is_empty( header ) ) {
   5310e:	b692           	cmpl %a2@,%d3                                     	<== NOT EXECUTED
   53110:	6756           	beqs 53168 <_Watchdog_Adjust_to_chain+0x80>       	<== NOT EXECUTED
   53112:	2a0b           	movel %a3,%d5                                     	<== NOT EXECUTED

        do {
          node = _Chain_Get_unprotected( header );
          _Chain_Append_unprotected( to_fire, node );

	  _ISR_Flash( level );
   53114:	2c08           	movel %a0,%d6                                     	<== NOT EXECUTED
   53116:	5885           	addql #4,%d5                                      	<== NOT EXECUTED
   53118:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
  }
  _ISR_Disable( level );

  if ( !_Chain_Is_empty( header ) ) {
    while ( units ) {
      if ( units < _Watchdog_First( header )->delta_interval ) {
   5311a:	2428 0010      	movel %a0@(16),%d2                                	<== NOT EXECUTED
   5311e:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   53120:	6308           	blss 5312a <_Watchdog_Adjust_to_chain+0x42>       	<== NOT EXECUTED
	_Watchdog_First( header )->delta_interval -= units;
   53122:	9481           	subl %d1,%d2                                      	<== NOT EXECUTED
   53124:	2142 0010      	movel %d2,%a0@(16)                                	<== NOT EXECUTED
   53128:	603e           	bras 53168 <_Watchdog_Adjust_to_chain+0x80>       	<== NOT EXECUTED
	break;
      } else {
	units -= _Watchdog_First( header )->delta_interval;
	_Watchdog_First( header )->delta_interval = 0;
   5312a:	42a8 0010      	clrl %a0@(16)                                     	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   5312e:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   53130:	b689           	cmpl %a1,%d3                                      	<== NOT EXECUTED
   53132:	6604           	bnes 53138 <_Watchdog_Adjust_to_chain+0x50>       	<== NOT EXECUTED
   53134:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   53136:	6008           	bras 53140 <_Watchdog_Adjust_to_chain+0x58>       	<== NOT EXECUTED
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   53138:	2051           	moveal %a1@,%a0                                   	<== NOT EXECUTED
  the_chain->first    = new_first;
   5313a:	2488           	movel %a0,%a2@                                    	<== NOT EXECUTED
  new_first->previous = _Chain_Head(the_chain);
   5313c:	214a 0004      	movel %a2,%a0@(4)                                 	<== NOT EXECUTED
  Chain_Node    *the_node
)
{
  Chain_Node *old_last_node;

  the_node->next      = _Chain_Tail(the_chain);
   53140:	2285           	movel %d5,%a1@                                    	<== NOT EXECUTED
  old_last_node       = the_chain->last;
   53142:	206b 0008      	moveal %a3@(8),%a0                                	<== NOT EXECUTED
  the_chain->last     = the_node;
   53146:	2749 0008      	movel %a1,%a3@(8)                                 	<== NOT EXECUTED
  old_last_node->next = the_node;
  the_node->previous  = old_last_node;
   5314a:	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;
   5314e:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED

        do {
          node = _Chain_Get_unprotected( header );
          _Chain_Append_unprotected( to_fire, node );

	  _ISR_Flash( level );
   53150:	2006           	movel %d6,%d0                                     	<== NOT EXECUTED
   53152:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   53154:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   53156:	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));
   53158:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED

        } while ( !_Chain_Is_empty( header ) &&
                  _Watchdog_First( header )->delta_interval == 0 );
   5315a:	b688           	cmpl %a0,%d3                                      	<== NOT EXECUTED
   5315c:	670a           	beqs 53168 <_Watchdog_Adjust_to_chain+0x80>       	<== NOT EXECUTED
   5315e:	4aa8 0010      	tstl %a0@(16)                                     	<== NOT EXECUTED
   53162:	67ca           	beqs 5312e <_Watchdog_Adjust_to_chain+0x46>       	<== 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;
   53164:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED
    return;
  }
  _ISR_Disable( level );

  if ( !_Chain_Is_empty( header ) ) {
    while ( units ) {
   53166:	66b0           	bnes 53118 <_Watchdog_Adjust_to_chain+0x30>       	<== NOT EXECUTED
	  break;
      }
    }

  }
  _ISR_Enable( level );
   53168:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   5316a:	4cd7 0c7c      	moveml %sp@,%d2-%d6/%a2-%a3                       	<== NOT EXECUTED
   5316e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   53170:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047c94 <_Watchdog_Handler_initialization>:
 *  Output parameters: NONE
 */

void _Watchdog_Handler_initialization( void )
{
  _Watchdog_Sync_count = 0;
   47c94:	42b9 0005 6de8 	clrl 56de8 <_Watchdog_Sync_count>                 	<== NOT EXECUTED
 *
 *  Output parameters: NONE
 */

void _Watchdog_Handler_initialization( void )
{
   47c9a:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Watchdog_Sync_count = 0;
  _Watchdog_Sync_level = 0;
   47c9e:	42b9 0005 6d5e 	clrl 56d5e <_Watchdog_Sync_level>                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47ca4:	41f9 0005 6d80 	lea 56d80 <_Watchdog_Ticks_chain>,%a0             	<== NOT EXECUTED
  _Watchdog_Ticks_since_boot = 0;

  _Chain_Initialize_empty( &_Watchdog_Ticks_chain );
  _Chain_Initialize_empty( &_Watchdog_Seconds_chain );
}
   47caa:	43f9 0005 6d74 	lea 56d74 <_Watchdog_Seconds_chain>,%a1           	<== NOT EXECUTED
   47cb0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   47cb2:	23c8 0005 6d88 	movel %a0,56d88 <_Watchdog_Ticks_chain+0x8>       	<== NOT EXECUTED
   47cb8:	23c9 0005 6d7c 	movel %a1,56d7c <_Watchdog_Seconds_chain+0x8>     	<== NOT EXECUTED

void _Watchdog_Handler_initialization( void )
{
  _Watchdog_Sync_count = 0;
  _Watchdog_Sync_level = 0;
  _Watchdog_Ticks_since_boot = 0;
   47cbe:	42b9 0005 6dec 	clrl 56dec <_Watchdog_Ticks_since_boot>           	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47cc4:	20bc 0005 6d84 	movel #355716,%a0@                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   47cca:	42b9 0005 6d84 	clrl 56d84 <_Watchdog_Ticks_chain+0x4>            	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47cd0:	22bc 0005 6d78 	movel #355704,%a1@                                	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
   47cd6:	42b9 0005 6d78 	clrl 56d78 <_Watchdog_Seconds_chain+0x4>          	<== NOT EXECUTED

  _Chain_Initialize_empty( &_Watchdog_Ticks_chain );
  _Chain_Initialize_empty( &_Watchdog_Seconds_chain );
}
   47cdc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00047bc4 <_Watchdog_Insert>:

void _Watchdog_Insert(
  Chain_Control         *header,
  Watchdog_Control      *the_watchdog
)
{
   47bc4:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   47bc8:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
   47bcc:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   47bd0:	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;
   47bd4:	2639 0005 6d42 	movel 56d42 <_ISR_Nest_level>,%d3                 	<== NOT EXECUTED

  _ISR_Disable( level );
   47bda:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   47be0:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   47be2:	40c4           	movew %sr,%d4                                     	<== NOT EXECUTED
   47be4:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   47be6:	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 ) {
   47be8:	4aaa 0008      	tstl %a2@(8)                                      	<== NOT EXECUTED
   47bec:	6706           	beqs 47bf4 <_Watchdog_Insert+0x30>                	<== NOT EXECUTED
    _ISR_Enable( level );
   47bee:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   47bf0:	6000 009a      	braw 47c8c <_Watchdog_Insert+0xc8>                	<== NOT EXECUTED
    return;
  }

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
  _Watchdog_Sync_count++;
   47bf4:	2039 0005 6de8 	movel 56de8 <_Watchdog_Sync_count>,%d0            	<== NOT EXECUTED
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
    _ISR_Enable( level );
    return;
  }

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
   47bfa:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
  _Watchdog_Sync_count++;
   47bfc:	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 );
   47bfe:	2241           	moveal %d1,%a1                                    	<== NOT EXECUTED
  if ( the_watchdog->state != WATCHDOG_INACTIVE ) {
    _ISR_Enable( level );
    return;
  }

  the_watchdog->state = WATCHDOG_BEING_INSERTED;
   47c00:	2542 0008      	movel %d2,%a2@(8)                                 	<== NOT EXECUTED
  _Watchdog_Sync_count++;
   47c04:	23c0 0005 6de8 	movel %d0,56de8 <_Watchdog_Sync_count>            	<== NOT EXECUTED

restart:
  delta_interval = the_watchdog->initial;
   47c0a:	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 ;
   47c0e:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
        ;
        after = _Watchdog_Next( after ) ) {

     if ( delta_interval == 0 || !_Watchdog_Next( after ) )
   47c10:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   47c12:	673c           	beqs 47c50 <_Watchdog_Insert+0x8c>                	<== NOT EXECUTED
   47c14:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   47c16:	6738           	beqs 47c50 <_Watchdog_Insert+0x8c>                	<== NOT EXECUTED
       break;

     if ( delta_interval < after->delta_interval ) {
   47c18:	2228 0010      	movel %a0@(16),%d1                                	<== NOT EXECUTED
   47c1c:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   47c1e:	6308           	blss 47c28 <_Watchdog_Insert+0x64>                	<== NOT EXECUTED
       after->delta_interval -= delta_interval;
   47c20:	9282           	subl %d2,%d1                                      	<== NOT EXECUTED
   47c22:	2141 0010      	movel %d1,%a0@(16)                                	<== NOT EXECUTED
   47c26:	6028           	bras 47c50 <_Watchdog_Insert+0x8c>                	<== 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 );
   47c28:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   47c2a:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
   47c2c:	8084           	orl %d4,%d0                                       	<== NOT EXECUTED
   47c2e:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
   47c30:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
     if ( delta_interval < after->delta_interval ) {
       after->delta_interval -= delta_interval;
       break;
     }

     delta_interval -= after->delta_interval;
   47c32:	9481           	subl %d1,%d2                                      	<== NOT EXECUTED
      *  mechanism used here WAS redesigned to address this.
      */

     _ISR_Flash( level );

     if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) {
   47c34:	b0aa 0008      	cmpl %a2@(8),%d0                                  	<== NOT EXECUTED
   47c38:	663c           	bnes 47c76 <_Watchdog_Insert+0xb2>                	<== NOT EXECUTED
       goto exit_insert;
     }

     if ( _Watchdog_Sync_level > insert_isr_nest_level ) {
   47c3a:	2039 0005 6d5e 	movel 56d5e <_Watchdog_Sync_level>,%d0            	<== NOT EXECUTED
   47c40:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   47c42:	6408           	bccs 47c4c <_Watchdog_Insert+0x88>                	<== NOT EXECUTED
       _Watchdog_Sync_level = insert_isr_nest_level;
   47c44:	23c3 0005 6d5e 	movel %d3,56d5e <_Watchdog_Sync_level>            	<== NOT EXECUTED
   47c4a:	60be           	bras 47c0a <_Watchdog_Insert+0x46>                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
  Watchdog_Control *the_watchdog
)
{

  return ( (Watchdog_Control *) the_watchdog->Node.next );
   47c4c:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
   47c4e:	60c0           	bras 47c10 <_Watchdog_Insert+0x4c>                	<== NOT EXECUTED

  _Watchdog_Activate( the_watchdog );

  the_watchdog->delta_interval = delta_interval;

  _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node );
   47c50:	2068 0004      	moveal %a0@(4),%a0                                	<== NOT EXECUTED
)
{
  Chain_Node *before_node;

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

  the_watchdog->start_time = _Watchdog_Ticks_since_boot;
   47c56:	2039 0005 6dec 	movel 56dec <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
  after_node->next      = the_node;
   47c5c:	208a           	movel %a2,%a0@                                    	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Watchdog_Activate(
  Watchdog_Control *the_watchdog
)
{

  the_watchdog->state = WATCHDOG_ACTIVE;
   47c5e:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
  Chain_Node *the_node
)
{
  Chain_Node *before_node;

  the_node->previous    = after_node;
   47c60:	2548 0004      	movel %a0,%a2@(4)                                 	<== NOT EXECUTED
   47c64:	2541 0008      	movel %d1,%a2@(8)                                 	<== NOT EXECUTED
   47c68:	2540 0014      	movel %d0,%a2@(20)                                	<== NOT EXECUTED
     }
  }

  _Watchdog_Activate( the_watchdog );

  the_watchdog->delta_interval = delta_interval;
   47c6c:	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;
   47c70:	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;
   47c74:	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;
   47c76:	23c3 0005 6d5e 	movel %d3,56d5e <_Watchdog_Sync_level>            	<== NOT EXECUTED
  _Watchdog_Sync_count--;
   47c7c:	2039 0005 6de8 	movel 56de8 <_Watchdog_Sync_count>,%d0            	<== NOT EXECUTED
   47c82:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47c84:	23c0 0005 6de8 	movel %d0,56de8 <_Watchdog_Sync_count>            	<== NOT EXECUTED
  _ISR_Enable( level );
   47c8a:	46c4           	movew %d4,%sr                                     	<== NOT EXECUTED
}
   47c8c:	4cd7 0c1c      	moveml %sp@,%d2-%d4/%a2-%a3                       	<== NOT EXECUTED
   47c90:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47c92:	4e75           	rts

00047ce0 <_Watchdog_Remove>:
 */

Watchdog_States _Watchdog_Remove(
  Watchdog_Control *the_watchdog
)
{
   47ce0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47ce4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  ISR_Level         level;
  Watchdog_States   previous_state;
  Watchdog_Control *next_watchdog;

  _ISR_Disable( level );
   47ce6:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

Watchdog_States _Watchdog_Remove(
  Watchdog_Control *the_watchdog
)
{
   47cec:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47cee:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  ISR_Level         level;
  Watchdog_States   previous_state;
  Watchdog_Control *next_watchdog;

  _ISR_Disable( level );
   47cf2:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   47cf4:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47cf6:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
  previous_state = the_watchdog->state;
   47cf8:	222a 0008      	movel %a2@(8),%d1                                 	<== NOT EXECUTED
  switch ( previous_state ) {
   47cfc:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   47cfe:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47d00:	670c           	beqs 47d0e <_Watchdog_Remove+0x2e>                	<== NOT EXECUTED
   47d02:	6242           	bhis 47d46 <_Watchdog_Remove+0x66>                	<== NOT EXECUTED
   47d04:	103c 0003      	moveb #3,%d0                                      	<== NOT EXECUTED
   47d08:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   47d0a:	653a           	bcss 47d46 <_Watchdog_Remove+0x66>                	<== NOT EXECUTED
   47d0c:	6006           	bras 47d14 <_Watchdog_Remove+0x34>                	<== 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;
   47d0e:	42aa 0008      	clrl %a2@(8)                                      	<== NOT EXECUTED
   47d12:	6032           	bras 47d46 <_Watchdog_Remove+0x66>                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
  Watchdog_Control *the_watchdog
)
{

  return ( (Watchdog_Control *) the_watchdog->Node.next );
   47d14:	2052           	moveal %a2@,%a0                                   	<== NOT EXECUTED
      break;

    case WATCHDOG_ACTIVE:
    case WATCHDOG_REMOVE_IT:

      the_watchdog->state = WATCHDOG_INACTIVE;
   47d16:	42aa 0008      	clrl %a2@(8)                                      	<== NOT EXECUTED
      next_watchdog = _Watchdog_Next( the_watchdog );

      if ( _Watchdog_Next(next_watchdog) )
   47d1a:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   47d1c:	6708           	beqs 47d26 <_Watchdog_Remove+0x46>                	<== NOT EXECUTED
        next_watchdog->delta_interval += the_watchdog->delta_interval;
   47d1e:	202a 0010      	movel %a2@(16),%d0                                	<== NOT EXECUTED
   47d22:	d1a8 0010      	addl %d0,%a0@(16)                                 	<== NOT EXECUTED

      if ( _Watchdog_Sync_count )
   47d26:	2039 0005 6de8 	movel 56de8 <_Watchdog_Sync_count>,%d0            	<== NOT EXECUTED
   47d2c:	670c           	beqs 47d3a <_Watchdog_Remove+0x5a>                	<== NOT EXECUTED
        _Watchdog_Sync_level = _ISR_Nest_level;
   47d2e:	2039 0005 6d42 	movel 56d42 <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
   47d34:	23c0 0005 6d5e 	movel %d0,56d5e <_Watchdog_Sync_level>            	<== NOT EXECUTED
)
{
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
   47d3a:	2252           	moveal %a2@,%a1                                   	<== NOT EXECUTED
  previous       = the_node->previous;
   47d3c:	206a 0004      	moveal %a2@(4),%a0                                	<== NOT EXECUTED
  next->previous = previous;
  previous->next = next;
   47d40:	2089           	movel %a1,%a0@                                    	<== NOT EXECUTED
  Chain_Node *next;
  Chain_Node *previous;

  next           = the_node->next;
  previous       = the_node->previous;
  next->previous = previous;
   47d42:	2348 0004      	movel %a0,%a1@(4)                                 	<== NOT EXECUTED

      _Chain_Extract_unprotected( &the_watchdog->Node );
      break;
  }
  the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
   47d46:	2039 0005 6dec 	movel 56dec <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
   47d4c:	2540 0018      	movel %d0,%a2@(24)                                	<== NOT EXECUTED

  _ISR_Enable( level );
   47d50:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
  return( previous_state );
}
   47d52:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   47d54:	245f           	moveal %sp@+,%a2                                  	<== NOT EXECUTED
   47d56:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47d58:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   47d5a:	4e75           	rts

00047d5c <_Watchdog_Tickle>:
 */

void _Watchdog_Tickle(
  Chain_Control *header
)
{
   47d5c:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   47d60:	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 );
   47d64:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
 */

void _Watchdog_Tickle(
  Chain_Control *header
)
{
   47d6a:	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 );
   47d6e:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   47d70:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47d72:	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));
   47d74:	264d           	moveal %a5,%a3                                    	<== NOT EXECUTED
   47d76:	205b           	moveal %a3@+,%a0                                  	<== NOT EXECUTED

  if ( _Chain_Is_empty( header ) )
   47d78:	b7c8           	cmpal %a0,%a3                                     	<== NOT EXECUTED
   47d7a:	6750           	beqs 47dcc <_Watchdog_Tickle+0x70>                	<== 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) {
   47d7c:	2028 0010      	movel %a0@(16),%d0                                	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
  Chain_Control *header
)
{

  return ( (Watchdog_Control *) header->first );
   47d80:	2448           	moveal %a0,%a2                                    	<== NOT EXECUTED
   47d82:	6708           	beqs 47d8c <_Watchdog_Tickle+0x30>                	<== NOT EXECUTED
    the_watchdog->delta_interval--;
   47d84:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   47d86:	2140 0010      	movel %d0,%a0@(16)                                	<== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )
   47d8a:	6640           	bnes 47dcc <_Watchdog_Tickle+0x70>                	<== NOT EXECUTED
      goto leave;
  }

  do {
     watchdog_state = _Watchdog_Remove( the_watchdog );
   47d8c:	49f9 0004 7ce0 	lea 47ce0 <_Watchdog_Remove>,%a4                  	<== NOT EXECUTED

       case WATCHDOG_REMOVE_IT:
         break;
     }

	 _ISR_Disable( level );
   47d92:	263c 0000 0700 	movel #1792,%d3                                   	<== NOT EXECUTED
    if ( the_watchdog->delta_interval != 0 )
      goto leave;
  }

  do {
     watchdog_state = _Watchdog_Remove( the_watchdog );
   47d98:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   47d9a:	4e94           	jsr %a4@                                          	<== NOT EXECUTED

     _ISR_Enable( level );
   47d9c:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

     switch( watchdog_state ) {
   47d9e:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   47da0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47da2:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   47da4:	6610           	bnes 47db6 <_Watchdog_Tickle+0x5a>                	<== NOT EXECUTED
       case WATCHDOG_ACTIVE:
         (*the_watchdog->routine)(
   47da6:	2f2a 0024      	movel %a2@(36),%sp@-                              	<== NOT EXECUTED
   47daa:	2f2a 0020      	movel %a2@(32),%sp@-                              	<== NOT EXECUTED
   47dae:	206a 001c      	moveal %a2@(28),%a0                               	<== NOT EXECUTED
   47db2:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   47db4:	508f           	addql #8,%sp                                      	<== NOT EXECUTED

       case WATCHDOG_REMOVE_IT:
         break;
     }

	 _ISR_Disable( level );
   47db6:	2003           	movel %d3,%d0                                     	<== NOT EXECUTED
   47db8:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   47dba:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   47dbc:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   47dbe:	2015           	movel %a5@,%d0                                    	<== NOT EXECUTED
   47dc0:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

     the_watchdog = _Watchdog_First( header );
   } while ( !_Chain_Is_empty( header ) &&
             (the_watchdog->delta_interval == 0) );
   47dc2:	b7c0           	cmpal %d0,%a3                                     	<== NOT EXECUTED
   47dc4:	6706           	beqs 47dcc <_Watchdog_Tickle+0x70>                	<== NOT EXECUTED
   47dc6:	4aaa 0010      	tstl %a2@(16)                                     	<== NOT EXECUTED
   47dca:	67cc           	beqs 47d98 <_Watchdog_Tickle+0x3c>                	<== NOT EXECUTED

leave:
   _ISR_Enable(level);
   47dcc:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED
}
   47dce:	4cee 3c0c ffe8 	moveml %fp@(-24),%d2-%d3/%a2-%a5                  	<== NOT EXECUTED
   47dd4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47dd6:	4e75           	rts

00047df0 <_Workspace_Allocate>:
 *  _Workspace_Allocate
 */
void *_Workspace_Allocate(
  size_t   size
)
{
   47df0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   return _Heap_Allocate( &_Workspace_Area, size );
   47df4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47df8:	4879 0005 6cc6 	pea 56cc6 <_Workspace_Area>                       	<== NOT EXECUTED
   47dfe:	4eb9 0004 9c20 	jsr 49c20 <_Heap_Allocate>                        	<== NOT EXECUTED
}
   47e04:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47e06:	4e75           	rts

00047e08 <_Workspace_Allocate_or_fatal_error>:
 *  _Workspace_Allocate_or_fatal_error
 */
void *_Workspace_Allocate_or_fatal_error(
  size_t      size
)
{
   47e08:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
 */
void *_Workspace_Allocate(
  size_t   size
)
{
   return _Heap_Allocate( &_Workspace_Area, size );
   47e0c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47e10:	4879 0005 6cc6 	pea 56cc6 <_Workspace_Area>                       	<== NOT EXECUTED
   47e16:	4eb9 0004 9c20 	jsr 49c20 <_Heap_Allocate>                        	<== NOT EXECUTED
{
  void        *memory;

  memory = _Workspace_Allocate( size );

  if ( memory == NULL )
   47e1c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   47e1e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47e20:	6610           	bnes 47e32 <_Workspace_Allocate_or_fatal_error+0x2a>	<== NOT EXECUTED
    _Internal_error_Occurred(
   47e22:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   47e26:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   47e2a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47e2c:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
      TRUE,
      INTERNAL_ERROR_WORKSPACE_ALLOCATION
    );

  return memory;
}
   47e32:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47e34:	4e75           	rts

00047dd8 <_Workspace_Free>:
 *  _Workspace_Free
 */
bool _Workspace_Free(
  void *block
)
{
   47dd8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   return _Heap_Free( &_Workspace_Area, block );
   47ddc:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   47de0:	4879 0005 6cc6 	pea 56cc6 <_Workspace_Area>                       	<== NOT EXECUTED
   47de6:	4eb9 0004 9ca0 	jsr 49ca0 <_Heap_Free>                            	<== NOT EXECUTED
}
   47dec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47dee:	4e75           	rts

00047e36 <_Workspace_Handler_initialization>:
 */
void _Workspace_Handler_initialization(
  void       *starting_address,
  size_t      size
)
{
   47e36:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   47e3a:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47e3c:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   47e40:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47e42:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  uint32_t    memory_available;

  if ( !starting_address || !_Addresses_Is_aligned( starting_address ) )
   47e46:	6706           	beqs 47e4e <_Workspace_Handler_initialization+0x18>	<== NOT EXECUTED
   47e48:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   47e4a:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   47e4c:	6706           	beqs 47e54 <_Workspace_Handler_initialization+0x1e>	<== NOT EXECUTED
    _Internal_error_Occurred(
   47e4e:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   47e52:	6040           	bras 47e94 <_Workspace_Handler_initialization+0x5e>	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS
    );

  if ( _Configuration_Table->do_zero_of_workspace )
   47e54:	2079 0005 6d3e 	moveal 56d3e <_Configuration_Table>,%a0           	<== NOT EXECUTED
   47e5a:	4a28 0028      	tstb %a0@(40)                                     	<== NOT EXECUTED
   47e5e:	6712           	beqs 47e72 <_Workspace_Handler_initialization+0x3c>	<== NOT EXECUTED
   memset( starting_address, 0, size );
   47e60:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47e62:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47e64:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47e66:	4eb9 0004 b464 	jsr 4b464 <memset>                                	<== NOT EXECUTED
   47e6c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

  memory_available = _Heap_Initialize(
   47e72:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   47e76:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   47e78:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   47e7a:	4879 0005 6cc6 	pea 56cc6 <_Workspace_Area>                       	<== NOT EXECUTED
   47e80:	4eb9 0004 5d6c 	jsr 45d6c <_Heap_Initialize>                      	<== NOT EXECUTED
    starting_address,
    size,
    CPU_HEAP_ALIGNMENT
  );

  if ( memory_available == 0 )
   47e86:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   47e8c:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   47e8e:	6610           	bnes 47ea0 <_Workspace_Handler_initialization+0x6a>	<== NOT EXECUTED
    _Internal_error_Occurred(
   47e90:	4878 0003      	pea 3 <DIVIDE>                                    	<== NOT EXECUTED
   47e94:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   47e98:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   47e9a:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
      INTERNAL_ERROR_CORE,
      TRUE,
      INTERNAL_ERROR_TOO_LITTLE_WORKSPACE
    );
}
   47ea0:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   47ea4:	262e fffc      	movel %fp@(-4),%d3                                	<== NOT EXECUTED
   47ea8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47eaa:	4e75           	rts

000450d4 <rtems_barrier_create>:
  rtems_name           name,
  rtems_attribute      attribute_set,
  uint32_t             maximum_waiters,
  rtems_id            *id
)
{
   450d4:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   450d8:	48d7 1c0c      	moveml %d2-%d3/%a2-%a4,%sp@                       	<== NOT EXECUTED
   450dc:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   450e0:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   450e4:	222e 0010      	movel %fp@(16),%d1                                	<== NOT EXECUTED
   450e8:	286e 0014      	moveal %fp@(20),%a4                               	<== NOT EXECUTED
  Barrier_Control         *the_barrier;
  CORE_barrier_Attributes  the_attributes;

  if ( !rtems_is_name_valid( name ) )
   450ec:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   450ee:	6606           	bnes 450f6 <rtems_barrier_create+0x22>            	<== NOT EXECUTED
   450f0:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   450f2:	6000 0086      	braw 4517a <rtems_barrier_create+0xa6>            	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   450f6:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   450f8:	6604           	bnes 450fe <rtems_barrier_create+0x2a>            	<== NOT EXECUTED
   450fa:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   450fc:	607c           	bras 4517a <rtems_barrier_create+0xa6>            	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  /* Initialize core barrier attributes */
  if ( _Attributes_Is_barrier_automatic( attribute_set ) ) {
   450fe:	0802 0004      	btst #4,%d2                                       	<== NOT EXECUTED
   45102:	670e           	beqs 45112 <rtems_barrier_create+0x3e>            	<== NOT EXECUTED
    the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
    if ( maximum_waiters == 0 )
   45104:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   45106:	6604           	bnes 4510c <rtems_barrier_create+0x38>            	<== NOT EXECUTED
   45108:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4510a:	606e           	bras 4517a <rtems_barrier_create+0xa6>            	<== 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;
   4510c:	42ae fff8      	clrl %fp@(-8)                                     	<== NOT EXECUTED
   45110:	6006           	bras 45118 <rtems_barrier_create+0x44>            	<== NOT EXECUTED
    if ( maximum_waiters == 0 )
      return RTEMS_INVALID_NUMBER;
  } else
    the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE;
   45112:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45114:	2d40 fff8      	movel %d0,%fp@(-8)                                	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   45118:	2039 0005 8ddc 	movel 58ddc <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4511e:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
  the_attributes.maximum_count = maximum_waiters;
   45120:	2d41 fffc      	movel %d1,%fp@(-4)                                	<== NOT EXECUTED
   45124:	23c0 0005 8ddc 	movel %d0,58ddc <_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 );
   4512a:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   45130:	4eb9 0004 6d78 	jsr 46d78 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* prevents deletion */

  the_barrier = _Barrier_Allocate();

  if ( !the_barrier ) {
   45136:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45138:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4513a:	47f9 0004 79ba 	lea 479ba <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED
   45140:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45142:	6606           	bnes 4514a <rtems_barrier_create+0x76>            	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   45144:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   45146:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   45148:	6030           	bras 4517a <rtems_barrier_create+0xa6>            	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }

  the_barrier->attribute_set = attribute_set;
   4514a:	2542 0010      	movel %d2,%a2@(16)                                	<== NOT EXECUTED

  _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
   4514e:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   45152:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   45156:	4eb9 0004 6548 	jsr 46548 <_CORE_barrier_Initialize>              	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4515c:	2079 0005 8cee 	moveal 58cee <_Barrier_Information+0x1a>,%a0      	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   45162:	2543 000c      	movel %d3,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   45166:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45168:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
    &_Barrier_Information,
    &the_barrier->Object,
    (Objects_Name) name
  );

  *id = the_barrier->Object.id;
   4516c:	28aa 0008      	movel %a2@(8),%a4@                                	<== NOT EXECUTED
   45170:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED

  _Thread_Enable_dispatch();
   45174:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   45176:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45178:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4517a:	4cee 1c0c ffe4 	moveml %fp@(-28),%d2-%d3/%a2-%a4                  	<== NOT EXECUTED
   45180:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45182:	4e75           	rts

00045184 <rtems_barrier_delete>:
 */

rtems_status_code rtems_barrier_delete(
  rtems_id   id
)
{
   45184:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45188:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Barrier_Control *)
   4518a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4518e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45192:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   45198:	4eb9 0004 71d8 	jsr 471d8 <_Objects_Get>                          	<== NOT EXECUTED
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   4519e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   451a4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   451a6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   451aa:	6704           	beqs 451b0 <rtems_barrier_delete+0x2c>            	<== NOT EXECUTED
   451ac:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   451ae:	603a           	bras 451ea <rtems_barrier_delete+0x66>            	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _CORE_barrier_Flush(
   451b0:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   451b4:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   451b6:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   451ba:	4eb9 0004 8040 	jsr 48040 <_Thread_queue_Flush>                   	<== NOT EXECUTED
        &the_barrier->Barrier,
        NULL,
        CORE_BARRIER_WAS_DELETED
      );

      _Objects_Close( &_Barrier_Information, &the_barrier->Object );
   451c0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   451c2:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   451c8:	4eb9 0004 6e00 	jsr 46e00 <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Barrier_Free (
  Barrier_Control *the_barrier
)
{
  _Objects_Free( &_Barrier_Information, &the_barrier->Object );
   451ce:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   451d0:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   451d6:	4eb9 0004 7078 	jsr 47078 <_Objects_Free>                         	<== NOT EXECUTED

      _Barrier_Free( the_barrier );

      _Thread_Enable_dispatch();
   451dc:	4eb9 0004 79ba 	jsr 479ba <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   451e2:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   451e8:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   451ea:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   451ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   451f0:	4e75           	rts                                               	<== NOT EXECUTED
	...

000451f4 <rtems_barrier_ident>:

rtems_status_code rtems_barrier_ident(
  rtems_name  name,
  rtems_id   *id
)
{
   451f4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   451f8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   451fc:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   45202:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45206:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   4520c:	4eb9 0004 733c 	jsr 4733c <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   45212:	41f9 0005 625c 	lea 5625c <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   45218:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4521c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4521e:	4e75           	rts

00045220 <rtems_barrier_release>:

rtems_status_code rtems_barrier_release(
  rtems_id          id,
  uint32_t         *released
)
{
   45220:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45224:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45226:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   4522a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4522c:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  if ( !released )
   45230:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   45232:	6604           	bnes 45238 <rtems_barrier_release+0x18>           	<== NOT EXECUTED
   45234:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   45236:	6042           	bras 4527a <rtems_barrier_release+0x5a>           	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Barrier_Control *)
   45238:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4523c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4523e:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   45244:	4eb9 0004 71d8 	jsr 471d8 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   4524a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45250:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   45252:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45256:	6704           	beqs 4525c <rtems_barrier_release+0x3c>           	<== NOT EXECUTED
   45258:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4525a:	601e           	bras 4527a <rtems_barrier_release+0x5a>           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL );
   4525c:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4525e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45260:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   45264:	4eb9 0004 6584 	jsr 46584 <_CORE_barrier_Release>                 	<== NOT EXECUTED
   4526a:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   4526c:	4eb9 0004 79ba 	jsr 479ba <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45272:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45278:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4527a:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4527e:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   45282:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45284:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045288 <rtems_barrier_wait>:

rtems_status_code rtems_barrier_wait(
  rtems_id        id,
  rtems_interval  timeout
)
{
   45288:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4528c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4528e:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   45292:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45296:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45298:	4879 0005 8cd4 	pea 58cd4 <_Barrier_Information>                  	<== NOT EXECUTED
   4529e:	4eb9 0004 71d8 	jsr 471d8 <_Objects_Get>                          	<== NOT EXECUTED
  Barrier_Control   *the_barrier;
  Objects_Locations  location;

  the_barrier = _Barrier_Get( id, &location );
  switch ( location ) {
   452a4:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   452aa:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   452ac:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   452b0:	6704           	beqs 452b6 <rtems_barrier_wait+0x2e>              	<== NOT EXECUTED
   452b2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   452b4:	6032           	bras 452e8 <rtems_barrier_wait+0x60>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _CORE_barrier_Wait(
   452b6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   452b8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   452bc:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   452c0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   452c2:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   452c6:	4eb9 0004 65b8 	jsr 465b8 <_CORE_barrier_Wait>                    	<== NOT EXECUTED
        id,
        TRUE,
        timeout,
        NULL
      );
      _Thread_Enable_dispatch();
   452cc:	4eb9 0004 79ba 	jsr 479ba <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return _Barrier_Translate_core_barrier_return_code(
   452d2:	2079 0005 8e9a 	moveal 58e9a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   452d8:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   452dc:	4eb9 0004 a354 	jsr 4a354 <_Barrier_Translate_core_barrier_return_code>	<== NOT EXECUTED
   452e2:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   452e8:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   452ec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   452ee:	4e75           	rts

0004608c <rtems_build_id>:
  uint32_t api,
  uint32_t class,
  uint32_t node,
  uint32_t index
)
{
   4608c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46090:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   46092:	202e 000c      	movel %fp@(12),%d0                                	<== NOT EXECUTED
   46096:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   4609a:	761b           	moveq #27,%d3                                     	<== NOT EXECUTED
   4609c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4609e:	e7a8           	lsll %d3,%d0                                      	<== NOT EXECUTED
   460a0:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
   460a4:	163c 0018      	moveb #24,%d3                                     	<== NOT EXECUTED
   460a8:	e7a9           	lsll %d3,%d1                                      	<== NOT EXECUTED
   460aa:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   460ac:	80ae 0014      	orl %fp@(20),%d0                                  	<== NOT EXECUTED
   460b0:	4842           	swap %d2                                          	<== NOT EXECUTED
   460b2:	4242           	clrw %d2                                          	<== NOT EXECUTED
  return _Objects_Build_id( api, class, node, index );
}
   460b4:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   460b6:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   460b8:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   460ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   460bc:	4e75           	rts                                               	<== NOT EXECUTED
	...

000460c0 <rtems_build_name>:
  char C1,
  char C2,
  char C3,
  char C4
)
{
   460c0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   460c4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   460c6:	142e 000b      	moveb %fp@(11),%d2                                	<== NOT EXECUTED
   460ca:	7218           	moveq #24,%d1                                     	<== NOT EXECUTED
   460cc:	102e 000f      	moveb %fp@(15),%d0                                	<== NOT EXECUTED
   460d0:	49c2           	extbl %d2                                         	<== NOT EXECUTED
   460d2:	e3aa           	lsll %d1,%d2                                      	<== NOT EXECUTED
   460d4:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   460d6:	122e 0013      	moveb %fp@(19),%d1                                	<== NOT EXECUTED
   460da:	4840           	swap %d0                                          	<== NOT EXECUTED
   460dc:	4240           	clrw %d0                                          	<== NOT EXECUTED
   460de:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   460e0:	49c1           	extbl %d1                                         	<== NOT EXECUTED
   460e2:	e189           	lsll #8,%d1                                       	<== NOT EXECUTED
  return _Objects_Build_name( C1, C2, C3, C4 );
}
   460e4:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
  char C1,
  char C2,
  char C3,
  char C4
)
{
   460e6:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   460e8:	122e 0017      	moveb %fp@(23),%d1                                	<== NOT EXECUTED
   460ec:	49c1           	extbl %d1                                         	<== NOT EXECUTED
  return _Objects_Build_name( C1, C2, C3, C4 );
}
   460ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   460f0:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   460f2:	4e75           	rts

0004463c <rtems_clock_get>:

rtems_status_code rtems_clock_get(
  rtems_clock_get_options  option,
  void                    *time_buffer
)
{
   4463c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   44640:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44642:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   44646:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  if ( !time_buffer )
   4464a:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4464c:	6604           	bnes 44652 <rtems_clock_get+0x16>                 	<== NOT EXECUTED
   4464e:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   44650:	6062           	bras 446b4 <rtems_clock_get+0x78>                 	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  switch ( option ) {
   44652:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
   44654:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   44656:	6514           	bcss 4466c <rtems_clock_get+0x30>                 	<== NOT EXECUTED
   44658:	303b 0a08      	movew %pc@(44662 <rtems_clock_get+0x26>,%d0:l:2),%d0	<== NOT EXECUTED
   4465c:	48c0           	extl %d0                                          	<== NOT EXECUTED
   4465e:	4efb 0802      	jmp %pc@(44662 <rtems_clock_get+0x26>,%d0:l)      	<== NOT EXECUTED
   44662:	000e           	016                                               	<== NOT EXECUTED
   44664:	001e           	036                                               	<== NOT EXECUTED
   44666:	002e           	056                                               	<== NOT EXECUTED
   44668:	0036           	066                                               	<== NOT EXECUTED
   4466a:	0042           	0102                                              	<== NOT EXECUTED
   4466c:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4466e:	6044           	bras 446b4 <rtems_clock_get+0x78>                 	<== NOT EXECUTED
    case RTEMS_CLOCK_GET_TOD:
      return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer );
   44670:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   44674:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   44678:	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 );
   4467a:	4ef9 0004 470c 	jmp 4470c <rtems_clock_get_tod>                   	<== NOT EXECUTED

    case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH:
      return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer);
   44680:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   44684:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   44688:	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);
   4468a:	4ef9 0004 46bc 	jmp 446bc <rtems_clock_get_seconds_since_epoch>   	<== NOT EXECUTED

    case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: {
      rtems_interval *interval = (rtems_interval *)time_buffer;

      *interval = rtems_clock_get_ticks_since_boot();
   44690:	4eb9 0004 46fc 	jsr 446fc <rtems_clock_get_ticks_since_boot>      	<== NOT EXECUTED
   44696:	6006           	bras 4469e <rtems_clock_get+0x62>                 	<== 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();
   44698:	4eb9 0004 46e4 	jsr 446e4 <rtems_clock_get_ticks_per_second>      	<== NOT EXECUTED
   4469e:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
   446a0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   446a2:	6010           	bras 446b4 <rtems_clock_get+0x78>                 	<== NOT EXECUTED
      return RTEMS_SUCCESSFUL;
    }
    case RTEMS_CLOCK_GET_TIME_VALUE:
      return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer );
   446a4:	2d4a 0008      	movel %a2,%fp@(8)                                 	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   446a8:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   446ac:	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 );
   446ae:	4ef9 0004 47c4 	jmp 447c4 <rtems_clock_get_tod_timeval>           	<== NOT EXECUTED
      break;
  }

  return RTEMS_INVALID_NUMBER;

}
   446b4:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   446b8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   446ba:	4e75           	rts

000446bc <rtems_clock_get_seconds_since_epoch>:
#include <rtems/score/watchdog.h>

rtems_status_code rtems_clock_get_seconds_since_epoch(
  rtems_interval *the_interval
)
{
   446bc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   446c0:	206e 0008      	moveal %fp@(8),%a0                                	<== NOT EXECUTED
  if ( !the_interval )
   446c4:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   446c6:	6604           	bnes 446cc <rtems_clock_get_seconds_since_epoch+0x10>	<== NOT EXECUTED
   446c8:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   446ca:	6014           	bras 446e0 <rtems_clock_get_seconds_since_epoch+0x24>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   446cc:	4a39 0005 6cb8 	tstb 56cb8 <_TOD_Is_set>                          	<== NOT EXECUTED
   446d2:	6604           	bnes 446d8 <rtems_clock_get_seconds_since_epoch+0x1c>	<== NOT EXECUTED
   446d4:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   446d6:	6008           	bras 446e0 <rtems_clock_get_seconds_since_epoch+0x24>	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  *the_interval = _TOD_Seconds_since_epoch;
   446d8:	4280           	clrl %d0                                          	<== NOT EXECUTED
   446da:	20b9 0005 6d36 	movel 56d36 <_TOD_Now>,%a0@                       	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   446e0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   446e2:	4e75           	rts

000446e4 <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)
{
   446e4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick;
}
   446e8:	41f9 0005 6e32 	lea 56e32 <_TOD_Microseconds_per_tick>,%a0        	<== NOT EXECUTED
   446ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   446f0:	203c 000f 4240 	movel #1000000,%d0                                	<== NOT EXECUTED
   446f6:	4c50 0000      	remul %a0@,%d0,%d0                                	<== NOT EXECUTED
   446fa:	4e75           	rts

000446fc <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)
{
   446fc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Watchdog_Ticks_since_boot;
   44700:	2039 0005 6dec 	movel 56dec <_Watchdog_Ticks_since_boot>,%d0      	<== NOT EXECUTED
}
   44706:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44708:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004470c <rtems_clock_get_tod>:
#include <rtems/score/watchdog.h>

rtems_status_code rtems_clock_get_tod(
  rtems_time_of_day  *time_buffer
)
{
   4470c:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
   44710:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44712:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   44716:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  rtems_time_of_day *tmbuf = time_buffer;
  struct tm time;
  struct timeval now;

  if ( !time_buffer )
   44718:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4471a:	6606           	bnes 44722 <rtems_clock_get_tod+0x16>             	<== NOT EXECUTED
   4471c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4471e:	6000 0096      	braw 447b6 <rtems_clock_get_tod+0xaa>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   44722:	4a39 0005 6cb8 	tstb 56cb8 <_TOD_Is_set>                          	<== NOT EXECUTED
   44728:	6606           	bnes 44730 <rtems_clock_get_tod+0x24>             	<== NOT EXECUTED
   4472a:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   4472c:	6000 0088      	braw 447b6 <rtems_clock_get_tod+0xaa>             	<== NOT EXECUTED
)
{
  ISR_Level level;
  struct timespec now;

  _ISR_Disable(level);
   44730:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   44736:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   44738:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   4473a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    _TOD_Get( &now );
   4473c:	486e fff0      	pea %fp@(-16)                                     	<== NOT EXECUTED
   44740:	4eb9 0004 5c58 	jsr 45c58 <_TOD_Get>                              	<== NOT EXECUTED
  _ISR_Enable(level);
   44746:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  time->tv_sec  = now.tv_sec;
  time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
   44748:	222e fff4      	movel %fp@(-12),%d1                               	<== NOT EXECUTED

  /* Obtain the current time */
  _TOD_Get_timeval( &now );

  /* Split it into a closer format */
  gmtime_r( &now.tv_sec, &time );
   4474c:	486e ffcc      	pea %fp@(-52)                                     	<== NOT EXECUTED
   44750:	243c 0000 03e8 	movel #1000,%d2                                   	<== NOT EXECUTED
   44756:	4c42 1001      	remul %d2,%d1,%d1                                 	<== NOT EXECUTED
   4475a:	2d41 fffc      	movel %d1,%fp@(-4)                                	<== NOT EXECUTED

  _ISR_Disable(level);
    _TOD_Get( &now );
  _ISR_Enable(level);

  time->tv_sec  = now.tv_sec;
   4475e:	2d6e fff0 fff8 	movel %fp@(-16),%fp@(-8)                          	<== NOT EXECUTED
   44764:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   44768:	4eb9 0004 b3d8 	jsr 4b3d8 <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;
   4476e:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   44772:	41f9 0005 6e32 	lea 56e32 <_TOD_Microseconds_per_tick>,%a0        	<== NOT EXECUTED
   44778:	4c50 1001      	remul %a0@,%d1,%d1                                	<== NOT EXECUTED
   4477c:	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;
   44780:	222e ffe0      	movel %fp@(-32),%d1                               	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
   44784:	242e ffdc      	movel %fp@(-36),%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;
   44788:	0681 0000 076c 	addil #1900,%d1                                   	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
   4478e:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
  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;
   44790:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   44796:	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;
   44798:	2481           	movel %d1,%a2@                                    	<== NOT EXECUTED
  tmbuf->month  = time.tm_mon + 1;
  tmbuf->day    = time.tm_mday;
   4479a:	256e ffd8 0008 	movel %fp@(-40),%a2@(8)                           	<== NOT EXECUTED
  tmbuf->hour   = time.tm_hour;
   447a0:	256e ffd4 000c 	movel %fp@(-44),%a2@(12)                          	<== NOT EXECUTED
  tmbuf->minute = time.tm_min;
   447a6:	256e ffd0 0010 	movel %fp@(-48),%a2@(16)                          	<== NOT EXECUTED
  tmbuf->second = time.tm_sec;
   447ac:	256e ffcc 0014 	movel %fp@(-52),%a2@(20)                          	<== 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;
   447b2:	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;
}
   447b6:	242e ffc4      	movel %fp@(-60),%d2                               	<== NOT EXECUTED
   447ba:	246e ffc8      	moveal %fp@(-56),%a2                              	<== NOT EXECUTED
   447be:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   447c0:	4e75           	rts                                               	<== NOT EXECUTED
	...

000447c4 <rtems_clock_get_tod_timeval>:
#include <rtems/score/watchdog.h>

rtems_status_code rtems_clock_get_tod_timeval(
  struct timeval  *time
)
{
   447c4:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   447c8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   447ca:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
   447ce:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  if ( !time )
   447d0:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   447d2:	6604           	bnes 447d8 <rtems_clock_get_tod_timeval+0x14>     	<== NOT EXECUTED
   447d4:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   447d6:	603e           	bras 44816 <rtems_clock_get_tod_timeval+0x52>     	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Is_set )
   447d8:	4a39 0005 6cb8 	tstb 56cb8 <_TOD_Is_set>                          	<== NOT EXECUTED
   447de:	6604           	bnes 447e4 <rtems_clock_get_tod_timeval+0x20>     	<== NOT EXECUTED
   447e0:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   447e2:	6032           	bras 44816 <rtems_clock_get_tod_timeval+0x52>     	<== NOT EXECUTED
)
{
  ISR_Level level;
  struct timespec now;

  _ISR_Disable(level);
   447e4:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   447ea:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   447ec:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   447ee:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    _TOD_Get( &now );
   447f0:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   447f4:	4eb9 0004 5c58 	jsr 45c58 <_TOD_Get>                              	<== NOT EXECUTED
  _ISR_Enable(level);
   447fa:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

  time->tv_sec  = now.tv_sec;
  time->tv_usec = now.tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND;
   447fc:	222e fffc      	movel %fp@(-4),%d1                                	<== NOT EXECUTED
   44800:	243c 0000 03e8 	movel #1000,%d2                                   	<== NOT EXECUTED
   44806:	4c42 1001      	remul %d2,%d1,%d1                                 	<== NOT EXECUTED
   4480a:	2541 0004      	movel %d1,%a2@(4)                                 	<== NOT EXECUTED
   4480e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   44810:	4280           	clrl %d0                                          	<== NOT EXECUTED

  _ISR_Disable(level);
    _TOD_Get( &now );
  _ISR_Enable(level);

  time->tv_sec  = now.tv_sec;
   44812:	24ae fff8      	movel %fp@(-8),%a2@                               	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  _TOD_Get_timeval( time );

  return RTEMS_SUCCESSFUL;
}
   44816:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   4481a:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   4481e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44820:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044a3c <rtems_clock_get_uptime>:
 *    error code       - if unsuccessful
 */
rtems_status_code rtems_clock_get_uptime(
  struct timespec *uptime
)
{
   44a3c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   44a40:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  if ( !uptime )
   44a44:	6606           	bnes 44a4c <rtems_clock_get_uptime+0x10>          	<== NOT EXECUTED
   44a46:	103c 0009      	moveb #9,%d0                                      	<== NOT EXECUTED
   44a4a:	600c           	bras 44a58 <rtems_clock_get_uptime+0x1c>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _TOD_Get_uptime( uptime );
   44a4c:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   44a4e:	4eb9 0004 605c 	jsr 4605c <_TOD_Get_uptime>                       	<== NOT EXECUTED
   44a54:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   44a56:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   44a58:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44a5a:	4e75           	rts

000454cc <rtems_clock_set>:
 */

rtems_status_code rtems_clock_set(
  rtems_time_of_day *time_buffer
)
{
   454cc:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   454d0:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
   454d4:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  struct timespec  newtime;

  if ( !time_buffer )
   454d8:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   454da:	6604           	bnes 454e0 <rtems_clock_set+0x14>                 	<== NOT EXECUTED
   454dc:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   454de:	6060           	bras 45540 <rtems_clock_set+0x74>                 	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( _TOD_Validate( time_buffer ) ) {
   454e0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   454e2:	4eb9 0004 563c 	jsr 4563c <_TOD_Validate>                         	<== NOT EXECUTED
   454e8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   454ea:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   454ec:	6604           	bnes 454f2 <rtems_clock_set+0x26>                 	<== NOT EXECUTED
   454ee:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
   454f0:	604e           	bras 45540 <rtems_clock_set+0x74>                 	<== NOT EXECUTED
    newtime.tv_sec = _TOD_To_seconds( time_buffer );
   454f2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   454f4:	4eb9 0004 5588 	jsr 45588 <_TOD_To_seconds>                       	<== NOT EXECUTED
    newtime.tv_nsec = time_buffer->ticks *
   454fa:	242a 0018      	movel %a2@(24),%d2                                	<== NOT EXECUTED
   454fe:	41f9 0006 115a 	lea 6115a <_TOD_Microseconds_per_tick>,%a0        	<== NOT EXECUTED
   45504:	4c10 2800      	mulsl %a0@,%d2                                    	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   45508:	2079 0006 0fcc 	moveal 60fcc <_Thread_Dispatch_disable_level>,%a0 	<== NOT EXECUTED
   4550e:	2602           	movel %d2,%d3                                     	<== NOT EXECUTED
   45510:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   45512:	e58b           	lsll #2,%d3                                       	<== NOT EXECUTED
   45514:	ef89           	lsll #7,%d1                                       	<== NOT EXECUTED
   45516:	9283           	subl %d3,%d1                                      	<== NOT EXECUTED
   45518:	d282           	addl %d2,%d1                                      	<== NOT EXECUTED
   4551a:	5288           	addql #1,%a0                                      	<== NOT EXECUTED
   4551c:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   4551e:	2d41 fffc      	movel %d1,%fp@(-4)                                	<== NOT EXECUTED
   45522:	23c8 0006 0fcc 	movel %a0,60fcc <_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 );
   45528:	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 );
   4552c:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   45530:	4eb9 0004 6d48 	jsr 46d48 <_TOD_Set>                              	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   45536:	4eb9 0004 7de6 	jsr 47de6 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4553c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4553e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_INVALID_CLOCK;
}
   45540:	4cee 040c ffec 	moveml %fp@(-20),%d2-%d3/%a2                      	<== NOT EXECUTED
   45546:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45548:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044824 <rtems_clock_set_nanoseconds_extension>:
 *    error code        - if unsuccessful
 */
rtems_status_code rtems_clock_set_nanoseconds_extension(
  rtems_nanoseconds_extension_routine routine
)
{
   44824:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   44828:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
  if ( !routine )
   4482c:	6604           	bnes 44832 <rtems_clock_set_nanoseconds_extension+0xe>	<== NOT EXECUTED
   4482e:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   44830:	6008           	bras 4483a <rtems_clock_set_nanoseconds_extension+0x16>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _Watchdog_Nanoseconds_since_tick_handler = routine;
   44832:	4280           	clrl %d0                                          	<== NOT EXECUTED
   44834:	23c1 0005 6e3a 	movel %d1,56e3a <_Watchdog_Nanoseconds_since_tick_handler>	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4483a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4483c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044840 <rtems_clock_tick>:
 *
 *  NOTE: This routine only works for leap-years through 2099.
 */

rtems_status_code rtems_clock_tick( void )
{
   44840:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _TOD_Tickle_ticks();
   44844:	4eb9 0004 5cf0 	jsr 45cf0 <_TOD_Tickle_ticks>                     	<== NOT EXECUTED
 */

RTEMS_INLINE_ROUTINE void _Watchdog_Tickle_ticks( void )
{

  _Watchdog_Tickle( &_Watchdog_Ticks_chain );
   4484a:	4879 0005 6d80 	pea 56d80 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   44850:	4eb9 0004 7d5c 	jsr 47d5c <_Watchdog_Tickle>                      	<== NOT EXECUTED

  _Watchdog_Tickle_ticks();

  _Thread_Tickle_timeslice();
   44856:	4eb9 0004 7820 	jsr 47820 <_Thread_Tickle_timeslice>              	<== NOT EXECUTED

  if ( _Thread_Is_context_switch_necessary() &&
   4485c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
 *  otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_context_switch_necessary( void )
{
  return ( _Context_Switch_necessary );
   4485e:	1039 0005 6d72 	moveb 56d72 <_Context_Switch_necessary>,%d0       	<== NOT EXECUTED
   44864:	670e           	beqs 44874 <rtems_clock_tick+0x34>                	<== NOT EXECUTED
 *  otherwise.
 */

RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void )
{
  return ( _Thread_Dispatch_disable_level == 0 );
   44866:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4486c:	6606           	bnes 44874 <rtems_clock_tick+0x34>                	<== NOT EXECUTED
       _Thread_Is_dispatching_enabled() )
    _Thread_Dispatch();
   4486e:	4eb9 0004 6afc 	jsr 46afc <_Thread_Dispatch>                      	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   44874:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44876:	4280           	clrl %d0                                          	<== NOT EXECUTED
   44878:	4e75           	rts                                               	<== NOT EXECUTED
	...

000499b8 <rtems_debug_disable>:
 */

void rtems_debug_disable (
  rtems_debug_control  to_be_disabled
)
{
   499b8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Debug_Level &= ~to_be_disabled;
   499bc:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
}
   499c0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

void rtems_debug_disable (
  rtems_debug_control  to_be_disabled
)
{
  _Debug_Level &= ~to_be_disabled;
   499c2:	4680           	notl %d0                                          	<== NOT EXECUTED
   499c4:	c1b9 0005 6d66 	andl %d0,56d66 <_Debug_Level>                     	<== NOT EXECUTED
}
   499ca:	4e75           	rts

000499a6 <rtems_debug_enable>:
 */

void rtems_debug_enable (
  rtems_debug_control  to_be_enabled
)
{
   499a6:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Debug_Level |= to_be_enabled;
   499aa:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
}
   499ae:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

void rtems_debug_enable (
  rtems_debug_control  to_be_enabled
)
{
  _Debug_Level |= to_be_enabled;
   499b0:	81b9 0005 6d66 	orl %d0,56d66 <_Debug_Level>                      	<== NOT EXECUTED
}
   499b6:	4e75           	rts

0004487c <rtems_event_receive>:
  rtems_event_set  event_in,
  rtems_option     option_set,
  rtems_interval   ticks,
  rtems_event_set *event_out
)
{
   4487c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   44880:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   44884:	226e 0014      	moveal %fp@(20),%a1                               	<== NOT EXECUTED
  RTEMS_API_Control       *api;

  if ( !event_out )
   44888:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   4488a:	6604           	bnes 44890 <rtems_event_receive+0x14>             	<== NOT EXECUTED
   4488c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4488e:	604a           	bras 448da <rtems_event_receive+0x5e>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
   44890:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   44896:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED

  if ( _Event_sets_Is_empty( event_in ) ) {
   4489a:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   4489c:	6606           	bnes 448a4 <rtems_event_receive+0x28>             	<== NOT EXECUTED
    *event_out = api->pending_events;
   4489e:	2290           	movel %a0@,%a1@                                   	<== NOT EXECUTED
   448a0:	4280           	clrl %d0                                          	<== NOT EXECUTED
   448a2:	6036           	bras 448da <rtems_event_receive+0x5e>             	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   448a4:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   448aa:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   448ac:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
  }

  _Thread_Disable_dispatch();
  _Event_Seize( event_in, option_set, ticks, event_out );
   448b2:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   448b4:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   448b8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   448bc:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   448be:	4eb9 0004 48e0 	jsr 448e0 <_Event_Seize>                          	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   448c4:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return( _Thread_Executing->Wait.return_code );
   448ca:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   448d0:	2028 0034      	movel %a0@(52),%d0                                	<== NOT EXECUTED
   448d4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
}
   448da:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   448dc:	4e75           	rts                                               	<== NOT EXECUTED
	...

000449e4 <rtems_event_send>:

rtems_status_code rtems_event_send(
  Objects_Id        id,
  rtems_event_set   event_in
)
{
   449e4:	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 );
   449e8:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   449ec:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   449f0:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   449f6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
{
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  the_thread = _Thread_Get( id, &location );
   449f8:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
  switch ( location ) {
   449fa:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   449fe:	6704           	beqs 44a04 <rtems_event_send+0x20>                	<== NOT EXECUTED
   44a00:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   44a02:	602a           	bras 44a2e <rtems_event_send+0x4a>                	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
   44a04:	2069 010c      	moveal %a1@(268),%a0                              	<== NOT EXECUTED
  rtems_event_set *the_event_set
)
{
  ISR_Level level;

  _ISR_Disable( level );
   44a08:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   44a0e:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   44a10:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   44a12:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    *the_event_set |= the_new_events;
   44a14:	222e 000c      	movel %fp@(12),%d1                                	<== NOT EXECUTED
   44a18:	8390           	orl %d1,%a0@                                      	<== NOT EXECUTED
  _ISR_Enable( level );
   44a1a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
      _Event_sets_Post( event_in, &api->pending_events );
      _Event_Surrender( the_thread );
   44a1c:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   44a1e:	4eb9 0004 4a34 	jsr 44a34 <_Event_Surrender>                      	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   44a24:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44a2a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   44a2c:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   44a2e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44a30:	4e75           	rts                                               	<== NOT EXECUTED
	...

00048fdc <rtems_extension_create>:
rtems_status_code rtems_extension_create(
  rtems_name              name,
  rtems_extensions_table *extension_table,
  Objects_Id             *id
)
{
   48fdc:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   48fe0:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   48fe4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   48fe8:	286e 0010      	moveal %fp@(16),%a4                               	<== NOT EXECUTED
  Extension_Control *the_extension;

  if ( !id )
   48fec:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   48fee:	6604           	bnes 48ff4 <rtems_extension_create+0x18>          	<== NOT EXECUTED
   48ff0:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   48ff2:	6062           	bras 49056 <rtems_extension_create+0x7a>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !rtems_is_name_valid( name ) )
   48ff4:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   48ff6:	6604           	bnes 48ffc <rtems_extension_create+0x20>          	<== NOT EXECUTED
   48ff8:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   48ffa:	605a           	bras 49056 <rtems_extension_create+0x7a>          	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   48ffc:	2039 0006 298c 	movel 6298c <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   49002:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   49004:	23c0 0006 298c 	movel %d0,6298c <_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 );
   4900a:	4879 0006 2b42 	pea 62b42 <_Extension_Information>                	<== NOT EXECUTED
   49010:	4eb9 0004 9bc8 	jsr 49bc8 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_extension = _Extension_Allocate();

  if ( !the_extension ) {
   49016:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   49018:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4901a:	47f9 0004 a87a 	lea 4a87a <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED
   49020:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   49022:	6606           	bnes 4902a <rtems_extension_create+0x4e>          	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   49024:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   49026:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   49028:	602c           	bras 49056 <rtems_extension_create+0x7a>          	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }

  _User_extensions_Add_set( &the_extension->Extension, extension_table );
   4902a:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4902e:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   49032:	4eb9 0004 b5f0 	jsr 4b5f0 <_User_extensions_Add_set>              	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   49038:	4280           	clrl %d0                                          	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4903a:	2542 000c      	movel %d2,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4903e:	2079 0006 2b5c 	moveal 62b5c <_Extension_Information+0x1a>,%a0    	<== NOT EXECUTED
   49044:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
    &_Extension_Information,
    &the_extension->Object,
    (Objects_Name) name
  );

  *id = the_extension->Object.id;
   49048:	28aa 0008      	movel %a2@(8),%a4@                                	<== NOT EXECUTED
   4904c:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   49050:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   49052:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   49054:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   49056:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   4905c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4905e:	4e75           	rts

00049060 <rtems_extension_delete>:
 */

rtems_status_code rtems_extension_delete(
  Objects_Id id
)
{
   49060:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   49064:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Extension_Control *_Extension_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Extension_Control *)
   49066:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4906a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4906e:	4879 0006 2b42 	pea 62b42 <_Extension_Information>                	<== NOT EXECUTED
   49074:	4eb9 0004 a028 	jsr 4a028 <_Objects_Get>                          	<== NOT EXECUTED
  Extension_Control   *the_extension;
  Objects_Locations    location;

  the_extension = _Extension_Get( id, &location );
  switch ( location ) {
   4907a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   49080:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   49082:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   49086:	6704           	beqs 4908c <rtems_extension_delete+0x2c>          	<== NOT EXECUTED
   49088:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4908a:	6034           	bras 490c0 <rtems_extension_delete+0x60>          	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      _User_extensions_Remove_set( &the_extension->Extension );
   4908c:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   49090:	4eb9 0004 b704 	jsr 4b704 <_User_extensions_Remove_set>           	<== NOT EXECUTED
      _Objects_Close( &_Extension_Information, &the_extension->Object );
   49096:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   49098:	4879 0006 2b42 	pea 62b42 <_Extension_Information>                	<== NOT EXECUTED
   4909e:	4eb9 0004 9c50 	jsr 49c50 <_Objects_Close>                        	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Extension_Free (
  Extension_Control *the_extension
)
{
  _Objects_Free( &_Extension_Information, &the_extension->Object );
   490a4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   490a6:	4879 0006 2b42 	pea 62b42 <_Extension_Information>                	<== NOT EXECUTED
   490ac:	4eb9 0004 9ec8 	jsr 49ec8 <_Objects_Free>                         	<== NOT EXECUTED
      _Extension_Free( the_extension );
      _Thread_Enable_dispatch();
   490b2:	4eb9 0004 a87a 	jsr 4a87a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   490b8:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   490be:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   490c0:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   490c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   490c6:	4e75           	rts

00046ce0 <rtems_extension_ident>:

rtems_status_code rtems_extension_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   46ce0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   46ce4:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   46ce8:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   46cee:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46cf2:	4879 0005 a55a 	pea 5a55a <_Extension_Information>                	<== NOT EXECUTED
   46cf8:	4eb9 0004 7d9c 	jsr 47d9c <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   46cfe:	41f9 0005 7604 	lea 57604 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   46d04:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   46d08:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46d0a:	4e75           	rts

00045570 <rtems_fatal_error_occurred>:
 */

void rtems_fatal_error_occurred(
  uint32_t   the_error
)
{
   45570:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error );
   45574:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45578:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4557a:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4557e:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED

00046c5c <rtems_get_version_string>:
#endif

#include <rtems/system.h>

const char *rtems_get_version_string(void)
{
   46c5c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _RTEMS_version;
}
   46c60:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46c62:	203c 0005 84f2 	movel #361714,%d0                                 	<== NOT EXECUTED
   46c68:	4e75           	rts                                               	<== NOT EXECUTED
	...

000453f2 <rtems_initialize_before_drivers>:
   *  Scheduling can properly occur now as long as we avoid dispatching.
   */
}

void rtems_initialize_before_drivers(void)
{
   453f2:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   *  Run the API and BSPs predriver hook.
   */

  _API_extensions_Run_predriver();

}
   453f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

  /*
   *  Run the API and BSPs predriver hook.
   */

  _API_extensions_Run_predriver();
   453f8:	4ef9 0004 5700 	jmp 45700 <_API_extensions_Run_predriver>         	<== NOT EXECUTED

000453fe <rtems_initialize_data_structures>:
Objects_Information *_Internal_Objects[ OBJECTS_INTERNAL_CLASSES_LAST + 1 ];

void rtems_initialize_data_structures(
  rtems_configuration_table *configuration_table
)
{
   453fe:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45402:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45404:	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 );
   45408:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4540e:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   45410:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   45412:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

  /*
   *  Make sure the parameters were not NULL.
   */
  if ( configuration_table == NULL )
   45414:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   45416:	660e           	bnes 45426 <rtems_initialize_data_structures+0x28>	<== NOT EXECUTED
    _Internal_error_Occurred(
   45418:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4541a:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   4541e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45420:	4eb9 0004 5f40 	jsr 45f40 <_Internal_error_Occurred>              	<== NOT EXECUTED
  _Configuration_Table    = configuration_table;

  /*
   * Initialize any target architecture specific support as early as possible
   */
  _CPU_Initialize( _Thread_Dispatch );
   45426:	4879 0004 6afc 	pea 46afc <_Thread_Dispatch>                      	<== NOT EXECUTED
    );

  /*
   *  Provide pointers just for later convenience.
   */
  _Configuration_Table    = configuration_table;
   4542c:	23ca 0005 6d3e 	movel %a2,56d3e <_Configuration_Table>            	<== NOT EXECUTED

  /*
   * Initialize any target architecture specific support as early as possible
   */
  _CPU_Initialize( _Thread_Dispatch );
   45432:	4eb9 0004 7f70 	jsr 47f70 <_CPU_Initialize>                       	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Handler_initialization (
  bool  is_multiprocessing
)
{
  _System_state_Current = SYSTEM_STATE_BEFORE_INITIALIZATION;
   45438:	42b9 0005 6e36 	clrl 56e36 <_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();
   4543e:	4eb9 0004 9998 	jsr 49998 <_Debug_Manager_initialization>         	<== NOT EXECUTED

  _API_extensions_Initialization();
   45444:	4eb9 0004 56e0 	jsr 456e0 <_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(
   4544a:	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;
   4544e:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45450:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
   45456:	2f12           	movel %a2@,%sp@-                                  	<== NOT EXECUTED
   45458:	4eb9 0004 7e36 	jsr 47e36 <_Workspace_Handler_initialization>     	<== NOT EXECUTED
     (void *)configuration_table->work_space_start,
     configuration_table->work_space_size
  );

  _User_extensions_Handler_initialization(
   4545e:	2f2a 003a      	movel %a2@(58),%sp@-                              	<== NOT EXECUTED
   45462:	2f2a 0036      	movel %a2@(54),%sp@-                              	<== NOT EXECUTED
   45466:	4eb9 0004 7994 	jsr 47994 <_User_extensions_Handler_initialization>	<== NOT EXECUTED
    configuration_table->number_of_initial_extensions,
    configuration_table->User_extension_table
  );

  _ISR_Handler_initialization();
   4546c:	4eb9 0004 5f9c 	jsr 45f9c <_ISR_Handler_initialization>           	<== NOT EXECUTED

  _Objects_Handler_initialization(
   45472:	4eb9 0004 6640 	jsr 46640 <_Objects_Handler_initialization>       	<== NOT EXECUTED
  _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects;

  /*
   * Initialize the internal allocator Mutex
   */
  _API_Mutex_Initialization( 1 );
   45478:	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;
   4547c:	203c 0005 6cba 	movel #355514,%d0                                 	<== NOT EXECUTED
   45482:	23c0 0005 6c60 	movel %d0,56c60 <_Objects_Information_table+0x4>  	<== NOT EXECUTED

  /*
   * Initialize the internal allocator Mutex
   */
  _API_Mutex_Initialization( 1 );
   45488:	4eb9 0004 5844 	jsr 45844 <_API_Mutex_Initialization>             	<== NOT EXECUTED
  _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex );
   4548e:	4879 0005 6d5a 	pea 56d5a <_RTEMS_Allocator_Mutex>                	<== NOT EXECUTED
   45494:	4eb9 0004 57a0 	jsr 457a0 <_API_Mutex_Allocate>                   	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _Priority_Handler_initialization( void )
{
  size_t index;

  _Priority_Major_bit_map = 0;
   4549a:	4240           	clrw %d0                                          	<== NOT EXECUTED
   4549c:	33c0 0005 6d58 	movew %d0,56d58 <_Priority_Major_bit_map>         	<== NOT EXECUTED
   454a2:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   454a8:	41f9 0005 6dc8 	lea 56dc8 <_Priority_Bit_map>,%a0                 	<== NOT EXECUTED
  for ( index=0 ; index <16 ; index++ )
     _Priority_Bit_map[ index ] = 0;
   454ae:	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++ )
   454b0:	b1fc 0005 6de8 	cmpal #355816,%a0                                 	<== NOT EXECUTED
   454b6:	66f6           	bnes 454ae <rtems_initialize_data_structures+0xb0>	<== NOT EXECUTED

  _Priority_Handler_initialization();

  _Watchdog_Handler_initialization();
   454b8:	4eb9 0004 7c94 	jsr 47c94 <_Watchdog_Handler_initialization>      	<== NOT EXECUTED

  _TOD_Handler_initialization( configuration_table->microseconds_per_tick );
   454be:	2f2a 000c      	movel %a2@(12),%sp@-                              	<== NOT EXECUTED
   454c2:	4eb9 0004 5cb8 	jsr 45cb8 <_TOD_Handler_initialization>           	<== NOT EXECUTED

  _Thread_Handler_initialization(
   454c8:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   454cc:	2f2a 0010      	movel %a2@(16),%sp@-                              	<== NOT EXECUTED
   454d0:	4eb9 0004 6e90 	jsr 46e90 <_Thread_Handler_initialization>        	<== NOT EXECUTED
  );
#endif

/* MANAGERS */

  _RTEMS_API_Initialize( configuration_table );
   454d6:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   454d8:	4eb9 0004 564c 	jsr 4564c <_RTEMS_API_Initialize>                 	<== NOT EXECUTED

  _Extension_Manager_initialization( configuration_table->maximum_extensions );
   454de:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   454e2:	4eb9 0004 5540 	jsr 45540 <_Extension_Manager_initialization>     	<== NOT EXECUTED

  _IO_Manager_initialization(
   454e8:	2f2a 002a      	movel %a2@(42),%sp@-                              	<== NOT EXECUTED
   454ec:	2f2a 002e      	movel %a2@(46),%sp@-                              	<== NOT EXECUTED
   454f0:	2f2a 0032      	movel %a2@(50),%sp@-                              	<== NOT EXECUTED
   454f4:	4eb9 0004 55ba 	jsr 455ba <_IO_Manager_initialization>            	<== NOT EXECUTED
  _Thread_Create_idle();

  /*
   *  Scheduling can properly occur now as long as we avoid dispatching.
   */
}
   454fa:	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();
   454fe:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED

  /*
   *  Scheduling can properly occur now as long as we avoid dispatching.
   */
}
   45504:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   45506:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45508:	23c0 0005 6e36 	movel %d0,56e36 <_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();
   4550e:	4ef9 0004 6a0c 	jmp 46a0c <_Thread_Create_idle>                   	<== NOT EXECUTED

000453e0 <rtems_initialize_device_drivers>:
  _API_extensions_Run_predriver();

}

void rtems_initialize_device_drivers(void)
{
   453e0:	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();
   453e4:	4eb9 0004 5584 	jsr 45584 <_IO_Initialize_all_drivers>            	<== NOT EXECUTED
   *
   *  The API extensions are supposed to create user initialization tasks.
   */

  _API_extensions_Run_postdriver();
}
   453ea:	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();
   453ec:	4ef9 0004 572a 	jmp 4572a <_API_extensions_Run_postdriver>        	<== NOT EXECUTED

000453cc <rtems_initialize_start_multitasking>:

  _API_extensions_Run_postdriver();
}

void rtems_initialize_start_multitasking(void)
{
   453cc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   ******                 APPLICATION RUNS HERE                 ******
   ******            RETURNS WHEN SYSTEM IS SHUT DOWN           ******
   *******************************************************************
   *******************************************************************
   *******************************************************************/
}
   453d0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   453d2:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   453d4:	23c0 0005 6e36 	movel %d0,56e36 <_System_state_Current>           	<== NOT EXECUTED
void rtems_initialize_start_multitasking(void)
{

  _System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING );

  _Thread_Start_multitasking();
   453da:	4ef9 0004 7688 	jmp 47688 <_Thread_Start_multitasking>            	<== NOT EXECUTED

00044bcc <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
)
{
   44bcc:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   44bd0:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   44bd4:	206e 000c      	moveal %fp@(12),%a0                               	<== NOT EXECUTED
   44bd8:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
  if ( !_ISR_Is_vector_number_valid( vector ) )
   44bdc:	b1fc 0000 00ff 	cmpal #255,%a0                                    	<== NOT EXECUTED
   44be2:	6304           	blss 44be8 <rtems_interrupt_catch+0x1c>           	<== NOT EXECUTED
   44be4:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   44be6:	6020           	bras 44c08 <rtems_interrupt_catch+0x3c>           	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) )
   44be8:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   44bea:	671a           	beqs 44c06 <rtems_interrupt_catch+0x3a>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) )
   44bec:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   44bee:	6716           	beqs 44c06 <rtems_interrupt_catch+0x3a>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _ISR_Install_vector(
   44bf0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   44bf2:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   44bf4:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   44bf6:	4eb9 0004 7faa 	jsr 47faa <_CPU_ISR_install_vector>               	<== NOT EXECUTED
   44bfc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   44c02:	4280           	clrl %d0                                          	<== NOT EXECUTED
   44c04:	6002           	bras 44c08 <rtems_interrupt_catch+0x3c>           	<== NOT EXECUTED
    vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler );

  return RTEMS_SUCCESSFUL;
   44c06:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
}
   44c08:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44c0a:	4e75           	rts

0004560c <rtems_interrupt_disable>:
 */

#undef rtems_interrupt_disable

rtems_interrupt_level rtems_interrupt_disable( void )
{
   4560c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  rtems_interrupt_level previous_level;

  _ISR_Disable( previous_level );
   45610:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   45616:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   45618:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4561a:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  return previous_level;
}
   4561c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4561e:	4e75           	rts

00045620 <rtems_interrupt_enable>:
#undef rtems_interrupt_enable

void rtems_interrupt_enable(
  rtems_interrupt_level previous_level
)
{
   45620:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _ISR_Enable( previous_level );
   45624:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   45628:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
}
   4562a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4562c:	4e75           	rts

0004562e <rtems_interrupt_flash>:
#undef rtems_interrupt_flash

void rtems_interrupt_flash(
  rtems_interrupt_level previous_level
)
{
   4562e:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  _ISR_Flash( previous_level );
   45632:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   45638:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4563c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4563e:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   45640:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
}
   45642:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45644:	4e75           	rts

00045646 <rtems_interrupt_is_in_progress>:

#undef rtems_interrupt_is_in_progress

bool rtems_interrupt_is_in_progress( void )
{
  return _ISR_Is_in_progress();
   45646:	2039 0005 8d42 	movel 58d42 <_ISR_Nest_level>,%d0                 	<== NOT EXECUTED
 */

#undef rtems_interrupt_is_in_progress

bool rtems_interrupt_is_in_progress( void )
{
   4564c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _ISR_Is_in_progress();
   45650:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45652:	56c0           	sne %d0                                           	<== NOT EXECUTED
}
   45654:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45656:	4480           	negl %d0                                          	<== NOT EXECUTED
   45658:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004a8d8 <rtems_io_close>:
rtems_status_code rtems_io_close(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4a8d8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a8dc:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a8de:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4a8e2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4a8e4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4a8e8:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4a8ec:	b4b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4a8f2:	6504           	bcss 4a8f8 <rtems_io_close+0x20>                  	<== NOT EXECUTED
   4a8f4:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4a8f6:	602c           	bras 4a924 <rtems_io_close+0x4c>                  	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].close_entry;
   4a8f8:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a8fa:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4a8fc:	2079 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4a902:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4a904:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4a906:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4a908:	2030 1808      	movel %a0@(00000008,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4a90c:	6716           	beqs 4a924 <rtems_io_close+0x4c>                  	<== NOT EXECUTED
   4a90e:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4a912:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4a914:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4a918:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4a91c:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a91e:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4a920:	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;
   4a922:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   4a924:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a926:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4a928:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a92a:	4e75           	rts

0004a92c <rtems_io_control>:
rtems_status_code rtems_io_control(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4a92c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a930:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a932:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4a936:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4a938:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4a93c:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4a940:	b4b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4a946:	6504           	bcss 4a94c <rtems_io_control+0x20>                	<== NOT EXECUTED
   4a948:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4a94a:	602c           	bras 4a978 <rtems_io_control+0x4c>                	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].control_entry;
   4a94c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a94e:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4a950:	2079 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4a956:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4a958:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4a95a:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4a95c:	2030 1814      	movel %a0@(00000014,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4a960:	6716           	beqs 4a978 <rtems_io_control+0x4c>                	<== NOT EXECUTED
   4a962:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4a966:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4a968:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4a96c:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4a970:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a972:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4a974:	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;
   4a976:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   4a978:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a97a:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4a97c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a97e:	4e75           	rts

000499e4 <rtems_io_initialize>:
rtems_status_code rtems_io_initialize(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   499e4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   499e8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   499ea:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   499ee:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   499f2:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   499f6:	b2b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d1            	<== NOT EXECUTED
   499fc:	6504           	bcss 49a02 <rtems_io_initialize+0x1e>             	<== NOT EXECUTED
   499fe:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   49a00:	602a           	bras 49a2c <rtems_io_initialize+0x48>             	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].initialization_entry;
   49a02:	2079 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   49a08:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   49a0a:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   49a0c:	91c0           	subal %d0,%a0                                     	<== NOT EXECUTED
   49a0e:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   49a10:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   49a12:	2030 0800      	movel %a0@(00000000,%d0:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   49a16:	6714           	beqs 49a2c <rtems_io_initialize+0x48>             	<== NOT EXECUTED
   49a18:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   49a1c:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   49a1e:	2d42 000c      	movel %d2,%fp@(12)                                	<== NOT EXECUTED
   49a22:	2d41 0008      	movel %d1,%fp@(8)                                 	<== NOT EXECUTED
}
   49a26:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   49a28:	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;
   49a2a:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   49a2c:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   49a2e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   49a30:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004a980 <rtems_io_open>:
rtems_status_code rtems_io_open(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4a980:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a984:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a986:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4a98a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4a98c:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4a990:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4a994:	b4b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4a99a:	6504           	bcss 4a9a0 <rtems_io_open+0x20>                   	<== NOT EXECUTED
   4a99c:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4a99e:	602c           	bras 4a9cc <rtems_io_open+0x4c>                   	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].open_entry;
   4a9a0:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a9a2:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4a9a4:	2079 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4a9aa:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4a9ac:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4a9ae:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4a9b0:	2030 1804      	movel %a0@(00000004,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4a9b4:	6716           	beqs 4a9cc <rtems_io_open+0x4c>                   	<== NOT EXECUTED
   4a9b6:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4a9ba:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4a9bc:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4a9c0:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4a9c4:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a9c6:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4a9c8:	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;
   4a9ca:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   4a9cc:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4a9ce:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4a9d0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a9d2:	4e75           	rts

0004a9d4 <rtems_io_read>:
rtems_status_code rtems_io_read(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4a9d4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4a9d8:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4a9da:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4a9de:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4a9e0:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4a9e4:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4a9e8:	b4b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4a9ee:	6504           	bcss 4a9f4 <rtems_io_read+0x20>                   	<== NOT EXECUTED
   4a9f0:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4a9f2:	602c           	bras 4aa20 <rtems_io_read+0x4c>                   	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].read_entry;
   4a9f4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4a9f6:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4a9f8:	2079 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4a9fe:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4aa00:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4aa02:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4aa04:	2030 180c      	movel %a0@(0000000c,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4aa08:	6716           	beqs 4aa20 <rtems_io_read+0x4c>                   	<== NOT EXECUTED
   4aa0a:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4aa0e:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4aa10:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4aa14:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4aa18:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4aa1a:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4aa1c:	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;
   4aa1e:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   4aa20:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4aa22:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4aa24:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4aa26:	4e75           	rts

000461c8 <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
)
{
   461c8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   461cc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   461ce:	226e 000c      	moveal %fp@(12),%a1                               	<== NOT EXECUTED
   461d2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   461d4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   461d8:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED

  /*
   *  Validate the pointer data and contents passed in
   */
  if ( !driver_table )
   461dc:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   461de:	6700 00aa      	beqw 4628a <rtems_io_register_driver+0xc2>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !registered_major )
   461e2:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   461e4:	6700 00a4      	beqw 4628a <rtems_io_register_driver+0xc2>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !driver_table->initialization_entry && !driver_table->open_entry )
   461e8:	4a91           	tstl %a1@                                         	<== NOT EXECUTED
   461ea:	6608           	bnes 461f4 <rtems_io_register_driver+0x2c>        	<== NOT EXECUTED
   461ec:	4aa9 0004      	tstl %a1@(4)                                      	<== NOT EXECUTED
   461f0:	6700 0098      	beqw 4628a <rtems_io_register_driver+0xc2>        	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  *registered_major = 0;
   461f4:	4292           	clrl %a2@                                         	<== NOT EXECUTED

  /*
   *  The requested major number is higher than what is configured.
   */
  if ( major >= _IO_Number_of_drivers )
   461f6:	2239 0005 8eba 	movel 58eba <_IO_Number_of_drivers>,%d1           	<== NOT EXECUTED
   461fc:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   461fe:	6206           	bhis 46206 <rtems_io_register_driver+0x3e>        	<== NOT EXECUTED
   46200:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   46202:	6000 008c      	braw 46290 <rtems_io_register_driver+0xc8>        	<== NOT EXECUTED
  /*
   * Test for initialise/open being present to indicate the driver slot is
   * in use.
   */

  if ( major == 0 ) {
   46206:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   46208:	6632           	bnes 4623c <rtems_io_register_driver+0x74>        	<== NOT EXECUTED
    bool found = false;
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
   4620a:	2079 0005 8ebe 	moveal 58ebe <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   46210:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   46212:	2401           	movel %d1,%d2                                     	<== NOT EXECUTED
   46214:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   46216:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   46218:	91c1           	subal %d1,%a0                                     	<== NOT EXECUTED
   4621a:	5382           	subql #1,%d2                                      	<== NOT EXECUTED
   4621c:	41f0 08e8      	lea %a0@(ffffffe8,%d0:l),%a0                      	<== NOT EXECUTED
   46220:	6012           	bras 46234 <rtems_io_register_driver+0x6c>        	<== NOT EXECUTED
      if ( !_IO_Driver_address_table[major].initialization_entry &&
   46222:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   46224:	6606           	bnes 4622c <rtems_io_register_driver+0x64>        	<== NOT EXECUTED
   46226:	4aa8 0004      	tstl %a0@(4)                                      	<== NOT EXECUTED
   4622a:	6710           	beqs 4623c <rtems_io_register_driver+0x74>        	<== NOT EXECUTED
   * in use.
   */

  if ( major == 0 ) {
    bool found = false;
    for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) {
   4622c:	5382           	subql #1,%d2                                      	<== NOT EXECUTED
   4622e:	d1fc ffff ffe8 	addal #-24,%a0                                    	<== NOT EXECUTED
   46234:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   46236:	66ea           	bnes 46222 <rtems_io_register_driver+0x5a>        	<== NOT EXECUTED
   46238:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4623a:	6054           	bras 46290 <rtems_io_register_driver+0xc8>        	<== NOT EXECUTED

    if ( !found )
      return RTEMS_TOO_MANY;
  }

  if ( _IO_Driver_address_table[major].initialization_entry ||
   4623c:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4623e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   46240:	2079 0005 8ebe 	moveal 58ebe <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   46246:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   46248:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   4624a:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   4624c:	d1c0           	addal %d0,%a0                                     	<== NOT EXECUTED
   4624e:	4a90           	tstl %a0@                                         	<== NOT EXECUTED
   46250:	663c           	bnes 4628e <rtems_io_register_driver+0xc6>        	<== NOT EXECUTED
   46252:	4aa8 0004      	tstl %a0@(4)                                      	<== NOT EXECUTED
   46256:	6636           	bnes 4628e <rtems_io_register_driver+0xc6>        	<== NOT EXECUTED
       _IO_Driver_address_table[major].open_entry )
    return RTEMS_RESOURCE_IN_USE;


  _IO_Driver_address_table[major] = *driver_table;
   46258:	4878 0018      	pea 18 <OPER2+0x4>                                	<== NOT EXECUTED
   4625c:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   4625e:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   46260:	4eb9 0004 beb0 	jsr 4beb0 <memcpy>                                	<== NOT EXECUTED
  *registered_major               = major;
   46266:	2482           	movel %d2,%a2@                                    	<== NOT EXECUTED

  return rtems_io_initialize( major, 0, NULL );
}
   46268:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   4626c:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   46270:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   46274:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4627a:	42ae 0010      	clrl %fp@(16)                                     	<== NOT EXECUTED
   4627e:	42ae 000c      	clrl %fp@(12)                                     	<== NOT EXECUTED
}
   46282:	4e5e           	unlk %fp                                          	<== NOT EXECUTED


  _IO_Driver_address_table[major] = *driver_table;
  *registered_major               = major;

  return rtems_io_initialize( major, 0, NULL );
   46284:	4ef9 0004 6008 	jmp 46008 <rtems_io_initialize>                   	<== NOT EXECUTED
   4628a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4628c:	6002           	bras 46290 <rtems_io_register_driver+0xc8>        	<== NOT EXECUTED
   4628e:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
}
   46290:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46294:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46298:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4629a:	4e75           	rts

0004629c <rtems_io_unregister_driver>:
 */

rtems_status_code rtems_io_unregister_driver(
  rtems_device_major_number major
)
{
   4629c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   462a0:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
  if ( major < _IO_Number_of_drivers ) {
   462a4:	b2b9 0005 8eba 	cmpl 58eba <_IO_Number_of_drivers>,%d1            	<== NOT EXECUTED
   462aa:	6504           	bcss 462b0 <rtems_io_unregister_driver+0x14>      	<== NOT EXECUTED
   462ac:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
   462ae:	6024           	bras 462d4 <rtems_io_unregister_driver+0x38>      	<== NOT EXECUTED
    memset(
   462b0:	4878 0018      	pea 18 <OPER2+0x4>                                	<== NOT EXECUTED
   462b4:	2001           	movel %d1,%d0                                     	<== NOT EXECUTED
   462b6:	e789           	lsll #3,%d1                                       	<== NOT EXECUTED
   462b8:	eb88           	lsll #5,%d0                                       	<== NOT EXECUTED
   462ba:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   462bc:	d0b9 0005 8ebe 	addl 58ebe <_IO_Driver_address_table>,%d0         	<== NOT EXECUTED
   462c2:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   462c4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   462c6:	4eb9 0004 bf20 	jsr 4bf20 <memset>                                	<== NOT EXECUTED
   462cc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   462d2:	4280           	clrl %d0                                          	<== NOT EXECUTED
      sizeof( rtems_driver_address_table )
    );
    return RTEMS_SUCCESSFUL;
  }
  return RTEMS_UNSATISFIED;
}
   462d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   462d6:	4e75           	rts

0004aa28 <rtems_io_write>:
rtems_status_code rtems_io_write(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *argument
)
{
   4aa28:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   4aa2c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4aa2e:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4aa32:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4aa34:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4aa38:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  rtems_device_driver_entry callout;

  if ( major >= _IO_Number_of_drivers )
   4aa3c:	b4b9 0005 6f1e 	cmpl 56f1e <_IO_Number_of_drivers>,%d2            	<== NOT EXECUTED
   4aa42:	6504           	bcss 4aa48 <rtems_io_write+0x20>                  	<== NOT EXECUTED
   4aa44:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4aa46:	602c           	bras 4aa74 <rtems_io_write+0x4c>                  	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  callout = _IO_Driver_address_table[major].write_entry;
   4aa48:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4aa4a:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4aa4c:	2079 0005 6f22 	moveal 56f22 <_IO_Driver_address_table>,%a0       	<== NOT EXECUTED
   4aa52:	e788           	lsll #3,%d0                                       	<== NOT EXECUTED
   4aa54:	eb89           	lsll #5,%d1                                       	<== NOT EXECUTED
   4aa56:	9280           	subl %d0,%d1                                      	<== NOT EXECUTED
   4aa58:	2030 1810      	movel %a0@(00000010,%d1:l),%d0                    	<== NOT EXECUTED
  return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL;
   4aa5c:	6716           	beqs 4aa74 <rtems_io_write+0x4c>                  	<== NOT EXECUTED
   4aa5e:	2d49 0010      	movel %a1,%fp@(16)                                	<== NOT EXECUTED
   4aa62:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4aa64:	2d43 000c      	movel %d3,%fp@(12)                                	<== NOT EXECUTED
   4aa68:	2d42 0008      	movel %d2,%fp@(8)                                 	<== NOT EXECUTED
}
   4aa6c:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4aa6e:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4aa70:	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;
   4aa72:	4ed1           	jmp %a1@                                          	<== NOT EXECUTED
}
   4aa74:	241f           	movel %sp@+,%d2                                   	<== NOT EXECUTED
   4aa76:	261f           	movel %sp@+,%d3                                   	<== NOT EXECUTED
   4aa78:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4aa7a:	4e75           	rts

000470d0 <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)
{
   470d0:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   470d4:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   470d8:	286e 0008      	moveal %fp@(8),%a4                                	<== NOT EXECUTED
  uint32_t             i;
  uint32_t             api_index;
  Thread_Control      *the_thread;
  Objects_Information *information;

  if ( !routine )
   470dc:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   470de:	673e           	beqs 4711e <rtems_iterate_over_all_threads+0x4e>  	<== NOT EXECUTED
    return;
   470e0:	47f9 0006 0f88 	lea 60f88 <_Objects_Information_table+0x4>,%a3    	<== NOT EXECUTED

  for ( api_index = 1 ;
        api_index <= OBJECTS_APIS_LAST ;
        api_index++ ) {
    if ( !_Objects_Information_table[ api_index ] )
   470e6:	2053           	moveal %a3@,%a0                                   	<== NOT EXECUTED
   470e8:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   470ea:	6728           	beqs 47114 <rtems_iterate_over_all_threads+0x44>  	<== NOT EXECUTED
      continue;
    information = _Objects_Information_table[ api_index ][ 1 ];
   470ec:	2468 0004      	moveal %a0@(4),%a2                                	<== NOT EXECUTED
    if ( information ) {
   470f0:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   470f2:	6720           	beqs 47114 <rtems_iterate_over_all_threads+0x44>  	<== NOT EXECUTED
   470f4:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   470f6:	6012           	bras 4710a <rtems_iterate_over_all_threads+0x3a>  	<== NOT EXECUTED
      for ( i=1 ; i <= information->maximum ; i++ ) {
        the_thread = (Thread_Control *)information->local_table[ i ];
   470f8:	206a 001a      	moveal %a2@(26),%a0                               	<== NOT EXECUTED
   470fc:	2030 2c00      	movel %a0@(00000000,%d2:l:4),%d0                  	<== NOT EXECUTED

        if ( !the_thread )
   47100:	6706           	beqs 47108 <rtems_iterate_over_all_threads+0x38>  	<== NOT EXECUTED
          continue;

        (*routine)(the_thread);
   47102:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   47104:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   47106:	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++ ) {
   47108:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   4710a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4710c:	302a 000e      	movew %a2@(14),%d0                                	<== NOT EXECUTED
   47110:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   47112:	64e4           	bccs 470f8 <rtems_iterate_over_all_threads+0x28>  	<== NOT EXECUTED
   47114:	588b           	addql #4,%a3                                      	<== NOT EXECUTED

  if ( !routine )
    return;

  for ( api_index = 1 ;
        api_index <= OBJECTS_APIS_LAST ;
   47116:	b7fc 0006 0f98 	cmpal #397208,%a3                                 	<== NOT EXECUTED
   4711c:	66c8           	bnes 470e6 <rtems_iterate_over_all_threads+0x16>  	<== NOT EXECUTED
        (*routine)(the_thread);
      }
    }
  }

}
   4711e:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   47124:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   47126:	4e75           	rts

0004cfe4 <rtems_message_queue_broadcast>:
  Objects_Id            id,
  const void           *buffer,
  size_t                size,
  uint32_t             *count
)
{
   4cfe4:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4cfe8:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   4cfec:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   4cff0:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4cff4:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;
  CORE_message_queue_Status       core_status;

  if ( !buffer )
   4cff8:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4cffa:	6756           	beqs 4d052 <rtems_message_queue_broadcast+0x6e>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !count )
   4cffc:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4cffe:	6752           	beqs 4d052 <rtems_message_queue_broadcast+0x6e>   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   4d000:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d004:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4d006:	4879 0006 ca76 	pea 6ca76 <_Message_queue_Information>            	<== NOT EXECUTED
   4d00c:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4d012:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d018:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4d01a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d01e:	6704           	beqs 4d024 <rtems_message_queue_broadcast+0x40>   	<== NOT EXECUTED
   4d020:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d022:	6030           	bras 4d054 <rtems_message_queue_broadcast+0x70>   	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      core_status = _CORE_message_queue_Broadcast(
   4d024:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d026:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4d028:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4d02a:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4d02e:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4d030:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   4d034:	4eb9 0005 00b8 	jsr 500b8 <_CORE_message_queue_Broadcast>         	<== NOT EXECUTED
   4d03a:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
                        NULL,
                      #endif
                      count
                    );

      _Thread_Enable_dispatch();
   4d03c:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return
   4d042:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d044:	4eb9 0004 d380 	jsr 4d380 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED
   4d04a:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   4d050:	6002           	bras 4d054 <rtems_message_queue_broadcast+0x70>   	<== NOT EXECUTED
   4d052:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   4d054:	4cee 001c fff0 	moveml %fp@(-16),%d2-%d4                          	<== NOT EXECUTED
   4d05a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d05c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d060 <rtems_message_queue_create>:
  uint32_t            count,
  size_t              max_message_size,
  rtems_attribute     attribute_set,
  Objects_Id         *id
)
{
   4d060:	4e56 ffe0      	linkw %fp,#-32                                    	<== NOT EXECUTED
   4d064:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   4d068:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   4d06c:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4d070:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   4d074:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
   4d078:	286e 0018      	moveal %fp@(24),%a4                               	<== NOT EXECUTED
  CORE_message_queue_Attributes   the_msgq_attributes;
#if defined(RTEMS_MULTIPROCESSING)
  bool                            is_global;
#endif

  if ( !rtems_is_name_valid( name ) )
   4d07c:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   4d07e:	6606           	bnes 4d086 <rtems_message_queue_create+0x26>      	<== NOT EXECUTED
   4d080:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4d082:	6000 00a6      	braw 4d12a <rtems_message_queue_create+0xca>      	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   4d086:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   4d088:	6606           	bnes 4d090 <rtems_message_queue_create+0x30>      	<== NOT EXECUTED
   4d08a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d08c:	6000 009c      	braw 4d12a <rtems_message_queue_create+0xca>      	<== NOT EXECUTED
  if ( (is_global = _Attributes_Is_global( attribute_set ) ) &&
       !_System_state_Is_multiprocessing )
    return RTEMS_MP_NOT_CONFIGURED;
#endif

  if ( count == 0 )
   4d090:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4d092:	6606           	bnes 4d09a <rtems_message_queue_create+0x3a>      	<== NOT EXECUTED
   4d094:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4d096:	6000 0092      	braw 4d12a <rtems_message_queue_create+0xca>      	<== NOT EXECUTED
      return RTEMS_INVALID_NUMBER;

  if ( max_message_size == 0 )
   4d09a:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4d09c:	6606           	bnes 4d0a4 <rtems_message_queue_create+0x44>      	<== NOT EXECUTED
   4d09e:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
   4d0a0:	6000 0088      	braw 4d12a <rtems_message_queue_create+0xca>      	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4d0a4:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4d0aa:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4d0ac:	23c0 0006 c830 	movel %d0,6c830 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
#endif
#endif

  _Thread_Disable_dispatch();              /* protects object pointer */

  the_message_queue = _Message_queue_Allocate();
   4d0b2:	4eb9 0005 4c10 	jsr 54c10 <_Message_queue_Allocate>               	<== NOT EXECUTED
   4d0b8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  if ( !the_message_queue ) {
   4d0ba:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4d0bc:	660a           	bnes 4d0c8 <rtems_message_queue_create+0x68>      	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   4d0be:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4d0c4:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4d0c6:	6062           	bras 4d12a <rtems_message_queue_create+0xca>      	<== 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;
   4d0c8:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   4d0ca:	56c0           	sne %d0                                           	<== NOT EXECUTED
   4d0cc:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4d0ce:	204e           	moveal %fp,%a0                                    	<== NOT EXECUTED
   4d0d0:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4d0d2:	2100           	movel %d0,%a0@-                                   	<== NOT EXECUTED
   4d0d4:	47f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_message_queue->attribute_set = attribute_set;
   4d0da:	2542 0010      	movel %d2,%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(
   4d0de:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4d0e0:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4d0e2:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   4d0e4:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   4d0e8:	4eb9 0005 01ec 	jsr 501ec <_CORE_message_queue_Initialize>        	<== NOT EXECUTED
   4d0ee:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4d0f4:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4d0f6:	6616           	bnes 4d10e <rtems_message_queue_create+0xae>      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Message_queue_Free (
  Message_queue_Control *the_message_queue
)
{
  _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
   4d0f8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4d0fa:	4879 0006 ca76 	pea 6ca76 <_Message_queue_Information>            	<== NOT EXECUTED
   4d100:	4eb9 0005 1578 	jsr 51578 <_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();
   4d106:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d108:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4d10a:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
   4d10c:	601c           	bras 4d12a <rtems_message_queue_create+0xca>      	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4d10e:	2545 000c      	movel %d5,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4d112:	2079 0006 ca90 	moveal 6ca90 <_Message_queue_Information+0x1a>,%a0	<== NOT EXECUTED
   4d118:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4d11a:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
    &_Message_queue_Information,
    &the_message_queue->Object,
    (Objects_Name) name
  );

  *id = the_message_queue->Object.id;
   4d11e:	28aa 0008      	movel %a2@(8),%a4@                                	<== NOT EXECUTED
   4d122:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
      name,
      0
    );
#endif

  _Thread_Enable_dispatch();
   4d126:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d128:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4d12a:	4cee 1c3c ffe0 	moveml %fp@(-32),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4d130:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d132:	4e75           	rts

0004ee10 <rtems_message_queue_delete>:
 */

rtems_status_code rtems_message_queue_delete(
  Objects_Id id
)
{
   4ee10:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4ee14:	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 *)
   4ee16:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4ee1a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ee1e:	4879 0006 2c32 	pea 62c32 <_Message_queue_Information>            	<== NOT EXECUTED
   4ee24:	4eb9 0004 a028 	jsr 4a028 <_Objects_Get>                          	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4ee2a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4ee30:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4ee32:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4ee36:	6704           	beqs 4ee3c <rtems_message_queue_delete+0x2c>      	<== NOT EXECUTED
   4ee38:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4ee3a:	603a           	bras 4ee76 <rtems_message_queue_delete+0x66>      	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Message_queue_Information,
   4ee3c:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4ee3e:	4879 0006 2c32 	pea 62c32 <_Message_queue_Information>            	<== NOT EXECUTED
   4ee44:	4eb9 0004 9c50 	jsr 49c50 <_Objects_Close>                        	<== NOT EXECUTED
                      &the_message_queue->Object );

      _CORE_message_queue_Close(
   4ee4a:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   4ee4e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ee50:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   4ee54:	4eb9 0004 f414 	jsr 4f414 <_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 );
   4ee5a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4ee5c:	4879 0006 2c32 	pea 62c32 <_Message_queue_Information>            	<== NOT EXECUTED
   4ee62:	4eb9 0004 9ec8 	jsr 49ec8 <_Objects_Free>                         	<== NOT EXECUTED
          0,                                 /* Not used */
          0
        );
      }
#endif
      _Thread_Enable_dispatch();
   4ee68:	4eb9 0004 a87a 	jsr 4a87a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4ee6e:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   4ee74:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4ee76:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4ee7a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ee7c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d1a4 <rtems_message_queue_flush>:

rtems_status_code rtems_message_queue_flush(
  Objects_Id  id,
  uint32_t   *count
)
{
   4d1a4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4d1a8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4d1aa:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  if ( !count )
   4d1ae:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4d1b0:	6604           	bnes 4d1b6 <rtems_message_queue_flush+0x12>       	<== NOT EXECUTED
   4d1b2:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d1b4:	603c           	bras 4d1f2 <rtems_message_queue_flush+0x4e>       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   4d1b6:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d1ba:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d1be:	4879 0006 ca76 	pea 6ca76 <_Message_queue_Information>            	<== NOT EXECUTED
   4d1c4:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4d1ca:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d1d0:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4d1d2:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d1d6:	6704           	beqs 4d1dc <rtems_message_queue_flush+0x38>       	<== NOT EXECUTED
   4d1d8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d1da:	6016           	bras 4d1f2 <rtems_message_queue_flush+0x4e>       	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
   4d1dc:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   4d1e0:	4eb9 0005 0170 	jsr 50170 <_CORE_message_queue_Flush>             	<== NOT EXECUTED
   4d1e6:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   4d1e8:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4d1ee:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4d1f0:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d1f2:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4d1f6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d1f8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d1fc <rtems_message_queue_get_number_pending>:

rtems_status_code rtems_message_queue_get_number_pending(
  Objects_Id  id,
  uint32_t   *count
)
{
   4d1fc:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4d200:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4d202:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;

  if ( !count )
   4d206:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4d208:	6604           	bnes 4d20e <rtems_message_queue_get_number_pending+0x12>	<== NOT EXECUTED
   4d20a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d20c:	6032           	bras 4d240 <rtems_message_queue_get_number_pending+0x44>	<== NOT EXECUTED
   4d20e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d212:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d216:	4879 0006 ca76 	pea 6ca76 <_Message_queue_Information>            	<== NOT EXECUTED
   4d21c:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4d222:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d228:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4d22a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d22e:	6704           	beqs 4d234 <rtems_message_queue_get_number_pending+0x38>	<== NOT EXECUTED
   4d230:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d232:	600c           	bras 4d240 <rtems_message_queue_get_number_pending+0x44>	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *count = the_message_queue->message_queue.number_of_pending_messages;
   4d234:	24a8 005c      	movel %a0@(92),%a2@                               	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   4d238:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4d23e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d240:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4d244:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d246:	4e75           	rts

0004ee80 <rtems_message_queue_ident>:
rtems_status_code rtems_message_queue_ident(
  rtems_name    name,
  uint32_t      node,
  Objects_Id   *id
)
{
   4ee80:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   4ee84:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4ee88:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4ee8c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ee90:	4879 0006 2c32 	pea 62c32 <_Message_queue_Information>            	<== NOT EXECUTED
   4ee96:	4eb9 0004 a18c 	jsr 4a18c <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4ee9c:	41f9 0005 de34 	lea 5de34 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    node,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   4eea2:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4eea6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4eea8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004eeac <rtems_message_queue_receive>:
  void                 *buffer,
  size_t               *size,
  rtems_option          option_set,
  rtems_interval        timeout
)
{
   4eeac:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4eeb0:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   4eeb4:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4eeb8:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
   4eebc:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
  register Message_queue_Control *the_message_queue;
  Objects_Locations               location;
  bool                            wait;

  if ( !buffer )
   4eec0:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4eec2:	6766           	beqs 4ef2a <rtems_message_queue_receive+0x7e>     	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !size )
   4eec4:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4eec6:	6762           	beqs 4ef2a <rtems_message_queue_receive+0x7e>     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Message_queue_Control *)
   4eec8:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4eecc:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4eed0:	4879 0006 2c32 	pea 62c32 <_Message_queue_Information>            	<== NOT EXECUTED
   4eed6:	4eb9 0004 a028 	jsr 4a028 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4eedc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4eee2:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4eee4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4eee8:	6704           	beqs 4eeee <rtems_message_queue_receive+0x42>     	<== NOT EXECUTED
   4eeea:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4eeec:	603e           	bras 4ef2c <rtems_message_queue_receive+0x80>     	<== NOT EXECUTED
      if ( _Options_Is_no_wait( option_set ) )
        wait = false;
      else
        wait = true;

      _CORE_message_queue_Seize(
   4eeee:	2f2e 0018      	movel %fp@(24),%sp@-                              	<== NOT EXECUTED
   4eef2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4eef4:	b182           	eorl %d0,%d2                                      	<== NOT EXECUTED
   4eef6:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   4eef8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4eefa:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4eefc:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4eefe:	2f28 0008      	movel %a0@(8),%sp@-                               	<== NOT EXECUTED
   4ef02:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   4ef06:	4eb9 0004 f4b4 	jsr 4f4b4 <_CORE_message_queue_Seize>             	<== NOT EXECUTED
        buffer,
        size,
        wait,
        timeout
      );
      _Thread_Enable_dispatch();
   4ef0c:	4eb9 0004 a87a 	jsr 4a87a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return _Message_queue_Translate_core_message_queue_return_code(
   4ef12:	2079 0006 2a4a 	moveal 62a4a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   4ef18:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   4ef1c:	4eb9 0004 efb8 	jsr 4efb8 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED
   4ef22:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   4ef28:	6002           	bras 4ef2c <rtems_message_queue_receive+0x80>     	<== NOT EXECUTED
   4ef2a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4ef2c:	4cee 001c fff0 	moveml %fp@(-16),%d2-%d4                          	<== NOT EXECUTED
   4ef32:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4ef34:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004ef38 <rtems_message_queue_send>:
rtems_status_code rtems_message_queue_send(
  Objects_Id            id,
  const void           *buffer,
  size_t                size
)
{
   4ef38:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4ef3c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4ef3e:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4ef42:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4ef44:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;
  Objects_Locations                location;
  CORE_message_queue_Status        status;

  if ( !buffer )
   4ef48:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4ef4a:	6604           	bnes 4ef50 <rtems_message_queue_send+0x18>        	<== NOT EXECUTED
   4ef4c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4ef4e:	605a           	bras 4efaa <rtems_message_queue_send+0x72>        	<== NOT EXECUTED
   4ef50:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4ef54:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4ef56:	4879 0006 2c32 	pea 62c32 <_Message_queue_Information>            	<== NOT EXECUTED
   4ef5c:	4eb9 0004 a028 	jsr 4a028 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4ef62:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4ef68:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4ef6a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4ef6e:	6704           	beqs 4ef74 <rtems_message_queue_send+0x3c>        	<== NOT EXECUTED
   4ef70:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4ef72:	6036           	bras 4efaa <rtems_message_queue_send+0x72>        	<== NOT EXECUTED
  CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
  bool                                    wait,
  Watchdog_Interval                          timeout
)
{
  return _CORE_message_queue_Submit(
   4ef74:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ef76:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ef78:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   4ef7e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4ef80:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4ef82:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4ef86:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4ef88:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   4ef8c:	4eb9 0004 f5f4 	jsr 4f5f4 <_CORE_message_queue_Submit>            	<== NOT EXECUTED
        MESSAGE_QUEUE_MP_HANDLER,
        FALSE,   /* sender does not block */
        0        /* no timeout */
      );

      _Thread_Enable_dispatch();
   4ef92:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   4ef98:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4ef9a:	4eb9 0004 a87a 	jsr 4a87a <_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);
   4efa0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4efa2:	4eb9 0004 efb8 	jsr 4efb8 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED
   4efa8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   4efaa:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4efae:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   4efb2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4efb4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d398 <rtems_message_queue_urgent>:
rtems_status_code rtems_message_queue_urgent(
  Objects_Id            id,
  const void           *buffer,
  size_t                size
)
{
   4d398:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4d39c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4d39e:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4d3a2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d3a4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
  register Message_queue_Control  *the_message_queue;
  Objects_Locations                location;
  CORE_message_queue_Status        status;

  if ( !buffer )
   4d3a8:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4d3aa:	6604           	bnes 4d3b0 <rtems_message_queue_urgent+0x18>      	<== NOT EXECUTED
   4d3ac:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d3ae:	605a           	bras 4d40a <rtems_message_queue_urgent+0x72>      	<== NOT EXECUTED
   4d3b0:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d3b4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d3b6:	4879 0006 ca76 	pea 6ca76 <_Message_queue_Information>            	<== NOT EXECUTED
   4d3bc:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_message_queue = _Message_queue_Get( id, &location );
  switch ( location ) {
   4d3c2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d3c8:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4d3ca:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d3ce:	6704           	beqs 4d3d4 <rtems_message_queue_urgent+0x3c>      	<== NOT EXECUTED
   4d3d0:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d3d2:	6036           	bras 4d40a <rtems_message_queue_urgent+0x72>      	<== NOT EXECUTED
  CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
  bool                                    wait,
  Watchdog_Interval                          timeout
)
{
  return _CORE_message_queue_Submit(
   4d3d4:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4d3d6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4d3d8:	2f3c 8000 0000 	movel #-2147483648,%sp@-                          	<== NOT EXECUTED
   4d3de:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4d3e0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d3e2:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4d3e6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4d3e8:	4868 0014      	pea %a0@(20)                                      	<== NOT EXECUTED
   4d3ec:	4eb9 0005 03e8 	jsr 503e8 <_CORE_message_queue_Submit>            	<== NOT EXECUTED
        id,
        MESSAGE_QUEUE_MP_HANDLER,
        FALSE,   /* sender does not block */
        0        /* no timeout */
      );
      _Thread_Enable_dispatch();
   4d3f2:	dffc 0000 0020 	addal #32,%sp                                     	<== NOT EXECUTED
   4d3f8:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4d3fa:	4eb9 0005 1ef2 	jsr 51ef2 <_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);
   4d400:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d402:	4eb9 0004 d380 	jsr 4d380 <_Message_queue_Translate_core_message_queue_return_code>	<== NOT EXECUTED
   4d408:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d40a:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4d40e:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   4d412:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d414:	4e75           	rts                                               	<== NOT EXECUTED
	...

000460f4 <rtems_object_api_maximum_class>:
#include <rtems/rtems/types.h>

int rtems_object_api_maximum_class(
  uint32_t api
)
{
   460f4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_API_maximum_class(api);
}
   460f8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED

int rtems_object_api_maximum_class(
  uint32_t api
)
{
  return _Objects_API_maximum_class(api);
   460fa:	4ef9 0004 777c 	jmp 4777c <_Objects_API_maximum_class>            	<== NOT EXECUTED

00046100 <rtems_object_api_minimum_class>:
#include <rtems/rtems/types.h>

uint32_t rtems_object_api_minimum_class(
  uint32_t api
)
{
   46100:	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 )
   46104:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   46108:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4610a:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4610c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4610e:	55c0           	scs %d0                                           	<== NOT EXECUTED
   46110:	49c0           	extbl %d0                                         	<== NOT EXECUTED
  if ( _Objects_Is_api_valid( api ) )
    return 1;
  return -1;
}
   46112:	123c 0001      	moveb #1,%d1                                      	<== NOT EXECUTED
   46116:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46118:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4611a:	4e75           	rts

0004611c <rtems_object_get_api_class_name>:

const char *rtems_object_get_api_class_name(
  uint32_t the_api,
  uint32_t the_class
)
{
   4611c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46120:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   46124:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  const rtems_assoc_t *api_assoc;
  const rtems_assoc_t *class_assoc;

  if ( the_api == OBJECTS_INTERNAL_API )
   46126:	203c 0005 8a54 	movel #363092,%d0                                 	<== NOT EXECUTED
   4612c:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4612e:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   46130:	6712           	beqs 46144 <rtems_object_get_api_class_name+0x28> 	<== NOT EXECUTED
    api_assoc = rtems_object_api_internal_assoc;
  else if ( the_api == OBJECTS_CLASSIC_API )
   46132:	7402           	moveq #2,%d2                                      	<== NOT EXECUTED
   46134:	203c 0005 74c3 	movel #357571,%d0                                 	<== NOT EXECUTED
   4613a:	b481           	cmpl %d1,%d2                                      	<== NOT EXECUTED
   4613c:	6622           	bnes 46160 <rtems_object_get_api_class_name+0x44> 	<== NOT EXECUTED
   4613e:	203c 0005 8a6c 	movel #363116,%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 );
   46144:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   46148:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4614a:	4eb9 0004 a43c 	jsr 4a43c <rtems_assoc_ptr_by_local>              	<== NOT EXECUTED
   46150:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( class_assoc )
   46152:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46154:	203c 0005 74cb 	movel #357579,%d0                                 	<== NOT EXECUTED
   4615a:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   4615c:	6702           	beqs 46160 <rtems_object_get_api_class_name+0x44> 	<== NOT EXECUTED
    return class_assoc->name;
   4615e:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
  return "BAD CLASS";
}
   46160:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   46164:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46166:	4e75           	rts

00046168 <rtems_object_get_api_name>:
};

const char *rtems_object_get_api_name(
  uint32_t api
)
{
   46168:	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 );
   4616c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   46170:	4879 0005 8ae4 	pea 58ae4 <rtems_objects_api_assoc>               	<== NOT EXECUTED
   46176:	4eb9 0004 a43c 	jsr 4a43c <rtems_assoc_ptr_by_local>              	<== NOT EXECUTED
   4617c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  if ( api_assoc )
   4617e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46180:	203c 0005 74cb 	movel #357579,%d0                                 	<== NOT EXECUTED
   46186:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   46188:	6702           	beqs 4618c <rtems_object_get_api_name+0x24>       	<== NOT EXECUTED
    return api_assoc->name;
   4618a:	2010           	movel %a0@,%d0                                    	<== NOT EXECUTED
  return "BAD CLASS";
}
   4618c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4618e:	4e75           	rts

000461c8 <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
)
{
   461c8:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   461cc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   461ce:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   461d2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t             i;

  /*
   * Validate parameters and look up information structure.
   */
  if ( !info )
   461d4:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   461d6:	6604           	bnes 461dc <rtems_object_get_class_information+0x14>	<== NOT EXECUTED
   461d8:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   461da:	6052           	bras 4622e <rtems_object_get_class_information+0x66>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  obj_info = _Objects_Get_information( the_api, the_class );
   461dc:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   461e0:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   461e4:	4eb9 0004 7ae4 	jsr 47ae4 <_Objects_Get_information>              	<== NOT EXECUTED
  if ( !obj_info )
   461ea:	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 );
   461ec:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
  if ( !obj_info )
   461ee:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   461f0:	6604           	bnes 461f6 <rtems_object_get_class_information+0x2e>	<== NOT EXECUTED
   461f2:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   461f4:	6038           	bras 4622e <rtems_object_get_class_information+0x66>	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  /*
   * Return information about this object class to the user.
   */
  info->minimum_id  = obj_info->minimum_id;
   461f6:	24a9 0006      	movel %a1@(6),%a2@                                	<== NOT EXECUTED
  info->maximum_id  = obj_info->maximum_id;
  info->auto_extend = obj_info->auto_extend;
  info->maximum     = obj_info->maximum;
   461fa:	4282           	clrl %d2                                          	<== NOT EXECUTED
   461fc:	4281           	clrl %d1                                          	<== NOT EXECUTED
   461fe:	3429 000e      	movew %a1@(14),%d2                                	<== NOT EXECUTED
   46202:	7001           	moveq #1,%d0                                      	<== 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;
   46204:	2569 000a 0004 	movel %a1@(10),%a2@(4)                            	<== NOT EXECUTED
  info->auto_extend = obj_info->auto_extend;
  info->maximum     = obj_info->maximum;
   4620a:	2542 0008      	movel %d2,%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;
   4620e:	1569 0010 000c 	moveb %a1@(16),%a2@(12)                           	<== NOT EXECUTED
   46214:	600e           	bras 46224 <rtems_object_get_class_information+0x5c>	<== NOT EXECUTED
  info->maximum     = obj_info->maximum;

  for ( unallocated=0, i=1 ; i <= info->maximum ; i++ )
    if ( !obj_info->local_table[i] )
   46216:	2069 001a      	moveal %a1@(26),%a0                               	<== NOT EXECUTED
   4621a:	4ab0 0c00      	tstl %a0@(00000000,%d0:l:4)                       	<== NOT EXECUTED
   4621e:	6602           	bnes 46222 <rtems_object_get_class_information+0x5a>	<== NOT EXECUTED
      unallocated++;
   46220:	5281           	addql #1,%d1                                      	<== 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++ )
   46222:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   46224:	b480           	cmpl %d0,%d2                                      	<== NOT EXECUTED
   46226:	64ee           	bccs 46216 <rtems_object_get_class_information+0x4e>	<== NOT EXECUTED
    if ( !obj_info->local_table[i] )
      unallocated++;

  info->unallocated = unallocated;
   46228:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4622a:	2541 000e      	movel %d1,%a2@(14)                                	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   4622e:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   46232:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   46236:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46238:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045828 <rtems_object_get_classic_name>:

rtems_status_code rtems_object_get_classic_name(
  rtems_id      id,
  rtems_name   *name
)
{
   45828:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4582c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4582e:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;
  Objects_Name                      name_u;

  if ( !name )
   45832:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   45834:	6604           	bnes 4583a <rtems_object_get_classic_name+0x12>   	<== NOT EXECUTED
   45836:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   45838:	601e           	bras 45858 <rtems_object_get_classic_name+0x30>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  status = _Objects_Id_to_name( id, &name_u );
   4583a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4583e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45842:	4eb9 0004 71a0 	jsr 471a0 <_Objects_Id_to_name>                   	<== NOT EXECUTED

  *name = name_u.name_u32;
  return _Status_Object_name_errors_to_status[ status ];
   45848:	41f9 0005 6244 	lea 56244 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
   4584e:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   45852:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  if ( !name )
    return RTEMS_INVALID_ADDRESS;

  status = _Objects_Id_to_name( id, &name_u );

  *name = name_u.name_u32;
   45854:	24ae fffc      	movel %fp@(-4),%a2@                               	<== NOT EXECUTED
  return _Status_Object_name_errors_to_status[ status ];
}
   45858:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4585c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4585e:	4e75           	rts

0004f060 <rtems_object_get_name>:
char *rtems_object_get_name(
  Objects_Id     id,
  size_t         length,
  char          *name
)
{
   4f060:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_Get_name_as_string( id, length, name );
}
   4f064:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
  Objects_Id     id,
  size_t         length,
  char          *name
)
{
  return _Objects_Get_name_as_string( id, length, name );
   4f066:	4ef9 0004 faa0 	jmp 4faa0 <_Objects_Get_name_as_string>           	<== NOT EXECUTED

00046248 <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)
{
   46248:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return OBJECTS_ITRON_API;
}
   4624c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4624e:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   46250:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046254 <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)
{
   46254:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return OBJECTS_INTERNAL_API;
}
   46258:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4625a:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4625c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046260 <rtems_object_id_get_api>:

#undef rtems_object_id_get_api
uint32_t rtems_object_id_get_api(
  rtems_id id
)
{
   46260:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46264:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46266:	102e 0008      	moveb %fp@(8),%d0                                 	<== NOT EXECUTED
  return _Objects_Get_API( id );
}
   4626a:	7207           	moveq #7,%d1                                      	<== NOT EXECUTED
   4626c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4626e:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   46270:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046274 <rtems_object_id_get_class>:

#undef rtems_object_id_get_class
uint32_t rtems_object_id_get_class(
  rtems_id id
)
{
   46274:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   46278:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
  return _Objects_Get_class( id );
}
   4627c:	721b           	moveq #27,%d1                                     	<== NOT EXECUTED
   4627e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46280:	e2a8           	lsrl %d1,%d0                                      	<== NOT EXECUTED
   46282:	4e75           	rts

00046284 <rtems_object_id_get_index>:

#undef rtems_object_id_get_index
uint32_t rtems_object_id_get_index(
  rtems_id id
)
{
   46284:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_Get_index( id );
}
   46288:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4628a:	302e 000a      	movew %fp@(10),%d0                                	<== NOT EXECUTED
   4628e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46290:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046294 <rtems_object_id_get_node>:

#undef rtems_object_id_get_node
uint32_t rtems_object_id_get_node(
  rtems_id id
)
{
   46294:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  return _Objects_Get_node( id );
}
   46298:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4629a:	102e 0009      	moveb %fp@(9),%d0                                 	<== NOT EXECUTED
   4629e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   462a0:	4e75           	rts                                               	<== NOT EXECUTED
	...

000462a4 <rtems_object_set_name>:
 */
rtems_status_code rtems_object_set_name(
  rtems_id       id,
  const char    *name
)
{
   462a4:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   462a8:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
   462ac:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   462b0:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
  Objects_Information *information;
  Objects_Locations    location;
  Objects_Control     *the_object;
  Objects_Id           tmpId;

  if ( !name )
   462b4:	6604           	bnes 462ba <rtems_object_set_name+0x16>           	<== NOT EXECUTED
   462b6:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   462b8:	6058           	bras 46312 <rtems_object_set_name+0x6e>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
   462ba:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   462bc:	6704           	beqs 462c2 <rtems_object_set_name+0x1e>           	<== NOT EXECUTED
   462be:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   462c0:	600a           	bras 462cc <rtems_object_set_name+0x28>           	<== NOT EXECUTED
   462c2:	2079 0005 a27a 	moveal 5a27a <_Thread_Executing>,%a0              	<== NOT EXECUTED
   462c8:	2428 0008      	movel %a0@(8),%d2                                 	<== NOT EXECUTED

  information  = _Objects_Get_information_id( tmpId );
   462cc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   462ce:	4eb9 0004 7ab8 	jsr 47ab8 <_Objects_Get_information_id>           	<== NOT EXECUTED
  if ( !information )
   462d4:	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 );
   462d6:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
  if ( !information )
   462d8:	6736           	beqs 46310 <rtems_object_set_name+0x6c>           	<== NOT EXECUTED
    return RTEMS_INVALID_ID;

  the_object = _Objects_Get( information, tmpId, &location );
   462da:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   462de:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   462e0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   462e2:	4eb9 0004 7c80 	jsr 47c80 <_Objects_Get>                          	<== NOT EXECUTED
  switch ( location ) {
   462e8:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   462ee:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   462f2:	661c           	bnes 46310 <rtems_object_set_name+0x6c>           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Set_name( information, the_object, name );
   462f4:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   462f6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   462f8:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   462fa:	4eb9 0004 7e88 	jsr 47e88 <_Objects_Set_name>                     	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   46300:	4eb9 0004 8576 	jsr 48576 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   46306:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4630c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4630e:	6002           	bras 46312 <rtems_object_set_name+0x6e>           	<== NOT EXECUTED
      return RTEMS_SUCCESSFUL;
   46310:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46312:	4cee 001c fff0 	moveml %fp@(-16),%d2-%d4                          	<== NOT EXECUTED
   46318:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4631a:	4e75           	rts

0004d418 <rtems_partition_create>:
  uint32_t            length,
  uint32_t            buffer_size,
  rtems_attribute     attribute_set,
  Objects_Id         *id
)
{
   4d418:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4d41c:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   4d420:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   4d424:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4d428:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
   4d42c:	262e 0014      	movel %fp@(20),%d3                                	<== NOT EXECUTED
   4d430:	286e 001c      	moveal %fp@(28),%a4                               	<== NOT EXECUTED
  register Partition_Control *the_partition;

  if ( !rtems_is_name_valid( name ) )
   4d434:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   4d436:	6606           	bnes 4d43e <rtems_partition_create+0x26>          	<== NOT EXECUTED
   4d438:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4d43a:	6000 00b2      	braw 4d4ee <rtems_partition_create+0xd6>          	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !starting_address )
   4d43e:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4d440:	6700 00a6      	beqw 4d4e8 <rtems_partition_create+0xd0>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !id )
   4d444:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   4d446:	6700 00a0      	beqw 4d4e8 <rtems_partition_create+0xd0>          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( length == 0 || buffer_size == 0 || length < buffer_size ||
   4d44a:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4d44c:	6700 009e      	beqw 4d4ec <rtems_partition_create+0xd4>          	<== NOT EXECUTED
   4d450:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4d452:	6700 0098      	beqw 4d4ec <rtems_partition_create+0xd4>          	<== NOT EXECUTED
   4d456:	b682           	cmpl %d2,%d3                                      	<== NOT EXECUTED
   4d458:	6200 0092      	bhiw 4d4ec <rtems_partition_create+0xd4>          	<== NOT EXECUTED
   4d45c:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4d45e:	c083           	andl %d3,%d0                                      	<== NOT EXECUTED
   4d460:	6600 008a      	bnew 4d4ec <rtems_partition_create+0xd4>          	<== NOT EXECUTED
         !_Partition_Is_buffer_size_aligned( buffer_size ) )
    return RTEMS_INVALID_SIZE;

  if ( !_Addresses_Is_aligned( starting_address ) )
   4d464:	103c 0003      	moveb #3,%d0                                      	<== NOT EXECUTED
   4d468:	c084           	andl %d4,%d0                                      	<== NOT EXECUTED
   4d46a:	667c           	bnes 4d4e8 <rtems_partition_create+0xd0>          	<== NOT EXECUTED
   4d46c:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4d472:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4d474:	23c0 0006 c830 	movel %d0,6c830 <_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 );
   4d47a:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d480:	4eb9 0005 1278 	jsr 51278 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();               /* prevents deletion */

  the_partition = _Partition_Allocate();

  if ( !the_partition ) {
   4d486:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4d488:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4d48a:	47f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED
   4d490:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4d492:	6606           	bnes 4d49a <rtems_partition_create+0x82>          	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   4d494:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d496:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4d498:	6054           	bras 4d4ee <rtems_partition_create+0xd6>          	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_partition->starting_address      = starting_address;
   4d49a:	2544 0010      	movel %d4,%a2@(16)                                	<== NOT EXECUTED
  the_partition->length                = length;
  the_partition->buffer_size           = buffer_size;
  the_partition->attribute_set         = attribute_set;
   4d49e:	256e 0018 001c 	movel %fp@(24),%a2@(28)                           	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }
#endif

  the_partition->starting_address      = starting_address;
  the_partition->length                = length;
   4d4a4:	2542 0014      	movel %d2,%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,
   4d4a8:	4c43 2002      	remul %d3,%d2,%d2                                 	<== NOT EXECUTED
  }
#endif

  the_partition->starting_address      = starting_address;
  the_partition->length                = length;
  the_partition->buffer_size           = buffer_size;
   4d4ac:	2543 0018      	movel %d3,%a2@(24)                                	<== NOT EXECUTED
  the_partition->attribute_set         = attribute_set;
  the_partition->number_of_used_blocks = 0;
   4d4b0:	42aa 0020      	clrl %a2@(32)                                     	<== NOT EXECUTED

  _Chain_Initialize( &the_partition->Memory, starting_address,
   4d4b4:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4d4b6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d4b8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4d4ba:	486a 0024      	pea %a2@(36)                                      	<== NOT EXECUTED
   4d4be:	4eb9 0005 007c 	jsr 5007c <_Chain_Initialize>                     	<== NOT EXECUTED
   4d4c4:	2079 0006 c676 	moveal 6c676 <_Partition_Information+0x1a>,%a0    	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4d4ca:	2545 000c      	movel %d5,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4d4ce:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4d4d0:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   4d4d4:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
    &_Partition_Information,
    &the_partition->Object,
    (Objects_Name) name
  );

  *id = the_partition->Object.id;
   4d4d8:	28aa 0008      	movel %a2@(8),%a4@                                	<== NOT EXECUTED
      name,
      0                  /* Not used */
    );
#endif

  _Thread_Enable_dispatch();
   4d4dc:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d4de:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4d4e4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4d4e6:	6006           	bras 4d4ee <rtems_partition_create+0xd6>          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
   4d4e8:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d4ea:	6002           	bras 4d4ee <rtems_partition_create+0xd6>          	<== NOT EXECUTED
   4d4ec:	7008           	moveq #8,%d0                                      	<== NOT EXECUTED
}
   4d4ee:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4d4f4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d4f6:	4e75           	rts

0004d4f8 <rtems_partition_delete>:
 */

rtems_status_code rtems_partition_delete(
  Objects_Id id
)
{
   4d4f8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4d4fc:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4d4fe:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Partition_Control *)
   4d500:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d504:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d508:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d50e:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  register Partition_Control *the_partition;
  Objects_Locations           location;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   4d514:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d51a:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4d51c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d520:	6704           	beqs 4d526 <rtems_partition_delete+0x2e>          	<== NOT EXECUTED
   4d522:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d524:	6038           	bras 4d55e <rtems_partition_delete+0x66>          	<== NOT EXECUTED
   4d526:	47f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( the_partition->number_of_used_blocks == 0 ) {
   4d52c:	4aaa 0020      	tstl %a2@(32)                                     	<== NOT EXECUTED
   4d530:	6628           	bnes 4d55a <rtems_partition_delete+0x62>          	<== NOT EXECUTED
        _Objects_Close( &_Partition_Information, &the_partition->Object );
   4d532:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4d534:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d53a:	4eb9 0005 1300 	jsr 51300 <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Partition_Free (
   Partition_Control *the_partition
)
{
  _Objects_Free( &_Partition_Information, &the_partition->Object );
   4d540:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4d542:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d548:	4eb9 0005 1578 	jsr 51578 <_Objects_Free>                         	<== NOT EXECUTED
            0                          /* Not used */
          );
        }
#endif

        _Thread_Enable_dispatch();
   4d54e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d550:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4d556:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4d558:	6004           	bras 4d55e <rtems_partition_delete+0x66>          	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   4d55a:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d55c:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d55e:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   4d562:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   4d566:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d568:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d56c <rtems_partition_get_buffer>:

rtems_status_code rtems_partition_get_buffer(
  Objects_Id   id,
  void       **buffer
)
{
   4d56c:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4d570:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   4d574:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
  register Partition_Control *the_partition;
  Objects_Locations           location;
  void                       *the_buffer;

  if ( !buffer )
   4d578:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4d57a:	6604           	bnes 4d580 <rtems_partition_get_buffer+0x14>      	<== NOT EXECUTED
   4d57c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d57e:	604c           	bras 4d5cc <rtems_partition_get_buffer+0x60>      	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Partition_Control *)
   4d580:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d584:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d588:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d58e:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   4d594:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d59a:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4d59c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d5a0:	6704           	beqs 4d5a6 <rtems_partition_get_buffer+0x3a>      	<== NOT EXECUTED
   4d5a2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d5a4:	6026           	bras 4d5cc <rtems_partition_get_buffer+0x60>      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void *_Partition_Allocate_buffer (
   Partition_Control *the_partition
)
{
  return _Chain_Get( &the_partition->Memory );
   4d5a6:	486a 0024      	pea %a2@(36)                                      	<== NOT EXECUTED
   4d5aa:	4eb9 0005 0048 	jsr 50048 <_Chain_Get>                            	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_buffer = _Partition_Allocate_buffer( the_partition );
      if ( the_buffer ) {
   4d5b0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4d5b2:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4d5b4:	41f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a0           	<== NOT EXECUTED
   4d5ba:	670c           	beqs 4d5c8 <rtems_partition_get_buffer+0x5c>      	<== NOT EXECUTED
        the_partition->number_of_used_blocks += 1;
   4d5bc:	52aa 0020      	addql #1,%a2@(32)                                 	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   4d5c0:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
        *buffer = the_buffer;
   4d5c2:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4d5c4:	2682           	movel %d2,%a3@                                    	<== NOT EXECUTED
   4d5c6:	6004           	bras 4d5cc <rtems_partition_get_buffer+0x60>      	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   4d5c8:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4d5ca:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d5cc:	4cee 0c04 fff0 	moveml %fp@(-16),%d2/%a2-%a3                      	<== NOT EXECUTED
   4d5d2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d5d4:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d5d8 <rtems_partition_ident>:
rtems_status_code rtems_partition_ident(
  rtems_name    name,
  uint32_t      node,
  Objects_Id   *id
)
{
   4d5d8:	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 );
   4d5dc:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4d5e0:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4d5e4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d5e8:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d5ee:	4eb9 0005 1874 	jsr 51874 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4d5f4:	41f9 0006 597e 	lea 6597e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED

  return _Status_Object_name_errors_to_status[ status ];
}
   4d5fa:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4d5fe:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d600:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d604 <rtems_partition_return_buffer>:

rtems_status_code rtems_partition_return_buffer(
  Objects_Id  id,
  void       *buffer
)
{
   4d604:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   4d608:	48d7 040c      	moveml %d2-%d3/%a2,%sp@                           	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Partition_Control *)
   4d60c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d610:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   4d614:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d618:	4879 0006 c65c 	pea 6c65c <_Partition_Information>                	<== NOT EXECUTED
   4d61e:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  register Partition_Control *the_partition;
  Objects_Locations           location;

  the_partition = _Partition_Get( id, &location );
  switch ( location ) {
   4d624:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d62a:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4d62c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d630:	6704           	beqs 4d636 <rtems_partition_return_buffer+0x32>   	<== NOT EXECUTED
   4d632:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d634:	6044           	bras 4d67a <rtems_partition_return_buffer+0x76>   	<== NOT EXECUTED
)
{
  void *starting;
  void *ending;

  starting = the_partition->starting_address;
   4d636:	222a 0010      	movel %a2@(16),%d1                                	<== NOT EXECUTED
  ending   = _Addresses_Add_offset( starting, the_partition->length );
   4d63a:	202a 0014      	movel %a2@(20),%d0                                	<== NOT EXECUTED
  void *address,
  void *base,
  void *limit
)
{
  return (address >= base && address <= limit);
   4d63e:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   4d640:	6242           	bhis 4d684 <rtems_partition_return_buffer+0x80>   	<== NOT EXECUTED
   4d642:	d081           	addl %d1,%d0                                      	<== NOT EXECUTED
   4d644:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   4d646:	54c0           	scc %d0                                           	<== NOT EXECUTED
   4d648:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4d64a:	4480           	negl %d0                                          	<== NOT EXECUTED

  return (
   4d64c:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4d64e:	6734           	beqs 4d684 <rtems_partition_return_buffer+0x80>   	<== NOT EXECUTED
   4d650:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4d652:	9081           	subl %d1,%d0                                      	<== NOT EXECUTED
   4d654:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED
   4d656:	4c6a 1003 0018 	remul %a2@(24),%d3,%d1                            	<== NOT EXECUTED
   4d65c:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4d65e:	6624           	bnes 4d684 <rtems_partition_return_buffer+0x80>   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
  Partition_Control *the_partition,
  Chain_Node        *the_buffer
)
{
  _Chain_Append( &the_partition->Memory, the_buffer );
   4d660:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4d662:	486a 0024      	pea %a2@(36)                                      	<== NOT EXECUTED
   4d666:	4eb9 0005 0010 	jsr 50010 <_Chain_Append>                         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
        _Partition_Free_buffer( the_partition, buffer );
        the_partition->number_of_used_blocks -= 1;
   4d66c:	53aa 0020      	subql #1,%a2@(32)                                 	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   4d670:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4d676:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4d678:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d67a:	4cee 040c fff0 	moveml %fp@(-16),%d2-%d3/%a2                      	<== NOT EXECUTED
   4d680:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d682:	4e75           	rts                                               	<== NOT EXECUTED
        _Partition_Free_buffer( the_partition, buffer );
        the_partition->number_of_used_blocks -= 1;
        _Thread_Enable_dispatch();
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   4d684:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4d68a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4d68c:	60ec           	bras 4d67a <rtems_partition_return_buffer+0x76>   	<== NOT EXECUTED
	...

0004ca64 <rtems_port_create>:
  void         *internal_start,
  void         *external_start,
  uint32_t      length,
  Objects_Id   *id
)
{
   4ca64:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4ca68:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4ca6c:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4ca70:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4ca74:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
   4ca78:	266e 0018      	moveal %fp@(24),%a3                               	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;

  if ( !rtems_is_name_valid( name) )
   4ca7c:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4ca7e:	6604           	bnes 4ca84 <rtems_port_create+0x20>               	<== NOT EXECUTED
   4ca80:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4ca82:	606e           	bras 4caf2 <rtems_port_create+0x8e>               	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   4ca84:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4ca86:	6768           	beqs 4caf0 <rtems_port_create+0x8c>               	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_Addresses_Is_aligned( internal_start ) ||
   4ca88:	2004           	movel %d4,%d0                                     	<== NOT EXECUTED
   4ca8a:	8083           	orl %d3,%d0                                       	<== NOT EXECUTED
   4ca8c:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4ca8e:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4ca90:	665e           	bnes 4caf0 <rtems_port_create+0x8c>               	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4ca92:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4ca98:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4ca9a:	23c0 0006 c830 	movel %d0,6c830 <_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 *)
   4caa0:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4caa6:	4eb9 0005 1278 	jsr 51278 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* to prevent deletion */

  the_port = _Dual_ported_memory_Allocate();

  if ( !the_port ) {
   4caac:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4caae:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4cab0:	45f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
   4cab6:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4cab8:	6606           	bnes 4cac0 <rtems_port_create+0x5c>               	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   4caba:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4cabc:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4cabe:	6032           	bras 4caf2 <rtems_port_create+0x8e>               	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }

  the_port->internal_base = internal_start;
  the_port->external_base = external_start;
  the_port->length        = length - 1;
   4cac0:	202e 0014      	movel %fp@(20),%d0                                	<== NOT EXECUTED
   4cac4:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   4cac6:	2340 0018      	movel %d0,%a1@(24)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4caca:	2079 0006 c63a 	moveal 6c63a <_Dual_ported_memory_Information+0x1a>,%a0	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4cad0:	2342 000c      	movel %d2,%a1@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4cad4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4cad6:	3029 000a      	movew %a1@(10),%d0                                	<== NOT EXECUTED
   4cada:	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;
   4cade:	26a9 0008      	movel %a1@(8),%a3@                                	<== NOT EXECUTED
  if ( !the_port ) {
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_port->internal_base = internal_start;
   4cae2:	2343 0010      	movel %d3,%a1@(16)                                	<== NOT EXECUTED
  the_port->external_base = external_start;
   4cae6:	2344 0014      	movel %d4,%a1@(20)                                	<== NOT EXECUTED
    &the_port->Object,
    (Objects_Name) name
  );

  *id = the_port->Object.id;
  _Thread_Enable_dispatch();
   4caea:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4caec:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4caee:	6002           	bras 4caf2 <rtems_port_create+0x8e>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
   4caf0:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
}
   4caf2:	4cee 0c1c ffec 	moveml %fp@(-20),%d2-%d4/%a2-%a3                  	<== NOT EXECUTED
   4caf8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cafa:	4e75           	rts

0004cafc <rtems_port_delete>:
 */

rtems_status_code rtems_port_delete(
  Objects_Id id
)
{
   4cafc:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4cb00:	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 *)
   4cb02:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4cb06:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4cb0a:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4cb10:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   4cb16:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4cb1c:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4cb1e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4cb22:	6704           	beqs 4cb28 <rtems_port_delete+0x2c>               	<== NOT EXECUTED
   4cb24:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4cb26:	602a           	bras 4cb52 <rtems_port_delete+0x56>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object );
   4cb28:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4cb2a:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4cb30:	4eb9 0005 1300 	jsr 51300 <_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 );
   4cb36:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4cb38:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4cb3e:	4eb9 0005 1578 	jsr 51578 <_Objects_Free>                         	<== NOT EXECUTED
      _Dual_ported_memory_Free( the_port );
      _Thread_Enable_dispatch();
   4cb44:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4cb4a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4cb50:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4cb52:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4cb56:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cb58:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004cb5c <rtems_port_external_to_internal>:
rtems_status_code rtems_port_external_to_internal(
  Objects_Id   id,
  void        *external,
  void       **internal
)
{
   4cb5c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4cb60:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4cb62:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   4cb66:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4cb68:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;
  uint32_t                             ending;

  if ( !internal )
   4cb6c:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4cb6e:	6604           	bnes 4cb74 <rtems_port_external_to_internal+0x18> 	<== NOT EXECUTED
   4cb70:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4cb72:	6044           	bras 4cbb8 <rtems_port_external_to_internal+0x5c> 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Dual_ported_memory_Control *_Dual_ported_memory_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Dual_ported_memory_Control *)
   4cb74:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4cb78:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4cb7c:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4cb82:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   4cb88:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4cb8e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4cb90:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4cb94:	6704           	beqs 4cb9a <rtems_port_external_to_internal+0x3e> 	<== NOT EXECUTED
   4cb96:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4cb98:	601e           	bras 4cbb8 <rtems_port_external_to_internal+0x5c> 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE uint32_t   _Addresses_Subtract (
  void *left,
  void *right
)
{
  return ((char *) left - (char *) right);
   4cb9a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4cb9c:	90a8 0014      	subl %a0@(20),%d0                                 	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      ending = _Addresses_Subtract( external, the_port->external_base );
      if ( ending > the_port->length )
   4cba0:	b0a8 0018      	cmpl %a0@(24),%d0                                 	<== NOT EXECUTED
   4cba4:	6304           	blss 4cbaa <rtems_port_external_to_internal+0x4e> 	<== NOT EXECUTED
        *internal = external;
   4cba6:	2482           	movel %d2,%a2@                                    	<== NOT EXECUTED
   4cba8:	6006           	bras 4cbb0 <rtems_port_external_to_internal+0x54> 	<== NOT EXECUTED
      else
        *internal = _Addresses_Add_offset( the_port->internal_base,
   4cbaa:	d0a8 0010      	addl %a0@(16),%d0                                 	<== NOT EXECUTED
   4cbae:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
                                           ending );
      _Thread_Enable_dispatch();
   4cbb0:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4cbb6:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4cbb8:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4cbbc:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4cbc0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cbc2:	4e75           	rts

0004cbc4 <rtems_port_ident>:

rtems_status_code rtems_port_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   4cbc4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   4cbc8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4cbcc:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4cbce:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4cbd2:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4cbd8:	4eb9 0005 1874 	jsr 51874 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4cbde:	41f9 0006 597e 	lea 6597e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_ALL_NODES,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   4cbe4:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4cbe8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cbea:	4e75           	rts

0004cbec <rtems_port_internal_to_external>:
rtems_status_code rtems_port_internal_to_external(
  Objects_Id   id,
  void        *internal,
  void       **external
)
{
   4cbec:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4cbf0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4cbf2:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   4cbf6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4cbf8:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  register Dual_ported_memory_Control *the_port;
  Objects_Locations                    location;
  uint32_t                             ending;

  if ( !external )
   4cbfc:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4cbfe:	6604           	bnes 4cc04 <rtems_port_internal_to_external+0x18> 	<== NOT EXECUTED
   4cc00:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4cc02:	6044           	bras 4cc48 <rtems_port_internal_to_external+0x5c> 	<== NOT EXECUTED
   4cc04:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4cc08:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4cc0c:	4879 0006 c620 	pea 6c620 <_Dual_ported_memory_Information>       	<== NOT EXECUTED
   4cc12:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_port = _Dual_ported_memory_Get( id, &location );
  switch ( location ) {
   4cc18:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4cc1e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4cc20:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4cc24:	6704           	beqs 4cc2a <rtems_port_internal_to_external+0x3e> 	<== NOT EXECUTED
   4cc26:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4cc28:	601e           	bras 4cc48 <rtems_port_internal_to_external+0x5c> 	<== NOT EXECUTED
   4cc2a:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4cc2c:	90a8 0010      	subl %a0@(16),%d0                                 	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      ending = _Addresses_Subtract( internal, the_port->internal_base );
      if ( ending > the_port->length )
   4cc30:	b0a8 0018      	cmpl %a0@(24),%d0                                 	<== NOT EXECUTED
   4cc34:	6304           	blss 4cc3a <rtems_port_internal_to_external+0x4e> 	<== NOT EXECUTED
        *external = internal;
   4cc36:	2482           	movel %d2,%a2@                                    	<== NOT EXECUTED
   4cc38:	6006           	bras 4cc40 <rtems_port_internal_to_external+0x54> 	<== NOT EXECUTED
      else
        *external = _Addresses_Add_offset( the_port->external_base,
   4cc3a:	d0a8 0014      	addl %a0@(20),%d0                                 	<== NOT EXECUTED
   4cc3e:	2480           	movel %d0,%a2@                                    	<== NOT EXECUTED
                                           ending );
      _Thread_Enable_dispatch();
   4cc40:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4cc46:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4cc48:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4cc4c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4cc50:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4cc52:	4e75           	rts

0004d690 <rtems_rate_monotonic_cancel>:
 */

rtems_status_code rtems_rate_monotonic_cancel(
  Objects_Id id
)
{
   4d690:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4d694:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   4d696:	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 *)
   4d698:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d69c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d6a0:	4879 0006 c698 	pea 6c698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   4d6a6:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;
  Objects_Locations       location;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   4d6ac:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d6b2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4d6b4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d6b8:	6704           	beqs 4d6be <rtems_rate_monotonic_cancel+0x2e>     	<== NOT EXECUTED
   4d6ba:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d6bc:	602c           	bras 4d6ea <rtems_rate_monotonic_cancel+0x5a>     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
   4d6be:	2039 0006 c8ee 	movel 6c8ee <_Thread_Executing>,%d0               	<== NOT EXECUTED
   4d6c4:	47f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED
   4d6ca:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   4d6ce:	6706           	beqs 4d6d6 <rtems_rate_monotonic_cancel+0x46>     	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   4d6d0:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d6d2:	7017           	moveq #23,%d0                                     	<== NOT EXECUTED
   4d6d4:	6014           	bras 4d6ea <rtems_rate_monotonic_cancel+0x5a>     	<== NOT EXECUTED
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }
      (void) _Watchdog_Remove( &the_period->Timer );
   4d6d6:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4d6da:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
      the_period->state = RATE_MONOTONIC_INACTIVE;
   4d6e0:	42aa 0038      	clrl %a2@(56)                                     	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   4d6e4:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4d6e6:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4d6e8:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d6ea:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   4d6ee:	266e fff8      	moveal %fp@(-8),%a3                               	<== NOT EXECUTED
   4d6f2:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d6f4:	4e75           	rts                                               	<== NOT EXECUTED
	...

000458fc <rtems_rate_monotonic_create>:

rtems_status_code rtems_rate_monotonic_create(
  rtems_name    name,
  Objects_Id   *id
)
{
   458fc:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   45900:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   45904:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   45908:	286e 000c      	moveal %fp@(12),%a4                               	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;

  if ( !rtems_is_name_valid( name ) )
   4590c:	6606           	bnes 45914 <rtems_rate_monotonic_create+0x18>     	<== NOT EXECUTED
   4590e:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45910:	6000 00a6      	braw 459b8 <rtems_rate_monotonic_create+0xbc>     	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   45914:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   45916:	6606           	bnes 4591e <rtems_rate_monotonic_create+0x22>     	<== NOT EXECUTED
   45918:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4591a:	6000 009c      	braw 459b8 <rtems_rate_monotonic_create+0xbc>     	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4591e:	2039 0005 97a0 	movel 597a0 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   45924:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45926:	23c0 0005 97a0 	movel %d0,597a0 <_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 *)
   4592c:	4879 0005 9698 	pea 59698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   45932:	4eb9 0004 75a0 	jsr 475a0 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();            /* to prevent deletion */

  the_period = _Rate_monotonic_Allocate();

  if ( !the_period ) {
   45938:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4593a:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4593c:	47f9 0004 82ce 	lea 482ce <_Thread_Enable_dispatch>,%a3           	<== NOT EXECUTED
   45942:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45944:	6606           	bnes 4594c <rtems_rate_monotonic_create+0x50>     	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   45946:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   45948:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4594a:	606c           	bras 459b8 <rtems_rate_monotonic_create+0xbc>     	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }

  the_period->owner = _Thread_Executing;
   4594c:	41f9 0005 985e 	lea 5985e <_Thread_Executing>,%a0                 	<== NOT EXECUTED
   45952:	2550 0050      	movel %a0@,%a2@(80)                               	<== NOT EXECUTED
  the_period->state = RATE_MONOTONIC_INACTIVE;
   45956:	42aa 0038      	clrl %a2@(56)                                     	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4595a:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   4595e:	42aa 002c      	clrl %a2@(44)                                     	<== NOT EXECUTED
  the_watchdog->id        = id;
   45962:	42aa 0030      	clrl %a2@(48)                                     	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   45966:	42aa 0034      	clrl %a2@(52)                                     	<== NOT EXECUTED

  _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL );

  _Rate_monotonic_Reset_statistics( the_period );
   4596a:	4878 0038      	pea 38 <DBL_MANT_DIG+0x3>                         	<== NOT EXECUTED
   4596e:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   45970:	486a 0054      	pea %a2@(84)                                      	<== NOT EXECUTED
   45974:	4eb9 0004 cbbc 	jsr 4cbbc <memset>                                	<== NOT EXECUTED
   4597a:	203c 7fff ffff 	movel #2147483647,%d0                             	<== NOT EXECUTED
   45980:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   45984:	2079 0005 96b2 	moveal 596b2 <_Rate_monotonic_Information+0x1a>,%a0	<== NOT EXECUTED
   4598a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4598c:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   45990:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
   45994:	207c 7fff ffff 	moveal #2147483647,%a0                            	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4599a:	2542 000c      	movel %d2,%a2@(12)                                	<== NOT EXECUTED
   4599e:	2548 0060      	movel %a0,%a2@(96)                                	<== NOT EXECUTED
   459a2:	2548 0074      	movel %a0,%a2@(116)                               	<== NOT EXECUTED
   459a6:	2548 0078      	movel %a0,%a2@(120)                               	<== NOT EXECUTED
    &_Rate_monotonic_Information,
    &the_period->Object,
    (Objects_Name) name
  );

  *id = the_period->Object.id;
   459aa:	28aa 0008      	movel %a2@(8),%a4@                                	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   459ae:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   459b0:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   459b6:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   459b8:	4cee 1c04 fff0 	moveml %fp@(-16),%d2/%a2-%a4                      	<== NOT EXECUTED
   459be:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   459c0:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004d7c0 <rtems_rate_monotonic_delete>:
 */

rtems_status_code rtems_rate_monotonic_delete(
  Objects_Id id
)
{
   4d7c0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4d7c4:	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 *)
   4d7c6:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4d7ca:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4d7ce:	4879 0006 c698 	pea 6c698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   4d7d4:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  Rate_monotonic_Control *the_period;
  Objects_Locations       location;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   4d7da:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4d7e0:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4d7e2:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4d7e6:	6704           	beqs 4d7ec <rtems_rate_monotonic_delete+0x2c>     	<== NOT EXECUTED
   4d7e8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4d7ea:	6038           	bras 4d824 <rtems_rate_monotonic_delete+0x64>     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Rate_monotonic_Information, &the_period->Object );
   4d7ec:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4d7ee:	4879 0006 c698 	pea 6c698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   4d7f4:	4eb9 0005 1300 	jsr 51300 <_Objects_Close>                        	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_period->Timer );
   4d7fa:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4d7fe:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
      the_period->state = RATE_MONOTONIC_INACTIVE;
   4d804:	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 );
   4d808:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4d80a:	4879 0006 c698 	pea 6c698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   4d810:	4eb9 0005 1578 	jsr 51578 <_Objects_Free>                         	<== NOT EXECUTED
      _Rate_monotonic_Free( the_period );
      _Thread_Enable_dispatch();
   4d816:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4d81c:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   4d822:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4d824:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4d828:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4d82a:	4e75           	rts

00066308 <rtems_rate_monotonic_get_statistics>:

rtems_status_code rtems_rate_monotonic_get_statistics(
  Objects_Id                               id,
  rtems_rate_monotonic_period_statistics  *statistics
)
{
   66308:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   6630c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   6630e:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  if ( !statistics )
   66312:	6604           	bnes 66318 <rtems_rate_monotonic_get_statistics+0x10>	<== NOT EXECUTED
   66314:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   66316:	6044           	bras 6635c <rtems_rate_monotonic_get_statistics+0x54>	<== NOT EXECUTED
   66318:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   6631c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   66320:	4879 0009 2b2c 	pea 92b2c <_Rate_monotonic_Information>           	<== NOT EXECUTED
   66326:	4eb9 0004 a190 	jsr 4a190 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   6632c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   66332:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   66334:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   66338:	6704           	beqs 6633e <rtems_rate_monotonic_get_statistics+0x36>	<== NOT EXECUTED
   6633a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   6633c:	601e           	bras 6635c <rtems_rate_monotonic_get_statistics+0x54>	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      *statistics = the_period->Statistics;
   6633e:	4878 0038      	pea 38 <DBL_MANT_DIG+0x3>                         	<== NOT EXECUTED
   66342:	4868 0054      	pea %a0@(84)                                      	<== NOT EXECUTED
   66346:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   66348:	4eb9 0006 a3dc 	jsr 6a3dc <memcpy>                                	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   6634e:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   66354:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   6635a:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6635c:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   66360:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   66362:	4e75           	rts

00066364 <rtems_rate_monotonic_get_status>:

rtems_status_code rtems_rate_monotonic_get_status(
  Objects_Id                           id,
  rtems_rate_monotonic_period_status  *status
)
{
   66364:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   66368:	48d7 1c04      	moveml %d2/%a2-%a4,%sp@                           	<== NOT EXECUTED
   6636c:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  if ( !status )
   66370:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   66372:	6606           	bnes 6637a <rtems_rate_monotonic_get_status+0x16> 	<== NOT EXECUTED
   66374:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   66376:	6000 0094      	braw 6640c <rtems_rate_monotonic_get_status+0xa8> 	<== NOT EXECUTED
   6637a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   6637e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   66382:	4879 0009 2b2c 	pea 92b2c <_Rate_monotonic_Information>           	<== NOT EXECUTED
   66388:	4eb9 0004 a190 	jsr 4a190 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   6638e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   66394:	2840           	moveal %d0,%a4                                    	<== NOT EXECUTED
   66396:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   6639a:	6704           	beqs 663a0 <rtems_rate_monotonic_get_status+0x3c> 	<== NOT EXECUTED
   6639c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   6639e:	606c           	bras 6640c <rtems_rate_monotonic_get_status+0xa8> 	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0);
   663a0:	206c 0050      	moveal %a4@(80),%a0                               	<== NOT EXECUTED
   663a4:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   663a6:	6604           	bnes 663ac <rtems_rate_monotonic_get_status+0x48> 	<== NOT EXECUTED
   663a8:	4281           	clrl %d1                                          	<== NOT EXECUTED
   663aa:	6004           	bras 663b0 <rtems_rate_monotonic_get_status+0x4c> 	<== NOT EXECUTED
   663ac:	2228 0008      	movel %a0@(8),%d1                                 	<== NOT EXECUTED
      status->state = the_period->state;
   663b0:	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);
   663b4:	2681           	movel %d1,%a3@                                    	<== NOT EXECUTED
      status->state = the_period->state;
   663b6:	2740 0004      	movel %d0,%a3@(4)                                 	<== NOT EXECUTED

      if ( status->state == RATE_MONOTONIC_INACTIVE ) {
   663ba:	6612           	bnes 663ce <rtems_rate_monotonic_get_status+0x6a> 	<== 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;
   663bc:	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;
   663c0:	42ab 0008      	clrl %a3@(8)                                      	<== NOT EXECUTED
          status->since_last_period.tv_nsec = 0;
   663c4:	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;
   663c8:	42ab 0010      	clrl %a3@(16)                                     	<== NOT EXECUTED
   663cc:	6036           	bras 66404 <rtems_rate_monotonic_get_status+0xa0> 	<== 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 );
   663ce:	240e           	movel %fp,%d2                                     	<== NOT EXECUTED
   663d0:	0682 ffff fff4 	addil #-12,%d2                                    	<== NOT EXECUTED
   663d6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   663d8:	4eb9 0005 db14 	jsr 5db14 <_TOD_Get_uptime>                       	<== NOT EXECUTED
        #endif

        #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
          _Timespec_Subtract(
   663de:	486b 0008      	pea %a3@(8)                                       	<== NOT EXECUTED
   663e2:	45f9 0004 b6d4 	lea 4b6d4 <_Timespec_Subtract>,%a2                	<== NOT EXECUTED
   663e8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   663ea:	486c 0044      	pea %a4@(68)                                      	<== NOT EXECUTED
   663ee:	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(
   663f0:	486b 0010      	pea %a3@(16)                                      	<== NOT EXECUTED
   663f4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   663f6:	4879 0009 2726 	pea 92726 <_Thread_Time_of_last_context_switch>   	<== NOT EXECUTED
   663fc:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   663fe:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
            the_period->owner->cpu_time_used -
            the_period->owner_executed_at_period;
        #endif
      }

      _Thread_Enable_dispatch();
   66404:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   6640a:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   6640c:	4cee 1c04 ffe4 	moveml %fp@(-28),%d2/%a2-%a4                      	<== NOT EXECUTED
   66412:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   66414:	4e75           	rts                                               	<== NOT EXECUTED
	...

000459c4 <rtems_rate_monotonic_ident>:

rtems_status_code rtems_rate_monotonic_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   459c4:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   459c8:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   459cc:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   459d2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   459d6:	4879 0005 9698 	pea 59698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   459dc:	4eb9 0004 7c50 	jsr 47c50 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   459e2:	41f9 0005 6b94 	lea 56b94 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   459e8:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   459ec:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   459ee:	4e75           	rts

00045bcc <rtems_rate_monotonic_period>:

rtems_status_code rtems_rate_monotonic_period(
  Objects_Id        id,
  rtems_interval    length
)
{
   45bcc:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   45bd0:	48d7 041c      	moveml %d2-%d4/%a2,%sp@                           	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Rate_monotonic_Control *)
   45bd4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45bd8:	282e 0008      	movel %fp@(8),%d4                                 	<== NOT EXECUTED
   45bdc:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   45be0:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   45be2:	4879 0005 9698 	pea 59698 <_Rate_monotonic_Information>           	<== NOT EXECUTED
   45be8:	4eb9 0004 7aec 	jsr 47aec <_Objects_Get>                          	<== NOT EXECUTED
  rtems_rate_monotonic_period_states   local_state;
  ISR_Level                            level;

  the_period = _Rate_monotonic_Get( id, &location );

  switch ( location ) {
   45bee:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45bf4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   45bf6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45bfa:	6600 012e      	bnew 45d2a <rtems_rate_monotonic_period+0x15e>    	<== NOT EXECUTED
    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
   45bfe:	2039 0005 985e 	movel 5985e <_Thread_Executing>,%d0               	<== NOT EXECUTED
   45c04:	b0aa 0050      	cmpl %a2@(80),%d0                                 	<== NOT EXECUTED
   45c08:	6706           	beqs 45c10 <rtems_rate_monotonic_period+0x44>     	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   45c0a:	7417           	moveq #23,%d2                                     	<== NOT EXECUTED
   45c0c:	6000 00dc      	braw 45cea <rtems_rate_monotonic_period+0x11e>    	<== NOT EXECUTED
        return RTEMS_NOT_OWNER_OF_RESOURCE;
      }

      if ( length == RTEMS_PERIOD_STATUS ) {
   45c10:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   45c12:	661c           	bnes 45c30 <rtems_rate_monotonic_period+0x64>     	<== NOT EXECUTED
        switch ( the_period->state ) {
   45c14:	202a 0038      	movel %a2@(56),%d0                                	<== NOT EXECUTED
   45c18:	6710           	beqs 45c2a <rtems_rate_monotonic_period+0x5e>     	<== NOT EXECUTED
   45c1a:	5780           	subql #3,%d0                                      	<== NOT EXECUTED
   45c1c:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   45c1e:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45c20:	6500 00c6      	bcsw 45ce8 <rtems_rate_monotonic_period+0x11c>    	<== NOT EXECUTED
   45c24:	7406           	moveq #6,%d2                                      	<== NOT EXECUTED
   45c26:	6000 00c2      	braw 45cea <rtems_rate_monotonic_period+0x11e>    	<== NOT EXECUTED
   45c2a:	740b           	moveq #11,%d2                                     	<== NOT EXECUTED
   45c2c:	6000 00bc      	braw 45cea <rtems_rate_monotonic_period+0x11e>    	<== NOT EXECUTED
        }
        _Thread_Enable_dispatch();
        return( return_value );
      }

      _ISR_Disable( level );
   45c30:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   45c36:	40c2           	movew %sr,%d2                                     	<== NOT EXECUTED
   45c38:	8082           	orl %d2,%d0                                       	<== NOT EXECUTED
   45c3a:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED

      switch ( the_period->state ) {
   45c3c:	202a 0038      	movel %a2@(56),%d0                                	<== NOT EXECUTED
   45c40:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   45c42:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45c44:	6740           	beqs 45c86 <rtems_rate_monotonic_period+0xba>     	<== NOT EXECUTED
   45c46:	123c 0004      	moveb #4,%d1                                      	<== NOT EXECUTED
   45c4a:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   45c4c:	6700 00a4      	beqw 45cf2 <rtems_rate_monotonic_period+0x126>    	<== NOT EXECUTED
   45c50:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45c52:	6600 00d6      	bnew 45d2a <rtems_rate_monotonic_period+0x15e>    	<== NOT EXECUTED
        case RATE_MONOTONIC_INACTIVE: {

          _ISR_Enable( level );
   45c56:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

          /*
           *  Baseline statistics information for the beginning of a period.
           */
          _Rate_monotonic_Initiate_statistics( the_period );
   45c58:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45c5a:	4eb9 0004 59f0 	jsr 459f0 <_Rate_monotonic_Initiate_statistics>   	<== NOT EXECUTED

          the_period->state = RATE_MONOTONIC_ACTIVE;
   45c60:	7402           	moveq #2,%d2                                      	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   45c62:	203c 0004 5f94 	movel #286612,%d0                                 	<== NOT EXECUTED
   45c68:	2542 0038      	movel %d2,%a2@(56)                                	<== NOT EXECUTED
          );

          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   45c6c:	4202           	clrb %d2                                          	<== NOT EXECUTED
  the_watchdog->id        = id;
   45c6e:	2544 0030      	movel %d4,%a2@(48)                                	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45c72:	2543 001c      	movel %d3,%a2@(28)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   45c76:	2540 002c      	movel %d0,%a2@(44)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   45c7a:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   45c7e:	42aa 0034      	clrl %a2@(52)                                     	<== NOT EXECUTED
   45c82:	6000 0084      	braw 45d08 <rtems_rate_monotonic_period+0x13c>    	<== NOT EXECUTED
        case RATE_MONOTONIC_ACTIVE:

          /*
           *  Update statistics from the concluding period.
           */
          _Rate_monotonic_Update_statistics( the_period );
   45c86:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45c88:	4eb9 0004 5a68 	jsr 45a68 <_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;
   45c8e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
          the_period->next_length = length;
   45c90:	2543 004c      	movel %d3,%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;
   45c94:	2541 0038      	movel %d1,%a2@(56)                                	<== NOT EXECUTED
          the_period->next_length = length;

          _ISR_Enable( level );
   45c98:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

          _Thread_Executing->Wait.id = the_period->Object.id;
   45c9a:	2079 0005 985e 	moveal 5985e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45ca0:	216a 0008 0020 	movel %a2@(8),%a0@(32)                            	<== NOT EXECUTED
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   45ca6:	4878 4000      	pea 4000 <D_MAX_EXP+0x3801>                       	<== NOT EXECUTED
   45caa:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   45cac:	4eb9 0004 8b40 	jsr 48b40 <_Thread_Set_state>                     	<== NOT EXECUTED

          /*
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?
           */
          _ISR_Disable( level );
   45cb2:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   45cb8:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   45cba:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   45cbc:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
            local_state = the_period->state;
   45cbe:	222a 0038      	movel %a2@(56),%d1                                	<== NOT EXECUTED
            the_period->state = RATE_MONOTONIC_ACTIVE;
   45cc2:	7402           	moveq #2,%d2                                      	<== NOT EXECUTED
   45cc4:	2542 0038      	movel %d2,%a2@(56)                                	<== NOT EXECUTED
          _ISR_Enable( level );
   45cc8:	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 )
   45cca:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45ccc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45cd2:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   45cd4:	6612           	bnes 45ce8 <rtems_rate_monotonic_period+0x11c>    	<== NOT EXECUTED
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   45cd6:	4878 4000      	pea 4000 <D_MAX_EXP+0x3801>                       	<== NOT EXECUTED
   45cda:	2f39 0005 985e 	movel 5985e <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   45ce0:	4eb9 0004 7f0c 	jsr 47f0c <_Thread_Clear_state>                   	<== NOT EXECUTED
   45ce6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED

          _Thread_Enable_dispatch();
   45ce8:	4282           	clrl %d2                                          	<== NOT EXECUTED
   45cea:	4eb9 0004 82ce 	jsr 482ce <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45cf0:	603a           	bras 45d2c <rtems_rate_monotonic_period+0x160>    	<== NOT EXECUTED
        case RATE_MONOTONIC_EXPIRED:

          /*
           *  Update statistics from the concluding period
           */
          _Rate_monotonic_Update_statistics( the_period );
   45cf2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45cf4:	4eb9 0004 5a68 	jsr 45a68 <_Rate_monotonic_Update_statistics>     	<== NOT EXECUTED

          _ISR_Enable( level );
   45cfa:	46c2           	movew %d2,%sr                                     	<== NOT EXECUTED

          the_period->state = RATE_MONOTONIC_ACTIVE;
   45cfc:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   45cfe:	7406           	moveq #6,%d2                                      	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45d00:	2543 001c      	movel %d3,%a2@(28)                                	<== NOT EXECUTED
           */
          _Rate_monotonic_Update_statistics( the_period );

          _ISR_Enable( level );

          the_period->state = RATE_MONOTONIC_ACTIVE;
   45d04:	2541 0038      	movel %d1,%a2@(56)                                	<== NOT EXECUTED
          the_period->next_length = length;
   45d08:	2543 004c      	movel %d3,%a2@(76)                                	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   45d0c:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   45d10:	4879 0005 987c 	pea 5987c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   45d16:	4eb9 0004 9364 	jsr 49364 <_Watchdog_Insert>                      	<== NOT EXECUTED

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   45d1c:	4eb9 0004 82ce 	jsr 482ce <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45d22:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   45d28:	6002           	bras 45d2c <rtems_rate_monotonic_period+0x160>    	<== NOT EXECUTED
          return RTEMS_TIMEOUT;
   45d2a:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45d2c:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   45d2e:	4cee 041c ffec 	moveml %fp@(-20),%d2-%d4/%a2                      	<== NOT EXECUTED
   45d34:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45d36:	4e75           	rts

0005d1f2 <rtems_rate_monotonic_report_statistics>:

void rtems_rate_monotonic_report_statistics( void )
{
   5d1f2:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin );
   5d1f6:	4879 0004 65dc 	pea 465dc <printk_plugin>                         	<== NOT EXECUTED
   5d1fc:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5d1fe:	4eb9 0005 d05c 	jsr 5d05c <rtems_rate_monotonic_report_statistics_with_plugin>	<== NOT EXECUTED
   5d204:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
}
   5d206:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d208:	4e75           	rts                                               	<== NOT EXECUTED
	...

0005d05c <rtems_rate_monotonic_report_statistics_with_plugin>:
 */
void rtems_rate_monotonic_report_statistics_with_plugin(
  void                  *context,
  rtems_printk_plugin_t  print
)
{
   5d05c:	4e56 ff78      	linkw %fp,#-136                                   	<== NOT EXECUTED
   5d060:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@                       	<== NOT EXECUTED
   5d064:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   5d068:	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 )
   5d06c:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   5d06e:	6700 0178      	beqw 5d1e8 <rtems_rate_monotonic_report_statistics_with_plugin+0x18c>	<== NOT EXECUTED
    return;

  (*print)( context, "Period information by period\n" );
   5d072:	4879 0007 a666 	pea 7a666 <IMFS_memfile_handlers+0x1dc>           	<== NOT EXECUTED

    /*
     *  Print part of report line that is not dependent on granularity
     */

    (*print)( context,
   5d078:	2a0e           	movel %fp,%d5                                     	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   5d07a:	280e           	movel %fp,%d4                                     	<== NOT EXECUTED
  char                                   name[5];

  if ( !print )
    return;

  (*print)( context, "Period information by period\n" );
   5d07c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d07e:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
  (*print)( context, "--- CPU times are in seconds ---\n" );
   5d080:	4879 0007 a684 	pea 7a684 <IMFS_memfile_handlers+0x1fa>           	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   5d086:	2e0e           	movel %fp,%d7                                     	<== 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 );
   5d088:	4bf9 0006 6364 	lea 66364 <rtems_rate_monotonic_get_status>,%a5   	<== NOT EXECUTED
  if ( !print )
    return;

  (*print)( context, "Period information by period\n" );
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
  (*print)( context, "--- CPU times are in seconds ---\n" );
   5d08e:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d090:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
  (*print)( context, "--- Wall times are in seconds ---\n" );
   5d092:	4879 0007 a6a6 	pea 7a6a6 <IMFS_memfile_handlers+0x21c>           	<== NOT EXECUTED

    /*
     *  Print part of report line that is not dependent on granularity
     */

    (*print)( context,
   5d098:	5b85           	subql #5,%d5                                      	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   5d09a:	0684 ffff fff2 	addil #-14,%d4                                    	<== NOT EXECUTED
  (*print)( context, "Period information by period\n" );
#if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS)
  (*print)( context, "--- CPU times are in seconds ---\n" );
#endif
#if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS)
  (*print)( context, "--- Wall times are in seconds ---\n" );
   5d0a0:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d0a2:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
  Be sure to test the various cases.
  (*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
  (*print)( context, "   ID     OWNER COUNT MISSED     "
   5d0a4:	4879 0007 a6c9 	pea 7a6c9 <IMFS_memfile_handlers+0x23f>           	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   5d0aa:	0687 ffff ffba 	addil #-70,%d7                                    	<== NOT EXECUTED
   5d0b0:	47f9 0005 e414 	lea 5e414 <_Timespec_Divide_by_integer>,%a3       	<== NOT EXECUTED
  Be sure to test the various cases.
  (*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
  (*print)( context, "   ID     OWNER COUNT MISSED     "
   5d0b6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d0b8:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
       #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
          "      "
       #endif
          "   WALL TIME\n"
  );
  (*print)( context, "                               "
   5d0ba:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   5d0c0:	2ebc 0007 a714 	movel #501524,%sp@                                	<== NOT EXECUTED
    #endif

    name[ 0 ] = '\0';

    if ( the_status.owner ) {
      rtems_object_get_name( the_status.owner, sizeof(name), name );
   5d0c6:	49f9 0004 87f8 	lea 487f8 <rtems_object_get_name>,%a4             	<== NOT EXECUTED
       #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS
          "      "
       #endif
          "   WALL TIME\n"
  );
  (*print)( context, "                               "
   5d0cc:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d0ce:	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 ;
   5d0d0:	2439 0009 2b32 	movel 92b32 <_Rate_monotonic_Information+0x6>,%d2 	<== NOT EXECUTED
   5d0d6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   5d0d8:	6000 0104      	braw 5d1de <rtems_rate_monotonic_report_statistics_with_plugin+0x182>	<== NOT EXECUTED
        id <= _Rate_monotonic_Information.maximum_id ;
        id++ ) {
    status = rtems_rate_monotonic_get_statistics( id, &the_stats );
   5d0dc:	486e ffa2      	pea %fp@(-94)                                     	<== NOT EXECUTED
   5d0e0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d0e2:	4eb9 0006 6308 	jsr 66308 <rtems_rate_monotonic_get_statistics>   	<== NOT EXECUTED
    if ( status != RTEMS_SUCCESSFUL )
   5d0e8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   5d0ea:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5d0ec:	6600 00ee      	bnew 5d1dc <rtems_rate_monotonic_report_statistics_with_plugin+0x180>	<== NOT EXECUTED
      continue;

    /* If the above passed, so should this but check it anyway */
    status = rtems_rate_monotonic_get_status( id, &the_status );
   5d0f0:	486e ffda      	pea %fp@(-38)                                     	<== NOT EXECUTED
   5d0f4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d0f6:	4e95           	jsr %a5@                                          	<== NOT EXECUTED
        continue;
    #endif

    name[ 0 ] = '\0';

    if ( the_status.owner ) {
   5d0f8:	202e ffda      	movel %fp@(-38),%d0                               	<== NOT EXECUTED
    #if defined(RTEMS_DEBUG)
      if ( status != RTEMS_SUCCESSFUL )
        continue;
    #endif

    name[ 0 ] = '\0';
   5d0fc:	4201           	clrb %d1                                          	<== NOT EXECUTED

    if ( the_status.owner ) {
   5d0fe:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    #if defined(RTEMS_DEBUG)
      if ( status != RTEMS_SUCCESSFUL )
        continue;
    #endif

    name[ 0 ] = '\0';
   5d100:	1d41 fffb      	moveb %d1,%fp@(-5)                                	<== NOT EXECUTED

    if ( the_status.owner ) {
   5d104:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5d106:	6710           	beqs 5d118 <rtems_rate_monotonic_report_statistics_with_plugin+0xbc>	<== NOT EXECUTED
      rtems_object_get_name( the_status.owner, sizeof(name), name );
   5d108:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   5d10a:	4878 0005      	pea 5 <COMPARE>                                   	<== NOT EXECUTED
   5d10e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5d110:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   5d112:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED

    /*
     *  Print part of report line that is not dependent on granularity
     */

    (*print)( context,
   5d118:	2f2e ffa6      	movel %fp@(-90),%sp@-                             	<== NOT EXECUTED
   5d11c:	2f2e ffa2      	movel %fp@(-94),%sp@-                             	<== NOT EXECUTED
   5d120:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   5d122:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d124:	4879 0007 a760 	pea 7a760 <IMFS_memfile_handlers+0x2d6>           	<== NOT EXECUTED
   5d12a:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d12c:	4e92           	jsr %a2@                                          	<== NOT EXECUTED

    /*
     *  If the count is zero, don't print statistics
     */

    if (the_stats.count == 0) {
   5d12e:	202e ffa2      	movel %fp@(-94),%d0                               	<== NOT EXECUTED
   5d132:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   5d138:	6610           	bnes 5d14a <rtems_rate_monotonic_report_statistics_with_plugin+0xee>	<== NOT EXECUTED
      (*print)( context, "\n" );
   5d13a:	4879 0007 aa70 	pea 7aa70 <__func__.5623+0x118>                   	<== NOT EXECUTED
   5d140:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d142:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   5d144:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   5d146:	6000 0094      	braw 5d1dc <rtems_rate_monotonic_report_statistics_with_plugin+0x180>	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   5d14a:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
         &the_stats.total_cpu_time,
         the_stats.count,
         &cpu_average
      );
      (*print)( context,
   5d14c:	2c3c 0000 03e8 	movel #1000,%d6                                   	<== NOT EXECUTED
     */
    {
    #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS
      struct timespec   cpu_average;

      _Timespec_Divide_by_integer(
   5d152:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5d154:	2f07           	movel %d7,%sp@-                                   	<== NOT EXECUTED
   5d156:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
         &the_stats.total_cpu_time,
         the_stats.count,
         &cpu_average
      );
      (*print)( context,
   5d158:	202e fff6      	movel %fp@(-10),%d0                               	<== NOT EXECUTED
   5d15c:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   5d160:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5d162:	202e ffb6      	movel %fp@(-74),%d0                               	<== NOT EXECUTED
   5d166:	2f2e fff2      	movel %fp@(-14),%sp@-                             	<== NOT EXECUTED
   5d16a:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   5d16e:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   5d170:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   5d172:	222e ffae      	movel %fp@(-82),%d1                               	<== NOT EXECUTED
   5d176:	2f2e ffb2      	movel %fp@(-78),%sp@-                             	<== NOT EXECUTED
   5d17a:	4c46 1801      	remsl %d6,%d1,%d1                                 	<== NOT EXECUTED
   5d17e:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   5d180:	2f2e ffaa      	movel %fp@(-86),%sp@-                             	<== NOT EXECUTED
   5d184:	4879 0007 a777 	pea 7a777 <IMFS_memfile_handlers+0x2ed>           	<== NOT EXECUTED
   5d18a:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d18c:	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(
   5d18e:	dffc 0000 0028 	addal #40,%sp                                     	<== NOT EXECUTED
   5d194:	2e84           	movel %d4,%sp@                                    	<== NOT EXECUTED
   5d196:	2f2e ffa2      	movel %fp@(-94),%sp@-                             	<== NOT EXECUTED
   5d19a:	486e ffd2      	pea %fp@(-46)                                     	<== NOT EXECUTED
   5d19e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
         &the_stats.total_wall_time,
         the_stats.count,
         &wall_average
      );
      (*print)( context,
   5d1a0:	202e fff6      	movel %fp@(-10),%d0                               	<== NOT EXECUTED
   5d1a4:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   5d1a8:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   5d1aa:	202e ffce      	movel %fp@(-50),%d0                               	<== NOT EXECUTED
   5d1ae:	2f2e fff2      	movel %fp@(-14),%sp@-                             	<== NOT EXECUTED
   5d1b2:	4c46 0800      	remsl %d6,%d0,%d0                                 	<== NOT EXECUTED
   5d1b6:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   5d1b8:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   5d1ba:	222e ffc6      	movel %fp@(-58),%d1                               	<== NOT EXECUTED
   5d1be:	2f2e ffca      	movel %fp@(-54),%sp@-                             	<== NOT EXECUTED
   5d1c2:	4c46 1801      	remsl %d6,%d1,%d1                                 	<== NOT EXECUTED
   5d1c6:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   5d1c8:	2f2e ffc2      	movel %fp@(-62),%sp@-                             	<== NOT EXECUTED
   5d1cc:	4879 0007 a796 	pea 7a796 <IMFS_memfile_handlers+0x30c>           	<== NOT EXECUTED
   5d1d2:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   5d1d4:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   5d1d6:	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 ;
        id++ ) {
   5d1dc:	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 ;
   5d1de:	b4b9 0009 2b36 	cmpl 92b36 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   5d1e4:	6300 fef6      	blsw 5d0dc <rtems_rate_monotonic_report_statistics_with_plugin+0x80>	<== NOT EXECUTED
        the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
      );
    #endif
    }
  }
}
   5d1e8:	4cee 3cfc ff78 	moveml %fp@(-136),%d2-%d7/%a2-%a5                 	<== NOT EXECUTED
   5d1ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d1f0:	4e75           	rts

0005d20c <rtems_rate_monotonic_reset_all_statistics>:

/*
 *  rtems_rate_monotonic_reset_all_statistics
 */
void rtems_rate_monotonic_reset_all_statistics( void )
{
   5d20c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   5d210:	2039 0009 2660 	movel 92660 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   5d216:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5d218:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   5d21a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d21c:	23c0 0009 2660 	movel %d0,92660 <_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 ;
   5d222:	2439 0009 2b32 	movel 92b32 <_Rate_monotonic_Information+0x6>,%d2 	<== NOT EXECUTED
          id <= _Rate_monotonic_Information.maximum_id ;
          id++ ) {
      status = rtems_rate_monotonic_reset_statistics( id );
   5d228:	45f9 0005 d250 	lea 5d250 <rtems_rate_monotonic_reset_statistics>,%a2	<== NOT EXECUTED
   5d22e:	6008           	bras 5d238 <rtems_rate_monotonic_reset_all_statistics+0x2c>	<== NOT EXECUTED
   5d230:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d232:	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++ ) {
   5d234:	5282           	addql #1,%d2                                      	<== NOT EXECUTED
   5d236:	588f           	addql #4,%sp                                      	<== 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 ;
   5d238:	b4b9 0009 2b36 	cmpl 92b36 <_Rate_monotonic_Information+0xa>,%d2  	<== NOT EXECUTED
   5d23e:	63f0           	blss 5d230 <rtems_rate_monotonic_reset_all_statistics+0x24>	<== NOT EXECUTED

  /*
   *  Done so exit thread dispatching disabled critical section.
   */
  _Thread_Enable_dispatch();
}
   5d240:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   5d244:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   5d248:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
    }

  /*
   *  Done so exit thread dispatching disabled critical section.
   */
  _Thread_Enable_dispatch();
   5d24a:	4ef9 0004 a9de 	jmp 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED

0005d250 <rtems_rate_monotonic_reset_statistics>:
 */

rtems_status_code rtems_rate_monotonic_reset_statistics(
  Objects_Id                               id
)
{
   5d250:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5d254:	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 *)
   5d256:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5d25a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5d25e:	4879 0009 2b2c 	pea 92b2c <_Rate_monotonic_Information>           	<== NOT EXECUTED
   5d264:	4eb9 0004 a190 	jsr 4a190 <_Objects_Get>                          	<== NOT EXECUTED
  Objects_Locations              location;
  Rate_monotonic_Control        *the_period;

  the_period = _Rate_monotonic_Get( id, &location );
  switch ( location ) {
   5d26a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5d270:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   5d272:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5d276:	6704           	beqs 5d27c <rtems_rate_monotonic_reset_statistics+0x2c>	<== NOT EXECUTED
   5d278:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   5d27a:	6034           	bras 5d2b0 <rtems_rate_monotonic_reset_statistics+0x60>	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Rate_monotonic_Reset_statistics( the_period );
   5d27c:	4878 0038      	pea 38 <DBL_MANT_DIG+0x3>                         	<== NOT EXECUTED
   5d280:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5d282:	486a 0054      	pea %a2@(84)                                      	<== NOT EXECUTED
   5d286:	4eb9 0006 a54c 	jsr 6a54c <memset>                                	<== NOT EXECUTED
   5d28c:	203c 7fff ffff 	movel #2147483647,%d0                             	<== NOT EXECUTED
   5d292:	2540 0078      	movel %d0,%a2@(120)                               	<== NOT EXECUTED
   5d296:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
   5d29a:	2540 0060      	movel %d0,%a2@(96)                                	<== NOT EXECUTED
   5d29e:	2540 0074      	movel %d0,%a2@(116)                               	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   5d2a2:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5d2a8:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5d2ae:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5d2b0:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5d2b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d2b6:	4e75           	rts

0004dd20 <rtems_region_create>:
  uint32_t            length,
  uint32_t            page_size,
  rtems_attribute     attribute_set,
  Objects_Id         *id
)
{
   4dd20:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4dd24:	48d7 0c7c      	moveml %d2-%d6/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4dd28:	2c2e 0008      	movel %fp@(8),%d6                                 	<== NOT EXECUTED
   4dd2c:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   4dd30:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
   4dd34:	2a2e 0014      	movel %fp@(20),%d5                                	<== NOT EXECUTED
   4dd38:	262e 0018      	movel %fp@(24),%d3                                	<== NOT EXECUTED
   4dd3c:	266e 001c      	moveal %fp@(28),%a3                               	<== NOT EXECUTED
  rtems_status_code  return_status;
  Region_Control    *the_region;

  if ( !rtems_is_name_valid( name ) )
   4dd40:	4a86           	tstl %d6                                          	<== NOT EXECUTED
   4dd42:	6606           	bnes 4dd4a <rtems_region_create+0x2a>             	<== NOT EXECUTED
   4dd44:	7403           	moveq #3,%d2                                      	<== NOT EXECUTED
   4dd46:	6000 00ca      	braw 4de12 <rtems_region_create+0xf2>             	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !starting_address )
   4dd4a:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4dd4c:	6700 00c2      	beqw 4de10 <rtems_region_create+0xf0>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !id )
   4dd50:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4dd52:	6700 00bc      	beqw 4de10 <rtems_region_create+0xf0>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_Addresses_Is_aligned( starting_address ) )
   4dd56:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4dd58:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   4dd5a:	6600 00b4      	bnew 4de10 <rtems_region_create+0xf0>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();                      /* to prevent deletion */
   4dd5e:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4dd64:	4eb9 0004 ff78 	jsr 4ff78 <_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 );
   4dd6a:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4dd70:	4eb9 0005 1278 	jsr 51278 <_Objects_Allocate>                     	<== NOT EXECUTED

    the_region = _Region_Allocate();

    if ( !the_region )
   4dd76:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4dd78:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4dd7a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4dd7c:	6604           	bnes 4dd82 <rtems_region_create+0x62>             	<== NOT EXECUTED
   4dd7e:	7405           	moveq #5,%d2                                      	<== NOT EXECUTED
   4dd80:	607e           	bras 4de00 <rtems_region_create+0xe0>             	<== NOT EXECUTED
      return_status = RTEMS_TOO_MANY;

    else {

      the_region->maximum_segment_size = _Heap_Initialize(
   4dd82:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   4dd84:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4dd86:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4dd88:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   4dd8c:	4eb9 0005 0dac 	jsr 50dac <_Heap_Initialize>                      	<== NOT EXECUTED
        &the_region->Memory, starting_address, length, page_size
      );

      if ( !the_region->maximum_segment_size ) {
   4dd92:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    if ( !the_region )
      return_status = RTEMS_TOO_MANY;

    else {

      the_region->maximum_segment_size = _Heap_Initialize(
   4dd98:	2540 005c      	movel %d0,%a2@(92)                                	<== NOT EXECUTED
        &the_region->Memory, starting_address, length, page_size
      );

      if ( !the_region->maximum_segment_size ) {
   4dd9c:	6614           	bnes 4ddb2 <rtems_region_create+0x92>             	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Region_Free (
  Region_Control *the_region
)
{
  _Objects_Free( &_Region_Information, &the_region->Object );
   4dd9e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4dda0:	7408           	moveq #8,%d2                                      	<== NOT EXECUTED
   4dda2:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4dda8:	4eb9 0005 1578 	jsr 51578 <_Objects_Free>                         	<== NOT EXECUTED
   4ddae:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4ddb0:	604e           	bras 4de00 <rtems_region_create+0xe0>             	<== NOT EXECUTED
        return_status = RTEMS_INVALID_SIZE;
      }

      else {

        the_region->starting_address      = starting_address;
   4ddb2:	2542 0050      	movel %d2,%a2@(80)                                	<== NOT EXECUTED
        the_region->length                = length;
        the_region->page_size             = page_size;
        the_region->attribute_set         = attribute_set;
        the_region->number_of_used_blocks = 0;

        _Thread_queue_Initialize(
   4ddb6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
          &_Region_Information,
          &the_region->Object,
          (Objects_Name) name
        );

        *id = the_region->Object.id;
   4ddb8:	4282           	clrl %d2                                          	<== NOT EXECUTED
      else {

        the_region->starting_address      = starting_address;
        the_region->length                = length;
        the_region->page_size             = page_size;
        the_region->attribute_set         = attribute_set;
   4ddba:	2543 0060      	movel %d3,%a2@(96)                                	<== NOT EXECUTED
        the_region->number_of_used_blocks = 0;

        _Thread_queue_Initialize(
   4ddbe:	e48b           	lsrl #2,%d3                                       	<== NOT EXECUTED
      }

      else {

        the_region->starting_address      = starting_address;
        the_region->length                = length;
   4ddc0:	2544 0054      	movel %d4,%a2@(84)                                	<== NOT EXECUTED
        the_region->page_size             = page_size;
        the_region->attribute_set         = attribute_set;
        the_region->number_of_used_blocks = 0;

        _Thread_queue_Initialize(
   4ddc4:	c083           	andl %d3,%d0                                      	<== NOT EXECUTED

      else {

        the_region->starting_address      = starting_address;
        the_region->length                = length;
        the_region->page_size             = page_size;
   4ddc6:	2545 0058      	movel %d5,%a2@(88)                                	<== NOT EXECUTED
        the_region->attribute_set         = attribute_set;
        the_region->number_of_used_blocks = 0;
   4ddca:	42aa 0064      	clrl %a2@(100)                                    	<== NOT EXECUTED

        _Thread_queue_Initialize(
   4ddce:	4878 0006      	pea 6 <EXTENDSFDF>                                	<== NOT EXECUTED
   4ddd2:	4878 0040      	pea 40 <FP_REGS_SAVED>                            	<== NOT EXECUTED
   4ddd6:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4ddd8:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4dddc:	4eb9 0005 25a4 	jsr 525a4 <_Thread_queue_Initialize>              	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4dde2:	2079 0006 c6ee 	moveal 6c6ee <_Region_Information+0x1a>,%a0       	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4dde8:	2546 000c      	movel %d6,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4ddec:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4ddee:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
          &_Region_Information,
          &the_region->Object,
          (Objects_Name) name
        );

        *id = the_region->Object.id;
   4ddf2:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4ddf8:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
   4ddfc:	26aa 0008      	movel %a2@(8),%a3@                                	<== NOT EXECUTED
        return_status = RTEMS_SUCCESSFUL;
      }
    }

  _RTEMS_Unlock_allocator();
   4de00:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4de06:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4de0c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4de0e:	6002           	bras 4de12 <rtems_region_create+0xf2>             	<== NOT EXECUTED
  return return_status;
   4de10:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
}
   4de12:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4de14:	4cee 0c7c ffe4 	moveml %fp@(-28),%d2-%d6/%a2-%a3                  	<== NOT EXECUTED
   4de1a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4de1c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004de20 <rtems_region_delete>:
 */

rtems_status_code rtems_region_delete(
  Objects_Id id
)
{
   4de20:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4de24:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4de26:	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();
   4de28:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4de2e:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Region_Control *)
   4de34:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4de38:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4de3c:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4de42:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4de48:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4de4a:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   4de4e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4de54:	670e           	beqs 4de64 <rtems_region_delete+0x44>             	<== NOT EXECUTED
   4de56:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4de58:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4de5a:	6604           	bnes 4de60 <rtems_region_delete+0x40>             	<== NOT EXECUTED
   4de5c:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
   4de5e:	6032           	bras 4de92 <rtems_region_delete+0x72>             	<== NOT EXECUTED
   4de60:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4de62:	602e           	bras 4de92 <rtems_region_delete+0x72>             	<== NOT EXECUTED

      case OBJECTS_LOCAL:
        _Region_Debug_Walk( the_region, 5 );
        if ( the_region->number_of_used_blocks != 0 )
   4de64:	4aaa 0064      	tstl %a2@(100)                                    	<== NOT EXECUTED
   4de68:	6704           	beqs 4de6e <rtems_region_delete+0x4e>             	<== NOT EXECUTED
   4de6a:	740c           	moveq #12,%d2                                     	<== NOT EXECUTED
   4de6c:	6024           	bras 4de92 <rtems_region_delete+0x72>             	<== NOT EXECUTED
          return_status = RTEMS_RESOURCE_IN_USE;
        else {
          _Objects_Close( &_Region_Information, &the_region->Object );
   4de6e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Region_Free (
  Region_Control *the_region
)
{
  _Objects_Free( &_Region_Information, &the_region->Object );
   4de70:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4de72:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4de78:	4eb9 0005 1300 	jsr 51300 <_Objects_Close>                        	<== NOT EXECUTED
   4de7e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4de80:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4de86:	4eb9 0005 1578 	jsr 51578 <_Objects_Free>                         	<== NOT EXECUTED
   4de8c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4de92:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4de98:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return return_status;
}
   4de9e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4dea0:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4dea4:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4dea8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4deaa:	4e75           	rts

0004deac <rtems_region_extend>:
rtems_status_code rtems_region_extend(
  Objects_Id          id,
  void               *starting_address,
  uint32_t            length
)
{
   4deac:	4e56 fff8      	linkw %fp,#-8                                     	<== NOT EXECUTED
   4deb0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4deb2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4deb4:	242e 000c      	movel %fp@(12),%d2                                	<== 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 )
   4deb8:	6608           	bnes 4dec2 <rtems_region_extend+0x16>             	<== NOT EXECUTED
   4deba:	143c 0009      	moveb #9,%d2                                      	<== NOT EXECUTED
   4debe:	6000 008e      	braw 4df4e <rtems_region_extend+0xa2>             	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();                      /* to prevent deletion */
   4dec2:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4dec8:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Region_Control *)
   4dece:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   4ded2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ded6:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4dedc:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4dee2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4dee4:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   4dee8:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4deee:	670a           	beqs 4defa <rtems_region_extend+0x4e>             	<== NOT EXECUTED
   4def0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4def2:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4def4:	6648           	bnes 4df3e <rtems_region_extend+0x92>             	<== NOT EXECUTED
   4def6:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
   4def8:	6046           	bras 4df40 <rtems_region_extend+0x94>             	<== NOT EXECUTED

      case OBJECTS_LOCAL:

        heap_status = _Heap_Extend(
   4defa:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4defe:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4df02:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4df04:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   4df08:	4eb9 0005 0ad4 	jsr 50ad4 <_Heap_Extend>                          	<== NOT EXECUTED
          starting_address,
          length,
          &amount_extended
        );

        switch ( heap_status ) {
   4df0e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4df14:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4df16:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4df18:	670c           	beqs 4df26 <rtems_region_extend+0x7a>             	<== NOT EXECUTED
   4df1a:	620e           	bhis 4df2a <rtems_region_extend+0x7e>             	<== NOT EXECUTED
   4df1c:	123c 0002      	moveb #2,%d1                                      	<== NOT EXECUTED
   4df20:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4df22:	661a           	bnes 4df3e <rtems_region_extend+0x92>             	<== NOT EXECUTED
   4df24:	6014           	bras 4df3a <rtems_region_extend+0x8e>             	<== NOT EXECUTED
   4df26:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
   4df28:	6016           	bras 4df40 <rtems_region_extend+0x94>             	<== NOT EXECUTED
          case HEAP_EXTEND_SUCCESSFUL:
            the_region->length                += amount_extended;
   4df2a:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
            the_region->maximum_segment_size  += amount_extended;
   4df2e:	d1aa 005c      	addl %d0,%a2@(92)                                 	<== NOT EXECUTED
          &amount_extended
        );

        switch ( heap_status ) {
          case HEAP_EXTEND_SUCCESSFUL:
            the_region->length                += amount_extended;
   4df32:	d1aa 0054      	addl %d0,%a2@(84)                                 	<== NOT EXECUTED
            the_region->maximum_segment_size  += amount_extended;
   4df36:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4df38:	6006           	bras 4df40 <rtems_region_extend+0x94>             	<== NOT EXECUTED
            return_status = RTEMS_SUCCESSFUL;
            break;
   4df3a:	7418           	moveq #24,%d2                                     	<== NOT EXECUTED
   4df3c:	6002           	bras 4df40 <rtems_region_extend+0x94>             	<== NOT EXECUTED
   4df3e:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4df40:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4df46:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4df4c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   4df4e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4df50:	242e fff0      	movel %fp@(-16),%d2                               	<== NOT EXECUTED
   4df54:	246e fff4      	moveal %fp@(-12),%a2                              	<== NOT EXECUTED
   4df58:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4df5a:	4e75           	rts

0004df5c <rtems_region_get_free_information>:

rtems_status_code rtems_region_get_free_information(
  Objects_Id              id,
  Heap_Information_block *the_info
)
{
   4df5c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4df60:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4df62:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
   4df66:	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 )
   4df68:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4df6a:	6604           	bnes 4df70 <rtems_region_get_free_information+0x14>	<== NOT EXECUTED
   4df6c:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
   4df6e:	6066           	bras 4dfd6 <rtems_region_get_free_information+0x7a>	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   4df70:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4df76:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
   4df7c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4df80:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4df84:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4df8a:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4df90:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4df92:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   4df96:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4df9c:	670e           	beqs 4dfac <rtems_region_get_free_information+0x50>	<== NOT EXECUTED
   4df9e:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4dfa0:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4dfa2:	6604           	bnes 4dfa8 <rtems_region_get_free_information+0x4c>	<== NOT EXECUTED
   4dfa4:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
   4dfa6:	6020           	bras 4dfc8 <rtems_region_get_free_information+0x6c>	<== NOT EXECUTED
   4dfa8:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4dfaa:	601c           	bras 4dfc8 <rtems_region_get_free_information+0x6c>	<== 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 );
   4dfac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4dfae:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4dfb0:	4868 0068      	pea %a0@(104)                                     	<== NOT EXECUTED
    the_region = _Region_Get( id, &location );
    switch ( location ) {

      case OBJECTS_LOCAL:

        the_info->Used.number   = 0;
   4dfb4:	42aa 000c      	clrl %a2@(12)                                     	<== NOT EXECUTED
        the_info->Used.total    = 0;
   4dfb8:	42aa 0014      	clrl %a2@(20)                                     	<== NOT EXECUTED
        the_info->Used.largest  = 0;
   4dfbc:	42aa 0010      	clrl %a2@(16)                                     	<== NOT EXECUTED

        _Heap_Get_free_information( &the_region->Memory, &the_info->Free );
   4dfc0:	4eb9 0005 0cec 	jsr 50cec <_Heap_Get_free_information>            	<== NOT EXECUTED
   4dfc6:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4dfc8:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4dfce:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4dfd4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   4dfd6:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4dfd8:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4dfdc:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4dfe0:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4dfe2:	4e75           	rts

0004dfe4 <rtems_region_get_information>:

rtems_status_code rtems_region_get_information(
  Objects_Id              id,
  Heap_Information_block *the_info
)
{
   4dfe4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4dfe8:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4dfea:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !the_info )
   4dfee:	6606           	bnes 4dff6 <rtems_region_get_information+0x12>    	<== NOT EXECUTED
   4dff0:	143c 0009      	moveb #9,%d2                                      	<== NOT EXECUTED
   4dff4:	6062           	bras 4e058 <rtems_region_get_information+0x74>    	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   4dff6:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4dffc:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
   4e002:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4e006:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e00a:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4e010:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4e016:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4e018:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   4e01c:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4e022:	670e           	beqs 4e032 <rtems_region_get_information+0x4e>    	<== NOT EXECUTED
   4e024:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e026:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4e028:	6604           	bnes 4e02e <rtems_region_get_information+0x4a>    	<== NOT EXECUTED
   4e02a:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
   4e02c:	601c           	bras 4e04a <rtems_region_get_information+0x66>    	<== NOT EXECUTED
   4e02e:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4e030:	6018           	bras 4e04a <rtems_region_get_information+0x66>    	<== NOT EXECUTED

      case OBJECTS_LOCAL:
        if ( _Heap_Get_information( &the_region->Memory, the_info ) !=
   4e032:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4e034:	4868 0068      	pea %a0@(104)                                     	<== NOT EXECUTED
   4e038:	4eb9 0005 0d30 	jsr 50d30 <_Heap_Get_information>                 	<== NOT EXECUTED
   4e03e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4e040:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4e042:	6604           	bnes 4e048 <rtems_region_get_information+0x64>    	<== NOT EXECUTED
   4e044:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4e046:	6002           	bras 4e04a <rtems_region_get_information+0x66>    	<== NOT EXECUTED
   4e048:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4e04a:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e050:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4e056:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   4e058:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4e05a:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4e05e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e060:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e064 <rtems_region_get_segment>:
  uint32_t           size,
  rtems_option       option_set,
  rtems_interval     timeout,
  void              **segment
)
{
   4e064:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4e068:	48d7 1c0c      	moveml %d2-%d3/%a2-%a4,%sp@                       	<== NOT EXECUTED
   4e06c:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   4e070:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   4e074:	286e 0018      	moveal %fp@(24),%a4                               	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;
  void                    *the_segment;

  if ( !segment )
   4e078:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   4e07a:	6606           	bnes 4e082 <rtems_region_get_segment+0x1e>        	<== NOT EXECUTED
   4e07c:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
   4e07e:	6000 00f2      	braw 4e172 <rtems_region_get_segment+0x10e>       	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  *segment = NULL;
   4e082:	4294           	clrl %a4@                                         	<== NOT EXECUTED

  if ( size == 0 )
   4e084:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4e086:	6608           	bnes 4e090 <rtems_region_get_segment+0x2c>        	<== NOT EXECUTED
   4e088:	143c 0008      	moveb #8,%d2                                      	<== NOT EXECUTED
   4e08c:	6000 00e4      	braw 4e172 <rtems_region_get_segment+0x10e>       	<== NOT EXECUTED
    return RTEMS_INVALID_SIZE;

  _RTEMS_Lock_allocator();
   4e090:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e096:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
   4e09c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED

    executing  = _Thread_Executing;
   4e0a0:	2679 0006 c8ee 	moveal 6c8ee <_Thread_Executing>,%a3              	<== NOT EXECUTED
   4e0a6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4e0a8:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4e0ae:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4e0b4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4e0b6:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   4e0ba:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4e0c0:	670e           	beqs 4e0d0 <rtems_region_get_segment+0x6c>        	<== NOT EXECUTED
   4e0c2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e0c4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4e0c6:	6700 009a      	beqw 4e162 <rtems_region_get_segment+0xfe>        	<== NOT EXECUTED
   4e0ca:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4e0cc:	6000 0096      	braw 4e164 <rtems_region_get_segment+0x100>       	<== NOT EXECUTED

      case OBJECTS_LOCAL:
        if ( size > the_region->maximum_segment_size )
   4e0d0:	b4aa 005c      	cmpl %a2@(92),%d2                                 	<== NOT EXECUTED
   4e0d4:	6306           	blss 4e0dc <rtems_region_get_segment+0x78>        	<== NOT EXECUTED
   4e0d6:	7408           	moveq #8,%d2                                      	<== NOT EXECUTED
   4e0d8:	6000 008a      	braw 4e164 <rtems_region_get_segment+0x100>       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void *_Region_Allocate_segment (
  Region_Control *the_region,
  uint32_t        size
)
{
   return _Heap_Allocate( &the_region->Memory, size );
   4e0dc:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4e0de:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   4e0e2:	4eb9 0005 0a54 	jsr 50a54 <_Heap_Allocate>                        	<== NOT EXECUTED

          the_segment = _Region_Allocate_segment( the_region, size );

          _Region_Debug_Walk( the_region, 2 );

          if ( the_segment ) {
   4e0e8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4e0ea:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4e0ec:	670a           	beqs 4e0f8 <rtems_region_get_segment+0x94>        	<== NOT EXECUTED
            the_region->number_of_used_blocks += 1;
   4e0ee:	52aa 0064      	addql #1,%a2@(100)                                	<== NOT EXECUTED
            *segment = the_segment;
   4e0f2:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4e0f4:	2880           	movel %d0,%a4@                                    	<== NOT EXECUTED
   4e0f6:	606c           	bras 4e164 <rtems_region_get_segment+0x100>       	<== NOT EXECUTED
            return_status = RTEMS_SUCCESSFUL;
          }

          else if ( _Options_Is_no_wait( option_set ) ) {
   4e0f8:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   4e0fc:	0800 0000      	btst #0,%d0                                       	<== NOT EXECUTED
   4e100:	6704           	beqs 4e106 <rtems_region_get_segment+0xa2>        	<== NOT EXECUTED
   4e102:	740d           	moveq #13,%d2                                     	<== NOT EXECUTED
   4e104:	605e           	bras 4e164 <rtems_region_get_segment+0x100>       	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   4e106:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4e10c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4e10e:	23c0 0006 c830 	movel %d0,6c830 <_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();
   4e114:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e11a:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED

            executing->Wait.queue           = &the_region->Wait_queue;
   4e120:	200a           	movel %a2,%d0                                     	<== NOT EXECUTED
   4e122:	0680 0000 0010 	addil #16,%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;
   4e128:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e12a:	2541 0040      	movel %d1,%a2@(64)                                	<== NOT EXECUTED
            executing->Wait.id              = id;
            executing->Wait.count           = size;
   4e12e:	2742 0024      	movel %d2,%a3@(36)                                	<== NOT EXECUTED
             *  because this thread is going to block.
             */
            _Thread_Disable_dispatch();
            _RTEMS_Unlock_allocator();

            executing->Wait.queue           = &the_region->Wait_queue;
   4e132:	2740 0044      	movel %d0,%a3@(68)                                	<== NOT EXECUTED
            executing->Wait.id              = id;
   4e136:	2743 0020      	movel %d3,%a3@(32)                                	<== NOT EXECUTED
            executing->Wait.count           = size;
            executing->Wait.return_argument = segment;
   4e13a:	274c 0028      	movel %a4,%a3@(40)                                	<== NOT EXECUTED

            _Thread_queue_Enter_critical_section( &the_region->Wait_queue );

            _Thread_queue_Enqueue( &the_region->Wait_queue, timeout );
   4e13e:	4879 0005 2690 	pea 52690 <_Thread_queue_Timeout>                 	<== NOT EXECUTED
   4e144:	2f2e 0014      	movel %fp@(20),%sp@-                              	<== NOT EXECUTED
   4e148:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4e14a:	4eb9 0005 2358 	jsr 52358 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED

            _Thread_Enable_dispatch();
   4e150:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

            return (rtems_status_code) executing->Wait.return_code;
   4e156:	242b 0034      	movel %a3@(52),%d2                                	<== NOT EXECUTED
   4e15a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4e160:	6010           	bras 4e172 <rtems_region_get_segment+0x10e>       	<== NOT EXECUTED
   4e162:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4e164:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e16a:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4e170:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   4e172:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4e174:	4cee 1c0c ffe8 	moveml %fp@(-24),%d2-%d3/%a2-%a4                  	<== NOT EXECUTED
   4e17a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e17c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e180 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
  Objects_Id         id,
  void              *segment,
  size_t            *size
)
{
   4e180:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4e184:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4e186:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   4e18a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4e18c:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_INTERNAL_ERROR;
  register Region_Control *the_region;

  if ( !segment )
   4e190:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4e192:	676e           	beqs 4e202 <rtems_region_get_segment_size+0x82>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !size )
   4e194:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4e196:	676a           	beqs 4e202 <rtems_region_get_segment_size+0x82>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   4e198:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e19e:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Region_Control *_Region_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Region_Control *)
   4e1a4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4e1a8:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e1ac:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4e1b2:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4e1b8:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4e1ba:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   4e1be:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4e1c4:	670e           	beqs 4e1d4 <rtems_region_get_segment_size+0x54>   	<== NOT EXECUTED
   4e1c6:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e1c8:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4e1ca:	6604           	bnes 4e1d0 <rtems_region_get_segment_size+0x50>   	<== NOT EXECUTED
   4e1cc:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
   4e1ce:	6022           	bras 4e1f2 <rtems_region_get_segment_size+0x72>   	<== NOT EXECUTED
   4e1d0:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4e1d2:	601e           	bras 4e1f2 <rtems_region_get_segment_size+0x72>   	<== NOT EXECUTED

      case OBJECTS_LOCAL:
        if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) )
   4e1d4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4e1d6:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4e1d8:	4868 0068      	pea %a0@(104)                                     	<== NOT EXECUTED
   4e1dc:	4eb9 0005 1128 	jsr 51128 <_Heap_Size_of_user_area>               	<== NOT EXECUTED
   4e1e2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4e1e8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4e1ea:	6704           	beqs 4e1f0 <rtems_region_get_segment_size+0x70>   	<== NOT EXECUTED
   4e1ec:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4e1ee:	6002           	bras 4e1f2 <rtems_region_get_segment_size+0x72>   	<== NOT EXECUTED
   4e1f0:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4e1f2:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e1f8:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4e1fe:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4e200:	6002           	bras 4e204 <rtems_region_get_segment_size+0x84>   	<== NOT EXECUTED
  return return_status;
   4e202:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
}
   4e204:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4e206:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4e20a:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   4e20e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e210:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e214 <rtems_region_ident>:

rtems_status_code rtems_region_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   4e214:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   4e218:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4e21c:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   4e222:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e226:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4e22c:	4eb9 0005 1874 	jsr 51874 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4e232:	41f9 0006 597e 	lea 6597e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   4e238:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4e23c:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e23e:	4e75           	rts

0004e240 <rtems_region_resize_segment>:
  Objects_Id  id,
  void       *segment,
  size_t      size,
  size_t     *old_size
)
{
   4e240:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4e244:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   4e248:	266e 0014      	moveal %fp@(20),%a3                               	<== 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 )
   4e24c:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4e24e:	6700 00a0      	beqw 4e2f0 <rtems_region_resize_segment+0xb0>     	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   4e252:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e258:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
   4e25e:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   4e262:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e266:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4e26c:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4e272:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4e274:	202e fff8      	movel %fp@(-8),%d0                                	<== NOT EXECUTED
   4e278:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4e27e:	670a           	beqs 4e28a <rtems_region_resize_segment+0x4a>     	<== NOT EXECUTED
   4e280:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e282:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4e284:	6758           	beqs 4e2de <rtems_region_resize_segment+0x9e>     	<== NOT EXECUTED
   4e286:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4e288:	6056           	bras 4e2e0 <rtems_region_resize_segment+0xa0>     	<== NOT EXECUTED

      case OBJECTS_LOCAL:

        _Region_Debug_Walk( the_region, 7 );

        status = _Heap_Resize_block(
   4e28a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4e28e:	486e fff4      	pea %fp@(-12)                                     	<== NOT EXECUTED
   4e292:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4e296:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4e29a:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   4e29e:	4eb9 0005 0f80 	jsr 50f80 <_Heap_Resize_block>                    	<== NOT EXECUTED
          segment,
          (uint32_t) size,
          &osize,
          &avail_size
        );
        *old_size = (uint32_t) osize;
   4e2a4:	26ae fff4      	movel %fp@(-12),%a3@                              	<== NOT EXECUTED

      case OBJECTS_LOCAL:

        _Region_Debug_Walk( the_region, 7 );

        status = _Heap_Resize_block(
   4e2a8:	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 )
   4e2aa:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   4e2b0:	6610           	bnes 4e2c2 <rtems_region_resize_segment+0x82>     	<== NOT EXECUTED
   4e2b2:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4e2b6:	670a           	beqs 4e2c2 <rtems_region_resize_segment+0x82>     	<== NOT EXECUTED
          _Region_Process_queue( the_region );    /* unlocks allocator */
   4e2b8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4e2ba:	4eb9 0005 4cb4 	jsr 54cb4 <_Region_Process_queue>                 	<== NOT EXECUTED
   4e2c0:	602a           	bras 4e2ec <rtems_region_resize_segment+0xac>     	<== NOT EXECUTED
        else
          _RTEMS_Unlock_allocator();
   4e2c2:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e2c8:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED

        return
   4e2ce:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4e2d0:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4e2d2:	671e           	beqs 4e2f2 <rtems_region_resize_segment+0xb2>     	<== NOT EXECUTED
   4e2d4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   4e2d6:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   4e2d8:	6616           	bnes 4e2f0 <rtems_region_resize_segment+0xb0>     	<== NOT EXECUTED
   4e2da:	740d           	moveq #13,%d2                                     	<== NOT EXECUTED
   4e2dc:	6014           	bras 4e2f2 <rtems_region_resize_segment+0xb2>     	<== NOT EXECUTED
   4e2de:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4e2e0:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e2e6:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   4e2ec:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4e2ee:	6002           	bras 4e2f2 <rtems_region_resize_segment+0xb2>     	<== NOT EXECUTED
  return return_status;
   4e2f0:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
}
   4e2f2:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4e2f4:	4cee 0c04 ffe8 	moveml %fp@(-24),%d2/%a2-%a3                      	<== NOT EXECUTED
   4e2fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e2fc:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e300 <rtems_region_return_segment>:

rtems_status_code rtems_region_return_segment(
  Objects_Id  id,
  void       *segment
)
{
   4e300:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4e304:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4e306:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  uint32_t                 size;
#endif
  int                      status;
  register Region_Control *the_region;

  _RTEMS_Lock_allocator();
   4e308:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e30e:	4eb9 0004 ff78 	jsr 4ff78 <_API_Mutex_Lock>                       	<== NOT EXECUTED
   4e314:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4e318:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e31c:	4879 0006 c6d4 	pea 6c6d4 <_Region_Information>                   	<== NOT EXECUTED
   4e322:	4eb9 0005 16d8 	jsr 516d8 <_Objects_Get_no_protection>            	<== NOT EXECUTED
   4e328:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4e32a:	202e fffc      	movel %fp@(-4),%d0                                	<== NOT EXECUTED
   4e32e:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   4e334:	670e           	beqs 4e344 <rtems_region_return_segment+0x44>     	<== NOT EXECUTED
   4e336:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e338:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4e33a:	6604           	bnes 4e340 <rtems_region_return_segment+0x40>     	<== NOT EXECUTED
   4e33c:	7404           	moveq #4,%d2                                      	<== NOT EXECUTED
   4e33e:	602a           	bras 4e36a <rtems_region_return_segment+0x6a>     	<== NOT EXECUTED
   4e340:	7419           	moveq #25,%d2                                     	<== NOT EXECUTED
   4e342:	6026           	bras 4e36a <rtems_region_return_segment+0x6a>     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE bool _Region_Free_segment (
  Region_Control *the_region,
  void           *the_segment
)
{
  return _Heap_Free( &the_region->Memory, the_segment );
   4e344:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4e348:	486a 0068      	pea %a2@(104)                                     	<== NOT EXECUTED
   4e34c:	4eb9 0005 0b68 	jsr 50b68 <_Heap_Free>                            	<== NOT EXECUTED
#endif
          status = _Region_Free_segment( the_region, segment );

          _Region_Debug_Walk( the_region, 4 );

          if ( !status )
   4e352:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4e354:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4e356:	6710           	beqs 4e368 <rtems_region_return_segment+0x68>     	<== NOT EXECUTED
            return_status = RTEMS_INVALID_ADDRESS;

          else {
            the_region->number_of_used_blocks -= 1;
   4e358:	53aa 0064      	subql #1,%a2@(100)                                	<== NOT EXECUTED

            _Region_Process_queue(the_region); /* unlocks allocator */
   4e35c:	4282           	clrl %d2                                          	<== NOT EXECUTED
   4e35e:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4e360:	4eb9 0005 4cb4 	jsr 54cb4 <_Region_Process_queue>                 	<== NOT EXECUTED
   4e366:	600e           	bras 4e376 <rtems_region_return_segment+0x76>     	<== NOT EXECUTED

            return RTEMS_SUCCESSFUL;
   4e368:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4e36a:	2f39 0006 c8e6 	movel 6c8e6 <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   4e370:	4eb9 0004 ffdc 	jsr 4ffdc <_API_Mutex_Unlock>                     	<== NOT EXECUTED
  return return_status;
}
   4e376:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   4e378:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4e37c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4e380:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
  return return_status;
}
   4e382:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e384:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044c0c <rtems_semaphore_create>:
  uint32_t             count,
  rtems_attribute      attribute_set,
  rtems_task_priority  priority_ceiling,
  rtems_id            *id
)
{
   44c0c:	4e56 ffd0      	linkw %fp,#-48                                    	<== NOT EXECUTED
   44c10:	48d7 0c3c      	moveml %d2-%d5/%a2-%a3,%sp@                       	<== NOT EXECUTED
   44c14:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   44c18:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   44c1c:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
   44c20:	266e 0018      	moveal %fp@(24),%a3                               	<== 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 ) )
   44c24:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   44c26:	6606           	bnes 44c2e <rtems_semaphore_create+0x22>          	<== NOT EXECUTED
   44c28:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   44c2a:	6000 0172      	braw 44d9e <rtems_semaphore_create+0x192>         	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   44c2e:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   44c30:	6606           	bnes 44c38 <rtems_semaphore_create+0x2c>          	<== NOT EXECUTED
   44c32:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   44c34:	6000 0168      	braw 44d9e <rtems_semaphore_create+0x192>         	<== NOT EXECUTED
  uint32_t             count,
  rtems_attribute      attribute_set,
  rtems_task_priority  priority_ceiling,
  rtems_id            *id
)
{
   44c38:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   44c3a:	0281 0000 00c0 	andil #192,%d1                                    	<== NOT EXECUTED
      return RTEMS_NOT_DEFINED;

  } else
#endif

  if ( _Attributes_Is_inherit_priority( attribute_set ) ||
   44c40:	6724           	beqs 44c66 <rtems_semaphore_create+0x5a>          	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Attributes_Is_binary_semaphore(
  rtems_attribute attribute_set
)
{
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_BINARY_SEMAPHORE);
   44c42:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   44c44:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
              _Attributes_Is_priority_ceiling( attribute_set ) ) {

    if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) ||
   44c46:	7610           	moveq #16,%d3                                     	<== NOT EXECUTED
   44c48:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   44c4a:	670a           	beqs 44c56 <rtems_semaphore_create+0x4a>          	<== NOT EXECUTED
   44c4c:	163c 0020      	moveb #32,%d3                                     	<== NOT EXECUTED
   44c50:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   44c52:	6600 0148      	bnew 44d9c <rtems_semaphore_create+0x190>         	<== NOT EXECUTED
   44c56:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   44c58:	6600 0142      	bnew 44d9c <rtems_semaphore_create+0x190>         	<== NOT EXECUTED
             _Attributes_Is_priority( attribute_set ) ) )
      return RTEMS_NOT_DEFINED;

  }

  if ( _Attributes_Is_inherit_priority( attribute_set ) &&
   44c5c:	0c81 0000 00c0 	cmpil #192,%d1                                    	<== NOT EXECUTED
   44c62:	6700 0138      	beqw 44d9c <rtems_semaphore_create+0x190>         	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _Attributes_Is_counting_semaphore(
  rtems_attribute attribute_set
)
{
  return ((attribute_set & RTEMS_SEMAPHORE_CLASS) == RTEMS_COUNTING_SEMAPHORE);
   44c66:	7630           	moveq #48,%d3                                     	<== NOT EXECUTED
   44c68:	c682           	andl %d2,%d3                                      	<== NOT EXECUTED
       _Attributes_Is_priority_ceiling( attribute_set ) )
    return RTEMS_NOT_DEFINED;

  if ( !_Attributes_Is_counting_semaphore( attribute_set ) && ( count > 1 ) )
   44c6a:	670e           	beqs 44c7a <rtems_semaphore_create+0x6e>          	<== NOT EXECUTED
   44c6c:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   44c6e:	b084           	cmpl %d4,%d0                                      	<== NOT EXECUTED
   44c70:	6408           	bccs 44c7a <rtems_semaphore_create+0x6e>          	<== NOT EXECUTED
   44c72:	103c 000a      	moveb #10,%d0                                     	<== NOT EXECUTED
   44c76:	6000 0126      	braw 44d9e <rtems_semaphore_create+0x192>         	<== NOT EXECUTED
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   44c7a:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   44c80:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   44c82:	23c0 0005 6ca4 	movel %d0,56ca4 <_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 );
   44c88:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44c8e:	4eb9 0004 600c 	jsr 4600c <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();             /* prevents deletion */

  the_semaphore = _Semaphore_Allocate();

  if ( !the_semaphore ) {
   44c94:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   44c96:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   44c98:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   44c9a:	660c           	bnes 44ca8 <rtems_semaphore_create+0x9c>          	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   44c9c:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44ca2:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   44ca4:	6000 00f8      	braw 44d9e <rtems_semaphore_create+0x192>         	<== NOT EXECUTED
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }
#endif

  the_semaphore->attribute_set = attribute_set;
   44ca8:	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 ) ) {
   44cac:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   44cae:	6700 009a      	beqw 44d4a <rtems_semaphore_create+0x13e>         	<== NOT EXECUTED
    CORE_mutex_Status mutex_status;

    if ( _Attributes_Is_inherit_priority( attribute_set ) )
   44cb2:	0802 0006      	btst #6,%d2                                       	<== NOT EXECUTED
   44cb6:	6708           	beqs 44cc0 <rtems_semaphore_create+0xb4>          	<== NOT EXECUTED
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
   44cb8:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   44cba:	2d41 fff0      	movel %d1,%fp@(-16)                               	<== NOT EXECUTED
   44cbe:	6014           	bras 44cd4 <rtems_semaphore_create+0xc8>          	<== NOT EXECUTED
    else if ( _Attributes_Is_priority_ceiling( attribute_set ) )
   44cc0:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   44cc2:	6c04           	bges 44cc8 <rtems_semaphore_create+0xbc>          	<== NOT EXECUTED
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING;
   44cc4:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   44cc6:	6008           	bras 44cd0 <rtems_semaphore_create+0xc4>          	<== NOT EXECUTED
    else if ( _Attributes_Is_priority( attribute_set ) )
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY;
   44cc8:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   44cca:	56c0           	sne %d0                                           	<== NOT EXECUTED
   44ccc:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   44cce:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   44cd0:	2d40 fff0      	movel %d0,%fp@(-16)                               	<== NOT EXECUTED
    else
      the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO;


    if ( _Attributes_Is_binary_semaphore( attribute_set ) ) {
   44cd4:	7210           	moveq #16,%d1                                     	<== NOT EXECUTED
   44cd6:	b283           	cmpl %d3,%d1                                      	<== NOT EXECUTED
   44cd8:	661e           	bnes 44cf8 <rtems_semaphore_create+0xec>          	<== NOT EXECUTED
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;

      switch ( the_mutex_attributes.discipline ) {
   44cda:	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;
   44cde:	42ae ffea      	clrl %fp@(-22)                                    	<== NOT EXECUTED

      switch ( the_mutex_attributes.discipline ) {
   44ce2:	7601           	moveq #1,%d3                                      	<== NOT EXECUTED
   44ce4:	b680           	cmpl %d0,%d3                                      	<== NOT EXECUTED
   44ce6:	6416           	bccs 44cfe <rtems_semaphore_create+0xf2>          	<== NOT EXECUTED
   44ce8:	123c 0003      	moveb #3,%d1                                      	<== NOT EXECUTED
   44cec:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   44cee:	6514           	bcss 44d04 <rtems_semaphore_create+0xf8>          	<== 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;
   44cf0:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   44cf2:	1d40 ffee      	moveb %d0,%fp@(-18)                               	<== NOT EXECUTED
   44cf6:	600c           	bras 44d04 <rtems_semaphore_create+0xf8>          	<== NOT EXECUTED
          break;
      }
    } else {
      the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_BLOCKS;
   44cf8:	7202           	moveq #2,%d1                                      	<== NOT EXECUTED
   44cfa:	2d41 ffea      	movel %d1,%fp@(-22)                               	<== NOT EXECUTED
      the_mutex_attributes.only_owner_release = FALSE;
   44cfe:	4203           	clrb %d3                                          	<== NOT EXECUTED
   44d00:	1d43 ffee      	moveb %d3,%fp@(-18)                               	<== NOT EXECUTED
    }

    the_mutex_attributes.priority_ceiling = priority_ceiling;

    mutex_status = _CORE_mutex_Initialize(
   44d04:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   44d06:	b084           	cmpl %d4,%d0                                      	<== NOT EXECUTED
   44d08:	57c0           	seq %d0                                           	<== NOT EXECUTED
   44d0a:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   44d0c:	4480           	negl %d0                                          	<== NOT EXECUTED
   44d0e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   44d10:	486e ffea      	pea %fp@(-22)                                     	<== 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;
   44d14:	2d6e 0014 fff4 	movel %fp@(20),%fp@(-12)                          	<== NOT EXECUTED

    mutex_status = _CORE_mutex_Initialize(
   44d1a:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   44d1e:	4eb9 0004 58ec 	jsr 458ec <_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 ) {
   44d24:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   44d2a:	7206           	moveq #6,%d1                                      	<== NOT EXECUTED
   44d2c:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   44d2e:	664a           	bnes 44d7a <rtems_semaphore_create+0x16e>         	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
  Semaphore_Control *the_semaphore
)
{
  _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
   44d30:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44d32:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44d38:	4eb9 0004 630c 	jsr 4630c <_Objects_Free>                         	<== NOT EXECUTED
       _Semaphore_Free( the_semaphore );
       _Thread_Enable_dispatch();
   44d3e:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44d44:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   44d46:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
   44d48:	6054           	bras 44d9e <rtems_semaphore_create+0x192>         	<== NOT EXECUTED
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;

    _CORE_semaphore_Initialize(
   44d4a:	2f04           	movel %d4,%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;
   44d4c:	44c2           	movew %d2,%ccr                                    	<== NOT EXECUTED
   44d4e:	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(
   44d50:	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;
   44d54:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   44d56:	5280           	addql #1,%d0                                      	<== NOT EXECUTED

    /*
     *  This effectively disables limit checking.
     */

    the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
   44d58:	76ff           	moveq #-1,%d3                                     	<== NOT EXECUTED
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;

    _CORE_semaphore_Initialize(
   44d5a:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
       _Thread_Enable_dispatch();
       return RTEMS_INVALID_PRIORITY;
     }
  } else {
    if ( _Attributes_Is_priority( attribute_set ) )
      the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY;
   44d5e:	2d40 fffc      	movel %d0,%fp@(-4)                                	<== NOT EXECUTED

    /*
     *  This effectively disables limit checking.
     */

    the_semaphore_attributes.maximum_count = 0xFFFFFFFF;
   44d62:	2d43 fff8      	movel %d3,%fp@(-8)                                	<== NOT EXECUTED

    /*
     *  The following are just to make Purify happy.
     */

    the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES;
   44d66:	42ae ffea      	clrl %fp@(-22)                                    	<== NOT EXECUTED
    the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM;
   44d6a:	42ae fff4      	clrl %fp@(-12)                                    	<== NOT EXECUTED

    _CORE_semaphore_Initialize(
   44d6e:	4eb9 0004 5bc0 	jsr 45bc0 <_CORE_semaphore_Initialize>            	<== NOT EXECUTED
   44d74:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   44d7a:	2079 0005 6bf2 	moveal 56bf2 <_Semaphore_Information+0x1a>,%a0    	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   44d80:	2545 000c      	movel %d5,%a2@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   44d84:	4280           	clrl %d0                                          	<== NOT EXECUTED
   44d86:	302a 000a      	movew %a2@(10),%d0                                	<== NOT EXECUTED
   44d8a:	218a 0c00      	movel %a2,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
    &_Semaphore_Information,
    &the_semaphore->Object,
    (Objects_Name) name
  );

  *id = the_semaphore->Object.id;
   44d8e:	26aa 0008      	movel %a2@(8),%a3@                                	<== NOT EXECUTED
      the_semaphore->Object.id,
      name,
      0                          /* Not used */
    );
#endif
  _Thread_Enable_dispatch();
   44d92:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44d98:	4280           	clrl %d0                                          	<== NOT EXECUTED
   44d9a:	6002           	bras 44d9e <rtems_semaphore_create+0x192>         	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
   44d9c:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
}
   44d9e:	4cee 0c3c ffd0 	moveml %fp@(-48),%d2-%d5/%a2-%a3                  	<== NOT EXECUTED
   44da4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44da6:	4e75           	rts

00044da8 <rtems_semaphore_delete>:
#endif

rtems_status_code rtems_semaphore_delete(
  rtems_id   id
)
{
   44da8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   44dac:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Semaphore_Control *)
   44dae:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   44db2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   44db6:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44dbc:	4eb9 0004 646c 	jsr 4646c <_Objects_Get>                          	<== NOT EXECUTED
  register Semaphore_Control *the_semaphore;
  Objects_Locations           location;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   44dc2:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   44dc8:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   44dca:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   44dce:	6704           	beqs 44dd4 <rtems_semaphore_delete+0x2c>          	<== NOT EXECUTED
   44dd0:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   44dd2:	606c           	bras 44e40 <rtems_semaphore_delete+0x98>          	<== NOT EXECUTED
   44dd4:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   44dd6:	c0aa 0010      	andl %a2@(16),%d0                                 	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   44dda:	6728           	beqs 44e04 <rtems_semaphore_delete+0x5c>          	<== NOT EXECUTED
        if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) &&
   44ddc:	4aaa 0062      	tstl %a2@(98)                                     	<== NOT EXECUTED
   44de0:	6610           	bnes 44df2 <rtems_semaphore_delete+0x4a>          	<== NOT EXECUTED
   44de2:	7220           	moveq #32,%d1                                     	<== NOT EXECUTED
   44de4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   44de6:	670a           	beqs 44df2 <rtems_semaphore_delete+0x4a>          	<== NOT EXECUTED
             !_Attributes_Is_simple_binary_semaphore(
                 the_semaphore->attribute_set ) ) {
          _Thread_Enable_dispatch();
   44de8:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44dee:	700c           	moveq #12,%d0                                     	<== NOT EXECUTED
   44df0:	604e           	bras 44e40 <rtems_semaphore_delete+0x98>          	<== NOT EXECUTED
          return RTEMS_RESOURCE_IN_USE;
        }
        _CORE_mutex_Flush(
   44df2:	4878 0004      	pea 4 <FPCONTEXT_ARG>                             	<== NOT EXECUTED
   44df6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   44df8:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   44dfc:	4eb9 0004 58e0 	jsr 458e0 <_CORE_mutex_Flush>                     	<== NOT EXECUTED
   44e02:	6010           	bras 44e14 <rtems_semaphore_delete+0x6c>          	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          SEMAPHORE_MP_OBJECT_WAS_DELETED,
          CORE_MUTEX_WAS_DELETED
        );
      } else {
        _CORE_semaphore_Flush(
   44e04:	4878 0002      	pea 2 <DOUBLE_FLOAT>                              	<== NOT EXECUTED
   44e08:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   44e0a:	486a 0014      	pea %a2@(20)                                      	<== NOT EXECUTED
   44e0e:	4eb9 0004 5bb4 	jsr 45bb4 <_CORE_semaphore_Flush>                 	<== NOT EXECUTED
          SEMAPHORE_MP_OBJECT_WAS_DELETED,
          CORE_SEMAPHORE_WAS_DELETED
        );
     }

      _Objects_Close( &_Semaphore_Information, &the_semaphore->Object );
   44e14:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   44e16:	2e8a           	movel %a2,%sp@                                    	<== NOT EXECUTED
   44e18:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44e1e:	4eb9 0004 6094 	jsr 46094 <_Objects_Close>                        	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Semaphore_Free (
  Semaphore_Control *the_semaphore
)
{
  _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
   44e24:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44e26:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44e2c:	4eb9 0004 630c 	jsr 4630c <_Objects_Free>                         	<== NOT EXECUTED
          0,                         /* Not used */
          0                          /* Not used */
        );
      }
#endif
      _Thread_Enable_dispatch();
   44e32:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44e38:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   44e3e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   44e40:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   44e44:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44e46:	4e75           	rts

0005d324 <rtems_semaphore_flush>:
#endif

rtems_status_code rtems_semaphore_flush(
  rtems_id        id
)
{
   5d324:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5d328:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5d32c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5d330:	4879 0009 2594 	pea 92594 <_Semaphore_Information>                	<== NOT EXECUTED
   5d336:	4eb9 0004 a190 	jsr 4a190 <_Objects_Get>                          	<== NOT EXECUTED
  register Semaphore_Control *the_semaphore;
  Objects_Locations           location;

  the_semaphore = _Semaphore_Get( id, &location );
  switch ( location ) {
   5d33c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   5d342:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   5d344:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5d348:	6704           	beqs 5d34e <rtems_semaphore_flush+0x2a>           	<== NOT EXECUTED
   5d34a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   5d34c:	603c           	bras 5d38a <rtems_semaphore_flush+0x66>           	<== NOT EXECUTED
   5d34e:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   5d350:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   5d352:	0681 0000 0014 	addil #20,%d1                                     	<== NOT EXECUTED
   5d358:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   5d35c:	6710           	beqs 5d36e <rtems_semaphore_flush+0x4a>           	<== NOT EXECUTED
        _CORE_mutex_Flush(
   5d35e:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   5d362:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5d364:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   5d366:	4eb9 0004 94c0 	jsr 494c0 <_CORE_mutex_Flush>                     	<== NOT EXECUTED
   5d36c:	600e           	bras 5d37c <rtems_semaphore_flush+0x58>           	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          SEND_OBJECT_WAS_DELETED,
          CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT
        );
      } else {
        _CORE_semaphore_Flush(
   5d36e:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   5d372:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   5d374:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   5d376:	4eb9 0004 9794 	jsr 49794 <_CORE_semaphore_Flush>                 	<== NOT EXECUTED
   5d37c:	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();
   5d382:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5d388:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   5d38a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d38c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e630 <rtems_semaphore_ident>:
rtems_status_code rtems_semaphore_ident(
  rtems_name  name,
  uint32_t    node,
  rtems_id   *id
)
{
   4e630:	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 );
   4e634:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   4e638:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4e63c:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e640:	4879 0006 c710 	pea 6c710 <_Semaphore_Information>                	<== NOT EXECUTED
   4e646:	4eb9 0005 1874 	jsr 51874 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4e64c:	41f9 0006 597e 	lea 6597e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED

  return _Status_Object_name_errors_to_status[ status ];
}
   4e652:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4e656:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e658:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044e48 <rtems_semaphore_obtain>:
rtems_status_code rtems_semaphore_obtain(
  rtems_id        id,
  rtems_option    option_set,
  rtems_interval  timeout
)
{
   44e48:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   44e4c:	48d7 001c      	moveml %d2-%d4,%sp@                               	<== NOT EXECUTED
  Objects_Id         id,
  Objects_Locations *location,
  ISR_Level         *level
)
{
  return (Semaphore_Control *)
   44e50:	486e fff8      	pea %fp@(-8)                                      	<== NOT EXECUTED
   44e54:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   44e58:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   44e5c:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   44e60:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   44e62:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
   44e66:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44e6c:	4eb9 0004 641c 	jsr 4641c <_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 ) {
   44e72:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   44e78:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   44e7a:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   44e7e:	6706           	beqs 44e86 <rtems_semaphore_obtain+0x3e>          	<== NOT EXECUTED
   44e80:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   44e82:	6000 00c0      	braw 44f44 <rtems_semaphore_obtain+0xfc>          	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   44e86:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   44e88:	c0a9 0010      	andl %a1@(16),%d0                                 	<== NOT EXECUTED
   44e8c:	6734           	beqs 44ec2 <rtems_semaphore_obtain+0x7a>          	<== NOT EXECUTED
        _CORE_mutex_Seize(
   44e8e:	2f2e fff8      	movel %fp@(-8),%sp@-                              	<== NOT EXECUTED
   44e92:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   44e94:	b182           	eorl %d0,%d2                                      	<== NOT EXECUTED
   44e96:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   44e98:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   44e9a:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   44e9c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   44e9e:	4869 0014      	pea %a1@(20)                                      	<== NOT EXECUTED
   44ea2:	4eb9 0004 5a00 	jsr 45a00 <_CORE_mutex_Seize>                     	<== NOT EXECUTED
          id,
          ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
          timeout,
          level
        );
        return _Semaphore_Translate_core_mutex_return_code(
   44ea8:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   44eae:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   44eb2:	4eb9 0004 4fdc 	jsr 44fdc <_Semaphore_Translate_core_mutex_return_code>	<== NOT EXECUTED
   44eb8:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   44ebe:	6000 0084      	braw 44f44 <rtems_semaphore_obtain+0xfc>          	<== NOT EXECUTED
  Watchdog_Interval        timeout,
  ISR_Level               *level_p
)
{
  Thread_Control *executing;
  ISR_Level       level = *level_p;
   44ec2:	222e fff8      	movel %fp@(-8),%d1                                	<== NOT EXECUTED

  /* disabled when you get here */

  executing = _Thread_Executing;
   44ec6:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
  executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
   44ecc:	42a8 0034      	clrl %a0@(52)                                     	<== NOT EXECUTED
  if ( the_semaphore->count != 0 ) {
   44ed0:	2029 005c      	movel %a1@(92),%d0                                	<== NOT EXECUTED
   44ed4:	670a           	beqs 44ee0 <rtems_semaphore_obtain+0x98>          	<== NOT EXECUTED
    the_semaphore->count -= 1;
   44ed6:	5380           	subql #1,%d0                                      	<== NOT EXECUTED
   44ed8:	2340 005c      	movel %d0,%a1@(92)                                	<== NOT EXECUTED
    _ISR_Enable( level );
   44edc:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   44ede:	6052           	bras 44f32 <rtems_semaphore_obtain+0xea>          	<== NOT EXECUTED
    return;
  }

  if ( !wait ) {
   44ee0:	0802 0000      	btst #0,%d2                                       	<== NOT EXECUTED
   44ee4:	670a           	beqs 44ef0 <rtems_semaphore_obtain+0xa8>          	<== NOT EXECUTED
    _ISR_Enable( level );
   44ee6:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
   44ee8:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   44eea:	2140 0034      	movel %d0,%a0@(52)                                	<== NOT EXECUTED
   44eee:	6042           	bras 44f32 <rtems_semaphore_obtain+0xea>          	<== NOT EXECUTED
   44ef0:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   44ef6:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   44ef8:	23c0 0005 6ca4 	movel %d0,56ca4 <_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;
   44efe:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   44f00:	2340 0044      	movel %d0,%a1@(68)                                	<== NOT EXECUTED
    return;
  }

  _Thread_Disable_dispatch();
  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
  executing->Wait.queue          = &the_semaphore->Wait_queue;
   44f04:	2009           	movel %a1,%d0                                     	<== NOT EXECUTED
   44f06:	0680 0000 0014 	addil #20,%d0                                     	<== NOT EXECUTED
  executing->Wait.id             = id;
   44f0c:	2143 0020      	movel %d3,%a0@(32)                                	<== NOT EXECUTED
    return;
  }

  _Thread_Disable_dispatch();
  _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue );
  executing->Wait.queue          = &the_semaphore->Wait_queue;
   44f10:	2140 0044      	movel %d0,%a0@(68)                                	<== NOT EXECUTED
  executing->Wait.id             = id;
  _ISR_Enable( level );
   44f14:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED

  _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout );
   44f16:	4879 0004 73ec 	pea 473ec <_Thread_queue_Timeout>                 	<== NOT EXECUTED
   44f1c:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   44f1e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   44f20:	4eb9 0004 70b4 	jsr 470b4 <_Thread_queue_Enqueue_with_handler>    	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   44f26:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   44f2c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
        id,
        ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE),
        timeout,
        &level
      );
      return _Semaphore_Translate_core_semaphore_return_code(
   44f32:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   44f38:	2f28 0034      	movel %a0@(52),%sp@-                              	<== NOT EXECUTED
   44f3c:	4eb9 0004 4ff2 	jsr 44ff2 <_Semaphore_Translate_core_semaphore_return_code>	<== NOT EXECUTED
   44f42:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      break;

  }

  return RTEMS_INVALID_ID;
}
   44f44:	4cee 001c ffec 	moveml %fp@(-20),%d2-%d4                          	<== NOT EXECUTED
   44f4a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44f4c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00044f50 <rtems_semaphore_release>:
#endif

rtems_status_code rtems_semaphore_release(
  rtems_id   id
)
{
   44f50:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   44f54:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   44f56:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   44f58:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Semaphore_Control *)
   44f5c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   44f60:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   44f62:	4879 0005 6bd8 	pea 56bd8 <_Semaphore_Information>                	<== NOT EXECUTED
   44f68:	4eb9 0004 646c 	jsr 4646c <_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 ) {
   44f6e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   44f74:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   44f76:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   44f7a:	6704           	beqs 44f80 <rtems_semaphore_release+0x30>         	<== NOT EXECUTED
   44f7c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   44f7e:	604e           	bras 44fce <rtems_semaphore_release+0x7e>         	<== NOT EXECUTED
   44f80:	2200           	movel %d0,%d1                                     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) {
   44f82:	7030           	moveq #48,%d0                                     	<== NOT EXECUTED
   44f84:	0681 0000 0014 	addil #20,%d1                                     	<== NOT EXECUTED
   44f8a:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   44f8e:	45f9 0004 6c4e 	lea 46c4e <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
   44f94:	671a           	beqs 44fb0 <rtems_semaphore_release+0x60>         	<== NOT EXECUTED
        mutex_status = _CORE_mutex_Surrender(
   44f96:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   44f98:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   44f9a:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   44f9c:	4eb9 0004 5aa8 	jsr 45aa8 <_CORE_mutex_Surrender>                 	<== NOT EXECUTED
   44fa2:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
          &the_semaphore->Core_control.mutex,
          id,
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
   44fa4:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
        return _Semaphore_Translate_core_mutex_return_code( mutex_status );
   44fa6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   44fa8:	4eb9 0004 4fdc 	jsr 44fdc <_Semaphore_Translate_core_mutex_return_code>	<== NOT EXECUTED
   44fae:	6018           	bras 44fc8 <rtems_semaphore_release+0x78>         	<== NOT EXECUTED
      } else {
        semaphore_status = _CORE_semaphore_Surrender(
   44fb0:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   44fb2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   44fb4:	2f01           	movel %d1,%sp@-                                   	<== NOT EXECUTED
   44fb6:	4eb9 0004 5c08 	jsr 45c08 <_CORE_semaphore_Surrender>             	<== NOT EXECUTED
   44fbc:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
          &the_semaphore->Core_control.semaphore,
          id,
          MUTEX_MP_SUPPORT
        );
        _Thread_Enable_dispatch();
   44fbe:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
        return
   44fc0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   44fc2:	4eb9 0004 4ff2 	jsr 44ff2 <_Semaphore_Translate_core_semaphore_return_code>	<== NOT EXECUTED
   44fc8:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   44fce:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   44fd2:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   44fd6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   44fd8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045514 <rtems_shutdown_executive>:
 */

void rtems_shutdown_executive(
   uint32_t   result
)
{
   45514:	4e56 ffcc      	linkw %fp,#-52                                    	<== NOT EXECUTED
  if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) {
   45518:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4551a:	b0b9 0005 6e36 	cmpl 56e36 <_System_state_Current>,%d0            	<== NOT EXECUTED
   45520:	6718           	beqs 4553a <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 );
   45522:	4879 0005 6c70 	pea 56c70 <_Thread_BSP_context>                   	<== NOT EXECUTED
   45528:	486e ffcc      	pea %fp@(-52)                                     	<== NOT EXECUTED
   4552c:	23c0 0005 6e36 	movel %d0,56e36 <_System_state_Current>           	<== NOT EXECUTED
   45532:	4eb9 0004 7eac 	jsr 47eac <_CPU_Context_switch>                   	<== NOT EXECUTED
   45538:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    _System_state_Set( SYSTEM_STATE_SHUTDOWN );
    _Thread_Stop_multitasking();
  }
}
   4553a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4553c:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045ad8 <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 ];
   45ad8:	2079 0005 8cfa 	moveal 58cfa <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45ade:	2039 0005 8c3c 	movel 58c3c <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED

rtems_status_code rtems_signal_catch(
  rtems_asr_entry   asr_handler,
  rtems_mode        mode_set
)
{
   45ae4:	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 ];
   45ae8:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED

rtems_status_code rtems_signal_catch(
  rtems_asr_entry   asr_handler,
  rtems_mode        mode_set
)
{
   45aec:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   45af0:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45af2:	23c0 0005 8c3c 	movel %d0,58c3c <_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 ) ) {
   45af8:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   45afa:	670c           	beqs 45b08 <rtems_signal_catch+0x30>              	<== NOT EXECUTED
    asr->mode_set = mode_set;
    asr->handler = asr_handler;
   45afc:	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;
   45b00:	216e 000c 000e 	movel %fp@(12),%a0@(14)                           	<== NOT EXECUTED
   45b06:	601a           	bras 45b22 <rtems_signal_catch+0x4a>              	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
  ASR_Information *information
)
{
  information->is_enabled      = true;
   45b08:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   45b0a:	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;
   45b0e:	42a8 001a      	clrl %a0@(26)                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _ASR_Initialize (
  ASR_Information *information
)
{
  information->is_enabled      = true;
  information->handler         = NULL;
   45b12:	42a8 000a      	clrl %a0@(10)                                     	<== NOT EXECUTED
  information->mode_set        = RTEMS_DEFAULT_MODES;
   45b16:	42a8 000e      	clrl %a0@(14)                                     	<== NOT EXECUTED
  information->signals_posted  = 0;
   45b1a:	42a8 0012      	clrl %a0@(18)                                     	<== NOT EXECUTED
  information->signals_pending = 0;
   45b1e:	42a8 0016      	clrl %a0@(22)                                     	<== NOT EXECUTED
    asr->handler = asr_handler;
  }
  else
    _ASR_Initialize( asr );
  _Thread_Enable_dispatch();
   45b22:	4eb9 0004 79b6 	jsr 479b6 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45b28:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45b2a:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45b2c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004e81c <rtems_signal_send>:

rtems_status_code rtems_signal_send(
  Objects_Id        id,
  rtems_signal_set  signal_set
)
{
   4e81c:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4e820:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4e822:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;
  ASR_Information         *asr;

  if ( !signal_set )
   4e826:	6606           	bnes 4e82e <rtems_signal_send+0x12>               	<== NOT EXECUTED
   4e828:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4e82a:	6000 0084      	braw 4e8b0 <rtems_signal_send+0x94>               	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  the_thread = _Thread_Get( id, &location );
   4e82e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4e832:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4e836:	4eb9 0005 1f1c 	jsr 51f1c <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4e83c:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  ASR_Information         *asr;

  if ( !signal_set )
    return RTEMS_INVALID_NUMBER;

  the_thread = _Thread_Get( id, &location );
   4e83e:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
  switch ( location ) {
   4e840:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4e844:	6704           	beqs 4e84a <rtems_signal_send+0x2e>               	<== NOT EXECUTED
   4e846:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4e848:	6066           	bras 4e8b0 <rtems_signal_send+0x94>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
   4e84a:	2069 010c      	moveal %a1@(268),%a0                              	<== NOT EXECUTED
      asr = &api->Signal;

      if ( ! _ASR_Is_null_handler( asr->handler ) ) {
   4e84e:	4aa8 000a      	tstl %a0@(10)                                     	<== NOT EXECUTED
   4e852:	6754           	beqs 4e8a8 <rtems_signal_send+0x8c>               	<== NOT EXECUTED
        if ( asr->is_enabled ) {
   4e854:	4a28 0008      	tstb %a0@(8)                                      	<== NOT EXECUTED
   4e858:	6732           	beqs 4e88c <rtems_signal_send+0x70>               	<== NOT EXECUTED
  rtems_signal_set *signal_set
)
{
  ISR_Level              _level;

  _ISR_Disable( _level );
   4e85a:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   4e860:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4e862:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4e864:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    *signal_set |= signals;
   4e866:	85a8 0012      	orl %d2,%a0@(18)                                  	<== NOT EXECUTED
  _ISR_Enable( _level );
   4e86a:	46c0           	movew %d0,%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 ) )
   4e86c:	2039 0006 c8ce 	movel 6c8ce <_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;
   4e872:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4e874:	1341 0075      	moveb %d1,%a1@(117)                               	<== NOT EXECUTED

          if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
   4e878:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4e87a:	6722           	beqs 4e89e <rtems_signal_send+0x82>               	<== NOT EXECUTED
   4e87c:	b3f9 0006 c8ee 	cmpal 6c8ee <_Thread_Executing>,%a1               	<== NOT EXECUTED
   4e882:	661a           	bnes 4e89e <rtems_signal_send+0x82>               	<== NOT EXECUTED
            _ISR_Signals_to_thread_executing = TRUE;
   4e884:	13c1 0006 c97c 	moveb %d1,6c97c <_ISR_Signals_to_thread_executing>	<== NOT EXECUTED
   4e88a:	6012           	bras 4e89e <rtems_signal_send+0x82>               	<== NOT EXECUTED
  rtems_signal_set *signal_set
)
{
  ISR_Level              _level;

  _ISR_Disable( _level );
   4e88c:	223c 0000 0700 	movel #1792,%d1                                   	<== NOT EXECUTED
   4e892:	40c0           	movew %sr,%d0                                     	<== NOT EXECUTED
   4e894:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4e896:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
    *signal_set |= signals;
   4e898:	85a8 0016      	orl %d2,%a0@(22)                                  	<== NOT EXECUTED
  _ISR_Enable( _level );
   4e89c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
        } else {
          _ASR_Post_signals( signal_set, &asr->signals_pending );
        }
        _Thread_Enable_dispatch();
   4e89e:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4e8a4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4e8a6:	6008           	bras 4e8b0 <rtems_signal_send+0x94>               	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   4e8a8:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4e8ae:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4e8b0:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   4e8b4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4e8b6:	4e75           	rts

00045008 <rtems_task_create>:
  size_t               stack_size,
  rtems_mode           initial_modes,
  rtems_attribute      attribute_set,
  Objects_Id          *id
)
{
   45008:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4500c:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   45010:	266e 0008      	moveal %fp@(8),%a3                                	<== NOT EXECUTED
   45014:	262e 000c      	movel %fp@(12),%d3                                	<== NOT EXECUTED
   45018:	242e 0014      	movel %fp@(20),%d2                                	<== NOT EXECUTED
   4501c:	282e 0018      	movel %fp@(24),%d4                                	<== NOT EXECUTED
   45020:	286e 001c      	moveal %fp@(28),%a4                               	<== NOT EXECUTED
  Priority_Control         core_priority;
  RTEMS_API_Control       *api;
  ASR_Information         *asr;


  if ( !id )
   45024:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   45026:	6606           	bnes 4502e <rtems_task_create+0x26>               	<== NOT EXECUTED
   45028:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4502a:	6000 00fc      	braw 45128 <rtems_task_create+0x120>              	<== NOT EXECUTED
   return RTEMS_INVALID_ADDRESS;

  if ( !rtems_is_name_valid( name ) )
   4502e:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   45030:	6606           	bnes 45038 <rtems_task_create+0x30>               	<== NOT EXECUTED
   45032:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   45034:	6000 00f2      	braw 45128 <rtems_task_create+0x120>              	<== NOT EXECUTED

  /*
   *  Validate the RTEMS API priority and convert it to the core priority range.
   */

  if ( !_Attributes_Is_system_task( the_attribute_set ) ) {
   45038:	4a44           	tstw %d4                                          	<== NOT EXECUTED
   4503a:	6d1e           	blts 4505a <rtems_task_create+0x52>               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
  rtems_task_priority the_priority
)
{
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
   4503c:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4503e:	6714           	beqs 45054 <rtems_task_create+0x4c>               	<== NOT EXECUTED
   45040:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45042:	1039 0005 5192 	moveb 55192 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   45048:	b083           	cmpl %d3,%d0                                      	<== NOT EXECUTED
   4504a:	54c0           	scc %d0                                           	<== NOT EXECUTED
   4504c:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4504e:	4480           	negl %d0                                          	<== NOT EXECUTED
    if ( !_RTEMS_tasks_Priority_is_valid( initial_priority ) )
   45050:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45052:	6606           	bnes 4505a <rtems_task_create+0x52>               	<== NOT EXECUTED
   45054:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
   45056:	6000 00d0      	braw 45128 <rtems_task_create+0x120>              	<== NOT EXECUTED
   */

  /*
   *  Lock the allocator mutex for protection
   */
  _RTEMS_Lock_allocator();
   4505a:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45060:	4eb9 0004 5810 	jsr 45810 <_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 );
   45066:	4879 0005 6c14 	pea 56c14 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   4506c:	4eb9 0004 600c 	jsr 4600c <_Objects_Allocate>                     	<== NOT EXECUTED
   *         the event of an error.
   */

  the_thread = _RTEMS_tasks_Allocate();

  if ( !the_thread ) {
   45072:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   45074:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   45076:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   45078:	6614           	bnes 4508e <rtems_task_create+0x86>               	<== NOT EXECUTED
    _RTEMS_Unlock_allocator();
   4507a:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45080:	4eb9 0004 5874 	jsr 45874 <_API_Mutex_Unlock>                     	<== NOT EXECUTED
   45086:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45088:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4508a:	6000 009c      	braw 45128 <rtems_task_create+0x120>              	<== NOT EXECUTED

  /*
   *  Initialize the core thread for this task.
   */

  status = _Thread_Initialize(
   4508e:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   45090:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
   45092:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
   45094:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   45096:	7a09           	moveq #9,%d5                                      	<== NOT EXECUTED
   45098:	2202           	movel %d2,%d1                                     	<== NOT EXECUTED
   4509a:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4509c:	eaa9           	lsrl %d5,%d1                                      	<== NOT EXECUTED
   4509e:	1a3c 0001      	moveb #1,%d5                                      	<== NOT EXECUTED
   450a2:	ca81           	andl %d1,%d5                                      	<== NOT EXECUTED
   450a4:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   450a6:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   450a8:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   450aa:	e088           	lsrl #8,%d0                                       	<== NOT EXECUTED
   450ac:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   450ae:	7a01           	moveq #1,%d5                                      	<== NOT EXECUTED
   450b0:	ca80           	andl %d0,%d5                                      	<== NOT EXECUTED
   450b2:	2f05           	movel %d5,%sp@-                                   	<== NOT EXECUTED
   450b4:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   450b6:	c084           	andl %d4,%d0                                      	<== NOT EXECUTED
   450b8:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   450ba:	47f9 0004 5874 	lea 45874 <_API_Mutex_Unlock>,%a3                 	<== NOT EXECUTED
   450c0:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   450c2:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   450c6:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   450c8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   450ca:	4879 0005 6c14 	pea 56c14 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   450d0:	4eb9 0004 6d0c 	jsr 46d0c <_Thread_Initialize>                    	<== NOT EXECUTED
    NULL,        /* no budget algorithm callout */
    _Modes_Get_interrupt_level(initial_modes),
    (Objects_Name) name
  );

  if ( !status ) {
   450d6:	dffc 0000 002c 	addal #44,%sp                                     	<== NOT EXECUTED
   450dc:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   450de:	6626           	bnes 45106 <rtems_task_create+0xfe>               	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _RTEMS_tasks_Free (
  Thread_Control *the_task
)
{
  _Objects_Free(
   450e0:	2f2a 0008      	movel %a2@(8),%sp@-                               	<== NOT EXECUTED
   450e4:	4eb9 0004 6390 	jsr 46390 <_Objects_Get_information_id>           	<== NOT EXECUTED
   450ea:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   450ec:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   450ee:	4eb9 0004 630c 	jsr 4630c <_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();
   450f4:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   450fa:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   450fc:	700d           	moveq #13,%d0                                     	<== NOT EXECUTED
   450fe:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45104:	6022           	bras 45128 <rtems_task_create+0x120>              	<== NOT EXECUTED
  }

  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
  asr = &api->Signal;

  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
   45106:	720a           	moveq #10,%d1                                     	<== NOT EXECUTED
   45108:	206a 010c      	moveal %a2@(268),%a0                              	<== NOT EXECUTED
   4510c:	e2aa           	lsrl %d1,%d2                                      	<== NOT EXECUTED
   4510e:	7a01           	moveq #1,%d5                                      	<== NOT EXECUTED

  *id = the_thread->Object.id;
   45110:	28aa 0008      	movel %a2@(8),%a4@                                	<== NOT EXECUTED
  }

  api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
  asr = &api->Signal;

  asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true;
   45114:	bb82           	eorl %d5,%d2                                      	<== NOT EXECUTED
   45116:	c485           	andl %d5,%d2                                      	<== NOT EXECUTED
   45118:	1142 0008      	moveb %d2,%a0@(8)                                 	<== NOT EXECUTED
    );

   }
#endif

  _RTEMS_Unlock_allocator();
   4511c:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45122:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   45124:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45126:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   45128:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4512e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45130:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045134 <rtems_task_delete>:
 */

rtems_status_code rtems_task_delete(
  Objects_Id id
)
{
   45134:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   45138:	48d7 1c00      	moveml %a2-%a4,%sp@                               	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  Objects_Information     *the_information;

  _RTEMS_Lock_allocator();
   4513c:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45142:	4eb9 0004 5810 	jsr 45810 <_API_Mutex_Lock>                       	<== NOT EXECUTED

  the_thread = _Thread_Get( id, &location );
   45148:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4514c:	49f9 0004 5874 	lea 45874 <_API_Mutex_Unlock>,%a4                 	<== NOT EXECUTED
   45152:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   45156:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4515c:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
  Objects_Locations        location;
  Objects_Information     *the_information;

  _RTEMS_Lock_allocator();

  the_thread = _Thread_Get( id, &location );
   45162:	2640           	moveal %d0,%a3                                    	<== NOT EXECUTED
  switch ( location ) {
   45164:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   45168:	663e           	bnes 451a8 <rtems_task_delete+0x74>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_information = _Objects_Get_information_id( the_thread->Object.id );
   4516a:	2f2b 0008      	movel %a3@(8),%sp@-                               	<== NOT EXECUTED
   4516e:	45f9 0004 6390 	lea 46390 <_Objects_Get_information_id>,%a2       	<== NOT EXECUTED
   45174:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
            0                                /* Not used */
          );
        }
      #endif

      _Thread_Close( the_information, the_thread );
   45176:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   45178:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4517a:	4eb9 0004 6938 	jsr 46938 <_Thread_Close>                         	<== NOT EXECUTED
   45180:	2f2b 0008      	movel %a3@(8),%sp@-                               	<== NOT EXECUTED
   45184:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   45186:	2f0b           	movel %a3,%sp@-                                   	<== NOT EXECUTED
   45188:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4518a:	4eb9 0004 630c 	jsr 4630c <_Objects_Free>                         	<== NOT EXECUTED

      _RTEMS_tasks_Free( the_thread );

      _RTEMS_Unlock_allocator();
   45190:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   45196:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   45198:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4519e:	dffc 0000 001c 	addal #28,%sp                                     	<== NOT EXECUTED
   451a4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   451a6:	600c           	bras 451b4 <rtems_task_delete+0x80>               	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }

  _RTEMS_Unlock_allocator();
   451a8:	2f39 0005 6d5a 	movel 56d5a <_RTEMS_Allocator_Mutex>,%sp@-        	<== NOT EXECUTED
   451ae:	4e94           	jsr %a4@                                          	<== NOT EXECUTED
   451b0:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   451b2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
  return RTEMS_INVALID_ID;
}
   451b4:	4cee 1c00 fff0 	moveml %fp@(-16),%a2-%a4                          	<== NOT EXECUTED
   451ba:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   451bc:	4e75           	rts                                               	<== NOT EXECUTED
	...

000466c4 <rtems_task_get_note>:
rtems_status_code rtems_task_get_note(
  Objects_Id  id,
  uint32_t    notepad,
  uint32_t   *note
)
{
   466c4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   466c8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   466ca:	2079 0005 a43e 	moveal 5a43e <_Configuration_Table>,%a0           	<== NOT EXECUTED
rtems_status_code rtems_task_get_note(
  Objects_Id  id,
  uint32_t    notepad,
  uint32_t   *note
)
{
   466d0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   466d2:	2068 003e      	moveal %a0@(62),%a0                               	<== NOT EXECUTED
rtems_status_code rtems_task_get_note(
  Objects_Id  id,
  uint32_t    notepad,
  uint32_t   *note
)
{
   466d6:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   466da:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   466de:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   466e2:	4a28 0004      	tstb %a0@(4)                                      	<== NOT EXECUTED
   466e6:	6604           	bnes 466ec <rtems_task_get_note+0x28>             	<== NOT EXECUTED
   466e8:	7016           	moveq #22,%d0                                     	<== NOT EXECUTED
   466ea:	605c           	bras 46748 <rtems_task_get_note+0x84>             	<== NOT EXECUTED
    return RTEMS_NOT_CONFIGURED;

  if ( !note )
   466ec:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   466ee:	6604           	bnes 466f4 <rtems_task_get_note+0x30>             	<== NOT EXECUTED
   466f0:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   466f2:	6054           	bras 46748 <rtems_task_get_note+0x84>             	<== 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 )
   466f4:	720f           	moveq #15,%d1                                     	<== NOT EXECUTED
   466f6:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   466f8:	6404           	bccs 466fe <rtems_task_get_note+0x3a>             	<== NOT EXECUTED
   466fa:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   466fc:	604a           	bras 46748 <rtems_task_get_note+0x84>             	<== NOT EXECUTED

  /*
   *  Optimize the most likely case to avoid the Thread_Dispatch.
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
   466fe:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   46700:	670c           	beqs 4670e <rtems_task_get_note+0x4a>             	<== NOT EXECUTED
   46702:	2079 0005 a462 	moveal 5a462 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46708:	b0a8 0008      	cmpl %a0@(8),%d0                                  	<== NOT EXECUTED
   4670c:	6610           	bnes 4671e <rtems_task_get_note+0x5a>             	<== NOT EXECUTED
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
   4670e:	2079 0005 a462 	moveal 5a462 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46714:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   46718:	24b0 2c1e      	movel %a0@(0000001e,%d2:l:4),%a2@                 	<== NOT EXECUTED
   4671c:	6028           	bras 46746 <rtems_task_get_note+0x82>             	<== NOT EXECUTED
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
   4671e:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   46722:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   46724:	4eb9 0004 8444 	jsr 48444 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   4672a:	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 );
   4672c:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   4672e:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   46732:	6704           	beqs 46738 <rtems_task_get_note+0x74>             	<== NOT EXECUTED
   46734:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   46736:	6010           	bras 46748 <rtems_task_get_note+0x84>             	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      *note = api->Notepads[ notepad ];
   46738:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   4673c:	24b0 2c1e      	movel %a0@(0000001e,%d2:l:4),%a2@                 	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   46740:	4eb9 0004 841a 	jsr 4841a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   46746:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   46748:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4674c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46750:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46752:	4e75           	rts

000451c0 <rtems_task_ident>:
rtems_status_code rtems_task_ident(
  rtems_name    name,
  uint32_t      node,
  Objects_Id   *id
)
{
   451c0:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   451c4:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   451c8:	226e 0010      	moveal %fp@(16),%a1                               	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  if ( !id )
   451cc:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   451ce:	6604           	bnes 451d4 <rtems_task_ident+0x14>                	<== NOT EXECUTED
   451d0:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   451d2:	6034           	bras 45208 <rtems_task_ident+0x48>                	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( name == OBJECTS_ID_OF_SELF ) {
   451d4:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   451d6:	660c           	bnes 451e4 <rtems_task_ident+0x24>                	<== NOT EXECUTED
    *id = _Thread_Executing->Object.id;
   451d8:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   451de:	22a8 0008      	movel %a0@(8),%a1@                                	<== NOT EXECUTED
   451e2:	6024           	bras 45208 <rtems_task_ident+0x48>                	<== NOT EXECUTED
    return RTEMS_SUCCESSFUL;
   }

  status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id );
   451e4:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   451e6:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   451ea:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   451ec:	4879 0005 6c14 	pea 56c14 <_RTEMS_tasks_Information>              	<== NOT EXECUTED
   451f2:	4eb9 0004 65d0 	jsr 465d0 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED

  return _Status_Object_name_errors_to_status[ status ];
   451f8:	41f9 0005 4196 	lea 54196 <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
   451fe:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   45202:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
}
   45208:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4520a:	4e75           	rts

00045550 <rtems_task_is_suspended>:
 */

rtems_status_code rtems_task_is_suspended(
  Objects_Id id
)
{
   45550:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   45554:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   45558:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4555c:	4eb9 0004 6f44 	jsr 46f44 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   45562:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   45564:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   45566:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4556a:	6704           	beqs 45570 <rtems_task_is_suspended+0x20>         	<== NOT EXECUTED
   4556c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4556e:	6018           	bras 45588 <rtems_task_is_suspended+0x38>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
   45570:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   45572:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   45576:	41f9 0004 6f1a 	lea 46f1a <_Thread_Enable_dispatch>,%a0           	<== NOT EXECUTED
   4557c:	6606           	bnes 45584 <rtems_task_is_suspended+0x34>         	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   4557e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   45580:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45582:	6004           	bras 45588 <rtems_task_is_suspended+0x38>         	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   45584:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   45586:	700f           	moveq #15,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45588:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4558a:	4e75           	rts

0004a7b8 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
  rtems_mode  mode_set,
  rtems_mode  mask,
  rtems_mode *previous_mode_set
)
{
   4a7b8:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4a7bc:	48d7 1c3c      	moveml %d2-%d5/%a2-%a4,%sp@                       	<== NOT EXECUTED
   4a7c0:	2a2e 0008      	movel %fp@(8),%d5                                 	<== NOT EXECUTED
   4a7c4:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4a7c8:	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 )
   4a7cc:	4a8c           	tstl %a4                                          	<== NOT EXECUTED
   4a7ce:	6606           	bnes 4a7d6 <rtems_task_mode+0x1e>                 	<== NOT EXECUTED
   4a7d0:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4a7d2:	6000 00fa      	braw 4a8ce <rtems_task_mode+0x116>                	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  executing     = _Thread_Executing;
   4a7d6:	2679 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a3              	<== NOT EXECUTED
  api = executing->API_Extensions[ THREAD_API_RTEMS ];
   4a7dc:	246b 010c      	moveal %a3@(268),%a2                              	<== NOT EXECUTED
  asr = &api->Signal;

  old_mode  = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
   4a7e0:	263c 0000 0100 	movel #256,%d3                                    	<== NOT EXECUTED
   4a7e6:	4a2b 0076      	tstb %a3@(118)                                    	<== NOT EXECUTED
   4a7ea:	6702           	beqs 4a7ee <rtems_task_mode+0x36>                 	<== NOT EXECUTED
   4a7ec:	4283           	clrl %d3                                          	<== NOT EXECUTED

  if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
   4a7ee:	4aab 007c      	tstl %a3@(124)                                    	<== NOT EXECUTED
   4a7f2:	6704           	beqs 4a7f8 <rtems_task_mode+0x40>                 	<== NOT EXECUTED
    old_mode |= RTEMS_NO_TIMESLICE;
  else
    old_mode |= RTEMS_TIMESLICE;
   4a7f4:	08c3 0009      	bset #9,%d3                                       	<== NOT EXECUTED

  old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
   4a7f8:	243c 0000 0400 	movel #1024,%d2                                   	<== NOT EXECUTED
   4a7fe:	4a2a 0008      	tstb %a2@(8)                                      	<== NOT EXECUTED
   4a802:	6702           	beqs 4a806 <rtems_task_mode+0x4e>                 	<== NOT EXECUTED
   4a804:	4282           	clrl %d2                                          	<== NOT EXECUTED
  old_mode |= _ISR_Get_level();
   4a806:	4eb9 0004 7f78 	jsr 47f78 <_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;
   4a80c:	8480           	orl %d0,%d2                                       	<== NOT EXECUTED
  old_mode |= _ISR_Get_level();

  *previous_mode_set = old_mode;
   4a80e:	8483           	orl %d3,%d2                                       	<== NOT EXECUTED
   4a810:	2882           	movel %d2,%a4@                                    	<== NOT EXECUTED

  /*
   *  These are generic thread scheduling characteristics.
   */

  if ( mask & RTEMS_PREEMPT_MASK )
   4a812:	0804 0008      	btst #8,%d4                                       	<== NOT EXECUTED
   4a816:	670e           	beqs 4a826 <rtems_task_mode+0x6e>                 	<== NOT EXECUTED
    executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE;
   4a818:	2005           	movel %d5,%d0                                     	<== NOT EXECUTED
   4a81a:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4a81c:	e088           	lsrl #8,%d0                                       	<== NOT EXECUTED
   4a81e:	b380           	eorl %d1,%d0                                      	<== NOT EXECUTED
   4a820:	c081           	andl %d1,%d0                                      	<== NOT EXECUTED
   4a822:	1740 0076      	moveb %d0,%a3@(118)                               	<== NOT EXECUTED

  if ( mask & RTEMS_TIMESLICE_MASK ) {
   4a826:	0804 0009      	btst #9,%d4                                       	<== NOT EXECUTED
   4a82a:	671c           	beqs 4a848 <rtems_task_mode+0x90>                 	<== NOT EXECUTED
    if ( _Modes_Is_timeslice(mode_set) ) {
   4a82c:	0805 0009      	btst #9,%d5                                       	<== NOT EXECUTED
   4a830:	6712           	beqs 4a844 <rtems_task_mode+0x8c>                 	<== NOT EXECUTED
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;
   4a832:	41f9 0005 6c54 	lea 56c54 <_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;
   4a838:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;
   4a83a:	2750 0078      	movel %a0@,%a3@(120)                              	<== 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;
   4a83e:	2740 007c      	movel %d0,%a3@(124)                               	<== NOT EXECUTED
   4a842:	6004           	bras 4a848 <rtems_task_mode+0x90>                 	<== NOT EXECUTED
      executing->cpu_time_budget  = _Thread_Ticks_per_timeslice;
    } else
      executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
   4a844:	42ab 007c      	clrl %a3@(124)                                    	<== NOT EXECUTED

  /*
   *  Set the new interrupt level
   */

  if ( mask & RTEMS_INTERRUPT_MASK )
   4a848:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
   4a84a:	c084           	andl %d4,%d0                                      	<== NOT EXECUTED
   4a84c:	6712           	beqs 4a860 <rtems_task_mode+0xa8>                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
  Modes_Control mode_set
)
{
  _ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
   4a84e:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4a850:	7007           	moveq #7,%d0                                      	<== NOT EXECUTED
   4a852:	c085           	andl %d5,%d0                                      	<== NOT EXECUTED
   4a854:	e188           	lsll #8,%d0                                       	<== NOT EXECUTED
   4a856:	0281 0000 f8ff 	andil #63743,%d1                                  	<== NOT EXECUTED
   4a85c:	8280           	orl %d0,%d1                                       	<== NOT EXECUTED
   4a85e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   */

  is_asr_enabled = FALSE;
  needs_asr_dispatching = FALSE;

  if ( mask & RTEMS_ASR_MASK ) {
   4a860:	0804 000a      	btst #10,%d4                                      	<== NOT EXECUTED
   4a864:	6746           	beqs 4a8ac <rtems_task_mode+0xf4>                 	<== NOT EXECUTED
   4a866:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4a868:	2205           	movel %d5,%d1                                     	<== NOT EXECUTED
   4a86a:	e0a9           	lsrl %d0,%d1                                      	<== NOT EXECUTED
   4a86c:	103c 0001      	moveb #1,%d0                                      	<== NOT EXECUTED
   4a870:	b181           	eorl %d0,%d1                                      	<== NOT EXECUTED
   4a872:	c280           	andl %d0,%d1                                      	<== NOT EXECUTED
    is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
    if ( is_asr_enabled != asr->is_enabled ) {
   4a874:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4a876:	102a 0008      	moveb %a2@(8),%d0                                 	<== NOT EXECUTED
   4a87a:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4a87c:	672e           	beqs 4a8ac <rtems_task_mode+0xf4>                 	<== NOT EXECUTED
      asr->is_enabled = is_asr_enabled;
   4a87e:	1541 0008      	moveb %d1,%a2@(8)                                 	<== NOT EXECUTED
)
{
  rtems_signal_set _signals;
  ISR_Level        _level;

  _ISR_Disable( _level );
   4a882:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4a888:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4a88a:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4a88c:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
    _signals                     = information->signals_pending;
   4a88e:	202a 0016      	movel %a2@(22),%d0                                	<== NOT EXECUTED
    information->signals_pending = information->signals_posted;
   4a892:	256a 0012 0016 	movel %a2@(18),%a2@(22)                           	<== NOT EXECUTED
    information->signals_posted  = _signals;
   4a898:	2540 0012      	movel %d0,%a2@(18)                                	<== NOT EXECUTED
  _ISR_Enable( _level );
   4a89c:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      _ASR_Swap_signals( asr );
      if ( _ASR_Are_signals_pending( asr ) ) {
   4a89e:	4aaa 0012      	tstl %a2@(18)                                     	<== NOT EXECUTED
   4a8a2:	6708           	beqs 4a8ac <rtems_task_mode+0xf4>                 	<== NOT EXECUTED
        needs_asr_dispatching = true;
        executing->do_post_task_switch_extension = true;
   4a8a4:	7401           	moveq #1,%d2                                      	<== NOT EXECUTED
   4a8a6:	1742 0075      	moveb %d2,%a3@(117)                               	<== NOT EXECUTED
   4a8aa:	6002           	bras 4a8ae <rtems_task_mode+0xf6>                 	<== NOT EXECUTED
   4a8ac:	4202           	clrb %d2                                          	<== NOT EXECUTED
      }
    }
  }

  if ( _System_state_Is_up(_System_state_Current) )
   4a8ae:	7203           	moveq #3,%d1                                      	<== NOT EXECUTED
   4a8b0:	b2b9 0005 6e36 	cmpl 56e36 <_System_state_Current>,%d1            	<== NOT EXECUTED
   4a8b6:	6614           	bnes 4a8cc <rtems_task_mode+0x114>                	<== NOT EXECUTED
    if ( _Thread_Evaluate_mode() || needs_asr_dispatching )
   4a8b8:	4eb9 0004 aa7c 	jsr 4aa7c <_Thread_Evaluate_mode>                 	<== NOT EXECUTED
   4a8be:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4a8c0:	6604           	bnes 4a8c6 <rtems_task_mode+0x10e>                	<== NOT EXECUTED
   4a8c2:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4a8c4:	6706           	beqs 4a8cc <rtems_task_mode+0x114>                	<== NOT EXECUTED
      _Thread_Dispatch();
   4a8c6:	4eb9 0004 6afc 	jsr 46afc <_Thread_Dispatch>                      	<== NOT EXECUTED
   4a8cc:	4280           	clrl %d0                                          	<== NOT EXECUTED

  return RTEMS_SUCCESSFUL;
}
   4a8ce:	4cee 1c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a4                  	<== NOT EXECUTED
   4a8d4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4a8d6:	4e75           	rts

000459a8 <rtems_task_restart>:

rtems_status_code rtems_task_restart(
  Objects_Id id,
  uint32_t   argument
)
{
   459a8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   459ac:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   459b0:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   459b4:	4eb9 0004 73e0 	jsr 473e0 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   459ba:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   459bc:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   459c0:	6704           	beqs 459c6 <rtems_task_restart+0x1e>              	<== NOT EXECUTED
   459c2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   459c4:	6028           	bras 459ee <rtems_task_restart+0x46>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( _Thread_Restart( the_thread, NULL, argument ) ) {
   459c6:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   459ca:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   459cc:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   459ce:	4eb9 0004 7b8c 	jsr 47b8c <_Thread_Restart>                       	<== NOT EXECUTED
   459d4:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   459da:	41f9 0004 73b6 	lea 473b6 <_Thread_Enable_dispatch>,%a0           	<== NOT EXECUTED
   459e0:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   459e2:	6706           	beqs 459ea <rtems_task_restart+0x42>              	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   459e4:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   459e6:	4280           	clrl %d0                                          	<== NOT EXECUTED
   459e8:	6004           	bras 459ee <rtems_task_restart+0x46>              	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   459ea:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   459ec:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   459ee:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   459f0:	4e75           	rts                                               	<== NOT EXECUTED
	...

000461c4 <rtems_task_resume>:
 */

rtems_status_code rtems_task_resume(
  Objects_Id id
)
{
   461c4:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   461c8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   461ca:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   461ce:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   461d2:	4eb9 0004 7e40 	jsr 47e40 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   461d8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   461da:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   461dc:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   461e0:	6704           	beqs 461e6 <rtems_task_resume+0x22>               	<== NOT EXECUTED
   461e2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   461e4:	6026           	bras 4620c <rtems_task_resume+0x48>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( _States_Is_suspended( the_thread->current_state ) ) {
   461e6:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   461e8:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   461ec:	45f9 0004 7de6 	lea 47de6 <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
   461f2:	6714           	beqs 46208 <rtems_task_resume+0x44>               	<== NOT EXECUTED
        _Thread_Resume( the_thread, TRUE );
   461f4:	4878 0001      	pea 1 <ADD>                                       	<== NOT EXECUTED
   461f8:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   461fa:	4eb9 0004 85ec 	jsr 485ec <_Thread_Resume>                        	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   46200:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   46202:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   46204:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46206:	6004           	bras 4620c <rtems_task_resume+0x48>               	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   46208:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4620a:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4620c:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   46210:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   46212:	4e75           	rts

0005d534 <rtems_task_self>:

#include <rtems/system.h>
#include <rtems/rtems/tasks.h>

rtems_id rtems_task_self(void)
{
   5d534:	2079 0009 271e 	moveal 9271e <_Thread_Executing>,%a0              	<== NOT EXECUTED
   5d53a:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   return _Thread_Executing->Object.id;
}
   5d53e:	2028 0008      	movel %a0@(8),%d0                                 	<== NOT EXECUTED
   5d542:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d544:	4e75           	rts                                               	<== NOT EXECUTED
	...

00046848 <rtems_task_set_note>:
rtems_status_code rtems_task_set_note(
  Objects_Id id,
  uint32_t   notepad,
  uint32_t   note
)
{
   46848:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4684c:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   4684e:	2079 0005 a43e 	moveal 5a43e <_Configuration_Table>,%a0           	<== NOT EXECUTED
rtems_status_code rtems_task_set_note(
  Objects_Id id,
  uint32_t   notepad,
  uint32_t   note
)
{
   46854:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   46856:	2068 003e      	moveal %a0@(62),%a0                               	<== NOT EXECUTED
rtems_status_code rtems_task_set_note(
  Objects_Id id,
  uint32_t   notepad,
  uint32_t   note
)
{
   4685a:	202e 0008      	movel %fp@(8),%d0                                 	<== NOT EXECUTED
   4685e:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   46862:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;
  RTEMS_API_Control       *api;

  if ( !rtems_configuration_get_notepads_enabled() )
   46866:	4a28 0004      	tstb %a0@(4)                                      	<== NOT EXECUTED
   4686a:	6604           	bnes 46870 <rtems_task_set_note+0x28>             	<== NOT EXECUTED
   4686c:	7016           	moveq #22,%d0                                     	<== NOT EXECUTED
   4686e:	6054           	bras 468c4 <rtems_task_set_note+0x7c>             	<== 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 )
   46870:	720f           	moveq #15,%d1                                     	<== NOT EXECUTED
   46872:	b282           	cmpl %d2,%d1                                      	<== NOT EXECUTED
   46874:	6404           	bccs 4687a <rtems_task_set_note+0x32>             	<== NOT EXECUTED
   46876:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   46878:	604a           	bras 468c4 <rtems_task_set_note+0x7c>             	<== NOT EXECUTED

  /*
   *  Optimize the most likely case to avoid the Thread_Dispatch.
   */

  if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ||
   4687a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4687c:	670c           	beqs 4688a <rtems_task_set_note+0x42>             	<== NOT EXECUTED
   4687e:	2079 0005 a462 	moveal 5a462 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46884:	b0a8 0008      	cmpl %a0@(8),%d0                                  	<== NOT EXECUTED
   46888:	6610           	bnes 4689a <rtems_task_set_note+0x52>             	<== NOT EXECUTED
       _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) {
      api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
   4688a:	2079 0005 a462 	moveal 5a462 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   46890:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   46894:	2183 2c1e      	movel %d3,%a0@(0000001e,%d2:l:4)                  	<== NOT EXECUTED
   46898:	6028           	bras 468c2 <rtems_task_set_note+0x7a>             	<== NOT EXECUTED
      return RTEMS_SUCCESSFUL;
  }

  the_thread = _Thread_Get( id, &location );
   4689a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4689e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   468a0:	4eb9 0004 8444 	jsr 48444 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   468a6:	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 );
   468a8:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   468aa:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   468ae:	6704           	beqs 468b4 <rtems_task_set_note+0x6c>             	<== NOT EXECUTED
   468b0:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   468b2:	6010           	bras 468c4 <rtems_task_set_note+0x7c>             	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
      api->Notepads[ notepad ] = note;
   468b4:	2068 010c      	moveal %a0@(268),%a0                              	<== NOT EXECUTED
   468b8:	2183 2c1e      	movel %d3,%a0@(0000001e,%d2:l:4)                  	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   468bc:	4eb9 0004 841a 	jsr 4841a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   468c2:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   468c4:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   468c8:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   468cc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   468ce:	4e75           	rts

00048cb8 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
  Objects_Id           id,
  rtems_task_priority  new_priority,
  rtems_task_priority *old_priority
)
{
   48cb8:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   48cbc:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   48cbe:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   48cc2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48cc4:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations               location;

  if ( new_priority != RTEMS_CURRENT_PRIORITY &&
   48cc8:	6710           	beqs 48cda <rtems_task_set_priority+0x22>         	<== NOT EXECUTED
   48cca:	4280           	clrl %d0                                          	<== NOT EXECUTED
   48ccc:	1039 0005 fde2 	moveb 5fde2 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   48cd2:	b082           	cmpl %d2,%d0                                      	<== NOT EXECUTED
   48cd4:	6404           	bccs 48cda <rtems_task_set_priority+0x22>         	<== NOT EXECUTED
   48cd6:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
   48cd8:	6056           	bras 48d30 <rtems_task_set_priority+0x78>         	<== NOT EXECUTED
       !_RTEMS_tasks_Priority_is_valid( new_priority ) )
    return RTEMS_INVALID_PRIORITY;

  if ( !old_priority )
   48cda:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   48cdc:	6604           	bnes 48ce2 <rtems_task_set_priority+0x2a>         	<== NOT EXECUTED
   48cde:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   48ce0:	604e           	bras 48d30 <rtems_task_set_priority+0x78>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
   48ce2:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   48ce6:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   48cea:	4eb9 0004 a8d4 	jsr 4a8d4 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   48cf0:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_PRIORITY;

  if ( !old_priority )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
   48cf2:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   48cf4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   48cf8:	6704           	beqs 48cfe <rtems_task_set_priority+0x46>         	<== NOT EXECUTED
   48cfa:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   48cfc:	6032           	bras 48d30 <rtems_task_set_priority+0x78>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      /* XXX need helper to "convert" from core priority */
      *old_priority = the_thread->current_priority;
   48cfe:	24a8 0014      	movel %a0@(20),%a2@                               	<== NOT EXECUTED
      if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
   48d02:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   48d04:	6722           	beqs 48d28 <rtems_task_set_priority+0x70>         	<== NOT EXECUTED
        the_thread->real_priority = new_priority;
   48d06:	2142 0018      	movel %d2,%a0@(24)                                	<== NOT EXECUTED
        if ( the_thread->resource_count == 0 ||
   48d0a:	4aa8 001c      	tstl %a0@(28)                                     	<== NOT EXECUTED
   48d0e:	6706           	beqs 48d16 <rtems_task_set_priority+0x5e>         	<== NOT EXECUTED
   48d10:	b4a8 0014      	cmpl %a0@(20),%d2                                 	<== NOT EXECUTED
   48d14:	6412           	bccs 48d28 <rtems_task_set_priority+0x70>         	<== NOT EXECUTED
             the_thread->current_priority > new_priority )
          _Thread_Change_priority( the_thread, new_priority, FALSE );
   48d16:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   48d18:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   48d1a:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   48d1c:	4eb9 0004 a374 	jsr 4a374 <_Thread_Change_priority>               	<== NOT EXECUTED
   48d22:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
      }
      _Thread_Enable_dispatch();
   48d28:	4eb9 0004 a87a 	jsr 4a87a <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   48d2e:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   48d30:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   48d34:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   48d38:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   48d3a:	4e75           	rts

000452a0 <rtems_task_start>:
rtems_status_code rtems_task_start(
  rtems_id         	id,
  rtems_task_entry 	entry_point,
  rtems_task_argument	argument
)
{
   452a0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   452a4:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   452a6:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  if ( entry_point == NULL )
   452aa:	6604           	bnes 452b0 <rtems_task_start+0x10>                	<== NOT EXECUTED
   452ac:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   452ae:	6046           	bras 452f6 <rtems_task_start+0x56>                	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get( id, &location );
   452b0:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   452b4:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   452b8:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   452be:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   452c0:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   452c4:	6704           	beqs 452ca <rtems_task_start+0x2a>                	<== NOT EXECUTED
   452c6:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   452c8:	602c           	bras 452f6 <rtems_task_start+0x56>                	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( _Thread_Start(
   452ca:	2f2e 0010      	movel %fp@(16),%sp@-                              	<== NOT EXECUTED
   452ce:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   452d0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   452d2:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   452d4:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   452d6:	4eb9 0004 76dc 	jsr 476dc <_Thread_Start>                         	<== NOT EXECUTED
   452dc:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   452e2:	41f9 0004 6c4e 	lea 46c4e <_Thread_Enable_dispatch>,%a0           	<== NOT EXECUTED
   452e8:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   452ea:	6706           	beqs 452f2 <rtems_task_start+0x52>                	<== NOT EXECUTED
             the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) {
        _Thread_Enable_dispatch();
   452ec:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   452ee:	4280           	clrl %d0                                          	<== NOT EXECUTED
   452f0:	6004           	bras 452f6 <rtems_task_start+0x56>                	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   452f2:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   452f4:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   452f6:	242e fff8      	movel %fp@(-8),%d2                                	<== NOT EXECUTED
   452fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   452fc:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045300 <rtems_task_suspend>:
 */

rtems_status_code rtems_task_suspend(
  Objects_Id id
)
{
   45300:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   45304:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   45306:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4530a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4530e:	4eb9 0004 6c78 	jsr 46c78 <_Thread_Get>                           	<== NOT EXECUTED
  switch ( location ) {
   45314:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
)
{
  register Thread_Control *the_thread;
  Objects_Locations        location;

  the_thread = _Thread_Get( id, &location );
   45316:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch ( location ) {
   45318:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4531c:	6704           	beqs 45322 <rtems_task_suspend+0x22>              	<== NOT EXECUTED
   4531e:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   45320:	6022           	bras 45344 <rtems_task_suspend+0x44>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_States_Is_suspended( the_thread->current_state ) ) {
   45322:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   45324:	c0a8 0010      	andl %a0@(16),%d0                                 	<== NOT EXECUTED
   45328:	45f9 0004 6c4e 	lea 46c4e <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
   4532e:	6610           	bnes 45340 <rtems_task_suspend+0x40>              	<== NOT EXECUTED
        _Thread_Suspend( the_thread );
   45330:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   45332:	4eb9 0004 7730 	jsr 47730 <_Thread_Suspend>                       	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   45338:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4533a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4533c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4533e:	6004           	bras 45344 <rtems_task_suspend+0x44>              	<== NOT EXECUTED
        return RTEMS_SUCCESSFUL;
      }
      _Thread_Enable_dispatch();
   45340:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   45342:	700f           	moveq #15,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   45344:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   45348:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4534a:	4e75           	rts

0005d738 <rtems_task_variable_add>:
rtems_status_code rtems_task_variable_add(
  rtems_id tid,
  void **ptr,
  void (*dtor)(void *)
)
{
   5d738:	4e56 fff0      	linkw %fp,#-16                                    	<== NOT EXECUTED
   5d73c:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   5d740:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
   5d744:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp, *new;

  if ( !ptr )
   5d748:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   5d74a:	6604           	bnes 5d750 <rtems_task_variable_add+0x18>         	<== NOT EXECUTED
   5d74c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   5d74e:	6070           	bras 5d7c0 <rtems_task_variable_add+0x88>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   5d750:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5d754:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5d758:	4eb9 0004 aa08 	jsr 4aa08 <_Thread_Get>                           	<== NOT EXECUTED
  switch (location) {
   5d75e:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  rtems_task_variable_t *tvp, *new;

  if ( !ptr )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   5d760:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
  switch (location) {
   5d762:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5d766:	6704           	beqs 5d76c <rtems_task_variable_add+0x34>         	<== NOT EXECUTED
   5d768:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   5d76a:	6054           	bras 5d7c0 <rtems_task_variable_add+0x88>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      /*
       *  Figure out if the variable is already in this task's list.
       */
      tvp = the_thread->task_variables;
   5d76c:	206a 011c      	moveal %a2@(284),%a0                              	<== NOT EXECUTED
   5d770:	6014           	bras 5d786 <rtems_task_variable_add+0x4e>         	<== NOT EXECUTED
      while (tvp) {
        if (tvp->ptr == ptr) {
   5d772:	b7e8 0004      	cmpal %a0@(4),%a3                                 	<== NOT EXECUTED
   5d776:	660c           	bnes 5d784 <rtems_task_variable_add+0x4c>         	<== NOT EXECUTED
          tvp->dtor = dtor;
   5d778:	2142 0010      	movel %d2,%a0@(16)                                	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   5d77c:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5d782:	603a           	bras 5d7be <rtems_task_variable_add+0x86>         	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
   5d784:	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) {
   5d786:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   5d788:	66e8           	bnes 5d772 <rtems_task_variable_add+0x3a>         	<== NOT EXECUTED
      }

      /*
       *  Now allocate memory for this task variable.
       */
      new = (rtems_task_variable_t *)
   5d78a:	4878 0014      	pea 14 <OPER2>                                    	<== NOT EXECUTED
   5d78e:	4eb9 0004 bb80 	jsr 4bb80 <_Workspace_Allocate>                   	<== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
   5d794:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      }

      /*
       *  Now allocate memory for this task variable.
       */
      new = (rtems_task_variable_t *)
   5d796:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   5d798:	43f9 0004 a9de 	lea 4a9de <_Thread_Enable_dispatch>,%a1           	<== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
   5d79e:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   5d7a0:	6606           	bnes 5d7a8 <rtems_task_variable_add+0x70>         	<== NOT EXECUTED
        _Thread_Enable_dispatch();
   5d7a2:	4e91           	jsr %a1@                                          	<== NOT EXECUTED
   5d7a4:	701a           	moveq #26,%d0                                     	<== NOT EXECUTED
   5d7a6:	6018           	bras 5d7c0 <rtems_task_variable_add+0x88>         	<== NOT EXECUTED
      }
      new->gval = *ptr;
      new->ptr = ptr;
      new->dtor = dtor;

      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
   5d7a8:	20aa 011c      	movel %a2@(284),%a0@                              	<== NOT EXECUTED
         _Workspace_Allocate(sizeof(rtems_task_variable_t));
      if (new == NULL) {
        _Thread_Enable_dispatch();
        return RTEMS_NO_MEMORY;
      }
      new->gval = *ptr;
   5d7ac:	2153 0008      	movel %a3@,%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;
   5d7b0:	2540 011c      	movel %d0,%a2@(284)                               	<== NOT EXECUTED
      if (new == NULL) {
        _Thread_Enable_dispatch();
        return RTEMS_NO_MEMORY;
      }
      new->gval = *ptr;
      new->ptr = ptr;
   5d7b4:	214b 0004      	movel %a3,%a0@(4)                                 	<== NOT EXECUTED
      new->dtor = dtor;
   5d7b8:	2142 0010      	movel %d2,%a0@(16)                                	<== NOT EXECUTED

      new->next = (struct rtems_task_variable_tt *)the_thread->task_variables;
      the_thread->task_variables = new;
      _Thread_Enable_dispatch();
   5d7bc:	4e91           	jsr %a1@                                          	<== NOT EXECUTED
   5d7be:	4280           	clrl %d0                                          	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   5d7c0:	4cee 0c04 fff0 	moveml %fp@(-16),%d2/%a2-%a3                      	<== NOT EXECUTED
   5d7c6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d7c8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0005d7cc <rtems_task_variable_delete>:

rtems_status_code rtems_task_variable_delete(
  rtems_id  tid,
  void    **ptr
)
{
   5d7cc:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5d7d0:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5d7d2:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d7d4:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp, *prev;

  if ( !ptr )
   5d7d8:	675a           	beqs 5d834 <rtems_task_variable_delete+0x68>      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  prev = NULL;

  the_thread = _Thread_Get (tid, &location);
   5d7da:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5d7de:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5d7e2:	4eb9 0004 aa08 	jsr 4aa08 <_Thread_Get>                           	<== NOT EXECUTED
  switch (location) {
   5d7e8:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
  if ( !ptr )
    return RTEMS_INVALID_ADDRESS;

  prev = NULL;

  the_thread = _Thread_Get (tid, &location);
   5d7ea:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
  switch (location) {
   5d7ec:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5d7f0:	6704           	beqs 5d7f6 <rtems_task_variable_delete+0x2a>      	<== NOT EXECUTED
   5d7f2:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   5d7f4:	6040           	bras 5d836 <rtems_task_variable_delete+0x6a>      	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      tvp = the_thread->task_variables;
   5d7f6:	206a 011c      	moveal %a2@(284),%a0                              	<== NOT EXECUTED
   5d7fa:	93c9           	subal %a1,%a1                                     	<== NOT EXECUTED
   5d7fc:	602c           	bras 5d82a <rtems_task_variable_delete+0x5e>      	<== NOT EXECUTED
      while (tvp) {
        if (tvp->ptr == ptr) {
   5d7fe:	b4a8 0004      	cmpl %a0@(4),%d2                                  	<== NOT EXECUTED
   5d802:	6622           	bnes 5d826 <rtems_task_variable_delete+0x5a>      	<== NOT EXECUTED
          if (prev)
   5d804:	4a89           	tstl %a1                                          	<== NOT EXECUTED
   5d806:	6704           	beqs 5d80c <rtems_task_variable_delete+0x40>      	<== NOT EXECUTED
            prev->next = tvp->next;
   5d808:	2290           	movel %a0@,%a1@                                   	<== NOT EXECUTED
   5d80a:	6004           	bras 5d810 <rtems_task_variable_delete+0x44>      	<== NOT EXECUTED
          else
            the_thread->task_variables = (rtems_task_variable_t *)tvp->next;
   5d80c:	2550 011c      	movel %a0@,%a2@(284)                              	<== NOT EXECUTED

          _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp );
   5d810:	2f08           	movel %a0,%sp@-                                   	<== NOT EXECUTED
   5d812:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5d814:	4eb9 0005 d8ac 	jsr 5d8ac <_RTEMS_Tasks_Invoke_task_variable_dtor>	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   5d81a:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5d820:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   5d822:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5d824:	6010           	bras 5d836 <rtems_task_variable_delete+0x6a>      	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        prev = tvp;
        tvp = (rtems_task_variable_t *)tvp->next;
   5d826:	2248           	moveal %a0,%a1                                    	<== NOT EXECUTED
   5d828:	2050           	moveal %a0@,%a0                                   	<== NOT EXECUTED
  the_thread = _Thread_Get (tid, &location);
  switch (location) {

    case OBJECTS_LOCAL:
      tvp = the_thread->task_variables;
      while (tvp) {
   5d82a:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   5d82c:	66d0           	bnes 5d7fe <rtems_task_variable_delete+0x32>      	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        prev = tvp;
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
   5d82e:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5d834:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
    case OBJECTS_ERROR:
        break;
  }

  return RTEMS_INVALID_ID;
}
   5d836:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   5d83a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5d83e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d840:	4e75           	rts                                               	<== NOT EXECUTED
	...

0005d844 <rtems_task_variable_get>:
rtems_status_code rtems_task_variable_get(
  rtems_id tid,
  void **ptr,
  void **result
)
{
   5d844:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   5d848:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   5d84a:	246e 0010      	moveal %fp@(16),%a2                               	<== NOT EXECUTED
   5d84e:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   5d850:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
  Thread_Control        *the_thread;
  Objects_Locations      location;
  rtems_task_variable_t *tvp;

  if ( !ptr )
   5d854:	6746           	beqs 5d89c <rtems_task_variable_get+0x58>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !result )
   5d856:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   5d858:	6742           	beqs 5d89c <rtems_task_variable_get+0x58>         	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   5d85a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   5d85e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   5d862:	4eb9 0004 aa08 	jsr 4aa08 <_Thread_Get>                           	<== NOT EXECUTED
  switch (location) {
   5d868:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !result )
    return RTEMS_INVALID_ADDRESS;

  the_thread = _Thread_Get (tid, &location);
   5d86a:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
  switch (location) {
   5d86c:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   5d870:	6704           	beqs 5d876 <rtems_task_variable_get+0x32>         	<== NOT EXECUTED
   5d872:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   5d874:	6028           	bras 5d89e <rtems_task_variable_get+0x5a>         	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      /*
       *  Figure out if the variable is in this task's list.
       */
      tvp = the_thread->task_variables;
   5d876:	2068 011c      	moveal %a0@(284),%a0                              	<== NOT EXECUTED
   5d87a:	6016           	bras 5d892 <rtems_task_variable_get+0x4e>         	<== NOT EXECUTED
      while (tvp) {
        if (tvp->ptr == ptr) {
   5d87c:	b4a8 0004      	cmpl %a0@(4),%d2                                  	<== NOT EXECUTED
   5d880:	660e           	bnes 5d890 <rtems_task_variable_get+0x4c>         	<== NOT EXECUTED
	  /*
	   * Should this return the current (i.e not the
	   * saved) value if `tid' is the current task?
	   */
          *result = tvp->tval;
   5d882:	24a8 000c      	movel %a0@(12),%a2@                               	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   5d886:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   5d88c:	4280           	clrl %d0                                          	<== NOT EXECUTED
   5d88e:	600e           	bras 5d89e <rtems_task_variable_get+0x5a>         	<== NOT EXECUTED
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
   5d890:	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) {
   5d892:	4a88           	tstl %a0                                          	<== NOT EXECUTED
   5d894:	66e6           	bnes 5d87c <rtems_task_variable_get+0x38>         	<== NOT EXECUTED
          _Thread_Enable_dispatch();
          return RTEMS_SUCCESSFUL;
        }
        tvp = (rtems_task_variable_t *)tvp->next;
      }
      _Thread_Enable_dispatch();
   5d896:	4eb9 0004 a9de 	jsr 4a9de <_Thread_Enable_dispatch>               	<== NOT EXECUTED
      return RTEMS_INVALID_ADDRESS;
   5d89c:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED

    case OBJECTS_ERROR:
      break;
  }
  return RTEMS_INVALID_ID;
}
   5d89e:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   5d8a2:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   5d8a6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   5d8a8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004534c <rtems_task_wake_after>:
 */

rtems_status_code rtems_task_wake_after(
  rtems_interval ticks
)
{
   4534c:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45350:	2039 0005 6ca4 	movel 56ca4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   45356:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   45358:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4535c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4535e:	23c0 0005 6ca4 	movel %d0,56ca4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
  _Thread_Disable_dispatch();
    if ( ticks == 0 ) {
   45364:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   45366:	6608           	bnes 45370 <rtems_task_wake_after+0x24>           	<== NOT EXECUTED
      _Thread_Yield_processor();
   45368:	4eb9 0004 7890 	jsr 47890 <_Thread_Yield_processor>               	<== NOT EXECUTED
   4536e:	604a           	bras 453ba <rtems_task_wake_after+0x6e>           	<== NOT EXECUTED
    } else {
      _Thread_Set_state( _Thread_Executing, STATES_DELAYING );
   45370:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>                            	<== NOT EXECUTED
   45374:	2f39 0005 6d62 	movel 56d62 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   4537a:	4eb9 0004 7490 	jsr 47490 <_Thread_Set_state>                     	<== NOT EXECUTED
      _Watchdog_Initialize(
   45380:	2079 0005 6d62 	moveal 56d62 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45386:	2028 0008      	movel %a0@(8),%d0                                 	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4538a:	223c 0004 6ac0 	movel #289472,%d1                                 	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45390:	2142 0054      	movel %d2,%a0@(84)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   45394:	2141 0064      	movel %d1,%a0@(100)                               	<== NOT EXECUTED
  the_watchdog->id        = id;
   45398:	2140 0068      	movel %d0,%a0@(104)                               	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4539c:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   453a0:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   453a4:	4868 0048      	pea %a0@(72)                                      	<== NOT EXECUTED
   453a8:	4879 0005 6d80 	pea 56d80 <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   453ae:	4eb9 0004 7bc4 	jsr 47bc4 <_Watchdog_Insert>                      	<== NOT EXECUTED
   453b4:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
        _Thread_Executing->Object.id,
        NULL
      );
      _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks );
    }
  _Thread_Enable_dispatch();
   453ba:	4eb9 0004 6c4e 	jsr 46c4e <_Thread_Enable_dispatch>               	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   453c0:	242e fffc      	movel %fp@(-4),%d2                                	<== NOT EXECUTED
   453c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   453c6:	4280           	clrl %d0                                          	<== NOT EXECUTED
   453c8:	4e75           	rts                                               	<== NOT EXECUTED
	...

00045e74 <rtems_task_wake_when>:
 */

rtems_status_code rtems_task_wake_when(
  rtems_time_of_day *time_buffer
)
{
   45e74:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
   45e78:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45e7a:	246e 0008      	moveal %fp@(8),%a2                                	<== NOT EXECUTED
  Watchdog_Interval   seconds;

  if ( !_TOD_Is_set )
   45e7e:	4a39 0005 8908 	tstb 58908 <_TOD_Is_set>                          	<== NOT EXECUTED
   45e84:	6606           	bnes 45e8c <rtems_task_wake_when+0x18>            	<== NOT EXECUTED
   45e86:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   45e88:	6000 009c      	braw 45f26 <rtems_task_wake_when+0xb2>            	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !time_buffer )
   45e8c:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   45e8e:	6606           	bnes 45e96 <rtems_task_wake_when+0x22>            	<== NOT EXECUTED
   45e90:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   45e92:	6000 0092      	braw 45f26 <rtems_task_wake_when+0xb2>            	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  time_buffer->ticks = 0;
   45e96:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED

  if ( !_TOD_Validate( time_buffer ) )
   45e9a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45e9c:	4eb9 0004 52ec 	jsr 452ec <_TOD_Validate>                         	<== NOT EXECUTED
   45ea2:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   45ea4:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   45ea6:	677c           	beqs 45f24 <rtems_task_wake_when+0xb0>            	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( time_buffer );
   45ea8:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   45eaa:	4eb9 0004 5238 	jsr 45238 <_TOD_To_seconds>                       	<== NOT EXECUTED

  if ( seconds <= _TOD_Seconds_since_epoch )
   45eb0:	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 );
   45eb2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED

  if ( seconds <= _TOD_Seconds_since_epoch )
   45eb4:	b0b9 0005 8986 	cmpl 58986 <_TOD_Now>,%d0                         	<== NOT EXECUTED
   45eba:	6368           	blss 45f24 <rtems_task_wake_when+0xb0>            	<== NOT EXECUTED
   45ebc:	2039 0005 88f4 	movel 588f4 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   45ec2:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   45ec4:	23c0 0005 88f4 	movel %d0,588f4 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  _Thread_Disable_dispatch();
    _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME );
   45eca:	4878 0010      	pea 10 <FP_STATE_SAVED>                           	<== NOT EXECUTED
   45ece:	2f39 0005 89b2 	movel 589b2 <_Thread_Executing>,%sp@-             	<== NOT EXECUTED
   45ed4:	4eb9 0004 7ff0 	jsr 47ff0 <_Thread_Set_state>                     	<== NOT EXECUTED
    _Watchdog_Initialize(
   45eda:	2079 0005 89b2 	moveal 589b2 <_Thread_Executing>,%a0              	<== NOT EXECUTED
   45ee0:	2028 0008      	movel %a0@(8),%d0                                 	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   45ee4:	2140 0068      	movel %d0,%a0@(104)                               	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45ee8:	95f9 0005 8986 	subal 58986 <_TOD_Now>,%a2                        	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   45eee:	203c 0004 7620 	movel #292384,%d0                                 	<== NOT EXECUTED
   45ef4:	2140 0064      	movel %d0,%a0@(100)                               	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   45ef8:	214a 0054      	movel %a2,%a0@(84)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   45efc:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   45f00:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
   45f04:	4868 0048      	pea %a0@(72)                                      	<== NOT EXECUTED
   45f08:	4879 0005 89c4 	pea 589c4 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   45f0e:	4eb9 0004 87a8 	jsr 487a8 <_Watchdog_Insert>                      	<== NOT EXECUTED
    );
    _Watchdog_Insert_seconds(
      &_Thread_Executing->Timer,
      seconds - _TOD_Seconds_since_epoch
    );
  _Thread_Enable_dispatch();
   45f14:	4eb9 0004 77ae 	jsr 477ae <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   45f1a:	dffc 0000 0010 	addal #16,%sp                                     	<== NOT EXECUTED
   45f20:	4280           	clrl %d0                                          	<== NOT EXECUTED
   45f22:	6002           	bras 45f26 <rtems_task_wake_when+0xb2>            	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
   45f24:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
}
   45f26:	246e fffc      	moveal %fp@(-4),%a2                               	<== NOT EXECUTED
   45f2a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   45f2c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004ef70 <rtems_timer_cancel>:
 */

rtems_status_code rtems_timer_cancel(
  Objects_Id id
)
{
   4ef70:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Timer_Control *)
   4ef74:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4ef78:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4ef7c:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4ef82:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  Timer_Control   *the_timer;
  Objects_Locations       location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4ef88:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4ef8e:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4ef90:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4ef94:	6704           	beqs 4ef9a <rtems_timer_cancel+0x2a>              	<== NOT EXECUTED
   4ef96:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4ef98:	601c           	bras 4efb6 <rtems_timer_cancel+0x46>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
   4ef9a:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4ef9c:	b0a8 0038      	cmpl %a0@(56),%d0                                 	<== NOT EXECUTED
   4efa0:	670c           	beqs 4efae <rtems_timer_cancel+0x3e>              	<== NOT EXECUTED
        (void) _Watchdog_Remove( &the_timer->Ticker );
   4efa2:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   4efa6:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
   4efac:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   4efae:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4efb4:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4efb6:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4efb8:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004efbc <rtems_timer_create>:

rtems_status_code rtems_timer_create(
  rtems_name    name,
  Objects_Id   *id
)
{
   4efbc:	4e56 fff4      	linkw %fp,#-12                                    	<== NOT EXECUTED
   4efc0:	48d7 0c04      	moveml %d2/%a2-%a3,%sp@                           	<== NOT EXECUTED
   4efc4:	242e 0008      	movel %fp@(8),%d2                                 	<== NOT EXECUTED
   4efc8:	266e 000c      	moveal %fp@(12),%a3                               	<== NOT EXECUTED
  Timer_Control *the_timer;

  if ( !rtems_is_name_valid( name ) )
   4efcc:	6604           	bnes 4efd2 <rtems_timer_create+0x16>              	<== NOT EXECUTED
   4efce:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
   4efd0:	6068           	bras 4f03a <rtems_timer_create+0x7e>              	<== NOT EXECUTED
    return RTEMS_INVALID_NAME;

  if ( !id )
   4efd2:	4a8b           	tstl %a3                                          	<== NOT EXECUTED
   4efd4:	6604           	bnes 4efda <rtems_timer_create+0x1e>              	<== NOT EXECUTED
   4efd6:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4efd8:	6060           	bras 4f03a <rtems_timer_create+0x7e>              	<== NOT EXECUTED
   4efda:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4efe0:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4efe2:	23c0 0006 c830 	movel %d0,6c830 <_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 );
   4efe8:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4efee:	4eb9 0005 1278 	jsr 51278 <_Objects_Allocate>                     	<== NOT EXECUTED

  _Thread_Disable_dispatch();         /* to prevent deletion */

  the_timer = _Timer_Allocate();

  if ( !the_timer ) {
   4eff4:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4eff6:	2240           	moveal %d0,%a1                                    	<== NOT EXECUTED
   4eff8:	45f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a2           	<== NOT EXECUTED
   4effe:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f000:	6606           	bnes 4f008 <rtems_timer_create+0x4c>              	<== NOT EXECUTED
    _Thread_Enable_dispatch();
   4f002:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4f004:	7005           	moveq #5,%d0                                      	<== NOT EXECUTED
   4f006:	6032           	bras 4f03a <rtems_timer_create+0x7e>              	<== NOT EXECUTED
    information,
    _Objects_Get_index( the_object->id ),
    the_object
  );

  the_object->name = name;
   4f008:	2342 000c      	movel %d2,%a1@(12)                                	<== NOT EXECUTED
  #if defined(RTEMS_DEBUG)
    if ( index > information->maximum )
      return;
  #endif

  information->local_table[ index ] = the_object;
   4f00c:	2079 0006 cacc 	moveal 6cacc <_Timer_Information+0x1a>,%a0        	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   4f012:	42a9 0030      	clrl %a1@(48)                                     	<== NOT EXECUTED
   4f016:	4280           	clrl %d0                                          	<== NOT EXECUTED
    return RTEMS_TOO_MANY;
  }

  the_timer->the_class = TIMER_DORMANT;
   4f018:	7204           	moveq #4,%d1                                      	<== NOT EXECUTED
   4f01a:	3029 000a      	movew %a1@(10),%d0                                	<== NOT EXECUTED
    &_Timer_Information,
    &the_timer->Object,
    (Objects_Name) name
  );

  *id = the_timer->Object.id;
   4f01e:	26a9 0008      	movel %a1@(8),%a3@                                	<== NOT EXECUTED
   4f022:	2189 0c00      	movel %a1,%a0@(00000000,%d0:l:4)                  	<== NOT EXECUTED
  if ( !the_timer ) {
    _Thread_Enable_dispatch();
    return RTEMS_TOO_MANY;
  }

  the_timer->the_class = TIMER_DORMANT;
   4f026:	2341 0038      	movel %d1,%a1@(56)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f02a:	42a9 0018      	clrl %a1@(24)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
   4f02e:	42a9 002c      	clrl %a1@(44)                                     	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   4f032:	42a9 0034      	clrl %a1@(52)                                     	<== NOT EXECUTED
    &the_timer->Object,
    (Objects_Name) name
  );

  *id = the_timer->Object.id;
  _Thread_Enable_dispatch();
   4f036:	4e92           	jsr %a2@                                          	<== NOT EXECUTED
   4f038:	4280           	clrl %d0                                          	<== NOT EXECUTED
  return RTEMS_SUCCESSFUL;
}
   4f03a:	4cee 0c04 fff4 	moveml %fp@(-12),%d2/%a2-%a3                      	<== NOT EXECUTED
   4f040:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f042:	4e75           	rts

0004f044 <rtems_timer_delete>:
 */

rtems_status_code rtems_timer_delete(
  Objects_Id id
)
{
   4f044:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4f048:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Timer_Control *)
   4f04a:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f04e:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4f052:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f058:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  Timer_Control     *the_timer;
  Objects_Locations  location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f05e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f064:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f066:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f06a:	6704           	beqs 4f070 <rtems_timer_delete+0x2c>              	<== NOT EXECUTED
   4f06c:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f06e:	6034           	bras 4f0a4 <rtems_timer_delete+0x60>              	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      _Objects_Close( &_Timer_Information, &the_timer->Object );
   4f070:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
   4f072:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f078:	4eb9 0005 1300 	jsr 51300 <_Objects_Close>                        	<== NOT EXECUTED
      (void) _Watchdog_Remove( &the_timer->Ticker );
   4f07e:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4f082:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Timer_Free (
  Timer_Control *the_timer
)
{
  _Objects_Free( &_Timer_Information, &the_timer->Object );
   4f088:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f08a:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f090:	4eb9 0005 1578 	jsr 51578 <_Objects_Free>                         	<== NOT EXECUTED
      _Timer_Free( the_timer );
      _Thread_Enable_dispatch();
   4f096:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f09c:	dffc 0000 0014 	addal #20,%sp                                     	<== NOT EXECUTED
   4f0a2:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f0a4:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4f0a8:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f0aa:	4e75           	rts

0004f0ac <rtems_timer_fire_after>:
  Objects_Id                         id,
  rtems_interval                     ticks,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   4f0ac:	4e56 ffe4      	linkw %fp,#-28                                    	<== NOT EXECUTED
   4f0b0:	48d7 0c3c      	moveml %d2-%d5/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4f0b4:	282e 0008      	movel %fp@(8),%d4                                 	<== NOT EXECUTED
   4f0b8:	2a2e 000c      	movel %fp@(12),%d5                                	<== NOT EXECUTED
   4f0bc:	262e 0010      	movel %fp@(16),%d3                                	<== NOT EXECUTED
  Timer_Control      *the_timer;
  Objects_Locations   location;
  ISR_Level           level;

  if ( ticks == 0 )
   4f0c0:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   4f0c2:	6606           	bnes 4f0ca <rtems_timer_fire_after+0x1e>          	<== NOT EXECUTED
   4f0c4:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4f0c6:	6000 0090      	braw 4f158 <rtems_timer_fire_after+0xac>          	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  if ( !routine )
   4f0ca:	4a83           	tstl %d3                                          	<== NOT EXECUTED
   4f0cc:	6606           	bnes 4f0d4 <rtems_timer_fire_after+0x28>          	<== NOT EXECUTED
   4f0ce:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4f0d0:	6000 0086      	braw 4f158 <rtems_timer_fire_after+0xac>          	<== NOT EXECUTED
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
  Objects_Id         id,
  Objects_Locations *location
)
{
  return (Timer_Control *)
   4f0d4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f0d8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4f0da:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f0e0:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f0e6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f0ec:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f0ee:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f0f2:	6704           	beqs 4f0f8 <rtems_timer_fire_after+0x4c>          	<== NOT EXECUTED
   4f0f4:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f0f6:	6060           	bras 4f158 <rtems_timer_fire_after+0xac>          	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   4f0f8:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4f0fa:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   4f100:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f102:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED

      _ISR_Disable( level );
   4f108:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4f10e:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4f110:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4f112:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4f114:	47f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a3           	<== 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 ) {
   4f11a:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4f11c:	4aaa 0018      	tstl %a2@(24)                                     	<== NOT EXECUTED
   4f120:	6706           	beqs 4f128 <rtems_timer_fire_after+0x7c>          	<== NOT EXECUTED
          _ISR_Enable( level );
   4f122:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   4f124:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4f126:	602e           	bras 4f156 <rtems_timer_fire_after+0xaa>          	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4f128:	2543 002c      	movel %d3,%a2@(44)                                	<== NOT EXECUTED
  the_watchdog->id        = id;
   4f12c:	2544 0030      	movel %d4,%a2@(48)                                	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   4f130:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== 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;
   4f136:	42aa 0038      	clrl %a2@(56)                                     	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f13a:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      _ISR_Enable( level );
   4f13e:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   4f140:	2545 001c      	movel %d5,%a2@(28)                                	<== NOT EXECUTED

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   4f144:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f146:	4879 0006 c90c 	pea 6c90c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   4f14c:	4eb9 0005 3174 	jsr 53174 <_Watchdog_Insert>                      	<== NOT EXECUTED


      _Watchdog_Insert_ticks( &the_timer->Ticker, ticks );
      _Thread_Enable_dispatch();
   4f152:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4f154:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4f156:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f158:	4cee 0c3c ffe4 	moveml %fp@(-28),%d2-%d5/%a2-%a3                  	<== NOT EXECUTED
   4f15e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f160:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004f164 <rtems_timer_fire_when>:
  Objects_Id                          id,
  rtems_time_of_day                  *wall_time,
  rtems_timer_service_routine_entry   routine,
  void                               *user_data
)
{
   4f164:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4f168:	48d7 043c      	moveml %d2-%d5/%a2,%sp@                           	<== NOT EXECUTED
   4f16c:	282e 0008      	movel %fp@(8),%d4                                 	<== NOT EXECUTED
   4f170:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   4f174:	2a2e 0010      	movel %fp@(16),%d5                                	<== NOT EXECUTED
  Timer_Control       *the_timer;
  Objects_Locations    location;
  rtems_interval       seconds;

  if ( !_TOD_Is_set )
   4f178:	4a39 0006 c844 	tstb 6c844 <_TOD_Is_set>                          	<== NOT EXECUTED
   4f17e:	6606           	bnes 4f186 <rtems_timer_fire_when+0x22>           	<== NOT EXECUTED
   4f180:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   4f182:	6000 00a6      	braw 4f22a <rtems_timer_fire_when+0xc6>           	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !_TOD_Validate( wall_time ) )
   4f186:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f188:	4eb9 0004 c9e0 	jsr 4c9e0 <_TOD_Validate>                         	<== NOT EXECUTED
   4f18e:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4f190:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4f192:	6700 0094      	beqw 4f228 <rtems_timer_fire_when+0xc4>           	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  if ( !routine )
   4f196:	4a85           	tstl %d5                                          	<== NOT EXECUTED
   4f198:	6606           	bnes 4f1a0 <rtems_timer_fire_when+0x3c>           	<== NOT EXECUTED
   4f19a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4f19c:	6000 008c      	braw 4f22a <rtems_timer_fire_when+0xc6>           	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  seconds = _TOD_To_seconds( wall_time );
   4f1a0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f1a2:	4eb9 0004 c92c 	jsr 4c92c <_TOD_To_seconds>                       	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   4f1a8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  if ( !routine )
    return RTEMS_INVALID_ADDRESS;

  seconds = _TOD_To_seconds( wall_time );
   4f1aa:	2600           	movel %d0,%d3                                     	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   4f1ac:	b0b9 0006 c8c2 	cmpl 6c8c2 <_TOD_Now>,%d0                         	<== NOT EXECUTED
   4f1b2:	6374           	blss 4f228 <rtems_timer_fire_when+0xc4>           	<== NOT EXECUTED
   4f1b4:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f1b8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   4f1ba:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f1c0:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f1c6:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f1cc:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f1ce:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f1d2:	6704           	beqs 4f1d8 <rtems_timer_fire_when+0x74>           	<== NOT EXECUTED
   4f1d4:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f1d6:	6052           	bras 4f22a <rtems_timer_fire_when+0xc6>           	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   4f1d8:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
   4f1da:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   4f1e0:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f1e2:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   4f1e8:	2544 0030      	movel %d4,%a2@(48)                                	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   4f1ec:	96b9 0006 c8c2 	subl 6c8c2 <_TOD_Now>,%d3                         	<== NOT EXECUTED
      the_timer->the_class = TIMER_TIME_OF_DAY;
   4f1f2:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   4f1f4:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== NOT EXECUTED
   4f1fa:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   4f1fe:	2543 001c      	movel %d3,%a2@(28)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4f202:	2545 002c      	movel %d5,%a2@(44)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f206:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
)
{

  the_watchdog->initial = units;

  _Watchdog_Insert( &_Watchdog_Seconds_chain, the_watchdog );
   4f20a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f20c:	4879 0006 c900 	pea 6c900 <_Watchdog_Seconds_chain>               	<== NOT EXECUTED
   4f212:	4eb9 0005 3174 	jsr 53174 <_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();
   4f218:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f21e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f224:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4f226:	6002           	bras 4f22a <rtems_timer_fire_when+0xc6>           	<== NOT EXECUTED
      return RTEMS_SUCCESSFUL;
   4f228:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f22a:	4cee 043c ffe8 	moveml %fp@(-24),%d2-%d5/%a2                      	<== NOT EXECUTED
   4f230:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f232:	4e75           	rts

0004f234 <rtems_timer_get_information>:

rtems_status_code rtems_timer_get_information(
  Objects_Id               id,
  rtems_timer_information *the_info
)
{
   4f234:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4f238:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f23a:	246e 000c      	moveal %fp@(12),%a2                               	<== NOT EXECUTED
  Timer_Control     *the_timer;
  Objects_Locations  location;

  if ( !the_info )
   4f23e:	4a8a           	tstl %a2                                          	<== NOT EXECUTED
   4f240:	6604           	bnes 4f246 <rtems_timer_get_information+0x12>     	<== NOT EXECUTED
   4f242:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4f244:	6044           	bras 4f28a <rtems_timer_get_information+0x56>     	<== NOT EXECUTED
   4f246:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f24a:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4f24e:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f254:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f25a:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f260:	2040           	moveal %d0,%a0                                    	<== NOT EXECUTED
   4f262:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f266:	6704           	beqs 4f26c <rtems_timer_get_information+0x38>     	<== NOT EXECUTED
   4f268:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f26a:	601e           	bras 4f28a <rtems_timer_get_information+0x56>     	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      the_info->the_class  = the_timer->the_class;
   4f26c:	24a8 0038      	movel %a0@(56),%a2@                               	<== NOT EXECUTED
      the_info->initial    = the_timer->Ticker.initial;
   4f270:	2568 001c 0004 	movel %a0@(28),%a2@(4)                            	<== NOT EXECUTED
      the_info->start_time = the_timer->Ticker.start_time;
   4f276:	2568 0024 0008 	movel %a0@(36),%a2@(8)                            	<== NOT EXECUTED
      the_info->stop_time  = the_timer->Ticker.stop_time;
   4f27c:	2568 0028 000c 	movel %a0@(40),%a2@(12)                           	<== NOT EXECUTED
      _Thread_Enable_dispatch();
   4f282:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f288:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f28a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4f28e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f290:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004f294 <rtems_timer_ident>:

rtems_status_code rtems_timer_ident(
  rtems_name    name,
  Objects_Id   *id
)
{
   4f294:	4e56 0000      	linkw %fp,#0                                      	<== NOT EXECUTED
  Objects_Name_or_id_lookup_errors  status;

  status = _Objects_Name_to_id_u32(
   4f298:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4f29c:	2f3c 7fff ffff 	movel #2147483647,%sp@-                           	<== NOT EXECUTED
   4f2a2:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4f2a6:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f2ac:	4eb9 0005 1874 	jsr 51874 <_Objects_Name_to_id_u32>               	<== NOT EXECUTED
   4f2b2:	41f9 0006 597e 	lea 6597e <_Status_Object_name_errors_to_status>,%a0	<== NOT EXECUTED
    OBJECTS_SEARCH_LOCAL_NODE,
    id
  );

  return _Status_Object_name_errors_to_status[ status ];
}
   4f2b8:	2030 0c00      	movel %a0@(00000000,%d0:l:4),%d0                  	<== NOT EXECUTED
   4f2bc:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f2be:	4e75           	rts

0004f500 <rtems_timer_initiate_server>:
rtems_status_code rtems_timer_initiate_server(
  uint32_t             priority,
  uint32_t             stack_size,
  rtems_attribute      attribute_set
)
{
   4f500:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4f504:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f506:	222e 0008      	movel %fp@(8),%d1                                 	<== NOT EXECUTED
   4f50a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
  rtems_task_priority the_priority
)
{
  return (  ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
   4f50c:	4a81           	tstl %d1                                          	<== NOT EXECUTED
   4f50e:	671e           	beqs 4f52e <rtems_timer_initiate_server+0x2e>     	<== NOT EXECUTED
   4f510:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4f512:	1039 0006 69e2 	moveb 669e2 <rtems_maximum_priority>,%d0          	<== NOT EXECUTED
   4f518:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4f51a:	54c0           	scc %d0                                           	<== NOT EXECUTED
   4f51c:	49c0           	extbl %d0                                         	<== NOT EXECUTED
   4f51e:	4480           	negl %d0                                          	<== NOT EXECUTED
   *  Make sure the requested priority is valid.  The if is
   *  structured so we check it is invalid before looking for
   *  a specific invalid value as the default.
   */
  _priority = priority;
  if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) {
   4f520:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4f522:	6704           	beqs 4f528 <rtems_timer_initiate_server+0x28>     	<== NOT EXECUTED
   4f524:	2601           	movel %d1,%d3                                     	<== NOT EXECUTED
   4f526:	600e           	bras 4f536 <rtems_timer_initiate_server+0x36>     	<== NOT EXECUTED
    if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY )
   4f528:	70ff           	moveq #-1,%d0                                     	<== NOT EXECUTED
   4f52a:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4f52c:	6706           	beqs 4f534 <rtems_timer_initiate_server+0x34>     	<== NOT EXECUTED
   4f52e:	7013           	moveq #19,%d0                                     	<== NOT EXECUTED
   4f530:	6000 0144      	braw 4f676 <rtems_timer_initiate_server+0x176>    	<== NOT EXECUTED
   4f534:	4283           	clrl %d3                                          	<== NOT EXECUTED
   4f536:	2039 0006 c830 	movel 6c830 <_Thread_Dispatch_disable_level>,%d0  	<== NOT EXECUTED
   4f53c:	5280           	addql #1,%d0                                      	<== NOT EXECUTED
   4f53e:	23c0 0006 c830 	movel %d0,6c830 <_Thread_Dispatch_disable_level>  	<== NOT EXECUTED

  /*
   *  Just to make sure this is only called once.
   */
  _Thread_Disable_dispatch();
    tmpInitialized  = initialized;
   4f544:	1439 0006 7cb0 	moveb 67cb0 <initialized.4039>,%d2                	<== NOT EXECUTED
    initialized = true;
   4f54a:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4f54c:	13c1 0006 7cb0 	moveb %d1,67cb0 <initialized.4039>                	<== NOT EXECUTED
  _Thread_Enable_dispatch();
   4f552:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED

  if ( tmpInitialized )
   4f558:	4a02           	tstb %d2                                          	<== NOT EXECUTED
   4f55a:	6706           	beqs 4f562 <rtems_timer_initiate_server+0x62>     	<== NOT EXECUTED
   4f55c:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
   4f55e:	6000 0116      	braw 4f676 <rtems_timer_initiate_server+0x176>    	<== 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(
   4f562:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f566:	202e 0010      	movel %fp@(16),%d0                                	<== NOT EXECUTED
   4f56a:	08c0 000f      	bset #15,%d0                                      	<== NOT EXECUTED
   4f56e:	2f00           	movel %d0,%sp@-                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4f570:	223c 0006 c7ac 	movel #444332,%d1                                 	<== NOT EXECUTED
   4f576:	4878 0100      	pea 100 <FP_REGS_SAVED+0xc0>                      	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f57a:	203c 0006 c7a8 	movel #444328,%d0                                 	<== NOT EXECUTED
   4f580:	2f2e 000c      	movel %fp@(12),%sp@-                              	<== NOT EXECUTED
   4f584:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4f586:	23c1 0006 c7a8 	movel %d1,6c7a8 <_Timer_To_be_inserted>           	<== NOT EXECUTED
   4f58c:	2f3c 5449 4d45 	movel #1414090053,%sp@-                           	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f592:	23c0 0006 c7b0 	movel %d0,6c7b0 <_Timer_To_be_inserted+0x8>       	<== 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;
   4f598:	42b9 0006 c7ac 	clrl 6c7ac <_Timer_To_be_inserted+0x4>            	<== NOT EXECUTED
   4f59e:	4eb9 0004 e8b8 	jsr 4e8b8 <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) {
   4f5a4:	dffc 0000 0018 	addal #24,%sp                                     	<== NOT EXECUTED
   4f5aa:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f5ac:	6600 00c0      	bnew 4f66e <rtems_timer_initiate_server+0x16e>    	<== 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(
   4f5b0:	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 )
   4f5b4:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4f5b6:	4281           	clrl %d1                                          	<== NOT EXECUTED
   4f5b8:	3039 0006 c75a 	movew 6c75a <_RTEMS_tasks_Information+0xe>,%d0    	<== NOT EXECUTED
   4f5be:	3209           	movew %a1,%d1                                     	<== NOT EXECUTED
   4f5c0:	b081           	cmpl %d1,%d0                                      	<== NOT EXECUTED
   4f5c2:	6404           	bccs 4f5c8 <rtems_timer_initiate_server+0xc8>     	<== NOT EXECUTED
   4f5c4:	91c8           	subal %a0,%a0                                     	<== NOT EXECUTED
   4f5c6:	600a           	bras 4f5d2 <rtems_timer_initiate_server+0xd2>     	<== NOT EXECUTED
    return NULL;
  return information->local_table[ index ];
   4f5c8:	2079 0006 c766 	moveal 6c766 <_RTEMS_tasks_Information+0x1a>,%a0  	<== NOT EXECUTED
   4f5ce:	2070 1c00      	moveal %a0@(00000000,%d1:l:4),%a0                 	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   4f5d2:	42a8 006c      	clrl %a0@(108)                                    	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4f5d6:	203c 0005 1d64 	movel #335204,%d0                                 	<== NOT EXECUTED
   4f5dc:	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);
   4f5e0:	223c 0006 c78c 	movel #444300,%d1                                 	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f5e6:	42a8 0050      	clrl %a0@(80)                                     	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   4f5ea:	2149 0068      	movel %a1,%a0@(104)                               	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f5ee:	203c 0006 c788 	movel #444296,%d0                                 	<== NOT EXECUTED
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   4f5f4:	42a7           	clrl %sp@-                                        	<== NOT EXECUTED
   4f5f6:	4879 0004 f726 	pea 4f726 <_Timer_Server_body>                    	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4f5fc:	23c1 0006 c788 	movel %d1,6c788 <_Timer_Ticks_chain>              	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f602:	223c 0006 c7a0 	movel #444320,%d1                                 	<== NOT EXECUTED
   4f608:	23c0 0006 c790 	movel %d0,6c790 <_Timer_Ticks_chain+0x8>          	<== NOT EXECUTED
   4f60e:	203c 0006 c79c 	movel #444316,%d0                                 	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   4f614:	23c1 0006 c79c 	movel %d1,6c79c <_Timer_Seconds_chain>            	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4f61a:	223c 0005 1d64 	movel #335204,%d1                                 	<== NOT EXECUTED
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4f620:	23c0 0006 c7a4 	movel %d0,6c7a4 <_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;
   4f626:	203c 0004 f682 	movel #325250,%d0                                 	<== NOT EXECUTED

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   4f62c:	2f09           	movel %a1,%sp@-                                   	<== NOT EXECUTED
   4f62e:	23c1 0006 c7d0 	movel %d1,6c7d0 <_Timer_Seconds_timer+0x1c>       	<== 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;
   4f634:	23c0 0006 caee 	movel %d0,6caee <_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(
   4f63a:	23c8 0006 caf2 	movel %a0,6caf2 <_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;
   4f640:	42b9 0006 c78c 	clrl 6c78c <_Timer_Ticks_chain+0x4>               	<== NOT EXECUTED
   4f646:	42b9 0006 c7a0 	clrl 6c7a0 <_Timer_Seconds_chain+0x4>             	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f64c:	42b9 0006 c7bc 	clrl 6c7bc <_Timer_Seconds_timer+0x8>             	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   4f652:	23c9 0006 c7d4 	movel %a1,6c7d4 <_Timer_Seconds_timer+0x20>       	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   4f658:	42b9 0006 c7d8 	clrl 6c7d8 <_Timer_Seconds_timer+0x24>            	<== NOT EXECUTED
  _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method;

  /*
   *  Start the timer server
   */
  status = rtems_task_start(
   4f65e:	4eb9 0004 ed88 	jsr 4ed88 <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) {
   4f664:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f66a:	4a80           	tstl %d0                                          	<== NOT EXECUTED
   4f66c:	6708           	beqs 4f676 <rtems_timer_initiate_server+0x176>    	<== 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;
   4f66e:	4201           	clrb %d1                                          	<== NOT EXECUTED
   4f670:	13c1 0006 7cb0 	moveb %d1,67cb0 <initialized.4039>                	<== NOT EXECUTED
  }

  return status;
}
   4f676:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4f67a:	262e fff8      	movel %fp@(-8),%d3                                	<== NOT EXECUTED
   4f67e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f680:	4e75           	rts

0004f2c0 <rtems_timer_reset>:
 */

rtems_status_code rtems_timer_reset(
  Objects_Id id
)
{
   4f2c0:	4e56 fffc      	linkw %fp,#-4                                     	<== NOT EXECUTED
   4f2c4:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f2c6:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f2c8:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f2cc:	2f2e 0008      	movel %fp@(8),%sp@-                               	<== NOT EXECUTED
   4f2d0:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f2d6:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
  Timer_Control     *the_timer;
  Objects_Locations  location;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f2dc:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f2e2:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f2e4:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f2e8:	6704           	beqs 4f2ee <rtems_timer_reset+0x2e>               	<== NOT EXECUTED
   4f2ea:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f2ec:	6078           	bras 4f366 <rtems_timer_reset+0xa6>               	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      switch ( the_timer->the_class ) {
   4f2ee:	202a 0038      	movel %a2@(56),%d0                                	<== NOT EXECUTED
   4f2f2:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   4f2f4:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4f2f6:	6732           	beqs 4f32a <rtems_timer_reset+0x6a>               	<== NOT EXECUTED
   4f2f8:	620a           	bhis 4f304 <rtems_timer_reset+0x44>               	<== NOT EXECUTED
   4f2fa:	123c 0004      	moveb #4,%d1                                      	<== NOT EXECUTED
   4f2fe:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   4f300:	655c           	bcss 4f35e <rtems_timer_reset+0x9e>               	<== NOT EXECUTED
   4f302:	6050           	bras 4f354 <rtems_timer_reset+0x94>               	<== NOT EXECUTED
        case TIMER_INTERVAL:
          _Watchdog_Remove( &the_timer->Ticker );
   4f304:	240a           	movel %a2,%d2                                     	<== NOT EXECUTED
   4f306:	0682 0000 0010 	addil #16,%d2                                     	<== NOT EXECUTED
   4f30c:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f30e:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
          _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker );
   4f314:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f316:	4879 0006 c90c 	pea 6c90c <_Watchdog_Ticks_chain>                 	<== NOT EXECUTED
   4f31c:	4eb9 0005 3174 	jsr 53174 <_Watchdog_Insert>                      	<== NOT EXECUTED
   4f322:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f328:	6034           	bras 4f35e <rtems_timer_reset+0x9e>               	<== NOT EXECUTED
          break;
        case TIMER_INTERVAL_ON_TASK:
          if ( !_Timer_Server_schedule_operation ) {
   4f32a:	4ab9 0006 caee 	tstl 6caee <_Timer_Server_schedule_operation>     	<== NOT EXECUTED
   4f330:	660a           	bnes 4f33c <rtems_timer_reset+0x7c>               	<== NOT EXECUTED
            _Thread_Enable_dispatch();
   4f332:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f338:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
   4f33a:	602a           	bras 4f366 <rtems_timer_reset+0xa6>               	<== NOT EXECUTED
            return RTEMS_INCORRECT_STATE;
          }
          _Watchdog_Remove( &the_timer->Ticker );
   4f33c:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4f340:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
          (*_Timer_Server_schedule_operation)( the_timer );
   4f346:	2079 0006 caee 	moveal 6caee <_Timer_Server_schedule_operation>,%a0	<== NOT EXECUTED
   4f34c:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f34e:	4e90           	jsr %a0@                                          	<== NOT EXECUTED
   4f350:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4f352:	600a           	bras 4f35e <rtems_timer_reset+0x9e>               	<== NOT EXECUTED
          break;
        case TIMER_TIME_OF_DAY:
        case TIMER_TIME_OF_DAY_ON_TASK:
        case TIMER_DORMANT:
          _Thread_Enable_dispatch();
   4f354:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f35a:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   4f35c:	6008           	bras 4f366 <rtems_timer_reset+0xa6>               	<== NOT EXECUTED
          return RTEMS_NOT_DEFINED;
      }
      _Thread_Enable_dispatch();
   4f35e:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f364:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f366:	242e fff4      	movel %fp@(-12),%d2                               	<== NOT EXECUTED
   4f36a:	246e fff8      	moveal %fp@(-8),%a2                               	<== NOT EXECUTED
   4f36e:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f370:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004f374 <rtems_timer_server_fire_after>:
  Objects_Id                         id,
  rtems_interval                     ticks,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   4f374:	4e56 ffe8      	linkw %fp,#-24                                    	<== NOT EXECUTED
   4f378:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@                       	<== NOT EXECUTED
   4f37c:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   4f380:	282e 000c      	movel %fp@(12),%d4                                	<== NOT EXECUTED
   4f384:	242e 0010      	movel %fp@(16),%d2                                	<== NOT EXECUTED
  Timer_Control        *the_timer;
  Objects_Locations     location;
  ISR_Level             level;

  if ( !_Timer_Server )
   4f388:	4ab9 0006 caf2 	tstl 6caf2 <_Timer_Server>                        	<== NOT EXECUTED
   4f38e:	6606           	bnes 4f396 <rtems_timer_server_fire_after+0x22>   	<== NOT EXECUTED
   4f390:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
   4f392:	6000 0090      	braw 4f424 <rtems_timer_server_fire_after+0xb0>   	<== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;

  if ( !routine )
   4f396:	4a82           	tstl %d2                                          	<== NOT EXECUTED
   4f398:	6606           	bnes 4f3a0 <rtems_timer_server_fire_after+0x2c>   	<== NOT EXECUTED
   4f39a:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4f39c:	6000 0086      	braw 4f424 <rtems_timer_server_fire_after+0xb0>   	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( ticks == 0 )
   4f3a0:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4f3a2:	6604           	bnes 4f3a8 <rtems_timer_server_fire_after+0x34>   	<== NOT EXECUTED
   4f3a4:	700a           	moveq #10,%d0                                     	<== NOT EXECUTED
   4f3a6:	607c           	bras 4f424 <rtems_timer_server_fire_after+0xb0>   	<== NOT EXECUTED
   4f3a8:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f3ac:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f3ae:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f3b4:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_NUMBER;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f3ba:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f3c0:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f3c2:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f3c6:	6704           	beqs 4f3cc <rtems_timer_server_fire_after+0x58>   	<== NOT EXECUTED
   4f3c8:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f3ca:	6058           	bras 4f424 <rtems_timer_server_fire_after+0xb0>   	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   4f3cc:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4f3d0:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED

      _ISR_Disable( level );
   4f3d6:	203c 0000 0700 	movel #1792,%d0                                   	<== NOT EXECUTED
   4f3dc:	40c1           	movew %sr,%d1                                     	<== NOT EXECUTED
   4f3de:	8081           	orl %d1,%d0                                       	<== NOT EXECUTED
   4f3e0:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   4f3e2:	47f9 0005 1ef2 	lea 51ef2 <_Thread_Enable_dispatch>,%a3           	<== 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 ) {
   4f3e8:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4f3ea:	4aaa 0018      	tstl %a2@(24)                                     	<== NOT EXECUTED
   4f3ee:	6706           	beqs 4f3f6 <rtems_timer_server_fire_after+0x82>   	<== NOT EXECUTED
          _ISR_Enable( level );
   4f3f0:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
          _Thread_Enable_dispatch();
   4f3f2:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4f3f4:	602c           	bras 4f422 <rtems_timer_server_fire_after+0xae>   	<== 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;
   4f3f6:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4f3f8:	2542 002c      	movel %d2,%a2@(44)                                	<== NOT EXECUTED
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   4f3fc:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== NOT EXECUTED
   4f402:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   4f406:	2543 0030      	movel %d3,%a2@(48)                                	<== NOT EXECUTED
        _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
        the_timer->Ticker.initial = ticks;
   4f40a:	2544 001c      	movel %d4,%a2@(28)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f40e:	42aa 0018      	clrl %a2@(24)                                     	<== NOT EXECUTED
      _ISR_Enable( level );
   4f412:	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 );
   4f414:	2079 0006 caee 	moveal 6caee <_Timer_Server_schedule_operation>,%a0	<== NOT EXECUTED
   4f41a:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f41c:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   4f41e:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   4f420:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4f422:	4280           	clrl %d0                                          	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f424:	4cee 0c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a3                  	<== NOT EXECUTED
   4f42a:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f42c:	4e75           	rts                                               	<== NOT EXECUTED
	...

0004f430 <rtems_timer_server_fire_when>:
  Objects_Id                         id,
  rtems_time_of_day                  *wall_time,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   4f430:	4e56 ffec      	linkw %fp,#-20                                    	<== NOT EXECUTED
   4f434:	48d7 041c      	moveml %d2-%d4/%a2,%sp@                           	<== NOT EXECUTED
   4f438:	262e 0008      	movel %fp@(8),%d3                                 	<== NOT EXECUTED
   4f43c:	242e 000c      	movel %fp@(12),%d2                                	<== NOT EXECUTED
   4f440:	282e 0010      	movel %fp@(16),%d4                                	<== NOT EXECUTED
  Timer_Control        *the_timer;
  Objects_Locations     location;
  rtems_interval        seconds;

  if ( !_Timer_Server )
   4f444:	4ab9 0006 caf2 	tstl 6caf2 <_Timer_Server>                        	<== NOT EXECUTED
   4f44a:	6606           	bnes 4f452 <rtems_timer_server_fire_when+0x22>    	<== NOT EXECUTED
   4f44c:	700e           	moveq #14,%d0                                     	<== NOT EXECUTED
   4f44e:	6000 00a4      	braw 4f4f4 <rtems_timer_server_fire_when+0xc4>    	<== NOT EXECUTED
    return RTEMS_INCORRECT_STATE;

  if ( !_TOD_Is_set )
   4f452:	4a39 0006 c844 	tstb 6c844 <_TOD_Is_set>                          	<== NOT EXECUTED
   4f458:	6606           	bnes 4f460 <rtems_timer_server_fire_when+0x30>    	<== NOT EXECUTED
   4f45a:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   4f45c:	6000 0096      	braw 4f4f4 <rtems_timer_server_fire_when+0xc4>    	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !routine )
   4f460:	4a84           	tstl %d4                                          	<== NOT EXECUTED
   4f462:	6606           	bnes 4f46a <rtems_timer_server_fire_when+0x3a>    	<== NOT EXECUTED
   4f464:	7009           	moveq #9,%d0                                      	<== NOT EXECUTED
   4f466:	6000 008c      	braw 4f4f4 <rtems_timer_server_fire_when+0xc4>    	<== NOT EXECUTED
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Validate( wall_time ) )
   4f46a:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f46c:	4eb9 0004 c9e0 	jsr 4c9e0 <_TOD_Validate>                         	<== NOT EXECUTED
   4f472:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   4f474:	4a00           	tstb %d0                                          	<== NOT EXECUTED
   4f476:	677a           	beqs 4f4f2 <rtems_timer_server_fire_when+0xc2>    	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( wall_time );
   4f478:	2f02           	movel %d2,%sp@-                                   	<== NOT EXECUTED
   4f47a:	4eb9 0004 c92c 	jsr 4c92c <_TOD_To_seconds>                       	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   4f480:	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 );
   4f482:	2400           	movel %d0,%d2                                     	<== NOT EXECUTED
  if ( seconds <= _TOD_Seconds_since_epoch )
   4f484:	b0b9 0006 c8c2 	cmpl 6c8c2 <_TOD_Now>,%d0                         	<== NOT EXECUTED
   4f48a:	6366           	blss 4f4f2 <rtems_timer_server_fire_when+0xc2>    	<== NOT EXECUTED
   4f48c:	486e fffc      	pea %fp@(-4)                                      	<== NOT EXECUTED
   4f490:	2f03           	movel %d3,%sp@-                                   	<== NOT EXECUTED
   4f492:	4879 0006 cab2 	pea 6cab2 <_Timer_Information>                    	<== NOT EXECUTED
   4f498:	4eb9 0005 1710 	jsr 51710 <_Objects_Get>                          	<== NOT EXECUTED
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   4f49e:	dffc 0000 000c 	addal #12,%sp                                     	<== NOT EXECUTED
   4f4a4:	2440           	moveal %d0,%a2                                    	<== NOT EXECUTED
   4f4a6:	4aae fffc      	tstl %fp@(-4)                                     	<== NOT EXECUTED
   4f4aa:	6704           	beqs 4f4b0 <rtems_timer_server_fire_when+0x80>    	<== NOT EXECUTED
   4f4ac:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   4f4ae:	6044           	bras 4f4f4 <rtems_timer_server_fire_when+0xc4>    	<== NOT EXECUTED

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   4f4b0:	486a 0010      	pea %a2@(16)                                      	<== NOT EXECUTED
   4f4b4:	4eb9 0005 3290 	jsr 53290 <_Watchdog_Remove>                      	<== NOT EXECUTED
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   4f4ba:	2543 0030      	movel %d3,%a2@(48)                                	<== 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;
   4f4be:	94b9 0006 c8c2 	subl 6c8c2 <_TOD_Now>,%d2                         	<== 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;
   4f4c4:	7003           	moveq #3,%d0                                      	<== NOT EXECUTED
  the_watchdog->user_data = user_data;
   4f4c6:	256e 0014 0034 	movel %fp@(20),%a2@(52)                           	<== 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 );
   4f4cc:	2079 0006 caee 	moveal 6caee <_Timer_Server_schedule_operation>,%a0	<== 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;
   4f4d2:	2540 0038      	movel %d0,%a2@(56)                                	<== NOT EXECUTED
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   4f4d6:	2544 002c      	movel %d4,%a2@(44)                                	<== NOT EXECUTED
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch;
   4f4da:	2542 001c      	movel %d2,%a2@(28)                                	<== NOT EXECUTED
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   4f4de:	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 );
   4f4e2:	2f0a           	movel %a2,%sp@-                                   	<== NOT EXECUTED
   4f4e4:	4e90           	jsr %a0@                                          	<== NOT EXECUTED

      _Thread_Enable_dispatch();
   4f4e6:	4eb9 0005 1ef2 	jsr 51ef2 <_Thread_Enable_dispatch>               	<== NOT EXECUTED
   4f4ec:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   4f4ee:	4280           	clrl %d0                                          	<== NOT EXECUTED
   4f4f0:	6002           	bras 4f4f4 <rtems_timer_server_fire_when+0xc4>    	<== NOT EXECUTED
      return RTEMS_SUCCESSFUL;
   4f4f2:	7014           	moveq #20,%d0                                     	<== NOT EXECUTED
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   4f4f4:	4cee 041c ffec 	moveml %fp@(-20),%d2-%d4/%a2                      	<== NOT EXECUTED
   4f4fa:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
   4f4fc:	4e75           	rts                                               	<== NOT EXECUTED
	...