code review 5608059: build: dist-based build for Plan 9

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 521 matching lines @@
 // 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;
         Buf b, b1, path;
         Vec compile, files, link, go, missing, clean, lib, extra;
         Time ttarg, t;
-        int i, j, k, n, doclean, targ;
+        int i, j, k, n, doclean, targ, usecpp;
 
         if(vflag) {
                 if(!streq(goos, gohostos) || !streq(goarch, gohostarch))
                         xprintf("%s (%s/%s)\n", dir, goos, goarch);
                 else
                         xprintf("%s\n", dir);
         }
 
         binit(&b);
         binit(&b1);
         binit(&path);
         vinit(&compile);
         vinit(&files);
         vinit(&link);
         vinit(&go);
         vinit(&missing);
         vinit(&clean);
         vinit(&lib);
         vinit(&extra);
 
+
         // path = full path to dir.
         bpathf(&path, "%s/src/%s", goroot, dir);
         name = lastelem(dir);
 
         // For misc/prof, copy into the tool directory and we're done.
         if(hasprefix(dir, "misc/")) {
                 copy(bpathf(&b, "%s/%s", tooldir, name),
                         bpathf(&b1, "%s/misc/%s", goroot, name), 1);
                 goto out;
         }
@@ skipping 25 matching lines @@
 
         exe = "";
         if(streq(gohostos, "windows"))
                 exe = ".exe";
 
         // Start final link command line.
         // Note: code below knows that link.p[targ] is the target.
         if(islib) {
                 // C library.
                 vadd(&link, "ar");
-                vadd(&link, "rsc");
+                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");
                 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;
                 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.
-                vcopy(&link, gccargs.p, gccargs.len);
-                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");
+                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);
+                        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");
+                }
         }
         ttarg = mtime(link.p[targ]);
 
         // Gather files that are sources for this target.
         // Everything in that directory, and any target-specific
         // additions.
         xreaddir(&files, bstr(&path));
 
         // Remove files beginning with . or _,
         // which are likely to be editor temporary files.
@@ skipping 13 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 49 matching lines @@
                         stale = 1;
                 if(t == 0) {
                         vadd(&missing, p);
                         files.p[n++] = files.p[i];
                         continue;
                 }
                 files.p[n++] = files.p[i];
         }
         files.len = n;
 
