1 /* Basic dependency engine for GNU Make.
2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 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
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
32 extern int try_implicit_rule ();
35 /* Incremented when a command is started (under -n, when one would be). */
36 unsigned int commands_started
= 0;
38 static int update_file (), update_file_1 (), check_dep (), touch_file ();
39 static void remake_file ();
40 static time_t name_mtime ();
41 static int library_search ();
42 extern time_t f_mtime ();
44 /* Remake all the goals in the `struct dep' chain GOALS. Return -1 if nothing
45 was done, 0 if all goals were updated successfully, or 1 if a goal failed.
46 If MAKEFILES is nonzero, these goals are makefiles, so -t, -q, and -n should
47 be disabled for them unless they were also command-line targets, and we
48 should only make one goal at a time and return as soon as one goal whose
49 `changed' member is nonzero is successfully made. */
52 update_goal_chain (goals
, makefiles
)
53 register struct dep
*goals
;
56 int t
= touch_flag
, q
= question_flag
, n
= just_print_flag
;
57 unsigned int j
= job_slots
;
60 #define MTIME(file) (makefiles ? file_mtime_no_search (file) \
63 /* Duplicate the chain so we can remove things from it. */
65 goals
= copy_dep_chain (goals
);
68 /* Clear the `changed' flag of each goal in the chain.
69 We will use the flag below to notice when any commands
70 have actually been run for a target. When no commands
71 have been run, we give an "up to date" diagnostic. */
74 for (g
= goals
; g
!= 0; g
= g
->next
)
79 /* Only run one job at a time. */
82 /* Update all the goals until they are all finished. */
86 register struct dep
*g
, *lastgoal
;
88 /* Start jobs that are waiting for the load to go down. */
90 start_waiting_jobs ();
92 /* Wait for a child to die. */
100 /* Iterate over all double-colon entries for this file. */
101 struct file
*file
= g
->file
;
102 int stop
, any_not_updated
= 0;
103 for (file
= g
->file
->double_colon
? g
->file
->double_colon
: g
->file
;
107 unsigned int ocommands_started
;
109 time_t mtime
= MTIME (file
);
110 check_renamed (file
);
114 if (file
->cmd_target
)
121 touch_flag
= question_flag
= just_print_flag
= 0;
124 /* Save the old value of `commands_started' so we can compare
125 later. It will be incremented when any commands are
127 ocommands_started
= commands_started
;
129 x
= update_file (file
, makefiles
? 1 : 0);
130 check_renamed (file
);
132 /* Set the goal's `changed' flag if any commands were started
133 by calling update_file above. We check this flag below to
134 decide when to give an "up to date" diagnostic. */
135 g
->changed
+= commands_started
- ocommands_started
;
138 if (x
!= 0 || file
->updated
)
140 /* If STATUS was not already 1, set it to 1 if
141 updating failed, or to 0 if updating succeeded.
142 Leave STATUS as it is if no updating was done. */
146 if (file
->update_status
!= 0)
148 /* Updating failed, or -q triggered.
149 The STATUS value tells our caller which. */
150 status
= file
->update_status
;
151 /* If -q just triggered, stop immediately.
152 It doesn't matter how much more we run,
153 since we already know the answer to return. */
154 stop
= (!keep_going_flag
&& !question_flag
157 else if (MTIME (file
) != mtime
)
159 /* Updating was done. If this is a makefile and
160 just_print_flag or question_flag is set
161 (meaning -n or -q was given and this file was
162 specified as a command-line target), don't
163 change STATUS. If STATUS is changed, we will
164 get re-exec'd, and fall into an infinite loop. */
166 || (!just_print_flag
&& !question_flag
))
168 if (makefiles
&& file
->dontcare
)
169 /* This is a default makefile. Stop remaking. */
175 /* Keep track if any double-colon entry is not finished.
176 When they are all finished, the goal is finished. */
177 any_not_updated
|= !file
->updated
;
183 /* Reset FILE since it is null at the end of the loop. */
186 if (stop
|| !any_not_updated
)
188 /* If we have found nothing whatever to do for the goal,
189 print a message saying nothing needs doing. */
192 /* If the update_status is zero, we updated successfully
193 or not at all. G->changed will have been set above if
194 any commands were actually started for this goal. */
195 && file
->update_status
== 0 && !g
->changed
196 /* Never give a message under -s or -q. */
197 && !silent_flag
&& !question_flag
)
199 if (file
->phony
|| file
->cmds
== 0)
200 message ("Nothing to be done for `%s'.",
203 message ("`%s' is up to date.", file
->name
);
207 /* This goal is finished. Remove it from the chain. */
211 lastgoal
->next
= g
->next
;
213 /* Free the storage. */
216 g
= lastgoal
== 0 ? goals
: lastgoal
->next
;
240 /* If FILE is not up to date, execute the commands for it.
241 Return 0 if successful, 1 if unsuccessful;
242 but with some flag settings, just call `exit' if unsuccessful.
244 DEPTH is the depth in recursions of this function.
245 We increment it during the consideration of our dependencies,
246 then decrement it again after finding out whether this file
249 If there are multiple double-colon entries for FILE,
250 each is considered in turn. */
253 update_file (file
, depth
)
257 register int status
= 0;
258 register struct file
*f
;
260 for (f
= file
->double_colon
? file
->double_colon
: file
; f
!= 0; f
= f
->prev
)
262 status
|= update_file_1 (f
, depth
);
265 if (status
!= 0 && !keep_going_flag
)
268 switch (f
->command_state
)
271 /* The file is done being remade. */
275 case cs_deps_running
:
276 /* Don't run the other :: rules for this
277 file until this rule is finished. */
281 assert (f
->command_state
== cs_running
);
289 /* Consider a single `struct file' and update it as appropriate. */
292 update_file_1 (file
, depth
)
296 register time_t this_mtime
;
297 int noexist
, must_make
, deps_changed
;
299 register struct dep
*d
, *lastd
;
302 DEBUGPR ("Considering target file `%s'.\n");
306 if (file
->update_status
> 0)
308 DEBUGPR ("Recently tried and failed to update file `%s'.\n");
309 return file
->update_status
;
312 DEBUGPR ("File `%s' was considered already.\n");
316 switch (file
->command_state
)
319 case cs_deps_running
:
322 DEBUGPR ("Still updating file `%s'.\n");
325 DEBUGPR ("Finished updating file `%s'.\n");
326 return file
->update_status
;
333 /* Notice recursive update of the same file. */
336 /* Looking at the file's modtime beforehand allows the possibility
337 that its name may be changed by a VPATH search, and thus it may
338 not need an implicit rule. If this were not done, the file
339 might get implicit commands that apply to its initial name, only
340 to have that name replaced with another found by VPATH search. */
342 this_mtime
= file_mtime (file
);
343 check_renamed (file
);
344 noexist
= this_mtime
== (time_t) -1;
346 DEBUGPR ("File `%s' does not exist.\n");
350 /* If file was specified as a target with no commands,
351 come up with some default commands. */
353 if (!file
->phony
&& file
->cmds
== 0 && !file
->tried_implicit
)
355 if (try_implicit_rule (file
, depth
))
356 DEBUGPR ("Found an implicit rule for `%s'.\n");
358 DEBUGPR ("No implicit rule found for `%s'.\n");
359 file
->tried_implicit
= 1;
361 if (file
->cmds
== 0 && !file
->is_target
362 && default_file
!= 0 && default_file
->cmds
!= 0)
364 DEBUGPR ("Using default commands for `%s'.\n");
365 file
->cmds
= default_file
->cmds
;
368 /* Update all non-intermediate files we depend on, if necessary,
369 and see whether any of them is more recent than this file. */
377 check_renamed (d
->file
);
379 mtime
= file_mtime (d
->file
);
380 check_renamed (d
->file
);
382 if (d
->file
->updating
)
384 error ("Circular %s <- %s dependency dropped.",
385 file
->name
, d
->file
->name
);
388 file
->deps
= d
->next
;
394 lastd
->next
= d
->next
;
401 d
->file
->parent
= file
;
402 dep_status
|= check_dep (d
->file
, depth
, this_mtime
, &must_make
);
403 check_renamed (d
->file
);
406 register struct file
*f
= d
->file
;
411 running
|= (f
->command_state
== cs_running
412 || f
->command_state
== cs_deps_running
);
418 if (dep_status
!= 0 && !keep_going_flag
)
422 d
->changed
= file_mtime (d
->file
) != mtime
;
428 /* Now we know whether this target needs updating.
429 If it does, update all the intermediate files we depend on. */
433 for (d
= file
->deps
; d
!= 0; d
= d
->next
)
434 if (d
->file
->intermediate
)
436 time_t mtime
= file_mtime (d
->file
);
437 check_renamed (d
->file
);
438 d
->file
->parent
= file
;
439 dep_status
|= update_file (d
->file
, depth
);
440 check_renamed (d
->file
);
443 register struct file
*f
= d
->file
;
448 running
|= (f
->command_state
== cs_running
449 || f
->command_state
== cs_deps_running
);
455 if (dep_status
!= 0 && !keep_going_flag
)
459 d
->changed
= ((file
->phony
&& file
->cmds
!= 0)
460 || file_mtime (d
->file
) != mtime
);
466 DEBUGPR ("Finished dependencies of target file `%s'.\n");
470 set_command_state (file
, cs_deps_running
);
472 DEBUGPR ("The dependencies of `%s' are being made.\n");
476 /* If any dependency failed, give up now. */
480 file
->update_status
= dep_status
;
481 notice_finished_file (file
);
485 DEBUGPR ("Giving up on target file `%s'.\n");
487 if (depth
== 0 && keep_going_flag
488 && !just_print_flag
&& !question_flag
)
489 error ("Target `%s' not remade because of errors.", file
->name
);
494 if (file
->command_state
== cs_deps_running
)
495 /* The commands for some deps were running on the last iteration, but
496 they have finished now. Reset the command_state to not_started to
497 simplify later bookkeeping. It is important that we do this only
498 when the prior state was cs_deps_running, because that prior state
499 was definitely propagated to FILE's also_make's by set_command_state
500 (called above), but in another state an also_make may have
501 independently changed to finished state, and we would confuse that
502 file's bookkeeping (updated, but not_started is bogus state). */
503 set_command_state (file
, cs_not_started
);
505 /* Now record which dependencies are more
506 recent than this file, so we can define $?. */
509 for (d
= file
->deps
; d
!= 0; d
= d
->next
)
511 time_t d_mtime
= file_mtime (d
->file
);
512 check_renamed (d
->file
);
514 #if 1 /* %%% In version 4, remove this code completely to
515 implement not remaking deps if their deps are newer
516 than their parents. */
517 if (d_mtime
== (time_t) -1 && !d
->file
->intermediate
)
518 /* We must remake if this dep does not
519 exist and is not intermediate. */
523 /* Set DEPS_CHANGED if this dep actually changed. */
524 deps_changed
|= d
->changed
;
526 /* Set D->changed if either this dep actually changed,
527 or its dependent, FILE, is older or does not exist. */
528 d
->changed
|= noexist
|| d_mtime
> this_mtime
;
530 if (debug_flag
&& !noexist
)
532 print_spaces (depth
);
533 if (d_mtime
== (time_t) -1)
534 printf ("Dependency `%s' does not exist.\n", dep_name (d
));
536 printf ("Dependency `%s' is %s than dependent `%s'.\n",
537 dep_name (d
), d
->changed
? "newer" : "older", file
->name
);
542 /* Here depth returns to the value it had when we were called. */
545 if (file
->double_colon
&& file
->deps
== 0)
548 DEBUGPR ("Target `%s' is double-colon and has no dependencies.\n");
550 else if (!noexist
&& file
->is_target
&& !deps_changed
&& file
->cmds
== 0)
553 DEBUGPR ("No commands for `%s' and no dependencies actually changed.\n");
558 DEBUGPR ("No need to remake target `%s'.\n");
559 notice_finished_file (file
);
563 DEBUGPR ("Must remake target `%s'.\n");
565 /* Now, take appropriate actions to remake the file. */
568 if (file
->command_state
!= cs_finished
)
570 DEBUGPR ("Commands of `%s' are being run.\n");
574 switch (file
->update_status
)
577 DEBUGPR ("Failed to remake target file `%s'.\n");
580 DEBUGPR ("Successfully remade target file `%s'.\n");
583 DEBUGPR ("Target file `%s' needs remade under -q.\n");
586 assert (file
->update_status
>= 0 && file
->update_status
<= 2);
591 return file
->update_status
;
594 /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all
595 files listed in its `also_make' member. Under -t, this function also
598 On return, FILE->update_status will no longer be -1 if it was. */
601 notice_finished_file (file
)
602 register struct file
*file
;
605 int ran
= file
->command_state
== cs_running
;
607 file
->command_state
= cs_finished
;
611 /* The update status will be:
612 -1 if this target was not remade;
613 0 if 0 or more commands (+ or ${MAKE}) were run and won;
614 1 if some commands were run and lost.
615 We touch the target if it has commands which either were not run
616 or won when they ran (i.e. status is 0). */
617 && file
->update_status
== 0)
619 if (file
->cmds
!= 0 && file
->cmds
->any_recurse
)
621 /* If all the command lines were recursive,
622 we don't want to do the touching. */
624 for (i
= 0; i
< file
->cmds
->ncommand_lines
; ++i
)
625 if (!(file
->cmds
->lines_flags
[i
] & COMMANDS_RECURSE
))
626 goto have_nonrecursing
;
632 file
->update_status
= 0;
634 /* Should set file's modification date and do nothing else. */
635 file
->update_status
= touch_file (file
);
639 if (ran
&& !file
->phony
)
643 if (just_print_flag
|| question_flag
644 || (file
->is_target
&& file
->cmds
== 0))
645 file
->last_mtime
= NEW_MTIME
;
647 file
->last_mtime
= 0;
649 /* Propagate the change of modification time to all the double-colon
650 entries for this file. */
651 for (f
= file
->double_colon
; f
!= 0; f
= f
->next
)
652 f
->last_mtime
= file
->last_mtime
;
655 if (ran
&& file
->update_status
!= -1)
656 /* We actually tried to update FILE, which has
657 updated its also_make's as well (if it worked).
658 If it didn't work, it wouldn't work again for them.
659 So mark them as updated with the same status. */
660 for (d
= file
->also_make
; d
!= 0; d
= d
->next
)
662 d
->file
->command_state
= cs_finished
;
663 d
->file
->updated
= 1;
664 d
->file
->update_status
= file
->update_status
;
666 if (ran
&& !d
->file
->phony
)
667 /* Fetch the new modification time.
668 We do this instead of just invalidating the cached time
669 so that a vpath_search can happen. Otherwise, it would
670 never be done because the target is already updated. */
671 (void) f_mtime (d
->file
, 0);
673 else if (file
->update_status
== -1)
674 /* Nothing was done for FILE, but it needed nothing done.
675 So mark it now as "succeeded". */
676 file
->update_status
= 0;
679 /* Check whether another file (whose mtime is THIS_MTIME)
680 needs updating on account of a dependency which is file FILE.
681 If it does, store 1 in *MUST_MAKE_PTR.
682 In the process, update any non-intermediate files
683 that FILE depends on (including FILE itself).
684 Return nonzero if any updating failed. */
687 check_dep (file
, depth
, this_mtime
, must_make_ptr
)
693 register struct dep
*d
;
699 if (!file
->intermediate
)
700 /* If this is a non-intermediate file, update it and record
701 whether it is newer than THIS_MTIME. */
704 dep_status
= update_file (file
, depth
);
705 check_renamed (file
);
706 mtime
= file_mtime (file
);
707 check_renamed (file
);
708 if (mtime
== (time_t) -1 || mtime
> this_mtime
)
713 /* FILE is an intermediate file.
714 Update all non-intermediate files we depend on, if necessary,
715 and see whether any of them is more recent than the file
716 on whose behalf we are checking. */
717 register struct dep
*lastd
;
722 if (d
->file
->updating
)
724 error ("Circular %s <- %s dependency dropped.",
725 file
->name
, d
->file
->name
);
728 file
->deps
= d
->next
;
734 lastd
->next
= d
->next
;
741 d
->file
->parent
= file
;
742 dep_status
|= check_dep (d
->file
, depth
, this_mtime
, must_make_ptr
);
743 check_renamed (d
->file
);
744 if (dep_status
!= 0 && !keep_going_flag
)
747 if (d
->file
->command_state
== cs_running
748 || d
->file
->command_state
== cs_deps_running
)
749 /* Record that some of FILE's dependencies are still being made.
750 This tells the upper levels to wait on processing it until
751 the commands are finished. */
752 set_command_state (file
, cs_deps_running
);
763 /* Touch FILE. Return zero if successful, one if not. */
765 #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
769 register struct file
*file
;
773 printf ("touch %s\n", file
->name
);
778 if (ar_name (file
->name
))
779 return ar_touch (file
->name
);
783 int fd
= open (file
->name
, O_RDWR
| O_CREAT
, 0666);
786 TOUCH_ERROR ("touch: open: ");
796 status
= fstat (fd
, &statbuf
);
798 while (status
< 0 && errno
== EINTR
);
801 TOUCH_ERROR ("touch: fstat: ");
802 /* Rewrite character 0 same as it already is. */
803 if (read (fd
, &buf
, 1) < 0)
804 TOUCH_ERROR ("touch: read: ");
805 if (lseek (fd
, 0L, 0) < 0L)
806 TOUCH_ERROR ("touch: lseek: ");
807 if (write (fd
, &buf
, 1) < 0)
808 TOUCH_ERROR ("touch: write: ");
809 /* If file length was 0, we just
810 changed it, so change it back. */
811 if (statbuf
.st_size
== 0)
814 fd
= open (file
->name
, O_RDWR
| O_TRUNC
, 0666);
816 TOUCH_ERROR ("touch: open: ");
825 /* Having checked and updated the dependencies of FILE,
826 do whatever is appropriate to remake FILE itself.
827 Return the status from executing FILE's commands. */
836 /* Phony target. Pretend it succeeded. */
837 file
->update_status
= 0;
838 else if (file
->is_target
)
839 /* This is a nonexistent target file we cannot make.
840 Pretend it was successfully remade. */
841 file
->update_status
= 0;
844 /* This is a dependency file we cannot remake. Fail. */
845 static const char msg_noparent
[]
846 = "%sNo rule to make target `%s'%s";
847 static const char msg_parent
[]
848 = "%sNo rule to make target `%s', needed by `%s'%s";
849 if (keep_going_flag
|| file
->dontcare
)
853 if (file
->parent
== 0)
854 error (msg_noparent
, "*** ", file
->name
, ".");
856 error (msg_parent
, "*** ",
857 file
->name
, file
->parent
->name
, ".");
859 file
->update_status
= 2;
863 if (file
->parent
== 0)
864 fatal (msg_noparent
, "", file
->name
, "");
866 fatal (msg_parent
, "", file
->name
, file
->parent
->name
, "");
872 chop_commands (file
->cmds
);
874 if (!touch_flag
|| file
->cmds
->any_recurse
)
876 execute_file_commands (file
);
880 /* This tells notice_finished_file it is ok to touch the file. */
881 file
->update_status
= 0;
884 /* This does the touching under -t. */
885 notice_finished_file (file
);
888 /* Return the mtime of a file, given a `struct file'.
889 Caches the time in the struct file to avoid excess stat calls.
891 If the file is not found, and SEARCH is nonzero, VPATH searching and
892 replacement is done. If that fails, a library (-lLIBNAME) is tried and
893 the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into
897 f_mtime (file
, search
)
898 register struct file
*file
;
903 /* File's mtime is not known; must get it from the system. */
906 if (ar_name (file
->name
))
908 /* This file is an archive-member reference. */
910 char *arname
, *memname
;
914 /* Find the archive's name. */
915 ar_parse_name (file
->name
, &arname
, &memname
);
917 /* Find the modification time of the archive itself.
918 Also allow for its name to be changed via VPATH search. */
919 arfile
= lookup_file (arname
);
922 arfile
= enter_file (arname
);
925 mtime
= f_mtime (arfile
, search
);
926 check_renamed (arfile
);
927 if (search
&& strcmp (arfile
->name
, arname
))
929 /* The archive's name has changed.
930 Change the archive-member reference accordingly. */
932 unsigned int arlen
, memlen
;
940 arname
= arfile
->name
;
941 arlen
= strlen (arname
);
942 memlen
= strlen (memname
);
946 file
->name
= (char *) xmalloc (arlen
+ 1 + memlen
+ 2);
947 bcopy (arname
, file
->name
, arlen
);
948 file
->name
[arlen
] = '(';
949 bcopy (memname
, file
->name
+ arlen
+ 1, memlen
);
950 file
->name
[arlen
+ 1 + memlen
] = ')';
951 file
->name
[arlen
+ 1 + memlen
+ 1] = '\0';
958 if (mtime
== (time_t) -1)
959 /* The archive doesn't exist, so it's members don't exist either. */
962 mtime
= ar_member_date (file
->name
);
967 mtime
= name_mtime (file
->name
);
969 if (mtime
== (time_t) -1 && search
)
971 /* If name_mtime failed, search VPATH. */
972 char *name
= file
->name
;
973 if (vpath_search (&name
, &mtime
)
974 /* Last resort, is it a library (-lxxx)? */
975 || (name
[0] == '-' && name
[1] == 'l'
976 && library_search (&name
, &mtime
)))
979 /* vpath_search and library_search store zero in MTIME
980 if they didn't need to do a stat call for their work. */
981 file
->last_mtime
= mtime
;
982 rename_file (file
, name
);
983 check_renamed (file
);
984 return file_mtime (file
);
989 /* Store the mtime into all the entries for this file. */
990 if (file
->double_colon
)
991 file
= file
->double_colon
;
994 file
->last_mtime
= mtime
;
1002 /* Return the mtime of the file or archive-member reference NAME. */
1006 register char *name
;
1010 if (safe_stat (name
, &st
) < 0)
1013 return (time_t) st
.st_mtime
;
1017 /* Search for a library file specified as -lLIBNAME, searching for a
1018 suitable library file in the system library directories and the VPATH
1022 library_search (lib
, mtime_ptr
)
1026 static char *dirs
[] =
1030 LIBDIR
, /* Defined by configuration. */
1034 char *libname
= &(*lib
)[2]; /* Name without the `-l'. */
1037 /* Buffer to construct possible names in. */
1038 char *buf
= xmalloc (sizeof (LIBDIR
) + 8 + strlen (libname
) + 4 + 2 + 1);
1041 /* Look first for `libNAME.a' in the current directory. */
1043 sprintf (buf
, "lib%s.a", libname
);
1044 mtime
= name_mtime (buf
);
1045 if (mtime
!= (time_t) -1)
1053 /* Now try VPATH search on that. */
1056 if (vpath_search (&file
, mtime_ptr
))
1063 /* Now try the standard set of directories. */
1065 for (dp
= dirs
; *dp
!= 0; ++dp
)
1067 sprintf (buf
, "%s/lib%s.a", *dp
, libname
);
1068 mtime
= name_mtime (buf
);
1069 if (mtime
!= (time_t) -1)