a001461c <_CORE_message_queue_Broadcast>:
{
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
a001461c:	e590304c 	ldr	r3, [r0, #76]	; 0x4c
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif
  uint32_t                                  *count
)
{
a0014620:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
a0014624:	e1520003 	cmp	r2, r3
    Objects_Id                                 id __attribute__((unused)),
    CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
  #endif
  uint32_t                                  *count
)
{
a0014628:	e1a06000 	mov	r6, r0
a001462c:	e1a07002 	mov	r7, r2
a0014630:	e1a0a001 	mov	sl, r1
a0014634:	e59d8020 	ldr	r8, [sp, #32]
  Thread_Control          *the_thread;
  uint32_t                 number_broadcasted;
  Thread_Wait_information *waitp;

  if ( size > the_message_queue->maximum_message_size ) {
a0014638:	9a000001 	bls	a0014644 <_CORE_message_queue_Broadcast+0x28>
a001463c:	e3a00001 	mov	r0, #1                                              	<== NOT EXECUTED
a0014640:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}                        	<== 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 ) {
a0014644:	e5905048 	ldr	r5, [r0, #72]	; 0x48
a0014648:	e3550000 	cmp	r5, #0
a001464c:	0a000009 	beq	a0014678 <_CORE_message_queue_Broadcast+0x5c>
    *count = 0;
a0014650:	e3a00000 	mov	r0, #0
a0014654:	e5880000 	str	r0, [r8]
    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
a0014658:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}
  const void *source,
  void       *destination,
  size_t      size
)
{
  memcpy(destination, source, size);
a001465c:	e594002c 	ldr	r0, [r4, #44]	; 0x2c
a0014660:	e1a0100a 	mov	r1, sl
a0014664:	e1a02007 	mov	r2, r7
a0014668:	eb001fb8 	bl	a001c550 <memcpy>
      buffer,
      waitp->return_argument_second.mutable_object,
      size
    );

    *(size_t *) the_thread->Wait.return_argument = size;
a001466c:	e5943028 	ldr	r3, [r4, #40]	; 0x28
   */
  number_broadcasted = 0;
  while ((the_thread =
          _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
    waitp = &the_thread->Wait;
    number_broadcasted += 1;
a0014670:	e2855001 	add	r5, r5, #1
      buffer,
      waitp->return_argument_second.mutable_object,
      size
    );

    *(size_t *) the_thread->Wait.return_argument = size;
a0014674:	e5837000 	str	r7, [r3]
   *  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))) {
a0014678:	e1a00006 	mov	r0, r6
a001467c:	eb00096f 	bl	a0016c40 <_Thread_queue_Dequeue>
  /*
   *  There must be no pending messages if there is a thread waiting to
   *  receive a message.
   */
  number_broadcasted = 0;
  while ((the_thread =
a0014680:	e2504000 	subs	r4, r0, #0
a0014684:	1afffff4 	bne	a001465c <_CORE_message_queue_Broadcast+0x40>
      if ( !_Objects_Is_local_id( the_thread->Object.id ) )
        (*api_message_queue_mp_support) ( the_thread, id );
    #endif

  }
  *count = number_broadcasted;
a0014688:	e5885000 	str	r5, [r8]
a001468c:	e1a00004 	mov	r0, r4
  return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
}
a0014690:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}

a000925c <_CORE_mutex_Seize_interrupt_trylock>:
{
  Thread_Control   *executing;

  /* disabled when you get here */

  executing = _Thread_Executing;
a000925c:	e59f2120 	ldr	r2, [pc, #288]	; a0009384 <_CORE_mutex_Seize_interrupt_trylock+0x128>
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
a0009260:	e3a03000 	mov	r3, #0
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
  CORE_mutex_Control  *the_mutex,
  ISR_Level           *level_p
)
{
a0009264:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
{
  Thread_Control   *executing;

  /* disabled when you get here */

  executing = _Thread_Executing;
a0009268:	e5922000 	ldr	r2, [r2]
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
a000926c:	e5823034 	str	r3, [r2, #52]	; 0x34
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
a0009270:	e590c050 	ldr	ip, [r0, #80]	; 0x50
a0009274:	e15c0003 	cmp	ip, r3
a0009278:	0a00002c 	beq	a0009330 <_CORE_mutex_Seize_interrupt_trylock+0xd4>
    the_mutex->lock       = CORE_MUTEX_LOCKED;
a000927c:	e5803050 	str	r3, [r0, #80]	; 0x50
    the_mutex->holder     = executing;
    the_mutex->holder_id  = executing->Object.id;
a0009280:	e592c008 	ldr	ip, [r2, #8]
 */
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
  CORE_mutex_Attributes *the_attribute
)
{
  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
a0009284:	e5903048 	ldr	r3, [r0, #72]	; 0x48

  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;
a0009288:	e580205c 	str	r2, [r0, #92]	; 0x5c
    the_mutex->holder_id  = executing->Object.id;
a000928c:	e580c060 	str	ip, [r0, #96]	; 0x60
    the_mutex->nest_count = 1;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
a0009290:	e3530002 	cmp	r3, #2
  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;
a0009294:	e3a0c001 	mov	ip, #1
a0009298:	e580c054 	str	ip, [r0, #84]	; 0x54
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
a000929c:	0a000001 	beq	a00092a8 <_CORE_mutex_Seize_interrupt_trylock+0x4c>
a00092a0:	e3530003 	cmp	r3, #3
a00092a4:	1a000004 	bne	a00092bc <_CORE_mutex_Seize_interrupt_trylock+0x60>
       _Chain_Prepend_unprotected( &executing->lock_mutex,
                                   &the_mutex->queue.lock_queue );
       the_mutex->queue.priority_before = executing->current_priority;
#endif

      executing->resource_count++;
a00092a8:	e592c01c 	ldr	ip, [r2, #28]
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
a00092ac:	e3530003 	cmp	r3, #3
       _Chain_Prepend_unprotected( &executing->lock_mutex,
                                   &the_mutex->queue.lock_queue );
       the_mutex->queue.priority_before = executing->current_priority;
#endif

      executing->resource_count++;
a00092b0:	e28c3001 	add	r3, ip, #1
a00092b4:	e582301c 	str	r3, [r2, #28]
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
a00092b8:	0a000000 	beq	a00092c0 <_CORE_mutex_Seize_interrupt_trylock+0x64>
      _ISR_Enable( *level_p );
a00092bc:	ea00002a 	b	a000936c <_CORE_mutex_Seize_interrupt_trylock+0x110>
       */
    {
      Priority_Control  ceiling;
      Priority_Control  current;

      ceiling = the_mutex->Attributes.priority_ceiling;
a00092c0:	e590304c 	ldr	r3, [r0, #76]	; 0x4c
      current = executing->current_priority;
a00092c4:	e592c014 	ldr	ip, [r2, #20]
      if ( current == ceiling ) {
a00092c8:	e15c0003 	cmp	ip, r3
a00092cc:	1a000000 	bne	a00092d4 <_CORE_mutex_Seize_interrupt_trylock+0x78>
        _ISR_Enable( *level_p );
a00092d0:	ea000025 	b	a000936c <_CORE_mutex_Seize_interrupt_trylock+0x110>
        return 0;
      }

      if ( current > ceiling ) {
a00092d4:	9a00000b 	bls	a0009308 <_CORE_mutex_Seize_interrupt_trylock+0xac>
	rtems_fatal_error_occurred( 99 );
      }
    }
  #endif

  _Thread_Dispatch_disable_level += 1;
a00092d8:	e59f30a8 	ldr	r3, [pc, #168]	; a0009388 <_CORE_mutex_Seize_interrupt_trylock+0x12c>
a00092dc:	e5932000 	ldr	r2, [r3]
a00092e0:	e2822001 	add	r2, r2, #1
a00092e4:	e5832000 	str	r2, [r3]
a00092e8:	e5913000 	ldr	r3, [r1]
a00092ec:	e129f003 	msr	CPSR_fc, r3
        _Thread_Disable_dispatch();
        _ISR_Enable( *level_p );
        _Thread_Change_priority(
a00092f0:	e3a02000 	mov	r2, #0
a00092f4:	e590104c 	ldr	r1, [r0, #76]	; 0x4c
a00092f8:	e590005c 	ldr	r0, [r0, #92]	; 0x5c
a00092fc:	ebfff1d2 	bl	a0005a4c <_Thread_Change_priority>
          the_mutex->holder,
          the_mutex->Attributes.priority_ceiling,
         false
        );
        _Thread_Enable_dispatch();
a0009300:	ebfff335 	bl	a0005fdc <_Thread_Enable_dispatch>
a0009304:	ea00001a 	b	a0009374 <_CORE_mutex_Seize_interrupt_trylock+0x118>
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
a0009308:	e3a03006 	mov	r3, #6
a000930c:	e5823034 	str	r3, [r2, #52]	; 0x34
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
        the_mutex->nest_count = 0;     /* undo locking above */
a0009310:	e3a03000 	mov	r3, #0
a0009314:	e5803054 	str	r3, [r0, #84]	; 0x54
        _Thread_Enable_dispatch();
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
a0009318:	e2833001 	add	r3, r3, #1
a000931c:	e5803050 	str	r3, [r0, #80]	; 0x50
        the_mutex->nest_count = 0;     /* undo locking above */
        executing->resource_count--;   /* undo locking above */
a0009320:	e592301c 	ldr	r3, [r2, #28]
a0009324:	e2433001 	sub	r3, r3, #1
a0009328:	e582301c 	str	r3, [r2, #28]
        _ISR_Enable( *level_p );
a000932c:	ea00000e 	b	a000936c <_CORE_mutex_Seize_interrupt_trylock+0x110>
  /*
   *  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 ) ) {
a0009330:	e590305c 	ldr	r3, [r0, #92]	; 0x5c
a0009334:	e1530002 	cmp	r3, r2
a0009338:	1a00000f 	bne	a000937c <_CORE_mutex_Seize_interrupt_trylock+0x120>
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
a000933c:	e5902040 	ldr	r2, [r0, #64]	; 0x40
a0009340:	e3520000 	cmp	r2, #0
a0009344:	0a000002 	beq	a0009354 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
a0009348:	e3520001 	cmp	r2, #1
a000934c:	1a00000a 	bne	a000937c <_CORE_mutex_Seize_interrupt_trylock+0x120>
a0009350:	ea000003 	b	a0009364 <_CORE_mutex_Seize_interrupt_trylock+0x108>  	<== NOT EXECUTED
      case CORE_MUTEX_NESTING_ACQUIRES:
        the_mutex->nest_count++;
a0009354:	e5903054 	ldr	r3, [r0, #84]	; 0x54
a0009358:	e2833001 	add	r3, r3, #1
a000935c:	e5803054 	str	r3, [r0, #84]	; 0x54
        _ISR_Enable( *level_p );
a0009360:	ea000001 	b	a000936c <_CORE_mutex_Seize_interrupt_trylock+0x110>
        return 0;
      case CORE_MUTEX_NESTING_IS_ERROR:
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
a0009364:	e3a02002 	mov	r2, #2                                              	<== NOT EXECUTED
a0009368:	e5832034 	str	r2, [r3, #52]	; 0x34                                	<== NOT EXECUTED
a000936c:	e5913000 	ldr	r3, [r1]
a0009370:	e129f003 	msr	CPSR_fc, r3
a0009374:	e3a00000 	mov	r0, #0
a0009378:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)
a000937c:	e3a00001 	mov	r0, #1
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
a0009380:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)
a0009384:	a0018760 	.word	0xa0018760
a0009388:	a00186ac 	.word	0xa00186ac

a000e4d4 <_Heap_Extend>:
  Heap_Control *heap,
  void *area_begin_ptr,
  uintptr_t area_size,
  uintptr_t *amount_extended
)
{
a000e4d4:	e92d41f0 	push	{r4, r5, r6, r7, r8, lr}
a000e4d8:	e1a04000 	mov	r4, r0
  Heap_Statistics *const stats = &heap->stats;
  uintptr_t const area_begin = (uintptr_t) area_begin_ptr;
  uintptr_t const heap_area_begin = heap->area_begin;
a000e4dc:	e594c018 	ldr	ip, [r4, #24]
  uintptr_t const heap_area_end = heap->area_end;
a000e4e0:	e590001c 	ldr	r0, [r0, #28]
  Heap_Control *heap,
  void *area_begin_ptr,
  uintptr_t area_size,
  uintptr_t *amount_extended
)
{
a000e4e4:	e1a08003 	mov	r8, r3
  uintptr_t const area_begin = (uintptr_t) area_begin_ptr;
  uintptr_t const heap_area_begin = heap->area_begin;
  uintptr_t const heap_area_end = heap->area_end;
  uintptr_t const new_heap_area_end = heap_area_end + area_size;
  uintptr_t extend_size = 0;
  Heap_Block *const last_block = heap->last_block;
a000e4e8:	e5946024 	ldr	r6, [r4, #36]	; 0x24
  uintptr_t *amount_extended
)
{
  Heap_Statistics *const stats = &heap->stats;
  uintptr_t const area_begin = (uintptr_t) area_begin_ptr;
  uintptr_t const heap_area_begin = heap->area_begin;
a000e4ec:	e1510000 	cmp	r1, r0
a000e4f0:	23a05000 	movcs	r5, #0
a000e4f4:	33a05001 	movcc	r5, #1
a000e4f8:	e151000c 	cmp	r1, ip
a000e4fc:	33a05000 	movcc	r5, #0
a000e500:	e3550000 	cmp	r5, #0
a000e504:	0a000001 	beq	a000e510 <_Heap_Extend+0x3c>
a000e508:	e3a00001 	mov	r0, #1
a000e50c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}
   *  As noted, this code only supports (4).
   */

  if ( area_begin >= heap_area_begin && area_begin < heap_area_end ) {
    return HEAP_EXTEND_ERROR; /* case 3 */
  } else if ( area_begin != heap_area_end ) {
a000e510:	e1510000 	cmp	r1, r0
a000e514:	0a000001 	beq	a000e520 <_Heap_Extend+0x4c>
a000e518:	e3a00002 	mov	r0, #2
a000e51c:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}
   *  block and free it.
   */

  heap->area_end = new_heap_area_end;

  extend_size = new_heap_area_end
a000e520:	e3e07007 	mvn	r7, #7
{
  Heap_Statistics *const stats = &heap->stats;
  uintptr_t const area_begin = (uintptr_t) area_begin_ptr;
  uintptr_t const heap_area_begin = heap->area_begin;
  uintptr_t const heap_area_end = heap->area_end;
  uintptr_t const new_heap_area_end = heap_area_end + area_size;
a000e524:	e0821001 	add	r1, r2, r1
   *  block and free it.
   */

  heap->area_end = new_heap_area_end;

  extend_size = new_heap_area_end
a000e528:	e0667007 	rsb	r7, r6, r7
a000e52c:	e0877001 	add	r7, r7, r1
   *  Currently only case 4 should make it to this point.
   *  The basic trick is to make the extend area look like a used
   *  block and free it.
   */

  heap->area_end = new_heap_area_end;
a000e530:	e584101c 	str	r1, [r4, #28]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
  uintptr_t value,
  uintptr_t alignment
)
{
  return value - (value % alignment);
a000e534:	e1a00007 	mov	r0, r7
a000e538:	e5941010 	ldr	r1, [r4, #16]
a000e53c:	ebffd298 	bl	a0002fa4 <__umodsi3>
a000e540:	e0600007 	rsb	r0, r0, r7

  extend_size = new_heap_area_end
    - (uintptr_t) last_block - HEAP_BLOCK_HEADER_SIZE;
  extend_size = _Heap_Align_down( extend_size, heap->page_size );

  *amount_extended = extend_size;
a000e544:	e5880000 	str	r0, [r8]

  if( extend_size >= heap->min_block_size ) {
a000e548:	e5943014 	ldr	r3, [r4, #20]
a000e54c:	e1500003 	cmp	r0, r3
a000e550:	2a000001 	bcs	a000e55c <_Heap_Extend+0x88>
a000e554:	e1a00005 	mov	r0, r5                                              	<== NOT EXECUTED
a000e558:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}                            	<== NOT EXECUTED
  uintptr_t size
)
{
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;

  block->size_and_flag = size | flag;
a000e55c:	e5961004 	ldr	r1, [r6, #4]
    Heap_Block *const new_last_block = _Heap_Block_at( last_block, extend_size );

    _Heap_Block_set_size( last_block, extend_size );

    new_last_block->size_and_flag =
a000e560:	e5942020 	ldr	r2, [r4, #32]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
  const Heap_Block *block,
  uintptr_t offset
)
{
  return (Heap_Block *) ((uintptr_t) block + offset);
a000e564:	e0803006 	add	r3, r0, r6
  uintptr_t size
)
{
  uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED;

  block->size_and_flag = size | flag;
a000e568:	e2011001 	and	r1, r1, #1
a000e56c:	e0632002 	rsb	r2, r3, r2
a000e570:	e1801001 	orr	r1, r0, r1
a000e574:	e3822001 	orr	r2, r2, #1
a000e578:	e5861004 	str	r1, [r6, #4]
a000e57c:	e5832004 	str	r2, [r3, #4]
        | HEAP_PREV_BLOCK_USED;

    heap->last_block = new_last_block;

    /* Statistics */
    stats->size += extend_size;
a000e580:	e594702c 	ldr	r7, [r4, #44]	; 0x2c
    ++stats->used_blocks;
a000e584:	e5941040 	ldr	r1, [r4, #64]	; 0x40
    --stats->frees; /* Do not count subsequent call as actual free() */
a000e588:	e5942050 	ldr	r2, [r4, #80]	; 0x50
        | HEAP_PREV_BLOCK_USED;

    heap->last_block = new_last_block;

    /* Statistics */
    stats->size += extend_size;
a000e58c:	e0870000 	add	r0, r7, r0
    ++stats->used_blocks;
a000e590:	e2811001 	add	r1, r1, #1
    --stats->frees; /* Do not count subsequent call as actual free() */
a000e594:	e2422001 	sub	r2, r2, #1
        | HEAP_PREV_BLOCK_USED;

    heap->last_block = new_last_block;

    /* Statistics */
    stats->size += extend_size;
a000e598:	e584002c 	str	r0, [r4, #44]	; 0x2c
    ++stats->used_blocks;
a000e59c:	e5841040 	str	r1, [r4, #64]	; 0x40

    new_last_block->size_and_flag =
      ((uintptr_t) heap->first_block - (uintptr_t) new_last_block)
        | HEAP_PREV_BLOCK_USED;

    heap->last_block = new_last_block;
a000e5a0:	e5843024 	str	r3, [r4, #36]	; 0x24

    /* Statistics */
    stats->size += extend_size;
    ++stats->used_blocks;
    --stats->frees; /* Do not count subsequent call as actual free() */
a000e5a4:	e5842050 	str	r2, [r4, #80]	; 0x50

    _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( last_block ));
a000e5a8:	e1a00004 	mov	r0, r4
a000e5ac:	e2861008 	add	r1, r6, #8
a000e5b0:	ebffec1c 	bl	a0009628 <_Heap_Free>
a000e5b4:	e1a00005 	mov	r0, r5
  }

  return HEAP_EXTEND_SUCCESSFUL;
}
a000e5b8:	e8bd81f0 	pop	{r4, r5, r6, r7, r8, pc}

a000654c <_Thread_queue_Enqueue_priority>:
  Priority_Control     priority;
  States_Control       block_state;

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
a000654c:	e5913014 	ldr	r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
  Thread_queue_Control *the_thread_queue,
  Thread_Control       *the_thread,
  ISR_Level            *level_p
)
{
a0006550:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
a0006554:	e281503c 	add	r5, r1, #60	; 0x3c
a0006558:	e5815038 	str	r5, [r1, #56]	; 0x38
  the_chain->permanent_null = NULL;
a000655c:	e3a05000 	mov	r5, #0
  the_chain->last           = _Chain_Head(the_chain);
a0006560:	e281c038 	add	ip, r1, #56	; 0x38
  priority     = the_thread->current_priority;
  header_index = _Thread_queue_Header_number( priority );
  header       = &the_thread_queue->Queues.Priority[ header_index ];
  block_state  = the_thread_queue->state;

  if ( _Thread_queue_Is_reverse_search( priority ) )
a0006564:	e3130020 	tst	r3, #32

  _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 ];
a0006568:	e1a04323 	lsr	r4, r3, #6
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
a000656c:	e581503c 	str	r5, [r1, #60]	; 0x3c
a0006570:	e285500c 	add	r5, r5, #12
  the_chain->last           = _Chain_Head(the_chain);
a0006574:	e581c040 	str	ip, [r1, #64]	; 0x40
  block_state  = the_thread_queue->state;
a0006578:	e5907038 	ldr	r7, [r0, #56]	; 0x38

  _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 ];
a000657c:	e02c0495 	mla	ip, r5, r4, r0
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;
a0006580:	159f8158 	ldrne	r8, [pc, #344]	; a00066e0 <_Thread_queue_Enqueue_priority+0x194>
  priority     = the_thread->current_priority;
  header_index = _Thread_queue_Header_number( priority );
  header       = &the_thread_queue->Queues.Priority[ header_index ];
  block_state  = the_thread_queue->state;

  if ( _Thread_queue_Is_reverse_search( priority ) )
a0006584:	1a000023 	bne	a0006618 <_Thread_queue_Enqueue_priority+0xcc>
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
a0006588:	e28c8004 	add	r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
a000658c:	e10f5000 	mrs	r5, CPSR
a0006590:	e3854080 	orr	r4, r5, #128	; 0x80
a0006594:	e129f004 	msr	CPSR_fc, r4
    goto restart_reverse_search;

restart_forward_search:
  search_priority = PRIORITY_MINIMUM - 1;
  _ISR_Disable( level );
  search_thread = (Thread_Control *) header->first;
a0006598:	e3e06000 	mvn	r6, #0
a000659c:	e59c4000 	ldr	r4, [ip]
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
a00065a0:	ea00000b 	b	a00065d4 <_Thread_queue_Enqueue_priority+0x88>
    search_priority = search_thread->current_priority;
a00065a4:	e5946014 	ldr	r6, [r4, #20]
    if ( priority <= search_priority )
a00065a8:	e1530006 	cmp	r3, r6
a00065ac:	9a00000a 	bls	a00065dc <_Thread_queue_Enqueue_priority+0x90>

static inline void arm_interrupt_flash( uint32_t level )
{
  uint32_t arm_switch_reg;

  asm volatile (
a00065b0:	e10fa000 	mrs	sl, CPSR
a00065b4:	e129f005 	msr	CPSR_fc, r5
a00065b8:	e129f00a 	msr	CPSR_fc, sl
    search_priority = search_thread->current_priority;
    if ( priority <= search_priority )
      break;
#endif
    _ISR_Flash( level );
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
a00065bc:	e594a010 	ldr	sl, [r4, #16]
a00065c0:	e117000a 	tst	r7, sl
a00065c4:	1a000001 	bne	a00065d0 <_Thread_queue_Enqueue_priority+0x84>

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
a00065c8:	e129f005 	msr	CPSR_fc, r5                                         	<== NOT EXECUTED
a00065cc:	eaffffee 	b	a000658c <_Thread_queue_Enqueue_priority+0x40>        	<== NOT EXECUTED
      _ISR_Enable( level );
      goto restart_forward_search;
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
a00065d0:	e5944000 	ldr	r4, [r4]

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 ) ) {
a00065d4:	e1540008 	cmp	r4, r8
a00065d8:	1afffff1 	bne	a00065a4 <_Thread_queue_Enqueue_priority+0x58>
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
a00065dc:	e5907030 	ldr	r7, [r0, #48]	; 0x30

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 ) ) {
a00065e0:	e1a0c005 	mov	ip, r5
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
a00065e4:	e3570001 	cmp	r7, #1
a00065e8:	1a000039 	bne	a00066d4 <_Thread_queue_Enqueue_priority+0x188>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;

  if ( priority == search_priority )
a00065ec:	e1530006 	cmp	r3, r6

  if ( the_thread_queue->sync_state !=
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a00065f0:	e3a03000 	mov	r3, #0
a00065f4:	e5803030 	str	r3, [r0, #48]	; 0x30

  if ( priority == search_priority )
a00065f8:	0a00002b 	beq	a00066ac <_Thread_queue_Enqueue_priority+0x160>
    goto equal_priority;

  search_node   = (Chain_Node *) search_thread;
  previous_node = search_node->previous;
a00065fc:	e5943004 	ldr	r3, [r4, #4]
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
a0006600:	e5814000 	str	r4, [r1]
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
a0006604:	e5810044 	str	r0, [r1, #68]	; 0x44
  search_node   = (Chain_Node *) search_thread;
  previous_node = search_node->previous;
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
  the_node->previous     = previous_node;
a0006608:	e5813004 	str	r3, [r1, #4]
  previous_node->next    = the_node;
a000660c:	e5831000 	str	r1, [r3]
  search_node->previous  = the_node;
a0006610:	e5841004 	str	r1, [r4, #4]
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
a0006614:	ea000022 	b	a00066a4 <_Thread_queue_Enqueue_priority+0x158>
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

restart_reverse_search:
  search_priority     = PRIORITY_MAXIMUM + 1;
a0006618:	e5d86000 	ldrb	r6, [r8]
a000661c:	e2866001 	add	r6, r6, #1
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
a0006620:	e10f5000 	mrs	r5, CPSR
a0006624:	e3854080 	orr	r4, r5, #128	; 0x80
a0006628:	e129f004 	msr	CPSR_fc, r4

  _ISR_Disable( level );
  search_thread = (Thread_Control *) header->last;
a000662c:	e59c4008 	ldr	r4, [ip, #8]
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
a0006630:	ea00000b 	b	a0006664 <_Thread_queue_Enqueue_priority+0x118>
    search_priority = search_thread->current_priority;
a0006634:	e5946014 	ldr	r6, [r4, #20]
    if ( priority >= search_priority )
a0006638:	e1530006 	cmp	r3, r6
a000663c:	2a00000a 	bcs	a000666c <_Thread_queue_Enqueue_priority+0x120>

static inline void arm_interrupt_flash( uint32_t level )
{
  uint32_t arm_switch_reg;

  asm volatile (
a0006640:	e10fa000 	mrs	sl, CPSR
a0006644:	e129f005 	msr	CPSR_fc, r5
a0006648:	e129f00a 	msr	CPSR_fc, sl
    search_priority = search_thread->current_priority;
    if ( priority >= search_priority )
      break;
#endif
    _ISR_Flash( level );
    if ( !_States_Are_set( search_thread->current_state, block_state) ) {
a000664c:	e594a010 	ldr	sl, [r4, #16]
a0006650:	e117000a 	tst	r7, sl
a0006654:	1a000001 	bne	a0006660 <_Thread_queue_Enqueue_priority+0x114>

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
a0006658:	e129f005 	msr	CPSR_fc, r5                                         	<== NOT EXECUTED
a000665c:	eaffffed 	b	a0006618 <_Thread_queue_Enqueue_priority+0xcc>        	<== NOT EXECUTED
      _ISR_Enable( level );
      goto restart_reverse_search;
    }
    search_thread = (Thread_Control *)
a0006660:	e5944004 	ldr	r4, [r4, #4]
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 ) ) {
a0006664:	e154000c 	cmp	r4, ip
a0006668:	1afffff1 	bne	a0006634 <_Thread_queue_Enqueue_priority+0xe8>
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
a000666c:	e5907030 	ldr	r7, [r0, #48]	; 0x30
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 ) ) {
a0006670:	e1a0c005 	mov	ip, r5
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
a0006674:	e3570001 	cmp	r7, #1
a0006678:	1a000015 	bne	a00066d4 <_Thread_queue_Enqueue_priority+0x188>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;

  if ( priority == search_priority )
a000667c:	e1530006 	cmp	r3, r6

  if ( the_thread_queue->sync_state !=
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
a0006680:	e3a03000 	mov	r3, #0
a0006684:	e5803030 	str	r3, [r0, #48]	; 0x30

  if ( priority == search_priority )
a0006688:	0a000007 	beq	a00066ac <_Thread_queue_Enqueue_priority+0x160>
    goto equal_priority;

  search_node = (Chain_Node *) search_thread;
  next_node   = search_node->next;
a000668c:	e5943000 	ldr	r3, [r4]
  the_node    = (Chain_Node *) the_thread;

  the_node->next          = next_node;
  the_node->previous      = search_node;
a0006690:	e5814004 	str	r4, [r1, #4]
  search_node->next       = the_node;
  next_node->previous    = the_node;
  the_thread->Wait.queue = the_thread_queue;
a0006694:	e5810044 	str	r0, [r1, #68]	; 0x44

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

  the_node->next          = next_node;
a0006698:	e5813000 	str	r3, [r1]
  the_node->previous      = search_node;
  search_node->next       = the_node;
  next_node->previous    = the_node;
a000669c:	e5831004 	str	r1, [r3, #4]
  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;
a00066a0:	e5841000 	str	r1, [r4]
a00066a4:	e129f005 	msr	CPSR_fc, r5
a00066a8:	ea000007 	b	a00066cc <_Thread_queue_Enqueue_priority+0x180>
a00066ac:	e284403c 	add	r4, r4, #60	; 0x3c
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

equal_priority:               /* add at end of priority group */
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );
  previous_node = search_node->previous;
a00066b0:	e5943004 	ldr	r3, [r4, #4]
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
a00066b4:	e5814000 	str	r4, [r1]
  the_node->previous     = previous_node;
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
a00066b8:	e5810044 	str	r0, [r1, #68]	; 0x44
  search_node   = _Chain_Tail( &search_thread->Wait.Block2n );
  previous_node = search_node->previous;
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
  the_node->previous     = previous_node;
a00066bc:	e5813004 	str	r3, [r1, #4]
  previous_node->next    = the_node;
a00066c0:	e5831000 	str	r1, [r3]
  search_node->previous  = the_node;
a00066c4:	e5841004 	str	r1, [r4, #4]
a00066c8:	e129f00c 	msr	CPSR_fc, ip
a00066cc:	e3a00001 	mov	r0, #1
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
a00066d0:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}
   *  the mutex by an ISR or timed out.
   *
   *  WARNING! Returning with interrupts disabled!
   */
  *level_p = level;
  return the_thread_queue->sync_state;
a00066d4:	e5900030 	ldr	r0, [r0, #48]	; 0x30
   *  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;
a00066d8:	e582c000 	str	ip, [r2]
  return the_thread_queue->sync_state;
}
a00066dc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}
a00066e0:	a0016f10 	.word	0xa0016f10

a0013c38 <_Timer_server_Body>:
 *  @a arg points to the corresponding timer server control block.
 */
static rtems_task _Timer_server_Body(
  rtems_task_argument arg
)
{
a0013c38:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}
a0013c3c:	e24dd020 	sub	sp, sp, #32
a0013c40:	e28d3014 	add	r3, sp, #20
a0013c44:	e28d5008 	add	r5, sp, #8
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
a0013c48:	e3a09000 	mov	r9, #0
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
a0013c4c:	e283a004 	add	sl, r3, #4
a0013c50:	e2858004 	add	r8, r5, #4
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
  the_chain->permanent_null = NULL;
  the_chain->last           = _Chain_Head(the_chain);
a0013c54:	e58d301c 	str	r3, [sp, #28]

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
a0013c58:	e2802008 	add	r2, r0, #8

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
a0013c5c:	e2803040 	add	r3, r0, #64	; 0x40
 *  @a arg points to the corresponding timer server control block.
 */
static rtems_task _Timer_server_Body(
  rtems_task_argument arg
)
{
a0013c60:	e1a04000 	mov	r4, r0
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
a0013c64:	e58da014 	str	sl, [sp, #20]
  the_chain->permanent_null = NULL;
a0013c68:	e58d9018 	str	r9, [sp, #24]
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
a0013c6c:	e58d8008 	str	r8, [sp, #8]
  the_chain->permanent_null = NULL;
a0013c70:	e58d900c 	str	r9, [sp, #12]
  the_chain->last           = _Chain_Head(the_chain);
a0013c74:	e58d5010 	str	r5, [sp, #16]
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a0013c78:	e280b030 	add	fp, r0, #48	; 0x30
    /*
     *  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 );
a0013c7c:	e2807068 	add	r7, r0, #104	; 0x68

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
a0013c80:	e58d2004 	str	r2, [sp, #4]

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
a0013c84:	e58d3000 	str	r3, [sp]
{
  /*
   *  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;
a0013c88:	e28d2014 	add	r2, sp, #20
a0013c8c:	e5842078 	str	r2, [r4, #120]	; 0x78
static void _Timer_server_Process_interval_watchdogs(
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
a0013c90:	e59f216c 	ldr	r2, [pc, #364]	; a0013e04 <_Timer_server_Body+0x1cc>
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a0013c94:	e1a0000b 	mov	r0, fp
static void _Timer_server_Process_interval_watchdogs(
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
a0013c98:	e5923000 	ldr	r3, [r2]

  /*
   *  We assume adequate unsigned arithmetic here.
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
a0013c9c:	e594103c 	ldr	r1, [r4, #60]	; 0x3c

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a0013ca0:	e1a02005 	mov	r2, r5
  /*
   *  We assume adequate unsigned arithmetic here.
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;
a0013ca4:	e584303c 	str	r3, [r4, #60]	; 0x3c

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
a0013ca8:	e0611003 	rsb	r1, r1, r3
a0013cac:	eb001001 	bl	a0017cb8 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a0013cb0:	e59f3150 	ldr	r3, [pc, #336]	; a0013e08 <_Timer_server_Body+0x1d0>
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
a0013cb4:	e5942074 	ldr	r2, [r4, #116]	; 0x74
static void _Timer_server_Process_tod_watchdogs(
  Timer_server_Watchdogs *watchdogs,
  Chain_Control *fire_chain
)
{
  Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
a0013cb8:	e5936000 	ldr	r6, [r3]
  /*
   *  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 ) {
a0013cbc:	e1560002 	cmp	r6, r2
a0013cc0:	9a000004 	bls	a0013cd8 <_Timer_server_Body+0xa0>
    /*
     *  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 );
a0013cc4:	e0621006 	rsb	r1, r2, r6
a0013cc8:	e1a00007 	mov	r0, r7
a0013ccc:	e1a02005 	mov	r2, r5
a0013cd0:	eb000ff8 	bl	a0017cb8 <_Watchdog_Adjust_to_chain>
a0013cd4:	ea000004 	b	a0013cec <_Timer_server_Body+0xb4>

  } else if ( snapshot < last_snapshot ) {
a0013cd8:	2a000003 	bcs	a0013cec <_Timer_server_Body+0xb4>
     /*
      *  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 );
a0013cdc:	e0662002 	rsb	r2, r6, r2
a0013ce0:	e1a00007 	mov	r0, r7
a0013ce4:	e3a01001 	mov	r1, #1
a0013ce8:	eb000fca 	bl	a0017c18 <_Watchdog_Adjust>
  }

  watchdogs->last_snapshot = snapshot;
a0013cec:	e5846074 	str	r6, [r4, #116]	; 0x74
}

static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
  while ( true ) {
    Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
a0013cf0:	e5940078 	ldr	r0, [r4, #120]	; 0x78
a0013cf4:	eb00022c 	bl	a00145ac <_Chain_Get>

    if ( timer == NULL ) {
a0013cf8:	e2501000 	subs	r1, r0, #0
a0013cfc:	0a00000a 	beq	a0013d2c <_Timer_server_Body+0xf4>
static void _Timer_server_Insert_timer(
  Timer_server_Control *ts,
  Timer_Control *timer
)
{
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
a0013d00:	e5913038 	ldr	r3, [r1, #56]	; 0x38
a0013d04:	e3530001 	cmp	r3, #1
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
a0013d08:	02811010 	addeq	r1, r1, #16
a0013d0c:	01a0000b 	moveq	r0, fp
static void _Timer_server_Insert_timer(
  Timer_server_Control *ts,
  Timer_Control *timer
)
{
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
a0013d10:	0a000003 	beq	a0013d24 <_Timer_server_Body+0xec>
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
a0013d14:	e3530003 	cmp	r3, #3
a0013d18:	1afffff4 	bne	a0013cf0 <_Timer_server_Body+0xb8>
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
a0013d1c:	e2811010 	add	r1, r1, #16
a0013d20:	e1a00007 	mov	r0, r7
a0013d24:	eb001010 	bl	a0017d6c <_Watchdog_Insert>
a0013d28:	eafffff0 	b	a0013cf0 <_Timer_server_Body+0xb8>
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
a0013d2c:	e10f3000 	mrs	r3, CPSR
a0013d30:	e3832080 	orr	r2, r3, #128	; 0x80
a0013d34:	e129f002 	msr	CPSR_fc, r2
     *  body loop.
     */
    _Timer_server_Process_insertions( ts );

    _ISR_Disable( level );
    if ( _Chain_Is_empty( insert_chain ) ) {
a0013d38:	e59d2014 	ldr	r2, [sp, #20]
a0013d3c:	e152000a 	cmp	r2, sl
a0013d40:	1a000005 	bne	a0013d5c <_Timer_server_Body+0x124>
      ts->insert_chain = NULL;
a0013d44:	e5841078 	str	r1, [r4, #120]	; 0x78

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
a0013d48:	e129f003 	msr	CPSR_fc, r3
  _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 ) ) {
a0013d4c:	e59d3008 	ldr	r3, [sp, #8]
a0013d50:	e1530008 	cmp	r3, r8
a0013d54:	1a000002 	bne	a0013d64 <_Timer_server_Body+0x12c>
a0013d58:	ea000015 	b	a0013db4 <_Timer_server_Body+0x17c>
a0013d5c:	e129f003 	msr	CPSR_fc, r3                                         	<== NOT EXECUTED
a0013d60:	eaffffca 	b	a0013c90 <_Timer_server_Body+0x58>                    	<== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
a0013d64:	e10f2000 	mrs	r2, CPSR
a0013d68:	e3823080 	orr	r3, r2, #128	; 0x80
a0013d6c:	e129f003 	msr	CPSR_fc, r3
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
a0013d70:	e59d3008 	ldr	r3, [sp, #8]
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
a0013d74:	e1530008 	cmp	r3, r8
a0013d78:	0a00000b 	beq	a0013dac <_Timer_server_Body+0x174>
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
a0013d7c:	e5931000 	ldr	r1, [r3]
         *  It is essential that interrupts are disable here since an interrupt
         *  service routine may remove a watchdog from the chain.
         */
        _ISR_Disable( level );
        watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
        if ( watchdog != NULL ) {
a0013d80:	e3530000 	cmp	r3, #0
  the_chain->first    = new_first;
a0013d84:	e58d1008 	str	r1, [sp, #8]
  new_first->previous = _Chain_Head(the_chain);
a0013d88:	e5815004 	str	r5, [r1, #4]
a0013d8c:	0a000006 	beq	a0013dac <_Timer_server_Body+0x174>
          watchdog->state = WATCHDOG_INACTIVE;
a0013d90:	e5839008 	str	r9, [r3, #8]

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
a0013d94:	e129f002 	msr	CPSR_fc, r2
        /*
         *  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 );
a0013d98:	e5930020 	ldr	r0, [r3, #32]
a0013d9c:	e5931024 	ldr	r1, [r3, #36]	; 0x24
a0013da0:	e1a0e00f 	mov	lr, pc
a0013da4:	e593f01c 	ldr	pc, [r3, #28]
      }
a0013da8:	eaffffed 	b	a0013d64 <_Timer_server_Body+0x12c>
a0013dac:	e129f002 	msr	CPSR_fc, r2
a0013db0:	eaffffb4 	b	a0013c88 <_Timer_server_Body+0x50>
a0013db4:	e59f3050 	ldr	r3, [pc, #80]	; a0013e0c <_Timer_server_Body+0x1d4>
    } else {
      ts->active = false;
a0013db8:	e5c4907c 	strb	r9, [r4, #124]	; 0x7c
a0013dbc:	e5932000 	ldr	r2, [r3]
a0013dc0:	e2822001 	add	r2, r2, #1
a0013dc4:	e5832000 	str	r2, [r3]

      /*
       *  Block until there is something to do.
       */
      _Thread_Disable_dispatch();
        _Thread_Set_state( ts->thread, STATES_DELAYING );
a0013dc8:	e3a01008 	mov	r1, #8
a0013dcc:	e5940000 	ldr	r0, [r4]
a0013dd0:	eb000d41 	bl	a00172dc <_Thread_Set_state>
        _Timer_server_Reset_interval_system_watchdog( ts );
a0013dd4:	e1a00004 	mov	r0, r4
a0013dd8:	ebffff6a 	bl	a0013b88 <_Timer_server_Reset_interval_system_watchdog>
        _Timer_server_Reset_tod_system_watchdog( ts );
a0013ddc:	e1a00004 	mov	r0, r4
a0013de0:	ebffff7e 	bl	a0013be0 <_Timer_server_Reset_tod_system_watchdog>
      _Thread_Enable_dispatch();
a0013de4:	eb000aa4 	bl	a001687c <_Thread_Enable_dispatch>

      ts->active = true;
a0013de8:	e3a03001 	mov	r3, #1
a0013dec:	e5c4307c 	strb	r3, [r4, #124]	; 0x7c

static void _Timer_server_Stop_interval_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
a0013df0:	e59d0004 	ldr	r0, [sp, #4]
a0013df4:	eb001035 	bl	a0017ed0 <_Watchdog_Remove>

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
a0013df8:	e59d0000 	ldr	r0, [sp]
a0013dfc:	eb001033 	bl	a0017ed0 <_Watchdog_Remove>
a0013e00:	eaffffa0 	b	a0013c88 <_Timer_server_Body+0x50>
a0013e04:	a0037c04 	.word	0xa0037c04
a0013e08:	a0037b34 	.word	0xa0037b34
a0013e0c:	a0037aac 	.word	0xa0037aac