Home | History | Annotate | Line # | Download | only in config
mkmakefile.c revision 1.52 
      1 /*	$NetBSD: mkmakefile.c,v 1.52 2015/09/01 11:22:59 uebayasi Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1992, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * This software was developed by the Computer Systems Engineering group
      8  * at Lawrence Berkeley Laboratory under DARPA contract BG 91-66 and
      9  * contributed to Berkeley.
     10  *
     11  * All advertising materials mentioning features or use of this software
     12  * must display the following acknowledgement:
     13  *	This product includes software developed by the University of
     14  *	California, Lawrence Berkeley Laboratories.
     15  *
     16  * Redistribution and use in source and binary forms, with or without
     17  * modification, are permitted provided that the following conditions
     18  * are met:
     19  * 1. Redistributions of source code must retain the above copyright
     20  *    notice, this list of conditions and the following disclaimer.
     21  * 2. Redistributions in binary form must reproduce the above copyright
     22  *    notice, this list of conditions and the following disclaimer in the
     23  *    documentation and/or other materials provided with the distribution.
     24  * 3. Neither the name of the University nor the names of its contributors
     25  *    may be used to endorse or promote products derived from this software
     26  *    without specific prior written permission.
     27  *
     28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     38  * SUCH DAMAGE.
     39  *
     40  *	from: @(#)mkmakefile.c	8.1 (Berkeley) 6/6/93
     41  */
     42 
     43 #if HAVE_NBTOOL_CONFIG_H
     44 #include "nbtool_config.h"
     45 #endif
     46 
     47 #include <sys/cdefs.h>
     48 __RCSID("$NetBSD: mkmakefile.c,v 1.52 2015/09/01 11:22:59 uebayasi Exp $");
     49 
     50 #include <sys/param.h>
     51 #include <ctype.h>
     52 #include <errno.h>
     53 #include <stdio.h>
     54 #include <stdlib.h>
     55 #include <string.h>
     56 #include <err.h>
     57 #include <util.h>
     58 #include "defs.h"
     59 #include "sem.h"
     60 
     61 /*
     62  * Make the Makefile.
     63  */
     64 
     65 static void emitdefs(FILE *);
     66 static void emitfiles(FILE *, int, int);
     67 
     68 static void emitobjs(FILE *);
     69 static void emitallkobjs(FILE *);
     70 static int emitallkobjscb(const char *, void *, void *);
     71 static void emitattrkobjs(FILE *);
     72 static int emitattrkobjscb(const char *, void *, void *);
     73 static void emitkobjs(FILE *);
     74 static void emitcfiles(FILE *);
     75 static void emitsfiles(FILE *);
     76 static void emitrules(FILE *);
     77 static void emitload(FILE *);
     78 static void emitincludes(FILE *);
     79 static void emitappmkoptions(FILE *);
     80 static void emitsubs(FILE *, const char *, const char *, int);
     81 static int  selectopt(const char *, void *);
     82 
     83 int has_build_kernel;
     84 
     85 int
     86 mkmakefile(void)
     87 {
     88 	FILE *ifp, *ofp;
     89 	int lineno;
     90 	void (*fn)(FILE *);
     91 	char line[BUFSIZ], ifname[200];
     92 
     93 	/*
     94 	 * Check if conf/Makefile.kern.inc defines "build_kernel".
     95 	 *
     96 	 * (This is usually done by checking "version" in sys/conf/files;
     97 	 * unfortunately the "build_kernel" change done around 2014 Aug didn't
     98 	 * bump that version.  Thus this hack.)
     99 	 */
    100 	(void)snprintf(ifname, sizeof(ifname), "%s/conf/Makefile.kern.inc",
    101 	    srcdir);
    102 	if ((ifp = fopen(ifname, "r")) == NULL) {
    103 		warn("cannot read %s", ifname);
    104 		goto bad2;
    105 	}
    106 	while (fgets(line, sizeof(line), ifp) != NULL) {
    107 		if (strncmp(line, "build_kernel:", 13) == 0) {
    108 			has_build_kernel = 1;
    109 			break;
    110 		}
    111 	}
    112 	(void)fclose(ifp);
    113 
    114 	/*
    115 	 * Try a makefile for the port first.
    116 	 */
    117 	(void)snprintf(ifname, sizeof(ifname), "%s/arch/%s/conf/Makefile.%s",
    118 	    srcdir, machine, machine);
    119 	if ((ifp = fopen(ifname, "r")) == NULL) {
    120 		/*
    121 		 * Try a makefile for the architecture second.
    122 		 */
    123 		(void)snprintf(ifname, sizeof(ifname),
    124 		    "%s/arch/%s/conf/Makefile.%s",
    125 		    srcdir, machinearch, machinearch);
    126 		ifp = fopen(ifname, "r");
    127 	}
    128 	if (ifp == NULL) {
    129 		warn("cannot read %s", ifname);
    130 		goto bad2;
    131 	}
    132 
    133 	if ((ofp = fopen("Makefile.tmp", "w")) == NULL) {
    134 		warn("cannot write Makefile");
    135 		goto bad1;
    136 	}
    137 
    138 	emitdefs(ofp);
    139 
    140 	lineno = 0;
    141 	while (fgets(line, sizeof(line), ifp) != NULL) {
    142 		lineno++;
    143 		if ((version < 20090214 && line[0] != '%') || line[0] == '#') {
    144 			fputs(line, ofp);
    145 			continue;
    146 		}
    147 		if (strcmp(line, "%OBJS\n") == 0)
    148 			fn = Mflag ? emitkobjs : emitobjs;
    149 		else if (strcmp(line, "%CFILES\n") == 0)
    150 			fn = emitcfiles;
    151 		else if (strcmp(line, "%SFILES\n") == 0)
    152 			fn = emitsfiles;
    153 		else if (strcmp(line, "%RULES\n") == 0)
    154 			fn = emitrules;
    155 		else if (strcmp(line, "%LOAD\n") == 0)
    156 			fn = emitload;
    157 		else if (strcmp(line, "%INCLUDES\n") == 0)
    158 			fn = emitincludes;
    159 		else if (strcmp(line, "%MAKEOPTIONSAPPEND\n") == 0)
    160 			fn = emitappmkoptions;
    161 		else if (strncmp(line, "%VERSION ", sizeof("%VERSION ")-1) == 0) {
    162 			int newvers;
    163 			if (sscanf(line, "%%VERSION %d\n", &newvers) != 1) {
    164 				cfgxerror(ifname, lineno, "syntax error for "
    165 				    "%%VERSION");
    166 			} else
    167 				setversion(newvers);
    168 			continue;
    169 		} else {
    170 			if (version < 20090214)
    171 				cfgxerror(ifname, lineno,
    172 				    "unknown %% construct ignored: %s", line);
    173 			else
    174 				emitsubs(ofp, line, ifname, lineno);
    175 			continue;
    176 		}
    177 		(*fn)(ofp);
    178 	}
    179 
    180 	fflush(ofp);
    181 	if (ferror(ofp))
    182 		goto wrerror;
    183 
    184 	if (ferror(ifp)) {
    185 		warn("error reading %s (at line %d)", ifname, lineno);
    186 		goto bad;
    187 	}
    188 
    189 	if (fclose(ofp)) {
    190 		ofp = NULL;
    191 		goto wrerror;
    192 	}
    193 	(void)fclose(ifp);
    194 
    195 	if (moveifchanged("Makefile.tmp", "Makefile") != 0) {
    196 		warn("error renaming Makefile");
    197 		goto bad2;
    198 	}
    199 	return (0);
    200 
    201  wrerror:
    202 	warn("error writing Makefile");
    203  bad:
    204 	if (ofp != NULL)
    205 		(void)fclose(ofp);
    206  bad1:
    207 	(void)fclose(ifp);
    208 	/* (void)unlink("Makefile.tmp"); */
    209  bad2:
    210 	return (1);
    211 }
    212 
    213 static void
    214 emitsubs(FILE *fp, const char *line, const char *file, int lineno)
    215 {
    216 	char *nextpct;
    217 	const char *optname;
    218 	struct nvlist *option;
    219 
    220 	while (*line != '\0') {
    221 		if (*line != '%') {
    222 			fputc(*line++, fp);
    223 			continue;
    224 		}
    225 
    226 		line++;
    227 		nextpct = strchr(line, '%');
    228 		if (nextpct == NULL) {
    229 			cfgxerror(file, lineno, "unbalanced %% or "
    230 			    "unknown construct");
    231 			return;
    232 		}
    233 		*nextpct = '\0';
    234 
    235 		if (*line == '\0')
    236 			fputc('%', fp);
    237 		else {
    238 			optname = intern(line);
    239 			if (!DEFINED_OPTION(optname)) {
    240 				cfgxerror(file, lineno, "unknown option %s",
    241 				    optname);
    242 				return;
    243 			}
    244 
    245 			if ((option = ht_lookup(opttab, optname)) == NULL)
    246 				option = ht_lookup(fsopttab, optname);
    247 			if (option != NULL)
    248 				fputs(option->nv_str ? option->nv_str : "1",
    249 				    fp);
    250 			/*
    251 			 * Otherwise it's not a selected option and we don't
    252 			 * output anything.
    253 			 */
    254 		}
    255 
    256 		line = nextpct + 1;
    257 	}
    258 }
    259 
    260 static void
    261 emitdefs(FILE *fp)
    262 {
    263 	struct nvlist *nv;
    264 
    265 	fprintf(fp, "KERNEL_BUILD=%s\n", conffile);
    266 	fputs("IDENT= \\\n", fp);
    267 	for (nv = options; nv != NULL; nv = nv->nv_next) {
    268 
    269 		/* Skip any options output to a header file */
    270 		if (DEFINED_OPTION(nv->nv_name))
    271 			continue;
    272 		const char *s = nv->nv_str;
    273 		fprintf(fp, "\t-D%s%s%s%s \\\n", nv->nv_name,
    274 		    s ? "=\"" : "",
    275 		    s ? s : "",
    276 		    s ? "\"" : "");
    277 	}
    278 	putc('\n', fp);
    279 	fprintf(fp, "MACHINE=%s\n", machine);
    280 
    281 	const char *subdir = "";
    282 	if (*srcdir != '/' && *srcdir != '.') {
    283 		/*
    284 		 * libkern and libcompat "Makefile.inc"s want relative S
    285 		 * specification to begin with '.'.
    286 		 */
    287 		subdir = "./";
    288 	}
    289 	fprintf(fp, "S=\t%s%s\n", subdir, srcdir);
    290 	for (nv = mkoptions; nv != NULL; nv = nv->nv_next)
    291 		fprintf(fp, "%s=%s\n", nv->nv_name, nv->nv_str);
    292 }
    293 
    294 static void
    295 emitfiletype(FILE *fp, struct filetype *fit)
    296 {
    297 	const char *prologue, *prefix, *sep;
    298 
    299 	prologue = prefix = sep = "";
    300 	if (*fit->fit_path != '/') {
    301 		prologue = "$S/";
    302 		if (fit->fit_prefix != NULL) {
    303 			if (*fit->fit_prefix == '/')
    304 				prologue = "";
    305 			prefix = fit->fit_prefix;
    306 			sep = "/";
    307 		}
    308 	}
    309 	fprintf(fp, "%s%s%s%s", prologue, prefix, sep, fit->fit_path);
    310 }
    311 
    312 static void
    313 emitobjs(FILE *fp)
    314 {
    315 	struct files *fi;
    316 
    317 	fputs("OBJS= \\\n", fp);
    318 	TAILQ_FOREACH(fi, &allfiles, fi_next) {
    319 		if ((fi->fi_flags & FI_SEL) == 0)
    320 			continue;
    321 		fprintf(fp, "\t%s.o \\\n", fi->fi_base);
    322 	}
    323 	TAILQ_FOREACH(fi, &allobjects, fi_next) {
    324 		if ((fi->fi_flags & FI_SEL) == 0)
    325 			continue;
    326 		putc('\t', fp);
    327 		emitfiletype(fp, &fi->fi_fit);
    328 		fputs(" \\\n", fp);
    329 	}
    330 	putc('\n', fp);
    331 }
    332 
    333 static void
    334 emitkobjs(FILE *fp)
    335 {
    336 	emitallkobjs(fp);
    337 	emitattrkobjs(fp);
    338 }
    339 
    340 static int emitallkobjsweighcb(const char *name, void *v, void *arg);
    341 static void weighattr(struct attr *a);
    342 static int attrcmp(const void *l, const void *r);
    343 
    344 struct attr **attrbuf;
    345 size_t attridx;
    346 
    347 static void
    348 emitallkobjs(FILE *fp)
    349 {
    350 	size_t i;
    351 
    352 	attrbuf = emalloc(nattrs * sizeof(*attrbuf));
    353 
    354 	ht_enumerate(attrtab, emitallkobjsweighcb, NULL);
    355 	ht_enumerate(attrtab, emitallkobjscb, NULL);
    356 	qsort(attrbuf, attridx, sizeof(struct attr *), attrcmp);
    357 
    358 	fputs("OBJS= \\\n", fp);
    359 	for (i = 0; i < attridx; i++)
    360 		fprintf(fp, "\t%s.ko \\\n", attrbuf[i]->a_name);
    361 	putc('\n', fp);
    362 
    363 	free(attrbuf);
    364 }
    365 
    366 static int
    367 emitallkobjscb(const char *name, void *v, void *arg)
    368 {
    369 	struct attr *a = v;
    370 
    371 	if (ht_lookup(selecttab, name) == NULL)
    372 		return 0;
    373 	if (TAILQ_EMPTY(&a->a_files))
    374 		return 0;
    375 	attrbuf[attridx++] = a;
    376 	/* XXX nattrs tracking is not exact yet */
    377 	if (attridx == nattrs) {
    378 		nattrs *= 2;
    379 		attrbuf = erealloc(attrbuf, nattrs * sizeof(*attrbuf));
    380 	}
    381 	return 0;
    382 }
    383 
    384 static int
    385 emitallkobjsweighcb(const char *name, void *v, void *arg)
    386 {
    387 	struct attr *a = v;
    388 
    389 	weighattr(a);
    390 	return 0;
    391 }
    392 
    393 static void
    394 weighattr(struct attr *a)
    395 {
    396 	struct attrlist *al;
    397 
    398 	for (al = a->a_deps; al != NULL; al = al->al_next) {
    399 		weighattr(al->al_this);
    400 	}
    401 	a->a_weight++;
    402 }
    403 
    404 static int
    405 attrcmp(const void *l, const void *r)
    406 {
    407 	const struct attr * const *a = l, * const *b = r;
    408 	const int wa = (*a)->a_weight, wb = (*b)->a_weight;
    409 	return (wa > wb) ? -1 : (wa < wb) ? 1 : 0;
    410 }
    411 
    412 static void
    413 emitattrkobjs(FILE *fp)
    414 {
    415 	extern struct	hashtab *attrtab;
    416 
    417 	ht_enumerate(attrtab, emitattrkobjscb, fp);
    418 }
    419 
    420 static int
    421 emitattrkobjscb(const char *name, void *v, void *arg)
    422 {
    423 	struct attr *a = v;
    424 	struct files *fi;
    425 	FILE *fp = arg;
    426 
    427 	if (ht_lookup(selecttab, name) == NULL)
    428 		return 0;
    429 	if (TAILQ_EMPTY(&a->a_files))
    430 		return 0;
    431 	fputc('\n', fp);
    432 	fprintf(fp, "# %s (%d)\n", name, a->a_weight);
    433 	fprintf(fp, "OBJS.%s= \\\n", name);
    434 	TAILQ_FOREACH(fi, &a->a_files, fi_anext) {
    435 		fprintf(fp, "\t%s.o \\\n", fi->fi_base);
    436 	}
    437 	fputc('\n', fp);
    438 	fprintf(fp, "%s.ko: ${OBJS.%s}\n", name, name);
    439 	fprintf(fp, "\t${LINK_O}\n");
    440 	return 0;
    441 }
    442 
    443 static void
    444 emitcfiles(FILE *fp)
    445 {
    446 
    447 	emitfiles(fp, 'c', 0);
    448 }
    449 
    450 static void
    451 emitsfiles(FILE *fp)
    452 {
    453 
    454 	emitfiles(fp, 's', 'S');
    455 }
    456 
    457 static void
    458 emitfiles(FILE *fp, int suffix, int upper_suffix)
    459 {
    460 	struct files *fi;
    461  	struct config *cf;
    462  	char swapname[100];
    463 
    464 	fprintf(fp, "%cFILES= \\\n", toupper(suffix));
    465 	TAILQ_FOREACH(fi, &allfiles, fi_next) {
    466 		if ((fi->fi_flags & FI_SEL) == 0)
    467 			continue;
    468 		if (fi->fi_suffix != suffix && fi->fi_suffix != upper_suffix)
    469 			continue;
    470 		putc('\t', fp);
    471 		emitfiletype(fp, &fi->fi_fit);
    472 		fputs(" \\\n", fp);
    473 	}
    474 
    475  	/*
    476  	 * The allfiles list does not include the configuration-specific
    477  	 * C source files.  These files should be eliminated someday, but
    478  	 * for now, we have to add them to ${CFILES} (and only ${CFILES}).
    479  	 */
    480  	if (suffix == 'c') {
    481  		TAILQ_FOREACH(cf, &allcf, cf_next) {
    482  			(void)snprintf(swapname, sizeof(swapname), "swap%s.c",
    483  			    cf->cf_name);
    484  			fprintf(fp, "\t%s \\\n", swapname);
    485  		}
    486  	}
    487 	putc('\n', fp);
    488 }
    489 
    490 /*
    491  * Emit the make-rules.
    492  */
    493 static void
    494 emitrules(FILE *fp)
    495 {
    496 	struct files *fi;
    497 
    498 	TAILQ_FOREACH(fi, &allfiles, fi_next) {
    499 		if ((fi->fi_flags & FI_SEL) == 0)
    500 			continue;
    501 		if (fi->fi_mkrule == NULL)
    502 			continue;
    503 		fprintf(fp, "%s.o: ", fi->fi_base);
    504 		emitfiletype(fp, &fi->fi_fit);
    505 		putc('\n', fp);
    506 		fprintf(fp, "\t%s\n\n", fi->fi_mkrule);
    507 	}
    508 }
    509 
    510 /*
    511  * Emit the load commands.
    512  *
    513  * This function is not to be called `spurt'.
    514  */
    515 static void
    516 emitload(FILE *fp)
    517 {
    518 	struct config *cf;
    519 
    520 	fputs(".MAIN: all\n", fp);
    521 	fputs("all:", fp);
    522 	TAILQ_FOREACH(cf, &allcf, cf_next) {
    523 		fprintf(fp, " %s", cf->cf_name);
    524 		/*
    525 		 * If we generate multiple configs inside the same build directory
    526 		 * with a parallel build, strange things may happen, so sequentialize
    527 		 * them.
    528 		 */
    529 		if (cf != TAILQ_LAST(&allcf,conftq))
    530 			fprintf(fp, " .WAIT");
    531 	}
    532 	fputs("\n\n", fp);
    533 	/*
    534 	 * Generate the backward-compatible "build_kernel" rule if
    535 	 * sys/conf/Makefile.kern.inc doesn't define any (pre-2014 Aug).
    536 	 */
    537 	if (has_build_kernel == 0) {
    538 		fprintf(fp, "build_kernel: .USE\n"
    539 		    "\t${SYSTEM_LD_HEAD}\n"
    540 		    "\t${SYSTEM_LD} swap${.TARGET}.o\n"
    541 		    "\t${SYSTEM_LD_TAIL}\n"
    542 		    "\n");
    543 	}
    544 	/*
    545 	 * Generate per-kernel rules.
    546 	 */
    547 	TAILQ_FOREACH(cf, &allcf, cf_next) {
    548 		fprintf(fp, "KERNELS+=%s\n", cf->cf_name);
    549 		fprintf(fp, "%s: ${SYSTEM_DEP} swap%s.o vers.o build_kernel\n",
    550 		    cf->cf_name, cf->cf_name);
    551 	}
    552 	fputs("\n", fp);
    553 }
    554 
    555 /*
    556  * Emit include headers (for any prefixes encountered)
    557  */
    558 static void
    559 emitincludes(FILE *fp)
    560 {
    561 	struct prefix *pf;
    562 
    563 	SLIST_FOREACH(pf, &allprefixes, pf_next) {
    564 		const char *prologue = (*pf->pf_prefix == '/') ? "" : "$S/";
    565 
    566 		fprintf(fp, "EXTRA_INCLUDES+=\t-I%s%s\n",
    567 		    prologue, pf->pf_prefix);
    568 	}
    569 }
    570 
    571 /*
    572  * Emit appending makeoptions.
    573  */
    574 static void
    575 emitappmkoptions(FILE *fp)
    576 {
    577 	struct nvlist *nv;
    578 	struct condexpr *cond;
    579 
    580 	for (nv = appmkoptions; nv != NULL; nv = nv->nv_next)
    581 		fprintf(fp, "%s+=%s\n", nv->nv_name, nv->nv_str);
    582 
    583 	for (nv = condmkoptions; nv != NULL; nv = nv->nv_next) {
    584 		cond = nv->nv_ptr;
    585 		if (expr_eval(cond, selectopt, NULL))
    586 			fprintf(fp, "%s+=%s\n", nv->nv_name, nv->nv_str);
    587 		condexpr_destroy(cond);
    588 		nv->nv_ptr = NULL;
    589 	}
    590 }
    591 
    592 static int
    593 /*ARGSUSED*/
    594 selectopt(const char *name, void *context)
    595 {
    596 
    597 	return (ht_lookup(selecttab, strtolower(name)) != NULL);
    598 }
    599