+++ /dev/null
-//===-- RuntimeLib.lc - LLVM Standard C Runtime Library -----------*- C -*-===//
-//
-// This file contains definitions of C functions that are useful to get LLVM
-// programs up and running. This library of functions is automatically linked
-// into programs loaded into LLI.
-//
-// This file is compiled by the LLVM port of GCC to get LLVM code.
-//
-// A lot of this code is ripped gratuitously from glibc and libiberty.
-//
-//===----------------------------------------------------------------------===//
-
-#include <stdlib.h>
-
-// Prototypes for functions exported by LLI directly.
-void exit(int Code);
-int putchar(int);
-void *malloc(unsigned);
-void free(void *);
-
-#define isspace(x) ((x) == ' ' || (x) == '\t' || (x) == '\n')
-#define isdigit(x) ((x) >= '0' && (x) <= '9')
-#define isupper(x) ((x) >= 'A' && (x) <= 'Z')
-#define islower(x) ((x) >= 'a' && (x) <= 'z')
-#define isalpha(x) (isupper(x) || islower(x))
-
-// The puts() function writes the string pointed to by s, followed by a
-// NEWLINE character, to the standard output stream stdout. On success the
-// number of characters written is returned; otherwise they return EOF.
-//
-int puts(const char *S) {
- const char *Str = S;
- while (*Str) putchar(*Str++);
- putchar('\n');
- return Str+1-S;
-}
-
-
-#ifndef ULONG_MAX
-#define ULONG_MAX ((unsigned long)(~0L)) /* 0xFFFFFFFF */
-#endif
-
-#ifndef LONG_MAX
-#define LONG_MAX ((long)(ULONG_MAX >> 1)) /* 0x7FFFFFFF */
-#endif
-
-#ifndef LONG_MIN
-#define LONG_MIN ((long)(~LONG_MAX)) /* 0x80000000 */
-#endif
-
-/*
- * Convert a string to a long integer.
- *
- * Ignores `locale' stuff. Assumes that the upper and lower case
- * alphabets and digits are each contiguous.
- */
-long strtol(const char *nptr, char **endptr, int base) {
- register const char *s = nptr;
- register unsigned long acc;
- register int c;
- register unsigned long cutoff;
- register int neg = 0, any, cutlim;
-
- /*
- * Skip white space and pick up leading +/- sign if any.
- * If base is 0, allow 0x for hex and 0 for octal, else
- * assume decimal; if base is already 16, allow 0x.
- */
- do {
- c = *s++;
- } while (isspace(c));
- if (c == '-') {
- neg = 1;
- c = *s++;
- } else if (c == '+')
- c = *s++;
- if ((base == 0 || base == 16) &&
- c == '0' && (*s == 'x' || *s == 'X')) {
- c = s[1];
- s += 2;
- base = 16;
- }
- if (base == 0)
- base = c == '0' ? 8 : 10;
-
- /*
- * Compute the cutoff value between legal numbers and illegal
- * numbers. That is the largest legal value, divided by the
- * base. An input number that is greater than this value, if
- * followed by a legal input character, is too big. One that
- * is equal to this value may be valid or not; the limit
- * between valid and invalid numbers is then based on the last
- * digit. For instance, if the range for longs is
- * [-2147483648..2147483647] and the input base is 10,
- * cutoff will be set to 214748364 and cutlim to either
- * 7 (neg==0) or 8 (neg==1), meaning that if we have accumulated
- * a value > 214748364, or equal but the next digit is > 7 (or 8),
- * the number is too big, and we will return a range error.
- *
- * Set any if any `digits' consumed; make it negative to indicate
- * overflow.
- */
- cutoff = neg ? -(unsigned long)LONG_MIN : LONG_MAX;
- cutlim = cutoff % (unsigned long)base;
- cutoff /= (unsigned long)base;
- for (acc = 0, any = 0;; c = *s++) {
- if (isdigit(c))
- c -= '0';
- else if (isalpha(c))
- c -= isupper(c) ? 'A' - 10 : 'a' - 10;
- else
- break;
- if (c >= base)
- break;
- if (any < 0 || acc > cutoff || acc == cutoff && c > cutlim)
- any = -1;
- else {
- any = 1;
- acc *= base;
- acc += c;
- }
- }
- if (any < 0) {
- acc = neg ? LONG_MIN : LONG_MAX;
- } else if (neg)
- acc = -acc;
- if (endptr != 0)
- *endptr = (char *) (any ? s - 1 : nptr);
- return (acc);
-}
-
-
-/* Convert a string to an int. */
-int atoi(const char *nptr) {
- return (int)strtol(nptr, 0, 10);
-}
-
-/* Convert a string to a long int. */
-long int atol(const char *nptr) {
- return strtol(nptr, 0, 10);
-}
-
-
-unsigned strlen(const char *Str) {
- int Count = 0;
- while (*Str) { ++Count; ++Str; }
- return Count;
-}
-
-char *strdup(const char *str) {
- int Len = strlen(str);
- char *Result = (char*)malloc((Len+1)*sizeof(char));
- memcpy(Result, str, Len+1);
- return Result;
-}
-
-
-/* Compare S1 and S2, returning less than, equal to or
- greater than zero if S1 is lexicographically less than,
- equal to or greater than S2. */
-int strcmp (const char *p1, const char *p2) {
- register const unsigned char *s1 = (const unsigned char *) p1;
- register const unsigned char *s2 = (const unsigned char *) p2;
- unsigned char c1, c2;
-
- do
- {
- c1 = (unsigned char) *s1++;
- c2 = (unsigned char) *s2++;
- if (c1 == '\0')
- return c1 - c2;
- }
- while (c1 == c2);
-
- return c1 - c2;
-}
-
-
-//===----------------------------------------------------------------------===//
-// 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);
-}
-
-
-//===----------------------------------------------------------------------===//
-// libm stuff...
-//===----------------------------------------------------------------------===//
-
projects / oota-llvm.git / commitdiff