00005290 <_POSIX_Condition_variables_Wait_support>:
  pthread_cond_t            *cond,
  pthread_mutex_t           *mutex,
  Watchdog_Interval          timeout,
  bool                       already_timedout
)
{
    5290:	e92d45f1 	push	{r0, r4, r5, r6, r7, r8, sl, lr}
    5294:	e1a04001 	mov	r4, r1
    5298:	e1a06000 	mov	r6, r0
  register POSIX_Condition_variables_Control *the_cond;
  Objects_Locations                           location;
  int                                         status;
  int                                         mutex_status;

  if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
    529c:	e1a0100d 	mov	r1, sp
    52a0:	e1a00004 	mov	r0, r4
  pthread_cond_t            *cond,
  pthread_mutex_t           *mutex,
  Watchdog_Interval          timeout,
  bool                       already_timedout
)
{
    52a4:	e1a08002 	mov	r8, r2
    52a8:	e20370ff 	and	r7, r3, #255	; 0xff
  register POSIX_Condition_variables_Control *the_cond;
  Objects_Locations                           location;
  int                                         status;
  int                                         mutex_status;

  if ( !_POSIX_Mutex_Get( mutex, &location ) ) {
    52ac:	eb00006f 	bl	5470 <_POSIX_Mutex_Get>
    52b0:	e3500000 	cmp	r0, #0
    52b4:	0a000032 	beq	5384 <_POSIX_Condition_variables_Wait_support+0xf4>
 */

RTEMS_INLINE_ROUTINE void _Thread_Unnest_dispatch( void )
{
  RTEMS_COMPILER_MEMORY_BARRIER();
  _Thread_Dispatch_disable_level -= 1;
    52b8:	e59f30d0 	ldr	r3, [pc, #208]	; 5390 <_POSIX_Condition_variables_Wait_support+0x100>
    52bc:	e5932000 	ldr	r2, [r3]
    52c0:	e2422001 	sub	r2, r2, #1
    52c4:	e5832000 	str	r2, [r3]
     return EINVAL;
  }

  _Thread_Unnest_dispatch();

  the_cond = _POSIX_Condition_variables_Get( cond, &location );
    52c8:	e1a0100d 	mov	r1, sp
    52cc:	e1a00006 	mov	r0, r6
    52d0:	ebffff7c 	bl	50c8 <_POSIX_Condition_variables_Get>
  switch ( location ) {
    52d4:	e59d3000 	ldr	r3, [sp]
    52d8:	e3530000 	cmp	r3, #0
     return EINVAL;
  }

  _Thread_Unnest_dispatch();

  the_cond = _POSIX_Condition_variables_Get( cond, &location );
    52dc:	e1a0a000 	mov	sl, r0
  switch ( location ) {
    52e0:	1a000027 	bne	5384 <_POSIX_Condition_variables_Wait_support+0xf4>

    case OBJECTS_LOCAL:

      if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) {
    52e4:	e5903014 	ldr	r3, [r0, #20]
    52e8:	e3530000 	cmp	r3, #0
    52ec:	0a000004 	beq	5304 <_POSIX_Condition_variables_Wait_support+0x74>
    52f0:	e5942000 	ldr	r2, [r4]
    52f4:	e1530002 	cmp	r3, r2
    52f8:	0a000001 	beq	5304 <_POSIX_Condition_variables_Wait_support+0x74>
        _Thread_Enable_dispatch();
    52fc:	eb000bab 	bl	81b0 <_Thread_Enable_dispatch>
    5300:	ea00001f 	b	5384 <_POSIX_Condition_variables_Wait_support+0xf4>
        return EINVAL;
      }

      (void) pthread_mutex_unlock( mutex );
    5304:	e1a00004 	mov	r0, r4
    5308:	eb0000de 	bl	5688 <pthread_mutex_unlock>
        _Thread_Enable_dispatch();
        return EINVAL;
      }
*/

      if ( !already_timedout ) {
    530c:	e3570000 	cmp	r7, #0
    5310:	1a000015 	bne	536c <_POSIX_Condition_variables_Wait_support+0xdc>
        the_cond->Mutex = *mutex;

        _Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
        _Thread_Executing->Wait.return_code = 0;
    5314:	e59f5078 	ldr	r5, [pc, #120]	; 5394 <_POSIX_Condition_variables_Wait_support+0x104>
        return EINVAL;
      }
*/

      if ( !already_timedout ) {
        the_cond->Mutex = *mutex;
    5318:	e5942000 	ldr	r2, [r4]

        _Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
        _Thread_Executing->Wait.return_code = 0;
    531c:	e5953000 	ldr	r3, [r5]
        return EINVAL;
      }
*/

      if ( !already_timedout ) {
        the_cond->Mutex = *mutex;
    5320:	e58a2014 	str	r2, [sl, #20]

        _Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
        _Thread_Executing->Wait.return_code = 0;
    5324:	e5837034 	str	r7, [r3, #52]	; 0x34
        _Thread_Executing->Wait.queue       = &the_cond->Wait_queue;
        _Thread_Executing->Wait.id          = *cond;
    5328:	e5961000 	ldr	r1, [r6]
      if ( !already_timedout ) {
        the_cond->Mutex = *mutex;

        _Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
        _Thread_Executing->Wait.return_code = 0;
        _Thread_Executing->Wait.queue       = &the_cond->Wait_queue;
    532c:	e28a2018 	add	r2, sl, #24
        _Thread_Executing->Wait.id          = *cond;
    5330:	e5831020 	str	r1, [r3, #32]

RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
  Thread_queue_Control *the_thread_queue
)
{
  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
    5334:	e3a01001 	mov	r1, #1
      if ( !already_timedout ) {
        the_cond->Mutex = *mutex;

        _Thread_queue_Enter_critical_section( &the_cond->Wait_queue );
        _Thread_Executing->Wait.return_code = 0;
        _Thread_Executing->Wait.queue       = &the_cond->Wait_queue;
    5338:	e5832044 	str	r2, [r3, #68]	; 0x44
        _Thread_Executing->Wait.id          = *cond;

        _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout );
    533c:	e1a00002 	mov	r0, r2
    5340:	e58a1048 	str	r1, [sl, #72]	; 0x48
    5344:	e59f204c 	ldr	r2, [pc, #76]	; 5398 <_POSIX_Condition_variables_Wait_support+0x108>
    5348:	e1a01008 	mov	r1, r8
    534c:	eb000cd0 	bl	8694 <_Thread_queue_Enqueue_with_handler>

        _Thread_Enable_dispatch();
    5350:	eb000b96 	bl	81b0 <_Thread_Enable_dispatch>
        /*
         *  Switch ourself out because we blocked as a result of the
         *  _Thread_queue_Enqueue.
         */

        status = _Thread_Executing->Wait.return_code;
    5354:	e5953000 	ldr	r3, [r5]
    5358:	e5935034 	ldr	r5, [r3, #52]	; 0x34
        if ( status && status != ETIMEDOUT )
    535c:	e3550074 	cmp	r5, #116	; 0x74
    5360:	13550000 	cmpne	r5, #0
    5364:	0a000002 	beq	5374 <_POSIX_Condition_variables_Wait_support+0xe4>
    5368:	ea000006 	b	5388 <_POSIX_Condition_variables_Wait_support+0xf8>   	<== NOT EXECUTED
          return status;

      } else {
        _Thread_Enable_dispatch();
    536c:	eb000b8f 	bl	81b0 <_Thread_Enable_dispatch>
    5370:	e3a05074 	mov	r5, #116	; 0x74

      /*
       *  When we get here the dispatch disable level is 0.
       */

      mutex_status = pthread_mutex_lock( mutex );
    5374:	e1a00004 	mov	r0, r4
    5378:	eb0000a3 	bl	560c <pthread_mutex_lock>
      if ( mutex_status )
    537c:	e3500000 	cmp	r0, #0
    5380:	0a000000 	beq	5388 <_POSIX_Condition_variables_Wait_support+0xf8>
    5384:	e3a05016 	mov	r5, #22
    case OBJECTS_ERROR:
      break;
  }

  return EINVAL;
}
    5388:	e1a00005 	mov	r0, r5
    538c:	e8bd85f8 	pop	{r3, r4, r5, r6, r7, r8, sl, pc}
    5390:	0001c6ac 	.word	0x0001c6ac
    5394:	0001c760 	.word	0x0001c760
    5398:	00008a40 	.word	0x00008a40

0000665c <_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
)
{
    665c:	e92d45f0 	push	{r4, r5, r6, r7, r8, sl, lr}
  Priority_Control     priority;
  States_Control       block_state;

  _Chain_Initialize_empty( &the_thread->Wait.Block2n );

  priority     = the_thread->current_priority;
    6660:	e5913014 	ldr	r3, [r1, #20]
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
    6664:	e281503c 	add	r5, r1, #60	; 0x3c
    6668:	e5815038 	str	r5, [r1, #56]	; 0x38
  the_chain->permanent_null = NULL;
    666c:	e3a05000 	mov	r5, #0
  the_chain->last           = _Chain_Head(the_chain);
    6670:	e281c038 	add	ip, r1, #56	; 0x38
  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 ) )
    6674:	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 ];
    6678:	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;
    667c:	e581503c 	str	r5, [r1, #60]	; 0x3c
    6680:	e285500c 	add	r5, r5, #12
  the_chain->last           = _Chain_Head(the_chain);
    6684:	e581c040 	str	ip, [r1, #64]	; 0x40
  block_state  = the_thread_queue->state;
    6688:	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 ];
    668c:	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;
    6690:	159f8154 	ldrne	r8, [pc, #340]	; 67ec <_Thread_queue_Enqueue_priority+0x190>
  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 ) )
    6694:	1a000023 	bne	6728 <_Thread_queue_Enqueue_priority+0xcc>
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
    6698:	e28c8004 	add	r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
    669c:	e10f5000 	mrs	r5, CPSR
    66a0:	e3854080 	orr	r4, r5, #128	; 0x80
    66a4:	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;
    66a8:	e3e06000 	mvn	r6, #0
    66ac:	e59c4000 	ldr	r4, [ip]
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
    66b0:	ea00000b 	b	66e4 <_Thread_queue_Enqueue_priority+0x88>
    search_priority = search_thread->current_priority;
    66b4:	e5946014 	ldr	r6, [r4, #20]
    if ( priority <= search_priority )
    66b8:	e1530006 	cmp	r3, r6
    66bc:	9a00000a 	bls	66ec <_Thread_queue_Enqueue_priority+0x90>

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

  asm volatile (
    66c0:	e10fa000 	mrs	sl, CPSR
    66c4:	e129f005 	msr	CPSR_fc, r5
    66c8:	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) ) {
    66cc:	e594a010 	ldr	sl, [r4, #16]
    66d0:	e117000a 	tst	r7, sl
    66d4:	1a000001 	bne	66e0 <_Thread_queue_Enqueue_priority+0x84>

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
    66d8:	e129f005 	msr	CPSR_fc, r5                                         	<== NOT EXECUTED
    66dc:	eaffffee 	b	669c <_Thread_queue_Enqueue_priority+0x40>            	<== NOT EXECUTED
      _ISR_Enable( level );
      goto restart_forward_search;
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
    66e0:	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 ) ) {
    66e4:	e1540008 	cmp	r4, r8
    66e8:	1afffff1 	bne	66b4 <_Thread_queue_Enqueue_priority+0x58>
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
    66ec:	e590c030 	ldr	ip, [r0, #48]	; 0x30
    66f0:	e35c0001 	cmp	ip, #1

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

  if ( the_thread_queue->sync_state !=
    66f8:	1a000038 	bne	67e0 <_Thread_queue_Enqueue_priority+0x184>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;

  if ( priority == search_priority )
    66fc:	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;
    6700:	e3a03000 	mov	r3, #0
    6704:	e5803030 	str	r3, [r0, #48]	; 0x30

  if ( priority == search_priority )
    6708:	0a00002a 	beq	67b8 <_Thread_queue_Enqueue_priority+0x15c>
    goto equal_priority;

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

  the_node->next         = search_node;
    6710:	e5814000 	str	r4, [r1]
  the_node->previous     = previous_node;
    6714:	e5813004 	str	r3, [r1, #4]
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
    6718:	e5810044 	str	r0, [r1, #68]	; 0x44
  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;
    671c:	e5831000 	str	r1, [r3]
  search_node->previous  = the_node;
    6720:	e5841004 	str	r1, [r4, #4]
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
    6724:	ea000021 	b	67b0 <_Thread_queue_Enqueue_priority+0x154>
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

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

  asm volatile (
    6730:	e10f5000 	mrs	r5, CPSR
    6734:	e3854080 	orr	r4, r5, #128	; 0x80
    6738:	e129f004 	msr	CPSR_fc, r4

  _ISR_Disable( level );
  search_thread = (Thread_Control *) header->last;
    673c:	e59c4008 	ldr	r4, [ip, #8]
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
    6740:	ea00000b 	b	6774 <_Thread_queue_Enqueue_priority+0x118>
    search_priority = search_thread->current_priority;
    6744:	e5946014 	ldr	r6, [r4, #20]
    if ( priority >= search_priority )
    6748:	e1530006 	cmp	r3, r6
    674c:	2a00000a 	bcs	677c <_Thread_queue_Enqueue_priority+0x120>

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

  asm volatile (
    6750:	e10fa000 	mrs	sl, CPSR
    6754:	e129f005 	msr	CPSR_fc, r5
    6758:	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) ) {
    675c:	e594a010 	ldr	sl, [r4, #16]
    6760:	e117000a 	tst	r7, sl
    6764:	1a000001 	bne	6770 <_Thread_queue_Enqueue_priority+0x114>

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
    6768:	e129f005 	msr	CPSR_fc, r5
    676c:	eaffffed 	b	6728 <_Thread_queue_Enqueue_priority+0xcc>
      _ISR_Enable( level );
      goto restart_reverse_search;
    }
    search_thread = (Thread_Control *)
    6770:	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 ) ) {
    6774:	e154000c 	cmp	r4, ip
    6778:	1afffff1 	bne	6744 <_Thread_queue_Enqueue_priority+0xe8>
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
    677c:	e590c030 	ldr	ip, [r0, #48]	; 0x30
    6780:	e35c0001 	cmp	ip, #1
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 ) ) {
    6784:	e1a0c005 	mov	ip, r5
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

  if ( the_thread_queue->sync_state !=
    6788:	1a000014 	bne	67e0 <_Thread_queue_Enqueue_priority+0x184>
       THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
    goto synchronize;

  the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;

  if ( priority == search_priority )
    678c:	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;
    6790:	e3a03000 	mov	r3, #0
    6794:	e5803030 	str	r3, [r0, #48]	; 0x30

  if ( priority == search_priority )
    6798:	0a000006 	beq	67b8 <_Thread_queue_Enqueue_priority+0x15c>
    goto equal_priority;

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

  the_node->next          = next_node;
  the_node->previous      = search_node;
    67a0:	e8810018 	stm	r1, {r3, r4}
  search_node->next       = the_node;
  next_node->previous    = the_node;
  the_thread->Wait.queue = the_thread_queue;
    67a4:	e5810044 	str	r0, [r1, #68]	; 0x44
  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;
    67a8:	e5841000 	str	r1, [r4]
  next_node->previous    = the_node;
    67ac:	e5831004 	str	r1, [r3, #4]
    67b0:	e129f005 	msr	CPSR_fc, r5
    67b4:	ea000007 	b	67d8 <_Thread_queue_Enqueue_priority+0x17c>
    67b8:	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;
    67bc:	e5943004 	ldr	r3, [r4, #4]
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
    67c0:	e5814000 	str	r4, [r1]
  the_node->previous     = previous_node;
    67c4:	e5813004 	str	r3, [r1, #4]
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
    67c8:	e5810044 	str	r0, [r1, #68]	; 0x44
  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;
    67cc:	e5831000 	str	r1, [r3]
  search_node->previous  = the_node;
    67d0:	e5841004 	str	r1, [r4, #4]
    67d4:	e129f00c 	msr	CPSR_fc, ip
    67d8:	e3a00001 	mov	r0, #1
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
    67dc:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}
   *  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;
    67e0:	e582c000 	str	ip, [r2]
  return the_thread_queue->sync_state;
    67e4:	e5900030 	ldr	r0, [r0, #48]	; 0x30
}
    67e8:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}
    67ec:	00018450 	.word	0x00018450

00013ce8 <_Timer_server_Body>:
 *  @a arg points to the corresponding timer server control block.
 */
static rtems_task _Timer_server_Body(
  rtems_task_argument arg
)
{
   13ce8:	e92d4ff0 	push	{r4, r5, r6, r7, r8, r9, sl, fp, lr}
   13cec:	e24dd020 	sub	sp, sp, #32
   13cf0:	e28d3014 	add	r3, sp, #20
   13cf4:	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;
   13cf8:	e3a09000 	mov	r9, #0
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
   13cfc:	e283a004 	add	sl, r3, #4
   13d00:	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);
   13d04:	e58d301c 	str	r3, [sp, #28]

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

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
   13d0c:	e2803040 	add	r3, r0, #64	; 0x40
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   13d10:	e58da014 	str	sl, [sp, #20]
  the_chain->permanent_null = NULL;
   13d14:	e58d9018 	str	r9, [sp, #24]
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
   13d18:	e58d8008 	str	r8, [sp, #8]
  the_chain->permanent_null = NULL;
   13d1c:	e58d900c 	str	r9, [sp, #12]
  the_chain->last           = _Chain_Head(the_chain);
   13d20:	e58d5010 	str	r5, [sp, #16]

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

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
   13d28:	e58d3000 	str	r3, [sp]
 *  @a arg points to the corresponding timer server control block.
 */
static rtems_task _Timer_server_Body(
  rtems_task_argument arg
)
{
   13d2c:	e1a04000 	mov	r4, r0
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   13d30:	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 );
   13d34:	e2807068 	add	r7, r0, #104	; 0x68
{
  /*
   *  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;
   13d38:	e28d2014 	add	r2, sp, #20
   13d3c:	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;
   13d40:	e59f2168 	ldr	r2, [pc, #360]	; 13eb0 <_Timer_server_Body+0x1c8>
   13d44:	e5923000 	ldr	r3, [r2]

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

  watchdogs->last_snapshot = snapshot;

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   13d4c:	e1a02005 	mov	r2, r5
   13d50:	e0611003 	rsb	r1, r1, r3
  /*
   *  We assume adequate unsigned arithmetic here.
   */
  Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;

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

  _Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
   13d58:	e1a0000b 	mov	r0, fp
   13d5c:	eb001049 	bl	17e88 <_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();
   13d60:	e59f314c 	ldr	r3, [pc, #332]	; 13eb4 <_Timer_server_Body+0x1cc>
  Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
   13d64:	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();
   13d68:	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 ) {
   13d6c:	e1560002 	cmp	r6, r2
   13d70:	9a000004 	bls	13d88 <_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 );
   13d74:	e0621006 	rsb	r1, r2, r6
   13d78:	e1a00007 	mov	r0, r7
   13d7c:	e1a02005 	mov	r2, r5
   13d80:	eb001040 	bl	17e88 <_Watchdog_Adjust_to_chain>
   13d84:	ea000003 	b	13d98 <_Timer_server_Body+0xb0>
     /*
      *  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 );
   13d88:	30662002 	rsbcc	r2, r6, r2
   13d8c:	31a00007 	movcc	r0, r7
   13d90:	33a01001 	movcc	r1, #1
   13d94:	3b001013 	blcc	17de8 <_Watchdog_Adjust>
  }

  watchdogs->last_snapshot = snapshot;
   13d98:	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 );
   13d9c:	e5940078 	ldr	r0, [r4, #120]	; 0x78
   13da0:	eb00023b 	bl	14694 <_Chain_Get>

    if ( timer == NULL ) {
   13da4:	e2501000 	subs	r1, r0, #0
   13da8:	0a00000a 	beq	13dd8 <_Timer_server_Body+0xf0>
static void _Timer_server_Insert_timer(
  Timer_server_Control *ts,
  Timer_Control *timer
)
{
  if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
   13dac:	e5913038 	ldr	r3, [r1, #56]	; 0x38
   13db0:	e3530001 	cmp	r3, #1
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
   13db4:	02811010 	addeq	r1, r1, #16
   13db8:	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 ) {
   13dbc:	0a000003 	beq	13dd0 <_Timer_server_Body+0xe8>
    _Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
  } else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
   13dc0:	e3530003 	cmp	r3, #3
   13dc4:	1afffff4 	bne	13d9c <_Timer_server_Body+0xb4>
    _Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
   13dc8:	e2811010 	add	r1, r1, #16
   13dcc:	e1a00007 	mov	r0, r7
   13dd0:	eb001059 	bl	17f3c <_Watchdog_Insert>
   13dd4:	eafffff0 	b	13d9c <_Timer_server_Body+0xb4>
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

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

    _ISR_Disable( level );
    if ( _Chain_Is_empty( insert_chain ) ) {
   13de4:	e59d2014 	ldr	r2, [sp, #20]
   13de8:	e152000a 	cmp	r2, sl
   13dec:	1a000005 	bne	13e08 <_Timer_server_Body+0x120>
      ts->insert_chain = NULL;
   13df0:	e5841078 	str	r1, [r4, #120]	; 0x78

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
   13df4:	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 ) ) {
   13df8:	e59d3008 	ldr	r3, [sp, #8]
   13dfc:	e1530008 	cmp	r3, r8
   13e00:	1a000002 	bne	13e10 <_Timer_server_Body+0x128>
   13e04:	ea000015 	b	13e60 <_Timer_server_Body+0x178>
   13e08:	e129f003 	msr	CPSR_fc, r3                                         	<== NOT EXECUTED
   13e0c:	eaffffcb 	b	13d40 <_Timer_server_Body+0x58>                       	<== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
   13e10:	e10f2000 	mrs	r2, CPSR
   13e14:	e3823080 	orr	r3, r2, #128	; 0x80
   13e18:	e129f003 	msr	CPSR_fc, r3
 */
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
  Chain_Control *the_chain
)
{
  return (the_chain->first == _Chain_Tail(the_chain));
   13e1c:	e59d3008 	ldr	r3, [sp, #8]
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
  Chain_Control *the_chain
)
{
  if ( !_Chain_Is_empty(the_chain))
   13e20:	e1530008 	cmp	r3, r8
   13e24:	0a00000b 	beq	13e58 <_Timer_server_Body+0x170>
{
  Chain_Node  *return_node;
  Chain_Node  *new_first;

  return_node         = the_chain->first;
  new_first           = return_node->next;
   13e28:	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 ) {
   13e2c:	e3530000 	cmp	r3, #0
  the_chain->first    = new_first;
   13e30:	e58d1008 	str	r1, [sp, #8]
  new_first->previous = _Chain_Head(the_chain);
   13e34:	e5815004 	str	r5, [r1, #4]
   13e38:	0a000006 	beq	13e58 <_Timer_server_Body+0x170>
          watchdog->state = WATCHDOG_INACTIVE;
   13e3c:	e5839008 	str	r9, [r3, #8]

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
   13e40:	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 );
   13e44:	e2830020 	add	r0, r3, #32
   13e48:	e8900003 	ldm	r0, {r0, r1}
   13e4c:	e1a0e00f 	mov	lr, pc
   13e50:	e593f01c 	ldr	pc, [r3, #28]
      }
   13e54:	eaffffed 	b	13e10 <_Timer_server_Body+0x128>
   13e58:	e129f002 	msr	CPSR_fc, r2
   13e5c:	eaffffb5 	b	13d38 <_Timer_server_Body+0x50>
    } else {
      ts->active = false;
   13e60:	e5c4907c 	strb	r9, [r4, #124]	; 0x7c
   13e64:	e59f304c 	ldr	r3, [pc, #76]	; 13eb8 <_Timer_server_Body+0x1d0>
   13e68:	e5932000 	ldr	r2, [r3]
   13e6c:	e2822001 	add	r2, r2, #1
   13e70:	e5832000 	str	r2, [r3]

      /*
       *  Block until there is something to do.
       */
      _Thread_Disable_dispatch();
        _Thread_Set_state( ts->thread, STATES_DELAYING );
   13e74:	e3a01008 	mov	r1, #8
   13e78:	e5940000 	ldr	r0, [r4]
   13e7c:	eb000d7d 	bl	17478 <_Thread_Set_state>
        _Timer_server_Reset_interval_system_watchdog( ts );
   13e80:	e1a00004 	mov	r0, r4
   13e84:	ebffff6b 	bl	13c38 <_Timer_server_Reset_interval_system_watchdog>
        _Timer_server_Reset_tod_system_watchdog( ts );
   13e88:	e1a00004 	mov	r0, r4
   13e8c:	ebffff7f 	bl	13c90 <_Timer_server_Reset_tod_system_watchdog>
      _Thread_Enable_dispatch();
   13e90:	eb000adf 	bl	16a14 <_Thread_Enable_dispatch>

      ts->active = true;
   13e94:	e3a03001 	mov	r3, #1
   13e98:	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 );
   13e9c:	e59d0004 	ldr	r0, [sp, #4]
   13ea0:	eb00107e 	bl	180a0 <_Watchdog_Remove>

static void _Timer_server_Stop_tod_system_watchdog(
  Timer_server_Control *ts
)
{
  _Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
   13ea4:	e59d0000 	ldr	r0, [sp]
   13ea8:	eb00107c 	bl	180a0 <_Watchdog_Remove>
   13eac:	eaffffa1 	b	13d38 <_Timer_server_Body+0x50>
   13eb0:	00039384 	.word	0x00039384
   13eb4:	000392b4 	.word	0x000392b4
   13eb8:	0003922c 	.word	0x0003922c