2007-02-08 Dave Brolley <brolley@redhat.com>

        * mep: New target directory.
        * README: Add MeP.
        * configure.in: Add support for MeP.
        * configure: Regenerated.
        * mep/configure.in: New file.
        * mep/configure: Ditto.
        * mep/Makefile.in: Ditto.
        * mep/aclocal.m4: Ditto.
        * mep/crt0.S: Ditto.
        * mep/crtn.S: Ditto.
        * mep/sim-crt0.S: Ditto.
        * mep/sim-crtn.S: Ditto.
        * mep/fmax.ld: Ditto.
        * mep/gcov-io.h: Ditto.
        * mep/gmap_default.ld: Ditto.
        * mep/handlers.c: Ditto.
        * mep/h_reset.c: Ditto.
        * mep/isatty.c: Ditto.
        * mep/mep-bb.c: Ditto.
        * mep/mep-gmon.c: Ditto.
        * mep/min.ld: Ditto.
        * mep/read.c: Ditto.
        * mep/sbrk.c: Ditto.
        * mep/sdram-crt0.S: Ditto.
        * mep/sdram-crtn.S: Ditto.
        * mep/simnovec-crt0.S: Ditto.
        * mep/simple.ld: Ditto.
        * mep/simsdran-crt0.S: Ditto.
        * mep/syscalls.S: Ditto.
        * mep/write.c: Ditto.

1 files changed, 137 insertions, 0 deletions

diff --git a/libgloss/mep/gcov-io.h b/libgloss/mep/gcov-io.h
new file mode 100644
index 000000000..cb99704cd
--- /dev/null
+++ b/libgloss/mep/gcov-io.h
@@ -0,0 +1,137 @@
+/* Machine-independent I/O routines for gcov.
+   
+   Copyright (c) 2000  Red Hat, Inc. All rights reserved.
+
+   This copyrighted material is made available to anyone wishing to use, modify,
+   copy, or redistribute it subject to the terms and conditions of the BSD 
+   License.   This program is distributed in the hope that it will be useful, 
+   but WITHOUT ANY WARRANTY expressed or implied, including the implied 
+   warranties of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  A copy of
+   this license is available at http://www.opensource.org/licenses. Any Red Hat
+   trademarks that are incorporated in the source code or documentation are not
+   subject to the BSD License and may only be used or replicated with the 
+   express permission of Red Hat, Inc.
+*/
+
+
+#ifndef GCC_GCOV_IO_H
+#define GCC_GCOV_IO_H
+#include <stdio.h>
+#include <sys/types.h>
+
+static int __fetch_long	(long *, char *, size_t);
+static int __store_long (long, char *, size_t);
+static int __read_long  (long *, FILE *, size_t);
+static int __write_long (long, FILE *, size_t);
+
+/* These routines only work for signed values. */
+
+/* Store a portable representation of VALUE in DEST using BYTES*8-1 bits.
+   Return a non-zero value if VALUE requires more than BYTES*8-1 bits
+   to store. */
+
+static int
+__store_long (value, dest, bytes)
+     long value;
+     char *dest;
+     size_t bytes;
+{
+  int upper_bit = (value < 0 ? 128 : 0);
+  size_t i;
+
+  if (value < 0)
+    {
+      long oldvalue = value;
+      value = -value;
+      if (oldvalue != -value)
+	return 1;
+    }
+
+  for(i = 0 ; i < (sizeof (value) < bytes ? sizeof (value) : bytes) ; i++) {
+    dest[i] = value & (i == (bytes - 1) ? 127 : 255);
+    value = value / 256;
+  }
+
+  if (value && value != -1)
+    return 1;
+
+  for(; i < bytes ; i++) 
+    dest[i] = 0;
+  dest[bytes - 1] |= upper_bit;
+  return 0;
+}
+
+/* Retrieve a quantity containing BYTES*8-1 bits from SOURCE and store
+   the result in DEST. Returns a non-zero value if the value in SOURCE
+   will not fit in DEST. */
+
+static int
+__fetch_long (dest, source, bytes)
+     long *dest;
+     char *source;
+     size_t bytes;
+{
+  long value = 0;
+  int i;
+
+  for (i = bytes - 1; (size_t) i > (sizeof (*dest) - 1); i--)
+    if (source[i] & ((size_t) i == (bytes - 1) ? 127 : 255 ))
+      return 1;
+
+  for (; i >= 0; i--)
+    value = value * 256 + (source[i] & ((size_t)i == (bytes - 1) ? 127 : 255));
+
+  if ((source[bytes - 1] & 128) && (value > 0))
+    value = - value;
+
+  *dest = value;
+  return 0;
+}
+
+/* Write a BYTES*8-bit quantity to FILE, portably. Returns a non-zero
+   value if the write fails, or if VALUE can't be stored in BYTES*8
+   bits.
+
+   Note that VALUE may not actually be large enough to hold BYTES*8
+   bits, but BYTES characters will be written anyway.
+
+   BYTES may be a maximum of 10. */
+
+static int
+__write_long (value, file, bytes)
+     long value;
+     FILE *file;
+     size_t bytes;
+{
+  char c[10];
+
+  if (bytes > 10 || __store_long (value, c, bytes))
+    return 1;
+  else
+    return fwrite(c, 1, bytes, file) != bytes;
+}
+
+/* Read a quantity containing BYTES bytes from FILE, portably. Return
+   a non-zero value if the read fails or if the value will not fit
+   in DEST.
+
+   Note that DEST may not be large enough to hold all of the requested
+   data, but the function will read BYTES characters anyway.
+
+   BYTES may be a maximum of 10. */
+
+static int
+__read_long (dest, file, bytes)
+     long *dest;
+     FILE *file;
+     size_t bytes;
+{
+  char c[10];
+
+  if (bytes > 10 || fread(c, 1, bytes, file) != bytes)
+    return 1;
+  else
+    return __fetch_long (dest, c, bytes);
+}
+
+#endif /* ! GCC_GCOV_IO_H */