000518c4 <_CORE_message_queue_Broadcast>:
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif
  uint32_t                                  *count
)
{
   518c4:	4e56 ffe0      	linkw %fp,#-32
   518c8:	48d7 3c3c      	moveml %d2-%d5/%a2-%a5,%sp@
   518cc:	246e 0008      	moveal %fp@(8),%a2
   518d0:	2a2e 000c      	movel %fp@(12),%d5
   518d4:	262e 0010      	movel %fp@(16),%d3
   518d8:	286e 001c      	moveal %fp@(28),%a4
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
   518dc:	b6aa 004c      	cmpl %a2@(76),%d3
   518e0:	6304           	blss 518e6 <_CORE_message_queue_Broadcast+0x22>
   518e2:	7001           	moveq #1,%d0                                      	<== NOT EXECUTED
   518e4:	6042           	bras 51928 <_CORE_message_queue_Broadcast+0x64>   	<== 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 ) {
   518e6:	4aaa 0048      	tstl %a2@(72)
   518ea:	6610           	bnes 518fc <_CORE_message_queue_Broadcast+0x38>
   *  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))) {
   518ec:	4282           	clrl %d2
   518ee:	283c 0005 3ab0 	movel #342704,%d4
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
   518f4:	4bf9 0005 8a9c 	lea 58a9c <memcpy>,%a5
   518fa:	601a           	bras 51916 <_CORE_message_queue_Broadcast+0x52>
   *        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;
   518fc:	4294           	clrl %a4@
   518fe:	6026           	bras 51926 <_CORE_message_queue_Broadcast+0x62>
   51900:	2f03           	movel %d3,%sp@-
   */
  number_broadcasted = 0;
  while ((the_thread =
          _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
    waitp = &the_thread->Wait;
    number_broadcasted += 1;
   51902:	5282           	addql #1,%d2
   51904:	2f05           	movel %d5,%sp@-
   51906:	2f2b 002c      	movel %a3@(44),%sp@-
   5190a:	4e95           	jsr %a5@
      buffer,
      waitp->return_argument_second.mutable_object,
      size
    );

    *(size_t *) the_thread->Wait.return_argument = size;
   5190c:	206b 0028      	moveal %a3@(40),%a0
   51910:	4fef 000c      	lea %sp@(12),%sp
   51914:	2083           	movel %d3,%a0@
   *  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))) {
   51916:	2f0a           	movel %a2,%sp@-
   51918:	2044           	moveal %d4,%a0
   5191a:	4e90           	jsr %a0@
  /*
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.
   */
  number_broadcasted = 0;
  while ((the_thread =
   5191c:	588f           	addql #4,%sp
          _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
   5191e:	2640           	moveal %d0,%a3
  /*
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.
   */
  number_broadcasted = 0;
  while ((the_thread =
   51920:	4a80           	tstl %d0
   51922:	66dc           	bnes 51900 <_CORE_message_queue_Broadcast+0x3c>
      if ( !_Objects_Is_local_id( the_thread->Object.id ) )
        (*api_message_queue_mp_support) ( the_thread, id );
    #endif

  }
  *count = number_broadcasted;
   51924:	2882           	movel %d2,%a4@
   51926:	4280           	clrl %d0
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
   51928:	4cee 3c3c ffe0 	moveml %fp@(-32),%d2-%d5/%a2-%a5
   5192e:	4e5e           	unlk %fp
   51930:	4e75           	rts
	...

00049910 <_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
)
{
   49910:	4e56 0000      	linkw %fp,#0
{
  Thread_Control   *executing;

  /* disabled when you get here */

  executing = _Thread_Executing;
   49914:	2279 0005 bade 	moveal 5bade <_Thread_Executing>,%a1
   4991a:	2f0b           	movel %a3,%sp@-
   4991c:	206e 0008      	moveal %fp@(8),%a0
   49920:	2f0a           	movel %a2,%sp@-
   49922:	246e 000c      	moveal %fp@(12),%a2
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
   49926:	42a9 0034      	clrl %a1@(52)
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
   4992a:	4aa8 004e      	tstl %a0@(78)
   4992e:	6700 0098      	beqw 499c8 <_CORE_mutex_Seize_interrupt_trylock+0xb8>
    the_mutex->lock       = CORE_MUTEX_LOCKED;
   49932:	42a8 004e      	clrl %a0@(78)
    the_mutex->holder     = executing;
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
   49936:	7201           	moveq #1,%d1
  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;
   49938:	2169 0008 005e 	movel %a1@(8),%a0@(94)
 */
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
  CORE_mutex_Attributes *the_attribute
)
{
  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
   4993e:	2028 0046      	movel %a0@(70),%d0
  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;
   49942:	2141 0052      	movel %d1,%a0@(82)
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   49946:	123c 0002      	moveb #2,%d1

  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;
   4994a:	2149 005a      	movel %a1,%a0@(90)
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
   4994e:	b280           	cmpl %d0,%d1
   49950:	6708           	beqs 4995a <_CORE_mutex_Seize_interrupt_trylock+0x4a>
   49952:	123c 0003      	moveb #3,%d1
   49956:	b280           	cmpl %d0,%d1
   49958:	660a           	bnes 49964 <_CORE_mutex_Seize_interrupt_trylock+0x54>
       _Chain_Prepend_unprotected( &executing->lock_mutex,
                                   &the_mutex->queue.lock_queue );
       the_mutex->queue.priority_before = executing->current_priority;
#endif

      executing->resource_count++;
   4995a:	52a9 001c      	addql #1,%a1@(28)
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
   4995e:	7203           	moveq #3,%d1
   49960:	b280           	cmpl %d0,%d1
   49962:	6706           	beqs 4996a <_CORE_mutex_Seize_interrupt_trylock+0x5a>
      _ISR_Enable( *level_p );
   49964:	2012           	movel %a2@,%d0
   49966:	46c0           	movew %d0,%sr
   49968:	607c           	bras 499e6 <_CORE_mutex_Seize_interrupt_trylock+0xd6>
       */
    {
      Priority_Control  ceiling;
      Priority_Control  current;

      ceiling = the_mutex->Attributes.priority_ceiling;
   4996a:	2028 004a      	movel %a0@(74),%d0
      current = executing->current_priority;
   4996e:	2229 0014      	movel %a1@(20),%d1
      if ( current == ceiling ) {
   49972:	b081           	cmpl %d1,%d0
   49974:	6606           	bnes 4997c <_CORE_mutex_Seize_interrupt_trylock+0x6c>
        _ISR_Enable( *level_p );
   49976:	2012           	movel %a2@,%d0
   49978:	46c0           	movew %d0,%sr
   4997a:	606a           	bras 499e6 <_CORE_mutex_Seize_interrupt_trylock+0xd6>
        return 0;
      }

      if ( current > ceiling ) {
   4997c:	b081           	cmpl %d1,%d0
   4997e:	642e           	bccs 499ae <_CORE_mutex_Seize_interrupt_trylock+0x9e>
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
   49980:	2039 0005 ba24 	movel 5ba24 <_Thread_Dispatch_disable_level>,%d0
   49986:	5280           	addql #1,%d0
   49988:	23c0 0005 ba24 	movel %d0,5ba24 <_Thread_Dispatch_disable_level>
        _Thread_Disable_dispatch();
        _ISR_Enable( *level_p );
   4998e:	2012           	movel %a2@,%d0
   49990:	46c0           	movew %d0,%sr
        _Thread_Change_priority(
   49992:	42a7           	clrl %sp@-
   49994:	2f28 004a      	movel %a0@(74),%sp@-
   49998:	2f28 005a      	movel %a0@(90),%sp@-
   4999c:	4eb9 0004 6768 	jsr 46768 <_Thread_Change_priority>
          the_mutex->holder,
          the_mutex->Attributes.priority_ceiling,
         false
        );
        _Thread_Enable_dispatch();
   499a2:	4eb9 0004 6c62 	jsr 46c62 <_Thread_Enable_dispatch>
   499a8:	4fef 000c      	lea %sp@(12),%sp
   499ac:	6038           	bras 499e6 <_CORE_mutex_Seize_interrupt_trylock+0xd6>
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
   499ae:	7006           	moveq #6,%d0
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
   499b0:	7201           	moveq #1,%d1
        );
        _Thread_Enable_dispatch();
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
   499b2:	2340 0034      	movel %d0,%a1@(52)
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
        the_mutex->nest_count = 0;     /* undo locking above */
   499b6:	42a8 0052      	clrl %a0@(82)
        _Thread_Enable_dispatch();
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
   499ba:	2141 004e      	movel %d1,%a0@(78)
        the_mutex->nest_count = 0;     /* undo locking above */
        executing->resource_count--;   /* undo locking above */
   499be:	53a9 001c      	subql #1,%a1@(28)
        _ISR_Enable( *level_p );
   499c2:	2012           	movel %a2@,%d0
   499c4:	46c0           	movew %d0,%sr
   499c6:	601e           	bras 499e6 <_CORE_mutex_Seize_interrupt_trylock+0xd6>
  /*
   *  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 ) ) {
   499c8:	2668 005a      	moveal %a0@(90),%a3
   499cc:	b3cb           	cmpal %a3,%a1
   499ce:	6626           	bnes 499f6 <_CORE_mutex_Seize_interrupt_trylock+0xe6>
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
   499d0:	2028 0040      	movel %a0@(64),%d0
   499d4:	6708           	beqs 499de <_CORE_mutex_Seize_interrupt_trylock+0xce>
   499d6:	7201           	moveq #1,%d1
   499d8:	b280           	cmpl %d0,%d1
   499da:	661a           	bnes 499f6 <_CORE_mutex_Seize_interrupt_trylock+0xe6>
   499dc:	600c           	bras 499ea <_CORE_mutex_Seize_interrupt_trylock+0xda>	<== NOT EXECUTED
      case CORE_MUTEX_NESTING_ACQUIRES:
        the_mutex->nest_count++;
   499de:	52a8 0052      	addql #1,%a0@(82)
        _ISR_Enable( *level_p );
   499e2:	2012           	movel %a2@,%d0
   499e4:	46c0           	movew %d0,%sr
   499e6:	4280           	clrl %d0
   499e8:	600e           	bras 499f8 <_CORE_mutex_Seize_interrupt_trylock+0xe8>
        return 0;
      case CORE_MUTEX_NESTING_IS_ERROR:
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
   499ea:	7002           	moveq #2,%d0                                      	<== NOT EXECUTED
   499ec:	2740 0034      	movel %d0,%a3@(52)                                	<== NOT EXECUTED
        _ISR_Enable( *level_p );
   499f0:	2012           	movel %a2@,%d0                                    	<== NOT EXECUTED
   499f2:	46c0           	movew %d0,%sr                                     	<== NOT EXECUTED
   499f4:	60f0           	bras 499e6 <_CORE_mutex_Seize_interrupt_trylock+0xd6>	<== NOT EXECUTED
   499f6:	7001           	moveq #1,%d0
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
   499f8:	246e fff8      	moveal %fp@(-8),%a2
   499fc:	266e fffc      	moveal %fp@(-4),%a3
   49a00:	4e5e           	unlk %fp
   49a02:	4e75           	rts

00045bb8 <_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
)
{
   45bb8:	4e56 0000      	linkw %fp,#0
   45bbc:	2f0a           	movel %a2,%sp@-
   45bbe:	246e 0008      	moveal %fp@(8),%a2
  ISR_Level       level;
  CORE_semaphore_Status status;

  status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;

  if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
   45bc2:	2f0a           	movel %a2,%sp@-
   45bc4:	4eb9 0004 6f84 	jsr 46f84 <_Thread_queue_Dequeue>
   45bca:	588f           	addql #4,%sp
   45bcc:	4a80           	tstl %d0
   45bce:	6704           	beqs 45bd4 <_CORE_semaphore_Surrender+0x1c>
   45bd0:	4280           	clrl %d0
   45bd2:	6024           	bras 45bf8 <_CORE_semaphore_Surrender+0x40>
    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
      (*api_semaphore_mp_support) ( the_thread, id );
#endif

  } else {
    _ISR_Disable( level );
   45bd4:	203c 0000 0700 	movel #1792,%d0
   45bda:	40c1           	movew %sr,%d1
   45bdc:	8081           	orl %d1,%d0
   45bde:	46c0           	movew %d0,%sr
      if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
   45be0:	202a 0048      	movel %a2@(72),%d0
   45be4:	b0aa 0040      	cmpl %a2@(64),%d0
   45be8:	6504           	bcss 45bee <_CORE_semaphore_Surrender+0x36>
   45bea:	7004           	moveq #4,%d0                                      	<== NOT EXECUTED
   45bec:	6008           	bras 45bf6 <_CORE_semaphore_Surrender+0x3e>       	<== NOT EXECUTED
        the_semaphore->count += 1;
   45bee:	5280           	addql #1,%d0
   45bf0:	2540 0048      	movel %d0,%a2@(72)
   45bf4:	4280           	clrl %d0
      else
        status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
    _ISR_Enable( level );
   45bf6:	46c1           	movew %d1,%sr
  }

  return status;
}
   45bf8:	246e fffc      	moveal %fp@(-4),%a2
   45bfc:	4e5e           	unlk %fp
   45bfe:	4e75           	rts

00045f7c <_Internal_error_Occurred>:
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  Internal_errors_t       the_error
)
{
   45f7c:	4e56 0000      	linkw %fp,#0
   45f80:	222e 000c      	movel %fp@(12),%d1
   45f84:	2f03           	movel %d3,%sp@-

  _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 );
   45f86:	4283           	clrl %d3
   45f88:	1601           	moveb %d1,%d3
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  Internal_errors_t       the_error
)
{
   45f8a:	2f02           	movel %d2,%sp@-
   45f8c:	242e 0010      	movel %fp@(16),%d2

  _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 );
   45f90:	2f02           	movel %d2,%sp@-
void _Internal_error_Occurred(
  Internal_errors_Source  the_source,
  bool                    is_internal,
  Internal_errors_t       the_error
)
{
   45f92:	202e 0008      	movel %fp@(8),%d0

  _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 );
   45f96:	2f03           	movel %d3,%sp@-

  _System_state_Set( SYSTEM_STATE_FAILED );

  _CPU_Fatal_halt( the_error );
   45f98:	263c 0000 0700 	movel #1792,%d3

  _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 );
   45f9e:	2f00           	movel %d0,%sp@-
  Internal_errors_t       the_error
)
{

  _Internal_errors_What_happened.the_source  = the_source;
  _Internal_errors_What_happened.is_internal = is_internal;
   45fa0:	13c1 0005 bace 	moveb %d1,5bace <_Internal_errors_What_happened+0x4>
  bool                    is_internal,
  Internal_errors_t       the_error
)
{

  _Internal_errors_What_happened.the_source  = the_source;
   45fa6:	23c0 0005 baca 	movel %d0,5baca <_Internal_errors_What_happened>
  _Internal_errors_What_happened.is_internal = is_internal;
  _Internal_errors_What_happened.the_error   = the_error;
   45fac:	23c2 0005 bad0 	movel %d2,5bad0 <_Internal_errors_What_happened+0x6>

  _User_extensions_Fatal( the_source, is_internal, the_error );
   45fb2:	4eb9 0004 7a26 	jsr 47a26 <_User_extensions_Fatal>

  _System_state_Set( SYSTEM_STATE_FAILED );

  _CPU_Fatal_halt( the_error );
   45fb8:	40c0           	movew %sr,%d0
   45fba:	8083           	orl %d3,%d0
   45fbc:	46c0           	movew %d0,%sr
   45fbe:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   45fc0:	223c dead beef 	movel #-559038737,%d1                             	<== NOT EXECUTED
   45fc6:	4ac8           	halt                                              	<== NOT EXECUTED

RTEMS_INLINE_ROUTINE void _System_state_Set (
  System_state_Codes state
)
{
  _System_state_Current = state;
   45fc8:	7005           	moveq #5,%d0
   45fca:	4fef 000c      	lea %sp@(12),%sp
   45fce:	23c0 0005 bba6 	movel %d0,5bba6 <_System_state_Current>
   45fd4:	60fe           	bras 45fd4 <_Internal_error_Occurred+0x58>
	...

00046040 <_Objects_Allocate>:
 */

Objects_Control *_Objects_Allocate(
  Objects_Information *information
)
{
   46040:	4e56 fff0      	linkw %fp,#-16
   46044:	48d7 0c0c      	moveml %d2-%d3/%a2-%a3,%sp@
   46048:	246e 0008      	moveal %fp@(8),%a2
   *  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 )
   4604c:	4aaa 0014      	tstl %a2@(20)
   46050:	6604           	bnes 46056 <_Objects_Allocate+0x16>
   46052:	4280           	clrl %d0                                          	<== NOT EXECUTED
   46054:	605e           	bras 460b4 <_Objects_Allocate+0x74>               	<== 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 );
   46056:	240a           	movel %a2,%d2
   46058:	0682 0000 001c 	addil #28,%d2
   4605e:	47f9 0004 989c 	lea 4989c <_Chain_Get>,%a3
   46064:	2f02           	movel %d2,%sp@-
   46066:	4e93           	jsr %a3@

  if ( information->auto_extend ) {
   46068:	588f           	addql #4,%sp
   4606a:	4a2a 0010      	tstb %a2@(16)
   4606e:	6744           	beqs 460b4 <_Objects_Allocate+0x74>
    /*
     *  If the list is empty then we are out of objects and need to
     *  extend information base.
     */

    if ( !the_object ) {
   46070:	4a80           	tstl %d0
   46072:	6612           	bnes 46086 <_Objects_Allocate+0x46>
      _Objects_Extend_information( information );
   46074:	2f0a           	movel %a2,%sp@-
   46076:	4eb9 0004 60ec 	jsr 460ec <_Objects_Extend_information>
      the_object =  (Objects_Control *) _Chain_Get( &information->Inactive );
   4607c:	2f02           	movel %d2,%sp@-
   4607e:	4e93           	jsr %a3@
    }

    if ( the_object ) {
   46080:	508f           	addql #8,%sp
   46082:	4a80           	tstl %d0
   46084:	672e           	beqs 460b4 <_Objects_Allocate+0x74>
      uint32_t   block;

      block = (uint32_t) _Objects_Get_index( the_object->id ) -
   46086:	2040           	moveal %d0,%a0
   46088:	4281           	clrl %d1
   4608a:	4283           	clrl %d3
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   4608c:	4282           	clrl %d2
    }

    if ( the_object ) {
      uint32_t   block;

      block = (uint32_t) _Objects_Get_index( the_object->id ) -
   4608e:	362a 0008      	movew %a2@(8),%d3
   46092:	3228 000a      	movew %a0@(10),%d1
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   46096:	342a 0012      	movew %a2@(18),%d2
      information->inactive--;
   4609a:	306a 0028      	moveaw %a2@(40),%a0
    }

    if ( the_object ) {
      uint32_t   block;

      block = (uint32_t) _Objects_Get_index( the_object->id ) -
   4609e:	9283           	subl %d3,%d1
              _Objects_Get_index( information->minimum_id );
      block /= information->allocation_size;

      information->inactive_per_block[ block ]--;
   460a0:	4c42 1001      	remul %d2,%d1,%d1
      information->inactive--;
   460a4:	5388           	subql #1,%a0

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

      information->inactive_per_block[ block ]--;
   460a6:	e589           	lsll #2,%d1
      information->inactive--;
   460a8:	3548 0028      	movew %a0,%a2@(40)

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

      information->inactive_per_block[ block ]--;
   460ac:	206a 002a      	moveal %a2@(42),%a0
   460b0:	d1c1           	addal %d1,%a0
   460b2:	5390           	subql #1,%a0@
      information->inactive--;
    }
  }

  return the_object;
}
   460b4:	4cee 0c0c fff0 	moveml %fp@(-16),%d2-%d3/%a2-%a3
   460ba:	4e5e           	unlk %fp
   460bc:	4e75           	rts
	...

000464ec <_Objects_Initialize_information>:
  information->maximum = 0;

  /*
   *  Register this Object Class in the Object Information Table.
   */
  _Objects_Information_table[ the_api ][ the_class ] = information;
   464ec:	41f9 0005 b9dc 	lea 5b9dc <_Objects_Information_table>,%a0
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   464f2:	4e56 fff0      	linkw %fp,#-16
   464f6:	202e 000c      	movel %fp@(12),%d0
  information->maximum = 0;

  /*
   *  Register this Object Class in the Object Information Table.
   */
  _Objects_Information_table[ the_api ][ the_class ] = information;
   464fa:	2270 0c00      	moveal %a0@(00000000,%d0:l:4),%a1
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   464fe:	48d7 003c      	moveml %d2-%d5,%sp@
   46502:	222e 0014      	movel %fp@(20),%d1
   46506:	4285           	clrl %d5

  /*
   *  Are we operating in limited or unlimited (e.g. auto-extend) mode.
   */
  information->auto_extend =
        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
   46508:	2601           	movel %d1,%d3
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   4650a:	206e 0008      	moveal %fp@(8),%a0
  information->the_class          = the_class;
  information->size               = size;
  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;
  information->inactive           = 0;
   4650e:	4242           	clrw %d2
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   46510:	3a2e 001a      	movew %fp@(26),%d5
   46514:	282e 0010      	movel %fp@(16),%d4

  /*
   *  Are we operating in limited or unlimited (e.g. auto-extend) mode.
   */
  information->auto_extend =
        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
   46518:	d683           	addl %d3,%d3
   4651a:	9783           	subxl %d3,%d3
   4651c:	4483           	negl %d3
  information->the_class          = the_class;
  information->size               = size;
  information->local_table        = 0;
  information->inactive_per_block = 0;
  information->object_blocks      = 0;
  information->inactive           = 0;
   4651e:	3142 0028      	movew %d2,%a0@(40)

  /*
   *  Set the maximum value to 0. It will be updated when objects are
   *  added to the inactive set from _Objects_Extend_information()
   */
  information->maximum = 0;
   46522:	3142 000e      	movew %d2,%a0@(14)
  ,
  bool                 supports_global,
  Objects_Thread_queue_Extract_callout extract
#endif
)
{
   46526:	242e 0020      	movel %fp@(32),%d2
  #if defined(RTEMS_MULTIPROCESSING)
    uint32_t              index;
  #endif

  information->the_api            = the_api;
  information->the_class          = the_class;
   4652a:	3144 0004      	movew %d4,%a0@(4)
  _Objects_Information_table[ the_api ][ the_class ] = information;

  /*
   *  Are we operating in limited or unlimited (e.g. auto-extend) mode.
   */
  information->auto_extend =
   4652e:	1143 0010      	moveb %d3,%a0@(16)
    uint32_t              index;
  #endif

  information->the_api            = the_api;
  information->the_class          = the_class;
  information->size               = size;
   46532:	2145 0014      	movel %d5,%a0@(20)
  information->maximum = 0;

  /*
   *  Register this Object Class in the Object Information Table.
   */
  _Objects_Information_table[ the_api ][ the_class ] = information;
   46536:	2388 4c00      	movel %a0,%a1@(00000000,%d4:l:4)
  /*
   *  Are we operating in limited or unlimited (e.g. auto-extend) mode.
   */
  information->auto_extend =
        (maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
  maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
   4653a:	0881 001f      	bclr #31,%d1
  uint32_t                maximum_per_allocation;
  #if defined(RTEMS_MULTIPROCESSING)
    uint32_t              index;
  #endif

  information->the_api            = the_api;
   4653e:	2080           	movel %d0,%a0@
  information->the_class          = the_class;
  information->size               = size;
  information->local_table        = 0;
   46540:	42a8 0018      	clrl %a0@(24)
  information->inactive_per_block = 0;
   46544:	42a8 002a      	clrl %a0@(42)
  information->object_blocks      = 0;
   46548:	42a8 002e      	clrl %a0@(46)
  maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;

  /*
   *  Unlimited and maximum of zero is illogical.
   */
  if ( information->auto_extend && maximum_per_allocation == 0) {
   4654c:	4a03           	tstb %d3
   4654e:	6714           	beqs 46564 <_Objects_Initialize_information+0x78>
   46550:	4a81           	tstl %d1
   46552:	6610           	bnes 46564 <_Objects_Initialize_information+0x78>
    _Internal_error_Occurred(
   46554:	4878 0014      	pea 14 <OPER2>
   46558:	4878 0001      	pea 1 <ADD>
   4655c:	42a7           	clrl %sp@-
   4655e:	4eb9 0004 5f7c 	jsr 45f7c <_Internal_error_Occurred>

  /*
   *  Calculate minimum and maximum Id's
   */
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
  information->minimum_id =
   46564:	7a18           	moveq #24,%d5
   46566:	4a81           	tstl %d1
   46568:	56c3           	sne %d3
   4656a:	eba8           	lsll %d5,%d0
   4656c:	1a3c 001b      	moveb #27,%d5
   46570:	49c3           	extbl %d3
   46572:	4483           	negl %d3
  information->allocation_size = maximum_per_allocation;

  /*
   *  Provide a null local table entry for the case of any empty table.
   */
  information->local_table = &null_local_table;
   46574:	43f9 0005 b1cc 	lea 5b1cc <null_local_table.3443>,%a1

  /*
   *  Calculate minimum and maximum Id's
   */
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
  information->minimum_id =
   4657a:	ebac           	lsll %d5,%d4
   4657c:	08c0 0010      	bset #16,%d0
  /*
   *  Calculate the maximum name length
   */
  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   46580:	1a3c 0003      	moveb #3,%d5

  /*
   *  Calculate minimum and maximum Id's
   */
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
  information->minimum_id =
   46584:	8084           	orl %d4,%d0
  /*
   *  Calculate the maximum name length
   */
  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   46586:	ca82           	andl %d2,%d5
  }

  /*
   *  The allocation unit is the maximum value
   */
  information->allocation_size = maximum_per_allocation;
   46588:	3141 0012      	movew %d1,%a0@(18)

  /*
   *  Calculate minimum and maximum Id's
   */
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
  information->minimum_id =
   4658c:	8083           	orl %d3,%d0
  information->allocation_size = maximum_per_allocation;

  /*
   *  Provide a null local table entry for the case of any empty table.
   */
  information->local_table = &null_local_table;
   4658e:	2149 0018      	movel %a1,%a0@(24)

  /*
   *  Calculate minimum and maximum Id's
   */
  minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
  information->minimum_id =
   46592:	2140 0006      	movel %d0,%a0@(6)
  /*
   *  Calculate the maximum name length
   */
  name_length = maximum_name_length;

  if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
   46596:	4a85           	tstl %d5
   46598:	6604           	bnes 4659e <_Objects_Initialize_information+0xb2>
   4659a:	2002           	movel %d2,%d0
   4659c:	6008           	bras 465a6 <_Objects_Initialize_information+0xba>
    name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
   4659e:	2002           	movel %d2,%d0                                     	<== NOT EXECUTED
   465a0:	5880           	addql #4,%d0                                      	<== NOT EXECUTED
   465a2:	74fc           	moveq #-4,%d2                                     	<== NOT EXECUTED
   465a4:	c082           	andl %d2,%d0                                      	<== NOT EXECUTED
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   465a6:	43e8 0020      	lea %a0@(32),%a1
   465aa:	2149 001c      	movel %a1,%a0@(28)
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   465ae:	43e8 001c      	lea %a0@(28),%a1
                  ~(OBJECTS_NAME_ALIGNMENT-1);

  information->name_length = name_length;
   465b2:	3140 0032      	movew %d0,%a0@(50)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   465b6:	42a8 0020      	clrl %a0@(32)
  the_chain->last           = _Chain_Head(the_chain);
   465ba:	2149 0024      	movel %a1,%a0@(36)
  _Chain_Initialize_empty( &information->Inactive );

  /*
   *  Initialize objects .. if there are any
   */
  if ( maximum_per_allocation ) {
   465be:	4a81           	tstl %d1
   465c0:	6712           	beqs 465d4 <_Objects_Initialize_information+0xe8>
    /*
     *  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 );
   465c2:	2d48 0008      	movel %a0,%fp@(8)
	_Chain_Initialize_empty( &information->global_table[ index ] );
     }
     else
       information->global_table = NULL;
  #endif
}
   465c6:	4cee 003c fff0 	moveml %fp@(-16),%d2-%d5
   465cc:	4e5e           	unlk %fp
    /*
     *  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 );
   465ce:	4ef9 0004 60ec 	jmp 460ec <_Objects_Extend_information>
	_Chain_Initialize_empty( &information->global_table[ index ] );
     }
     else
       information->global_table = NULL;
  #endif
}
   465d4:	4cee 003c fff0 	moveml %fp@(-16),%d2-%d5
   465da:	4e5e           	unlk %fp
   465dc:	4e75           	rts
	...

00047af4 <_Thread_Restart>:
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
   47af4:	7001           	moveq #1,%d0
bool _Thread_Restart(
  Thread_Control            *the_thread,
  void                      *pointer_argument,
  Thread_Entry_numeric_type  numeric_argument
)
{
   47af6:	4e56 0000      	linkw %fp,#0
   47afa:	2f0a           	movel %a2,%sp@-
   47afc:	246e 0008      	moveal %fp@(8),%a2
  if ( !_States_Is_dormant( the_thread->current_state ) ) {
   47b00:	c0aa 0010      	andl %a2@(16),%d0
   47b04:	4a00           	tstb %d0
   47b06:	6704           	beqs 47b0c <_Thread_Restart+0x18>
   47b08:	4200           	clrb %d0
   47b0a:	6064           	bras 47b70 <_Thread_Restart+0x7c>

    _Thread_Set_transient( the_thread );
   47b0c:	2f0a           	movel %a2,%sp@-
   47b0e:	4eb9 0004 7cd0 	jsr 47cd0 <_Thread_Set_transient>

    _Thread_Reset( the_thread, pointer_argument, numeric_argument );
   47b14:	2f2e 0010      	movel %fp@(16),%sp@-
   47b18:	2f2e 000c      	movel %fp@(12),%sp@-
   47b1c:	2f0a           	movel %a2,%sp@-
   47b1e:	4eb9 0004 a970 	jsr 4a970 <_Thread_Reset>

    _Thread_Load_environment( the_thread );
   47b24:	2f0a           	movel %a2,%sp@-
   47b26:	4eb9 0004 a60c 	jsr 4a60c <_Thread_Load_environment>

    _Thread_Ready( the_thread );
   47b2c:	2f0a           	movel %a2,%sp@-
   47b2e:	4eb9 0004 a8b0 	jsr 4a8b0 <_Thread_Ready>

    _User_extensions_Thread_restart( the_thread );
   47b34:	2f0a           	movel %a2,%sp@-
   47b36:	4eb9 0004 8284 	jsr 48284 <_User_extensions_Thread_restart>

    if ( _Thread_Is_executing ( the_thread ) )
   47b3c:	4fef 001c      	lea %sp@(28),%sp
   47b40:	b5f9 0005 c566 	cmpal 5c566 <_Thread_Executing>,%a2
   47b46:	6626           	bnes 47b6e <_Thread_Restart+0x7a>
 */

RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
  if ( _Thread_Executing->fp_context != NULL )
   47b48:	4aaa 0100      	tstl %a2@(256)
   47b4c:	670c           	beqs 47b5a <_Thread_Restart+0x66>
    _Context_Restore_fp( &_Thread_Executing->fp_context );
   47b4e:	486a 0100      	pea %a2@(256)
   47b52:	4eb9 0004 8774 	jsr 48774 <_CPU_Context_restore_fp>
   47b58:	588f           	addql #4,%sp
#endif

  _CPU_Context_Restart_self( &_Thread_Executing->Registers );
   47b5a:	2079 0005 c566 	moveal 5c566 <_Thread_Executing>,%a0
   47b60:	41e8 00cc      	lea %a0@(204),%a0
   47b64:	2f08           	movel %a0,%sp@-
   47b66:	4eb9 0004 8632 	jsr 48632 <_CPU_Context_Restart_self>
   47b6c:	588f           	addql #4,%sp                                      	<== NOT EXECUTED
   47b6e:	7001           	moveq #1,%d0

    return true;
  }

  return false;
}
   47b70:	246e fffc      	moveal %fp@(-4),%a2
   47b74:	4e5e           	unlk %fp
   47b76:	4e75           	rts

0004715c <_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
)
{
   4715c:	4e56 ffe4      	linkw %fp,#-28
   47160:	206e 000c      	moveal %fp@(12),%a0
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   47164:	43e8 003c      	lea %a0@(60),%a1
  Priority_Control     priority;
  States_Control       block_state;

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
   47168:	2028 0014      	movel %a0@(20),%d0
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_Level            *level_p
)
{
   4716c:	48d7 0c7c      	moveml %d2-%d6/%a2-%a3,%sp@

  _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 ];
   47170:	2400           	movel %d0,%d2
   47172:	ec8a           	lsrl #6,%d2
   47174:	2202           	movel %d2,%d1
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;

  _ISR_Disable( level );
   47176:	283c 0000 0700 	movel #1792,%d4

  _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 ];
   4717c:	e989           	lsll #4,%d1
   4717e:	e58a           	lsll #2,%d2
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_Level            *level_p
)
{
   47180:	246e 0008      	moveal %fp@(8),%a2

  _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 ];
   47184:	9282           	subl %d2,%d1
   47186:	47f2 1800      	lea %a2@(00000000,%d1:l),%a3
   4718a:	2149 0038      	movel %a1,%a0@(56)
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
   4718e:	43e8 0038      	lea %a0@(56),%a1
  block_state  = the_thread_queue->state;
   47192:	2a2a 0038      	movel %a2@(56),%d5
   47196:	2149 0040      	movel %a1,%a0@(64)
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
   4719a:	42a8 003c      	clrl %a0@(60)

  if ( _Thread_queue_Is_reverse_search( priority ) )
   4719e:	0800 0005      	btst #5,%d0
   471a2:	6660           	bnes 47204 <_Thread_queue_Enqueue_priority+0xa8>
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   471a4:	2c0b           	movel %a3,%d6
   471a6:	5886           	addql #4,%d6
    goto restart_reverse_search;

restart_forward_search:
  search_priority = PRIORITY_MINIMUM - 1;
  _ISR_Disable( level );
   471a8:	2404           	movel %d4,%d2
   471aa:	40c1           	movew %sr,%d1
   471ac:	8481           	orl %d1,%d2
   471ae:	46c2           	movew %d2,%sr
  search_thread = (Thread_Control *) header->first;
   471b0:	2253           	moveal %a3@,%a1
   471b2:	76ff           	moveq #-1,%d3
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
   471b4:	601e           	bras 471d4 <_Thread_queue_Enqueue_priority+0x78>
    search_priority = search_thread->current_priority;
   471b6:	2629 0014      	movel %a1@(20),%d3
    if ( priority <= search_priority )
   471ba:	b680           	cmpl %d0,%d3
   471bc:	641a           	bccs 471d8 <_Thread_queue_Enqueue_priority+0x7c>
      break;
    search_priority = search_thread->current_priority;
    if ( priority <= search_priority )
      break;
#endif
    _ISR_Flash( level );
   471be:	2404           	movel %d4,%d2
   471c0:	46c1           	movew %d1,%sr
   471c2:	8481           	orl %d1,%d2
   471c4:	46c2           	movew %d2,%sr
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
   471c6:	2405           	movel %d5,%d2
   471c8:	c4a9 0010      	andl %a1@(16),%d2
   471cc:	6604           	bnes 471d2 <_Thread_queue_Enqueue_priority+0x76>
      _ISR_Enable( level );
   471ce:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
      goto restart_forward_search;
   471d0:	60d6           	bras 471a8 <_Thread_queue_Enqueue_priority+0x4c>  	<== NOT EXECUTED
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
   471d2:	2251           	moveal %a1@,%a1

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:	bc89           	cmpl %a1,%d6
   471d6:	66de           	bnes 471b6 <_Thread_queue_Enqueue_priority+0x5a>
   471d8:	2401           	movel %d1,%d2
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
   471da:	7801           	moveq #1,%d4
   471dc:	b8aa 0030      	cmpl %a2@(48),%d4
   471e0:	6600 00a4      	bnew 47286 <_Thread_queue_Enqueue_priority+0x12a>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   471e4:	42aa 0030      	clrl %a2@(48)

  if ( priority == search_priority )
   471e8:	b680           	cmpl %d0,%d3
   471ea:	677e           	beqs 4726a <_Thread_queue_Enqueue_priority+0x10e>
    goto equal_priority;

  search_node   = (Chain_Node *) search_thread;
  previous_node = search_node->previous;
   471ec:	2669 0004      	moveal %a1@(4),%a3
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
   471f0:	2089           	movel %a1,%a0@
  the_node->previous     = previous_node;
   471f2:	214b 0004      	movel %a3,%a0@(4)
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
   471f6:	214a 0044      	movel %a2,%a0@(68)
  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;
   471fa:	2688           	movel %a0,%a3@
  search_node->previous  = the_node;
   471fc:	2348 0004      	movel %a0,%a1@(4)
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   47200:	46c1           	movew %d1,%sr
   47202:	6062           	bras 47266 <_Thread_queue_Enqueue_priority+0x10a>
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;
   47204:	4283           	clrl %d3
   47206:	1639 0005 a2f2 	moveb 5a2f2 <rtems_maximum_priority>,%d3

  _ISR_Disable( level );
   4720c:	2404           	movel %d4,%d2
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;
   4720e:	5283           	addql #1,%d3

  _ISR_Disable( level );
   47210:	40c1           	movew %sr,%d1
   47212:	8481           	orl %d1,%d2
   47214:	46c2           	movew %d2,%sr
  search_thread = (Thread_Control *) header->last;
   47216:	226b 0008      	moveal %a3@(8),%a1
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
   4721a:	6020           	bras 4723c <_Thread_queue_Enqueue_priority+0xe0>
    search_priority = search_thread->current_priority;
   4721c:	2629 0014      	movel %a1@(20),%d3
    if ( priority >= search_priority )
   47220:	b680           	cmpl %d0,%d3
   47222:	631c           	blss 47240 <_Thread_queue_Enqueue_priority+0xe4>
      break;
    search_priority = search_thread->current_priority;
    if ( priority >= search_priority )
      break;
#endif
    _ISR_Flash( level );
   47224:	2404           	movel %d4,%d2
   47226:	46c1           	movew %d1,%sr
   47228:	8481           	orl %d1,%d2
   4722a:	46c2           	movew %d2,%sr
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
   4722c:	2405           	movel %d5,%d2
   4722e:	c4a9 0010      	andl %a1@(16),%d2
   47232:	6604           	bnes 47238 <_Thread_queue_Enqueue_priority+0xdc>
      _ISR_Enable( level );
   47234:	46c1           	movew %d1,%sr
      goto restart_reverse_search;
   47236:	60cc           	bras 47204 <_Thread_queue_Enqueue_priority+0xa8>
    }
    search_thread = (Thread_Control *)
   47238:	2269 0004      	moveal %a1@(4),%a1
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 ) ) {
   4723c:	b7c9           	cmpal %a1,%a3
   4723e:	66dc           	bnes 4721c <_Thread_queue_Enqueue_priority+0xc0>
   47240:	2401           	movel %d1,%d2
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
   47242:	7801           	moveq #1,%d4
   47244:	b8aa 0030      	cmpl %a2@(48),%d4
   47248:	663c           	bnes 47286 <_Thread_queue_Enqueue_priority+0x12a>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
   4724a:	42aa 0030      	clrl %a2@(48)

  if ( priority == search_priority )
   4724e:	b680           	cmpl %d0,%d3
   47250:	6718           	beqs 4726a <_Thread_queue_Enqueue_priority+0x10e>
    goto equal_priority;

  search_node = (Chain_Node *) search_thread;
  next_node   = search_node->next;
   47252:	2651           	moveal %a1@,%a3
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
  the_node->previous      = search_node;
   47254:	2149 0004      	movel %a1,%a0@(4)

  search_node = (Chain_Node *) search_thread;
  next_node   = search_node->next;
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
   47258:	208b           	movel %a3,%a0@
  the_node->previous      = search_node;
  search_node->next       = the_node;
  next_node->previous    = the_node;
  the_thread->Wait.queue = the_thread_queue;
   4725a:	214a 0044      	movel %a2,%a0@(68)
  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;
   4725e:	2288           	movel %a0,%a1@
  next_node->previous    = the_node;
   47260:	2748 0004      	movel %a0,%a3@(4)
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   47264:	46c1           	movew %d1,%sr
   47266:	7001           	moveq #1,%d0
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
   47268:	6026           	bras 47290 <_Thread_queue_Enqueue_priority+0x134>
   4726a:	43e9 003c      	lea %a1@(60),%a1

equal_priority:               /* add at end of priority group */
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );
  previous_node = search_node->previous;
   4726e:	2669 0004      	moveal %a1@(4),%a3
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
   47272:	2089           	movel %a1,%a0@
  the_node->previous     = previous_node;
   47274:	214b 0004      	movel %a3,%a0@(4)
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
   47278:	214a 0044      	movel %a2,%a0@(68)
  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;
   4727c:	2688           	movel %a0,%a3@
  search_node->previous  = the_node;
   4727e:	2348 0004      	movel %a0,%a1@(4)
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
   47282:	46c2           	movew %d2,%sr
   47284:	60e0           	bras 47266 <_Thread_queue_Enqueue_priority+0x10a>
   *  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;
   47286:	206e 0010      	moveal %fp@(16),%a0
  return the_thread_queue->sync_state;
   4728a:	202a 0030      	movel %a2@(48),%d0
   *  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;
   4728e:	2082           	movel %d2,%a0@
  return the_thread_queue->sync_state;
}
   47290:	4cd7 0c7c      	moveml %sp@,%d2-%d6/%a2-%a3
   47294:	4e5e           	unlk %fp
   47296:	4e75           	rts

