Add parlib-compat.c for weak symbols with parlib
authorKevin Klues <>
Mon, 9 Nov 2015 22:56:26 +0000 (14:56 -0800)
committerBarret Rhoden <>
Mon, 16 Nov 2015 23:15:03 +0000 (15:15 -0800)
This commit requires a rebuild of glibc (XCC)

Historically, parlib and glibc have been 2 separate entities. In spirit,
however, they both serve to provide low level functionalitity required
by higher level libraries. In theory, all of the functionality we
provide in parlib could (and arguably should) eventually be pushed down
into the akaros port of glibc. However, for now, we have opted to keep
parlib and glibc separate to maintain a faster turn-around time with
building parlib vs. glibc.

Unfortunately, keeping parlib and glibc separate is not very clean when
it comes to building glibc. Glibc is designed to be the lowest level
library on the system, and as such, doesn't like it when it has
unresolved symbols from parlib at link time. Since all executables
eventually link with parlib, this is not a problem (in theory), but
glibc doesn't like it nonetheless, and we have problems building our
cross compiler if any parlib symbols are referenced inside our akaros
port of glibc.

To help with this, I've introduced a new file called parlib-compat.c,
to define weak symbols for any parlib symbol that needs to be accessed
internally by glibc. This way, the symbol will exist at the time libc is
linked (to get our cross compiler build to stop complaining), but those
symbols will be overridden by parlib.a in any final executable that
gets linked.

Unfortunately, this trick only works so long as we leave parlib as a
static library. If we ever decide to make parlib a .so, then we will
have to revisit this and use function pointers at runtime or something
similar. Maybe by then we will have pushed all of parlib's functionality
down into glibc, so the point will be moot anyway.

Signed-off-by: Kevin Klues <>
Signed-off-by: Barret Rhoden <>
tools/compilers/gcc-glibc/glibc-2.19-akaros/sysdeps/akaros/parlib-compat.c [new file with mode: 0644]

index 05e5bdd..d8f008b 100644 (file)
@@ -10,6 +10,11 @@ CFLAGS-flockfile.c = $(libio-mtsafe)
 CFLAGS-ftrylockfile.c = $(libio-mtsafe)
 CFLAGS-funlockfile.c = $(libio-mtsafe)
+# Weak alias functions for linking without parlib
+ifeq ($(subdir),stdlib)
+sysdep_routines += parlib-compat
 # Any sysdep .c file you want needs to be added here, if it's not somewhere
 # else already.  Many posix-ish .c files already are taken care of.  We also
 # need to be careful to only include some of them for specific subdirs.
index dc82952..e580909 100644 (file)
@@ -52,5 +52,9 @@ libc {
+    # Weak symbols in parlib-compat.c
+    akaros_printf;
+    _assert_failed;
diff --git a/tools/compilers/gcc-glibc/glibc-2.19-akaros/sysdeps/akaros/parlib-compat.c b/tools/compilers/gcc-glibc/glibc-2.19-akaros/sysdeps/akaros/parlib-compat.c
new file mode 100644 (file)
index 0000000..6327402
--- /dev/null
@@ -0,0 +1,28 @@
+/* Copyright (c) 2015 Google Inc.
+ * Kevin Klues <>
+ * See LICENSE for details.
+ */
+#include <libc-symbols.h>
+#include <parlib/stdio.h>
+#include <parlib/assert.h>
+/* Here we define functions that are really defined in parlib, but we need
+ * them in libc in order to link it. We weak alias them here so that the
+ * parlib definitions will override them later. Unfortunately, this trick
+ * only works so long as we leave parlib as a static library. If we ever
+ * decide to make parlib a .so, then we will have to revisit this and use
+ * function pointers at runtime or something similar. */
+int __akaros_printf(const char *format, ...)
+       assert(0);
+       return -1;
+weak_alias(__akaros_printf, akaros_printf)
+void ___assert_failed(const char *file, int line, const char *msg)
+       assert(0);
+weak_alias(___assert_failed, _assert_failed)