; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\retarget.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\retarget.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\retarget.crf ..\..\..\..\Platform\RVMDK\Retarget.c]
                          THUMB

                          AREA ||i.__data_GetMemChunk||, CODE, READONLY, ALIGN=1

                  __data_GetMemChunk PROC
;;;408    
;;;409    int __data_GetMemChunk(void)
000000  2000              MOVS     r0,#0
;;;410    {
;;;411    	return 0;
;;;412    }
000002  4770              BX       lr
;;;413    
                          ENDP


                          AREA ||i.__iar_Memchr||, CODE, READONLY, ALIGN=1

                  __iar_Memchr PROC
;;;272    void *
;;;273    MEMCHR (void const *s, int c_in, size_t n)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;274    {
000004  4606              MOV      r6,r0
000006  460f              MOV      r7,r1
;;;275      /* On 32-bit hardware, choosing longword to be a 32-bit unsigned
;;;276         long instead of a 64-bit uintmax_t tends to give better
;;;277         performance.  On 64-bit hardware, unsigned long is generally 64
;;;278         bits already.  Change this typedef to experiment with
;;;279         performance.  */
;;;280      typedef unsigned long int longword;
;;;281    
;;;282      const unsigned char *char_ptr;
;;;283      const longword *longword_ptr;
;;;284      longword repeated_one;
;;;285      longword repeated_c;
;;;286      unsigned char c;
;;;287    
;;;288      c = (unsigned char) c_in;
000008  b2fd              UXTB     r5,r7
;;;289    
;;;290      /* Handle the first few bytes by reading one byte at a time.
;;;291         Do this until CHAR_PTR is aligned on a longword boundary.  */
;;;292      for (char_ptr = (const unsigned char *) s;
00000a  4631              MOV      r1,r6
00000c  e007              B        |L2.30|
                  |L2.14|
;;;293           n > 0 && (size_t) char_ptr % sizeof (longword) != 0;
;;;294           --n, ++char_ptr)
;;;295        if (*char_ptr == c)
00000e  7808              LDRB     r0,[r1,#0]
000010  42a8              CMP      r0,r5
000012  d102              BNE      |L2.26|
;;;296          return (void *) char_ptr;
000014  4608              MOV      r0,r1
                  |L2.22|
;;;297    
;;;298      longword_ptr = (const longword *) char_ptr;
;;;299    
;;;300      /* All these elucidatory comments refer to 4-byte longwords,
;;;301         but the theory applies equally well to any size longwords.  */
;;;302    
;;;303      /* Compute auxiliary longword values:
;;;304         repeated_one is a value which has a 1 in every byte.
;;;305         repeated_c has c in every byte.  */
;;;306      repeated_one = 0x01010101;
;;;307      repeated_c = c | (c << 8);
;;;308      repeated_c |= repeated_c << 16;
;;;309      if (0xffffffffU < (longword) -1)
;;;310        {
;;;311          repeated_one |= repeated_one << 31 << 1;
;;;312          repeated_c |= repeated_c << 31 << 1;
;;;313          if (8 < sizeof (longword))
;;;314    	{
;;;315    	  size_t i;
;;;316    
;;;317    	  for (i = 64; i < sizeof (longword) * 8; i *= 2)
;;;318    	    {
;;;319    	      repeated_one |= repeated_one << i;
;;;320    	      repeated_c |= repeated_c << i;
;;;321    	    }
;;;322    	}
;;;323        }
;;;324    
;;;325      /* Instead of the traditional loop which tests each byte, we will test a
;;;326         longword at a time.  The tricky part is testing if *any of the four*
;;;327         bytes in the longword in question are equal to c.  We first use an xor
;;;328         with repeated_c.  This reduces the task to testing whether *any of the
;;;329         four* bytes in longword1 is zero.
;;;330    
;;;331         We compute tmp =
;;;332           ((longword1 - repeated_one) & ~longword1) & (repeated_one << 7).
;;;333         That is, we perform the following operations:
;;;334           1. Subtract repeated_one.
;;;335           2. & ~longword1.
;;;336           3. & a mask consisting of 0x80 in every byte.
;;;337         Consider what happens in each byte:
;;;338           - If a byte of longword1 is zero, step 1 and 2 transform it into 0xff,
;;;339    	 and step 3 transforms it into 0x80.  A carry can also be propagated
;;;340    	 to more significant bytes.
;;;341           - If a byte of longword1 is nonzero, let its lowest 1 bit be at
;;;342    	 position k (0 <= k <= 7); so the lowest k bits are 0.  After step 1,
;;;343    	 the byte ends in a single bit of value 0 and k bits of value 1.
;;;344    	 After step 2, the result is just k bits of value 1: 2^k - 1.  After
;;;345    	 step 3, the result is 0.  And no carry is produced.
;;;346         So, if longword1 has only non-zero bytes, tmp is zero.
;;;347         Whereas if longword1 has a zero byte, call j the position of the least
;;;348         significant zero byte.  Then the result has a zero at positions 0, ...,
;;;349         j-1 and a 0x80 at position j.  We cannot predict the result at the more
;;;350         significant bytes (positions j+1..3), but it does not matter since we
;;;351         already have a non-zero bit at position 8*j+7.
;;;352    
;;;353         So, the test whether any byte in longword1 is zero is equivalent to
;;;354         testing whether tmp is nonzero.  */
;;;355    
;;;356      while (n >= sizeof (longword))
;;;357        {
;;;358          longword longword1 = *longword_ptr ^ repeated_c;
;;;359    
;;;360          if ((((longword1 - repeated_one) & ~longword1)
;;;361    	   & (repeated_one << 7)) != 0)
;;;362    	break;
;;;363          longword_ptr++;
;;;364          n -= sizeof (longword);
;;;365        }
;;;366    
;;;367      char_ptr = (const unsigned char *) longword_ptr;
;;;368    
;;;369      /* At this point, we know that either n < sizeof (longword), or one of the
;;;370         sizeof (longword) bytes starting at char_ptr is == c.  On little-endian
;;;371         machines, we could determine the first such byte without any further
;;;372         memory accesses, just by looking at the tmp result from the last loop
;;;373         iteration.  But this does not work on big-endian machines.  Choose code
;;;374         that works in both cases.  */
;;;375    
;;;376      for (; n > 0; --n, ++char_ptr)
;;;377        {
;;;378          if (*char_ptr == c)
;;;379    	return (void *) char_ptr;
;;;380        }
;;;381    
;;;382      return NULL;
;;;383    }
000016  e8bd81f0          POP      {r4-r8,pc}
                  |L2.26|
00001a  1e52              SUBS     r2,r2,#1              ;294
00001c  1c49              ADDS     r1,r1,#1              ;294
                  |L2.30|
00001e  b11a              CBZ      r2,|L2.40|
000020  f0010003          AND      r0,r1,#3              ;293
000024  2800              CMP      r0,#0                 ;293
000026  d1f2              BNE      |L2.14|
                  |L2.40|
000028  460b              MOV      r3,r1                 ;298
00002a  f04f3401          MOV      r4,#0x1010101         ;306
00002e  ea452c05          ORR      r12,r5,r5,LSL #8      ;307
000032  ea4c4c0c          ORR      r12,r12,r12,LSL #16   ;308
000036  e010              B        |L2.90|
                  |L2.56|
000038  f8d38000          LDR      r8,[r3,#0]            ;358
00003c  ea88000c          EOR      r0,r8,r12             ;358
000040  eba00804          SUB      r8,r0,r4              ;360
000044  ea280800          BIC      r8,r8,r0              ;360
000048  ea0818c4          AND      r8,r8,r4,LSL #7       ;360
00004c  f1b80f00          CMP      r8,#0                 ;360
000050  d000              BEQ      |L2.84|
000052  e004              B        |L2.94|
                  |L2.84|
000054  1d1b              ADDS     r3,r3,#4              ;363
000056  1f12              SUBS     r2,r2,#4              ;364
000058  bf00              NOP                            ;365
                  |L2.90|
00005a  2a04              CMP      r2,#4                 ;356
00005c  d2ec              BCS      |L2.56|
                  |L2.94|
00005e  bf00              NOP                            ;362
000060  4619              MOV      r1,r3                 ;367
000062  e006              B        |L2.114|
                  |L2.100|
000064  7808              LDRB     r0,[r1,#0]            ;378
000066  42a8              CMP      r0,r5                 ;378
000068  d101              BNE      |L2.110|
00006a  4608              MOV      r0,r1                 ;379
00006c  e7d3              B        |L2.22|
                  |L2.110|
00006e  1e52              SUBS     r2,r2,#1              ;376
000070  1c49              ADDS     r1,r1,#1              ;376
                  |L2.114|
000072  2a00              CMP      r2,#0                 ;376
000074  d1f6              BNE      |L2.100|
000076  2000              MOVS     r0,#0                 ;382
000078  e7cd              B        |L2.22|
;;;384    //mxchipWNET.o
                          ENDP


                          AREA ||i.__iar_Strchr||, CODE, READONLY, ALIGN=2

                  __iar_Strchr PROC
;;;121    char *
;;;122    STRCHR (const char *s, int c_in)
000000  e92d5ff0          PUSH     {r4-r12,lr}
;;;123    {
000004  4682              MOV      r10,r0
000006  468b              MOV      r11,r1
;;;124      const unsigned char *char_ptr;
;;;125      const unsigned long int *longword_ptr;
;;;126      unsigned long int longword, magic_bits, charmask;
;;;127      unsigned char c;
;;;128    
;;;129      c = (unsigned char) c_in;
000008  f00b05ff          AND      r5,r11,#0xff
;;;130    
;;;131      /* Handle the first few characters by reading one character at a time.
;;;132         Do this until CHAR_PTR is aligned on a longword boundary.  */
;;;133      for (char_ptr = (const unsigned char *) s;
00000c  4654              MOV      r4,r10
00000e  e00a              B        |L3.38|
                  |L3.16|
;;;134           ((unsigned long int) char_ptr & (sizeof (longword) - 1)) != 0;
;;;135           ++char_ptr)
;;;136        if (*char_ptr == c)
000010  7820              LDRB     r0,[r4,#0]
000012  42a8              CMP      r0,r5
000014  d102              BNE      |L3.28|
;;;137          return (void *) char_ptr;
000016  4620              MOV      r0,r4
                  |L3.24|
;;;138        else if (*char_ptr == '\0')
;;;139          return NULL;
;;;140    
;;;141      /* All these elucidatory comments refer to 4-byte longwords,
;;;142         but the theory applies equally well to 8-byte longwords.  */
;;;143    
;;;144      longword_ptr = (unsigned long int *) char_ptr;
;;;145    
;;;146      /* Bits 31, 24, 16, and 8 of this number are zero.  Call these bits
;;;147         the "holes."  Note that there is a hole just to the left of
;;;148         each byte, with an extra at the end:
;;;149    
;;;150         bits:  01111110 11111110 11111110 11111111
;;;151         bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD
;;;152    
;;;153         The 1-bits make sure that carries propagate to the next 0-bit.
;;;154         The 0-bits provide holes for carries to fall into.  */
;;;155      switch (sizeof (longword))
;;;156        {
;;;157        case 4: magic_bits = 0x7efefeffL; break;
;;;158        default:
;;;159          abort ();
;;;160        }
;;;161    
;;;162      /* Set up a longword, each of whose bytes is C.  */
;;;163      charmask = c | (c << 8);
;;;164      charmask |= charmask << 16;
;;;165      if (sizeof (longword) > 4)
;;;166        /* Do the shift in two steps to avoid a warning if long has 32 bits.  */
;;;167        charmask |= (charmask << 16) << 16;
;;;168      if (sizeof (longword) > 8)
;;;169        abort ();
;;;170    
;;;171      /* Instead of the traditional loop which tests each character,
;;;172         we will test a longword at a time.  The tricky part is testing
;;;173         if *any of the four* bytes in the longword in question are zero.  */
;;;174      for (;;)
;;;175        {
;;;176          /* We tentatively exit the loop if adding MAGIC_BITS to
;;;177    	 LONGWORD fails to change any of the hole bits of LONGWORD.
;;;178    
;;;179    	 1) Is this safe?  Will it catch all the zero bytes?
;;;180    	 Suppose there is a byte with all zeros.  Any carry bits
;;;181    	 propagating from its left will fall into the hole at its
;;;182    	 least significant bit and stop.  Since there will be no
;;;183    	 carry from its most significant bit, the LSB of the
;;;184    	 byte to the left will be unchanged, and the zero will be
;;;185    	 detected.
;;;186    
;;;187    	 2) Is this worthwhile?  Will it ignore everything except
;;;188    	 zero bytes?  Suppose every byte of LONGWORD has a bit set
;;;189    	 somewhere.  There will be a carry into bit 8.  If bit 8
;;;190    	 is set, this will carry into bit 16.  If bit 8 is clear,
;;;191    	 one of bits 9-15 must be set, so there will be a carry
;;;192    	 into bit 16.  Similarly, there will be a carry into bit
;;;193    	 24.  If one of bits 24-30 is set, there will be a carry
;;;194    	 into bit 31, so all of the hole bits will be changed.
;;;195    
;;;196    	 The one misfire occurs when bits 24-30 are clear and bit
;;;197    	 31 is set; in this case, the hole at bit 31 is not
;;;198    	 changed.  If we had access to the processor carry flag,
;;;199    	 we could close this loophole by putting the fourth hole
;;;200    	 at bit 32!
;;;201    
;;;202    	 So it ignores everything except 128's, when they're aligned
;;;203    	 properly.
;;;204    
;;;205    	 3) But wait!  Aren't we looking for C as well as zero?
;;;206    	 Good point.  So what we do is XOR LONGWORD with a longword,
;;;207    	 each of whose bytes is C.  This turns each byte that is C
;;;208    	 into a zero.  */
;;;209    
;;;210          longword = *longword_ptr++;
;;;211    
;;;212          /* Add MAGIC_BITS to LONGWORD.  */
;;;213          if ((((longword + magic_bits)
;;;214    
;;;215    	    /* Set those bits that were unchanged by the addition.  */
;;;216    	    ^ ~longword)
;;;217    
;;;218    	   /* Look at only the hole bits.  If any of the hole bits
;;;219    	      are unchanged, most likely one of the bytes was a
;;;220    	      zero.  */
;;;221    	   & ~magic_bits) != 0 ||
;;;222    
;;;223    	  /* That caught zeroes.  Now test for C.  */
;;;224    	  ((((longword ^ charmask) + magic_bits) ^ ~(longword ^ charmask))
;;;225    	   & ~magic_bits) != 0)
;;;226    	{
;;;227    	  /* Which of the bytes was C or zero?
;;;228    	     If none of them were, it was a misfire; continue the search.  */
;;;229    
;;;230    	  const unsigned char *cp = (const unsigned char *) (longword_ptr - 1);
;;;231    
;;;232    	  if (*cp == c)
;;;233    	    return (char *) cp;
;;;234    	  else if (*cp == '\0')
;;;235    	    return NULL;
;;;236    	  if (*++cp == c)
;;;237    	    return (char *) cp;
;;;238    	  else if (*cp == '\0')
;;;239    	    return NULL;
;;;240    	  if (*++cp == c)
;;;241    	    return (char *) cp;
;;;242    	  else if (*cp == '\0')
;;;243    	    return NULL;
;;;244    	  if (*++cp == c)
;;;245    	    return (char *) cp;
;;;246    	  else if (*cp == '\0')
;;;247    	    return NULL;
;;;248    	  if (sizeof (longword) > 4)
;;;249    	    {
;;;250    	      if (*++cp == c)
;;;251    		return (char *) cp;
;;;252    	      else if (*cp == '\0')
;;;253    		return NULL;
;;;254    	      if (*++cp == c)
;;;255    		return (char *) cp;
;;;256    	      else if (*cp == '\0')
;;;257    		return NULL;
;;;258    	      if (*++cp == c)
;;;259    		return (char *) cp;
;;;260    	      else if (*cp == '\0')
;;;261    		return NULL;
;;;262    	      if (*++cp == c)
;;;263    		return (char *) cp;
;;;264    	      else if (*cp == '\0')
;;;265    		return NULL;
;;;266    	    }
;;;267    	}
;;;268      }
;;;269    }
000018  e8bd9ff0          POP      {r4-r12,pc}
                  |L3.28|
00001c  7820              LDRB     r0,[r4,#0]            ;138
00001e  b908              CBNZ     r0,|L3.36|
000020  2000              MOVS     r0,#0                 ;139
000022  e7f9              B        |L3.24|
                  |L3.36|
000024  1c64              ADDS     r4,r4,#1              ;135
                  |L3.38|
000026  f0040003          AND      r0,r4,#3              ;134
00002a  2800              CMP      r0,#0                 ;134
00002c  d1f0              BNE      |L3.16|
00002e  46a0              MOV      r8,r4                 ;144
000030  2004              MOVS     r0,#4                 ;155
000032  2804              CMP      r0,#4                 ;155
000034  d101              BNE      |L3.58|
000036  4f24              LDR      r7,|L3.200|
000038  e001              B        |L3.62|
                  |L3.58|
00003a  f7fffffe          BL       abort
                  |L3.62|
00003e  bf00              NOP                            ;157
000040  ea452905          ORR      r9,r5,r5,LSL #8       ;163
000044  ea494909          ORR      r9,r9,r9,LSL #16      ;164
000048  bf00              NOP                            ;174
                  |L3.74|
00004a  f8586b04          LDR      r6,[r8],#4            ;210
00004e  19f0              ADDS     r0,r6,r7              ;213
000050  43f1              MVNS     r1,r6                 ;213
000052  4048              EORS     r0,r0,r1              ;213
000054  43b8              BICS     r0,r0,r7              ;213
000056  b948              CBNZ     r0,|L3.108|
000058  ea860009          EOR      r0,r6,r9              ;224
00005c  4438              ADD      r0,r0,r7              ;224
00005e  ea860109          EOR      r1,r6,r9              ;224
000062  43c9              MVNS     r1,r1                 ;224
000064  4048              EORS     r0,r0,r1              ;224
000066  43b8              BICS     r0,r0,r7              ;224
000068  2800              CMP      r0,#0                 ;224
00006a  d0ee              BEQ      |L3.74|
                  |L3.108|
00006c  f1a80104          SUB      r1,r8,#4              ;230
000070  7808              LDRB     r0,[r1,#0]            ;232
000072  42a8              CMP      r0,r5                 ;232
000074  d101              BNE      |L3.122|
000076  4608              MOV      r0,r1                 ;233
000078  e7ce              B        |L3.24|
                  |L3.122|
00007a  7808              LDRB     r0,[r1,#0]            ;234
00007c  b908              CBNZ     r0,|L3.130|
00007e  2000              MOVS     r0,#0                 ;235
000080  e7ca              B        |L3.24|
                  |L3.130|
000082  1c48              ADDS     r0,r1,#1              ;236
000084  4601              MOV      r1,r0                 ;236
000086  7800              LDRB     r0,[r0,#0]            ;236
000088  42a8              CMP      r0,r5                 ;236
00008a  d101              BNE      |L3.144|
00008c  4608              MOV      r0,r1                 ;237
00008e  e7c3              B        |L3.24|
                  |L3.144|
000090  7808              LDRB     r0,[r1,#0]            ;238
000092  b908              CBNZ     r0,|L3.152|
000094  2000              MOVS     r0,#0                 ;239
000096  e7bf              B        |L3.24|
                  |L3.152|
000098  1c48              ADDS     r0,r1,#1              ;240
00009a  4601              MOV      r1,r0                 ;240
00009c  7800              LDRB     r0,[r0,#0]            ;240
00009e  42a8              CMP      r0,r5                 ;240
0000a0  d101              BNE      |L3.166|
0000a2  4608              MOV      r0,r1                 ;241
0000a4  e7b8              B        |L3.24|
                  |L3.166|
0000a6  7808              LDRB     r0,[r1,#0]            ;242
0000a8  b908              CBNZ     r0,|L3.174|
0000aa  2000              MOVS     r0,#0                 ;243
0000ac  e7b4              B        |L3.24|
                  |L3.174|
0000ae  1c48              ADDS     r0,r1,#1              ;244
0000b0  4601              MOV      r1,r0                 ;244
0000b2  7800              LDRB     r0,[r0,#0]            ;244
0000b4  42a8              CMP      r0,r5                 ;244
0000b6  d101              BNE      |L3.188|
0000b8  4608              MOV      r0,r1                 ;245
0000ba  e7ad              B        |L3.24|
                  |L3.188|
0000bc  7808              LDRB     r0,[r1,#0]            ;246
0000be  b908              CBNZ     r0,|L3.196|
0000c0  2000              MOVS     r0,#0                 ;247
0000c2  e7a9              B        |L3.24|
                  |L3.196|
0000c4  e7c1              B        |L3.74|
;;;270    
                          ENDP

0000c6  0000              DCW      0x0000
                  |L3.200|
                          DCD      0x7efefeff

                          AREA ||i.__iar_Strrchr||, CODE, READONLY, ALIGN=1

                  __iar_Strrchr PROC
;;;99     char *
;;;100    STRRCHR (const char *s, int c)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;101    {
000004  4607              MOV      r7,r0
000006  460d              MOV      r5,r1
;;;102      const char *found, *p;
;;;103    
;;;104      c = (unsigned char) c;
000008  b2ed              UXTB     r5,r5
;;;105    
;;;106      /* Since strchr is fast, we use it rather than the obvious loop.  */
;;;107    
;;;108      if (c == '\0')
00000a  b92d              CBNZ     r5,|L4.24|
;;;109        return strchr (s, '\0');
00000c  2100              MOVS     r1,#0
00000e  4638              MOV      r0,r7
000010  f7fffffe          BL       strchr
                  |L4.20|
;;;110    
;;;111      found = NULL;
;;;112      while ((p = strchr (s, c)) != NULL)
;;;113        {
;;;114          found = p;
;;;115          s = p + 1;
;;;116        }
;;;117    
;;;118      return (char *) found;
;;;119    }
000014  e8bd81f0          POP      {r4-r8,pc}
                  |L4.24|
000018  2600              MOVS     r6,#0                 ;111
00001a  e001              B        |L4.32|
                  |L4.28|
00001c  4626              MOV      r6,r4                 ;114
00001e  1c67              ADDS     r7,r4,#1              ;115
                  |L4.32|
000020  4629              MOV      r1,r5                 ;112
000022  4638              MOV      r0,r7                 ;112
000024  f7fffffe          BL       strchr
000028  0004              MOVS     r4,r0                 ;112
00002a  d1f7              BNE      |L4.28|
00002c  4630              MOV      r0,r6                 ;118
00002e  e7f1              B        |L4.20|
;;;120    
                          ENDP


                          AREA ||i.__iar_Strstr||, CODE, READONLY, ALIGN=1

                  __iar_Strstr PROC
;;;69     // logging.o
;;;70     char* __iar_Strstr(char* s1, char* s2)
000000  b510              PUSH     {r4,lr}
;;;71     {  
000002  4602              MOV      r2,r0
;;;72         int n;  
;;;73         if (*s2)  
000004  7808              LDRB     r0,[r1,#0]
000006  b188              CBZ      r0,|L5.44|
;;;74         {  
;;;75             while (*s1)  
000008  e00c              B        |L5.36|
                  |L5.10|
;;;76             {  
;;;77                 for (n=0; *(s1 + n) == *(s2 + n); n++)  
00000a  2300              MOVS     r3,#0
00000c  e005              B        |L5.26|
                  |L5.14|
;;;78                 {  
;;;79                     if (!*(s2 + n + 1))  
00000e  18c8              ADDS     r0,r1,r3
000010  7840              LDRB     r0,[r0,#1]
000012  b908              CBNZ     r0,|L5.24|
;;;80                         return (char *)s1;  
000014  4610              MOV      r0,r2
                  |L5.22|
;;;81                 }  
;;;82                 s1++;  
;;;83             }  
;;;84             return NULL;  
;;;85         }  
;;;86         else  
;;;87             return (char *)s1;  
;;;88     }  
000016  bd10              POP      {r4,pc}
                  |L5.24|
000018  1c5b              ADDS     r3,r3,#1              ;77
                  |L5.26|
00001a  5cd0              LDRB     r0,[r2,r3]            ;77
00001c  5ccc              LDRB     r4,[r1,r3]            ;77
00001e  42a0              CMP      r0,r4                 ;77
000020  d0f5              BEQ      |L5.14|
000022  1c52              ADDS     r2,r2,#1              ;82
                  |L5.36|
000024  7810              LDRB     r0,[r2,#0]            ;75
000026  2800              CMP      r0,#0                 ;75
000028  d1ef              BNE      |L5.10|
00002a  e7f4              B        |L5.22|
                  |L5.44|
00002c  4610              MOV      r0,r2                 ;87
00002e  e7f2              B        |L5.22|
;;;89     
                          ENDP


                          AREA ||i.__iar_dlmallinfo||, CODE, READONLY, ALIGN=1

                  __iar_dlmallinfo PROC
;;;388    
;;;389    __weak void *__iar_dlmallinfo(void)
000000  2000              MOVS     r0,#0
;;;390    {
;;;391        return NULL;
;;;392    }
000002  4770              BX       lr
;;;393    
                          ENDP


                          AREA ||i._sys_command_string||, CODE, READONLY, ALIGN=1

                  _sys_command_string PROC
;;;61     
;;;62     char *_sys_command_string(char * cmd, int len) 
000000  4602              MOV      r2,r0
;;;63     {
;;;64         cmd = cmd;
000002  bf00              NOP      
;;;65         len = len;
000004  bf00              NOP      
;;;66         return 0;
000006  2000              MOVS     r0,#0
;;;67     }
000008  4770              BX       lr
;;;68     
                          ENDP


                          AREA ||i._sys_exit||, CODE, READONLY, ALIGN=1

                  _sys_exit PROC
;;;51     
;;;52     void _sys_exit(int return_code) {
000000  bf00              NOP      
                  |L8.2|
;;;53     label:  goto label;  /* endless loop */
000002  e7fe              B        |L8.2|
;;;54     }
;;;55     
                          ENDP


                          AREA ||i._ttywrch||, CODE, READONLY, ALIGN=1

                  _ttywrch PROC
;;;46     
;;;47     void _ttywrch(int ch) {
000000  4770              BX       lr
;;;48       return;
;;;49     }
;;;50     
                          ENDP


                          AREA ||i.aes_decrypt||, CODE, READONLY, ALIGN=1

                  aes_decrypt PROC
;;;393    
;;;394    __weak int aes_decrypt(void)
000000  2000              MOVS     r0,#0
;;;395    {
;;;396        return 0;
;;;397    }
000002  4770              BX       lr
;;;398    
                          ENDP


                          AREA ||i.ferror||, CODE, READONLY, ALIGN=1

                  ferror PROC
;;;40     
;;;41     int ferror(FILE *f) {
000000  4601              MOV      r1,r0
;;;42       /* Your implementation of ferror */
;;;43       return EOF;
000002  f04f30ff          MOV      r0,#0xffffffff
;;;44     }
000006  4770              BX       lr
;;;45     
                          ENDP


                          AREA ||i.fgetc||, CODE, READONLY, ALIGN=1

                  fgetc PROC
;;;35     
;;;36     int fgetc(FILE *f) {
000000  4601              MOV      r1,r0
;;;37       return 0x30;
000002  2030              MOVS     r0,#0x30
;;;38     }
000004  4770              BX       lr
;;;39     
                          ENDP


                          AREA ||i.fputc||, CODE, READONLY, ALIGN=1

                  fputc PROC
;;;55     
;;;56     int fputc(int ch, FILE *f) {
000000  b513              PUSH     {r0,r1,r4,lr}
000002  460c              MOV      r4,r1
;;;57       MicoUartSend( STDIO_UART, &ch, 1 );
000004  2201              MOVS     r2,#1
000006  4669              MOV      r1,sp
000008  2000              MOVS     r0,#0
00000a  f7fffffe          BL       MicoUartSend
;;;58       return ch;
00000e  9800              LDR      r0,[sp,#0]
;;;59     }
000010  bd1c              POP      {r2-r4,pc}
;;;60     
                          ENDP


                          AREA ||i.is_nfc_up||, CODE, READONLY, ALIGN=1

                  is_nfc_up PROC
;;;384    //mxchipWNET.o
;;;385    int is_nfc_up(void){
000000  2000              MOVS     r0,#0
;;;386        return 0;
;;;387    }
000002  4770              BX       lr
;;;388    
                          ENDP


                          AREA ||i.mico_platform_get_rtc_time||, CODE, READONLY, ALIGN=1

                  mico_platform_get_rtc_time PROC
;;;433    
;;;434    int mico_platform_get_rtc_time (){
000000  2001              MOVS     r0,#1
;;;435        return 1;
;;;436    }
000002  4770              BX       lr
;;;437    int mico_platform_set_rtc_time (){
                          ENDP


                          AREA ||i.mico_platform_set_rtc_time||, CODE, READONLY, ALIGN=1

                  mico_platform_set_rtc_time PROC
;;;436    }
;;;437    int mico_platform_set_rtc_time (){
000000  2000              MOVS     r0,#0
;;;438        return 0;
;;;439    }
000002  4770              BX       lr
;;;440    
                          ENDP


                          AREA ||i.nfc_config_stop||, CODE, READONLY, ALIGN=1

                  nfc_config_stop PROC
;;;398    
;;;399    int nfc_config_stop(void)
000000  2000              MOVS     r0,#0
;;;400    {
;;;401        return 0;
;;;402    }
000002  4770              BX       lr
;;;403    
                          ENDP


                          AREA ||i.strdup||, CODE, READONLY, ALIGN=1

                  strdup PROC
;;;414    
;;;415    char *strdup(const char *src)
000000  b570              PUSH     {r4-r6,lr}
;;;416    {
000002  4604              MOV      r4,r0
;;;417      int len;
;;;418      char *dst;
;;;419      
;;;420      if (src == NULL)
000004  b90c              CBNZ     r4,|L18.10|
;;;421        return NULL;
000006  2000              MOVS     r0,#0
                  |L18.8|
;;;422      
;;;423      if (src[0] == 0)
;;;424        return NULL;
;;;425      
;;;426      len = strlen(src) + 1;
;;;427      dst = (char*)malloc(len);
;;;428      if (dst) 
;;;429        memcpy(dst, src, len);
;;;430      return dst;
;;;431    }
000008  bd70              POP      {r4-r6,pc}
                  |L18.10|
00000a  7820              LDRB     r0,[r4,#0]            ;423
00000c  b908              CBNZ     r0,|L18.18|
00000e  2000              MOVS     r0,#0                 ;424
000010  e7fa              B        |L18.8|
                  |L18.18|
000012  4620              MOV      r0,r4                 ;426
000014  f7fffffe          BL       strlen
000018  1c45              ADDS     r5,r0,#1              ;426
00001a  4628              MOV      r0,r5                 ;427
00001c  f7fffffe          BL       malloc
000020  4606              MOV      r6,r0                 ;427
000022  b126              CBZ      r6,|L18.46|
000024  462a              MOV      r2,r5                 ;429
000026  4621              MOV      r1,r4                 ;429
000028  4630              MOV      r0,r6                 ;429
00002a  f7fffffe          BL       __aeabi_memcpy
                  |L18.46|
00002e  4630              MOV      r0,r6                 ;430
000030  e7ea              B        |L18.8|
;;;432    
                          ENDP


                          AREA ||i.uart_init||, CODE, READONLY, ALIGN=1

                  uart_init PROC
;;;403    
;;;404    int uart_init(void)
000000  2000              MOVS     r0,#0
;;;405    {
;;;406        return 0;
;;;407    }
000002  4770              BX       lr
;;;408    
                          ENDP


                          AREA ||.data||, DATA, ALIGN=2

                  __stdout
                          DCD      0x00000000
                  __stdin
                          DCD      0x00000000
                  __stderr
                          DCD      0x00000000

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Platform\\RVMDK\\Retarget.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___10_Retarget_c_fgetc____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___10_Retarget_c_fgetc____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___10_Retarget_c_fgetc____REVSH|
#line 128
|__asm___10_Retarget_c_fgetc____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
