Back to index

glibc  2.9
Defines | Typedefs | Functions
memcopy.h File Reference
#include <sys/cdefs.h>
#include <endian.h>
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define op_t   unsigned long int
#define OPSIZ   (sizeof(op_t))
#define reg_char   char
#define MERGE(w0, sh_1, w1, sh_2)   (((w0) >> (sh_1)) | ((w1) << (sh_2)))
#define MERGE(w0, sh_1, w1, sh_2)   (((w0) << (sh_1)) | ((w1) >> (sh_2)))
#define BYTE_COPY_FWD(dst_bp, src_bp, nbytes)
#define BYTE_COPY_BWD(dst_ep, src_ep, nbytes)
#define WORD_COPY_FWD(dst_bp, src_bp, nbytes_left, nbytes)
#define WORD_COPY_BWD(dst_ep, src_ep, nbytes_left, nbytes)
#define OP_T_THRES   16

Typedefs

typedef unsigned char byte

Functions

void _wordcopy_fwd_aligned (long int, long int, size_t) __THROW
void _wordcopy_fwd_dest_aligned (long int, long int, size_t) __THROW
void _wordcopy_bwd_aligned (long int, long int, size_t) __THROW
void _wordcopy_bwd_dest_aligned (long int, long int, size_t) __THROW

Define Documentation

#define BYTE_COPY_BWD (   dst_ep,
  src_ep,
  nbytes 
)
Value:
do                                                                   \
    {                                                                \
      size_t __nbytes = (nbytes);                                    \
      while (__nbytes > 0)                                           \
       {                                                             \
	  byte __x;                                                  \
         src_ep -= 1;                                                       \
         __x = ((byte *) src_ep)[0];                                        \
         dst_ep -= 1;                                                       \
         __nbytes -= 1;                                              \
         ((byte *) dst_ep)[0] = __x;                                        \
       }                                                             \
    } while (0)

Definition at line 95 of file memcopy.h.

#define BYTE_COPY_FWD (   dst_bp,
  src_bp,
  nbytes 
)
Value:
do                                                                   \
    {                                                                \
      size_t __nbytes = (nbytes);                                    \
      while (__nbytes > 0)                                           \
       {                                                             \
	  byte __x = ((byte *) src_bp)[0];                                  \
         src_bp += 1;                                                       \
         __nbytes -= 1;                                              \
         ((byte *) dst_bp)[0] = __x;                                        \
         dst_bp += 1;                                                       \
       }                                                             \
    } while (0)

Definition at line 77 of file memcopy.h.

#define MERGE (   w0,
  sh_1,
  w1,
  sh_2 
)    (((w0) >> (sh_1)) | ((w1) << (sh_2)))

Definition at line 72 of file memcopy.h.

#define MERGE (   w0,
  sh_1,
  w1,
  sh_2 
)    (((w0) << (sh_1)) | ((w1) >> (sh_2)))

Definition at line 72 of file memcopy.h.

#define op_t   unsigned long int

Definition at line 59 of file memcopy.h.

#define OP_T_THRES   16

Definition at line 150 of file memcopy.h.

#define OPSIZ   (sizeof(op_t))

Definition at line 60 of file memcopy.h.

#define reg_char   char

Definition at line 66 of file memcopy.h.

#define WORD_COPY_BWD (   dst_ep,
  src_ep,
  nbytes_left,
  nbytes 
)
Value:
do                                                                   \
    {                                                                \
      if (src_ep % OPSIZ == 0)                                              \
       _wordcopy_bwd_aligned (dst_ep, src_ep, (nbytes) / OPSIZ);            \
      else								      \
	_wordcopy_bwd_dest_aligned (dst_ep, src_ep, (nbytes) / OPSIZ);             \
      src_ep -= (nbytes) & -OPSIZ;                                   \
      dst_ep -= (nbytes) & -OPSIZ;                                   \
      (nbytes_left) = (nbytes) % OPSIZ;                                     \
    } while (0)

Definition at line 136 of file memcopy.h.

