xref: /freebsd/contrib/bmake/compat.c (revision 5b56413d04e608379c9a306373554a8e4d321bc0)
1 /*	$NetBSD: compat.c,v 1.260 2024/07/11 20:09:16 sjg Exp $	*/
2 
3 /*
4  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * Adam de Boor.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  */
34 
35 /*
36  * Copyright (c) 1988, 1989 by Adam de Boor
37  * Copyright (c) 1989 by Berkeley Softworks
38  * All rights reserved.
39  *
40  * This code is derived from software contributed to Berkeley by
41  * Adam de Boor.
42  *
43  * Redistribution and use in source and binary forms, with or without
44  * modification, are permitted provided that the following conditions
45  * are met:
46  * 1. Redistributions of source code must retain the above copyright
47  *    notice, this list of conditions and the following disclaimer.
48  * 2. Redistributions in binary form must reproduce the above copyright
49  *    notice, this list of conditions and the following disclaimer in the
50  *    documentation and/or other materials provided with the distribution.
51  * 3. All advertising materials mentioning features or use of this software
52  *    must display the following acknowledgement:
53  *	This product includes software developed by the University of
54  *	California, Berkeley and its contributors.
55  * 4. Neither the name of the University nor the names of its contributors
56  *    may be used to endorse or promote products derived from this software
57  *    without specific prior written permission.
58  *
59  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69  * SUCH DAMAGE.
70  */
71 
72 /*
73  * This file implements the full-compatibility mode of make, which makes the
74  * targets without parallelism and without a custom shell.
75  *
76  * Interface:
77  *	Compat_MakeAll	Initialize this module and make the given targets.
78  */
79 
80 #ifdef HAVE_CONFIG_H
81 # include   "config.h"
82 #endif
83 #include <sys/types.h>
84 #include <sys/stat.h>
85 #include "wait.h"
86 
87 #include <errno.h>
88 #include <signal.h>
89 
90 #include "make.h"
91 #include "dir.h"
92 #include "job.h"
93 #include "metachar.h"
94 #include "pathnames.h"
95 
96 /*	"@(#)compat.c	8.2 (Berkeley) 3/19/94"	*/
97 MAKE_RCSID("$NetBSD: compat.c,v 1.260 2024/07/11 20:09:16 sjg Exp $");
98 
99 static GNode *curTarg = NULL;
100 static pid_t compatChild;
101 static int compatSigno;
102 
103 /*
104  * Delete the file of a failed, interrupted, or otherwise duffed target,
105  * unless inhibited by .PRECIOUS.
106  */
107 static void
108 CompatDeleteTarget(GNode *gn)
109 {
110 	if (gn != NULL && !GNode_IsPrecious(gn) &&
111 	    (gn->type & OP_PHONY) == 0) {
112 		const char *file = GNode_VarTarget(gn);
113 		if (!opts.noExecute && unlink_file(file) == 0)
114 			Error("*** %s removed", file);
115 	}
116 }
117 
118 /*
119  * Interrupt the creation of the current target and remove it if it ain't
120  * precious. Then exit.
121  *
122  * If .INTERRUPT exists, its commands are run first WITH INTERRUPTS IGNORED.
123  *
124  * XXX: is .PRECIOUS supposed to inhibit .INTERRUPT? I doubt it, but I've
125  * left the logic alone for now. - dholland 20160826
126  */
127 static void
128 CompatInterrupt(int signo)
129 {
130 	CompatDeleteTarget(curTarg);
131 
132 	if (curTarg != NULL && !GNode_IsPrecious(curTarg)) {
133 		/* Run .INTERRUPT only if hit with interrupt signal. */
134 		if (signo == SIGINT) {
135 			GNode *gn = Targ_FindNode(".INTERRUPT");
136 			if (gn != NULL)
137 				Compat_Make(gn, gn);
138 		}
139 	}
140 
141 	if (signo == SIGQUIT)
142 		_exit(signo);
143 
144 	/*
145 	 * If there is a child running, pass the signal on.
146 	 * We will exist after it has exited.
147 	 */
148 	compatSigno = signo;
149 	if (compatChild > 0) {
150 		KILLPG(compatChild, signo);
151 	} else {
152 		bmake_signal(signo, SIG_DFL);
153 		kill(myPid, signo);
154 	}
155 }
156 
157 static void
158 DebugFailedTarget(const char *cmd, const GNode *gn)
159 {
160 	const char *p = cmd;
161 	debug_printf("\n*** Failed target:  %s\n*** Failed command: ",
162 	    gn->name);
163 
164 	/*
165 	 * Replace runs of whitespace with a single space, to reduce the
166 	 * amount of whitespace for multi-line command lines.
167 	 */
168 	while (*p != '\0') {
169 		if (ch_isspace(*p)) {
170 			debug_printf(" ");
171 			cpp_skip_whitespace(&p);
172 		} else {
173 			debug_printf("%c", *p);
174 			p++;
175 		}
176 	}
177 	debug_printf("\n");
178 }
179 
180 static bool
181 UseShell(const char *cmd MAKE_ATTR_UNUSED)
182 {
183 #if defined(FORCE_USE_SHELL) || !defined(MAKE_NATIVE)
184 	/*
185 	 * In a non-native build, the host environment might be weird enough
186 	 * that it's necessary to go through a shell to get the correct
187 	 * behaviour.  Or perhaps the shell has been replaced with something
188 	 * that does extra logging, and that should not be bypassed.
189 	 */
190 	return true;
191 #else
192 	/*
193 	 * Search for meta characters in the command. If there are no meta
194 	 * characters, there's no need to execute a shell to execute the
195 	 * command.
196 	 *
197 	 * Additionally variable assignments and empty commands
198 	 * go to the shell. Therefore treat '=' and ':' like shell
199 	 * meta characters as documented in make(1).
200 	 */
201 
202 	return needshell(cmd);
203 #endif
204 }
205 
206 static int
207 Compat_Spawn(const char **av)
208 {
209 	int pid = vfork();
210 	if (pid < 0)
211 		Fatal("Could not fork");
212 
213 	if (pid == 0) {
214 #ifdef USE_META
215 		if (useMeta)
216 			meta_compat_child();
217 #endif
218 		(void)execvp(av[0], (char *const *)UNCONST(av));
219 		execDie("exec", av[0]);
220 	}
221 	return pid;
222 }
223 
224 /*
225  * Execute the next command for a target. If the command returns an error,
226  * the node's made field is set to ERROR and creation stops.
227  *
228  * Input:
229  *	cmdp		Command to execute
230  *	gn		Node from which the command came
231  *	ln		List node that contains the command
232  *
233  * Results:
234  *	true if the command succeeded.
235  */
236 bool
237 Compat_RunCommand(const char *cmdp, GNode *gn, StringListNode *ln)
238 {
239 	char *cmdStart;		/* Start of expanded command */
240 	char *volatile bp;
241 	bool silent;		/* Don't print command */
242 	bool doIt;		/* Execute even if -n */
243 	volatile bool errCheck;	/* Check errors */
244 	WAIT_T reason;		/* Reason for child's death */
245 	WAIT_T status;		/* Description of child's death */
246 	pid_t retstat;		/* Result of wait */
247 	const char **av;	/* Arguments for the child process */
248 	char **volatile mav;	/* Copy of the argument vector for freeing */
249 	bool useShell;		/* True if command should be executed using a
250 				 * shell */
251 	const char *cmd = cmdp;
252 	char cmd_file[MAXPATHLEN];
253 	size_t cmd_len;
254 
255 	silent = (gn->type & OP_SILENT) != OP_NONE;
256 	errCheck = !(gn->type & OP_IGNORE);
257 	doIt = false;
258 
259 	cmdStart = Var_SubstInTarget(cmd, gn);
260 	/* TODO: handle errors */
261 
262 	if (cmdStart[0] == '\0') {
263 		free(cmdStart);
264 		return true;
265 	}
266 	cmd = cmdStart;
267 	LstNode_Set(ln, cmdStart);
268 
269 	if (gn->type & OP_SAVE_CMDS) {
270 		GNode *endNode = Targ_GetEndNode();
271 		if (gn != endNode) {
272 			/*
273 			 * Append the expanded command, to prevent the
274 			 * local variables from being interpreted in the
275 			 * scope of the .END node.
276 			 *
277 			 * A probably unintended side effect of this is that
278 			 * the expanded command will be expanded again in the
279 			 * .END node.  Therefore, a literal '$' in these
280 			 * commands must be written as '$$$$' instead of the
281 			 * usual '$$'.
282 			 */
283 			Lst_Append(&endNode->commands, cmdStart);
284 			goto register_command;
285 		}
286 	}
287 	if (strcmp(cmdStart, "...") == 0) {
288 		gn->type |= OP_SAVE_CMDS;
289 	register_command:
290 		Parse_RegisterCommand(cmdStart);
291 		return true;
292 	}
293 
294 	for (;;) {
295 		if (*cmd == '@')
296 			silent = !DEBUG(LOUD);
297 		else if (*cmd == '-')
298 			errCheck = false;
299 		else if (*cmd == '+')
300 			doIt = true;
301 		else if (!ch_isspace(*cmd))
302 			/* Ignore whitespace for compatibility with gnu make */
303 			break;
304 		cmd++;
305 	}
306 
307 	while (ch_isspace(*cmd))
308 		cmd++;
309 	if (cmd[0] == '\0')
310 		goto register_command;
311 
312 	useShell = UseShell(cmd);
313 
314 	if (!silent || !GNode_ShouldExecute(gn)) {
315 		printf("%s\n", cmd);
316 		fflush(stdout);
317 	}
318 
319 	if (!doIt && !GNode_ShouldExecute(gn))
320 		goto register_command;
321 
322 	DEBUG1(JOB, "Execute: '%s'\n", cmd);
323 
324 	cmd_len = strlen(cmd);
325 	if (cmd_len > MAKE_CMDLEN_LIMIT)
326 		useShell = true;
327 	else
328 		cmd_file[0] = '\0';
329 
330 	if (useShell) {
331 		static const char *shargv[5];
332 
333 		if (Cmd_Argv(cmd, cmd_len, shargv, 5,
334 			cmd_file, sizeof(cmd_file),
335 			(errCheck && shellErrFlag != NULL),
336 			DEBUG(SHELL)) < 0)
337 			Fatal("cannot run \"%s\"", cmd);
338 		av = shargv;
339 		bp = NULL;
340 		mav = NULL;
341 	} else {
342 		Words words = Str_Words(cmd, false);
343 		mav = words.words;
344 		bp = words.freeIt;
345 		av = (void *)mav;
346 	}
347 
348 #ifdef USE_META
349 	if (useMeta)
350 		meta_compat_start();
351 #endif
352 
353 	Var_ReexportVars(gn);
354 
355 	compatChild = Compat_Spawn(av);
356 	free(mav);
357 	free(bp);
358 
359 	/* XXX: Memory management looks suspicious here. */
360 	/* XXX: Setting a list item to NULL is unexpected. */
361 	LstNode_SetNull(ln);
362 
363 #ifdef USE_META
364 	if (useMeta)
365 		meta_compat_parent(compatChild);
366 #endif
367 
368 	/* The child is off and running. Now all we can do is wait... */
369 	while ((retstat = wait(&reason)) != compatChild) {
370 		if (retstat > 0)
371 			JobReapChild(retstat, reason, false); /* not ours? */
372 		if (retstat == -1 && errno != EINTR)
373 			break;
374 	}
375 
376 	if (retstat < 0)
377 		Fatal("error in wait: %d: %s", retstat, strerror(errno));
378 
379 	if (WIFSTOPPED(reason)) {
380 		status = WSTOPSIG(reason);
381 	} else if (WIFEXITED(reason)) {
382 		status = WEXITSTATUS(reason);
383 #if defined(USE_META) && defined(USE_FILEMON_ONCE)
384 		if (useMeta)
385 			meta_cmd_finish(NULL);
386 #endif
387 		if (status != 0) {
388 			if (DEBUG(ERROR))
389 				DebugFailedTarget(cmd, gn);
390 			printf("*** Error code %d", status);
391 		}
392 	} else {
393 		status = WTERMSIG(reason);
394 		printf("*** Signal %d", status);
395 	}
396 
397 
398 	if (!WIFEXITED(reason) || status != 0) {
399 		if (errCheck) {
400 #ifdef USE_META
401 			if (useMeta)
402 				meta_job_error(NULL, gn, false, status);
403 #endif
404 			gn->made = ERROR;
405 			if (WIFEXITED(reason))
406 				gn->exit_status = status;
407 			if (opts.keepgoing) {
408 				/*
409 				 * Abort the current target,
410 				 * but let others continue.
411 				 */
412 				printf(" (continuing)\n");
413 			} else {
414 				printf("\n");
415 			}
416 			if (deleteOnError)
417 				CompatDeleteTarget(gn);
418 		} else {
419 			/*
420 			 * Continue executing commands for this target.
421 			 * If we return 0, this will happen...
422 			 */
423 			printf(" (ignored)\n");
424 			status = 0;
425 		}
426 		fflush(stdout);
427 	}
428 
429 	free(cmdStart);
430 	if (cmd_file[0] != '\0')
431 		unlink(cmd_file);
432 	compatChild = 0;
433 	if (compatSigno != 0) {
434 		bmake_signal(compatSigno, SIG_DFL);
435 		kill(myPid, compatSigno);
436 	}
437 
438 	return status == 0;
439 }
440 
441 static void
442 RunCommands(GNode *gn)
443 {
444 	StringListNode *ln;
445 
446 	for (ln = gn->commands.first; ln != NULL; ln = ln->next) {
447 		const char *cmd = ln->datum;
448 		if (!Compat_RunCommand(cmd, gn, ln))
449 			break;
450 	}
451 }
452 
453 static void
454 MakeInRandomOrder(GNode **gnodes, GNode **end, GNode *pgn)
455 {
456 	GNode **it;
457 	size_t r;
458 
459 	for (r = (size_t)(end - gnodes); r >= 2; r--) {
460 		/* Biased, but irrelevant in practice. */
461 		size_t i = (size_t)random() % r;
462 		GNode *t = gnodes[r - 1];
463 		gnodes[r - 1] = gnodes[i];
464 		gnodes[i] = t;
465 	}
466 
467 	for (it = gnodes; it != end; it++)
468 		Compat_Make(*it, pgn);
469 }
470 
471 static void
472 MakeWaitGroupsInRandomOrder(GNodeList *gnodes, GNode *pgn)
473 {
474 	Vector vec;
475 	GNodeListNode *ln;
476 	GNode **nodes;
477 	size_t i, n, start;
478 
479 	Vector_Init(&vec, sizeof(GNode *));
480 	for (ln = gnodes->first; ln != NULL; ln = ln->next)
481 		*(GNode **)Vector_Push(&vec) = ln->datum;
482 	nodes = vec.items;
483 	n = vec.len;
484 
485 	start = 0;
486 	for (i = 0; i < n; i++) {
487 		if (nodes[i]->type & OP_WAIT) {
488 			MakeInRandomOrder(nodes + start, nodes + i, pgn);
489 			Compat_Make(nodes[i], pgn);
490 			start = i + 1;
491 		}
492 	}
493 	MakeInRandomOrder(nodes + start, nodes + i, pgn);
494 
495 	Vector_Done(&vec);
496 }
497 
498 static void
499 MakeNodes(GNodeList *gnodes, GNode *pgn)
500 {
501 	GNodeListNode *ln;
502 
503 	if (Lst_IsEmpty(gnodes))
504 		return;
505 	if (opts.randomizeTargets) {
506 		MakeWaitGroupsInRandomOrder(gnodes, pgn);
507 		return;
508 	}
509 
510 	for (ln = gnodes->first; ln != NULL; ln = ln->next) {
511 		GNode *cgn = ln->datum;
512 		Compat_Make(cgn, pgn);
513 	}
514 }
515 
516 static bool
517 MakeUnmade(GNode *gn, GNode *pgn)
518 {
519 
520 	assert(gn->made == UNMADE);
521 
522 	/*
523 	 * First mark ourselves to be made, then apply whatever transformations
524 	 * the suffix module thinks are necessary. Once that's done, we can
525 	 * descend and make all our children. If any of them has an error
526 	 * but the -k flag was given, our 'make' field will be set to false
527 	 * again. This is our signal to not attempt to do anything but abort
528 	 * our parent as well.
529 	 */
530 	gn->flags.remake = true;
531 	gn->made = BEINGMADE;
532 
533 	if (!(gn->type & OP_MADE))
534 		Suff_FindDeps(gn);
535 
536 	MakeNodes(&gn->children, gn);
537 
538 	if (!gn->flags.remake) {
539 		gn->made = ABORTED;
540 		pgn->flags.remake = false;
541 		return false;
542 	}
543 
544 	if (Lst_FindDatum(&gn->implicitParents, pgn) != NULL)
545 		Var_Set(pgn, IMPSRC, GNode_VarTarget(gn));
546 
547 	/*
548 	 * All the children were made ok. Now youngestChild->mtime contains the
549 	 * modification time of the newest child, we need to find out if we
550 	 * exist and when we were modified last. The criteria for datedness
551 	 * are defined by GNode_IsOODate.
552 	 */
553 	DEBUG1(MAKE, "Examining %s...", gn->name);
554 	if (!GNode_IsOODate(gn)) {
555 		gn->made = UPTODATE;
556 		DEBUG0(MAKE, "up-to-date.\n");
557 		return false;
558 	}
559 
560 	/*
561 	 * If the user is just seeing if something is out-of-date, exit now
562 	 * to tell him/her "yes".
563 	 */
564 	DEBUG0(MAKE, "out-of-date.\n");
565 	if (opts.query && gn != Targ_GetEndNode())
566 		exit(1);
567 
568 	/*
569 	 * We need to be re-made.
570 	 * Ensure that $? (.OODATE) and $> (.ALLSRC) are both set.
571 	 */
572 	GNode_SetLocalVars(gn);
573 
574 	/*
575 	 * Alter our type to tell if errors should be ignored or things
576 	 * should not be printed so Compat_RunCommand knows what to do.
577 	 */
578 	if (opts.ignoreErrors)
579 		gn->type |= OP_IGNORE;
580 	if (opts.silent)
581 		gn->type |= OP_SILENT;
582 
583 	if (Job_CheckCommands(gn, Fatal)) {
584 		if (!opts.touch || (gn->type & OP_MAKE)) {
585 			curTarg = gn;
586 #ifdef USE_META
587 			if (useMeta && GNode_ShouldExecute(gn))
588 				meta_job_start(NULL, gn);
589 #endif
590 			RunCommands(gn);
591 			curTarg = NULL;
592 		} else {
593 			Job_Touch(gn, (gn->type & OP_SILENT) != OP_NONE);
594 		}
595 	} else {
596 		gn->made = ERROR;
597 	}
598 #ifdef USE_META
599 	if (useMeta && GNode_ShouldExecute(gn)) {
600 		if (meta_job_finish(NULL) != 0)
601 			gn->made = ERROR;
602 	}
603 #endif
604 
605 	if (gn->made != ERROR) {
606 		/*
607 		 * If the node was made successfully, mark it so, update
608 		 * its modification time and timestamp all its parents.
609 		 * This is to keep its state from affecting that of its parent.
610 		 */
611 		gn->made = MADE;
612 		if (Make_Recheck(gn) == 0)
613 			pgn->flags.force = true;
614 		if (!(gn->type & OP_EXEC)) {
615 			pgn->flags.childMade = true;
616 			GNode_UpdateYoungestChild(pgn, gn);
617 		}
618 	} else if (opts.keepgoing) {
619 		pgn->flags.remake = false;
620 	} else {
621 		PrintOnError(gn, "\nStop.\n");
622 		exit(1);
623 	}
624 	return true;
625 }
626 
627 static void
628 MakeOther(GNode *gn, GNode *pgn)
629 {
630 
631 	if (Lst_FindDatum(&gn->implicitParents, pgn) != NULL) {
632 		const char *target = GNode_VarTarget(gn);
633 		Var_Set(pgn, IMPSRC, target != NULL ? target : "");
634 	}
635 
636 	switch (gn->made) {
637 	case BEINGMADE:
638 		Error("Graph cycles through %s", gn->name);
639 		gn->made = ERROR;
640 		pgn->flags.remake = false;
641 		break;
642 	case MADE:
643 		if (!(gn->type & OP_EXEC)) {
644 			pgn->flags.childMade = true;
645 			GNode_UpdateYoungestChild(pgn, gn);
646 		}
647 		break;
648 	case UPTODATE:
649 		if (!(gn->type & OP_EXEC))
650 			GNode_UpdateYoungestChild(pgn, gn);
651 		break;
652 	default:
653 		break;
654 	}
655 }
656 
657 /*
658  * Make a target.
659  *
660  * If an error is detected and not being ignored, the process exits.
661  *
662  * Input:
663  *	gn		The node to make
664  *	pgn		Parent to abort if necessary
665  *
666  * Output:
667  *	gn->made
668  *		UPTODATE	gn was already up-to-date.
669  *		MADE		gn was recreated successfully.
670  *		ERROR		An error occurred while gn was being created,
671  *				either due to missing commands or in -k mode.
672  *		ABORTED		gn was not remade because one of its
673  *				dependencies could not be made due to errors.
674  */
675 void
676 Compat_Make(GNode *gn, GNode *pgn)
677 {
678 	if (shellName == NULL)	/* we came here from jobs */
679 		Shell_Init();
680 
681 	if (gn->made == UNMADE && (gn == pgn || !(pgn->type & OP_MADE))) {
682 		if (!MakeUnmade(gn, pgn))
683 			goto cohorts;
684 
685 		/* XXX: Replace with GNode_IsError(gn) */
686 	} else if (gn->made == ERROR) {
687 		/*
688 		 * Already had an error when making this.
689 		 * Tell the parent to abort.
690 		 */
691 		pgn->flags.remake = false;
692 	} else {
693 		MakeOther(gn, pgn);
694 	}
695 
696 cohorts:
697 	MakeNodes(&gn->cohorts, pgn);
698 }
699 
700 static void
701 MakeBeginNode(void)
702 {
703 	GNode *gn = Targ_FindNode(".BEGIN");
704 	if (gn == NULL)
705 		return;
706 
707 	Compat_Make(gn, gn);
708 	if (GNode_IsError(gn)) {
709 		PrintOnError(gn, "\nStop.\n");
710 		exit(1);
711 	}
712 }
713 
714 static void
715 InitSignals(void)
716 {
717 	if (bmake_signal(SIGINT, SIG_IGN) != SIG_IGN)
718 		bmake_signal(SIGINT, CompatInterrupt);
719 	if (bmake_signal(SIGTERM, SIG_IGN) != SIG_IGN)
720 		bmake_signal(SIGTERM, CompatInterrupt);
721 	if (bmake_signal(SIGHUP, SIG_IGN) != SIG_IGN)
722 		bmake_signal(SIGHUP, CompatInterrupt);
723 	if (bmake_signal(SIGQUIT, SIG_IGN) != SIG_IGN)
724 		bmake_signal(SIGQUIT, CompatInterrupt);
725 }
726 
727 void
728 Compat_MakeAll(GNodeList *targs)
729 {
730 	GNode *errorNode = NULL;
731 
732 	if (shellName == NULL)
733 		Shell_Init();
734 
735 	InitSignals();
736 
737 	/*
738 	 * Create the .END node now, to keep the (debug) output of the
739 	 * counter.mk test the same as before 2020-09-23.  This
740 	 * implementation detail probably doesn't matter though.
741 	 */
742 	(void)Targ_GetEndNode();
743 
744 	if (!opts.query)
745 		MakeBeginNode();
746 
747 	/*
748 	 * Expand .USE nodes right now, because they can modify the structure
749 	 * of the tree.
750 	 */
751 	Make_ExpandUse(targs);
752 
753 	while (!Lst_IsEmpty(targs)) {
754 		GNode *gn = Lst_Dequeue(targs);
755 		Compat_Make(gn, gn);
756 
757 		if (gn->made == UPTODATE) {
758 			printf("`%s' is up to date.\n", gn->name);
759 		} else if (gn->made == ABORTED) {
760 			printf("`%s' not remade because of errors.\n",
761 			    gn->name);
762 		}
763 		if (GNode_IsError(gn) && errorNode == NULL)
764 			errorNode = gn;
765 	}
766 
767 	if (errorNode == NULL) {
768 		GNode *endNode = Targ_GetEndNode();
769 		Compat_Make(endNode, endNode);
770 		if (GNode_IsError(endNode))
771 			errorNode = endNode;
772 	}
773 
774 	if (errorNode != NULL) {
775 		if (DEBUG(GRAPH2))
776 			Targ_PrintGraph(2);
777 		else if (DEBUG(GRAPH3))
778 			Targ_PrintGraph(3);
779 		PrintOnError(errorNode, "\nStop.\n");
780 		exit(1);
781 	}
782 }
783