Deleted Added
sdiff udiff text old ( 246223 ) new ( 249033 )
full compact
1# $Id: dirdeps.mk,v 1.28 2013/03/25 21:11:43 sjg Exp $
2
3# Copyright (c) 2010-2013, Juniper Networks, Inc.
4# All rights reserved.
5#
6# Redistribution and use in source and binary forms, with or without
7# modification, are permitted provided that the following conditions
8# are met:
9# 1. Redistributions of source code must retain the above copyright
10# notice, this list of conditions and the following disclaimer.
11# 2. Redistributions in binary form must reproduce the above copyright
12# notice, this list of conditions and the following disclaimer in the

--- 16 unchanged lines hidden (view full) ---

29# should provide sufficient clue.
30# Otherwise the recommendation is to use Makefile.depend.${MACHINE}
31# as expected below.
32
33# Note: this file gets multiply included.
34# This is what we do with DIRDEPS
35
36# DIRDEPS:
37# This is a list of directories - relative to SRCTOP, it is
38# normally only of interest to .MAKE.LEVEL 0.
39# In some cases the entry may be qualified with a .<machine>
40# or .<target_spec> suffix (see TARGET_SPEC_VARS below),
41# for example to force building something for the pseudo
42# machines "host" or "common" regardless of current ${MACHINE}.
43#
44# All unqualified entries end up being qualified with .${TARGET_SPEC}
45# and partially qualified (if TARGET_SPEC_VARS has multiple
46# entries) are also expanded to a full .<target_spec>.
47# The _DIRDEPS_USE target uses the suffix to set TARGET_SPEC
48# correctly when visiting each entry.
49#
50# The fully qualified directory entries are used to construct a
51# dependency graph that will drive the build later.
52#
53# Also, for each fully qualified directory target, we will search
54# using ${.MAKE.DEPENDFILE_PREFERENCE} to find additional
55# dependencies. We use Makefile.depend (default value for
56# .MAKE.DEPENDFILE_PREFIX) to refer to these makefiles to
57# distinguish them from others.
58#
59# Each Makefile.depend file sets DEP_RELDIR to be the
60# the RELDIR (path relative to SRCTOP) for its directory, and
61# since each Makefile.depend file includes dirdeps.mk, this
62# processing is recursive and results in .MAKE.LEVEL 0 learning the
63# dependencies of the tree wrt the initial directory (_DEP_RELDIR).
64#
65# BUILD_AT_LEVEL0
66# Indicates whether .MAKE.LEVEL 0 builds anything:
67# if "no" sub-makes are used to build everything,
68# if "yes" sub-makes are only used to build for other machines.
69# It is best to use "no", but this can require fixing some
70# makefiles to not do anything at .MAKE.LEVEL 0.
71#
72# TARGET_SPEC_VARS
73# The default value is just MACHINE, and for most environments
74# this is sufficient. The _DIRDEPS_USE target actually sets
75# both MACHINE and TARGET_SPEC to the suffix of the current
76# target so that in the general case TARGET_SPEC can be ignored.
77#
78# If more than MACHINE is needed then sys.mk needs to decompose
79# TARGET_SPEC and set the relevant variables accordingly.
80# It is important that MACHINE be included in and actually be
81# the first member of TARGET_SPEC_VARS. This allows other
82# variables to be considered optional, and some of the treatment
83# below relies on MACHINE being the first entry.
84# Note: TARGET_SPEC cannot contain any '.'s so the target
85# triple used by compiler folk won't work (directly anyway).
86#
87# For example:
88#
89# # Always list MACHINE first,
90# # other variables might be optional.
91# TARGET_SPEC_VARS = MACHINE TARGET_OS
92# .if ${TARGET_SPEC:Uno:M*,*} != ""
93# _tspec := ${TARGET_SPEC:S/,/ /g}
94# MACHINE := ${_tspec:[1]}
95# TARGET_OS := ${_tspec:[2]}
96# # etc.
97# # We need to stop that TARGET_SPEC affecting any submakes
98# # and deal with MACHINE=${TARGET_SPEC} in the environment.
99# TARGET_SPEC =
100# # export but do not track
101# .export-env TARGET_SPEC
102# .export ${TARGET_SPEC_VARS}
103# .for v in ${TARGET_SPEC_VARS:O:u}
104# .if empty($v)
105# .undef $v
106# .endif
107# .endfor
108# .endif
109# # make sure we know what TARGET_SPEC is
110# # as we may need it to find Makefile.depend*
111# TARGET_SPEC = ${TARGET_SPEC_VARS:@v@${$v:U}@:ts,}
112#
113
114.if ${.MAKE.LEVEL} == 0
115# only the first instance is interested in all this
116
117# First off, we want to know what ${MACHINE} to build for.
118# This can be complicated if we are using a mixture of ${MACHINE} specific
119# and non-specific Makefile.depend*
120
121.if !target(_DIRDEP_USE)
122# do some setup we only need once
123_CURDIR ?= ${.CURDIR}
124
125# make sure these are empty to start with
126_DEP_TARGET_SPEC =
127_DIRDEP_CHECKED =
128
129# If TARGET_SPEC_VARS is other than just MACHINE
130# it should be set by sys.mk or similar by now.
131# TARGET_SPEC must not contain any '.'s.
132TARGET_SPEC_VARS ?= MACHINE
133# this is what we started with
134TARGET_SPEC = ${TARGET_SPEC_VARS:@v@${$v:U}@:ts,}
135# this is what we mostly use below
136DEP_TARGET_SPEC = ${TARGET_SPEC_VARS:S,^,DEP_,:@v@${$v:U}@:ts,}
137# make sure we have defaults
138.for v in ${TARGET_SPEC_VARS}
139DEP_$v ?= ${$v}
140.endfor
141
142.if ${TARGET_SPEC_VARS:[#]} > 1
143# Ok, this gets more complex (putting it mildly).
144# In order to stay sane, we need to ensure that all the build_dirs
145# we compute below are fully qualified wrt DEP_TARGET_SPEC.
146# The makefiles may only partially specify (eg. MACHINE only),
147# so we need to construct a set of modifiers to fill in the gaps.
148# jot 10 should output 1 2 3 .. 10
149JOT ?= jot
150_tspec_x := ${${JOT} ${TARGET_SPEC_VARS:[#]}:L:sh}
151# this handles unqualified entries
152M_dep_qual_fixes = C;(/[^/.,]+)$$;\1.${DEP_TARGET_SPEC};
153# there needs to be at least one item missing for these to make sense
154.for i in ${_tspec_x:[2..-1]}
155_tspec_m$i := ${TARGET_SPEC_VARS:[2..$i]:@w@[^,]+@:ts,}
156_tspec_a$i := ,${TARGET_SPEC_VARS:[$i..-1]:@v@$${DEP_$v}@:ts,}
157M_dep_qual_fixes += C;(\.${_tspec_m$i})$$;\1${_tspec_a$i};
158.endfor
159.else
160# A harmless? default.
161M_dep_qual_fixes = U
162.endif
163
164.if !defined(.MAKE.DEPENDFILE_PREFERENCE)
165# .MAKE.DEPENDFILE_PREFERENCE makes the logic below neater?
166# you really want this set by sys.mk or similar
167.MAKE.DEPENDFILE_PREFERENCE = ${_CURDIR}/${.MAKE.DEPENDFILE:T}
168.if ${.MAKE.DEPENDFILE:E} == "${TARGET_SPEC}"
169.if ${TARGET_SPEC} != ${MACHINE}
170.MAKE.DEPENDFILE_PREFERENCE += ${_CURDIR}/${.MAKE.DEPENDFILE:T:R}.$${MACHINE}
171.endif
172.MAKE.DEPENDFILE_PREFERENCE += ${_CURDIR}/${.MAKE.DEPENDFILE:T:R}
173.endif
174.endif
175
176_default_dependfile := ${.MAKE.DEPENDFILE_PREFERENCE:[1]:T}
177_machine_dependfiles := ${.MAKE.DEPENDFILE_PREFERENCE:T:M*${MACHINE}*}
178
179# for machine specific dependfiles we require ${MACHINE} to be at the end
180# also for the sake of sanity we require a common prefix
181.if !defined(.MAKE.DEPENDFILE_PREFIX)
182# knowing .MAKE.DEPENDFILE_PREFIX helps
183.if !empty(_machine_dependfiles)
184.MAKE.DEPENDFILE_PREFIX := ${_machine_dependfiles:[1]:T:R}
185.else
186.MAKE.DEPENDFILE_PREFIX := ${_default_dependfile:T}
187.endif
188.endif
189
190
191# this is how we identify non-machine specific dependfiles
192N_notmachine := ${.MAKE.DEPENDFILE_PREFERENCE:E:N*${MACHINE}*:${M_ListToSkip}}
193
194.endif # !target(_DIRDEP_USE)
195
196# if we were included recursively _DEP_TARGET_SPEC should be valid.
197.if empty(_DEP_TARGET_SPEC)
198# we may or may not have included a dependfile yet
199_last_dependfile := ${.MAKE.MAKEFILES:M*/${.MAKE.DEPENDFILE_PREFIX}*:[-1]}
200.if !empty(_debug_reldir)
201.info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: _last_dependfile='${_last_dependfile}'
202.endif
203
204.if empty(_last_dependfile) || ${_last_dependfile:E:${N_notmachine}} == ""
205# this is all we have to work with
206DEP_MACHINE = ${TARGET_MACHINE:U${MACHINE}}
207_DEP_TARGET_SPEC := ${DEP_TARGET_SPEC}
208.else
209_DEP_TARGET_SPEC = ${_last_dependfile:${M_dep_qual_fixes:ts:}:E}
210.endif
211.if !empty(_last_dependfile)
212# record that we've read dependfile for this
213_DIRDEP_CHECKED += ${_CURDIR}.${TARGET_SPEC}
214.endif
215.endif
216
217# by now _DEP_TARGET_SPEC should be set, parse it.
218.if ${TARGET_SPEC_VARS:[#]} > 1
219# we need to parse DEP_MACHINE may or may not contain more info
220_tspec := ${_DEP_TARGET_SPEC:S/,/ /g}
221.for i in ${_tspec_x}
222DEP_${TARGET_SPEC_VARS:[$i]} := ${_tspec:[$i]}
223.endfor
224.for v in ${TARGET_SPEC_VARS:O:u}
225.if empty(DEP_$v)
226.undef DEP_$v
227.endif
228.endfor
229.else
230DEP_MACHINE := ${_DEP_TARGET_SPEC}
231.endif
232
233# pickup customizations
234# as below you can use !target(_DIRDEP_USE) to protect things
235# which should only be done once.
236.-include "local.dirdeps.mk"
237
238# the first time we are included the _DIRDEP_USE target will not be defined
239# we can use this as a clue to do initialization and other one time things.
240.if !target(_DIRDEP_USE)

--- 10 unchanged lines hidden (view full) ---

251
252# remember the initial value of DEP_RELDIR - we test for it below.
253_DEP_RELDIR := ${DEP_RELDIR}
254
255# things we skip for host tools
256SKIP_HOSTDIR ?=
257
258NSkipHostDir = ${SKIP_HOSTDIR:N*.host:S,$,.host,:N.host:${M_ListToSkip}}
259
260# things we always skip
261# SKIP_DIRDEPS allows for adding entries on command line.
262SKIP_DIR += .host *.WAIT ${SKIP_DIRDEPS}
263SKIP_DIR.host += ${SKIP_HOSTDIR}
264
265DEP_SKIP_DIR = ${SKIP_DIR} \
266 ${SKIP_DIR.${DEP_TARGET_SPEC}:U} \
267 ${SKIP_DIR.${DEP_MACHINE}:U} \
268 ${SKIP_DIRDEPS.${DEP_MACHINE}:U}
269
270NSkipDir = ${DEP_SKIP_DIR:${M_ListToSkip}}
271
272.if defined(NO_DIRDEPS) || defined(NODIRDEPS)
273# confine ourselves to the original dir
274DIRDEPS_FILTER += M${_DEP_RELDIR}*
275.endif
276
277# we supress SUBDIR when visiting the leaves
278# we assume sys.mk will set MACHINE_ARCH
279# you can add extras to DIRDEP_USE_ENV
280# if there is no makefile in the target directory, we skip it.
281_DIRDEP_USE: .USE .MAKE
282 @for m in ${.MAKE.MAKEFILE_PREFERENCE}; do \
283 test -s ${.TARGET:R}/$$m || continue; \
284 echo "${TRACER}Checking ${.TARGET:R} for ${.TARGET:E} ..."; \
285 MACHINE_ARCH= NO_SUBDIR=1 ${DIRDEP_USE_ENV} \
286 TARGET_SPEC=${.TARGET:E} \
287 MACHINE=${.TARGET:E} \
288 ${.MAKE} -C ${.TARGET:R} || exit 1; \
289 break; \
290 done
291
292.ifdef ALL_MACHINES
293# this is how you limit it to only the machines we have been built for
294# previously.
295.if empty(ONLY_MACHINE_LIST)

--- 40 unchanged lines hidden (view full) ---

336.else
337_this_dir := ${SRCTOP}/${DEP_RELDIR}
338.endif
339
340# on rare occasions, there can be a need for extra help
341_dep_hack := ${_this_dir}/${.MAKE.DEPENDFILE_PREFIX}.inc
342.-include "${_dep_hack}"
343
344.if ${DEP_RELDIR} != ${_DEP_RELDIR} || ${DEP_TARGET_SPEC} != ${TARGET_SPEC}
345# this should be all
346_machines := ${DEP_MACHINE}
347.else
348# this is the machine list we actually use below
349_machines := ${_only_machines}
350
351.if defined(HOSTPROG) || ${DEP_MACHINE} == "host"
352# we need to build this guy's dependencies for host as well.
353_machines += host
354.endif
355
356_machines := ${_machines:O:u}
357.endif
358
359.if ${TARGET_SPEC_VARS:[#]} > 1
360# we need to tweak _machines
361_dm := ${DEP_MACHINE}
362_machines := ${_machines:@DEP_MACHINE@${DEP_TARGET_SPEC}@}
363DEP_MACHINE := ${_dm}
364.endif
365
366# reset each time through
367_build_dirs =
368
369.if ${DEP_RELDIR} == ${_DEP_RELDIR}
370# pickup other machines for this dir if necessary
371.if ${BUILD_AT_LEVEL0:Uyes} == "no"
372_build_dirs += ${_machines:@m@${_CURDIR}.$m@}
373.else
374_build_dirs += ${_machines:N${DEP_TARGET_SPEC}:@m@${_CURDIR}.$m@}
375.if ${DEP_TARGET_SPEC} == ${TARGET_SPEC}
376# pickup local dependencies now
377.-include <.depend>
378.endif
379.endif
380.endif
381
382.if !empty(_debug_reldir)
383.info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: DIRDEPS='${DIRDEPS}'
384.info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: _machines='${_machines}'
385.endif
386
387.if !empty(DIRDEPS)
388# these we reset each time through as they can depend on DEP_MACHINE
389DEP_DIRDEPS_FILTER = \
390 ${DIRDEPS_FILTER.${DEP_TARGET_SPEC}:U} \
391 ${DIRDEPS_FILTER.${DEP_MACHINE}:U} \
392 ${DIRDEPS_FILTER:U}
393.if empty(DEP_DIRDEPS_FILTER)
394# something harmless
395DEP_DIRDEPS_FILTER = U
396.endif
397
398# this is what we start with
399__depdirs := ${DIRDEPS:${NSkipDir}:${DEP_DIRDEPS_FILTER:ts:}:O:u:@d@${SRCTOP}/$d@}
400
401# some entries may be qualified with .<machine>
402# the :M*/*/*.* just tries to limit the dirs we check to likely ones.
403# the ${d:E:M*/*} ensures we don't consider junos/usr.sbin/mgd
404__qual_depdirs := ${__depdirs:M*/*/*.*:@d@${exists($d):?:${"${d:E:M*/*}":?:${exists(${d:R}):?$d:}}}@}
405__unqual_depdirs := ${__depdirs:${__qual_depdirs:Uno:${M_ListToSkip}}}
406
407.if ${DEP_RELDIR} == ${_DEP_RELDIR}

--- 9 unchanged lines hidden (view full) ---

417.endif
418
419# _build_dirs is what we will feed to _DIRDEP_USE
420_build_dirs += \
421 ${__qual_depdirs:M*.host:${NSkipHostDir}:N.host} \
422 ${__qual_depdirs:N*.host} \
423 ${_machines:@m@${__unqual_depdirs:@d@$d.$m@}@}
424
425# qualify everything now
426_build_dirs := ${_build_dirs:${M_dep_qual_fixes:ts:}:O:u}
427
428.endif # empty DIRDEPS
429
430# Normally if doing make -V something,
431# we do not want to waste time chasing DIRDEPS
432# but if we want to count the number of Makefile.depend* read, we do.
433.if ${.MAKEFLAGS:M-V${_V_READ_DIRDEPS}} == ""
434.if !empty(_build_dirs)
435# this makes it all happen
436dirdeps: ${_build_dirs}
437${_build_dirs}: _DIRDEP_USE
438
439.if !empty(_debug_reldir)
440.info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: needs: ${_build_dirs}
441.endif
442
443# this builds the dependency graph
444.for m in ${_machines}
445# it would be nice to do :N${.TARGET}
446.if !empty(__qual_depdirs)
447.for q in ${__qual_depdirs:${M_dep_qual_fixes:ts:}:E:O:u:N$m}
448.if !empty(_debug_reldir) || ${DEBUG_DIRDEPS:@x@${${DEP_RELDIR}.$m:L:M$x}${${DEP_RELDIR}.$q:L:M$x}@} != ""
449.info ${DEP_RELDIR}.$m: graph: ${_build_dirs:M*.$q}
450.endif
451${_this_dir}.$m: ${_build_dirs:M*.$q}
452.endfor
453.endif
454.if !empty(_debug_reldir)
455.info ${DEP_RELDIR}.$m: graph: ${_build_dirs:M*.$m:N${_this_dir}.$m}
456.endif
457${_this_dir}.$m: ${_build_dirs:M*.$m:N${_this_dir}.$m}
458.endfor
459
460.endif
461
462# Now find more dependencies - and recurse.
463.for d in ${_build_dirs}
464.if ${_DIRDEP_CHECKED:M$d} == ""
465# once only
466_DIRDEP_CHECKED += $d
467# Note: _build_dirs is fully qualifed so d:R is always the directory
468.if exists(${d:R})
469# Warning: there is an assumption here that MACHINE is always
470# the first entry in TARGET_SPEC_VARS.
471# If TARGET_SPEC and MACHINE are insufficient, you have a problem.
472_m := ${.MAKE.DEPENDFILE_PREFERENCE:T:S;${TARGET_SPEC}$;${d:E};:S;${MACHINE};${d:E:C/,.*//};:@m@${exists(${d:R}/$m):?${d:R}/$m:}@:[1]}
473.if !empty(_m)
474_qm := ${_m:${M_dep_qual_fixes:ts:}}
475.if !empty(_debug_search)
476.info Looking for ${_qm}
477.endif
478# we pass _DEP_TARGET_SPEC to tell the next step what we want
479_DEP_TARGET_SPEC := ${d:E}
480# some makefiles may still look at this
481_DEP_MACHINE := ${d:E:C/,.*//}
482.if !empty(_debug_reldir) && ${_qm} != ${_m}
483.info loading ${_m} for ${d:E}
484.endif
485.include <${_m}>
486.endif
487.endif
488.endif
489.endfor
490
491.endif # -V
492
493.elif ${.MAKE.LEVEL} > 42
494.error You should have stopped recursing by now.
495.else
496_DEP_RELDIR := ${DEP_RELDIR}
497# pickup local dependencies
498.-include <.depend>
499.endif
500