00050edc <_Timer_server_Body>:
 *  @a arg points to the corresponding timer server control block.
 */
static rtems_task _Timer_server_Body(
  rtems_task_argument arg
)
{
   50edc:	4e56 ffb4      	linkw %fp,#-76
   50ee0:	200e           	movel %fp,%d0
   50ee2:	0680 ffff fff4 	addil #-12,%d0
   50ee8:	48d7 3cfc      	moveml %d2-%d7/%a2-%a5,%sp@
   50eec:	246e 0008      	moveal %fp@(8),%a2
   50ef0:	240e           	movel %fp,%d2
   50ef2:	2a0e           	movel %fp,%d5
   50ef4:	260e           	movel %fp,%d3
   50ef6:	0682 ffff ffe8 	addil #-24,%d2
   50efc:	5185           	subql #8,%d5
   50efe:	0683 ffff ffec 	addil #-20,%d3

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
   50f04:	41ea 0008      	lea %a2@(8),%a0

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
   50f08:	4bea 0040      	lea %a2@(64),%a5
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f0c:	2e0a           	movel %a2,%d7
    /*
     *  This path is for normal forward movement and cases where the
     *  TOD has been set forward.
     */
    delta = snapshot - last_snapshot;
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f0e:	280a           	movel %a2,%d4
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f10:	0687 0000 0030 	addil #48,%d7
    /*
     *  This path is for normal forward movement and cases where the
     *  TOD has been set forward.
     */
    delta = snapshot - last_snapshot;
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f16:	0684 0000 0068 	addil #104,%d4
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f1c:	49f9 0005 48e4 	lea 548e4 <_Watchdog_Adjust_to_chain>,%a4
)
{
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
   50f22:	47f9 0005 4974 	lea 54974 <_Watchdog_Insert>,%a3

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
   50f28:	2d48 ffe4      	movel %a0,%fp@(-28)
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   50f2c:	2d45 fff4      	movel %d5,%fp@(-12)
  the_chain->permanent_null = NULL;
   50f30:	42ae fff8      	clrl %fp@(-8)
  the_chain->last           = _Chain_Head(the_chain);
   50f34:	2d40 fffc      	movel %d0,%fp@(-4)
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   50f38:	2d43 ffe8      	movel %d3,%fp@(-24)
  the_chain->permanent_null = NULL;
   50f3c:	42ae ffec      	clrl %fp@(-20)
  the_chain->last           = _Chain_Head(the_chain);
   50f40:	2d42 fff0      	movel %d2,%fp@(-16)
   50f44:	2d4d ffe0      	movel %a5,%fp@(-32)
{
  /*
   *  Afterwards all timer inserts are directed to this chain and the interval
   *  and TOD chains will be no more modified by other parties.
   */
  ts->insert_chain = insert_chain;
   50f48:	41ee fff4      	lea %fp@(-12),%a0
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.
     */
    _Timer_server_Process_insertions( ts );

    _ISR_Disable( level );
   50f4c:	3a7c 0700      	moveaw #1792,%a5
{
  /*
   *  Afterwards all timer inserts are directed to this chain and the interval
   *  and TOD chains will be no more modified by other parties.
   */
  ts->insert_chain = insert_chain;
   50f50:	2548 0078      	movel %a0,%a2@(120)
static void _Timer_server_Process_interval_watchdogs(
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
   50f54:	2039 0007 3a10 	movel 73a10 <_Watchdog_Ticks_since_boot>,%d0

  /*
   *  We assume adequate unsigned arithmetic here.
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
   50f5a:	222a 003c      	movel %a2@(60),%d1

  watchdogs->last_snapshot = snapshot;
   50f5e:	2540 003c      	movel %d0,%a2@(60)

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f62:	486e ffe8      	pea %fp@(-24)
   50f66:	9081           	subl %d1,%d0
   50f68:	2f00           	movel %d0,%sp@-
   50f6a:	2f07           	movel %d7,%sp@-
   50f6c:	4e94           	jsr %a4@
static void _Timer_server_Process_tod_watchdogs(
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
   50f6e:	2039 0007 3962 	movel 73962 <_TOD_Now>,%d0
  /*
   *  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 watchdogs->Chain to indicate this.
   */
  if ( snapshot > last_snapshot ) {
   50f74:	4fef 000c      	lea %sp@(12),%sp
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
   50f78:	222a 0074      	movel %a2@(116),%d1
  /*
   *  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 watchdogs->Chain to indicate this.
   */
  if ( snapshot > last_snapshot ) {
   50f7c:	b280           	cmpl %d0,%d1
   50f7e:	6414           	bccs 50f94 <_Timer_server_Body+0xb8>
    /*
     *  This path is for normal forward movement and cases where the
     *  TOD has been set forward.
     */
    delta = snapshot - last_snapshot;
    _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   50f80:	486e ffe8      	pea %fp@(-24)
   50f84:	2c00           	movel %d0,%d6
   50f86:	9c81           	subl %d1,%d6
   50f88:	2f06           	movel %d6,%sp@-
   50f8a:	2d40 ffdc      	movel %d0,%fp@(-36)
   50f8e:	2f04           	movel %d4,%sp@-
   50f90:	4e94           	jsr %a4@
   50f92:	6018           	bras 50fac <_Timer_server_Body+0xd0>

  } else if ( snapshot < last_snapshot ) {
   50f94:	b280           	cmpl %d0,%d1
   50f96:	631c           	blss 50fb4 <_Timer_server_Body+0xd8>
     /*
      *  The current TOD is before the last TOD which indicates that
      *  TOD has been set backwards.
      */
     delta = last_snapshot - snapshot;
     _Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
   50f98:	9280           	subl %d0,%d1
   50f9a:	2f01           	movel %d1,%sp@-
   50f9c:	4878 0001      	pea 1 <ADD>
   50fa0:	2d40 ffdc      	movel %d0,%fp@(-36)
   50fa4:	2f04           	movel %d4,%sp@-
   50fa6:	4eb9 0005 4864 	jsr 54864 <_Watchdog_Adjust>
   50fac:	202e ffdc      	movel %fp@(-36),%d0
   50fb0:	4fef 000c      	lea %sp@(12),%sp
  }

  watchdogs->last_snapshot = snapshot;
   50fb4:	2540 0074      	movel %d0,%a2@(116)
}

static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
  while ( true ) {
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
   50fb8:	202a 0078      	movel %a2@(120),%d0
   50fbc:	2f00           	movel %d0,%sp@-
   50fbe:	4eb9 0005 1850 	jsr 51850 <_Chain_Get>

    if ( timer == NULL ) {
   50fc4:	588f           	addql #4,%sp
}

static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
  while ( true ) {
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
   50fc6:	2040           	moveal %d0,%a0

    if ( timer == NULL ) {
   50fc8:	4a80           	tstl %d0
   50fca:	6724           	beqs 50ff0 <_Timer_server_Body+0x114>
static void _Timer_server_Insert_timer(
  Timer_server_Control *ts,
  Timer_Control *timer
)
{
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
   50fcc:	2028 0038      	movel %a0@(56),%d0                                	<== NOT EXECUTED
   50fd0:	7201           	moveq #1,%d1                                      	<== NOT EXECUTED
   50fd2:	b280           	cmpl %d0,%d1                                      	<== NOT EXECUTED
   50fd4:	6608           	bnes 50fde <_Timer_server_Body+0x102>             	<== NOT EXECUTED
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
   50fd6:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   50fda:	2f07           	movel %d7,%sp@-                                   	<== NOT EXECUTED
   50fdc:	600c           	bras 50fea <_Timer_server_Body+0x10e>             	<== NOT EXECUTED
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
   50fde:	7c03           	moveq #3,%d6                                      	<== NOT EXECUTED
   50fe0:	bc80           	cmpl %d0,%d6                                      	<== NOT EXECUTED
   50fe2:	66d4           	bnes 50fb8 <_Timer_server_Body+0xdc>              	<== NOT EXECUTED
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
   50fe4:	4868 0010      	pea %a0@(16)                                      	<== NOT EXECUTED
   50fe8:	2f04           	movel %d4,%sp@-                                   	<== NOT EXECUTED
   50fea:	4e93           	jsr %a3@                                          	<== NOT EXECUTED
   50fec:	508f           	addql #8,%sp                                      	<== NOT EXECUTED
   50fee:	60c8           	bras 50fb8 <_Timer_server_Body+0xdc>              	<== NOT EXECUTED
     *  of zero it will be processed in the next iteration of the timer server
     *  body loop.
     */
    _Timer_server_Process_insertions( ts );

    _ISR_Disable( level );
   50ff0:	200d           	movel %a5,%d0
   50ff2:	40c1           	movew %sr,%d1
   50ff4:	8081           	orl %d1,%d0
   50ff6:	46c0           	movew %d0,%sr
    if ( _Chain_Is_empty( insert_chain ) ) {
   50ff8:	baae fff4      	cmpl %fp@(-12),%d5
   50ffc:	6612           	bnes 51010 <_Timer_server_Body+0x134>
      ts->insert_chain = NULL;
   50ffe:	42aa 0078      	clrl %a2@(120)
      _ISR_Enable( level );
   51002:	46c1           	movew %d1,%sr

        /*
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.
         */
        _ISR_Disable( level );
   51004:	3a7c 0700      	moveaw #1792,%a5
  _Chain_Initialize_empty( &fire_chain );

  while ( true ) {
    _Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );

    if ( !_Chain_Is_empty( &fire_chain ) ) {
   51008:	b6ae ffe8      	cmpl %fp@(-24),%d3
   5100c:	6608           	bnes 51016 <_Timer_server_Body+0x13a>
   5100e:	6042           	bras 51052 <_Timer_server_Body+0x176>
      ts->insert_chain = NULL;
      _ISR_Enable( level );

      break;
    } else {
      _ISR_Enable( level );
   51010:	46c1           	movew %d1,%sr                                     	<== NOT EXECUTED
   51012:	6000 ff40      	braw 50f54 <_Timer_server_Body+0x78>              	<== NOT EXECUTED

        /*
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.
         */
        _ISR_Disable( level );
   51016:	220d           	movel %a5,%d1
   51018:	40c0           	movew %sr,%d0
   5101a:	8280           	orl %d0,%d1
   5101c:	46c1           	movew %d1,%sr
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   5101e:	206e ffe8      	moveal %fp@(-24),%a0
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   51022:	b688           	cmpl %a0,%d3
   51024:	6726           	beqs 5104c <_Timer_server_Body+0x170>
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   51026:	2250           	moveal %a0@,%a1
  the_chain->first    = new_first;
   51028:	2d49 ffe8      	movel %a1,%fp@(-24)
  new_first->previous = _Chain_Head(the_chain);
   5102c:	2342 0004      	movel %d2,%a1@(4)
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {
   51030:	4a88           	tstl %a0
   51032:	6718           	beqs 5104c <_Timer_server_Body+0x170>
          watchdog->state = WATCHDOG_INACTIVE;
   51034:	42a8 0008      	clrl %a0@(8)
          _ISR_Enable( level );
   51038:	46c0           	movew %d0,%sr
        /*
         *  The timer server may block here and wait for resources or time.
         *  The system watchdogs are inactive and will remain inactive since
         *  the active flag of the timer server is true.
         */
        (*watchdog->routine)( watchdog->id, watchdog->user_data );
   5103a:	2f28 0024      	movel %a0@(36),%sp@-
   5103e:	2f28 0020      	movel %a0@(32),%sp@-
   51042:	2068 001c      	moveal %a0@(28),%a0
   51046:	4e90           	jsr %a0@
      }
   51048:	508f           	addql #8,%sp
   5104a:	60ca           	bras 51016 <_Timer_server_Body+0x13a>
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {
          watchdog->state = WATCHDOG_INACTIVE;
          _ISR_Enable( level );
        } else {
          _ISR_Enable( level );
   5104c:	46c0           	movew %d0,%sr
   5104e:	6000 fef8      	braw 50f48 <_Timer_server_Body+0x6c>
         *  the active flag of the timer server is true.
         */
        (*watchdog->routine)( watchdog->id, watchdog->user_data );
      }
    } else {
      ts->active = false;
   51052:	4200           	clrb %d0
   51054:	1540 007c      	moveb %d0,%a2@(124)
   51058:	2039 0007 38d0 	movel 738d0 <_Thread_Dispatch_disable_level>,%d0
   5105e:	5280           	addql #1,%d0
   51060:	23c0 0007 38d0 	movel %d0,738d0 <_Thread_Dispatch_disable_level>

      /*
       *  Block until there is something to do.
       */
      _Thread_Disable_dispatch();
        _Thread_Set_state( ts->thread, STATES_DELAYING );
   51066:	4878 0008      	pea 8 <DIVIDE_BY_ZERO>

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
   5106a:	4bf9 0005 4a90 	lea 54a90 <_Watchdog_Remove>,%a5

      /*
       *  Block until there is something to do.
       */
      _Thread_Disable_dispatch();
        _Thread_Set_state( ts->thread, STATES_DELAYING );
   51070:	2f12           	movel %a2@,%sp@-
   51072:	4eb9 0005 40b0 	jsr 540b0 <_Thread_Set_state>
        _Timer_server_Reset_interval_system_watchdog( ts );
   51078:	2f0a           	movel %a2,%sp@-
   5107a:	4eba fd9c      	jsr %pc@(50e18 <_Timer_server_Reset_interval_system_watchdog>)
        _Timer_server_Reset_tod_system_watchdog( ts );
   5107e:	2f0a           	movel %a2,%sp@-
   51080:	4eba fdf6      	jsr %pc@(50e78 <_Timer_server_Reset_tod_system_watchdog>)
      _Thread_Enable_dispatch();
   51084:	4eb9 0005 375e 	jsr 5375e <_Thread_Enable_dispatch>

      ts->active = true;
   5108a:	7201           	moveq #1,%d1
   5108c:	1541 007c      	moveb %d1,%a2@(124)

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
   51090:	2f2e ffe4      	movel %fp@(-28),%sp@-
   51094:	4e95           	jsr %a5@

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
   51096:	2f2e ffe0      	movel %fp@(-32),%sp@-
   5109a:	4e95           	jsr %a5@
   5109c:	4fef 0018      	lea %sp@(24),%sp
   510a0:	6000 fea6      	braw 50f48 <_Timer_server_Body+0x6c>

000510a4 <_Timer_server_Schedule_operation_method>:

static void _Timer_server_Schedule_operation_method(
  Timer_server_Control *ts,
  Timer_Control *timer
)
{
   510a4:	4e56 fff0      	linkw %fp,#-16
   510a8:	206e 000c      	moveal %fp@(12),%a0
   510ac:	48d7 041c      	moveml %d2-%d4/%a2,%sp@
   510b0:	246e 0008      	moveal %fp@(8),%a2
  if ( ts->insert_chain == NULL ) {
   510b4:	202a 0078      	movel %a2@(120),%d0
   510b8:	6600 00f8      	bnew 511b2 <_Timer_server_Schedule_operation_method+0x10e>
   510bc:	2039 0007 38d0 	movel 738d0 <_Thread_Dispatch_disable_level>,%d0
   510c2:	5280           	addql #1,%d0
   510c4:	23c0 0007 38d0 	movel %d0,738d0 <_Thread_Dispatch_disable_level>
   *  being inserted.  This could result in an integer overflow.
   */

  _Thread_Disable_dispatch();

  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
   510ca:	2028 0038      	movel %a0@(56),%d0
   510ce:	7201           	moveq #1,%d1
   510d0:	b280           	cmpl %d0,%d1
   510d2:	6660           	bnes 51134 <_Timer_server_Schedule_operation_method+0x90>
    /*
     *  We have to advance the last known ticks value of the server and update
     *  the watchdog chain accordingly.
     */
    _ISR_Disable( level );
   510d4:	203c 0000 0700 	movel #1792,%d0
   510da:	40c3           	movew %sr,%d3
   510dc:	8083           	orl %d3,%d0
   510de:	46c0           	movew %d0,%sr
    snapshot = _Watchdog_Ticks_since_boot;
   510e0:	2039 0007 3a10 	movel 73a10 <_Watchdog_Ticks_since_boot>,%d0
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   510e6:	220a           	movel %a2,%d1
   510e8:	0681 0000 0034 	addil #52,%d1
    last_snapshot = ts->Interval_watchdogs.last_snapshot;
   510ee:	242a 003c      	movel %a2@(60),%d2
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   510f2:	226a 0030      	moveal %a2@(48),%a1
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   510f6:	b289           	cmpl %a1,%d1
   510f8:	6716           	beqs 51110 <_Timer_server_Schedule_operation_method+0x6c>
      first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );

      /*
       *  We assume adequate unsigned arithmetic here.
       */
      delta = snapshot - last_snapshot;
   510fa:	2800           	movel %d0,%d4
   510fc:	9882           	subl %d2,%d4

      delta_interval = first_watchdog->delta_interval;
   510fe:	2229 0010      	movel %a1@(16),%d1
      if (delta_interval > delta) {
   51102:	b881           	cmpl %d1,%d4
   51104:	6504           	bcss 5110a <_Timer_server_Schedule_operation_method+0x66>
   51106:	4281           	clrl %d1
   51108:	6002           	bras 5110c <_Timer_server_Schedule_operation_method+0x68>
        delta_interval -= delta;
   5110a:	9284           	subl %d4,%d1
      } else {
        delta_interval = 0;
      }
      first_watchdog->delta_interval = delta_interval;
   5110c:	2341 0010      	movel %d1,%a1@(16)
    }
    ts->Interval_watchdogs.last_snapshot = snapshot;
   51110:	2540 003c      	movel %d0,%a2@(60)
    _ISR_Enable( level );
   51114:	46c3           	movew %d3,%sr

    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
   51116:	4868 0010      	pea %a0@(16)
   5111a:	486a 0030      	pea %a2@(48)
   5111e:	4eb9 0005 4974 	jsr 54974 <_Watchdog_Insert>

    if ( !ts->active ) {
   51124:	508f           	addql #8,%sp
   51126:	102a 007c      	moveb %a2@(124),%d0
   5112a:	6678           	bnes 511a4 <_Timer_server_Schedule_operation_method+0x100>
      _Timer_server_Reset_interval_system_watchdog( ts );
   5112c:	2f0a           	movel %a2,%sp@-
   5112e:	4eba fce8      	jsr %pc@(50e18 <_Timer_server_Reset_interval_system_watchdog>)
   51132:	606e           	bras 511a2 <_Timer_server_Schedule_operation_method+0xfe>
    }
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
   51134:	7203           	moveq #3,%d1
   51136:	b280           	cmpl %d0,%d1
   51138:	666a           	bnes 511a4 <_Timer_server_Schedule_operation_method+0x100>
    /*
     *  We have to advance the last known seconds value of the server and update
     *  the watchdog chain accordingly.
     */
    _ISR_Disable( level );
   5113a:	203c 0000 0700 	movel #1792,%d0
   51140:	40c3           	movew %sr,%d3
   51142:	8083           	orl %d3,%d0
   51144:	46c0           	movew %d0,%sr
   51146:	200a           	movel %a2,%d0
   51148:	0680 0000 006c 	addil #108,%d0
    snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
   5114e:	2239 0007 3962 	movel 73962 <_TOD_Now>,%d1
    last_snapshot = ts->TOD_watchdogs.last_snapshot;
   51154:	242a 0074      	movel %a2@(116),%d2
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   51158:	226a 0068      	moveal %a2@(104),%a1
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   5115c:	b089           	cmpl %a1,%d0
   5115e:	6720           	beqs 51180 <_Timer_server_Schedule_operation_method+0xdc>
    if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
      first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
      delta_interval = first_watchdog->delta_interval;
   51160:	2029 0010      	movel %a1@(16),%d0
      if ( snapshot > last_snapshot ) {
   51164:	b481           	cmpl %d1,%d2
   51166:	6410           	bccs 51178 <_Timer_server_Schedule_operation_method+0xd4>
        /*
         *  We advanced in time.
         */
        delta = snapshot - last_snapshot;
   51168:	2801           	movel %d1,%d4
   5116a:	9882           	subl %d2,%d4
        if (delta_interval > delta) {
   5116c:	b880           	cmpl %d0,%d4
   5116e:	6504           	bcss 51174 <_Timer_server_Schedule_operation_method+0xd0>
   51170:	4280           	clrl %d0                                          	<== NOT EXECUTED
   51172:	6008           	bras 5117c <_Timer_server_Schedule_operation_method+0xd8>	<== NOT EXECUTED
          delta_interval -= delta;
   51174:	9084           	subl %d4,%d0
   51176:	6004           	bras 5117c <_Timer_server_Schedule_operation_method+0xd8>
        }
      } else {
        /*
         *  Someone put us in the past.
         */
        delta = last_snapshot - snapshot;
   51178:	d082           	addl %d2,%d0
        delta_interval += delta;
   5117a:	9081           	subl %d1,%d0
      }
      first_watchdog->delta_interval = delta_interval;
   5117c:	2340 0010      	movel %d0,%a1@(16)
    }
    ts->TOD_watchdogs.last_snapshot = snapshot;
   51180:	2541 0074      	movel %d1,%a2@(116)
    _ISR_Enable( level );
   51184:	46c3           	movew %d3,%sr

    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
   51186:	4868 0010      	pea %a0@(16)
   5118a:	486a 0068      	pea %a2@(104)
   5118e:	4eb9 0005 4974 	jsr 54974 <_Watchdog_Insert>

    if ( !ts->active ) {
   51194:	508f           	addql #8,%sp
   51196:	102a 007c      	moveb %a2@(124),%d0
   5119a:	6608           	bnes 511a4 <_Timer_server_Schedule_operation_method+0x100>
      _Timer_server_Reset_tod_system_watchdog( ts );
   5119c:	2f0a           	movel %a2,%sp@-
   5119e:	4eba fcd8      	jsr %pc@(50e78 <_Timer_server_Reset_tod_system_watchdog>)
   511a2:	588f           	addql #4,%sp
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.
     */
    _Chain_Append( ts->insert_chain, &timer->Object.Node );
  }
}
   511a4:	4cee 041c fff0 	moveml %fp@(-16),%d2-%d4/%a2
   511aa:	4e5e           	unlk %fp
    if ( !ts->active ) {
      _Timer_server_Reset_tod_system_watchdog( ts );
    }
  }

  _Thread_Enable_dispatch();
   511ac:	4ef9 0005 375e 	jmp 5375e <_Thread_Enable_dispatch>
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.
     */
    _Chain_Append( ts->insert_chain, &timer->Object.Node );
   511b2:	202a 0078      	movel %a2@(120),%d0                               	<== NOT EXECUTED
   511b6:	2d48 000c      	movel %a0,%fp@(12)                                	<== NOT EXECUTED
  }
}
   511ba:	4cee 041c fff0 	moveml %fp@(-16),%d2-%d4/%a2                      	<== NOT EXECUTED
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.
     */
    _Chain_Append( ts->insert_chain, &timer->Object.Node );
   511c0:	2d40 0008      	movel %d0,%fp@(8)                                 	<== NOT EXECUTED
  }
}
   511c4:	4e5e           	unlk %fp                                          	<== NOT EXECUTED
     *  server is not preemptible, so we must be in interrupt context here.  No
     *  thread dispatch will happen until the timer server finishes its
     *  critical section.  We have to use the protected chain methods because
     *  we may be interrupted by a higher priority interrupt.
     */
    _Chain_Append( ts->insert_chain, &timer->Object.Node );
   511c6:	4ef9 0005 1818 	jmp 51818 <_Chain_Append>                         	<== NOT EXECUTED

00071054 <_Timespec_Greater_than>:

bool _Timespec_Greater_than(
  const struct timespec *lhs,
  const struct timespec *rhs
)
{
   71054:	4e56 0000      	linkw %fp,#0
   71058:	226e 0008      	moveal %fp@(8),%a1
   7105c:	206e 000c      	moveal %fp@(12),%a0
  if ( lhs->tv_sec > rhs->tv_sec )
   71060:	2211           	movel %a1@,%d1
   71062:	2010           	movel %a0@,%d0
   71064:	b081           	cmpl %d1,%d0
   71066:	6c04           	bges 7106c <_Timespec_Greater_than+0x18>
   71068:	7001           	moveq #1,%d0
   7106a:	6014           	bras 71080 <_Timespec_Greater_than+0x2c>
    return true;

  if ( lhs->tv_sec < rhs->tv_sec )
   7106c:	b081           	cmpl %d1,%d0
   7106e:	6f04           	bles 71074 <_Timespec_Greater_than+0x20>
   71070:	4200           	clrb %d0                                          	<== NOT EXECUTED
   71072:	600c           	bras 71080 <_Timespec_Greater_than+0x2c>          	<== NOT EXECUTED

#include <rtems/system.h>
#include <rtems/score/timespec.h>
#include <rtems/score/tod.h>

bool _Timespec_Greater_than(
   71074:	2068 0004      	moveal %a0@(4),%a0
   71078:	b1e9 0004      	cmpal %a1@(4),%a0
   7107c:	5dc0           	slt %d0
   7107e:	4480           	negl %d0
  /* ASSERT: lhs->tv_sec == rhs->tv_sec */
  if ( lhs->tv_nsec > rhs->tv_nsec )
    return true;

  return false;
}
   71080:	4e5e           	unlk %fp
   71082:	4e75           	rts

000479ec <_User_extensions_Thread_exitted>:

void _User_extensions_Thread_exitted (
  Thread_Control *executing
)
{
   479ec:	4e56 0000      	linkw %fp,#0
   479f0:	2f0a           	movel %a2,%sp@-
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   479f2:	2479 0005 bbba 	moveal 5bbba <_User_extensions_List+0x8>,%a2
}

void _User_extensions_Thread_exitted (
  Thread_Control *executing
)
{
   479f8:	2f02           	movel %d2,%sp@-
   479fa:	242e 0008      	movel %fp@(8),%d2
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
   479fe:	6012           	bras 47a12 <_User_extensions_Thread_exitted+0x26>
        !_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 )
   47a00:	206a 002c      	moveal %a2@(44),%a0
   47a04:	4a88           	tstl %a0
   47a06:	6706           	beqs 47a0e <_User_extensions_Thread_exitted+0x22>
      (*the_extension->Callouts.thread_exitted)( executing );
   47a08:	2f02           	movel %d2,%sp@-
   47a0a:	4e90           	jsr %a0@
   47a0c:	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 ) {
   47a0e:	246a 0004      	moveal %a2@(4),%a2
{
  Chain_Node              *the_node;
  User_extensions_Control *the_extension;

  for ( the_node = _User_extensions_List.last ;
        !_Chain_Is_head( &_User_extensions_List, the_node ) ;
   47a12:	b5fc 0005 bbb2 	cmpal #375730,%a2
   47a18:	66e6           	bnes 47a00 <_User_extensions_Thread_exitted+0x14>
    the_extension = (User_extensions_Control *) the_node;

    if ( the_extension->Callouts.thread_exitted != NULL )
      (*the_extension->Callouts.thread_exitted)( executing );
  }
}
   47a1a:	242e fff8      	movel %fp@(-8),%d2
   47a1e:	246e fffc      	moveal %fp@(-4),%a2
   47a22:	4e5e           	unlk %fp
   47a24:	4e75           	rts

000708a8 <rtems_rate_monotonic_period>:

rtems_status_code rtems_rate_monotonic_period(
  rtems_id       id,
  rtems_interval length
)
{
   708a8:	4e56 ffec      	linkw %fp,#-20
   708ac:	48d7 041c      	moveml %d2-%d4/%a2,%sp@
   708b0:	486e fffc      	pea %fp@(-4)
   708b4:	262e 0008      	movel %fp@(8),%d3
   708b8:	2f03           	movel %d3,%sp@-
   708ba:	4879 0009 aca2 	pea 9aca2 <_Rate_monotonic_Information>
   708c0:	242e 000c      	movel %fp@(12),%d2
   708c4:	4eb9 0004 ba14 	jsr 4ba14 <_Objects_Get>
  rtems_rate_monotonic_period_states   local_state;
  ISR_Level                            level;

  the_period = _Rate_monotonic_Get( id, &location );

  switch ( location ) {
   708ca:	4fef 000c      	lea %sp@(12),%sp
   708ce:	2440           	moveal %d0,%a2
   708d0:	4aae fffc      	tstl %fp@(-4)
   708d4:	6600 0138      	bnew 70a0e <rtems_rate_monotonic_period+0x166>
    case OBJECTS_LOCAL:
      if ( !_Thread_Is_executing( the_period->owner ) ) {
   708d8:	2039 0009 a932 	movel 9a932 <_Thread_Executing>,%d0
   708de:	b0aa 0040      	cmpl %a2@(64),%d0
   708e2:	670c           	beqs 708f0 <rtems_rate_monotonic_period+0x48>
        _Thread_Enable_dispatch();
   708e4:	4eb9 0004 c2aa 	jsr 4c2aa <_Thread_Enable_dispatch>
   708ea:	7817           	moveq #23,%d4
        return RTEMS_NOT_OWNER_OF_RESOURCE;
   708ec:	6000 0122      	braw 70a10 <rtems_rate_monotonic_period+0x168>
      }

      if ( length == RTEMS_PERIOD_STATUS ) {
   708f0:	4a82           	tstl %d2
   708f2:	6622           	bnes 70916 <rtems_rate_monotonic_period+0x6e>
        switch ( the_period->state ) {
   708f4:	202a 0038      	movel %a2@(56),%d0
   708f8:	7204           	moveq #4,%d1
   708fa:	b280           	cmpl %d0,%d1
   708fc:	6404           	bccs 70902 <rtems_rate_monotonic_period+0x5a>
   708fe:	4284           	clrl %d4                                          	<== NOT EXECUTED
   70900:	600a           	bras 7090c <rtems_rate_monotonic_period+0x64>     	<== NOT EXECUTED
   70902:	41f9 0009 4922 	lea 94922 <CSWTCH.43>,%a0
   70908:	2830 0c00      	movel %a0@(00000000,%d0:l:4),%d4
          case RATE_MONOTONIC_ACTIVE:
          default:              /* unreached -- only to remove warnings */
            return_value = RTEMS_SUCCESSFUL;
            break;
        }
        _Thread_Enable_dispatch();
   7090c:	4eb9 0004 c2aa 	jsr 4c2aa <_Thread_Enable_dispatch>
        return( return_value );
   70912:	6000 00fc      	braw 70a10 <rtems_rate_monotonic_period+0x168>
      }

      _ISR_Disable( level );
   70916:	203c 0000 0700 	movel #1792,%d0
   7091c:	40c4           	movew %sr,%d4
   7091e:	8084           	orl %d4,%d0
   70920:	46c0           	movew %d0,%sr
      switch ( the_period->state ) {
   70922:	202a 0038      	movel %a2@(56),%d0
   70926:	7202           	moveq #2,%d1
   70928:	b280           	cmpl %d0,%d1
   7092a:	6740           	beqs 7096c <rtems_rate_monotonic_period+0xc4>
   7092c:	123c 0004      	moveb #4,%d1
   70930:	b280           	cmpl %d0,%d1
   70932:	6700 00a4      	beqw 709d8 <rtems_rate_monotonic_period+0x130>
   70936:	4a80           	tstl %d0
   70938:	6600 00d4      	bnew 70a0e <rtems_rate_monotonic_period+0x166>
        case RATE_MONOTONIC_INACTIVE: {

          _ISR_Enable( level );
   7093c:	46c4           	movew %d4,%sr

          /*
           *  Baseline statistics information for the beginning of a period.
           */
          _Rate_monotonic_Initiate_statistics( the_period );
   7093e:	2f0a           	movel %a2,%sp@-
          );

          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   70940:	4284           	clrl %d4
          _ISR_Enable( level );

          /*
           *  Baseline statistics information for the beginning of a period.
           */
          _Rate_monotonic_Initiate_statistics( the_period );
   70942:	4eb9 0007 0694 	jsr 70694 <_Rate_monotonic_Initiate_statistics>
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   70948:	203c 0007 0a1c 	movel #461340,%d0

          the_period->state = RATE_MONOTONIC_ACTIVE;
   7094e:	7202           	moveq #2,%d1
   70950:	2540 002c      	movel %d0,%a2@(44)
  the_watchdog->id        = id;
   70954:	2543 0030      	movel %d3,%a2@(48)
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   70958:	2542 001c      	movel %d2,%a2@(28)
   7095c:	2541 0038      	movel %d1,%a2@(56)
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   70960:	42aa 0018      	clrl %a2@(24)
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   70964:	42aa 0034      	clrl %a2@(52)
   70968:	6000 0084      	braw 709ee <rtems_rate_monotonic_period+0x146>
        case RATE_MONOTONIC_ACTIVE:

          /*
           *  Update statistics from the concluding period.
           */
          _Rate_monotonic_Update_statistics( the_period );
   7096c:	2f0a           	movel %a2,%sp@-
   7096e:	4eb9 0007 07b4 	jsr 707b4 <_Rate_monotonic_Update_statistics>
           *  This tells the _Rate_monotonic_Timeout that this task is
           *  in the process of blocking on the period and that we
           *  may be changing the length of the next period.
           */
          the_period->state = RATE_MONOTONIC_OWNER_IS_BLOCKING;
          the_period->next_length = length;
   70974:	2542 003c      	movel %d2,%a2@(60)
          /*
           *  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;
   70978:	7401           	moveq #1,%d2
   7097a:	2542 0038      	movel %d2,%a2@(56)
          the_period->next_length = length;

          _ISR_Enable( level );
   7097e:	46c4           	movew %d4,%sr

          _Thread_Executing->Wait.id = the_period->Object.id;
   70980:	2079 0009 a932 	moveal 9a932 <_Thread_Executing>,%a0
   70986:	216a 0008 0020 	movel %a2@(8),%a0@(32)
          _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   7098c:	4878 4000      	pea 4000 <D_MAX_EXP+0x3801>
   70990:	2f08           	movel %a0,%sp@-
   70992:	4eb9 0004 caa0 	jsr 4caa0 <_Thread_Set_state>

          /*
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?
           */
          _ISR_Disable( level );
   70998:	203c 0000 0700 	movel #1792,%d0
   7099e:	40c1           	movew %sr,%d1
   709a0:	8081           	orl %d1,%d0
   709a2:	46c0           	movew %d0,%sr
            local_state = the_period->state;
            the_period->state = RATE_MONOTONIC_ACTIVE;
   709a4:	143c 0002      	moveb #2,%d2
          /*
           *  Did the watchdog timer expire while we were actually blocking
           *  on it?
           */
          _ISR_Disable( level );
            local_state = the_period->state;
   709a8:	202a 0038      	movel %a2@(56),%d0
            the_period->state = RATE_MONOTONIC_ACTIVE;
   709ac:	2542 0038      	movel %d2,%a2@(56)
          _ISR_Enable( level );
   709b0:	46c1           	movew %d1,%sr

          /*
           *  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 )
   709b2:	7203           	moveq #3,%d1
   709b4:	4fef 000c      	lea %sp@(12),%sp
   709b8:	b280           	cmpl %d0,%d1
   709ba:	6612           	bnes 709ce <rtems_rate_monotonic_period+0x126>
            _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
   709bc:	4878 4000      	pea 4000 <D_MAX_EXP+0x3801>
   709c0:	2f39 0009 a932 	movel 9a932 <_Thread_Executing>,%sp@-
   709c6:	4eb9 0004 bef0 	jsr 4bef0 <_Thread_Clear_state>
   709cc:	508f           	addql #8,%sp

          _Thread_Enable_dispatch();
   709ce:	4eb9 0004 c2aa 	jsr 4c2aa <_Thread_Enable_dispatch>
   709d4:	4284           	clrl %d4
          return RTEMS_SUCCESSFUL;
   709d6:	6038           	bras 70a10 <rtems_rate_monotonic_period+0x168>
        case RATE_MONOTONIC_EXPIRED:

          /*
           *  Update statistics from the concluding period
           */
          _Rate_monotonic_Update_statistics( the_period );
   709d8:	2f0a           	movel %a2,%sp@-
   709da:	4eb9 0007 07b4 	jsr 707b4 <_Rate_monotonic_Update_statistics>

          _ISR_Enable( level );
   709e0:	46c4           	movew %d4,%sr

          the_period->state = RATE_MONOTONIC_ACTIVE;
   709e2:	7002           	moveq #2,%d0
          the_period->next_length = length;

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   709e4:	7806           	moveq #6,%d4
  Watchdog_Control      *the_watchdog,
  Watchdog_Interval      units
)
{

  the_watchdog->initial = units;
   709e6:	2542 001c      	movel %d2,%a2@(28)
           */
          _Rate_monotonic_Update_statistics( the_period );

          _ISR_Enable( level );

          the_period->state = RATE_MONOTONIC_ACTIVE;
   709ea:	2540 0038      	movel %d0,%a2@(56)
          the_period->next_length = length;
   709ee:	2542 003c      	movel %d2,%a2@(60)

  _Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
   709f2:	486a 0010      	pea %a2@(16)
   709f6:	4879 0009 a950 	pea 9a950 <_Watchdog_Ticks_chain>
   709fc:	4eb9 0004 d1b4 	jsr 4d1b4 <_Watchdog_Insert>

          _Watchdog_Insert_ticks( &the_period->Timer, length );
          _Thread_Enable_dispatch();
   70a02:	4eb9 0004 c2aa 	jsr 4c2aa <_Thread_Enable_dispatch>
          return RTEMS_TIMEOUT;
   70a08:	4fef 000c      	lea %sp@(12),%sp
   70a0c:	6002           	bras 70a10 <rtems_rate_monotonic_period+0x168>
   70a0e:	7804           	moveq #4,%d4
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   70a10:	2004           	movel %d4,%d0
   70a12:	4cee 041c ffec 	moveml %fp@(-20),%d2-%d4/%a2
   70a18:	4e5e           	unlk %fp
   70a1a:	4e75           	rts

0004f820 <rtems_region_get_segment_size>:
rtems_status_code rtems_region_get_segment_size(
  rtems_id   id,
  void      *segment,
  uintptr_t *size
)
{
   4f820:	4e56 fffc      	linkw %fp,#-4
   4f824:	2f03           	movel %d3,%sp@-
   4f826:	262e 0010      	movel %fp@(16),%d3
   4f82a:	2f02           	movel %d2,%sp@-
   4f82c:	242e 000c      	movel %fp@(12),%d2
  Objects_Locations        location;
  rtems_status_code        return_status = RTEMS_SUCCESSFUL;
  register Region_Control *the_region;

  if ( !segment )
   4f830:	6766           	beqs 4f898 <rtems_region_get_segment_size+0x78>
    return RTEMS_INVALID_ADDRESS;

  if ( !size )
   4f832:	4a83           	tstl %d3
   4f834:	6762           	beqs 4f898 <rtems_region_get_segment_size+0x78>
    return RTEMS_INVALID_ADDRESS;

  _RTEMS_Lock_allocator();
   4f836:	2f39 0007 3982 	movel 73982 <_RTEMS_Allocator_Mutex>,%sp@-
   4f83c:	4eb9 0005 1784 	jsr 51784 <_API_Mutex_Lock>
   4f842:	486e fffc      	pea %fp@(-4)
   4f846:	2f2e 0008      	movel %fp@(8),%sp@-
   4f84a:	4879 0007 37d4 	pea 737d4 <_Region_Information>
   4f850:	4eb9 0005 2ecc 	jsr 52ecc <_Objects_Get_no_protection>

    the_region = _Region_Get( id, &location );
    switch ( location ) {
   4f856:	222e fffc      	movel %fp@(-4),%d1
   4f85a:	4fef 0010      	lea %sp@(16),%sp
   4f85e:	670a           	beqs 4f86a <rtems_region_get_segment_size+0x4a>
   4f860:	7001           	moveq #1,%d0
   4f862:	b081           	cmpl %d1,%d0
   4f864:	6620           	bnes 4f886 <rtems_region_get_segment_size+0x66>
   4f866:	7404           	moveq #4,%d2
   4f868:	601e           	bras 4f888 <rtems_region_get_segment_size+0x68>

      case OBJECTS_LOCAL:
        if ( !_Heap_Size_of_alloc_area( &the_region->Memory, segment, size ) )
   4f86a:	2f03           	movel %d3,%sp@-
   4f86c:	2040           	moveal %d0,%a0
   4f86e:	2f02           	movel %d2,%sp@-
   4f870:	4868 0068      	pea %a0@(104)
   4f874:	4eb9 0005 294c 	jsr 5294c <_Heap_Size_of_alloc_area>
   4f87a:	4fef 000c      	lea %sp@(12),%sp
   4f87e:	4a00           	tstb %d0
   4f880:	6604           	bnes 4f886 <rtems_region_get_segment_size+0x66>
   4f882:	7409           	moveq #9,%d2                                      	<== NOT EXECUTED
   4f884:	6002           	bras 4f888 <rtems_region_get_segment_size+0x68>   	<== NOT EXECUTED
   4f886:	4282           	clrl %d2
      case OBJECTS_ERROR:
        return_status = RTEMS_INVALID_ID;
        break;
    }

  _RTEMS_Unlock_allocator();
   4f888:	2f39 0007 3982 	movel 73982 <_RTEMS_Allocator_Mutex>,%sp@-
   4f88e:	4eb9 0005 17e4 	jsr 517e4 <_API_Mutex_Unlock>
  return return_status;
   4f894:	588f           	addql #4,%sp
   4f896:	6002           	bras 4f89a <rtems_region_get_segment_size+0x7a>
   4f898:	7409           	moveq #9,%d2
}
   4f89a:	2002           	movel %d2,%d0
   4f89c:	242e fff4      	movel %fp@(-12),%d2
   4f8a0:	262e fff8      	movel %fp@(-8),%d3
   4f8a4:	4e5e           	unlk %fp
   4f8a6:	4e75           	rts

00050bc4 <rtems_timer_server_fire_when>:
  rtems_id                           id,
  rtems_time_of_day                  *wall_time,
  rtems_timer_service_routine_entry  routine,
  void                              *user_data
)
{
   50bc4:	4e56 ffe8      	linkw %fp,#-24
   50bc8:	48d7 0c1c      	moveml %d2-%d4/%a2-%a3,%sp@
   50bcc:	282e 0008      	movel %fp@(8),%d4
   50bd0:	262e 000c      	movel %fp@(12),%d3
   50bd4:	242e 0010      	movel %fp@(16),%d2
  Timer_Control        *the_timer;
  Objects_Locations     location;
  rtems_interval        seconds;
  Timer_server_Control *timer_server = _Timer_server;
   50bd8:	2679 0007 3b2a 	moveal 73b2a <_Timer_server>,%a3

  if ( !timer_server )
   50bde:	4a8b           	tstl %a3
   50be0:	6606           	bnes 50be8 <rtems_timer_server_fire_when+0x24>
   50be2:	700e           	moveq #14,%d0
   50be4:	6000 00a4      	braw 50c8a <rtems_timer_server_fire_when+0xc6>
    return RTEMS_INCORRECT_STATE;

  if ( !_TOD_Is_set )
   50be8:	4a39 0007 38e4 	tstb 738e4 <_TOD_Is_set>
   50bee:	6606           	bnes 50bf6 <rtems_timer_server_fire_when+0x32>
   50bf0:	700b           	moveq #11,%d0                                     	<== NOT EXECUTED
   50bf2:	6000 0096      	braw 50c8a <rtems_timer_server_fire_when+0xc6>    	<== NOT EXECUTED
    return RTEMS_NOT_DEFINED;

  if ( !routine )
   50bf6:	4a82           	tstl %d2
   50bf8:	6606           	bnes 50c00 <rtems_timer_server_fire_when+0x3c>
   50bfa:	7009           	moveq #9,%d0
   50bfc:	6000 008c      	braw 50c8a <rtems_timer_server_fire_when+0xc6>
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Validate( wall_time ) )
   50c00:	2f03           	movel %d3,%sp@-
   50c02:	4eb9 0004 e040 	jsr 4e040 <_TOD_Validate>
   50c08:	588f           	addql #4,%sp
   50c0a:	4a00           	tstb %d0
   50c0c:	677a           	beqs 50c88 <rtems_timer_server_fire_when+0xc4>
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( wall_time );
   50c0e:	2f03           	movel %d3,%sp@-
   50c10:	4eb9 0004 dfa0 	jsr 4dfa0 <_TOD_To_seconds>
  if ( seconds <= _TOD_Seconds_since_epoch() )
   50c16:	588f           	addql #4,%sp
    return RTEMS_INVALID_ADDRESS;

  if ( !_TOD_Validate( wall_time ) )
    return RTEMS_INVALID_CLOCK;

  seconds = _TOD_To_seconds( wall_time );
   50c18:	2600           	movel %d0,%d3
  if ( seconds <= _TOD_Seconds_since_epoch() )
   50c1a:	b0b9 0007 3962 	cmpl 73962 <_TOD_Now>,%d0
   50c20:	6366           	blss 50c88 <rtems_timer_server_fire_when+0xc4>
   50c22:	486e fffc      	pea %fp@(-4)
   50c26:	2f04           	movel %d4,%sp@-
   50c28:	4879 0007 3af2 	pea 73af2 <_Timer_Information>
   50c2e:	4eb9 0005 2f04 	jsr 52f04 <_Objects_Get>
    return RTEMS_INVALID_CLOCK;

  the_timer = _Timer_Get( id, &location );
  switch ( location ) {
   50c34:	4fef 000c      	lea %sp@(12),%sp
   50c38:	2440           	moveal %d0,%a2
   50c3a:	4aae fffc      	tstl %fp@(-4)
   50c3e:	6704           	beqs 50c44 <rtems_timer_server_fire_when+0x80>
   50c40:	7004           	moveq #4,%d0
   50c42:	6046           	bras 50c8a <rtems_timer_server_fire_when+0xc6>

    case OBJECTS_LOCAL:
      (void) _Watchdog_Remove( &the_timer->Ticker );
   50c44:	486a 0010      	pea %a2@(16)
   50c48:	4eb9 0005 4a90 	jsr 54a90 <_Watchdog_Remove>
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
  the_watchdog->user_data = user_data;
   50c4e:	256e 0014 0034 	movel %fp@(20),%a2@(52)
      the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
   50c54:	7003           	moveq #3,%d0
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
  the_watchdog->id        = id;
   50c56:	2544 0030      	movel %d4,%a2@(48)
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
   50c5a:	96b9 0007 3962 	subl 73962 <_TOD_Now>,%d3
  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;
   50c60:	2540 0038      	movel %d0,%a2@(56)
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();
   50c64:	2543 001c      	movel %d3,%a2@(28)
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
  the_watchdog->routine   = routine;
   50c68:	2542 002c      	movel %d2,%a2@(44)
  Watchdog_Service_routine_entry  routine,
  Objects_Id                      id,
  void                           *user_data
)
{
  the_watchdog->state     = WATCHDOG_INACTIVE;
   50c6c:	42aa 0018      	clrl %a2@(24)

      (*timer_server->schedule_operation)( timer_server, the_timer );
   50c70:	2f0a           	movel %a2,%sp@-
   50c72:	2f0b           	movel %a3,%sp@-
   50c74:	206b 0004      	moveal %a3@(4),%a0
   50c78:	4e90           	jsr %a0@

      _Thread_Enable_dispatch();
   50c7a:	4eb9 0005 375e 	jsr 5375e <_Thread_Enable_dispatch>
      return RTEMS_SUCCESSFUL;
   50c80:	4fef 000c      	lea %sp@(12),%sp
      _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data );
      the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch();

      (*timer_server->schedule_operation)( timer_server, the_timer );

      _Thread_Enable_dispatch();
   50c84:	4280           	clrl %d0
      return RTEMS_SUCCESSFUL;
   50c86:	6002           	bras 50c8a <rtems_timer_server_fire_when+0xc6>
   50c88:	7014           	moveq #20,%d0
    case OBJECTS_ERROR:
      break;
  }

  return RTEMS_INVALID_ID;
}
   50c8a:	4cee 0c1c ffe8 	moveml %fp@(-24),%d2-%d4/%a2-%a3
   50c90:	4e5e           	unlk %fp
   50c92:	4e75           	rts