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 assert (file
->update_status
== 0 || file
->update_status
== 1);
588 return file
->update_status
;
591 /* Set FILE's `updated' flag and re-check its mtime and the mtime's of all
592 files listed in its `also_make' member. Under -t, this function also
596 notice_finished_file (file
)
597 register struct file
*file
;
600 int ran
= file
->command_state
== cs_running
;
602 file
->command_state
= cs_finished
;
606 /* The update status will be:
607 -1 if this target was not remade;
608 0 if 0 or more commands (+ or ${MAKE}) were run and won;
609 1 if some commands were run and lost.
610 We touch the target if it has commands which either were not run
611 or won when they ran (i.e. status is 0). */
612 && file
->update_status
== 0)
614 if (file
->cmds
!= 0 && file
->cmds
->any_recurse
)
616 /* If all the command lines were recursive,
617 we don't want to do the touching. */
619 for (i
= 0; i
< file
->cmds
->ncommand_lines
; ++i
)
620 if (!(file
->cmds
->lines_flags
[i
] & COMMANDS_RECURSE
))
621 goto have_nonrecursing
;
627 file
->update_status
= 0;
629 /* Should set file's modification date and do nothing else. */
630 file
->update_status
= touch_file (file
);
634 if (ran
&& !file
->phony
)
638 if (just_print_flag
|| question_flag
639 || (file
->is_target
&& file
->cmds
== 0))
640 file
->last_mtime
= NEW_MTIME
;
642 file
->last_mtime
= 0;
644 /* Propagate the change of modification time to all the double-colon
645 entries for this file. */
646 for (f
= file
->double_colon
; f
!= 0; f
= f
->next
)
647 f
->last_mtime
= file
->last_mtime
;
650 if (ran
&& file
->update_status
!= -1)
651 /* We actually tried to update FILE, which has
652 updated its also_make's as well (if it worked).
653 If it didn't work, it wouldn't work again for them.
654 So mark them as updated with the same status. */
655 for (d
= file
->also_make
; d
!= 0; d
= d
->next
)
657 d
->file
->command_state
= cs_finished
;
658 d
->file
->updated
= 1;
659 d
->file
->update_status
= file
->update_status
;
661 if (ran
&& !d
->file
->phony
)
662 /* Fetch the new modification time.
663 We do this instead of just invalidating the cached time
664 so that a vpath_search can happen. Otherwise, it would
665 never be done because the target is already updated. */
666 (void) f_mtime (d
->file
, 0);
670 /* Check whether another file (whose mtime is THIS_MTIME)
671 needs updating on account of a dependency which is file FILE.
672 If it does, store 1 in *MUST_MAKE_PTR.
673 In the process, update any non-intermediate files
674 that FILE depends on (including FILE itself).
675 Return nonzero if any updating failed. */
678 check_dep (file
, depth
, this_mtime
, must_make_ptr
)
684 register struct dep
*d
;
690 if (!file
->intermediate
)
691 /* If this is a non-intermediate file, update it and record
692 whether it is newer than THIS_MTIME. */
695 dep_status
= update_file (file
, depth
);
696 check_renamed (file
);
697 mtime
= file_mtime (file
);
698 check_renamed (file
);
699 if (mtime
== (time_t) -1 || mtime
> this_mtime
)
704 /* FILE is an intermediate file.
705 Update all non-intermediate files we depend on, if necessary,
706 and see whether any of them is more recent than the file
707 on whose behalf we are checking. */
708 register struct dep
*lastd
;
713 if (d
->file
->updating
)
715 error ("Circular %s <- %s dependency dropped.",
716 file
->name
, d
->file
->name
);
719 file
->deps
= d
->next
;
725 lastd
->next
= d
->next
;
732 d
->file
->parent
= file
;
733 dep_status
|= check_dep (d
->file
, depth
, this_mtime
, must_make_ptr
);
734 check_renamed (d
->file
);
735 if (dep_status
!= 0 && !keep_going_flag
)
738 if (d
->file
->command_state
== cs_running
739 || d
->file
->command_state
== cs_deps_running
)
740 /* Record that some of FILE's dependencies are still being made.
741 This tells the upper levels to wait on processing it until
742 the commands are finished. */
743 set_command_state (file
, cs_deps_running
);
754 /* Touch FILE. Return zero if successful, one if not. */
756 #define TOUCH_ERROR(call) return (perror_with_name (call, file->name), 1)
760 register struct file
*file
;
764 printf ("touch %s\n", file
->name
);
769 if (ar_name (file
->name
))
770 return ar_touch (file
->name
);
774 int fd
= open (file
->name
, O_RDWR
| O_CREAT
, 0666);
777 TOUCH_ERROR ("touch: open: ");
787 status
= fstat (fd
, &statbuf
);
789 while (status
< 0 && errno
== EINTR
);
792 TOUCH_ERROR ("touch: fstat: ");
793 /* Rewrite character 0 same as it already is. */
794 if (read (fd
, &buf
, 1) < 0)
795 TOUCH_ERROR ("touch: read: ");
796 if (lseek (fd
, 0L, 0) < 0L)
797 TOUCH_ERROR ("touch: lseek: ");
798 if (write (fd
, &buf
, 1) < 0)
799 TOUCH_ERROR ("touch: write: ");
800 /* If file length was 0, we just
801 changed it, so change it back. */
802 if (statbuf
.st_size
== 0)
805 fd
= open (file
->name
, O_RDWR
| O_TRUNC
, 0666);
807 TOUCH_ERROR ("touch: open: ");
816 /* Having checked and updated the dependencies of FILE,
817 do whatever is appropriate to remake FILE itself.
818 Return the status from executing FILE's commands. */
827 /* Phony target. Pretend it succeeded. */
828 file
->update_status
= 0;
829 else if (file
->is_target
)
830 /* This is a nonexistent target file we cannot make.
831 Pretend it was successfully remade. */
832 file
->update_status
= 0;
835 /* This is a dependency file we cannot remake. Fail. */
836 static char noway
[] = "No rule to make target";
837 if (keep_going_flag
|| file
->dontcare
)
840 error ("*** %s `%s'.", noway
, file
->name
);
841 file
->update_status
= 1;
844 fatal ("%s `%s'", noway
, file
->name
);
849 chop_commands (file
->cmds
);
851 if (!touch_flag
|| file
->cmds
->any_recurse
)
853 execute_file_commands (file
);
857 /* This tells notice_finished_file it is ok to touch the file. */
858 file
->update_status
= 0;
861 /* This does the touching under -t. */
862 notice_finished_file (file
);
865 /* Return the mtime of a file, given a `struct file'.
866 Caches the time in the struct file to avoid excess stat calls.
868 If the file is not found, and SEARCH is nonzero, VPATH searching and
869 replacement is done. If that fails, a library (-lLIBNAME) is tried and
870 the library's actual name (/lib/libLIBNAME.a, etc.) is substituted into
874 f_mtime (file
, search
)
875 register struct file
*file
;
880 /* File's mtime is not known; must get it from the system. */
883 if (ar_name (file
->name
))
885 /* This file is an archive-member reference. */
887 char *arname
, *memname
;
891 /* Find the archive's name. */
892 ar_parse_name (file
->name
, &arname
, &memname
);
894 /* Find the modification time of the archive itself.
895 Also allow for its name to be changed via VPATH search. */
896 arfile
= lookup_file (arname
);
899 arfile
= enter_file (arname
);
902 mtime
= f_mtime (arfile
, search
);
903 check_renamed (arfile
);
904 if (search
&& strcmp (arfile
->name
, arname
))
906 /* The archive's name has changed.
907 Change the archive-member reference accordingly. */
909 unsigned int arlen
, memlen
;
917 arname
= arfile
->name
;
918 arlen
= strlen (arname
);
919 memlen
= strlen (memname
);
923 file
->name
= (char *) xmalloc (arlen
+ 1 + memlen
+ 2);
924 bcopy (arname
, file
->name
, arlen
);
925 file
->name
[arlen
] = '(';
926 bcopy (memname
, file
->name
+ arlen
+ 1, memlen
);
927 file
->name
[arlen
+ 1 + memlen
] = ')';
928 file
->name
[arlen
+ 1 + memlen
+ 1] = '\0';
935 if (mtime
== (time_t) -1)
936 /* The archive doesn't exist, so it's members don't exist either. */
939 mtime
= ar_member_date (file
->name
);
944 mtime
= name_mtime (file
->name
);
946 if (mtime
== (time_t) -1 && search
)
948 /* If name_mtime failed, search VPATH. */
949 char *name
= file
->name
;
950 if (vpath_search (&name
, &mtime
)
951 /* Last resort, is it a library (-lxxx)? */
952 || (name
[0] == '-' && name
[1] == 'l'
953 && library_search (&name
, &mtime
)))
956 /* vpath_search and library_search store zero in MTIME
957 if they didn't need to do a stat call for their work. */
958 file
->last_mtime
= mtime
;
959 rename_file (file
, name
);
960 check_renamed (file
);
961 return file_mtime (file
);
966 /* Store the mtime into all the entries for this file. */
967 if (file
->double_colon
)
968 file
= file
->double_colon
;
971 file
->last_mtime
= mtime
;
979 /* Return the mtime of the file or archive-member reference NAME. */
987 if (safe_stat (name
, &st
) < 0)
990 return (time_t) st
.st_mtime
;
994 /* Search for a library file specified as -lLIBNAME, searching for a
995 suitable library file in the system library directories and the VPATH
999 library_search (lib
, mtime_ptr
)
1003 static char *dirs
[] =
1007 LIBDIR
, /* Defined by configuration. */
1011 char *libname
= &(*lib
)[2]; /* Name without the `-l'. */
1014 /* Buffer to construct possible names in. */
1015 char *buf
= xmalloc (sizeof (LIBDIR
) + 8 + strlen (libname
) + 4 + 2 + 1);
1018 /* Look first for `libNAME.a' in the current directory. */
1020 sprintf (buf
, "lib%s.a", libname
);
1021 mtime
= name_mtime (buf
);
1022 if (mtime
!= (time_t) -1)
1030 /* Now try VPATH search on that. */
1033 if (vpath_search (&file
, mtime_ptr
))
1040 /* Now try the standard set of directories. */
1042 for (dp
= dirs
; *dp
!= 0; ++dp
)
1044 sprintf (buf
, "%s/lib%s.a", *dp
, libname
);
1045 mtime
= name_mtime (buf
);
1046 if (mtime
!= (time_t) -1)