#define WORD_COPY_FWD (   dst_bp,
  src_bp,
  nbytes_left,
  nbytes 
)
Value:
do                                                                   \
    {                                                                \
      if (src_bp % OPSIZ == 0)                                              \
       _wordcopy_fwd_aligned (dst_bp, src_bp, (nbytes) / OPSIZ);            \
      else								      \
	_wordcopy_fwd_dest_aligned (dst_bp, src_bp, (nbytes) / OPSIZ);             \
      src_bp += (nbytes) & -OPSIZ;                                   \
      dst_bp += (nbytes) & -OPSIZ;                                   \
      (nbytes_left) = (nbytes) % OPSIZ;                                     \
    } while (0)

Definition at line 116 of file memcopy.h.


Typedef Documentation

typedef unsigned char byte

Definition at line 63 of file memcopy.h.


Function Documentation

void _wordcopy_bwd_aligned ( long  int,
long  int,
size_t   
)

Definition at line 226 of file wordcopy.c.

{
  op_t a0, a1;

  switch (len % 8)
    {
    case 2:
      srcp -= 2 * OPSIZ;
      dstp -= 1 * OPSIZ;
      a0 = ((op_t *) srcp)[1];
      len += 6;
      goto do1;
    case 3:
      srcp -= 3 * OPSIZ;
      dstp -= 2 * OPSIZ;
      a1 = ((op_t *) srcp)[2];
      len += 5;
      goto do2;
    case 4:
      srcp -= 4 * OPSIZ;
      dstp -= 3 * OPSIZ;
      a0 = ((op_t *) srcp)[3];
      len += 4;
      goto do3;
    case 5:
      srcp -= 5 * OPSIZ;
      dstp -= 4 * OPSIZ;
      a1 = ((op_t *) srcp)[4];
      len += 3;
      goto do4;
    case 6:
      srcp -= 6 * OPSIZ;
      dstp -= 5 * OPSIZ;
      a0 = ((op_t *) srcp)[5];
      len += 2;
      goto do5;
    case 7:
      srcp -= 7 * OPSIZ;
      dstp -= 6 * OPSIZ;
      a1 = ((op_t *) srcp)[6];
      len += 1;
      goto do6;

    case 0:
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       return;
      srcp -= 8 * OPSIZ;
      dstp -= 7 * OPSIZ;
      a0 = ((op_t *) srcp)[7];
      goto do7;
    case 1:
      srcp -= 9 * OPSIZ;
      dstp -= 8 * OPSIZ;
      a1 = ((op_t *) srcp)[8];
      len -= 1;
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       goto do0;
      goto do8;                    /* No-op.  */
    }

  do
    {
    do8:
      a0 = ((op_t *) srcp)[7];
      ((op_t *) dstp)[7] = a1;
    do7:
      a1 = ((op_t *) srcp)[6];
      ((op_t *) dstp)[6] = a0;
    do6:
      a0 = ((op_t *) srcp)[5];
      ((op_t *) dstp)[5] = a1;
    do5:
      a1 = ((op_t *) srcp)[4];
      ((op_t *) dstp)[4] = a0;
    do4:
      a0 = ((op_t *) srcp)[3];
      ((op_t *) dstp)[3] = a1;
    do3:
      a1 = ((op_t *) srcp)[2];
      ((op_t *) dstp)[2] = a0;
    do2:
      a0 = ((op_t *) srcp)[1];
      ((op_t *) dstp)[1] = a1;
    do1:
      a1 = ((op_t *) srcp)[0];
      ((op_t *) dstp)[0] = a0;

      srcp -= 8 * OPSIZ;
      dstp -= 8 * OPSIZ;
      len -= 8;
    }
  while (len != 0);

  /* This is the right position for do0.  Please don't move
     it into the loop.  */
 do0:
  ((op_t *) dstp)[7] = a1;
}
void _wordcopy_bwd_dest_aligned ( long  int,
long  int,
size_t   
)

Definition at line 334 of file wordcopy.c.

