The Tor Browser: security/nss/lib/dbm/src/memmove.c@b8a032363ba2

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 #if defined(__sun) && !defined(__SVR4)

     2 /*-

     3  * Copyright (c) 1990, 1993

     4  *	The Regents of the University of California.  All rights reserved.

     5  *

     6  * This code is derived from software contributed to Berkeley by

     7  * Chris Torek.

     8  *

     9  * Redistribution and use in source and binary forms, with or without

    10  * modification, are permitted provided that the following conditions

    11  * are met:

    12  * 1. Redistributions of source code must retain the above copyright

    13  *    notice, this list of conditions and the following disclaimer.

    14  * 2. Redistributions in binary form must reproduce the above copyright

    15  *    notice, this list of conditions and the following disclaimer in the

    16  *    documentation and/or other materials provided with the distribution.

    17  * 3. ***REMOVED*** - see

    18  *    ftp://ftp.cs.berkeley.edu/pub/4bsd/README.Impt.License.Change

    19  * 4. Neither the name of the University nor the names of its contributors

    20  *    may be used to endorse or promote products derived from this software

    21  *    without specific prior written permission.

    22  *

    23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    33  * SUCH DAMAGE.

    34  */

    36 #if defined(LIBC_SCCS) && !defined(lint)

    37 static char sccsid[] = "@(#)bcopy.c	8.1 (Berkeley) 6/4/93";

    38 #endif /* LIBC_SCCS and not lint */

    40 #ifdef HAVE_SYS_CDEFS_H

    41 #include <sys/cdefs.h>

    42 #else

    43 #include "cdefs.h"

    44 #endif

    45 #include <string.h>

    47 /*

    48  * sizeof(word) MUST BE A POWER OF TWO

    49  * SO THAT wmask BELOW IS ALL ONES

    50  */

    51 typedef	int word;		/* "word" used for optimal copy speed */

    53 #define	wsize	sizeof(word)

    54 #define	wmask	(wsize - 1)

    56 /*

    57  * Copy a block of memory, handling overlap.

    58  * This is the routine that actually implements

    59  * (the portable versions of) bcopy, memcpy, and memmove.

    60  */

    61 #ifdef MEMCOPY

    62 void *

    63 memcpy(dst0, src0, length)

    64 #else

    65 #ifdef MEMMOVE

    66 void *

    67 memmove(dst0, src0, length)

    68 #else

    69 void

    70 bcopy(src0, dst0, length)

    71 #endif

    72 #endif

    73 	void *dst0;

    74 	const void *src0;

    75 	register size_t length;

    76 {

    77 	register char *dst = dst0;

    78 	register const char *src = src0;

    79 	register size_t t;

    81 	if (length == 0 || dst == src)		/* nothing to do */

    82 		goto done;

    84 	/*

    85 	 * Macros: loop-t-times; and loop-t-times, t>0

    86 	 */

    87 #define	TLOOP(s) if (t) TLOOP1(s)

    88 #define	TLOOP1(s) do { s; } while (--t)

    90 	if ((unsigned long)dst < (unsigned long)src) {

    91 		/*

    92 		 * Copy forward.

    93 		 */

    94 		t = (int)src;	/* only need low bits */

    95 		if ((t | (int)dst) & wmask) {

    96 			/*

    97 			 * Try to align operands.  This cannot be done

    98 			 * unless the low bits match.

    99 			 */

   100 			if ((t ^ (int)dst) & wmask || length < wsize)

   101 				t = length;

   102 			else

   103 				t = wsize - (t & wmask);

   104 			length -= t;

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

   106 		}

   107 		/*

   108 		 * Copy whole words, then mop up any trailing bytes.

   109 		 */

   110 		t = length / wsize;

   111 		TLOOP(*(word *)dst = *(word *)src; src += wsize; dst += wsize);

   112 		t = length & wmask;

   113 		TLOOP(*dst++ = *src++);

   114 	} else {

   115 		/*

   116 		 * Copy backwards.  Otherwise essentially the same.

   117 		 * Alignment works as before, except that it takes

   118 		 * (t&wmask) bytes to align, not wsize-(t&wmask).

   119 		 */

   120 		src += length;

   121 		dst += length;

   122 		t = (int)src;

   123 		if ((t | (int)dst) & wmask) {

   124 			if ((t ^ (int)dst) & wmask || length <= wsize)

   125 				t = length;

   126 			else

   127 				t &= wmask;

   128 			length -= t;

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

   130 		}

   131 		t = length / wsize;

   132 		TLOOP(src -= wsize; dst -= wsize; *(word *)dst = *(word *)src);

   133 		t = length & wmask;

   134 		TLOOP(*--dst = *--src);

   135 	}

   136 done:

   137 #if defined(MEMCOPY) || defined(MEMMOVE)

   138 	return (dst0);

   139 #else

   140 	return;

   141 #endif

   142 }

   143 #endif /* no __sgi */

   145 /* Some compilers don't like an empty source file. */

   146 static int dummy = 0;

The Tor Browser / file revision