From 53b20c34dc07d38683983afc2ad9d9170cffe9bd Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Tue, 30 Oct 2001 22:37:01 +0000
Subject: [PATCH] Implement memset memcpy, calloc

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1055 91177308-0d34-0410-b5e6-96231b3b80d8
---
 tools/lli/RuntimeLib.lc | 85 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/tools/lli/RuntimeLib.lc b/tools/lli/RuntimeLib.lc
index b8d3f04ef48..6a02c238772 100644
--- a/tools/lli/RuntimeLib.lc
+++ b/tools/lli/RuntimeLib.lc
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <stdlib.h>
 
 // Prototypes for functions exported by LLI directly.
 void exit(int Code);
@@ -140,8 +141,92 @@ long int atol(const char *nptr) {
 }
 
 
+//===----------------------------------------------------------------------===//
+// memory stuff...
+//===----------------------------------------------------------------------===//
+// http://sources.redhat.com/cgi-bin/cvsweb.cgi/libc/sysdeps/generic/?cvsroot=glibc
 
+typedef unsigned int op_t;
+#define OPSIZ 4
 
+void *memset (void *dstpp, int c, size_t len) {
+  long long int dstp = (long long int) dstpp;
+
+  if (len >= 8)
+    {
+      size_t xlen;
+      op_t cccc;
+
+      cccc = (unsigned char) c;
+      cccc |= cccc << 8;
+      cccc |= cccc << 16;
+      if (OPSIZ > 4)
+        /* Do the shift in two steps to avoid warning if long has 32 bits.  */
+        cccc |= (cccc << 16) << 16;
+
+      /* There are at least some bytes to set.
+         No need to test for LEN == 0 in this alignment loop.  */
+      while (dstp % OPSIZ != 0)
+        {
+          ((unsigned char *) dstp)[0] = c;
+          dstp += 1;
+          len -= 1;
+        }
+
+      /* Write 8 `op_t' per iteration until less than 8 `op_t' remain.  */
+      xlen = len / (OPSIZ * 8);
+      while (xlen > 0)
+        {
+          ((op_t *) dstp)[0] = cccc;
+          ((op_t *) dstp)[1] = cccc;
+          ((op_t *) dstp)[2] = cccc;
+          ((op_t *) dstp)[3] = cccc;
+          ((op_t *) dstp)[4] = cccc;
+          ((op_t *) dstp)[5] = cccc;
+          ((op_t *) dstp)[6] = cccc;
+          ((op_t *) dstp)[7] = cccc;
+          dstp += 8 * OPSIZ;
+          xlen -= 1;
+        }
+      len %= OPSIZ * 8;
+
+      /* Write 1 `op_t' per iteration until less than OPSIZ bytes remain.  */
+      xlen = len / OPSIZ;
+      while (xlen > 0)
+        {
+          ((op_t *) dstp)[0] = cccc;
+          dstp += OPSIZ;
+          xlen -= 1;
+        }
+      len %= OPSIZ;
+    }
+
+  /* Write the last few bytes.  */
+  while (len > 0)
+    {
+      ((unsigned char *) dstp)[0] = c;
+      dstp += 1;
+      len -= 1;
+    }
+
+  return dstpp;
+}
+
+void *memcpy(void *dstpp, const void *srcpp, size_t len) {
+  char *dstp = (char*)dstpp;
+  char *srcp = (char*) srcpp;
+  unsigned i;
+
+  for (i = 0; i < len; ++i)
+    dstp[i] = srcp[i];
+
+  return dstpp;
+}
+
+void *calloc(size_t nelem, size_t elsize) {
+  void *Result = malloc(nelem*elsize);
+  return memset(Result, 0, nelem*elsize);
+}
 
 
 //===----------------------------------------------------------------------===//