{
  op_t a0, a1, a2, a3;
  int sh_1, sh_2;

  /* Calculate how to shift a word read at the memory operation
     aligned srcp to make it aligned for copy.  */

  sh_1 = 8 * (srcp % OPSIZ);
  sh_2 = 8 * OPSIZ - sh_1;

  /* Make srcp aligned by rounding it down to the beginning of the op_t
     it points in the middle of.  */
  srcp &= -OPSIZ;
  srcp += OPSIZ;

  switch (len % 4)
    {
    case 2:
      srcp -= 3 * OPSIZ;
      dstp -= 1 * OPSIZ;
      a2 = ((op_t *) srcp)[2];
      a1 = ((op_t *) srcp)[1];
      len += 2;
      goto do1;
    case 3:
      srcp -= 4 * OPSIZ;
      dstp -= 2 * OPSIZ;
      a3 = ((op_t *) srcp)[3];
      a2 = ((op_t *) srcp)[2];
      len += 1;
      goto do2;
    case 0:
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       return;
      srcp -= 5 * OPSIZ;
      dstp -= 3 * OPSIZ;
      a0 = ((op_t *) srcp)[4];
      a3 = ((op_t *) srcp)[3];
      goto do3;
    case 1:
      srcp -= 6 * OPSIZ;
      dstp -= 4 * OPSIZ;
      a1 = ((op_t *) srcp)[5];
      a0 = ((op_t *) srcp)[4];
      len -= 1;
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       goto do0;
      goto do4;                    /* No-op.  */
    }

  do
    {
    do4:
      a3 = ((op_t *) srcp)[3];
      ((op_t *) dstp)[3] = MERGE (a0, sh_1, a1, sh_2);
    do3:
      a2 = ((op_t *) srcp)[2];
      ((op_t *) dstp)[2] = MERGE (a3, sh_1, a0, sh_2);
    do2:
      a1 = ((op_t *) srcp)[1];
      ((op_t *) dstp)[1] = MERGE (a2, sh_1, a3, sh_2);
    do1:
      a0 = ((op_t *) srcp)[0];
      ((op_t *) dstp)[0] = MERGE (a1, sh_1, a2, sh_2);

      srcp -= 4 * OPSIZ;
      dstp -= 4 * OPSIZ;
      len -= 4;
    }
  while (len != 0);

  /* This is the right position for do0.  Please don't move
     it into the loop.  */
 do0:
  ((op_t *) dstp)[3] = MERGE (a0, sh_1, a1, sh_2);
}
void _wordcopy_fwd_aligned ( long  int,
long  int,
size_t   
)

Definition at line 31 of file wordcopy.c.

{
  op_t a0, a1;

  switch (len % 8)
    {
    case 2:
      a0 = ((op_t *) srcp)[0];
      srcp -= 6 * OPSIZ;
      dstp -= 7 * OPSIZ;
      len += 6;
      goto do1;
    case 3:
      a1 = ((op_t *) srcp)[0];
      srcp -= 5 * OPSIZ;
      dstp -= 6 * OPSIZ;
      len += 5;
      goto do2;
    case 4:
      a0 = ((op_t *) srcp)[0];
      srcp -= 4 * OPSIZ;
      dstp -= 5 * OPSIZ;
      len += 4;
      goto do3;
    case 5:
      a1 = ((op_t *) srcp)[0];
      srcp -= 3 * OPSIZ;
      dstp -= 4 * OPSIZ;
      len += 3;
      goto do4;
    case 6:
      a0 = ((op_t *) srcp)[0];
      srcp -= 2 * OPSIZ;
      dstp -= 3 * OPSIZ;
      len += 2;
      goto do5;
    case 7:
      a1 = ((op_t *) srcp)[0];
      srcp -= 1 * OPSIZ;
      dstp -= 2 * OPSIZ;
      len += 1;
      goto do6;

    case 0:
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       return;
      a0 = ((op_t *) srcp)[0];
      srcp -= 0 * OPSIZ;
      dstp -= 1 * OPSIZ;
      goto do7;
    case 1:
      a1 = ((op_t *) srcp)[0];
      srcp -=-1 * OPSIZ;
      dstp -= 0 * OPSIZ;
      len -= 1;
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       goto do0;
      goto do8;                    /* No-op.  */
    }

  do
    {
    do8:
      a0 = ((op_t *) srcp)[0];
      ((op_t *) dstp)[0] = a1;
    do7:
      a1 = ((op_t *) srcp)[1];
      ((op_t *) dstp)[1] = a0;
    do6:
      a0 = ((op_t *) srcp)[2];
      ((op_t *) dstp)[2] = a1;
    do5:
      a1 = ((op_t *) srcp)[3];
      ((op_t *) dstp)[3] = a0;
    do4:
      a0 = ((op_t *) srcp)[4];
      ((op_t *) dstp)[4] = a1;
    do3:
      a1 = ((op_t *) srcp)[5];
      ((op_t *) dstp)[5] = a0;
    do2:
      a0 = ((op_t *) srcp)[6];
      ((op_t *) dstp)[6] = a1;
    do1:
      a1 = ((op_t *) srcp)[7];
      ((op_t *) dstp)[7] = a0;

      srcp += 8 * OPSIZ;
      dstp += 8 * OPSIZ;
      len -= 8;
    }
  while (len != 0);

  /* This is the right position for do0.  Please don't move
     it into the loop.  */
 do0:
  ((op_t *) dstp)[0] = a1;
}
void _wordcopy_fwd_dest_aligned ( long  int,
long  int,
size_t   
)

