Re: Automatic dependency tracking

[Tom Tromey <tromey at redhat dot com>]

>>>>> "Andrew" == Andrew STUBBS <andrew.stubbs@st.com> writes:

>> Daniel Jacobowitz wrote:
>> Option two: we could require GNU make.  GCC has done this for years,
>> but binutils does not; it may be premature.

>> Option three: we could manually list dependencies on generated files,
>> and support dependencies on source files only on systems with GNU
>> make.  This effectively means GNU make is a requirement if you are
>> hacking on GDB, but not to build GDB from a clean tree.

Andrew> As I understand it, dependencies on generated files must always be
Andrew> hard coded - otherwise the autogeneration build would fail
Andrew> (potentially, with parallel make being worse), so these two options
Andrew> are the same.

Yeah, this is basically true -- you always have to explicitly mention
the generated headers somewhere.

However, with order-only dependencies, you don't actually need to
maintain these by hand, in the sense of figuring out which objects
depend on which generated headers.  Instead you just require that the
generated files all be built before anything else.

Andrew> There is no need to require GNU make for build purposes. It would only
Andrew> be required for dependency tracking. The configure script can be made
Andrew> to disable dependency tracking on incompatible make variants.

You can do this dynamically by creating a GNUMakefile in the build
tree :-).  Well, if you don't mind the hackiness of that.

Andrew> BTW, which are the GNU make specific features in question?

'-include', and probably order-only dependencies.
'ifeq' makes it a bit friendlier too, and sometimes new-style pattern
rules (depending on details in the Makefile that I don't remember
right now).

I've appended the relevant code from libcpp's Makefile.  libcpp does
not use automake but does implement the dependency tracking bits.
Hmm, reading it now, I see it looks like goo :)

libcpp also has this:

    # Dependencies on generated headers have to be explicit.
    init.o: localedir.h

But with order-only dependencies I would just write:

    $(all_objects): | $(generated_headers)

This does the right thing.

Tom


# Dependency rule.
COMPILE.base = $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(ALL_CFLAGS) -c
ifeq ($(DEPMODE),depmode=gcc3)
# Note that we put the dependencies into a .Tpo file, then move them
# into place if the compile succeeds.  We need this because gcc does
# not atomically write the dependency output file.
COMPILE = $(COMPILE.base) -o $@ -MT $@ -MMD -MP -MF $(DEPDIR)/$*.Tpo
POSTCOMPILE = @mv $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
else
COMPILE = source='$<' object='$@' libtool=no DEPDIR=$(DEPDIR) $(DEPMODE) \
	  $(depcomp) $(COMPILE.base)
# depcomp handles atomicity for us, so we don't need a postcompile
# step.
POSTCOMPILE =
endif

# Implicit rules and I18N

.c.o:
	$(COMPILE) $<
	$(POSTCOMPILE)

# Dependencies
-include $(patsubst %.o, $(DEPDIR)/%.Po, $(libcpp_a_OBJS) $(makedepend_OBJS))