+        // If there are no files to compile, we're done.
+        if(files.len == 0)
+                goto out;
+········
         for(i=0; i<lib.len && !stale; i++)
                 if(mtime(lib.p[i]) > ttarg)
                         stale = 1;
 
         if(!stale)
                 goto out;
 
         // For package runtime, copy some files into the work space.
         if(streq(dir, "pkg/runtime")) {
                 copy(bpathf(&b, "%s/arch_GOARCH.h", workdir),
@@ skipping 38 matching lines @@
                 copy(bpathf(&b, "%s/zasm_GOOS_GOARCH.h", workdir),
                         bpathf(&b1, "%s/zasm_%s_%s.h", bstr(&path), goos, goarch), 0);
         }
 
         // Generate .c files from .goc files.
         if(streq(dir, "pkg/runtime")) {
                 for(i=0; i<files.len; i++) {
                         p = files.p[i];
                         if(!hassuffix(p, ".goc"))
                                 continue;
-                        // b = path/zp but with _goarch.c instead of .goc
+                        // b = path/zp but with _goos_goarch.c instead of .goc
                         bprintf(&b, "%s%sz%s", bstr(&path), slash, lastelem(p));
                         b.len -= 4;
-                        bwritef(&b, "_%s.c", goarch);
+                        bwritef(&b, "_%s_%s.c", goos, goarch);
                         goc2c(p, bstr(&b));
                         vadd(&files, bstr(&b));
                 }
                 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)
                         xprintf("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.
-                        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");
-
-                        vadd(&compile, "-I");
-                        vadd(&compile, bpathf(&b, "%s/include", goroot));
+                        if(streq(gohostos, "plan9")) {
+                                vadd(&compile, bprintf(&b, "%sc", gohostchar));
+                                vadd(&compile, "-FTVw");
+                                if(usecpp)
+                                        vadd(&compile, "-Bp+");
+                                vadd(&compile, bpathf(&b, "-I%s/include/plan9", goroot));
+                                vadd(&compile, bpathf(&b, "-I%s/include/plan9/%s", goroot, gohostarch));
+                        } 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");
+ ·······
+                                vadd(&compile, "-I");
+                                vadd(&compile, bpathf(&b, "%s/include", goroot));
+                        }
 
                         vadd(&compile, "-I");
                         vadd(&compile, bstr(&path));
 
                         // lib9/goos.c gets the default constants hard-coded.
                         if(streq(name, "goos.c")) {
                                 vadd(&compile, bprintf(&b, "-DGOOS=\"%s\"", goos));
                                 vadd(&compile, bprintf(&b, "-DGOARCH=\"%s\"", goarch));
                                 bprintf(&b1, "%s", goroot_final);
                                 bsubst(&b1, "\\", "\\\\");  // turn into C string
@@ skipping 26 matching lines @@
                         // To debug C programs on OS X, it is not enough to say -ggdb
                         // on the command line.  You have to leave the object files
                         // lying around too.  Leave them in pkg/obj/, which does not
                         // get removed when this tool exits.
                         bpathf(&b1, "%s/pkg/obj/%s", goroot, dir);
                         xmkdirall(bstr(&b1));
                         bpathf(&b, "%s/%s", bstr(&b1), lastelem(files.p[i]));
                         doclean = 0;
                 }
 
-                b.p[b.len-1] = 'o';  // was c or s
+                // Change the last character of the output file (which was c or s).
+                if(streq(gohostos, "plan9"))
+                        b.p[b.len-1] = gohostchar[0];
+                else
+                        b.p[b.len-1] = 'o';
                 vadd(&compile, "-o");
                 vadd(&compile, bstr(&b));
                 vadd(&compile, files.p[i]);
                 bgrunv(bstr(&path), CheckExit, &compile);
 
                 vadd(&link, bstr(&b));
                 if(doclean)
                         vadd(&clean, bstr(&b));
         }
         bgwait();
@@ skipping 20 matching lines @@
                         vadd(&compile, "-+");
 
                 vcopy(&compile, go.p, go.len);
 
                 runv(nil, bstr(&path), CheckExit, &compile);
         }
 
         if(!islib && !isgo) {
                 // C binaries need the libraries explicitly, and -lm.
                 vcopy(&link, lib.p, lib.len);
-                vadd(&link, "-lm");
+                if(!streq(gohostos, "plan9"))
+                        vadd(&link, "-lm");
         }
 
         // Remove target before writing it.
         xremove(link.p[targ]);
 
         runv(nil, nil, CheckExit, &link);
 
 nobuild:
         // In package runtime, we install runtime.h and cgocall.h too,
         // for use by cgo compilation.
@@ skipping 37 matching lines @@
 // We also allow the special tag cmd_go_bootstrap.
 // See ../go/bootstrap.go and package go/build.
 static bool
 shouldbuild(char *file, char *dir)
 {
         char *name, *p;
         int i, j, ret;
         Buf b;
         Vec lines, fields;
 
+        // On Plan 9, most of the libraries are already present.
+        // 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") && !hassuffix(file, "lib9/goos.c"))
+                        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;
 
         // Omit test files.
@@ skipping 284 matching lines @@
         char *sep;
         Buf b, b1;
         char *format;
 
         binit(&b);
         binit(&b1);
 
         format = "%s=\"%s\"\n";
         pflag = 0;
         ARGBEGIN{
+        case '9':
+                format = "%s='%s'\n";
+                break;
         case 'p':
                 pflag = 1;
                 break;
         case 'v':
                 vflag++;
                 break;
         case 'w':
                 format = "set %s=%s\n";
                 break;
         default:
@@ skipping 226 matching lines @@
                 break;
         default:
                 usage();
         }ARGEND
 
         if(argc > 0)
                 usage();
 
         xprintf("%s\n", goversion);
 }