Back to index

glibc  2.9
Defines | Functions
memmove.c File Reference
#include <string.h>
#include <memcopy.h>
#include <pagecopy.h>
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define a1   dest /* First arg is DEST. */
#define a1const
#define a2   src /* Second arg is SRC. */
#define a2const   const
#define RETURN(s)   return (s) /* Return DEST. */
#define rettype   void *

Functions

rettype memmove (a1const void *a1, a2const void *a2, size_t len)

Define Documentation

#define a1   dest /* First arg is DEST. */

Definition at line 29 of file memmove.c.

#define a1const

Definition at line 30 of file memmove.c.

#define a2   src /* Second arg is SRC. */

Definition at line 31 of file memmove.c.

#define a2const   const

Definition at line 32 of file memmove.c.

#define rettype   void *

Definition at line 37 of file memmove.c.

#define RETURN (   s)    return (s) /* Return DEST. */

Definition at line 36 of file memmove.c.


Function Documentation

rettype memmove ( a1const void *  a1,
a2const void *  a2,
size_t  len 
)

Definition at line 42 of file memmove.c.

{
  unsigned long int dstp = (long int) dest;
  unsigned long int srcp = (long int) src;

  /* This test makes the forward copying code be used whenever possible.
     Reduces the working set.  */
  if (dstp - srcp >= len)   /* *Unsigned* compare!  */
    {
      /* Copy from the beginning to the end.  */

      /* If there not too few bytes to copy, use word copy.  */
      if (len >= OP_T_THRES)
       {
         /* Copy just a few bytes to make DSTP aligned.  */
         len -= (-dstp) % OPSIZ;
         BYTE_COPY_FWD (dstp, srcp, (-dstp) % OPSIZ);

         /* Copy whole pages from SRCP to DSTP by virtual address
            manipulation, as much as possible.  */

         PAGE_COPY_FWD_MAYBE (dstp, srcp, len, len);

         /* Copy from SRCP to DSTP taking advantage of the known
            alignment of DSTP.  Number of bytes remaining is put
            in the third argument, i.e. in LEN.  This number may
            vary from machine to machine.  */

         WORD_COPY_FWD (dstp, srcp, len, len);

         /* Fall out and copy the tail.  */
       }

      /* There are just a few bytes to copy.  Use byte memory operations.  */
      BYTE_COPY_FWD (dstp, srcp, len);
    }
  else
    {
      /* Copy from the end to the beginning.  */
      srcp += len;
      dstp += len;

      /* If there not too few bytes to copy, use word copy.  */
      if (len >= OP_T_THRES)
       {
         /* Copy just a few bytes to make DSTP aligned.  */
         len -= dstp % OPSIZ;
         BYTE_COPY_BWD (dstp, srcp, dstp % OPSIZ);

         /* Copy from SRCP to DSTP taking advantage of the known
            alignment of DSTP.  Number of bytes remaining is put
            in the third argument, i.e. in LEN.  This number may
            vary from machine to machine.  */

         WORD_COPY_BWD (dstp, srcp, len, len);

         /* Fall out and copy the tail.  */
       }

      /* There are just a few bytes to copy.  Use byte memory operations.  */
      BYTE_COPY_BWD (dstp, srcp, len);
    }

  RETURN (dest);
}