static void memcpy_burst( U32 *pDest, U32 *pSrc, U32 size )
{
    U32  wCnt = (size + 3) >> 2; // words count to be copied
    do
    {
        *pDest++ = *pSrc++;
    } while (--wCnt);
}

   258: static void memcpy_burst( U32 *pDest, U32 *pSrc, U32 size )
   259: {
0x00001EC0  E92D0010  STMDB     R13!,{R4}
0x00001EC4  E1A03002  MOV       R3,R2
   260:     U32  wCnt = (size + 3) >> 2; // words count to be copied
0x00001EC8  E1A02003  MOV       R2,R3
0x00001ECC  E2822003  ADD       R2,R2,#0x00000003
0x00001ED0  E1A02122  MOV       R2,R2,LSR #2
   261:     do
   262:     {
   263:         *pDest++ = *pSrc++;
0x00001ED4  E1A03001  MOV       R3,R1
0x00001ED8  E2831004  ADD       R1,R3,#0x00000004
0x00001EDC  E5934000  LDR       R4,[R3]
0x00001EE0  E1A03000  MOV       R3,R0
0x00001EE4  E2830004  ADD       R0,R3,#0x00000004
0x00001EE8  E5834000  STR       R4,[R3]
   264:     } while (--wCnt);
0x00001EEC  E1A03002  MOV       R3,R2
0x00001EF0  E2433001  SUB       R3,R3,#0x00000001
0x00001EF4  E1A02003  MOV       R2,R3
0x00001EF8  E3530000  CMP       R3,#0x00000000
0x00001EFC  1AFFFFF4  BNE       0x00001ED4
   265: }

   258: static void memcpy_burst( U32 *pDest, U32 *pSrc, U32 size )
   259: {
0x00001EC0  B410      PUSH      {R4}
0x00001EC2  1C13      ADD       R3,R2,#0
   260:     U32  wCnt = (size + 3) >> 2; // words count to be copied
0x00001EC4  1C1A      ADD       R2,R3,#0
0x00001EC6  3203      ADD       R2,#0x03
0x00001EC8  0892      LSR       R2,R2,#2
   261:     do
   262:     {
   263:         *pDest++ = *pSrc++;
0x00001ECA  1C0B      ADD       R3,R1,#0
0x00001ECC  3104      ADD       R1,#0x04
0x00001ECE  681C      LDR       R4,[R3,#0x00]
0x00001ED0  1C03      ADD       R3,R0,#0
0x00001ED2  3004      ADD       R0,#0x04
0x00001ED4  601C      STR       R4,[R3,#0x00]
   264:     } while (--wCnt);
0x00001ED6  1C13      ADD       R3,R2,#0
0x00001ED8  3B01      SUB       R3,#0x01
0x00001EDA  1C1A      ADD       R2,R3,#0
0x00001EDC  2B00      CMP       R3,#0x00
0x00001EDE  D1F4      BNE       0x00001ECA
   265: }

NAME memcpy

RSEG CSTACK:DATA:NOROOT(2)

MULTWEAK ??memcpy??rT
MULTWEAK ??memmove??rT
PUBLIC memcpy
PUBLIC memmove

memcpy SYMBOL "memcpy"
??memcpy??rT SYMBOL "??rT", memcpy

memmove SYMBOL "memmove"
??memmove??rT SYMBOL "??rT", memmove


RSEG CODE:CODE:NOROOT(2)
THUMB
??memcpy??rT:
BX PC
Nop
REQUIRE memcpy


RSEG CODE:CODE:NOROOT(2)
ARM

#ifndef configUSE_MEMCPY8W
#define WORDS8_TRANSFER 0
#else
#if configUSE_MEMCPY8W == 1
#define WORDS8_TRANSFER 1
#else
#define WORDS8_TRANSFER 0
#endif
#endif

//---------------------------------------------------------------------------
// void *(memcpy)(void *p1, const void *p2, size_t n)
// Copy char p2[n] to p1[n]
//---------------------------------------------------------------------------
memcpy:
teq r2,#0 // Is p1 == 0 ?
bxeq lr // If p1 == 0, return

stmdb sp!,{lr} // Push return address
mov r12,r0 // Copy pointer p1
cmp r2,#8 // Is buffer long or short?
ble byteserial // Jump if n <= 8

sub r3,r0,r1 // Compare pointers p1, p2
tst r3,#3 // Strings aligned same?
bne byteserial // Jump if buffers not aligned


// Both strings are similarly aligned WRT word boundaries.
// At least a portion of the data can be copied an entire
// word at a time, which is faster than copying bytes.
wordserial:
ands r3,r0,#3 // Check byte alignment
beq wordaligned // Jump if p1, p2 word-aligned

rsb r3,r3,#4 // m = no. of odd initial bytes
sub r2,r2,r3 // n = n - m


// If the two buffers do not begin on word boundaries, begin
// by copying the odd bytes that precede the first full word.
preloop:
ldrb lr,[r1],#1 // Read byte from source
subs r3,r3,#1 // --m (decrement loop count)
strb lr,[r12],#1 // Write byte to destination
bne preloop // Loop if more bytes to move


wordaligned:
#if WORDS8_TRANSFER == 1
movs r3,r2,asr #5 // Any chunks of 8 words?
beq octsdone // Jump if no 8-word chunks

and r2,r2,#0x1F // Subtract chunks from n
stmdb sp!,{r4-r10} // Save registers on stack


// The strings are long enough that we can transfer at least
// some portion of the data in 8-word chunks.
octloop:
ldmia r1!,{r4-r10,lr} // Load 8 words from source
subs r3,r3,#1 // More 8-word chunks to move?
stmia r12!,{r4-r10,lr} // Write 8 words to destination
bne octloop // Loop if more chunks

ldmia sp!,{r4-r10} // Restore registers from stack

octsdone:
#endif
movs r3,r2,asr #2 // Any more whole words to move?
beq wordsdone // Jump if no more whole words


// Copy as much of the remaining data as possible one word at
// a time.
wordloop2:
ldr lr,[r1],#4 // Read next word from source
subs r3,r3,#1 // Decrement word count
str lr,[r12],#4 // Write next word to destination
bne wordloop2 // Loop while more words to move

wordsdone:
ands r2,r2,#3 // Any last bytes to transfer?
beq theend // Return if already done


// The two strings do not end on word boundaries.
// Copy the remaining data one byte at a time.
byteserial:
ldrb lr,[r1],#1 // Read byte from source
subs r2,r2,#1 // --n (decrement loop count)
strb lr,[r12],#1 // Write byte to destination
bne byteserial // Loop if more bytes to move

theend:
ldmia sp!,{lr} // Return
bx lr

//---------------------------------------------------------------------------
RSEG CODE:CODE:NOROOT(2)
THUMB
??memmove??rT:
BX PC
Nop
REQUIRE memmove


RSEG CODE:CODE:NOROOT(2)
ARM

//---------------------------------------------------------------------------
// Safely copy c bytes from source s to destination d.
// void *memmove(void *d, const void *s, unsigned c);
//---------------------------------------------------------------------------
memmove:
cmp r0,r1 // Is d > s ?
bls memcpy // Jump to memcpy if d <= s

// Need to copy backwards, starting at tail ends of source and
// destination arrays. Copy a word or a byte at a time?
orr r3,r1,r0 // tmp = s | d
orr r3,r3,r2 // tmp = s | d | c
ands r3,r3,#3 // Is tmp even multiple of 4?

add r1,r1,r2 // s + c (end of source buffer)
add r2,r2,r0 // d + c (end of dest'n buffer)
beq move1 // Jump if tmp is multiple of 4
b move2

// Because the source and destination arrays are not aligned to even
// word boundaries in memory, transfer only a byte at a time.
move3:
ldrb r3,[r1,#-1]! // Load next byte from source
strb r3,[r2,#-1]! // Store next byte to dest'n
move2:
teq r0,r2 // More bytes to move?
bne move3 // Jump if more bytes
bx lr // All done

// Because count c is an even multiple of 4 and the source
// and destination arrays begin on even word boundaries, move
// an entire word at a time from source to destination.
move4:
ldr r3,[r1,#-4]! // Load next word from source
str r3,[r2,#-4]! // Store next word to dest'n
move1:
teq r0,r2 // More words to move?
bne move4 // Jump if more words

bx lr // All done

END

    623          __arm void memcpy_burst( U32 *pDest, U32 *pSrc, U32 size )
    624          {
    625            U32  wCnt = (size + 3) >> 2; // words count to be copied
   \                     memcpy_burst:
   \   00000000   032082E2           ADD      R2,R2,#+3
   \   00000004   2221A0E1           LSR      R2,R2,#+2
    626            do
    627            {
    628              *pDest++ = *pSrc++;
   \                     ??memcpy_burst_0:
   \   00000008   ........           LDR      R3,[R1], #+4
   \   0000000C   ........           STR      R3,[R0], #+4
    629            } while (--wCnt);
   \   00000010   012052E2           SUBS     R2,R2,#+1
   \   00000014   FBFFFF1A           BNE      ??memcpy_burst_0
    630          }
   \   00000018   0EF0A0E1           MOV      PC,LR           ;; return

    623          __thumb void memcpy_burst( U32 *pDest, U32 *pSrc, U32 size )
    624          {
    625            U32  wCnt = (size + 3) >> 2; // words count to be copied
   \                     memcpy_burst:
   \   00000000   D21C               ADDS     R2,R2,#+3
   \   00000002   9208               LSRS     R2,R2,#+2
    626            do
    627            {
    628              *pDest++ = *pSrc++;
   \                     ??memcpy_burst_0:
   \   00000004   0B68               LDR      R3,[R1, #+0]
   \   00000006   0360               STR      R3,[R0, #+0]
   \   00000008   091D               ADDS     R1,R1,#+4
   \   0000000A   001D               ADDS     R0,R0,#+4
    629            } while (--wCnt);
   \   0000000C   521E               SUBS     R2,R2,#+1
   \   0000000E   F9D1               BNE      ??memcpy_burst_0
    630          }
   \   00000010   7047               BX       LR

typedef struct __DATALIST
{
   struct __DATALIST *next;  /* next datalist */
   void  *data;  /* adress for data */
   UINT data_len; /* lenght for this data in bytes */
   UINT total_len; /* total lenght for all data in datalist */

} DATALIST;

/* Fill IP header */
hIP.vihl = socket->vihl;
hIP.tos = socket->tos;
hIP.tlen = SWAP16(sizeof(IP_HEADER) +  sizeof(TCP_HEADER) + data_len);
hIP.id = IP_GetNextPacketID();
hIP.frags = 0;
hIP.ttl  = socket->ttl; /* ttl */
hIP.protocol  = IP_TCP; /* packet protocol */
hIP.src_ip = HOST_IP(); /* My IP */
hIP.dest_ip = arp_entry->ip; /* Dest IP */

/* Make checksum */
hIP.checksum  = 0;  
hIP.checksum  = (UINT16)~IP_MakeChecksum(0, &hIP, sizeof(IP_HEADER));

/* Fill TCP header */
hTCP.src_port  = socket->src_port;
hTCP.dest_port = socket->dest_port;
hTCP.seqno = SWAP32(socket->send_unacked);
hTCP.ackno = SWAP32(socket->receive_next);
hTCP.hlen = (sizeof(TCP_HEADER) << 2) & 0xfc;
hTCP.window = SWAP16(socket->window);
hTCP.urgent = 0;
if(flags) /* If flags are sets, we update them, differently we leave old */
hTCP.flags = flags;
hTCP.checksum = TCP_MakeChecksum(&hIP, &hTCP, data);