1 /* $NetBSD: targ.c,v 1.180 2024/03/10 02:53:37 sjg Exp $ */ 2 3 /* 4 * Copyright (c) 1988, 1989, 1990, 1993 5 * The Regents of the University of California. 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) 1989 by Berkeley Softworks 37 * All rights reserved. 38 * 39 * This code is derived from software contributed to Berkeley by 40 * Adam de Boor. 41 * 42 * Redistribution and use in source and binary forms, with or without 43 * modification, are permitted provided that the following conditions 44 * are met: 45 * 1. Redistributions of source code must retain the above copyright 46 * notice, this list of conditions and the following disclaimer. 47 * 2. Redistributions in binary form must reproduce the above copyright 48 * notice, this list of conditions and the following disclaimer in the 49 * documentation and/or other materials provided with the distribution. 50 * 3. All advertising materials mentioning features or use of this software 51 * must display the following acknowledgement: 52 * This product includes software developed by the University of 53 * California, Berkeley and its contributors. 54 * 4. Neither the name of the University nor the names of its contributors 55 * may be used to endorse or promote products derived from this software 56 * without specific prior written permission. 57 * 58 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 59 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 60 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 61 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 62 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 63 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 64 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 65 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 66 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 67 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 68 * SUCH DAMAGE. 69 */ 70 71 /* 72 * Maintaining the targets and sources, which are both implemented as GNode. 73 * 74 * Interface: 75 * Targ_Init Initialize the module. 76 * 77 * Targ_End Clean up the module. 78 * 79 * Targ_List Return the list of all targets so far. 80 * 81 * GNode_New Create a new GNode with the given name, don't add it 82 * to allNodes. 83 * 84 * Targ_FindNode Find the node, or return NULL. 85 * 86 * Targ_GetNode Find the node, or create it. 87 * 88 * Targ_NewInternalNode 89 * Create an internal node. 90 * 91 * Targ_FindList Given a list of names, find nodes for all 92 * of them, creating them as necessary. 93 * 94 * Targ_Propagate Propagate information between related nodes. 95 * Should be called after the makefiles are parsed 96 * but before any action is taken. 97 * 98 * Debugging: 99 * Targ_PrintGraph 100 * Print out the entire graph, all variables and 101 * statistics for the directory cache. 102 */ 103 104 #include <time.h> 105 106 #include "make.h" 107 #include "dir.h" 108 109 /* "@(#)targ.c 8.2 (Berkeley) 3/19/94" */ 110 MAKE_RCSID("$NetBSD: targ.c,v 1.180 2024/03/10 02:53:37 sjg Exp $"); 111 112 /* 113 * All target nodes that appeared on the left-hand side of one of the 114 * dependency operators ':', '::', '!'. 115 */ 116 static GNodeList allTargets = LST_INIT; 117 static HashTable allTargetsByName; 118 119 #ifdef CLEANUP 120 static GNodeList allNodes = LST_INIT; 121 122 static void GNode_Free(void *); 123 #endif 124 125 void 126 Targ_Init(void) 127 { 128 HashTable_Init(&allTargetsByName); 129 } 130 131 void 132 Targ_End(void) 133 { 134 Targ_Stats(); 135 #ifdef CLEANUP 136 Lst_Done(&allTargets); 137 HashTable_Done(&allTargetsByName); 138 Lst_DoneCall(&allNodes, GNode_Free); 139 #endif 140 } 141 142 void 143 Targ_Stats(void) 144 { 145 HashTable_DebugStats(&allTargetsByName, "targets"); 146 } 147 148 /* 149 * Return the list of all targets, which are all nodes that appear on the 150 * left-hand side of a dependency declaration such as "target: source". 151 * The returned list does not contain pure sources. 152 */ 153 GNodeList * 154 Targ_List(void) 155 { 156 return &allTargets; 157 } 158 159 /* 160 * Create a new graph node, but don't register it anywhere. 161 * 162 * Graph nodes that occur on the left-hand side of a dependency line such 163 * as "target: source" are called targets. XXX: In some cases (like the 164 * .ALLTARGETS variable), other nodes are called targets as well, even if 165 * they never occur on the left-hand side of a dependency line. 166 * 167 * Typical names for graph nodes are: 168 * "src.c" an ordinary file 169 * "clean" a .PHONY target 170 * ".END" a special hook target 171 * "-lm" a library 172 * "libm.a(sin.o)" an archive member 173 */ 174 GNode * 175 GNode_New(const char *name) 176 { 177 GNode *gn; 178 179 gn = bmake_malloc(sizeof *gn); 180 gn->name = bmake_strdup(name); 181 gn->uname = NULL; 182 gn->path = NULL; 183 gn->type = name[0] == '-' && name[1] == 'l' ? OP_LIB : OP_NONE; 184 memset(&gn->flags, 0, sizeof(gn->flags)); 185 gn->made = UNMADE; 186 gn->unmade = 0; 187 gn->mtime = 0; 188 gn->youngestChild = NULL; 189 Lst_Init(&gn->implicitParents); 190 Lst_Init(&gn->parents); 191 Lst_Init(&gn->children); 192 Lst_Init(&gn->order_pred); 193 Lst_Init(&gn->order_succ); 194 Lst_Init(&gn->cohorts); 195 gn->cohort_num[0] = '\0'; 196 gn->unmade_cohorts = 0; 197 gn->centurion = NULL; 198 gn->checked_seqno = 0; 199 HashTable_Init(&gn->vars); 200 Lst_Init(&gn->commands); 201 gn->suffix = NULL; 202 gn->fname = NULL; 203 gn->lineno = 0; 204 gn->exit_status = 0; 205 206 #ifdef CLEANUP 207 Lst_Append(&allNodes, gn); 208 #endif 209 210 return gn; 211 } 212 213 #ifdef CLEANUP 214 static void 215 GNode_Free(void *gnp) 216 { 217 GNode *gn = gnp; 218 219 free(gn->name); 220 free(gn->uname); 221 free(gn->path); 222 223 /* Don't free gn->youngestChild since it is not owned by this node. */ 224 225 /* 226 * In the following lists, only free the list nodes, but not the 227 * GNodes in them since these are not owned by this node. 228 */ 229 Lst_Done(&gn->implicitParents); 230 Lst_Done(&gn->parents); 231 Lst_Done(&gn->children); 232 Lst_Done(&gn->order_pred); 233 Lst_Done(&gn->order_succ); 234 Lst_Done(&gn->cohorts); 235 236 /* 237 * Do not free the variables themselves, even though they are owned 238 * by this node. 239 * 240 * XXX: For the nodes that represent targets or sources (and not 241 * SCOPE_GLOBAL), it should be safe to free the variables as well, 242 * since each node manages the memory for all its variables itself. 243 * 244 * XXX: The GNodes that are only used as variable scopes (SCOPE_CMD, 245 * SCOPE_GLOBAL, SCOPE_INTERNAL) are not freed at all (see Var_End, 246 * where they are not mentioned). These may be freed if their 247 * variable values are indeed not used anywhere else (see Trace_Init 248 * for the only suspicious use). 249 */ 250 HashTable_Done(&gn->vars); 251 252 /* 253 * Do not free the commands themselves, as they may be shared with 254 * other nodes. 255 */ 256 Lst_Done(&gn->commands); 257 258 /* 259 * gn->suffix is not owned by this node. 260 * 261 * XXX: gn->suffix should be unreferenced here. This requires a 262 * thorough check that the reference counting is done correctly in 263 * all places, otherwise a suffix might be freed too early. 264 */ 265 266 free(gn); 267 } 268 #endif 269 270 /* Get the existing global node, or return NULL. */ 271 GNode * 272 Targ_FindNode(const char *name) 273 { 274 return HashTable_FindValue(&allTargetsByName, name); 275 } 276 277 /* Get the existing global node, or create it. */ 278 GNode * 279 Targ_GetNode(const char *name) 280 { 281 bool isNew; 282 HashEntry *he = HashTable_CreateEntry(&allTargetsByName, name, &isNew); 283 if (!isNew) 284 return HashEntry_Get(he); 285 286 { 287 GNode *gn = Targ_NewInternalNode(name); 288 HashEntry_Set(he, gn); 289 return gn; 290 } 291 } 292 293 /* 294 * Create a node, register it in .ALLTARGETS but don't store it in the 295 * table of global nodes. This means it cannot be found by name. 296 * 297 * This is used for internal nodes, such as cohorts or .WAIT nodes. 298 */ 299 GNode * 300 Targ_NewInternalNode(const char *name) 301 { 302 GNode *gn = GNode_New(name); 303 Global_Append(".ALLTARGETS", name); 304 Lst_Append(&allTargets, gn); 305 DEBUG1(TARG, "Adding \"%s\" to all targets.\n", gn->name); 306 if (doing_depend) 307 gn->flags.fromDepend = true; 308 return gn; 309 } 310 311 /* 312 * Return the .END node, which contains the commands to be run when 313 * everything else has been made. 314 */ 315 GNode * 316 Targ_GetEndNode(void) 317 { 318 /* 319 * Save the node locally to avoid having to search for it all 320 * the time. 321 */ 322 static GNode *endNode = NULL; 323 324 if (endNode == NULL) { 325 endNode = Targ_GetNode(".END"); 326 endNode->type = OP_SPECIAL; 327 } 328 return endNode; 329 } 330 331 /* Add the named nodes to the list, creating them as necessary. */ 332 void 333 Targ_FindList(GNodeList *gns, StringList *names) 334 { 335 StringListNode *ln; 336 337 for (ln = names->first; ln != NULL; ln = ln->next) { 338 const char *name = ln->datum; 339 GNode *gn = Targ_GetNode(name); 340 Lst_Append(gns, gn); 341 } 342 } 343 344 static void 345 PrintNodeNames(GNodeList *gnodes) 346 { 347 GNodeListNode *ln; 348 349 for (ln = gnodes->first; ln != NULL; ln = ln->next) { 350 GNode *gn = ln->datum; 351 debug_printf(" %s%s", gn->name, gn->cohort_num); 352 } 353 } 354 355 static void 356 PrintNodeNamesLine(const char *label, GNodeList *gnodes) 357 { 358 if (Lst_IsEmpty(gnodes)) 359 return; 360 debug_printf("# %s:", label); 361 PrintNodeNames(gnodes); 362 debug_printf("\n"); 363 } 364 365 void 366 Targ_PrintCmds(GNode *gn) 367 { 368 StringListNode *ln; 369 370 for (ln = gn->commands.first; ln != NULL; ln = ln->next) { 371 const char *cmd = ln->datum; 372 debug_printf("\t%s\n", cmd); 373 } 374 } 375 376 /* 377 * Format a modification time in some reasonable way and return it. 378 * The formatted time is placed in a static area, so it is overwritten 379 * with each call. 380 */ 381 const char * 382 Targ_FmtTime(time_t tm) 383 { 384 static char buf[128]; 385 386 struct tm *parts = localtime(&tm); 387 (void)strftime(buf, sizeof buf, "%H:%M:%S %b %d, %Y", parts); 388 return buf; 389 } 390 391 /* Print out a type field giving only those attributes the user can set. */ 392 void 393 Targ_PrintType(GNodeType type) 394 { 395 static const struct { 396 GNodeType bit; 397 bool internal; 398 const char name[10]; 399 } names[] = { 400 { OP_MEMBER, true, "MEMBER" }, 401 { OP_LIB, true, "LIB" }, 402 { OP_ARCHV, true, "ARCHV" }, 403 { OP_PHONY, true, "PHONY" }, 404 { OP_NOTMAIN, false, "NOTMAIN" }, 405 { OP_INVISIBLE, false, "INVISIBLE" }, 406 { OP_MADE, true, "MADE" }, 407 { OP_JOIN, false, "JOIN" }, 408 { OP_MAKE, false, "MAKE" }, 409 { OP_SILENT, false, "SILENT" }, 410 { OP_PRECIOUS, false, "PRECIOUS" }, 411 { OP_IGNORE, false, "IGNORE" }, 412 { OP_EXEC, false, "EXEC" }, 413 { OP_USE, false, "USE" }, 414 { OP_USEBEFORE, false, "USEBEFORE" }, 415 { OP_OPTIONAL, false, "OPTIONAL" }, 416 }; 417 size_t i; 418 419 for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) { 420 if (type & names[i].bit) { 421 if (names[i].internal) 422 DEBUG1(TARG, " .%s", names[i].name); 423 else 424 debug_printf(" .%s", names[i].name); 425 } 426 } 427 } 428 429 const char * 430 GNodeMade_Name(GNodeMade made) 431 { 432 switch (made) { 433 case UNMADE: return "unmade"; 434 case DEFERRED: return "deferred"; 435 case REQUESTED: return "requested"; 436 case BEINGMADE: return "being made"; 437 case MADE: return "made"; 438 case UPTODATE: return "up-to-date"; 439 case ERROR: return "error when made"; 440 case ABORTED: return "aborted"; 441 default: return "unknown enum_made value"; 442 } 443 } 444 445 static const char * 446 GNode_OpName(const GNode *gn) 447 { 448 switch (gn->type & OP_OPMASK) { 449 case OP_DEPENDS: 450 return ":"; 451 case OP_FORCE: 452 return "!"; 453 case OP_DOUBLEDEP: 454 return "::"; 455 } 456 return ""; 457 } 458 459 static bool 460 GNodeFlags_IsNone(GNodeFlags flags) 461 { 462 return !flags.remake 463 && !flags.childMade 464 && !flags.force 465 && !flags.doneWait 466 && !flags.doneOrder 467 && !flags.fromDepend 468 && !flags.doneAllsrc 469 && !flags.cycle 470 && !flags.doneCycle; 471 } 472 473 /* Print the contents of a node. */ 474 void 475 Targ_PrintNode(GNode *gn, int pass) 476 { 477 debug_printf("# %s%s", gn->name, gn->cohort_num); 478 GNode_FprintDetails(opts.debug_file, ", ", gn, "\n"); 479 if (GNodeFlags_IsNone(gn->flags)) 480 return; 481 482 if (!GNode_IsTarget(gn)) 483 return; 484 485 debug_printf("#\n"); 486 if (gn == mainNode) 487 debug_printf("# *** MAIN TARGET ***\n"); 488 489 if (pass >= 2) { 490 if (gn->unmade > 0) 491 debug_printf("# %d unmade children\n", gn->unmade); 492 else 493 debug_printf("# No unmade children\n"); 494 if (!(gn->type & (OP_JOIN | OP_USE | OP_USEBEFORE | OP_EXEC))) { 495 if (gn->mtime != 0) { 496 debug_printf("# last modified %s: %s\n", 497 Targ_FmtTime(gn->mtime), 498 GNodeMade_Name(gn->made)); 499 } else if (gn->made != UNMADE) { 500 debug_printf("# nonexistent (maybe): %s\n", 501 GNodeMade_Name(gn->made)); 502 } else 503 debug_printf("# unmade\n"); 504 } 505 PrintNodeNamesLine("implicit parents", &gn->implicitParents); 506 } else { 507 if (gn->unmade != 0) 508 debug_printf("# %d unmade children\n", gn->unmade); 509 } 510 511 PrintNodeNamesLine("parents", &gn->parents); 512 PrintNodeNamesLine("order_pred", &gn->order_pred); 513 PrintNodeNamesLine("order_succ", &gn->order_succ); 514 515 debug_printf("%-16s%s", gn->name, GNode_OpName(gn)); 516 Targ_PrintType(gn->type); 517 PrintNodeNames(&gn->children); 518 debug_printf("\n"); 519 Targ_PrintCmds(gn); 520 debug_printf("\n\n"); 521 if (gn->type & OP_DOUBLEDEP) 522 Targ_PrintNodes(&gn->cohorts, pass); 523 } 524 525 void 526 Targ_PrintNodes(GNodeList *gnodes, int pass) 527 { 528 GNodeListNode *ln; 529 530 for (ln = gnodes->first; ln != NULL; ln = ln->next) 531 Targ_PrintNode(ln->datum, pass); 532 } 533 534 static void 535 PrintOnlySources(void) 536 { 537 GNodeListNode *ln; 538 539 for (ln = allTargets.first; ln != NULL; ln = ln->next) { 540 GNode *gn = ln->datum; 541 if (GNode_IsTarget(gn)) 542 continue; 543 544 debug_printf("#\t%s [%s]", gn->name, GNode_Path(gn)); 545 Targ_PrintType(gn->type); 546 debug_printf("\n"); 547 } 548 } 549 550 /* 551 * Input: 552 * pass 1 => before processing 553 * 2 => after processing 554 * 3 => after processing, an error occurred 555 */ 556 void 557 Targ_PrintGraph(int pass) 558 { 559 debug_printf("#*** Input graph:\n"); 560 Targ_PrintNodes(&allTargets, pass); 561 debug_printf("\n"); 562 debug_printf("\n"); 563 564 debug_printf("#\n"); 565 debug_printf("# Files that are only sources:\n"); 566 PrintOnlySources(); 567 568 debug_printf("#*** Global Variables:\n"); 569 Var_Dump(SCOPE_GLOBAL); 570 571 debug_printf("#*** Command-line Variables:\n"); 572 Var_Dump(SCOPE_CMDLINE); 573 574 debug_printf("\n"); 575 Dir_PrintDirectories(); 576 debug_printf("\n"); 577 578 Suff_PrintAll(); 579 } 580 581 /* 582 * Propagate some type information to cohort nodes (those from the '::' 583 * dependency operator). 584 * 585 * Should be called after the makefiles are parsed but before any action is 586 * taken. 587 */ 588 void 589 Targ_Propagate(void) 590 { 591 GNodeListNode *ln, *cln; 592 593 for (ln = allTargets.first; ln != NULL; ln = ln->next) { 594 GNode *gn = ln->datum; 595 GNodeType type = gn->type; 596 597 if (!(type & OP_DOUBLEDEP)) 598 continue; 599 600 for (cln = gn->cohorts.first; cln != NULL; cln = cln->next) { 601 GNode *cohort = cln->datum; 602 603 cohort->type |= type & (unsigned)~OP_OPMASK; 604 } 605 } 606 } 607