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
Comments
0 B
|👍
/👎
0 B
|👍
/👎
0 B
|👍
/👎
0 B
|👍
/👎
0 B
|0 👍
/0 👎
0 B
|👍
/👎
0 B
|0 👍
/0 👎