Definition at line 139 of file wordcopy.c.

{
  op_t a0, a1, a2, a3;
  int sh_1, sh_2;

  /* Calculate how to shift a word read at the memory operation
     aligned srcp to make it aligned for copy.  */

  sh_1 = 8 * (srcp % OPSIZ);
  sh_2 = 8 * OPSIZ - sh_1;

  /* Make SRCP aligned by rounding it down to the beginning of the `op_t'
     it points in the middle of.  */
  srcp &= -OPSIZ;

  switch (len % 4)
    {
    case 2:
      a1 = ((op_t *) srcp)[0];
      a2 = ((op_t *) srcp)[1];
      srcp -= 1 * OPSIZ;
      dstp -= 3 * OPSIZ;
      len += 2;
      goto do1;
    case 3:
      a0 = ((op_t *) srcp)[0];
      a1 = ((op_t *) srcp)[1];
      srcp -= 0 * OPSIZ;
      dstp -= 2 * OPSIZ;
      len += 1;
      goto do2;
    case 0:
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       return;
      a3 = ((op_t *) srcp)[0];
      a0 = ((op_t *) srcp)[1];
      srcp -=-1 * OPSIZ;
      dstp -= 1 * OPSIZ;
      len += 0;
      goto do3;
    case 1:
      a2 = ((op_t *) srcp)[0];
      a3 = ((op_t *) srcp)[1];
      srcp -=-2 * OPSIZ;
      dstp -= 0 * OPSIZ;
      len -= 1;
      if (OP_T_THRES <= 3 * OPSIZ && len == 0)
       goto do0;
      goto do4;                    /* No-op.  */
    }

  do
    {
    do4:
      a0 = ((op_t *) srcp)[0];
      ((op_t *) dstp)[0] = MERGE (a2, sh_1, a3, sh_2);
    do3:
      a1 = ((op_t *) srcp)[1];
      ((op_t *) dstp)[1] = MERGE (a3, sh_1, a0, sh_2);
    do2:
      a2 = ((op_t *) srcp)[2];
      ((op_t *) dstp)[2] = MERGE (a0, sh_1, a1, sh_2);
    do1:
      a3 = ((op_t *) srcp)[3];
      ((op_t *) dstp)[3] = MERGE (a1, sh_1, a2, sh_2);

      srcp += 4 * OPSIZ;
      dstp += 4 * OPSIZ;
      len -= 4;
    }
  while (len != 0);

  /* This is the right position for do0.  Please don't move
     it into the loop.  */
 do0:
  ((op_t *) dstp)[0] = MERGE (a2, sh_1, a3, sh_2);
}