memcpy.c File Reference

Copy a block of memory, handling overlap. More...

#include "amathc.h"

Include dependency graph for memcpy.c:

Go to the source code of this file.

Macros
#define	TLOOP(s)   if (t) TLOOP1(s)
	loop-t-times More...
#define	TLOOP1(s)   do { s; } while (--t)
	loop-t-times, t>0 More...

Typedefs
typedef uint32_t	word
	sizeof(word) MUST BE A POWER OF TWO SO THAT wmask BELOW IS ALL ONES More...
typedef uintptr_t	mem_ptr

Functions
void	MemCopy (void *destination, const void *source, unsigned int length)
	Copy a block of memory, handling overlap. More...

Detailed Description

Copy a block of memory, handling overlap.

Code originate from FreeBSD base, revision 229286.

The original source code can be obtained from: https://svnweb.freebsd.org/base/head/lib/libc/string/bcopy.c?revision=229286

Definition in file memcpy.c.

Macro Definition Documentation

TLOOP

#define TLOOP

(

s

)

if (t) TLOOP1(s)

loop-t-times

Definition at line 65 of file memcpy.c.

TLOOP1

#define TLOOP1

(

s

)

do { s; } while (--t)

loop-t-times, t>0

Definition at line 70 of file memcpy.c.

Typedef Documentation

mem_ptr

typedef uintptr_t mem_ptr

Definition at line 60 of file memcpy.c.

word

typedef uint32_t word

sizeof(word) MUST BE A POWER OF TWO SO THAT wmask BELOW IS ALL ONES

Definition at line 59 of file memcpy.c.

Function Documentation

MemCopy()

void MemCopy	(	void *	destination,
		const void *	source,
		unsigned int	length
	)

Copy a block of memory, handling overlap.

Definition at line 75 of file memcpy.c.

Referenced by CharBuffer::EnsureSize(), Lexer::GetDigitValue(), Lexer::GetLiteral(), Lexer::GetQuotedIdent(), DecimalSystem::GetText(), and Language::UntagText().

{
    char* dst = (char*) destination;
    const char* src = (const char*) source;
    unsigned int t;

    if (length == 0 || dst == src) // nothing to do
        return;

    if ((mem_ptr)dst < (mem_ptr)src)
    {
        // Copy forward
#if defined(AMIGA) // Take advantage of exec
        CopyMem((void*)source, destination, length);
#else
        t = (mem_ptr)src; // only need low bits
        if ((t | (mem_ptr)dst) & wmask)
        {
            // Try to align operands.  This cannot be done unless the low bits match.
            if ((t ^ (mem_ptr)dst) & wmask || length < wsize)
                t = length;
            else
                t = wsize - (t & wmask);
            length -= t;

            TLOOP1(*dst++ = *src++);
        }

        // Copy whole words, then mop up any trailing bytes.
        t = length / wsize;
        TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);

        t = length & wmask;
        TLOOP(*dst++ = *src++);
#endif
    }
    else
    {
        // Copy backwards.  Otherwise essentially the same.
        // Alignment works as before, except that it takes
        // (t&wmask) bytes to align, not wsize-(t&wmask).
        src += length;
        dst += length;
        t = (mem_ptr)src;
        if ((t | (mem_ptr)dst) & wmask)
        {
            if ((t ^ (mem_ptr)dst) & wmask || length <= wsize)
                t = length;
            else
                t &= wmask;
            length -= t;

            TLOOP1(*--dst = *--src);
        }

        t = length / wsize;
        TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);

        t = length & wmask;
        TLOOP(*--dst = *--src);
    }
}

Here is the caller graph for this function: