code review 69860055: cmd/dist: respect system CFLAGS/LDFLAGS

src/cmd/dist/build.c

 // Copyright 2012 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "a.h"
 #include "arg.h"
 
 /*
  * Initialization for any invocation.
  */
 
 // The usual variables.
 char *goarch;
 char *gobin;
 char *gohostarch;
 char *gohostchar;
 char *gohostos;
 char *goos;
 char *goarm;
 char *go386;
 char *goroot = GOROOT_FINAL;
 char *goroot_final = GOROOT_FINAL;
 char *goextlinkenabled = "";
 char *workdir;
 char *tooldir;
 char *gochar;
 char *goversion;
 char *slash;    // / for unix, \ for windows
 char *defaultcc;
+char *defaultcflags;
+char *defaultldflags;
 char *defaultcxxtarget;
 char *defaultcctarget;
 bool    rebuildall;
 bool defaultclang;
 
 static bool shouldbuild(char*, char*);
 static void copy(char*, char*, int);
 static void dopack(char*, char*, char**, int);
 static char *findgoversion(void);
 
@@ skipping 121 matching lines @@
                 // Xcode for OS X 10.9 Mavericks will ship a fake "gcc" binary that
                 // actually runs clang. We prepare different command
                 // lines for the two binaries, so it matters what we call it.
                 // See golang.org/issue/5822.
                 if(defaultclang)
                         bprintf(&b, "clang");
                 else
                         bprintf(&b, "gcc");
         }
         defaultcc = btake(&b);
+
+        xgetenv(&b, "CFLAGS");
+        defaultcflags = btake(&b);
+
+        xgetenv(&b, "LDFLAGS");
+        defaultldflags = btake(&b);
 
         xgetenv(&b, "CC_FOR_TARGET");
         if(b.len == 0) {
                 bprintf(&b, defaultcc);
         }
         defaultcctarget = btake(&b);
 
         xgetenv(&b, "CXX_FOR_TARGET");
         if(b.len == 0) {
                 xgetenv(&b, "CXX");
@@ skipping 277 matching lines @@
         "-Wno-comment",
         "-Wno-missing-field-initializers",
         "-Werror",
         "-fno-common",
         "-ggdb",
         "-pipe",
 #if defined(__NetBSD__) && defined(__arm__)
         // GCC 4.5.4 (NetBSD nb1 20120916) on ARM is known to mis-optimize gc/mparith3.c
         // Fix available at http://patchwork.ozlabs.org/patch/64562/.
         "-O1",
+#endif
+};
+
+// gccargs2 is the second part of gccargs.
+// it is used if the environment isn't defining CFLAGS.
+static char *proto_gccargs2[] = {
+#if defined(__NetBSD__) && defined(__arm__)
 #else
         "-O2",
 #endif
 };
 
-static Vec gccargs;
+static Vec gccargs, ldargs;
 
 // deptab lists changes to the default dependencies for a given prefix.
 // deps ending in /* read the whole directory; deps beginning with -
 // exclude files with that prefix.
 static struct {
         char *prefix;  // prefix of target
         char *dep[20];  // dependency tweaks for targets with that prefix
 } deptab[] = {
         {"lib9", {
                 "$GOROOT/include/u.h",
@@ skipping 191 matching lines @@
 
         // For release, cmd/prof is not included.
         if((streq(dir, "cmd/prof")) && !isdir(bstr(&path))) {
                 if(vflag > 1)
                         errprintf("skipping %s - does not exist\n", dir);
                 goto out;
         }
 
         // set up gcc command line on first run.
         if(gccargs.len == 0) {
-                bprintf(&b, "%s", defaultcc);
+                bprintf(&b, "%s %s", defaultcc, defaultcflags);
                 splitfields(&gccargs, bstr(&b));
                 for(i=0; i<nelem(proto_gccargs); i++)
                         vadd(&gccargs, proto_gccargs[i]);
+                if(defaultcflags[0] == '\0') {
+                        for(i=0; i<nelem(proto_gccargs2); i++)
+                                vadd(&gccargs, proto_gccargs2[i]);
+                }
                 if(contains(gccargs.p[0], "clang")) {
                         // disable ASCII art in clang errors, if possible
                         vadd(&gccargs, "-fno-caret-diagnostics");
                         // clang is too smart about unused command-line arguments
                         vadd(&gccargs, "-Qunused-arguments");
                 }
                 // disable word wrapping in error messages
                 vadd(&gccargs, "-fmessage-length=0");
                 if(streq(gohostos, "darwin")) {
                         // golang.org/issue/5261
                         vadd(&gccargs, "-mmacosx-version-min=10.6");
                 }
+        }
+        if(ldargs.len == 0 && defaultldflags[0] != '\0') {
+                bprintf(&b, "%s", defaultldflags);
+                splitfields(&ldargs, bstr(&b));
         }
 
         islib = hasprefix(dir, "lib") || streq(dir, "cmd/cc") || streq(dir, "cmd/gc");
         ispkg = hasprefix(dir, "pkg");
         isgo = ispkg || streq(dir, "cmd/go") || streq(dir, "cmd/cgo");
 
         exe = "";
         if(streq(gohostos, "windows"))
                 exe = ".exe";
 
@@ skipping 24 matching lines @@
         } else if(streq(dir, "cmd/go") || streq(dir, "cmd/cgo")) {
                 // Go command.
                 vadd(&link, bpathf(&b, "%s/%sl", tooldir, gochar));
                 vadd(&link, "-o");
                 elem = name;
                 if(streq(elem, "go"))
                         elem = "go_bootstrap";
                 targ = link.len;
                 vadd(&link, bpathf(&b, "%s/%s%s", tooldir, elem, exe));
         } else {
-                // C command. Use gccargs.
+                // C command. Use gccargs and ldargs.
                 if(streq(gohostos, "plan9")) {
                         vadd(&link, bprintf(&b, "%sl", gohostchar));
                         vadd(&link, "-o");
                         targ = link.len;
                         vadd(&link, bpathf(&b, "%s/%s", tooldir, name));
                 } else {
                         vcopy(&link, gccargs.p, gccargs.len);
+                        vcopy(&link, ldargs.p, ldargs.len);
                         if(sflag)
                                 vadd(&link, "-static");
                         vadd(&link, "-o");
                         targ = link.len;
                         vadd(&link, bpathf(&b, "%s/%s%s", tooldir, name, exe));
                         if(streq(gohostarch, "amd64"))
                                 vadd(&link, "-m64");
                         else if(streq(gohostarch, "386"))
                                 vadd(&link, "-m32");
                 }
@@ skipping 1023 matching lines @@
                 break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
 
         xprintf("%s\n", goversion);
 }