main.o:     file format elf32-littlearm


Disassembly of section .text.main:

00000000 <main>:
const char *pcTextForTask2 = "Task 2 is running, ulIdleCycleCount = ";

/*-----------------------------------------------------------*/

int main( void )
{
   0:	b580      	push	{r7, lr}
   2:	b082      	sub	sp, #8
   4:	af02      	add	r7, sp, #8
	GlobalVar |= 0x01;
   6:	4b0f      	ldr	r3, [pc, #60]	@ (44 <main+0x44>)
   8:	681b      	ldr	r3, [r3, #0]
   a:	f043 0301 	orr.w	r3, r3, #1
   e:	4a0d      	ldr	r2, [pc, #52]	@ (44 <main+0x44>)
  10:	6013      	str	r3, [r2, #0]
	/* Create the first task at priority 1... */
	xTaskCreate( vTaskFunction, "Task 1", 240, (void*)pcTextForTask1, 1, NULL );
  12:	4b0d      	ldr	r3, [pc, #52]	@ (48 <main+0x48>)
  14:	681b      	ldr	r3, [r3, #0]
  16:	2200      	movs	r2, #0
  18:	9201      	str	r2, [sp, #4]
  1a:	2201      	movs	r2, #1
  1c:	9200      	str	r2, [sp, #0]
  1e:	22f0      	movs	r2, #240	@ 0xf0
  20:	490a      	ldr	r1, [pc, #40]	@ (4c <main+0x4c>)
  22:	480b      	ldr	r0, [pc, #44]	@ (50 <main+0x50>)
  24:	f7ff fffe 	bl	0 <xTaskCreate>

	/* ... and the second task at priority 2.  The priority is the second to
	last parameter. */
	xTaskCreate( vTaskFunction, "Task 2", 240, (void*)pcTextForTask2, 2, NULL );
  28:	4b0a      	ldr	r3, [pc, #40]	@ (54 <main+0x54>)
  2a:	681b      	ldr	r3, [r3, #0]
  2c:	2200      	movs	r2, #0
  2e:	9201      	str	r2, [sp, #4]
  30:	2202      	movs	r2, #2
  32:	9200      	str	r2, [sp, #0]
  34:	22f0      	movs	r2, #240	@ 0xf0
  36:	4908      	ldr	r1, [pc, #32]	@ (58 <main+0x58>)
  38:	4805      	ldr	r0, [pc, #20]	@ (50 <main+0x50>)
  3a:	f7ff fffe 	bl	0 <xTaskCreate>

	/* Start the scheduler so our tasks start executing. */
	vTaskStartScheduler();
  3e:	f7ff fffe 	bl	0 <vTaskStartScheduler>

	for( ;; );
  42:	e7fe      	b.n	42 <main+0x42>
	...
  4c:	00000050 	.word	0x00000050
	...
  58:	00000058 	.word	0x00000058

Disassembly of section .text.vTaskFunction:

00000000 <vTaskFunction>:
	return 0;
}
/*-----------------------------------------------------------*/

void vTaskFunction( void *pvParameters )
{
   0:	b580      	push	{r7, lr}
   2:	b084      	sub	sp, #16
   4:	af00      	add	r7, sp, #0
   6:	6078      	str	r0, [r7, #4]
char *pcTaskName;

	/* The string to print out is passed in via the parameter.  Cast this to a
	character pointer. */
	pcTaskName = ( char * ) pvParameters;
   8:	687b      	ldr	r3, [r7, #4]
   a:	60fb      	str	r3, [r7, #12]
	/* As per most tasks, this task is implemented in an infinite loop. */
	for( ;; )
	{
		/* Print out the name of this task AND the number of times ulIdleCycleCount
        has been incremented. */
		vPrintStringAndNumber( pcTaskName, ulIdleCycleCount );
   c:	4b04      	ldr	r3, [pc, #16]	@ (20 <vTaskFunction+0x20>)
   e:	681b      	ldr	r3, [r3, #0]
  10:	4619      	mov	r1, r3
  12:	68f8      	ldr	r0, [r7, #12]
  14:	f7ff fffe 	bl	0 <vPrintStringAndNumber>

		/* Delay for a period.  This time we use a call to vTaskDelay() which
		puts the task into the Blocked state until the delay period has expired.
		The delay period is specified in 'ticks'. */
		vTaskDelay( 250 / portTICK_RATE_MS );
  18:	20fa      	movs	r0, #250	@ 0xfa
  1a:	f7ff fffe 	bl	0 <vTaskDelay>
		vPrintStringAndNumber( pcTaskName, ulIdleCycleCount );
  1e:	e7f5      	b.n	c <vTaskFunction+0xc>
  20:	00000000 	.word	0x00000000

Disassembly of section .text.vApplicationIdleHook:

00000000 <vApplicationIdleHook>:
/*-----------------------------------------------------------*/

/* Idle hook functions MUST be called vApplicationIdleHook(), take no parameters,
and return void. */
void vApplicationIdleHook( void )
{
   0:	b480      	push	{r7}
   2:	af00      	add	r7, sp, #0
	/* This hook function does nothing but increment a counter. */
	ulIdleCycleCount++;
   4:	4b04      	ldr	r3, [pc, #16]	@ (18 <vApplicationIdleHook+0x18>)
   6:	681b      	ldr	r3, [r3, #0]
   8:	3301      	adds	r3, #1
   a:	4a03      	ldr	r2, [pc, #12]	@ (18 <vApplicationIdleHook+0x18>)
   c:	6013      	str	r3, [r2, #0]
}
   e:	bf00      	nop
  10:	46bd      	mov	sp, r7
  12:	bc80      	pop	{r7}
  14:	4770      	bx	lr
  16:	bf00      	nop
  18:	00000000 	.word	0x00000000

Disassembly of section .text.vApplicationMallocFailedHook:

00000000 <vApplicationMallocFailedHook>:
/*-----------------------------------------------------------*/

void vApplicationMallocFailedHook( void )
{
   0:	b480      	push	{r7}
   2:	af00      	add	r7, sp, #0
	/* This function will only be called if an API call to create a task, queue
	or semaphore fails because there is too little heap RAM remaining. */
	for( ;; );
   4:	e7fe      	b.n	4 <vApplicationMallocFailedHook+0x4>

Disassembly of section .text.vApplicationStackOverflowHook:

00000000 <vApplicationStackOverflowHook>:
}
/*-----------------------------------------------------------*/

void vApplicationStackOverflowHook( TaskHandle_t pxTask, char *pcTaskName )
{
   0:	b480      	push	{r7}
   2:	b083      	sub	sp, #12
   4:	af00      	add	r7, sp, #0
   6:	6078      	str	r0, [r7, #4]
   8:	6039      	str	r1, [r7, #0]
	/* This function will only be called if a task overflows its stack.  Note
	that stack overflow checking does slow down the context switch
	implementation. */
	for( ;; );
   a:	e7fe      	b.n	a <vApplicationStackOverflowHook+0xa>

Disassembly of section .text.vApplicationTickHook:

00000000 <vApplicationTickHook>:
}
/*-----------------------------------------------------------*/

void vApplicationTickHook( void )
{
   0:	b480      	push	{r7}
   2:	af00      	add	r7, sp, #0
	/* This example does not use the tick hook to perform any processing. */
}
   4:	bf00      	nop
   6:	46bd      	mov	sp, r7
   8:	bc80      	pop	{r7}
   a:	4770      	bx	lr