code review 35900045: lib9, libmach, cmd/dist, go/build: add support for GOOS...

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.
  */
@@ skipping 15 matching lines @@
 char *gochar;
 char *goversion;
 char *slash;    // / for unix, \ for windows
 char *defaultcc;
 char *defaultcxx;
 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);
 
 // The known architecture letters.
 static char *gochars = "568";
 
 // The known architectures.
 static char *okgoarch[] = {
         // same order as gochars
         "arm",
         "amd64",
@@ skipping 441 matching lines @@
                 "$GOROOT/include/fmt.h",
                 "$GOROOT/include/libc.h",
                 "$GOROOT/include/bio.h",
                 "$GOROOT/include/ar.h",
                 "$GOROOT/include/bootexec.h",
                 "$GOROOT/include/mach.h",
                 "$GOROOT/include/ureg_amd64.h",
                 "$GOROOT/include/ureg_arm.h",
                 "$GOROOT/include/ureg_x86.h",
         }},
+        {"liblink", {
+                "$GOROOT/include/u.h",
+                "$GOROOT/include/utf.h",
+                "$GOROOT/include/fmt.h",
+                "$GOROOT/include/libc.h",
+                "$GOROOT/include/bio.h",
+                "$GOROOT/include/ar.h",
+                "$GOROOT/include/link.h",
+                "anames5.c",
+                "anames6.c",
+                "anames8.c",
+        }},
         {"cmd/cc", {
                 "-pgen.c",
                 "-pswt.c",
         }},
         {"cmd/gc", {
                 "-cplx.c",
                 "-pgen.c",
                 "-plive.c",
                 "-popt.c",
                 "-y1.tab.c",  // makefile dreg
                 "opnames.h",
         }},
         {"cmd/5c", {
                 "../cc/pgen.c",
                 "../cc/pswt.c",
-                "../5l/enam.c",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libcc.a",
         }},
         {"cmd/6c", {
                 "../cc/pgen.c",
                 "../cc/pswt.c",
-                "../6l/enam.c",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libcc.a",
         }},
         {"cmd/8c", {
                 "../cc/pgen.c",
                 "../cc/pswt.c",
-                "../8l/enam.c",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libcc.a",
         }},
         {"cmd/5g", {
                 "../gc/cplx.c",
                 "../gc/pgen.c",
                 "../gc/plive.c",
                 "../gc/popt.c",
                 "../gc/popt.h",
-                "../5l/enam.c",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libgc.a",
         }},
         {"cmd/6g", {
                 "../gc/cplx.c",
                 "../gc/pgen.c",
                 "../gc/plive.c",
                 "../gc/popt.c",
                 "../gc/popt.h",
-                "../6l/enam.c",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libgc.a",
         }},
         {"cmd/8g", {
                 "../gc/cplx.c",
                 "../gc/pgen.c",
                 "../gc/plive.c",
                 "../gc/popt.c",
                 "../gc/popt.h",
-                "../8l/enam.c",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libgc.a",
         }},
         {"cmd/5l", {
                 "../ld/*",
-                "enam.c",
         }},
         {"cmd/6l", {
                 "../ld/*",
-                "enam.c",
         }},
         {"cmd/8l", {
                 "../ld/*",
-                "enam.c",
         }},
         {"cmd/go", {
                 "zdefaultcc.go",
         }},
         {"cmd/", {
+                "$GOROOT/pkg/obj/$GOOS_$GOARCH/liblink.a",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libmach.a",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/libbio.a",
                 "$GOROOT/pkg/obj/$GOOS_$GOARCH/lib9.a",
         }},
         {"pkg/runtime", {
                 "zaexperiment.h", // must sort above zasm
                 "zasm_$GOOS_$GOARCH.h",
                 "zsys_$GOOS_$GOARCH.s",
                 "zgoarch_$GOARCH.go",
                 "zgoos_$GOOS.go",
@@ skipping 10 matching lines @@
         ".go",
         ".goc",
 };
 
 // gentab records how to generate some trivial files.
 static struct {
         char *nameprefix;
         void (*gen)(char*, char*);
 } gentab[] = {
         {"opnames.h", gcopnames},
-        {"enam.c", mkenam},
+        {"anames5.c", mkanames},
+        {"anames6.c", mkanames},
+        {"anames8.c", mkanames},
         {"zasm_", mkzasm},
         {"zdefaultcc.go", mkzdefaultcc},
         {"zsys_", mkzsys},
         {"zgoarch_", mkzgoarch},
         {"zgoos_", mkzgoos},
         {"zruntime_defs_", mkzruntimedefs},
         {"zversion.go", mkzversion},
         {"zaexperiment.h", mkzexperiment},
+
+        // not generated anymore, but delete the file if we see it
+        {"enam.c", nil},
 };
 
 // install installs the library, package, or binary associated with dir,
 // which is relative to $GOROOT/src.
 static void
 install(char *dir)
 {
         char *name, *p, *elem, *prefix, *exe;
-        bool islib, ispkg, isgo, stale;
+        bool islib, ispkg, isgo, stale, ispackcmd;
         Buf b, b1, path;
         Vec compile, files, link, go, missing, clean, lib, extra;
         Time ttarg, t;
-        int i, j, k, n, doclean, targ, usecpp;
+        int i, j, k, n, doclean, targ;
 
         if(vflag) {
                 if(!streq(goos, gohostos) || !streq(goarch, gohostarch))
                         errprintf("%s (%s/%s)\n", dir, goos, goarch);
                 else
                         errprintf("%s\n", dir);
         }
 
         binit(&b);
         binit(&b1);
@@ skipping 31 matching lines @@
                 bprintf(&b, "%s", defaultcc);
                 splitfields(&gccargs, bstr(&b));
                 for(i=0; i<nelem(proto_gccargs); i++)
                         vadd(&gccargs, proto_gccargs[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");
                 }
         }
 
         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";
 
         // Start final link command line.
         // Note: code below knows that link.p[targ] is the target.
+        ispackcmd = 0;
         if(islib) {
                 // C library.
                 vadd(&link, "ar");
                 if(streq(gohostos, "plan9"))
                         vadd(&link, "rc");
                 else
                         vadd(&link, "rsc");
                 prefix = "";
                 if(!hasprefix(name, "lib"))
                         prefix = "lib";
                 targ = link.len;
                 vadd(&link, bpathf(&b, "%s/pkg/obj/%s_%s/%s%s.a", goroot, gohostos, gohostarch, prefix, name));
         } else if(ispkg) {
                 // Go library (package).
-                vadd(&link, bpathf(&b, "%s/pack", tooldir));
-                vadd(&link, "grc");
+                ispackcmd = 1;
+                vadd(&link, "pack"); // program name - unused here, but all the other cases record one
                 p = bprintf(&b, "%s/pkg/%s_%s/%s", goroot, goos, goarch, dir+4);
                 *xstrrchr(p, '/') = '\0';
                 xmkdirall(p);
                 targ = link.len;
                 vadd(&link, bpathf(&b, "%s/pkg/%s_%s/%s.a", goroot, goos, goarch, dir+4));
         } 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;
@@ skipping 46 matching lines @@
         for(i=0; i<nelem(deptab); i++) {
                 if(hasprefix(dir, deptab[i].prefix)) {
                         for(j=0; (p=deptab[i].dep[j])!=nil; j++) {
                                 breset(&b1);
                                 bwritestr(&b1, p);
                                 bsubst(&b1, "$GOROOT", goroot);
                                 bsubst(&b1, "$GOOS", goos);
                                 bsubst(&b1, "$GOARCH", goarch);
                                 p = bstr(&b1);
                                 if(hassuffix(p, ".a")) {
-                                        if(streq(gohostos, "plan9") && hassuffix(p, "libbio.a"))
-                                                continue;
                                         vadd(&lib, bpathf(&b, "%s", p));
                                         continue;
                                 }
                                 if(hassuffix(p, "/*")) {
                                         bpathf(&b, "%s/%s", bstr(&path), p);
                                         b.len -= 2;
                                         xreaddir(&extra, bstr(&b));
                                         bprintf(&b, "%s", p);
                                         b.len -= 2;
                                         for(k=0; k<extra.len; k++)
@@ skipping 80 matching lines @@
                         bpathf(&b1, "%s/os_%s.h", bstr(&path), goos), 0);
                 copy(bpathf(&b, "%s/signals_GOOS.h", workdir),
                         bpathf(&b1, "%s/signals_%s.h", bstr(&path), goos), 0);
         }
 
         // Generate any missing files; regenerate existing ones.
         for(i=0; i<files.len; i++) {
                 p = files.p[i];
                 elem = lastelem(p);
                 for(j=0; j<nelem(gentab); j++) {
+                        if(gentab[j].gen == nil)
+                                continue;
                         if(hasprefix(elem, gentab[j].nameprefix)) {
                                 if(vflag > 1)
                                         errprintf("generate %s\n", p);
                                 gentab[j].gen(bstr(&path), p);
                                 // Do not add generated file to clean list.
                                 // In pkg/runtime, we want to be able to
                                 // build the package with the go tool,
                                 // and it assumes these generated files already
                                 // exist (it does not know how to build them).
                                 // The 'clean' command can remove
@@ skipping 31 matching lines @@
                 vuniq(&files);
         }
 
         if((!streq(goos, gohostos) || !streq(goarch, gohostarch)) && isgo) {
                 // We've generated the right files; the go command can do the build.
                 if(vflag > 1)
                         errprintf("skip build for cross-compile %s\n", dir);
                 goto nobuild;
         }
 
-        // The files generated by GNU Bison use macros that aren't
-        // supported by the Plan 9 compilers so we have to use the
-        // external preprocessor when compiling.
-        usecpp = 0;
-        if(streq(gohostos, "plan9")) {
-                for(i=0; i<files.len; i++) {
-                        p = files.p[i];
-                        if(hassuffix(p, "y.tab.c") || hassuffix(p, "y.tab.h")){
-                                usecpp = 1;
-                                break;
-                        }
-                }
-        }
-
         // Compile the files.
         for(i=0; i<files.len; i++) {
                 if(!hassuffix(files.p[i], ".c") && !hassuffix(files.p[i], ".s"))
                         continue;
                 name = lastelem(files.p[i]);
 
                 vreset(&compile);
                 if(!isgo) {
                         // C library or tool.
                         if(streq(gohostos, "plan9")) {
                                 vadd(&compile, bprintf(&b, "%sc", gohostchar));
-                                vadd(&compile, "-FTVw");
-                                if(usecpp)
-                                        vadd(&compile, "-Bp+");
+                                vadd(&compile, "-FTVwp");
+                                vadd(&compile, "-DPLAN9");
+                                vadd(&compile, "-D__STDC__=1");
+                                vadd(&compile, "-D__SIZE_TYPE__=ulong"); // for GNU Bison
                                 vadd(&compile, bpathf(&b, "-I%s/include/plan9", goroot));
                                 vadd(&compile, bpathf(&b, "-I%s/include/plan9/%s", goroot, gohostarch));
-                                // Work around Plan 9 C compiler's handling of #include with .. path.
-                                vadd(&compile, bpathf(&b, "-I%s/src/cmd/ld", goroot));
                         } else {
                                 vcopy(&compile, gccargs.p, gccargs.len);
                                 vadd(&compile, "-c");
                                 if(streq(gohostarch, "amd64"))
                                         vadd(&compile, "-m64");
                                 else if(streq(gohostarch, "386"))
                                         vadd(&compile, "-m32");
                                 if(streq(dir, "lib9"))
                                         vadd(&compile, "-DPLAN9PORT");
 ········
@@ skipping 80 matching lines @@
                         vadd(&clean, bstr(&b));
         }
         bgwait();
 
         if(isgo) {
                 // The last loop was compiling individual files.
                 // Hand the Go files to the compiler en masse.
                 vreset(&compile);
                 vadd(&compile, bpathf(&b, "%s/%sg", tooldir, gochar));
 
-                bpathf(&b, "%s/_go_.%s", workdir, gochar);
+                bpathf(&b, "%s/_go_.a", workdir);
+                vadd(&compile, "-pack");
                 vadd(&compile, "-o");
                 vadd(&compile, bstr(&b));
                 vadd(&clean, bstr(&b));
-                vadd(&link, bstr(&b));
+                if(!ispackcmd)
+                        vadd(&link, bstr(&b));
 
                 vadd(&compile, "-p");
                 if(hasprefix(dir, "pkg/"))
                         vadd(&compile, dir+4);
                 else
                         vadd(&compile, "main");
 
                 if(streq(dir, "pkg/runtime"))
                         vadd(&compile, "-+");
 
                 vcopy(&compile, go.p, go.len);
 
                 runv(nil, bstr(&path), CheckExit, &compile);
+
+                if(ispackcmd) {
+                        xremove(link.p[targ]);
+                        dopack(link.p[targ], bstr(&b), &link.p[targ+1], link.len - (targ+1));
+                        goto nobuild;
+                }
         }
 
         if(!islib && !isgo) {
                 // C binaries need the libraries explicitly, and -lm.
                 vcopy(&link, lib.p, lib.len);
                 if(!streq(gohostos, "plan9"))
                         vadd(&link, "-lm");
         }
 
         // Remove target before writing it.
@@ skipping 64 matching lines @@
         // The main exception is libmach which has been modified
         // in various places to support Go object files.
         if(streq(gohostos, "plan9")) {
                 if(streq(dir, "lib9")) {
                         name = lastelem(file);
                         if(streq(name, "goos.c") || streq(name, "flag.c"))
                                 return 1;
                         if(!contains(name, "plan9"))
                                 return 0;
                 }
-                if(streq(dir, "libbio"))
-                        return 0;
         }
 ········
         // Check file name for GOOS or GOARCH.
         name = lastelem(file);
         for(i=0; i<nelem(okgoos); i++)
                 if(contains(name, okgoos[i]) && !streq(okgoos[i], goos))
                         return 0;
         for(i=0; i<nelem(okgoarch); i++)
                 if(contains(name, okgoarch[i]) && !streq(okgoarch[i], goarch))
                         return 0;
@@ skipping 66 matching lines @@
 
         if(vflag > 1)
                 errprintf("cp %s %s\n", src, dst);
 
         binit(&b);
         readfile(&b, src);
         writefile(&b, dst, exec);
         bfree(&b);
 }
 
+// dopack copies the package src to dst,
+// appending the files listed in extra.
+// The archive format is the traditional Unix ar format.
+static void
+dopack(char *dst, char *src, char **extra, int nextra)
+{
+        int i;
+        char c, *p, *q;
+        Buf b, bdst;
+········
+        binit(&b);
+        binit(&bdst);
+
+        readfile(&bdst, src);
+        for(i=0; i<nextra; i++) {
+                readfile(&b, extra[i]);
+                // find last path element for archive member name
+                p = xstrrchr(extra[i], '/');
+                if(p)
+                        p++;
+                q = xstrrchr(extra[i], '\\');
+                if(q) {
+                        q++;
+                        if(p == nil || q > p)
+                                p = q;
+                }
+                if(p == nil)
+                        p = extra[i];
+                bwritef(&bdst, "%-16.16s%-12d%-6d%-6d%-8o%-10d`\n", p, 0, 0, 0, 0644, b.len);
+                bwriteb(&bdst, &b);
+                if(b.len&1) {
+                        c = 0;
+                        bwrite(&bdst, &c, 1);
+                }
+        }
+
+        writefile(&bdst, dst, 0);
+
+        bfree(&b);
+        bfree(&bdst);
+}
+
 // buildorder records the order of builds for the 'go bootstrap' command.
 static char *buildorder[] = {
         "lib9",
         "libbio",
         "libmach",
+        "liblink",
 
         "misc/pprof",
 
         "cmd/addr2line",
-        "cmd/nm",
         "cmd/objdump",
         "cmd/pack",
         "cmd/prof",
 
         "cmd/cc",  // must be before c
         "cmd/gc",  // must be before g
         "cmd/%sl",  // must be before a, c, g
         "cmd/%sa",
         "cmd/%sc",
         "cmd/%sg",
@@ skipping 58 matching lines @@
         "cmd/6c",
         "cmd/6g",
         "cmd/6l",
         "cmd/8a",
         "cmd/8c",
         "cmd/8g",
         "cmd/8l",
         "cmd/addr2line",
         "cmd/cc",
         "cmd/gc",
-        "cmd/go",
-        "cmd/nm",
+        "cmd/go",       
         "cmd/objdump",
         "cmd/pack",
         "cmd/prof",
         "lib9",
         "libbio",
         "libmach",
+        "liblink",
         "pkg/bufio",
         "pkg/bytes",
         "pkg/container/heap",
         "pkg/encoding",
         "pkg/encoding/base64",
         "pkg/encoding/json",
         "pkg/errors",
         "pkg/flag",
         "pkg/fmt",
         "pkg/go/ast",
@@ skipping 390 matching lines @@
                 break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
 
         xprintf("%s\n", goversion);
 }