1 /* Pattern and suffix rule internals for GNU Make.
2 Copyright (C) 1988-2020 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify it under the
6 terms of the GNU General Public License as published by the Free Software
7 Foundation; either version 3 of the License, or (at your option) any later
10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
12 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License along with
15 this program. If not, see <http://www.gnu.org/licenses/>. */
28 static void freerule (struct rule *rule, struct rule *lastrule);
30 /* Chain of all pattern rules. */
32 struct rule *pattern_rules;
34 /* Pointer to last rule in the chain, so we can add onto the end. */
36 struct rule *last_pattern_rule;
38 /* Number of rules in the chain. */
40 unsigned int num_pattern_rules;
42 /* Maximum number of target patterns of any pattern rule. */
44 unsigned int max_pattern_targets;
46 /* Maximum number of dependencies of any pattern rule. */
48 unsigned int max_pattern_deps;
50 /* Maximum length of the name of a dependencies of any pattern rule. */
52 size_t max_pattern_dep_length;
54 /* Pointer to structure for the file .SUFFIXES
55 whose dependencies are the suffixes to be searched. */
57 struct file *suffix_file;
59 /* Maximum length of a suffix. */
61 static size_t maxsuffix;
63 /* Compute the maximum dependency length and maximum number of dependencies of
64 all implicit rules. Also sets the subdir flag for a rule when appropriate,
65 possibly removing the rule completely when appropriate.
67 Add any global EXTRA_PREREQS here as well. */
70 snap_implicit_rules (void)
76 struct dep *prereqs = expand_extra_prereqs (lookup_variable (STRING_SIZE_TUPLE(".EXTRA_PREREQS")));
77 unsigned int pre_deps = 0;
79 max_pattern_dep_length = 0;
81 for (dep = prereqs; dep; dep = dep->next)
83 size_t l = strlen (dep_name (dep));
84 if (l > max_pattern_dep_length)
85 max_pattern_dep_length = l;
89 num_pattern_rules = max_pattern_targets = max_pattern_deps = 0;
91 for (rule = pattern_rules; rule; rule = rule->next)
93 unsigned int ndeps = pre_deps;
94 struct dep *lastdep = NULL;
98 if (rule->num > max_pattern_targets)
99 max_pattern_targets = rule->num;
101 for (dep = rule->deps; dep != 0; dep = dep->next)
103 const char *dname = dep_name (dep);
104 size_t len = strlen (dname);
107 const char *p = strrchr (dname, ']');
110 p = strrchr (dname, ':');
111 p2 = p ? strchr (p, '%') : 0;
113 const char *p = strrchr (dname, '/');
114 const char *p2 = p ? strchr (p, '%') : 0;
118 if (len > max_pattern_dep_length)
119 max_pattern_dep_length = len;
126 /* There is a slash before the % in the dep name.
127 Extract the directory name. */
130 if ((size_t) (p - dname) > namelen)
133 name = xrealloc (name, namelen + 1);
135 memcpy (name, dname, p - dname);
136 name[p - dname] = '\0';
138 /* In the deps of an implicit rule the 'changed' flag
139 actually indicates that the dependency is in a
140 nonexistent subdirectory. */
142 dep->changed = !dir_file_exists_p (name, "");
145 /* This dependency does not reside in a subdirectory. */
152 lastdep->next = copy_dep_chain (prereqs);
154 rule->deps = copy_dep_chain (prereqs);
157 if (ndeps > max_pattern_deps)
158 max_pattern_deps = ndeps;
162 free_dep_chain (prereqs);
165 /* Create a pattern rule from a suffix rule.
166 TARGET is the target suffix; SOURCE is the source suffix.
167 CMDS are the commands.
168 If TARGET is nil, it means the target pattern should be '(%.o)'.
169 If SOURCE is nil, it means there should be no deps. */
172 convert_suffix_rule (const char *target, const char *source,
173 struct commands *cmds)
175 const char **names, **percents;
178 names = xmalloc (sizeof (const char *));
179 percents = xmalloc (sizeof (const char *));
183 /* Special case: TARGET being nil means we are defining a '.X.a' suffix
184 rule; the target pattern is always '(%.o)'. */
186 *names = strcache_add_len ("(%.obj)", 7);
188 *names = strcache_add_len ("(%.o)", 5);
190 *percents = *names + 1;
194 /* Construct the target name. */
195 size_t len = strlen (target);
196 char *p = alloca (1 + len + 1);
198 memcpy (p + 1, target, len + 1);
199 *names = strcache_add_len (p, len + 1);
207 /* Construct the dependency name. */
208 size_t len = strlen (source);
209 char *p = alloca (1 + len + 1);
211 memcpy (p + 1, source, len + 1);
213 deps->name = strcache_add_len (p, len + 1);
216 create_pattern_rule (names, percents, 1, 0, deps, cmds, 0);
219 /* Convert old-style suffix rules to pattern rules.
220 All rules for the suffixes on the .SUFFIXES list are converted and added to
221 the chain of pattern rules. */
224 convert_to_pattern (void)
229 /* We will compute every potential suffix rule (.x.y) from the list of
230 suffixes in the .SUFFIXES target's dependencies and see if it exists.
231 First find the longest of the suffixes. */
234 for (d = suffix_file->deps; d != 0; d = d->next)
236 size_t l = strlen (dep_name (d));
241 /* Space to construct the suffix rule target name. */
242 rulename = alloca ((maxsuffix * 2) + 1);
244 for (d = suffix_file->deps; d != 0; d = d->next)
248 /* Make a rule that is just the suffix, with no deps or commands.
249 This rule exists solely to disqualify match-anything rules. */
250 convert_suffix_rule (dep_name (d), 0, 0);
252 if (d->file->cmds != 0)
253 /* Record a pattern for this suffix's null-suffix rule. */
254 convert_suffix_rule ("", dep_name (d), d->file->cmds);
256 /* Add every other suffix to this one and see if it exists as a
258 slen = strlen (dep_name (d));
259 memcpy (rulename, dep_name (d), slen);
261 for (d2 = suffix_file->deps; d2 != 0; d2 = d2->next)
266 s2len = strlen (dep_name (d2));
268 /* Can't build something from itself. */
269 if (slen == s2len && streq (dep_name (d), dep_name (d2)))
272 memcpy (rulename + slen, dep_name (d2), s2len + 1);
273 f = lookup_file (rulename);
275 /* No target, or no commands: it can't be a suffix rule. */
276 if (f == 0 || f->cmds == 0)
279 /* POSIX says that suffix rules can't have prerequisites.
280 In POSIX mode, don't make this a suffix rule. Previous versions
281 of GNU make did treat this as a suffix rule and ignored the
282 prerequisites, which is bad. In the future we'll do the same as
283 POSIX, but for now preserve the old behavior and warn about it. */
288 error (&f->cmds->fileinfo, 0,
289 _("warning: ignoring prerequisites on suffix rule definition"));
292 if (s2len == 2 && rulename[slen] == '.' && rulename[slen + 1] == 'a')
293 /* A suffix rule '.X.a:' generates the pattern rule '(%.o): %.X'.
294 It also generates a normal '%.a: %.X' rule below. */
295 convert_suffix_rule (NULL, /* Indicates '(%.o)'. */
299 /* The suffix rule '.X.Y:' is converted
300 to the pattern rule '%.Y: %.X'. */
301 convert_suffix_rule (dep_name (d2), dep_name (d), f->cmds);
307 /* Install the pattern rule RULE (whose fields have been filled in) at the end
308 of the list (so that any rules previously defined will take precedence).
309 If this rule duplicates a previous one (identical target and dependencies),
310 the old one is replaced if OVERRIDE is nonzero, otherwise this new one is
311 thrown out. When an old rule is replaced, the new one is put at the end of
312 the list. Return nonzero if RULE is used; zero if not. */
315 new_pattern_rule (struct rule *rule, int override)
317 struct rule *r, *lastrule;
325 /* Search for an identical rule. */
327 for (r = pattern_rules; r != 0; lastrule = r, r = r->next)
328 for (i = 0; i < rule->num; ++i)
330 for (j = 0; j < r->num; ++j)
331 if (!streq (rule->targets[i], r->targets[j]))
333 /* If all the targets matched... */
337 for (d = rule->deps, d2 = r->deps;
338 d != 0 && d2 != 0; d = d->next, d2 = d2->next)
339 if (!streq (dep_name (d), dep_name (d2)))
341 if (d == 0 && d2 == 0)
343 /* All the dependencies matched. */
346 /* Remove the old rule. */
347 freerule (r, lastrule);
348 /* Install the new one. */
349 if (pattern_rules == 0)
350 pattern_rules = rule;
352 last_pattern_rule->next = rule;
353 last_pattern_rule = rule;
355 /* We got one. Stop looking. */
360 /* The old rule stays intact. Destroy the new one. */
361 freerule (rule, (struct rule *) 0);
372 /* There was no rule to replace. */
373 if (pattern_rules == 0)
374 pattern_rules = rule;
376 last_pattern_rule->next = rule;
377 last_pattern_rule = rule;
384 /* Install an implicit pattern rule based on the three text strings
385 in the structure P points to. These strings come from one of
386 the arrays of default implicit pattern rules.
387 TERMINAL specifies what the 'terminal' field of the rule should be. */
390 install_pattern_rule (struct pspec *p, int terminal)
395 r = xmalloc (sizeof (struct rule));
398 r->targets = xmalloc (sizeof (const char *));
399 r->suffixes = xmalloc (sizeof (const char *));
400 r->lens = xmalloc (sizeof (unsigned int));
402 r->lens[0] = (unsigned int) strlen (p->target);
403 r->targets[0] = p->target;
404 r->suffixes[0] = find_percent_cached (&r->targets[0]);
405 assert (r->suffixes[0] != NULL);
409 r->deps = PARSE_SIMPLE_SEQ ((char **)&ptr, struct dep);
411 if (new_pattern_rule (r, 0))
413 r->terminal = terminal ? 1 : 0;
414 r->cmds = xmalloc (sizeof (struct commands));
415 r->cmds->fileinfo.filenm = 0;
416 r->cmds->fileinfo.lineno = 0;
417 r->cmds->fileinfo.offset = 0;
418 /* These will all be string literals, but we malloc space for them
419 anyway because somebody might want to free them later. */
420 r->cmds->commands = xstrdup (p->commands);
421 r->cmds->command_lines = 0;
422 r->cmds->recipe_prefix = RECIPEPREFIX_DEFAULT;
427 /* Free all the storage used in RULE and take it out of the
428 pattern_rules chain. LASTRULE is the rule whose next pointer
432 freerule (struct rule *rule, struct rule *lastrule)
434 struct rule *next = rule->next;
436 free_dep_chain (rule->deps);
438 /* MSVC erroneously warns without a cast here. */
439 free ((void *)rule->targets);
440 free ((void *)rule->suffixes);
443 /* We can't free the storage for the commands because there
444 are ways that they could be in more than one place:
445 * If the commands came from a suffix rule, they could also be in
446 the 'struct file's for other suffix rules or plain targets given
447 on the same makefile line.
448 * If two suffixes that together make a two-suffix rule were each
449 given twice in the .SUFFIXES list, and in the proper order, two
450 identical pattern rules would be created and the second one would
451 be discarded here, but both would contain the same 'struct commands'
452 pointer from the 'struct file' for the suffix rule. */
456 if (pattern_rules == rule)
460 pattern_rules = next;
461 else if (lastrule != 0)
462 lastrule->next = next;
463 if (last_pattern_rule == rule)
464 last_pattern_rule = lastrule;
467 /* Create a new pattern rule with the targets in the nil-terminated array
468 TARGETS. TARGET_PERCENTS is an array of pointers to the % in each element
469 of TARGETS. N is the number of items in the array (not counting the nil
470 element). The new rule has dependencies DEPS and commands from COMMANDS.
471 It is a terminal rule if TERMINAL is nonzero. This rule overrides
472 identical rules with different commands if OVERRIDE is nonzero.
474 The storage for TARGETS and its elements and TARGET_PERCENTS is used and
475 must not be freed until the rule is destroyed. */
478 create_pattern_rule (const char **targets, const char **target_percents,
479 unsigned short n, int terminal, struct dep *deps,
480 struct commands *commands, int override)
483 struct rule *r = xmalloc (sizeof (struct rule));
488 r->targets = targets;
489 r->suffixes = target_percents;
490 r->lens = xmalloc (n * sizeof (unsigned int));
492 for (i = 0; i < n; ++i)
494 r->lens[i] = (unsigned int) strlen (targets[i]);
495 assert (r->suffixes[i] != NULL);
499 if (new_pattern_rule (r, override))
500 r->terminal = terminal ? 1 : 0;
503 /* Print the data base of rules. */
505 static void /* Useful to call from gdb. */
506 print_rule (struct rule *r)
510 for (i = 0; i < r->num; ++i)
512 fputs (r->targets[i], stdout);
513 putchar ((i + 1 == r->num) ? ':' : ' ');
518 print_prereqs (r->deps);
521 print_commands (r->cmds);
525 print_rule_data_base (void)
527 unsigned int rules, terminal;
530 puts (_("\n# Implicit Rules"));
532 rules = terminal = 0;
533 for (r = pattern_rules; r != 0; r = r->next)
545 puts (_("\n# No implicit rules."));
548 printf (_("\n# %u implicit rules, %u (%.1f%%) terminal."),
549 rules, terminal, (double) terminal / (double) rules * 100.0);
552 if (num_pattern_rules != rules)
554 /* This can happen if a fatal error was detected while reading the
555 makefiles and thus count_implicit_rule_limits wasn't called yet. */
556 if (num_pattern_rules != 0)
557 ONN (fatal, NILF, _("BUG: num_pattern_rules is wrong! %u != %u"),
558 num_pattern_rules, rules);