0000927c <_CORE_mutex_Seize_interrupt_trylock>:
{
  Thread_Control   *executing;

  /* disabled when you get here */

  executing = _Thread_Executing;
    927c:	e59f3120 	ldr	r3, [pc, #288]	; 93a4 <_CORE_mutex_Seize_interrupt_trylock+0x128>
    9280:	e5933000 	ldr	r3, [r3]
  executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
    9284:	e3a02000 	mov	r2, #0
    9288:	e5832034 	str	r2, [r3, #52]	; 0x34
  if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
    928c:	e590c050 	ldr	ip, [r0, #80]	; 0x50
    9290:	e15c0002 	cmp	ip, r2
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
  CORE_mutex_Control  *the_mutex,
  ISR_Level           *level_p
)
{
    9294:	e52de004 	push	{lr}		; (str lr, [sp, #-4]!)
    9298:	0a00002c 	beq	9350 <_CORE_mutex_Seize_interrupt_trylock+0xd4>
    the_mutex->lock       = CORE_MUTEX_LOCKED;
    929c:	e5802050 	str	r2, [r0, #80]	; 0x50
 */
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
  CORE_mutex_Attributes *the_attribute
)
{
  return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
    92a0:	e5902048 	ldr	r2, [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;
    the_mutex->holder_id  = executing->Object.id;
    92a4:	e593c008 	ldr	ip, [r3, #8]
    the_mutex->nest_count = 1;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
    92a8:	e3520002 	cmp	r2, #2
  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;
    92ac:	e580c060 	str	ip, [r0, #96]	; 0x60
    the_mutex->nest_count = 1;
    92b0:	e3a0c001 	mov	ip, #1
    92b4:	e580c054 	str	ip, [r0, #84]	; 0x54

  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;
    92b8:	e580305c 	str	r3, [r0, #92]	; 0x5c
    the_mutex->holder_id  = executing->Object.id;
    the_mutex->nest_count = 1;
    if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
    92bc:	0a000001 	beq	92c8 <_CORE_mutex_Seize_interrupt_trylock+0x4c>
    92c0:	e3520003 	cmp	r2, #3
    92c4:	1a000004 	bne	92dc <_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++;
    92c8:	e593c01c 	ldr	ip, [r3, #28]
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
    92cc:	e3520003 	cmp	r2, #3
       _Chain_Prepend_unprotected( &executing->lock_mutex,
                                   &the_mutex->queue.lock_queue );
       the_mutex->queue.priority_before = executing->current_priority;
#endif

      executing->resource_count++;
    92d0:	e28c2001 	add	r2, ip, #1
    92d4:	e583201c 	str	r2, [r3, #28]
    }

    if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
    92d8:	0a000000 	beq	92e0 <_CORE_mutex_Seize_interrupt_trylock+0x64>
      _ISR_Enable( *level_p );
    92dc:	ea00002a 	b	938c <_CORE_mutex_Seize_interrupt_trylock+0x110>
       */
    {
      Priority_Control  ceiling;
      Priority_Control  current;

      ceiling = the_mutex->Attributes.priority_ceiling;
    92e0:	e590204c 	ldr	r2, [r0, #76]	; 0x4c
      current = executing->current_priority;
    92e4:	e593c014 	ldr	ip, [r3, #20]
      if ( current == ceiling ) {
    92e8:	e15c0002 	cmp	ip, r2
    92ec:	1a000000 	bne	92f4 <_CORE_mutex_Seize_interrupt_trylock+0x78>
        _ISR_Enable( *level_p );
    92f0:	ea000025 	b	938c <_CORE_mutex_Seize_interrupt_trylock+0x110>
        return 0;
      }

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

  _Thread_Dispatch_disable_level += 1;
    92f8:	e59f30a8 	ldr	r3, [pc, #168]	; 93a8 <_CORE_mutex_Seize_interrupt_trylock+0x12c>
    92fc:	e5932000 	ldr	r2, [r3]
    9300:	e2822001 	add	r2, r2, #1
    9304:	e5832000 	str	r2, [r3]
    9308:	e5913000 	ldr	r3, [r1]
    930c:	e129f003 	msr	CPSR_fc, r3
        _Thread_Disable_dispatch();
        _ISR_Enable( *level_p );
        _Thread_Change_priority(
    9310:	e3a02000 	mov	r2, #0
    9314:	e590104c 	ldr	r1, [r0, #76]	; 0x4c
    9318:	e590005c 	ldr	r0, [r0, #92]	; 0x5c
    931c:	ebfff1ef 	bl	5ae0 <_Thread_Change_priority>
          the_mutex->holder,
          the_mutex->Attributes.priority_ceiling,
         false
        );
        _Thread_Enable_dispatch();
    9320:	ebfff34f 	bl	6064 <_Thread_Enable_dispatch>
    9324:	ea00001a 	b	9394 <_CORE_mutex_Seize_interrupt_trylock+0x118>
        return 0;
      }
      /* if ( current < ceiling ) */ {
        executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
    9328:	e3a02006 	mov	r2, #6
    932c:	e5832034 	str	r2, [r3, #52]	; 0x34
        the_mutex->lock       = CORE_MUTEX_UNLOCKED;
        the_mutex->nest_count = 0;     /* undo locking above */
    9330:	e3a02000 	mov	r2, #0
    9334:	e5802054 	str	r2, [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;
    9338:	e2822001 	add	r2, r2, #1
    933c:	e5802050 	str	r2, [r0, #80]	; 0x50
        the_mutex->nest_count = 0;     /* undo locking above */
        executing->resource_count--;   /* undo locking above */
    9340:	e593201c 	ldr	r2, [r3, #28]
    9344:	e2422001 	sub	r2, r2, #1
    9348:	e583201c 	str	r2, [r3, #28]
        _ISR_Enable( *level_p );
    934c:	ea00000e 	b	938c <_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 ) ) {
    9350:	e590205c 	ldr	r2, [r0, #92]	; 0x5c
    9354:	e1520003 	cmp	r2, r3
    9358:	1a00000f 	bne	939c <_CORE_mutex_Seize_interrupt_trylock+0x120>
    switch ( the_mutex->Attributes.lock_nesting_behavior ) {
    935c:	e5903040 	ldr	r3, [r0, #64]	; 0x40
    9360:	e3530000 	cmp	r3, #0
    9364:	0a000002 	beq	9374 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
    9368:	e3530001 	cmp	r3, #1
    936c:	1a00000a 	bne	939c <_CORE_mutex_Seize_interrupt_trylock+0x120>
    9370:	ea000003 	b	9384 <_CORE_mutex_Seize_interrupt_trylock+0x108>      	<== NOT EXECUTED
      case CORE_MUTEX_NESTING_ACQUIRES:
        the_mutex->nest_count++;
    9374:	e5903054 	ldr	r3, [r0, #84]	; 0x54
    9378:	e2833001 	add	r3, r3, #1
    937c:	e5803054 	str	r3, [r0, #84]	; 0x54
        _ISR_Enable( *level_p );
    9380:	ea000001 	b	938c <_CORE_mutex_Seize_interrupt_trylock+0x110>
        return 0;
      case CORE_MUTEX_NESTING_IS_ERROR:
        executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
    9384:	e3a03002 	mov	r3, #2                                              	<== NOT EXECUTED
    9388:	e5823034 	str	r3, [r2, #52]	; 0x34                                	<== NOT EXECUTED
    938c:	e5913000 	ldr	r3, [r1]
    9390:	e129f003 	msr	CPSR_fc, r3
    9394:	e3a00000 	mov	r0, #0
    9398:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)
    939c:	e3a00001 	mov	r0, #1
  return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p );
}
    93a0:	e49df004 	pop	{pc}		; (ldr pc, [sp], #4)
    93a4:	000187c0 	.word	0x000187c0
    93a8:	0001870c 	.word	0x0001870c

000065c0 <_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
)
{
    65c0:	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;
    65c4:	e5913014 	ldr	r3, [r1, #20]
 */
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
  Chain_Control *the_chain
)
{
  the_chain->first          = _Chain_Tail(the_chain);
    65c8:	e281503c 	add	r5, r1, #60	; 0x3c
    65cc:	e5815038 	str	r5, [r1, #56]	; 0x38
  the_chain->permanent_null = NULL;
    65d0:	e3a05000 	mov	r5, #0
  the_chain->last           = _Chain_Head(the_chain);
    65d4:	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 ) )
    65d8:	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 ];
    65dc:	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;
    65e0:	e581503c 	str	r5, [r1, #60]	; 0x3c
    65e4:	e285500c 	add	r5, r5, #12
  the_chain->last           = _Chain_Head(the_chain);
    65e8:	e581c040 	str	ip, [r1, #64]	; 0x40
  block_state  = the_thread_queue->state;
    65ec:	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 ];
    65f0:	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;
    65f4:	159f8154 	ldrne	r8, [pc, #340]	; 6750 <_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 ) )
    65f8:	1a000023 	bne	668c <_Thread_queue_Enqueue_priority+0xcc>
 */
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
  Chain_Control *the_chain
)
{
   return (Chain_Node *) &the_chain->permanent_null;
    65fc:	e28c8004 	add	r8, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
  uint32_t arm_switch_reg;
  uint32_t level;

  asm volatile (
    6600:	e10f5000 	mrs	r5, CPSR
    6604:	e3854080 	orr	r4, r5, #128	; 0x80
    6608:	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;
    660c:	e3e06000 	mvn	r6, #0
    6610:	e59c4000 	ldr	r4, [ip]
  while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
    6614:	ea00000b 	b	6648 <_Thread_queue_Enqueue_priority+0x88>
    search_priority = search_thread->current_priority;
    6618:	e5946014 	ldr	r6, [r4, #20]
    if ( priority <= search_priority )
    661c:	e1530006 	cmp	r3, r6
    6620:	9a00000a 	bls	6650 <_Thread_queue_Enqueue_priority+0x90>

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

  asm volatile (
    6624:	e10fa000 	mrs	sl, CPSR
    6628:	e129f005 	msr	CPSR_fc, r5
    662c:	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) ) {
    6630:	e594a010 	ldr	sl, [r4, #16]
    6634:	e117000a 	tst	r7, sl
    6638:	1a000001 	bne	6644 <_Thread_queue_Enqueue_priority+0x84>

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
    663c:	e129f005 	msr	CPSR_fc, r5                                         	<== NOT EXECUTED
    6640:	eaffffee 	b	6600 <_Thread_queue_Enqueue_priority+0x40>            	<== NOT EXECUTED
      _ISR_Enable( level );
      goto restart_forward_search;
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
    6644:	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 ) ) {
    6648:	e1540008 	cmp	r4, r8
    664c:	1afffff1 	bne	6618 <_Thread_queue_Enqueue_priority+0x58>
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
    6650:	e590c030 	ldr	ip, [r0, #48]	; 0x30
    6654:	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 ) ) {
    6658:	e1a0c005 	mov	ip, r5
    }
    search_thread =
       (Thread_Control *)search_thread->Object.Node.next;
  }

  if ( the_thread_queue->sync_state !=
    665c:	1a000038 	bne	6744 <_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 )
    6660:	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;
    6664:	e3a03000 	mov	r3, #0
    6668:	e5803030 	str	r3, [r0, #48]	; 0x30

  if ( priority == search_priority )
    666c:	0a00002a 	beq	671c <_Thread_queue_Enqueue_priority+0x15c>
    goto equal_priority;

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

  the_node->next         = search_node;
    6674:	e5814000 	str	r4, [r1]
  the_node->previous     = previous_node;
    6678:	e5813004 	str	r3, [r1, #4]
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
    667c:	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;
    6680:	e5831000 	str	r1, [r3]
  search_node->previous  = the_node;
    6684:	e5841004 	str	r1, [r4, #4]
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
    6688:	ea000021 	b	6714 <_Thread_queue_Enqueue_priority+0x154>
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;

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

  asm volatile (
    6694:	e10f5000 	mrs	r5, CPSR
    6698:	e3854080 	orr	r4, r5, #128	; 0x80
    669c:	e129f004 	msr	CPSR_fc, r4

  _ISR_Disable( level );
  search_thread = (Thread_Control *) header->last;
    66a0:	e59c4008 	ldr	r4, [ip, #8]
  while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
    66a4:	ea00000b 	b	66d8 <_Thread_queue_Enqueue_priority+0x118>
    search_priority = search_thread->current_priority;
    66a8:	e5946014 	ldr	r6, [r4, #20]
    if ( priority >= search_priority )
    66ac:	e1530006 	cmp	r3, r6
    66b0:	2a00000a 	bcs	66e0 <_Thread_queue_Enqueue_priority+0x120>

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

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

static inline void arm_interrupt_enable( uint32_t level )
{
  ARM_SWITCH_REGISTERS;

  asm volatile (
    66cc:	e129f005 	msr	CPSR_fc, r5
    66d0:	eaffffed 	b	668c <_Thread_queue_Enqueue_priority+0xcc>
      _ISR_Enable( level );
      goto restart_reverse_search;
    }
    search_thread = (Thread_Control *)
    66d4:	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 ) ) {
    66d8:	e154000c 	cmp	r4, ip
    66dc:	1afffff1 	bne	66a8 <_Thread_queue_Enqueue_priority+0xe8>
    }
    search_thread = (Thread_Control *)
                         search_thread->Object.Node.previous;
  }

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

  if ( the_thread_queue->sync_state !=
    66ec:	1a000014 	bne	6744 <_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 )
    66f0:	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;
    66f4:	e3a03000 	mov	r3, #0
    66f8:	e5803030 	str	r3, [r0, #48]	; 0x30

  if ( priority == search_priority )
    66fc:	0a000006 	beq	671c <_Thread_queue_Enqueue_priority+0x15c>
    goto equal_priority;

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

  the_node->next          = next_node;
  the_node->previous      = search_node;
    6704:	e8810018 	stm	r1, {r3, r4}
  search_node->next       = the_node;
  next_node->previous    = the_node;
  the_thread->Wait.queue = the_thread_queue;
    6708:	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;
    670c:	e5841000 	str	r1, [r4]
  next_node->previous    = the_node;
    6710:	e5831004 	str	r1, [r3, #4]
    6714:	e129f005 	msr	CPSR_fc, r5
    6718:	ea000007 	b	673c <_Thread_queue_Enqueue_priority+0x17c>
    671c:	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;
    6720:	e5943004 	ldr	r3, [r4, #4]
  the_node      = (Chain_Node *) the_thread;

  the_node->next         = search_node;
    6724:	e5814000 	str	r4, [r1]
  the_node->previous     = previous_node;
    6728:	e5813004 	str	r3, [r1, #4]
  previous_node->next    = the_node;
  search_node->previous  = the_node;
  the_thread->Wait.queue = the_thread_queue;
    672c:	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;
    6730:	e5831000 	str	r1, [r3]
  search_node->previous  = the_node;
    6734:	e5841004 	str	r1, [r4, #4]
    6738:	e129f00c 	msr	CPSR_fc, ip
    673c:	e3a00001 	mov	r0, #1
  the_thread->Wait.queue = the_thread_queue;
  _ISR_Enable( level );
  return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
    6740:	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;
    6744:	e582c000 	str	ip, [r2]
  return the_thread_queue->sync_state;
    6748:	e5900030 	ldr	r0, [r0, #48]	; 0x30
}
    674c:	e8bd85f0 	pop	{r4, r5, r6, r7, r8, sl, pc}
    6750:	000170a0 	.word	0x000170a0

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:	eb000fdb 	bl	17cd0 <_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:	eb000fd2 	bl	17cd0 <_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:	3b000fa5 	blcc	17c30 <_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:	eb000228 	bl	14648 <_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:	eb000feb 	bl	17d84 <_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:	eb000d20 	bl	17304 <_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:	eb000a8c 	bl	168c8 <_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:	eb001010 	bl	17ee8 <_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:	eb00100e 	bl	17ee8 <_Watchdog_Remove>
   13eac:	eaffffa1 	b	13d38 <_Timer_server_Body+0x50>
   13eb0:	00037c44 	.word	0x00037c44
   13eb4:	00037b74 	.word	0x00037b74
   13eb8:	00037aec 	.word	0x00037aec