-diff -urN uClibc-0.9.26.org/extra/gcc-uClibc/gcc-uClibc.c uClibc-0.9.26/extra/gcc-uClibc/gcc-uClibc.c
---- uClibc-0.9.26.org/extra/gcc-uClibc/gcc-uClibc.c 1970-01-01 01:00:00.000000000 +0100
-+++ uClibc-0.9.26/extra/gcc-uClibc/gcc-uClibc.c 2003-08-28 07:51:04.000000000 +0200
-@@ -0,0 +1,667 @@
-+/* vi: set sw=4 ts=4: */
+diff -urN uClibc-0.9.29.org/extra/gcc-uClibc/gcc-uClibc.c uClibc-0.9.29/extra/gcc-uClibc/gcc-uClibc.c
+--- uClibc-0.9.29.org/extra/gcc-uClibc/gcc-uClibc.c 1970-01-01 01:00:00.000000000 +0100
++++ uClibc-0.9.29/extra/gcc-uClibc/gcc-uClibc.c 2007-06-03 22:03:22.061912354 +0200
+@@ -0,0 +1,518 @@
++/* vi: set ts=4 :*/
+/*
+ * Copyright (C) 2000 Manuel Novoa III
+ * Copyright (C) 2002-2003 Erik Andersen
++ * Copyright (C) 2006 Rob Landley <rob@landley.net>
+ *
-+ * This is a crude wrapper to use uClibc with gcc.
-+ * It was originally written to work around ./configure for ext2fs-utils.
-+ * It certainly can be improved, but it works for me in the normal cases.
-+ *
-+ * April 7, 2001
-+ *
-+ * A bug was fixed in building the gcc command line when dynamic linking.
-+ * The functions dlopen, etc. now work. At this time, you must make sure
-+ * the correct libdl.so is included however. It is safest to, for example,
-+ * add /lib/libdl.so.1 if using ld-linux.so.1 rather than adding -ldl to the
-+ * command line.
-+ *
-+ * Note: This is only a problem if devel and target archs are the same. To
-+ * avoid the problem, you can use a customized dynamic linker.
-+ *
-+ *
-+ * April 18, 2001
-+ *
-+ * The wrapper now works with either installed and uninstalled uClibc versions.
-+ * If you want to use the uninstalled header files and libs, either include
-+ * the string "build" in the invocation name such as
-+ * 'ln -s <ARCH>-uclibc-gcc <ARCH>-uclibc-gcc-build'
-+ * or include it in the environment variable setting of UCLIBC_ENV.
-+ * Note: This automatically enables the "rpath" behavior described below.
-+ *
-+ * The wrapper will now pass the location of the uClibc shared libs used to
-+ * the linker with the "-rpath" option if the invocation name includes the
-+ * string "rpath" or if the environment variable UCLIBC_ENV include it (as
-+ * with "build" above). This is primarily intended to be used on devel
-+ * platforms of the same arch as the target. A good place to use this feature
-+ * would be in the uClibc/test directory.
-+ *
-+ * The wrapper now displays the command line passed to gcc when '-v' is used.
-+ *
-+ * May 31, 2001
-+ *
-+ * "rpath" and "build" behavior are now decoupled. You can of course get
-+ * the old "build" behavior by setting UCLIBC_ENV="rpath-build". Order
-+ * isn't important here, as only the substrings are searched for.
-+ *
-+ * Added environment variable check for UCLIBC_GCC_DLOPT to let user specify
-+ * an alternative dynamic linker at runtime without using command line args.
-+ * Since this wouldn't commonly be used, I made it easy on myself. You have
-+ * to match the option you would have passed to the gcc wrapper. As an
-+ * example,
-+ *
-+ * export UCLIBC_GCC_DLOPT="-Wl,--dynamic-linker,/lib/ld-alt-linker.so.3"
-+ *
-+ * This is really only useful if target arch == devel arch and DEVEL_PREFIX
-+ * isn't empty. It involves a recompile, but you can at least test apps
-+ * on your devel system if combined with the "rpath" behavor if by using
-+ * LD_LIBRARY_PATH, etc.
-+ *
-+ * Also added check for "-Wl,--dynamic-linker" on the command line. The
-+ * use default dynamic linker or the envirnment-specified dynamic linker
-+ * is disabled in that case.
-+ *
-+ * Added options --uclibc-use-build-dir and --uclibc-use-rpath so that those
-+ * behaviors can be invoked from the command line.
-+ *
-+ */
-+
-+/*
-+ *
-+ * TODO:
-+ * Check/modify gcc-specific environment variables?
++ * Wrapper to use uClibc with gcc, and make gcc relocatable.
+ */
+
++#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
++#include <strings.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+
-+#include "gcc-uClibc.h"
-+
-+static char *our_usr_lib_path = "-L"UCLIBC_DEVEL_PREFIX"/lib";
-+
++static char *topdir;
+static char static_linking[] = "-static";
+static char nostdinc[] = "-nostdinc";
+static char nostartfiles[] = "-nostartfiles";
+static char nodefaultlibs[] = "-nodefaultlibs";
+static char nostdlib[] = "-nostdlib";
-+#ifdef __UCLIBC_CTOR_DTOR__
++
++// For C++
+static char nostdinc_plus[] = "-nostdinc++";
-+#endif
+
-+/* Include a local implementation of basename, since this
-+ * uses the host system's C lib, and CYGWIN apparently
-+ * doesn't provide an implementation of basename(). */
-+char *basename(const char *path)
-+{
-+ register const char *s;
-+ register const char *p;
-+ p = s = path;
-+ while (*s) {
-+ if (*s++ == '/') {
-+ p = s;
-+ }
-+ }
-+ return (char *) p;
-+}
+
-+char *dirname(char *path)
++// Confirm that a regular file exists, and (optionally) has the executable bit.
++int is_file(char *filename, int has_exe)
+{
-+ static const char null_or_empty_or_noslash[] = ".";
-+ register char *s;
-+ register char *last;
-+ char *first;
-+
-+ last = s = path;
-+
-+ if (s != NULL) {
-+
-+LOOP:
-+ while (*s && (*s != '/')) ++s;
-+ first = s;
-+ while (*s == '/') ++s;
-+ if (*s) {
-+ last = first;
-+ goto LOOP;
-+ }
++ // Confirm it has the executable bit set, if necessary.
++ if (!has_exe || !access(filename, X_OK)) {
++ struct stat st;
+
-+ if (last == path) {
-+ if (*last != '/') {
-+ goto DOT;
-+ }
-+ if ((*++last == '/') && (last[1] == 0)) {
-+ ++last;
-+ }
-+ }
-+ *last = 0;
-+ return path;
++ // Confirm it exists and is not a directory.
++ if (!stat(filename, &st) && S_ISREG(st.st_mode)) return 1;
+ }
-+DOT:
-+ return (char *) null_or_empty_or_noslash;
++ return 0;
+}
+
++// Find an executable in a colon-separated path
+
-+extern void *xmalloc(size_t size)
++char *find_in_path(char *path, char *filename, int has_exe)
+{
-+ void *ptr = malloc(size);
++ char *cwd = getcwd(NULL, 0);
++
++ if (index(filename, '/') && is_file(filename, has_exe))
++ return strdup(filename);
++
++ for (;;) {
++ char *str, *next = path ? index(path, ':') : NULL;
++ int len = next ? next-path : strlen(path);
++
++ // The +3 is a corner case: if strlen(filename) is 1, make sure we
++ // have enough space to append ".." to make topdir.
++ str = malloc(strlen(filename) + (len ? len : strlen(cwd)) + 3);
++ if (!len) sprintf(str, "%s/%s", cwd, filename);
++ else {
++ char *str2 = str;
++
++ strncpy(str, path, len);
++ str2 = str+len;
++ *(str2++) = '/';
++ strcpy(str2, filename);
++ }
+
-+ if (!ptr) {
-+ fprintf(stderr, "memory exhausted");
-+ exit(EXIT_FAILURE);
-+ }
-+ return ptr;
-+}
++ // If it's not a directory, return it.
++ if (is_file(str, has_exe)) return str;
++ else free(str);
+
-+void xstrcat(char **string, ...)
-+{
-+ const char *c;
-+ va_list p;
-+ /* Don't bother to calculate how big exerything
-+ * will be, just be careful to not overflow... */
-+ va_start(p, string);
-+ *string = xmalloc(BUFSIZ);
-+ **string = '\0';
-+ while(1) {
-+ if (!(c = va_arg(p, const char *)))
-+ break;
-+ strcat(*string, c);
++ if (!next) break;
++ path += len;
++ path++;
+ }
-+ va_end(p);
++ free(cwd);
++
++ return NULL;
+}
+
+int main(int argc, char **argv)
+ int use_build_dir = 0, linking = 1, use_static_linking = 0;
+ int use_stdinc = 1, use_start = 1, use_stdlib = 1, use_pic = 0;
+ int source_count = 0, use_rpath = 0, verbose = 0;
-+ int i, j, k, l, m, n;
-+ char ** gcc_argv;
-+ char ** gcc_argument;
-+ char ** libraries;
-+ char ** libpath;
-+ char *dlstr;
-+ char *incstr;
-+ char *devprefix;
-+ char *runprefix;
-+ char *builddir;
-+ char *libstr;
-+ char *build_dlstr = 0;
-+ char *cc;
-+ char *ep;
-+ char *rpath_link[2];
-+ char *rpath[2];
-+ char *uClibc_inc[2];
-+ char *our_lib_path[2];
-+ char *crt0_path[2];
-+ char *crtbegin_path[2];
-+ char *crtend_path[2];
-+ const char *application_name;
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ char *crti_path[2];
-+ char *crtn_path[2];
-+ int len;
-+ int ctor_dtor = 1, cplusplus = 0, use_nostdinc_plus = 0;
-+ int findlibgcc = 1;
-+ char *cpp = NULL;
-+#endif
-+#ifdef __UCLIBC_PROFILING__
++ int i, argcnt, liblen, n, sawM = 0, sawdotoa = 0, sawcES = 0;
++ char **gcc_argv, **libraries, **libpath;
++ char *dlstr, *incstr, *devprefix, *libstr, *build_dlstr = 0;
++ char *cc, *ep, *rpath_link[2], *rpath[2], *uClibc_inc[2], *our_lib_path[2];
++ char *crt0_path[2], *crtbegin_path[2], *crtend_path[2];
++ char *debug_wrapper=getenv("DEBUG_WRAPPER");
++
++ // For C++
++
++ char *crti_path[2], *crtn_path[2], *cpp = NULL;
++ int len, ctor_dtor = 1, cplusplus = 0, use_nostdinc_plus = 0;
++
++ // For profiling
+ int profile = 0;
+ char *gcrt1_path[2];
-+#endif
-+
-+ cc = getenv("UCLIBC_CC");
-+ if (cc==NULL) {
-+ cc = GCC_BIN;
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ findlibgcc = 0;
-+#endif
++
++ if(debug_wrapper) {
++ dprintf(2,"incoming: ");
++ for(gcc_argv=argv;*gcc_argv;gcc_argv++) dprintf(2,"%s ",*gcc_argv);
++ dprintf(2,"\n\n");
++ }
++
++ // Allocate space for new command line
++ gcc_argv = __builtin_alloca(sizeof(char*) * (argc + 128));
++
++ // What directory is the wrapper script in?
++ if(!(topdir = find_in_path(getenv("PATH"), argv[0], 1))) {
++ fprintf(stderr, "can't find %s in $PATH\n", argv[0]);
++ exit(1);
++ } else {
++ char *path = getenv("PATH"), *temp;
++
++ // Add that directory to the start of $PATH. (Better safe than sorry.)
++ *rindex(topdir,'/') = 0;
++ temp = malloc(strlen(topdir)+strlen(path)+7);
++ sprintf(temp,"PATH=%s:%s",topdir,path);
++ putenv(temp);
++
++ // The directory above the wrapper script should have include, gcc,
++ // and lib directories. However, the script could have a symlink
++ // pointing to its directory (ala /bin -> /usr/bin), so append ".."
++ // instead of trucating the path.
++ strcat(topdir,"/..");
+ }
+
-+ application_name = basename(argv[0]);
-+ if (application_name[0] == '-')
-+ application_name++;
-+
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ /* We must use strstr since g++ might be named like a
-+ * cross compiler (i.e. arm-linux-g++). We must also
-+ * search carefully, in case we are searching something
-+ * like /opt/c++/gcc-3.1/bin/arm-linux-g++ or some similar
-+ * perversion... */
-+ len = strlen(application_name);
-+ if ((strcmp(application_name+len-3, "g++")==0) ||
-+ (strcmp(application_name+len-3, "c++")==0)) {
++ // What's the name of the C compiler we're wrapping? (It may have a
++ // cross-prefix.)
++ cc = getenv("UCLIBC_CC");
++ if (!cc) cc = "gcc-unwrapped";
++
++
++ // Check end of name, since there could be a cross-prefix on the thing
++ len = strlen(argv[0]);
++ if (!strcmp(argv[0]+len-2, "ld")) {
++ // We're wrapping the linker.
++ // Wrapping the c++ compiler?
++ } else if (!strcmp(argv[0]+len-3, "g++") || !strcmp(argv[0]+len-3, "c++")) {
+ len = strlen(cc);
+ if (strcmp(cc+len-3, "gcc")==0) {
+ cpp = strdup(cc);
+ cplusplus = 1;
+ use_nostdinc_plus = 1;
+ }
-+#endif
+
+ devprefix = getenv("UCLIBC_DEVEL_PREFIX");
+ if (!devprefix) {
-+ devprefix = UCLIBC_DEVEL_PREFIX;
-+ }
-+
-+ runprefix = getenv("UCLIBC_RUNTIME_PREFIX");
-+ if (!runprefix) {
-+ runprefix = UCLIBC_RUNTIME_PREFIX;
-+ }
-+
-+ builddir = getenv("UCLIBC_BUILD_DIR");
-+ if (!builddir) {
-+ builddir = UCLIBC_BUILD_DIR;
++ devprefix = topdir;
+ }
+
+ incstr = getenv("UCLIBC_GCC_INC");
+ }
+
+
-+ xstrcat(&(rpath_link[0]), "-Wl,-rpath-link,", devprefix, "/lib:", runprefix, "/lib", NULL);
-+ xstrcat(&(rpath_link[1]), "-Wl,-rpath-link,", builddir, "/lib", NULL);
-+
-+ xstrcat(&(rpath[0]), "-Wl,-rpath,", devprefix, "/lib:", runprefix, "/lib", NULL);
-+ xstrcat(&(rpath[1]), "-Wl,-rpath,", builddir, "/lib", NULL);
-+
-+ xstrcat(&(uClibc_inc[0]), devprefix, "/include/", NULL);
-+ xstrcat(&(uClibc_inc[1]), builddir, "/include/", NULL);
-+
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ xstrcat(&(crt0_path[0]), devprefix, "/lib/crt1.o", NULL);
-+ xstrcat(&(crt0_path[1]), builddir, "/lib/crt1.o", NULL);
-+ xstrcat(&(crti_path[0]), devprefix, "/lib/crti.o", NULL);
-+ xstrcat(&(crti_path[1]), builddir, "/lib/crti.o", NULL);
-+ xstrcat(&(crtn_path[0]), devprefix, "/lib/crtn.o", NULL);
-+ xstrcat(&(crtn_path[1]), builddir, "/lib/crtn.o", NULL);
-+#else
-+ xstrcat(&(crt0_path[0]), devprefix, "/lib/crt0.o", NULL);
-+ xstrcat(&(crt0_path[1]), builddir, "/lib/crt0.o", NULL);
-+#endif
-+#ifdef __UCLIBC_PROFILING__
-+ xstrcat(&(gcrt1_path[0]), devprefix, "/lib/gcrt1.o", NULL);
-+ xstrcat(&(gcrt1_path[1]), builddir, "/lib/gcrt1.o", NULL);
-+#endif
-+
-+ xstrcat(&(our_lib_path[0]), "-L", devprefix, "/lib", NULL);
-+ xstrcat(&(our_lib_path[1]), "-L", builddir, "/lib", NULL);
-+
-+#ifdef __UCLIBC_HAS_SHARED__
-+ build_dlstr = "-Wl,--dynamic-linker," BUILD_DYNAMIC_LINKER;
-+ dlstr = getenv("UCLIBC_GCC_DLOPT");
-+ if (!dlstr) {
-+ dlstr = "-Wl,--dynamic-linker," DYNAMIC_LINKER;
-+ }
-+#endif
++ asprintf(rpath_link,"-Wl,-rpath-link,%s/lib", devprefix);
++ asprintf(rpath, "-Wl,-rpath,%s/lib", devprefix);
++ asprintf(uClibc_inc, "%s/include/", devprefix);
++
++//#ifdef CTOR_DTOR
++ asprintf(crt0_path, "%s/lib/crt1.o", devprefix);
++ asprintf(crti_path, "%s/lib/crti.o", devprefix);
++ asprintf(crtn_path, "%s/lib/crtn.o", devprefix);
++//#else
++// *crt0_path = asprintf("%s/lib/crt0.o", devprefix);
++//#endif
++
++ // profiling
++ asprintf(gcrt1_path, "%s/lib/gcrt1.o", devprefix, "/lib/gcrt1.o");
++ asprintf(our_lib_path, "-L%s/lib", devprefix);
+
-+ m = 0;
++ // Figure out where the dynamic linker is.
++ dlstr = getenv("UCLIBC_DYNAMIC_LINKER");
++ if (!dlstr) dlstr = "/lib/ld-uClibc.so.0";
++ asprintf(&dlstr, "-Wl,--dynamic-linker,%s", dlstr);
++
++ liblen = 0;
+ libraries = __builtin_alloca(sizeof(char*) * (argc));
-+ libraries[m] = '\0';
++ libraries[liblen] = '\0';
+
+ n = 0;
+ libpath = __builtin_alloca(sizeof(char*) * (argc));
+ libpath[n] = '\0';
+
++ // Parse the incoming gcc arguments.
++
+ for ( i = 1 ; i < argc ; i++ ) {
-+ if (argv[i][0] == '-') { /* option */
++ if (argv[i][0] == '-' && argv[i][1]) { /* option */
+ switch (argv[i][1]) {
+ case 'c': /* compile or assemble */
+ case 'S': /* generate assembler code */
+ case 'E': /* preprocess only */
+ case 'M': /* generate dependencies */
+ linking = 0;
++ if (argv[i][1] == 'M') sawM = 1;
++ else sawcES = 1;
+ break;
-+ case 'L': /* library */
++
++ case 'L': /* library path */
+ libpath[n++] = argv[i];
+ libpath[n] = '\0';
+ if (argv[i][2] == 0) {
+ }
+ argv[i] = '\0';
+ break;
++
+ case 'l': /* library */
-+ libraries[m++] = argv[i];
-+ libraries[m] = '\0';
++ libraries[liblen++] = argv[i];
++ libraries[liblen] = '\0';
+ argv[i] = '\0';
+ break;
++
+ case 'v': /* verbose */
+ if (argv[i][2] == 0) verbose = 1;
+ printf("Invoked as %s\n", argv[0]);
++ printf("Reference path: %s\n", topdir);
+ break;
++
+ case 'n':
+ if (strcmp(nostdinc,argv[i]) == 0) {
+ use_stdinc = 0;
+ } else if (strcmp(nostartfiles,argv[i]) == 0) {
-+#ifdef __UCLIBC_CTOR_DTOR__
+ ctor_dtor = 0;
-+#endif
+ use_start = 0;
+ } else if (strcmp(nodefaultlibs,argv[i]) == 0) {
+ use_stdlib = 0;
+ argv[i] = '\0';
+ } else if (strcmp(nostdlib,argv[i]) == 0) {
-+#ifdef __UCLIBC_CTOR_DTOR__
+ ctor_dtor = 0;
-+#endif
+ use_start = 0;
+ use_stdlib = 0;
-+ }
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ else if (strcmp(nostdinc_plus,argv[i]) == 0) {
++ } else if (strcmp(nostdinc_plus,argv[i]) == 0) {
+ if (cplusplus==1) {
+ use_nostdinc_plus = 0;
+ }
+ }
-+#endif
+ break;
++
+ case 's':
+ if (strstr(argv[i],static_linking) != NULL) {
+ use_static_linking = 1;
+ use_pic = 1;
+ }
+ break;
++
+ case 'W': /* -static could be passed directly to ld */
+ if (strncmp("-Wl,",argv[i],4) == 0) {
+ if (strstr(argv[i],static_linking) != 0) {
+ }
+ }
+ break;
-+#ifdef __UCLIBC_PROFILING__
-+ case 'p':
-+ if (strcmp("-pg",argv[i]) == 0) {
-+ profile = 1;
-+ }
++
++ case 'p':
++wow_this_sucks:
++ if (!strncmp("-print-",argv[i],7)) {
++ char *temp, *temp2;
++ int itemp, showall = 0;
++
++ temp = argv[i]+7;
++ if (!strcmp(temp, "search-dirs")) {
++ printf("install: %s/\n",devprefix);
++ printf("programs: %s\n",getenv("PATH"));
++ printf("libraries: ");
++ temp2 = "";
++ showall = 1;
++ } else if (!strncmp(temp, "file-name=", 10))
++ temp2 = temp+10;
++ else if (!strcmp(temp, "libgcc-file-name"))
++ temp2="libgcc.a";
++ else break;
++
++ // Find this entry in the library path.
++ for(itemp=0;;itemp++) {
++ if (itemp == n) {
++ asprintf(&temp, "%s/gcc/lib/%s", devprefix, temp2);
++ } else if (itemp == n+1) {
++ // This is so "include" finds the gcc internal
++ // include dir. The uClibc build needs this.
++ asprintf(&temp, "%s/gcc/%s", devprefix, temp2);
++ } else if (itemp == n+2) {
++ temp = temp2;
++ break;
++ } else {
++ asprintf(&temp, "%s/%s", libpath[itemp],
++ temp2);
++ }
++ if (showall) printf(":%s"+(itemp?0:1), temp);
++ else if (!access(temp, F_OK)) break;
++ }
++
++ printf("%s\n"+(showall ? 2 : 0), temp);
++ exit(0);
++
++ // Profiling.
++ } else if (!strcmp("-pg",argv[i])) profile = 1;
+ break;
-+#endif
++
+ case 'f':
+ /* Check if we are doing PIC */
+ if (strcmp("-fPIC",argv[i]) == 0) {
+ use_pic = 1;
+ } else if (strcmp("-fpic",argv[i]) == 0) {
+ use_pic = 1;
-+ }
-+#ifdef __UCLIBC_PROFILING__
-+ else if (strcmp("-fprofile-arcs",argv[i]) == 0) {
++
++ // profiling
++ } else if (strcmp("-fprofile-arcs",argv[i]) == 0) {
+ profile = 1;
+ }
-+#endif
+ break;
+
++ // --longopts
++
+ case '-':
-+ if (strstr(argv[i]+1,static_linking) != NULL) {
++ if (!strncmp(argv[i],"--print-",8)) {
++ argv[i]++;
++ goto wow_this_sucks;
++ } else if (strstr(argv[i]+1,static_linking) != NULL) {
+ use_static_linking = 1;
+ argv[i]='\0';
++ } else if (!strcmp("--version",argv[i])) {
++ printf("uClibc ");
++ fflush(stdout);
++ break;
+ } else if (strcmp("--uclibc-use-build-dir",argv[i]) == 0) {
+ use_build_dir = 1;
+ argv[i]='\0';
+ } else if (strncmp ("--uclibc-cc=", argv[i], 12) == 0) {
+ cc = argv[i] + 12;
+ argv[i] = 0;
-+ }
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ else if (strcmp("--uclibc-no-ctors",argv[i]) == 0) {
++ } else if (strcmp("--uclibc-no-ctors",argv[i]) == 0) {
+ ctor_dtor = 0;
+ argv[i]='\0';
+ }
-+#endif
+ break;
+ }
+ } else { /* assume it is an existing source file */
++ char *p = strchr (argv[i], '\0') - 2;
++ if (p > argv[i] && sawM && (!strcmp(p, ".o") || !strcmp(p, ".a")))
++ sawdotoa = 1;
+ ++source_count;
+ }
+ }
+
-+ gcc_argv = __builtin_alloca(sizeof(char*) * (argc + 64));
-+ gcc_argument = __builtin_alloca(sizeof(char*) * (argc + 20));
++ if (sawdotoa && sawM && !sawcES)
++ linking = 1;
+
-+ i = 0; k = 0;
-+#ifdef __UCLIBC_CTOR_DTOR__
++ argcnt = 0;
+ if (ctor_dtor) {
-+ struct stat statbuf;
-+ if (findlibgcc==1 || stat(LIBGCC_DIR, &statbuf)!=0 ||
-+ !S_ISDIR(statbuf.st_mode))
-+ {
-+ /* Bummer, gcc is hiding from us. This is going
-+ * to really slow things down... bummer. */
-+ int status, gcc_pipe[2];
-+ pid_t pid, wpid;
-+
-+ pipe(gcc_pipe);
-+ if (!(pid = fork())) {
-+ char *argv[4];
-+ close(gcc_pipe[0]);
-+ close(1);
-+ close(2);
-+ dup2(gcc_pipe[1], 1);
-+ dup2(gcc_pipe[1], 2);
-+ argv[0] = cc;
-+ argv[1] = "-print-libgcc-file-name";
-+ argv[2] = NULL;
-+ execvp(cc, argv);
-+ close(gcc_pipe[1]);
-+ _exit(EXIT_FAILURE);
-+ }
-+ wpid=0;
-+ while (wpid != pid) {
-+ wpid = wait(&status);
-+ }
-+ close(gcc_pipe[1]);
-+ if (WIFEXITED(status) && WEXITSTATUS(status)) {
-+crash_n_burn:
-+ fprintf(stderr, "Unable to locale crtbegin.o provided by gcc");
-+ exit(EXIT_FAILURE);
-+ }
-+ if (WIFSIGNALED(status)) {
-+ fprintf(stderr, "%s exited because of uncaught signal %d", cc, WTERMSIG(status));
-+ exit(EXIT_FAILURE);
-+ }
-+
-+ {
-+ char buf[1024], *dir;
-+ status = read(gcc_pipe[0], buf, sizeof(buf));
-+ close(gcc_pipe[0]);
-+ if (status < 0) {
-+ goto crash_n_burn;
-+ }
-+ buf[(status == sizeof(buf)) ? status-1 : status] = 0;
-+ dir = dirname(buf);
-+ xstrcat(&(crtbegin_path[0]), dir, "/crtbegin.o", NULL);
-+ xstrcat(&(crtbegin_path[1]), dir, "/crtbeginS.o", NULL);
-+ xstrcat(&(crtend_path[0]), dir, "/crtend.o", NULL);
-+ xstrcat(&(crtend_path[1]), dir, "/crtendS.o", NULL);
-+ }
-+
-+ } else {
-+ xstrcat(&(crtbegin_path[0]), LIBGCC_DIR, "crtbegin.o", NULL);
-+ xstrcat(&(crtbegin_path[1]), LIBGCC_DIR, "crtbeginS.o", NULL);
-+ xstrcat(&(crtend_path[0]), LIBGCC_DIR, "crtend.o", NULL);
-+ xstrcat(&(crtend_path[1]), LIBGCC_DIR, "crtendS.o", NULL);
-+ }
++ asprintf(crtbegin_path, "%s/gcc/lib/crtbegin.o", devprefix);
++ asprintf(crtbegin_path+1, "%s/gcc/lib/crtbeginS.o", devprefix);
++ asprintf(crtend_path, "%s/gcc/lib/crtend.o", devprefix);
++ asprintf(crtend_path+1, "%s/gcc/lib/crtendS.o", devprefix);
+ }
+
-+ if (cplusplus && cpp)
-+ gcc_argv[i++] = cpp;
-+ else
-+#endif
-+ gcc_argv[i++] = cc;
++ gcc_argv[argcnt++] = cpp ? cpp : cc;
+
-+ for ( j = 1 ; j < argc ; j++ ) {
-+ if (argv[j]=='\0') {
-+ continue;
-+ } else {
-+ gcc_argument[k++] = argv[j];
-+ gcc_argument[k] = '\0';
-+ }
-+ }
++ if (cplusplus) gcc_argv[argcnt++] = "-fno-use-cxa-atexit";
+
+ if (linking && source_count) {
-+#if defined __HAVE_ELF__ && ! defined __UCLIBC_HAS_MMU__
-+ gcc_argv[i++] = "-Wl,-elf2flt";
-+#endif
-+ gcc_argv[i++] = nostdlib;
++//#if defined HAS_ELF && ! defined HAS_MMU
++// gcc_argv[argcnt++] = "-Wl,-elf2flt";
++//#endif
++ gcc_argv[argcnt++] = "-Wl,--hash-style=sysv";
++ gcc_argv[argcnt++] = nostdlib;
+ if (use_static_linking) {
-+ gcc_argv[i++] = static_linking;
-+ }
-+ if (!use_static_linking) {
++ gcc_argv[argcnt++] = static_linking;
++ } else {
+ if (dlstr && use_build_dir) {
-+ gcc_argv[i++] = build_dlstr;
++ gcc_argv[argcnt++] = build_dlstr;
+ } else if (dlstr) {
-+ gcc_argv[i++] = dlstr;
++ gcc_argv[argcnt++] = dlstr;
+ }
+ if (use_rpath) {
-+ gcc_argv[i++] = rpath[use_build_dir];
++ gcc_argv[argcnt++] = rpath[use_build_dir];
+ }
+ }
-+ for ( l = 0 ; l < n ; l++ ) {
-+ if (libpath[l]) gcc_argv[i++] = libpath[l];
-+ }
-+ gcc_argv[i++] = rpath_link[use_build_dir]; /* just to be safe */
++ for ( i = 0 ; i < n ; i++ )
++ if (libpath[i]) gcc_argv[argcnt++] = libpath[i];
++ gcc_argv[argcnt++] = rpath_link[use_build_dir]; /* just to be safe */
+ if( libstr )
-+ gcc_argv[i++] = libstr;
-+ gcc_argv[i++] = our_lib_path[use_build_dir];
-+ if (!use_build_dir) {
-+ gcc_argv[i++] = our_usr_lib_path;
-+ }
++ gcc_argv[argcnt++] = libstr;
++ gcc_argv[argcnt++] = our_lib_path[use_build_dir];
++ if (!use_build_dir)
++ asprintf(gcc_argv+(argcnt++), "-L%s/gcc/lib", devprefix);
+ }
+ if (use_stdinc && source_count) {
-+ gcc_argv[i++] = nostdinc;
-+#ifdef __UCLIBC_CTOR_DTOR__
++ gcc_argv[argcnt++] = nostdinc;
++
+ if (cplusplus) {
-+ char *cppinc;
+ if (use_nostdinc_plus) {
-+ gcc_argv[i++] = nostdinc_plus;
++ gcc_argv[argcnt++] = nostdinc_plus;
+ }
-+ xstrcat(&cppinc, uClibc_inc[use_build_dir], "g++/", NULL);
-+ gcc_argv[i++] = "-isystem";
-+ gcc_argv[i++] = cppinc;
-+ xstrcat(&cppinc, uClibc_inc[use_build_dir], "g++-v3/", NULL);
-+ gcc_argv[i++] = "-isystem";
-+ gcc_argv[i++] = cppinc;
++ gcc_argv[argcnt++] = "-isystem";
++ asprintf(gcc_argv+(argcnt++), "%sc++/4.1.1", uClibc_inc[use_build_dir]);
++ //char *cppinc;
++ //#define TARGET_DIR "gcc/armv4l-unknown-linux/gnu/4.1.1"
++ //xstrcat(&cppinc, uClibc_inc[use_build_dir], "c++/4.1.1/" TARGET_DIR, NULL);
++ //gcc_argv[argcnt++] = "-isystem";
++ //gcc_argv[argcnt++] = cppinc;
++ //xstrcat(&cppinc, uClibc_inc[use_build_dir], "c++/4.1.1", NULL);
++ //gcc_argv[argcnt++] = "-isystem";
++ //gcc_argv[argcnt++] = cppinc;
+ }
-+#endif
-+ gcc_argv[i++] = "-isystem";
-+ gcc_argv[i++] = uClibc_inc[use_build_dir];
-+ gcc_argv[i++] = "-iwithprefix";
-+ gcc_argv[i++] = "include";
-+ if( incstr )
-+ gcc_argv[i++] = incstr;
++
++ gcc_argv[argcnt++] = "-isystem";
++ gcc_argv[argcnt++] = uClibc_inc[use_build_dir];
++ gcc_argv[argcnt++] = "-isystem";
++ asprintf(gcc_argv+(argcnt++), "%s/gcc/include", devprefix);
++ if(incstr) gcc_argv[argcnt++] = incstr;
+ }
+
++ gcc_argv[argcnt++] = "-U__nptl__";
++
+ if (linking && source_count) {
+
-+#ifdef __UCLIBC_PROFILING__
+ if (profile) {
-+ gcc_argv[i++] = gcrt1_path[use_build_dir];
++ gcc_argv[argcnt++] = gcrt1_path[use_build_dir];
+ }
-+#endif
-+#ifdef __UCLIBC_CTOR_DTOR__
+ if (ctor_dtor) {
-+ gcc_argv[i++] = crti_path[use_build_dir];
++ gcc_argv[argcnt++] = crti_path[use_build_dir];
+ if (use_pic) {
-+ gcc_argv[i++] = crtbegin_path[1];
++ gcc_argv[argcnt++] = crtbegin_path[1];
+ } else {
-+ gcc_argv[i++] = crtbegin_path[0];
++ gcc_argv[argcnt++] = crtbegin_path[0];
+ }
+ }
-+#endif
+ if (use_start) {
-+#ifdef __UCLIBC_PROFILING__
-+ if (!profile)
-+#endif
-+ {
-+ gcc_argv[i++] = crt0_path[use_build_dir];
++ if (!profile) {
++ gcc_argv[argcnt++] = crt0_path[use_build_dir];
+ }
+ }
-+ for ( l = 0 ; l < k ; l++ ) {
-+ if (gcc_argument[l]) gcc_argv[i++] = gcc_argument[l];
-+ }
++
++ // Add remaining unclaimed arguments.
++
++ for (i=1; i<argc; i++) if (argv[i]) gcc_argv[argcnt++] = argv[i];
++
+ if (use_stdlib) {
-+ //gcc_argv[i++] = "-Wl,--start-group";
-+ gcc_argv[i++] = "-lgcc";
-+ }
-+ for ( l = 0 ; l < m ; l++ ) {
-+ if (libraries[l]) gcc_argv[i++] = libraries[l];
++ //gcc_argv[argcnt++] = "-Wl,--start-group";
++ gcc_argv[argcnt++] = "-lgcc";
++// gcc_argv[argcnt++] = "-lgcc_eh";
+ }
++ for (i = 0 ; i < liblen ; i++)
++ if (libraries[i]) gcc_argv[argcnt++] = libraries[i];
+ if (use_stdlib) {
-+#ifdef __UCLIBC_CTOR_DTOR__
+ if (cplusplus) {
-+ gcc_argv[ i++ ] = "-lstdc++";
-+ gcc_argv[ i++ ] = "-lm";
++ gcc_argv[argcnt++] = "-lstdc++";
++ gcc_argv[argcnt++] = "-lm";
+ }
-+#endif
-+ gcc_argv[i++] = "-lc";
-+ gcc_argv[i++] = "-lgcc";
-+ //gcc_argv[i++] = "-Wl,--end-group";
++ gcc_argv[argcnt++] = "-lc";
++ gcc_argv[argcnt++] = "-lgcc";
++// gcc_argv[argcnt++] = "-lgcc_eh";
++ //gcc_argv[argcnt++] = "-Wl,--end-group";
+ }
-+#ifdef __UCLIBC_CTOR_DTOR__
+ if (ctor_dtor) {
-+ if (use_pic) {
-+ gcc_argv[i++] = crtend_path[1];
-+ } else {
-+ gcc_argv[i++] = crtend_path[0];
-+ }
-+
-+ gcc_argv[i++] = crtn_path[use_build_dir];
++ gcc_argv[argcnt++] = crtend_path[use_pic ? 1 : 0];
++ gcc_argv[argcnt++] = crtn_path[use_build_dir];
+ }
-+#endif
-+ } else {
-+ for ( l = 0 ; l < k ; l++ ) {
-+ if (gcc_argument[l]) gcc_argv[i++] = gcc_argument[l];
-+ }
-+ }
-+ gcc_argv[i++] = NULL;
++ } else for (i=1; i<argc; i++) if (argv[i]) gcc_argv[argcnt++] = argv[i];
++
++ gcc_argv[argcnt++] = NULL;
+
+ if (verbose) {
-+ for ( j = 0 ; gcc_argv[j] ; j++ ) {
-+ printf("arg[%2i] = %s\n", j, gcc_argv[j]);
++ for ( i = 0 ; gcc_argv[i] ; i++ ) {
++ printf("arg[%2i] = %s\n", i, gcc_argv[i]);
+ }
+ fflush(stdout);
+ }
-+ //no need to free memory from xstrcat because we never return...
-+#ifdef __UCLIBC_CTOR_DTOR__
-+ if (cplusplus && cpp) {
-+ execvp(cpp, gcc_argv);
-+ fprintf(stderr, "%s: %s\n", cpp, strerror(errno));
-+ } else
-+#endif
-+ {
-+ execvp(cc, gcc_argv);
-+ fprintf(stderr, "%s: %s\n", cc, strerror(errno));
++
++ if (debug_wrapper) {
++ dprintf(2, "outgoing: ");
++ for(i=0; gcc_argv[i]; i++) dprintf(2, "%s ",gcc_argv[i]);
++ dprintf(2, "\n\n");
+ }
++
++ //no need to free memory from xstrcat because we never return.
++ execvp(gcc_argv[0], gcc_argv);
++ fprintf(stderr, "%s: %s\n", cpp ? cpp : cc, strerror(errno));
+ exit(EXIT_FAILURE);
+}
-diff -urN uClibc-0.9.26.org/extra/gcc-uClibc/Makefile uClibc-0.9.26/extra/gcc-uClibc/Makefile
---- uClibc-0.9.26.org/extra/gcc-uClibc/Makefile 1970-01-01 01:00:00.000000000 +0100
-+++ uClibc-0.9.26/extra/gcc-uClibc/Makefile 2004-01-25 16:06:22.372828491 +0100
+diff -urN uClibc-0.9.29.org/extra/gcc-uClibc/Makefile uClibc-0.9.29/extra/gcc-uClibc/Makefile
+--- uClibc-0.9.29.org/extra/gcc-uClibc/Makefile 1970-01-01 01:00:00.000000000 +0100
++++ uClibc-0.9.29/extra/gcc-uClibc/Makefile 2007-06-03 22:02:11.494833771 +0200
@@ -0,0 +1,93 @@
+# Makefile for building a fake gcc/binutils toolchain
+# that simply spoofs the location of the C library
+ rm -f gcc-uClibc.h *-uclibc-gcc *-uclibc-ld core
+
+
-diff -ur uClibc/Makefile.in uClibc.toolchain/Makefile.in
---- uClibc/Makefile.in 2006-01-03 09:12:11.000000000 +0100
-+++ uClibc.toolchain/Makefile.in 2006-01-04 18:44:00.000000000 +0100
-@@ -16,7 +16,7 @@
+diff -urN uClibc-0.9.29.org/Makefile.in uClibc-0.9.29/Makefile.in
+--- uClibc-0.9.29.org/Makefile.in 2007-03-19 10:49:04.000000000 +0100
++++ uClibc-0.9.29/Makefile.in 2007-06-03 22:02:11.494833771 +0200
+@@ -17,7 +17,7 @@
ifeq ($(HAVE_DOT_CONFIG),y)
# In this section, we need .config
-include .config.cmd
-@@ -99,7 +99,7 @@
+@@ -108,7 +108,7 @@
pregen: headers
RUNTIME_PREFIX_LIB_FROM_DEVEL_PREFIX_LIB=$(shell $(top_srcdir)extra/scripts/relative_path.sh $(DEVEL_PREFIX)lib $(RUNTIME_PREFIX)lib)
-@@ -236,6 +236,12 @@
+@@ -272,6 +272,12 @@
fi
endif
+ $(MAKE) CROSS="$(CROSS)" CC="$(CC)" -C extra/gcc-uClibc install
+
utils:
- $(MAKE) CROSS="$(CROSS)" CC="$(CC)" -C utils
+ $(Q)$(MAKE) CROSS="$(CROSS)" CC="$(CC)" -C utils
projects / packages / uClibc.git / commitdiff