1 /* Basic dependency engine for GNU Make.
2 Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4 2010 Free Software Foundation, Inc.
5 This file is part of GNU Make.
7 GNU Make is free software; you can redistribute it and/or modify it under the
8 terms of the GNU General Public License as published by the Free Software
9 Foundation; either version 3 of the License, or (at your option) any later
12 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
14 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along with
17 this program. If not, see <http://www.gnu.org/licenses/>. */
42 extern int try_implicit_rule (struct file *file, unsigned int depth);
45 /* The test for circular dependencies is based on the 'updating' bit in
46 `struct file'. However, double colon targets have seperate `struct
47 file's; make sure we always use the base of the double colon chain. */
49 #define start_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
51 #define finish_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
53 #define is_updating(_f) (((_f)->double_colon ? (_f)->double_colon : (_f))\
57 /* Incremented when a command is started (under -n, when one would be). */
58 unsigned int commands_started = 0;
60 /* Current value for pruning the scan of the goal chain (toggle 0/1). */
61 static unsigned int considered;
63 static int update_file (struct file *file, unsigned int depth);
64 static int update_file_1 (struct file *file, unsigned int depth);
65 static int check_dep (struct file *file, unsigned int depth,
66 FILE_TIMESTAMP this_mtime, int *must_make_ptr);
67 static int touch_file (struct file *file);
68 static void remake_file (struct file *file);
69 static FILE_TIMESTAMP name_mtime (const char *name);
70 static const char *library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr);
73 /* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing
74 was done, 0 if all goals were updated successfully, or 1 if a goal failed.
76 If rebuilding_makefiles is nonzero, these goals are makefiles, so -t, -q,
77 and -n should be disabled for them unless they were also command-line
78 targets, and we should only make one goal at a time and return as soon as
79 one goal whose `changed' member is nonzero is successfully made. */
82 update_goal_chain (struct dep *goals)
84 int t = touch_flag, q = question_flag, n = just_print_flag;
87 #define MTIME(file) (rebuilding_makefiles ? file_mtime_no_search (file) \
90 /* Duplicate the chain so we can remove things from it. */
92 goals = copy_dep_chain (goals);
95 /* Clear the `changed' flag of each goal in the chain.
96 We will use the flag below to notice when any commands
97 have actually been run for a target. When no commands
98 have been run, we give an "up to date" diagnostic. */
101 for (g = goals; g != 0; g = g->next)
105 /* All files start with the considered bit 0, so the global value is 1. */
108 /* Update all the goals until they are all finished. */
112 register struct dep *g, *lastgoal;
114 /* Start jobs that are waiting for the load to go down. */
116 start_waiting_jobs ();
118 /* Wait for a child to die. */
120 reap_children (1, 0);
126 /* Iterate over all double-colon entries for this file. */
128 int stop = 0, any_not_updated = 0;
130 for (file = g->file->double_colon ? g->file->double_colon : g->file;
134 unsigned int ocommands_started;
137 file->dontcare = g->dontcare;
139 check_renamed (file);
140 if (rebuilding_makefiles)
142 if (file->cmd_target)
149 touch_flag = question_flag = just_print_flag = 0;
152 /* Save the old value of `commands_started' so we can compare
153 later. It will be incremented when any commands are
155 ocommands_started = commands_started;
157 x = update_file (file, rebuilding_makefiles ? 1 : 0);
158 check_renamed (file);
160 /* Set the goal's `changed' flag if any commands were started
161 by calling update_file above. We check this flag below to
162 decide when to give an "up to date" diagnostic. */
163 if (commands_started > ocommands_started)
166 /* If we updated a file and STATUS was not already 1, set it to
167 1 if updating failed, or to 0 if updating succeeded. Leave
168 STATUS as it is if no updating was done. */
171 if ((x != 0 || file->updated) && status < 1)
173 if (file->update_status != 0)
175 /* Updating failed, or -q triggered. The STATUS value
176 tells our caller which. */
177 status = file->update_status;
178 /* If -q just triggered, stop immediately. It doesn't
179 matter how much more we run, since we already know
180 the answer to return. */
181 stop = (question_flag && !keep_going_flag
182 && !rebuilding_makefiles);
186 FILE_TIMESTAMP mtime = MTIME (file);
187 check_renamed (file);
189 if (file->updated && g->changed &&
190 mtime != file->mtime_before_update)
192 /* Updating was done. If this is a makefile and
193 just_print_flag or question_flag is set (meaning
194 -n or -q was given and this file was specified
195 as a command-line target), don't change STATUS.
196 If STATUS is changed, we will get re-exec'd, and
197 enter an infinite loop. */
198 if (!rebuilding_makefiles
199 || (!just_print_flag && !question_flag))
201 if (rebuilding_makefiles && file->dontcare)
202 /* This is a default makefile; stop remaking. */
208 /* Keep track if any double-colon entry is not finished.
209 When they are all finished, the goal is finished. */
210 any_not_updated |= !file->updated;
218 /* Reset FILE since it is null at the end of the loop. */
221 if (stop || !any_not_updated)
223 /* If we have found nothing whatever to do for the goal,
224 print a message saying nothing needs doing. */
226 if (!rebuilding_makefiles
227 /* If the update_status is zero, we updated successfully
228 or not at all. G->changed will have been set above if
229 any commands were actually started for this goal. */
230 && file->update_status == 0 && !g->changed
231 /* Never give a message under -s or -q. */
232 && !silent_flag && !question_flag)
233 message (1, ((file->phony || file->cmds == 0)
234 ? _("Nothing to be done for `%s'.")
235 : _("`%s' is up to date.")),
238 /* This goal is finished. Remove it from the chain. */
242 lastgoal->next = g->next;
244 /* Free the storage. */
247 g = lastgoal == 0 ? goals : lastgoal->next;
259 /* If we reached the end of the dependency graph toggle the considered
260 flag for the next pass. */
262 considered = !considered;
265 if (rebuilding_makefiles)
275 /* If FILE is not up to date, execute the commands for it.
276 Return 0 if successful, 1 if unsuccessful;
277 but with some flag settings, just call `exit' if unsuccessful.
279 DEPTH is the depth in recursions of this function.
280 We increment it during the consideration of our dependencies,
281 then decrement it again after finding out whether this file
284 If there are multiple double-colon entries for FILE,
285 each is considered in turn. */
288 update_file (struct file *file, unsigned int depth)
290 register int status = 0;
291 register struct file *f;
293 f = file->double_colon ? file->double_colon : file;
295 /* Prune the dependency graph: if we've already been here on _this_
296 pass through the dependency graph, we don't have to go any further.
297 We won't reap_children until we start the next pass, so no state
298 change is possible below here until then. */
299 if (f->considered == considered)
301 /* Check for the case where a target has been tried and failed but
302 the diagnostics hasn't been issued. If we need the diagnostics
303 then we will have to continue. */
304 if (!(f->updated && f->update_status > 0 && !f->dontcare && f->no_diag) && f->command_state!=cs_not_started )
306 DBF (DB_VERBOSE, _("Pruning file `%s'.\n"));
307 return f->command_state == cs_finished ? f->update_status : 0;
311 /* This loop runs until we start commands for a double colon rule, or until
312 the chain is exhausted. */
313 for (; f != 0; f = f->prev)
315 f->considered = considered;
317 status |= update_file_1 (f, depth);
320 /* Clean up any alloca() used during the update. */
323 /* If we got an error, don't bother with double_colon etc. */
324 if (status != 0 && !keep_going_flag)
327 if (f->command_state == cs_running
328 || f->command_state == cs_deps_running)
330 /* Don't run the other :: rules for this
331 file until this rule is finished. */
337 /* Process the remaining rules in the double colon chain so they're marked
338 considered. Start their prerequisites, too. */
339 if (file->double_colon)
340 for (; f != 0 ; f = f->prev)
344 f->considered = considered;
346 for (d = f->deps; d != 0; d = d->next)
347 status |= update_file (d->file, depth + 1);
353 /* Show a message stating the target failed to build. */
356 complain (struct file *file)
358 const char *msg_noparent
359 = _("%sNo rule to make target `%s'%s");
360 const char *msg_parent
361 = _("%sNo rule to make target `%s', needed by `%s'%s");
363 /* If this file has no_diag set then it means we tried to update it
364 before in the dontcare mode and failed. The target that actually
365 failed is not necessarily this file but could be one of its direct
366 or indirect dependencies. So traverse this file's dependencies and
367 find the one that actually caused the failure. */
371 for (d = file->deps; d != 0; d = d->next)
373 if (d->file->updated && d->file->update_status > 0 && file->no_diag)
382 /* Didn't find any dependencies to complain about. */
383 if (!keep_going_flag)
385 if (file->parent == 0)
386 fatal (NILF, msg_noparent, "", file->name, "");
388 fatal (NILF, msg_parent, "", file->name, file->parent->name, "");
391 if (file->parent == 0)
392 error (NILF, msg_noparent, "*** ", file->name, ".");
394 error (NILF, msg_parent, "*** ", file->name, file->parent->name, ".");
400 /* Consider a single `struct file' and update it as appropriate. */
403 update_file_1 (struct file *file, unsigned int depth)
405 FILE_TIMESTAMP this_mtime;
406 int noexist, must_make, deps_changed;
413 DBF (DB_VERBOSE, _("Considering target file `%s'.\n"));
417 if (file->update_status > 0)
420 _("Recently tried and failed to update file `%s'.\n"));
422 /* If the file we tried to make is marked no_diag then no message
423 was printed about it when it failed during the makefile rebuild.
424 If we're trying to build it again in the normal rebuild, print a
426 if (file->no_diag && !file->dontcare)
429 return file->update_status;
432 DBF (DB_VERBOSE, _("File `%s' was considered already.\n"));
436 switch (file->command_state)
439 case cs_deps_running:
442 DBF (DB_VERBOSE, _("Still updating file `%s'.\n"));
445 DBF (DB_VERBOSE, _("Finished updating file `%s'.\n"));
446 return file->update_status;
451 /* Determine whether the diagnostics will be issued should this update
453 file->no_diag = file->dontcare;
457 /* Notice recursive update of the same file. */
458 start_updating (file);
460 /* We might change file if we find a different one via vpath;
461 remember this one to turn off updating. */
464 /* Looking at the file's modtime beforehand allows the possibility
465 that its name may be changed by a VPATH search, and thus it may
466 not need an implicit rule. If this were not done, the file
467 might get implicit commands that apply to its initial name, only
468 to have that name replaced with another found by VPATH search. */
470 this_mtime = file_mtime (file);
471 check_renamed (file);
472 noexist = this_mtime == NONEXISTENT_MTIME;
474 DBF (DB_BASIC, _("File `%s' does not exist.\n"));
475 else if (ORDINARY_MTIME_MIN <= this_mtime && this_mtime <= ORDINARY_MTIME_MAX
476 && file->low_resolution_time)
478 /* Avoid spurious rebuilds due to low resolution time stamps. */
479 int ns = FILE_TIMESTAMP_NS (this_mtime);
481 error (NILF, _("*** Warning: .LOW_RESOLUTION_TIME file `%s' has a high resolution time stamp"),
483 this_mtime += FILE_TIMESTAMPS_PER_S - 1 - ns;
488 /* If file was specified as a target with no commands,
489 come up with some default commands. */
491 if (!file->phony && file->cmds == 0 && !file->tried_implicit)
493 if (try_implicit_rule (file, depth))
494 DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n"));
496 DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n"));
497 file->tried_implicit = 1;
499 if (file->cmds == 0 && !file->is_target
500 && default_file != 0 && default_file->cmds != 0)
502 DBF (DB_IMPLICIT, _("Using default recipe for `%s'.\n"));
503 file->cmds = default_file->cmds;
506 /* Update all non-intermediate files we depend on, if necessary, and see
507 whether any of them is more recent than this file. We need to walk our
508 deps, AND the deps of any also_make targets to ensure everything happens
509 in the correct order. */
512 amake.next = file->also_make;
516 struct dep *lastd = 0;
518 /* Find the deps we're scanning */
524 FILE_TIMESTAMP mtime;
528 check_renamed (d->file);
530 mtime = file_mtime (d->file);
531 check_renamed (d->file);
533 if (is_updating (d->file))
535 error (NILF, _("Circular %s <- %s dependency dropped."),
536 file->name, d->file->name);
537 /* We cannot free D here because our the caller will still have
538 a reference to it when we were called recursively via
541 file->deps = d->next;
543 lastd->next = d->next;
548 d->file->parent = file;
549 maybe_make = must_make;
551 /* Inherit dontcare flag from our parent. */
552 if (rebuilding_makefiles)
554 dontcare = d->file->dontcare;
555 d->file->dontcare = file->dontcare;
558 dep_status |= check_dep (d->file, depth, this_mtime, &maybe_make);
560 /* Restore original dontcare flag. */
561 if (rebuilding_makefiles)
562 d->file->dontcare = dontcare;
564 if (! d->ignore_mtime)
565 must_make = maybe_make;
567 check_renamed (d->file);
570 register struct file *f = d->file;
575 running |= (f->command_state == cs_running
576 || f->command_state == cs_deps_running);
582 if (dep_status != 0 && !keep_going_flag)
586 /* The prereq is considered changed if the timestamp has changed while
587 it was built, OR it doesn't exist. */
588 d->changed = ((file_mtime (d->file) != mtime)
589 || (mtime == NONEXISTENT_MTIME));
596 /* Now we know whether this target needs updating.
597 If it does, update all the intermediate files we depend on. */
599 if (must_make || always_make_flag)
601 for (d = file->deps; d != 0; d = d->next)
602 if (d->file->intermediate)
606 FILE_TIMESTAMP mtime = file_mtime (d->file);
607 check_renamed (d->file);
608 d->file->parent = file;
610 /* Inherit dontcare flag from our parent. */
611 if (rebuilding_makefiles)
613 dontcare = d->file->dontcare;
614 d->file->dontcare = file->dontcare;
617 /* We may have already encountered this file earlier in the same
618 * pass before we knew we'd be updating this target. In that
619 * case calling update_file now would result in the file being
620 * inappropriately pruned so we toggle the considered bit back
622 d->file->considered = !considered;
624 dep_status |= update_file (d->file, depth);
626 /* Restore original dontcare flag. */
627 if (rebuilding_makefiles)
628 d->file->dontcare = dontcare;
630 check_renamed (d->file);
633 register struct file *f = d->file;
638 running |= (f->command_state == cs_running
639 || f->command_state == cs_deps_running);
645 if (dep_status != 0 && !keep_going_flag)
649 d->changed = ((file->phony && file->cmds != 0)
650 || file_mtime (d->file) != mtime);
654 finish_updating (file);
655 finish_updating (ofile);
657 DBF (DB_VERBOSE, _("Finished prerequisites of target file `%s'.\n"));
661 set_command_state (file, cs_deps_running);
663 DBF (DB_VERBOSE, _("The prerequisites of `%s' are being made.\n"));
667 /* If any dependency failed, give up now. */
671 file->update_status = dep_status;
672 notice_finished_file (file);
676 DBF (DB_VERBOSE, _("Giving up on target file `%s'.\n"));
678 if (depth == 0 && keep_going_flag
679 && !just_print_flag && !question_flag)
681 _("Target `%s' not remade because of errors."), file->name);
686 if (file->command_state == cs_deps_running)
687 /* The commands for some deps were running on the last iteration, but
688 they have finished now. Reset the command_state to not_started to
689 simplify later bookkeeping. It is important that we do this only
690 when the prior state was cs_deps_running, because that prior state
691 was definitely propagated to FILE's also_make's by set_command_state
692 (called above), but in another state an also_make may have
693 independently changed to finished state, and we would confuse that
694 file's bookkeeping (updated, but not_started is bogus state). */
695 set_command_state (file, cs_not_started);
697 /* Now record which prerequisites are more
698 recent than this file, so we can define $?. */
701 for (d = file->deps; d != 0; d = d->next)
703 FILE_TIMESTAMP d_mtime = file_mtime (d->file);
704 check_renamed (d->file);
706 if (! d->ignore_mtime)
709 /* %%% In version 4, remove this code completely to
710 implement not remaking deps if their deps are newer
711 than their parents. */
712 if (d_mtime == NONEXISTENT_MTIME && !d->file->intermediate)
713 /* We must remake if this dep does not
714 exist and is not intermediate. */
718 /* Set DEPS_CHANGED if this dep actually changed. */
719 deps_changed |= d->changed;
722 /* Set D->changed if either this dep actually changed,
723 or its dependent, FILE, is older or does not exist. */
724 d->changed |= noexist || d_mtime > this_mtime;
726 if (!noexist && ISDB (DB_BASIC|DB_VERBOSE))
732 if (ISDB (DB_VERBOSE))
733 fmt = _("Prerequisite `%s' is order-only for target `%s'.\n");
735 else if (d_mtime == NONEXISTENT_MTIME)
738 fmt = _("Prerequisite `%s' of target `%s' does not exist.\n");
743 fmt = _("Prerequisite `%s' is newer than target `%s'.\n");
745 else if (ISDB (DB_VERBOSE))
746 fmt = _("Prerequisite `%s' is older than target `%s'.\n");
750 print_spaces (depth);
751 printf (fmt, dep_name (d), file->name);
757 /* Here depth returns to the value it had when we were called. */
760 if (file->double_colon && file->deps == 0)
764 _("Target `%s' is double-colon and has no prerequisites.\n"));
766 else if (!noexist && file->is_target && !deps_changed && file->cmds == 0
767 && !always_make_flag)
771 _("No recipe for `%s' and no prerequisites actually changed.\n"));
773 else if (!must_make && file->cmds != 0 && always_make_flag)
776 DBF (DB_VERBOSE, _("Making `%s' due to always-make flag.\n"));
781 if (ISDB (DB_VERBOSE))
783 print_spaces (depth);
784 printf (_("No need to remake target `%s'"), file->name);
785 if (!streq (file->name, file->hname))
786 printf (_("; using VPATH name `%s'"), file->hname);
791 notice_finished_file (file);
793 /* Since we don't need to remake the file, convert it to use the
794 VPATH filename if we found one. hfile will be either the
795 local name if no VPATH or the VPATH name if one was found. */
799 file->name = file->hname;
806 DBF (DB_BASIC, _("Must remake target `%s'.\n"));
808 /* It needs to be remade. If it's VPATH and not reset via GPATH, toss the
810 if (!streq(file->name, file->hname))
812 DB (DB_BASIC, (_(" Ignoring VPATH name `%s'.\n"), file->hname));
813 file->ignore_vpath = 1;
816 /* Now, take appropriate actions to remake the file. */
819 if (file->command_state != cs_finished)
821 DBF (DB_VERBOSE, _("Recipe of `%s' is being run.\n"));
825 switch (file->update_status)
828 DBF (DB_BASIC, _("Failed to remake target file `%s'.\n"));
831 DBF (DB_BASIC, _("Successfully remade target file `%s'.\n"));
834 DBF (DB_BASIC, _("Target file `%s' needs remade under -q.\n"));
837 assert (file->update_status >= 0 && file->update_status <= 2);
842 return file->update_status;
845 /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all
846 files listed in its `also_make' member. Under -t, this function also
849 On return, FILE->update_status will no longer be -1 if it was. */
852 notice_finished_file (struct file *file)
855 int ran = file->command_state == cs_running;
858 file->command_state = cs_finished;
862 /* The update status will be:
863 -1 if this target was not remade;
864 0 if 0 or more commands (+ or ${MAKE}) were run and won;
865 1 if some commands were run and lost.
866 We touch the target if it has commands which either were not run
867 or won when they ran (i.e. status is 0). */
868 && file->update_status == 0)
870 if (file->cmds != 0 && file->cmds->any_recurse)
872 /* If all the command lines were recursive,
873 we don't want to do the touching. */
875 for (i = 0; i < file->cmds->ncommand_lines; ++i)
876 if (!(file->cmds->lines_flags[i] & COMMANDS_RECURSE))
877 goto have_nonrecursing;
883 file->update_status = 0;
884 /* According to POSIX, -t doesn't affect targets with no cmds. */
885 else if (file->cmds != 0)
887 /* Should set file's modification date and do nothing else. */
888 file->update_status = touch_file (file);
890 /* Pretend we ran a real touch command, to suppress the
891 "`foo' is up to date" message. */
894 /* Request for the timestamp to be updated (and distributed
895 to the double-colon entries). Simply setting ran=1 would
896 almost have done the trick, but messes up with the also_make
897 updating logic below. */
903 if (file->mtime_before_update == UNKNOWN_MTIME)
904 file->mtime_before_update = file->last_mtime;
906 if ((ran && !file->phony) || touched)
910 /* If -n, -t, or -q and all the commands are recursive, we ran them so
911 really check the target's mtime again. Otherwise, assume the target
912 would have been updated. */
914 if ((question_flag || just_print_flag || touch_flag) && file->cmds)
916 for (i = file->cmds->ncommand_lines; i > 0; --i)
917 if (! (file->cmds->lines_flags[i-1] & COMMANDS_RECURSE))
921 /* If there were no commands at all, it's always new. */
923 else if (file->is_target && file->cmds == 0)
926 file->last_mtime = i == 0 ? UNKNOWN_MTIME : NEW_MTIME;
929 if (file->double_colon)
931 /* If this is a double colon rule and it is the last one to be
932 updated, propagate the change of modification time to all the
933 double-colon entries for this file.
935 We do it on the last update because it is important to handle
936 individual entries as separate rules with separate timestamps
937 while they are treated as targets and then as one rule with the
938 unified timestamp when they are considered as a prerequisite
942 FILE_TIMESTAMP max_mtime = file->last_mtime;
944 /* Check that all rules were updated and at the same time find
945 the max timestamp. We assume UNKNOWN_MTIME is newer then
947 for (f = file->double_colon; f != 0 && f->updated; f = f->prev)
948 if (max_mtime != UNKNOWN_MTIME
949 && (f->last_mtime == UNKNOWN_MTIME || f->last_mtime > max_mtime))
950 max_mtime = f->last_mtime;
953 for (f = file->double_colon; f != 0; f = f->prev)
954 f->last_mtime = max_mtime;
957 if (ran && file->update_status != -1)
958 /* We actually tried to update FILE, which has
959 updated its also_make's as well (if it worked).
960 If it didn't work, it wouldn't work again for them.
961 So mark them as updated with the same status. */
962 for (d = file->also_make; d != 0; d = d->next)
964 d->file->command_state = cs_finished;
965 d->file->updated = 1;
966 d->file->update_status = file->update_status;
968 if (ran && !d->file->phony)
969 /* Fetch the new modification time.
970 We do this instead of just invalidating the cached time
971 so that a vpath_search can happen. Otherwise, it would
972 never be done because the target is already updated. */
973 f_mtime (d->file, 0);
975 else if (file->update_status == -1)
976 /* Nothing was done for FILE, but it needed nothing done.
977 So mark it now as "succeeded". */
978 file->update_status = 0;
981 /* Check whether another file (whose mtime is THIS_MTIME) needs updating on
982 account of a dependency which is file FILE. If it does, store 1 in
983 *MUST_MAKE_PTR. In the process, update any non-intermediate files that
984 FILE depends on (including FILE itself). Return nonzero if any updating
988 check_dep (struct file *file, unsigned int depth,
989 FILE_TIMESTAMP this_mtime, int *must_make_ptr)
996 start_updating (file);
998 /* We might change file if we find a different one via vpath;
999 remember this one to turn off updating. */
1002 if (file->phony || !file->intermediate)
1004 /* If this is a non-intermediate file, update it and record whether it
1005 is newer than THIS_MTIME. */
1006 FILE_TIMESTAMP mtime;
1007 dep_status = update_file (file, depth);
1008 check_renamed (file);
1009 mtime = file_mtime (file);
1010 check_renamed (file);
1011 if (mtime == NONEXISTENT_MTIME || mtime > this_mtime)
1016 /* FILE is an intermediate file. */
1017 FILE_TIMESTAMP mtime;
1019 if (!file->phony && file->cmds == 0 && !file->tried_implicit)
1021 if (try_implicit_rule (file, depth))
1022 DBF (DB_IMPLICIT, _("Found an implicit rule for `%s'.\n"));
1024 DBF (DB_IMPLICIT, _("No implicit rule found for `%s'.\n"));
1025 file->tried_implicit = 1;
1027 if (file->cmds == 0 && !file->is_target
1028 && default_file != 0 && default_file->cmds != 0)
1030 DBF (DB_IMPLICIT, _("Using default commands for `%s'.\n"));
1031 file->cmds = default_file->cmds;
1034 check_renamed (file);
1035 mtime = file_mtime (file);
1036 check_renamed (file);
1037 if (mtime != NONEXISTENT_MTIME && mtime > this_mtime)
1038 /* If the intermediate file actually exists and is newer, then we
1039 should remake from it. */
1043 /* Otherwise, update all non-intermediate files we depend on, if
1044 necessary, and see whether any of them is more recent than the
1045 file on whose behalf we are checking. */
1047 int deps_running = 0;
1049 /* If this target is not running, set it's state so that we check it
1050 fresh. It could be it was checked as part of an order-only
1051 prerequisite and so wasn't rebuilt then, but should be now. */
1052 if (file->command_state != cs_running)
1053 set_command_state (file, cs_not_started);
1061 if (is_updating (d->file))
1063 error (NILF, _("Circular %s <- %s dependency dropped."),
1064 file->name, d->file->name);
1067 file->deps = d->next;
1080 d->file->parent = file;
1081 maybe_make = *must_make_ptr;
1082 dep_status |= check_dep (d->file, depth, this_mtime,
1084 if (! d->ignore_mtime)
1085 *must_make_ptr = maybe_make;
1086 check_renamed (d->file);
1087 if (dep_status != 0 && !keep_going_flag)
1090 if (d->file->command_state == cs_running
1091 || d->file->command_state == cs_deps_running)
1099 /* Record that some of FILE's deps are still being made.
1100 This tells the upper levels to wait on processing it until the
1101 commands are finished. */
1102 set_command_state (file, cs_deps_running);
1106 finish_updating (file);
1107 finish_updating (ofile);
1112 /* Touch FILE. Return zero if successful, one if not. */
1114 #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
1117 touch_file (struct file *file)
1120 message (0, "touch %s", file->name);
1123 if (ar_name (file->name))
1124 return ar_touch (file->name);
1128 int fd = open (file->name, O_RDWR | O_CREAT, 0666);
1131 TOUCH_ERROR ("touch: open: ");
1134 struct stat statbuf;
1138 EINTRLOOP (e, fstat (fd, &statbuf));
1140 TOUCH_ERROR ("touch: fstat: ");
1141 /* Rewrite character 0 same as it already is. */
1142 if (read (fd, &buf, 1) < 0)
1143 TOUCH_ERROR ("touch: read: ");
1144 if (lseek (fd, 0L, 0) < 0L)
1145 TOUCH_ERROR ("touch: lseek: ");
1146 if (write (fd, &buf, 1) < 0)
1147 TOUCH_ERROR ("touch: write: ");
1148 /* If file length was 0, we just
1149 changed it, so change it back. */
1150 if (statbuf.st_size == 0)
1153 fd = open (file->name, O_RDWR | O_TRUNC, 0666);
1155 TOUCH_ERROR ("touch: open: ");
1164 /* Having checked and updated the dependencies of FILE,
1165 do whatever is appropriate to remake FILE itself.
1166 Return the status from executing FILE's commands. */
1169 remake_file (struct file *file)
1171 if (file->cmds == 0)
1174 /* Phony target. Pretend it succeeded. */
1175 file->update_status = 0;
1176 else if (file->is_target)
1177 /* This is a nonexistent target file we cannot make.
1178 Pretend it was successfully remade. */
1179 file->update_status = 0;
1182 /* This is a dependency file we cannot remake. Fail. */
1183 if (!rebuilding_makefiles || !file->dontcare)
1185 file->update_status = 2;
1190 chop_commands (file->cmds);
1192 /* The normal case: start some commands. */
1193 if (!touch_flag || file->cmds->any_recurse)
1195 execute_file_commands (file);
1199 /* This tells notice_finished_file it is ok to touch the file. */
1200 file->update_status = 0;
1203 /* This does the touching under -t. */
1204 notice_finished_file (file);
1207 /* Return the mtime of a file, given a `struct file'.
1208 Caches the time in the struct file to avoid excess stat calls.
1210 If the file is not found, and SEARCH is nonzero, VPATH searching and
1211 replacement is done. If that fails, a library (-lLIBNAME) is tried and
1212 the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into
1216 f_mtime (struct file *file, int search)
1218 FILE_TIMESTAMP mtime;
1220 /* File's mtime is not known; must get it from the system. */
1223 if (ar_name (file->name))
1225 /* This file is an archive-member reference. */
1227 char *arname, *memname;
1228 struct file *arfile;
1231 /* Find the archive's name. */
1232 ar_parse_name (file->name, &arname, &memname);
1234 /* Find the modification time of the archive itself.
1235 Also allow for its name to be changed via VPATH search. */
1236 arfile = lookup_file (arname);
1238 arfile = enter_file (strcache_add (arname));
1239 mtime = f_mtime (arfile, search);
1240 check_renamed (arfile);
1241 if (search && strcmp (arfile->hname, arname))
1243 /* The archive's name has changed.
1244 Change the archive-member reference accordingly. */
1247 unsigned int arlen, memlen;
1249 arlen = strlen (arfile->hname);
1250 memlen = strlen (memname);
1252 name = xmalloc (arlen + 1 + memlen + 2);
1253 memcpy (name, arfile->hname, arlen);
1255 memcpy (name + arlen + 1, memname, memlen);
1256 name[arlen + 1 + memlen] = ')';
1257 name[arlen + 1 + memlen + 1] = '\0';
1259 /* If the archive was found with GPATH, make the change permanent;
1260 otherwise defer it until later. */
1261 if (arfile->name == arfile->hname)
1262 rename_file (file, name);
1264 rehash_file (file, name);
1265 check_renamed (file);
1270 file->low_resolution_time = 1;
1272 if (mtime == NONEXISTENT_MTIME)
1273 /* The archive doesn't exist, so its members don't exist either. */
1274 return NONEXISTENT_MTIME;
1276 member_date = ar_member_date (file->hname);
1277 mtime = (member_date == (time_t) -1
1279 : file_timestamp_cons (file->hname, member_date, 0));
1284 mtime = name_mtime (file->name);
1286 if (mtime == NONEXISTENT_MTIME && search && !file->ignore_vpath)
1288 /* If name_mtime failed, search VPATH. */
1289 const char *name = vpath_search (file->name, &mtime, NULL, NULL);
1291 /* Last resort, is it a library (-lxxx)? */
1292 || (file->name[0] == '-' && file->name[1] == 'l'
1293 && (name = library_search (file->name, &mtime)) != 0))
1295 if (mtime != UNKNOWN_MTIME)
1296 /* vpath_search and library_search store UNKNOWN_MTIME
1297 if they didn't need to do a stat call for their work. */
1298 file->last_mtime = mtime;
1300 /* If we found it in VPATH, see if it's in GPATH too; if so,
1301 change the name right now; if not, defer until after the
1302 dependencies are updated. */
1303 if (gpath_search (name, strlen(name) - strlen(file->name) - 1))
1305 rename_file (file, name);
1306 check_renamed (file);
1307 return file_mtime (file);
1310 rehash_file (file, name);
1311 check_renamed (file);
1312 /* If the result of a vpath search is -o or -W, preserve it.
1313 Otherwise, find the mtime of the resulting file. */
1314 if (mtime != OLD_MTIME && mtime != NEW_MTIME)
1315 mtime = name_mtime (name);
1320 /* Files can have bogus timestamps that nothing newly made will be
1321 "newer" than. Updating their dependents could just result in loops.
1322 So notify the user of the anomaly with a warning.
1324 We only need to do this once, for now. */
1326 if (!clock_skew_detected
1327 && mtime != NONEXISTENT_MTIME && mtime != NEW_MTIME
1330 static FILE_TIMESTAMP adjusted_now;
1332 FILE_TIMESTAMP adjusted_mtime = mtime;
1334 #if defined(WINDOWS32) || defined(__MSDOS__)
1335 /* Experimentation has shown that FAT filesystems can set file times
1336 up to 3 seconds into the future! Play it safe. */
1338 #define FAT_ADJ_OFFSET (FILE_TIMESTAMP) 3
1340 FILE_TIMESTAMP adjustment = FAT_ADJ_OFFSET << FILE_TIMESTAMP_LO_BITS;
1341 if (ORDINARY_MTIME_MIN + adjustment <= adjusted_mtime)
1342 adjusted_mtime -= adjustment;
1343 #elif defined(__EMX__)
1344 /* FAT filesystems round time to the nearest even second!
1345 Allow for any file (NTFS or FAT) to perhaps suffer from this
1347 FILE_TIMESTAMP adjustment = (((FILE_TIMESTAMP_S (adjusted_mtime) & 1) == 0
1348 && FILE_TIMESTAMP_NS (adjusted_mtime) == 0)
1349 ? (FILE_TIMESTAMP) 1 << FILE_TIMESTAMP_LO_BITS
1353 /* If the file's time appears to be in the future, update our
1354 concept of the present and try once more. */
1355 if (adjusted_now < adjusted_mtime)
1358 FILE_TIMESTAMP now = file_timestamp_now (&resolution);
1359 adjusted_now = now + (resolution - 1);
1360 if (adjusted_now < adjusted_mtime)
1363 error (NILF, _("Warning: File `%s' has modification time in the future"),
1367 (FILE_TIMESTAMP_S (mtime) - FILE_TIMESTAMP_S (now)
1368 + ((FILE_TIMESTAMP_NS (mtime) - FILE_TIMESTAMP_NS (now))
1370 char from_now_string[100];
1372 if (from_now >= 99 && from_now <= ULONG_MAX)
1373 sprintf (from_now_string, "%lu", (unsigned long) from_now);
1375 sprintf (from_now_string, "%.2g", from_now);
1376 error (NILF, _("Warning: File `%s' has modification time %s s in the future"),
1377 file->name, from_now_string);
1379 clock_skew_detected = 1;
1384 /* Store the mtime into all the entries for this file. */
1385 if (file->double_colon)
1386 file = file->double_colon;
1390 /* If this file is not implicit but it is intermediate then it was
1391 made so by the .INTERMEDIATE target. If this file has never
1392 been built by us but was found now, it existed before make
1393 started. So, turn off the intermediate bit so make doesn't
1394 delete it, since it didn't create it. */
1395 if (mtime != NONEXISTENT_MTIME && file->command_state == cs_not_started
1396 && file->command_state == cs_not_started
1397 && !file->tried_implicit && file->intermediate)
1398 file->intermediate = 0;
1400 file->last_mtime = mtime;
1409 /* Return the mtime of the file or archive-member reference NAME. */
1411 /* First, we check with stat(). If the file does not exist, then we return
1412 NONEXISTENT_MTIME. If it does, and the symlink check flag is set, then
1413 examine each indirection of the symlink and find the newest mtime.
1414 This causes one duplicate stat() when -L is being used, but the code is
1417 static FILE_TIMESTAMP
1418 name_mtime (const char *name)
1420 FILE_TIMESTAMP mtime;
1424 EINTRLOOP (e, stat (name, &st));
1426 mtime = FILE_TIMESTAMP_STAT_MODTIME (name, st);
1427 else if (errno == ENOENT || errno == ENOTDIR)
1428 mtime = NONEXISTENT_MTIME;
1431 perror_with_name ("stat: ", name);
1432 return NONEXISTENT_MTIME;
1435 /* If we get here we either found it, or it doesn't exist.
1436 If it doesn't exist see if we can use a symlink mtime instead. */
1438 #ifdef MAKE_SYMLINKS
1440 # define S_ISLNK(_m) (((_m)&S_IFMT)==S_IFLNK)
1442 if (check_symlink_flag)
1446 /* Check each symbolic link segment (if any). Find the latest mtime
1447 amongst all of them (and the target file of course).
1448 Note that we have already successfully dereferenced all the links
1449 above. So, if we run into any error trying to lstat(), or
1450 readlink(), or whatever, something bizarre-o happened. Just give up
1451 and use whatever mtime we've already computed at that point. */
1452 strcpy (lpath, name);
1455 FILE_TIMESTAMP ltime;
1460 EINTRLOOP (e, lstat (lpath, &st));
1463 /* Just take what we have so far. */
1464 if (errno != ENOENT && errno != ENOTDIR)
1465 perror_with_name ("lstat: ", lpath);
1469 /* If this is not a symlink, we're done (we started with the real
1470 file's mtime so we don't need to test it again). */
1471 if (!S_ISLNK (st.st_mode))
1474 /* If this mtime is newer than what we had, keep the new one. */
1475 ltime = FILE_TIMESTAMP_STAT_MODTIME (lpath, st);
1479 /* Set up to check the file pointed to by this link. */
1480 EINTRLOOP (llen, readlink (lpath, lbuf, GET_PATH_MAX));
1483 /* Eh? Just take what we have. */
1484 perror_with_name ("readlink: ", lpath);
1489 /* If the target is fully-qualified or the source is just a
1490 filename, then the new path is the target. Otherwise it's the
1491 source directory plus the target. */
1492 if (lbuf[0] == '/' || (p = strrchr (lpath, '/')) == NULL)
1493 strcpy (lpath, lbuf);
1494 else if ((p - lpath) + llen + 2 > GET_PATH_MAX)
1495 /* Eh? Path too long! Again, just go with what we have. */
1498 /* Create the next step in the symlink chain. */
1508 /* Search for a library file specified as -lLIBNAME, searching for a
1509 suitable library file in the system library directories and the VPATH
1513 library_search (const char *lib, FILE_TIMESTAMP *mtime_ptr)
1515 static char *dirs[] =
1521 #if defined(WINDOWS32) && !defined(LIBDIR)
1523 * This is completely up to the user at product install time. Just define
1528 LIBDIR, /* Defined by configuration. */
1532 const char *file = 0;
1534 FILE_TIMESTAMP mtime;
1536 /* Loop variables for the libpatterns value. */
1540 unsigned int liblen;
1542 /* Information about the earliest (in the vpath sequence) match. */
1543 unsigned int best_vpath, best_path;
1544 unsigned int std_dirs = 0;
1548 libpatterns = xstrdup (variable_expand ("$(.LIBPATTERNS)"));
1550 /* Skip the '-l'. */
1552 liblen = strlen (lib);
1554 /* Loop through all the patterns in .LIBPATTERNS, and search on each one.
1555 To implement the linker-compatible behavior we have to search through
1556 all entries in .LIBPATTERNS and choose the "earliest" one. */
1558 while ((p = find_next_token (&p2, &len)) != 0)
1560 static char *buf = NULL;
1561 static unsigned int buflen = 0;
1562 static int libdir_maxlen = -1;
1563 char *libbuf = variable_expand ("");
1565 /* Expand the pattern using LIB as a replacement. */
1571 p3 = find_percent (p);
1574 /* Give a warning if there is no pattern. */
1575 error (NILF, _(".LIBPATTERNS element `%s' is not a pattern"), p);
1579 p4 = variable_buffer_output (libbuf, p, p3-p);
1580 p4 = variable_buffer_output (p4, lib, liblen);
1581 p4 = variable_buffer_output (p4, p3+1, len - (p3-p));
1585 /* Look first for `libNAME.a' in the current directory. */
1586 mtime = name_mtime (libbuf);
1587 if (mtime != NONEXISTENT_MTIME)
1591 file = strcache_add (libbuf);
1592 /* This by definition will have the best index, so stop now. */
1596 /* Now try VPATH search on that. */
1599 unsigned int vpath_index, path_index;
1600 const char* f = vpath_search (libbuf, mtime_ptr ? &mtime : NULL,
1601 &vpath_index, &path_index);
1604 /* If we have a better match, record it. */
1606 vpath_index < best_vpath ||
1607 (vpath_index == best_vpath && path_index < best_path))
1610 best_vpath = vpath_index;
1611 best_path = path_index;
1619 /* Now try the standard set of directories. */
1623 for (dp = dirs; *dp != 0; ++dp)
1625 int l = strlen (*dp);
1626 if (l > libdir_maxlen)
1630 buflen = strlen (libbuf);
1631 buf = xmalloc(libdir_maxlen + buflen + 2);
1633 else if (buflen < strlen (libbuf))
1635 buflen = strlen (libbuf);
1636 buf = xrealloc (buf, libdir_maxlen + buflen + 2);
1640 /* Use the last std_dirs index for standard directories. This
1641 was it will always be greater than the VPATH index. */
1642 unsigned int vpath_index = ~((unsigned int)0) - std_dirs;
1644 for (dp = dirs; *dp != 0; ++dp)
1646 sprintf (buf, "%s/%s", *dp, libbuf);
1647 mtime = name_mtime (buf);
1648 if (mtime != NONEXISTENT_MTIME)
1650 if (file == 0 || vpath_index < best_vpath)
1652 file = strcache_add (buf);
1653 best_vpath = vpath_index;