share/mk/dirdeps.mk

   1 # $Id: dirdeps.mk,v 1.162 2023/05/15 17:37:46 sjg Exp $
   2
   3 # SPDX-License-Identifier: BSD-2-Clause
   4 #
   5 # Copyright (c) 2010-2023, Simon J. Gerraty
   6 # Copyright (c) 2010-2018, Juniper Networks, Inc.
   7 # All rights reserved.
   8 #
   9 # Redistribution and use in source and binary forms, with or without
  10 # modification, are permitted provided that the following conditions
  11 # are met:
  12 # 1. Redistributions of source code must retain the above copyright
  13 #    notice, this list of conditions and the following disclaimer.
  14 # 2. Redistributions in binary form must reproduce the above copyright
  15 #    notice, this list of conditions and the following disclaimer in the
  16 #    documentation and/or other materials provided with the distribution.
  17 #
  18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29
  30 # Much of the complexity here is for supporting cross-building.
  31 # If a tree does not support that, simply using plain Makefile.depend
  32 # should provide sufficient clue.
  33 # Otherwise the recommendation is to use Makefile.depend.${MACHINE}
  34 # as expected below.
  35
  36 # Note: this file gets multiply included.
  37 # This is what we do with DIRDEPS
  38
  39 # DIRDEPS:
  40 #       This is a list of directories - relative to SRCTOP, it is
  41 #       normally only of interest to .MAKE.LEVEL 0.
  42 #       In some cases the entry may be qualified with a .<machine>
  43 #       or .<target_spec> suffix (see TARGET_SPEC_VARS below),
  44 #       for example to force building something for the pseudo
  45 #       machines "host" or "common" regardless of current ${MACHINE}.
  46 #
  47 #       All unqualified entries end up being qualified with .${TARGET_SPEC}
  48 #       and partially qualified (if TARGET_SPEC_VARS has multiple
  49 #       entries) are also expanded to a full .<target_spec>.
  50 #       The  _DIRDEP_USE target uses the suffix to set TARGET_SPEC
  51 #       correctly when visiting each entry.
  52 #
  53 #       The fully qualified directory entries are used to construct a
  54 #       dependency graph that will drive the build later.
  55 #
  56 #       Also, for each fully qualified directory target, we will search
  57 #       using ${.MAKE.DEPENDFILE_PREFERENCE} to find additional
  58 #       dependencies.  We use Makefile.depend (default value for
  59 #       .MAKE.DEPENDFILE_PREFIX) to refer to these makefiles to
  60 #       distinguish them from others.
  61 #
  62 #       Before each Makefile.depend file is read, we set
  63 #       DEP_RELDIR to be the RELDIR (path relative to SRCTOP) for
  64 #       its directory, and DEP_MACHINE etc according to the .<target_spec>
  65 #       represented by the suffix of the corresponding target.
  66 #
  67 #       Since each Makefile.depend file includes dirdeps.mk, this
  68 #       processing is recursive and results in .MAKE.LEVEL 0 learning the
  69 #       dependencies of the tree wrt the initial directory (_DEP_RELDIR).
  70 #
  71 #       NOTE: given the extent of processing that DIRDEPS undergoes it
  72 #       is important that any variables in entries use :U to guard
  73 #       against surprises when undefined.
  74 #
  75 # TARGET_SPEC_VARS
  76 #       The default value is just MACHINE, and for most environments
  77 #       this is sufficient.  The _DIRDEP_USE target actually sets
  78 #       both MACHINE and TARGET_SPEC to the suffix of the current
  79 #       target so that in the general case TARGET_SPEC can be ignored.
  80 #
  81 #       If more than MACHINE is needed then sys.mk needs to decompose
  82 #       TARGET_SPEC and set the relevant variables accordingly.
  83 #       It is important that MACHINE be included in and actually be
  84 #       the first member of TARGET_SPEC_VARS.  This allows other
  85 #       variables to be considered optional, and some of the treatment
  86 #       below relies on MACHINE being the first entry.
  87 #       Note: TARGET_SPEC cannot contain any '.'s so the target
  88 #       triple used by compiler folk won't work (directly anyway).
  89 #
  90 #       For example:
  91 #
  92 #               # Always list MACHINE first,
  93 #               # other variables might be optional.
  94 #               TARGET_SPEC_VARS = MACHINE TARGET_OS
  95 #               .if ${TARGET_SPEC:Uno:M*,*} != ""
  96 #               _tspec := ${TARGET_SPEC:S/,/ /g}
  97 #               MACHINE := ${_tspec:[1]}
  98 #               TARGET_OS := ${_tspec:[2]}
  99 #               # etc.
 100 #               # We need to stop that TARGET_SPEC affecting any submakes
 101 #               # and deal with MACHINE=${TARGET_SPEC} in the environment.
 102 #               TARGET_SPEC =
 103 #               # export but do not track
 104 #               .export-env TARGET_SPEC
 105 #               .export ${TARGET_SPEC_VARS}
 106 #               .for v in ${TARGET_SPEC_VARS:O:u}
 107 #               .if empty($v)
 108 #               .undef $v
 109 #               .endif
 110 #               .endfor
 111 #               .endif
 112 #               # make sure we know what TARGET_SPEC is
 113 #               # as we may need it to find Makefile.depend*
 114 #               TARGET_SPEC = ${TARGET_SPEC_VARS:@v@${$v:U}@:ts,}
 115 #
 116 #       The following variables can influence the initial DIRDEPS
 117 #       computation with regard to the TARGET_SPECs that will be
 118 #       built.
 119 #       Most should also be considered by init.mk
 120 #
 121 #       ONLY_TARGET_SPEC_LIST
 122 #               Defines a list of TARGET_SPECs for which the current
 123 #               directory can be built.
 124 #               If ALL_MACHINES is defined, we build for all the
 125 #               TARGET_SPECs listed.
 126 #
 127 #       ONLY_MACHINE_LIST
 128 #               As for ONLY_TARGET_SPEC_LIST but only specifies
 129 #               MACHINEs.
 130 #
 131 #       NOT_TARGET_SPEC_LIST
 132 #               A list of TARGET_SPECs for which the current
 133 #               directory should not be built.
 134 #
 135 #       NOT_MACHINE_LIST
 136 #               A list of MACHINEs the current directory should not be
 137 #               built for.
 138 #
 139 # DIRDEPS_EXPORT_VARS (DEP_EXPORT_VARS)
 140 #       It is discouraged, but sometimes necessary for a
 141 #       Makefile.depend file to influence the environment.
 142 #       Doing this is correctly (especially if using DIRDEPS_CACHE) is
 143 #       tricky so a Makefile.depend file can set DIRDEPS_EXPORT_VARS
 144 #       and dirdeps.mk will do the deed:
 145 #
 146 #               MK_UEFI = yes
 147 #               DIRDEPS_EXPORT_VARS = MK_UEFI
 148 #
 149 # _build_xtra_dirs
 150 #       local.dirdeps.mk can add targets to this variable.
 151 #       They will be hooked into the build, but independent of
 152 #       any other DIRDEP.
 153 #
 154 #       This allows for adding TESTS to the build, such that the build
 155 #       if any test fails, but without the risk of introducing
 156 #       circular dependencies.
 157
 158 now_utc ?= ${%s:L:gmtime}
 159 .if !defined(start_utc)
 160 start_utc := ${now_utc}
 161 .endif
 162
 163 .if !target(bootstrap) && (make(bootstrap) || \
 164         make(bootstrap-this) || \
 165         make(bootstrap-recurse) || \
 166         make(bootstrap-empty))
 167 # disable most of below
 168 .MAKE.LEVEL = 1
 169 .endif
 170
 171 # touch this at your peril
 172 _DIRDEP_USE_LEVEL?= 0
 173 .if ${.MAKE.LEVEL} == ${_DIRDEP_USE_LEVEL}
 174 # only the first instance is interested in all this
 175
 176 # the first time we are included the _DIRDEP_USE target will not be defined
 177 # we can use this as a clue to do initialization and other one time things.
 178 .if !target(_DIRDEP_USE)
 179
 180 # do some setup we only need once
 181 _CURDIR ?= ${.CURDIR}
 182 _OBJDIR ?= ${.OBJDIR}
 183
 184 .if ${MAKEFILE:T} == ${.PARSEFILE} && empty(DIRDEPS) && ${.TARGETS:Uall:M*[/.]*} != ""
 185 # This little trick let's us do
 186 #
 187 # mk -f dirdeps.mk some/dir.${TARGET_SPEC}
 188 #
 189 all:
 190 ${.TARGETS:Nall}: all
 191 DIRDEPS := ${.TARGETS:M*[/.]*}
 192 # so that -DNO_DIRDEPS works
 193 DEP_RELDIR := ${DIRDEPS:[1]:R}
 194 # this will become DEP_MACHINE below
 195 TARGET_MACHINE := ${DIRDEPS:[1]:E:C/,.*//}
 196 .if ${TARGET_MACHINE:N*/*} == ""
 197 TARGET_MACHINE := ${MACHINE}
 198 .endif
 199 # disable DIRDEPS_CACHE as it does not like this trick
 200 MK_DIRDEPS_CACHE = no
 201 # incase anyone needs to know
 202 _dirdeps_cmdline:
 203 .endif
 204
 205 # make sure we get the behavior we expect
 206 .MAKE.SAVE_DOLLARS = no
 207
 208 # make sure these are empty to start with
 209 _DEP_TARGET_SPEC =
 210
 211 # If TARGET_SPEC_VARS is other than just MACHINE
 212 # it should be set by sys.mk or similar by now.
 213 # TARGET_SPEC must not contain any '.'s.
 214 TARGET_SPEC_VARS ?= MACHINE
 215 # we allow for this to be a subset
 216 TARGET_SPEC_VARS.host ?= MACHINE
 217 TARGET_SPEC_VARS.host32 = ${TARGET_SPEC_VARS.host}
 218 # this is what we started with
 219 TARGET_SPEC = ${TARGET_SPEC_VARS:@v@${$v:U}@:ts,}
 220 # this is what we mostly use below
 221 DEP_TARGET_SPEC_VARS = ${TARGET_SPEC_VARS.${DEP_MACHINE}:U${TARGET_SPEC_VARS}}
 222 DEP_TARGET_SPEC = ${DEP_TARGET_SPEC_VARS:S,^,DEP_,:@v@${$v:U}@:ts,}
 223 # make sure we have defaults
 224 .for v in ${DEP_TARGET_SPEC_VARS}
 225 DEP_$v ?= ${$v}
 226 .endfor
 227
 228 .if ${TARGET_SPEC_VARS:[#]} > 1
 229 # Ok, this gets more complex (putting it mildly).
 230 # In order to stay sane, we need to ensure that all the build_dirs
 231 # we compute below are fully qualified wrt DEP_TARGET_SPEC.
 232 # The makefiles may only partially specify (eg. MACHINE only),
 233 # so we need to construct a set of modifiers to fill in the gaps.
 234 _tspec_x := ${TARGET_SPEC_VARS:${M_RANGE:Urange}}
 235 # this handles unqualified entries
 236 M_dep_qual_fixes = C;(/[^/.,]+)$$;\1.$${DEP_TARGET_SPEC};
 237 # there needs to be at least one item missing for these to make sense
 238 .for i in ${_tspec_x:[2..-1]}
 239 _tspec_m$i := ${TARGET_SPEC_VARS:[2..$i]:@w@[^,]+@:ts,}
 240 _tspec_a$i := ,${TARGET_SPEC_VARS:[$i..-1]:@v@$$$${DEP_$v}@:ts,}
 241 M_dep_qual_fixes += C;(\.${_tspec_m$i})$$;\1${_tspec_a$i};
 242 .endfor
 243 TARGET_SPEC_VARSr := ${TARGET_SPEC_VARS:[-1..1]}
 244 .if ${TARGET_SPEC_VARS.host} == ${TARGET_SPEC_VARS}
 245 M_dep_qual_fixes.host = ${M_dep_qual_fixes}
 246 .elif ${TARGET_SPEC_VARS.host:[#]} > 1
 247 _htspec_x := ${TARGET_SPEC_VARS.host:${M_RANGE:Urange}}
 248 # this handles unqualified entries
 249 M_dep_qual_fixes.host = C;(/[^/.,]+)$$;\1.$${DEP_TARGET_SPEC};
 250 # there needs to be at least one item missing for these to make sense
 251 .for i in ${_htspec_x:[2..-1]}
 252 _htspec_m$i := ${TARGET_SPEC_VARS.host:[2..$i]:@w@[^,]+@:ts,}
 253 _htspec_a$i := ,${TARGET_SPEC_VARS.host:[$i..-1]:@v@$$$${DEP_$v}@:ts,}
 254 M_dep_qual_fixes.host += C;(\.${_htspec_m$i})$$;\1${_htspec_a$i};
 255 .endfor
 256 .else
 257 M_dep_qual_fixes.host = U
 258 .endif
 259 .else
 260 # A harmless? default.
 261 M_dep_qual_fixes = U
 262 .endif
 263 M_dep_qual_fixes.host ?= ${M_dep_qual_fixes}
 264 M_dep_qual_fixes.host32 = ${M_dep_qual_fixes.host}
 265
 266 .if !defined(.MAKE.DEPENDFILE_PREFERENCE)
 267 # .MAKE.DEPENDFILE_PREFERENCE makes the logic below neater?
 268 # you really want this set by sys.mk or similar
 269 .MAKE.DEPENDFILE_PREFERENCE = ${_CURDIR}/${.MAKE.DEPENDFILE:T}
 270 .if ${.MAKE.DEPENDFILE:E} == "${TARGET_SPEC}"
 271 .if ${TARGET_SPEC} != ${MACHINE}
 272 .MAKE.DEPENDFILE_PREFERENCE += ${_CURDIR}/${.MAKE.DEPENDFILE:T:R}.$${MACHINE}
 273 .endif
 274 .MAKE.DEPENDFILE_PREFERENCE += ${_CURDIR}/${.MAKE.DEPENDFILE:T:R}
 275 .endif
 276 .endif
 277
 278 _default_dependfile := ${.MAKE.DEPENDFILE_PREFERENCE:[1]:T}
 279 _machine_dependfiles := ${.MAKE.DEPENDFILE_PREFERENCE:T:M*${MACHINE}*}
 280
 281 # for machine specific dependfiles we require ${MACHINE} to be at the end
 282 # also for the sake of sanity we require a common prefix
 283 .if !defined(.MAKE.DEPENDFILE_PREFIX)
 284 # knowing .MAKE.DEPENDFILE_PREFIX helps
 285 .if !empty(_machine_dependfiles)
 286 .MAKE.DEPENDFILE_PREFIX := ${_machine_dependfiles:[1]:T:R}
 287 .else
 288 .MAKE.DEPENDFILE_PREFIX := ${_default_dependfile:T}
 289 .endif
 290 .endif
 291
 292 # turn a list into a set of :N modifiers
 293 # NskipFoo = ${Foo:${M_ListToSkip}}
 294 M_ListToSkip ?= O:u:S,^,N,:ts:
 295
 296 # this is how we identify non-machine specific dependfiles
 297 N_notmachine := ${.MAKE.DEPENDFILE_PREFERENCE:E:N*${MACHINE}*:${M_ListToSkip}}
 298
 299 # this gets reset for each dirdep we check
 300 DEP_RELDIR ?= ${RELDIR}
 301
 302 # remember the initial value of DEP_RELDIR - we test for it below.
 303 _DEP_RELDIR := ${DEP_RELDIR}
 304
 305 # this can cause lots of output!
 306 # set to a set of glob expressions that might match RELDIR
 307 DEBUG_DIRDEPS ?= no
 308
 309 # make sure this target exists
 310 dirdeps: beforedirdeps .WAIT
 311 beforedirdeps:
 312
 313 .endif                          # !target(_DIRDEP_USE)
 314
 315 .if ${DEBUG_DIRDEPS:@x@${DEP_RELDIR:M$x}${${DEP_RELDIR}.${DEP_MACHINE}:L:M$x}@} != ""
 316 _debug_reldir = 1
 317 .else
 318 _debug_reldir = 0
 319 .endif
 320 .if ${DEBUG_DIRDEPS:@x@${DEP_RELDIR:M$x}${${DEP_RELDIR}.depend depend:L:M$x}@} != ""
 321 _debug_search = 1
 322 .else
 323 _debug_search = 0
 324 .endif
 325
 326 # First off, we want to know what ${MACHINE} to build for.
 327 # This can be complicated if we are using a mixture of ${MACHINE} specific
 328 # and non-specific Makefile.depend*
 329
 330 # if we were included recursively _DEP_TARGET_SPEC should be valid.
 331 .if empty(_DEP_TARGET_SPEC)
 332 DEP_MACHINE = ${TARGET_MACHINE:U${MACHINE}}
 333 _DEP_TARGET_SPEC := ${DEP_TARGET_SPEC}
 334 .if ${.INCLUDEDFROMFILE:U:M${.MAKE.DEPENDFILE_PREFIX}*} != ""
 335 # record that we've read dependfile for this
 336 _dirdeps_checked.${_CURDIR}.${TARGET_SPEC}:
 337 .endif
 338 .endif
 339
 340 # by now _DEP_TARGET_SPEC should be set, parse it.
 341 .if ${TARGET_SPEC_VARS:[#]} > 1
 342 # we need to parse DEP_MACHINE may or may not contain more info
 343 _tspec := ${_DEP_TARGET_SPEC:S/,/ /g}
 344 .for i in ${_tspec_x}
 345 DEP_${TARGET_SPEC_VARS:[$i]} := ${_tspec:[$i]}
 346 .endfor
 347 .for v in ${DEP_TARGET_SPEC_VARS:O:u}
 348 .if empty(DEP_$v)
 349 .undef DEP_$v
 350 .endif
 351 .endfor
 352 .else
 353 DEP_MACHINE := ${_DEP_TARGET_SPEC}
 354 .endif
 355
 356 # reset each time through
 357 _build_all_dirs =
 358 _build_xtra_dirs =
 359
 360 # DIRDEPS_CACHE can be very handy for debugging.
 361 # Also if repeatedly building the same target,
 362 # we can avoid the overhead of re-computing the tree dependencies.
 363 MK_DIRDEPS_CACHE ?= no
 364 BUILD_DIRDEPS_CACHE ?= no
 365 BUILD_DIRDEPS ?= yes
 366
 367 .if ${MK_DIRDEPS_CACHE} == "yes"
 368 # this is where we will cache all our work
 369 DIRDEPS_CACHE ?= ${_OBJDIR:tA}/dirdeps.cache${_TARGETS:U${.TARGETS}:Nall:O:u:ts-:S,/,_,g:S,^,.,:N.}
 370 .endif
 371
 372 # sanity check: Makefile.depend.options should *not* include us
 373 .if ${.INCLUDEDFROMFILE:U:M${.MAKE.DEPENDFILE_PREFIX}.options} != ""
 374 .error ${DEP_RELDIR}/${.MAKE.DEPENDFILE_PREFIX}.options: should include dirdeps-options.mk
 375 .endif
 376
 377 # pickup customizations
 378 # as below you can use !target(_DIRDEP_USE) to protect things
 379 # which should only be done once.
 380 .-include <local.dirdeps.mk>
 381
 382 .if !target(_DIRDEP_USE)
 383 # things we skip for host tools
 384 SKIP_HOSTDIR ?=
 385
 386 NSkipHostDir = ${SKIP_HOSTDIR:N*.host*:S,$,.host*,:N.host*:S,^,${SRCTOP}/,:${M_ListToSkip}}
 387
 388 # things we always skip
 389 # SKIP_DIRDEPS allows for adding entries on command line.
 390 SKIP_DIR += .host *.WAIT ${SKIP_DIRDEPS}
 391 SKIP_DIR.host += ${SKIP_HOSTDIR}
 392
 393 DEP_SKIP_DIR = ${SKIP_DIR} \
 394         ${SKIP_DIR.${DEP_TARGET_SPEC}:U} \
 395         ${TARGET_SPEC_VARS:@v@${SKIP_DIR.${DEP_$v}:U}@} \
 396         ${SKIP_DIRDEPS.${DEP_TARGET_SPEC}:U} \
 397         ${TARGET_SPEC_VARS:@v@${SKIP_DIRDEPS.${DEP_$v}:U}@}
 398
 399
 400 NSkipDir = ${DEP_SKIP_DIR:${M_ListToSkip}}
 401
 402 .if defined(NODIRDEPS) || defined(WITHOUT_DIRDEPS)
 403 NO_DIRDEPS =
 404 .elif defined(WITHOUT_DIRDEPS_BELOW)
 405 NO_DIRDEPS_BELOW =
 406 .endif
 407
 408 .if defined(NO_DIRDEPS)
 409 # confine ourselves to the original dir and below.
 410 DIRDEPS_FILTER += M${_DEP_RELDIR}*
 411 .elif defined(NO_DIRDEPS_BELOW)
 412 DIRDEPS_FILTER += M${_DEP_RELDIR}
 413 .endif
 414
 415 # this is what we run below
 416 DIRDEP_MAKE ?= ${.MAKE}
 417 DIRDEP_DIR ?= ${.TARGET:R}
 418
 419 # if you want us to report load averages during build
 420 # DIRDEP_USE_PRELUDE += ${DIRDEP_LOADAVG_REPORT};
 421
 422 DIRDEP_LOADAVG_CMD ?= ${UPTIME:Uuptime} | sed 's,.*\(load\),\1,'
 423 DIRDEP_LOADAVG_LAST = 0
 424 # yes the expression here is a bit complicated,
 425 # the trick is to only eval ${DIRDEP_LOADAVG_LAST::=${now_utc}}
 426 # when we want to report.
 427 # Note: expr(1) will exit 1 if the expression evaluates to 0
 428 # hence the  || true
 429 DIRDEP_LOADAVG_REPORT = \
 430         test -z "${"${expr ${now_utc} - ${DIRDEP_LOADAVG_INTERVAL:U60} - ${DIRDEP_LOADAVG_LAST} || true:L:sh:N-*}":?yes${DIRDEP_LOADAVG_LAST::=${now_utc}}:}" || \
 431         echo "${TRACER}`${DIRDEP_LOADAVG_CMD}`"
 432
 433 # we suppress SUBDIR when visiting the leaves
 434 # we assume sys.mk will set MACHINE_ARCH
 435 # you can add extras to DIRDEP_USE_ENV
 436 # if there is no makefile in the target directory, we skip it.
 437 _DIRDEP_USE:    .USE .MAKE
 438         @for m in ${.MAKE.MAKEFILE_PREFERENCE}; do \
 439                 test -s ${.TARGET:R}/$$m || continue; \
 440                 echo "${TRACER}Checking ${.TARGET:S,^${SRCTOP}/,,} for ${.TARGET:E} ..."; \
 441                 ${DIRDEP_USE_PRELUDE} \
 442                 MACHINE_ARCH= NO_SUBDIR=1 ${DIRDEP_USE_ENV} \
 443                 TARGET_SPEC=${.TARGET:E} \
 444                 MACHINE=${.TARGET:E} \
 445                 ${DIRDEP_MAKE} -C ${DIRDEP_DIR} || exit 1; \
 446                 break; \
 447         done
 448
 449 .ifdef ALL_MACHINES
 450 .if empty(ONLY_TARGET_SPEC_LIST) && empty(ONLY_MACHINE_LIST)
 451 # we start with everything
 452 _machine_list != echo; 'ls' -1 ${_CURDIR}/${.MAKE.DEPENDFILE_PREFIX}* 2> /dev/null
 453
 454 # some things we know we want to ignore
 455 DIRDEPS_TARGETS_SKIP_LIST += \
 456         *~ \
 457         *.bak \
 458         *.inc \
 459         *.old \
 460         *.options \
 461         *.orig \
 462         *.rej \
 463
 464 # first trim things we know we want to skip
 465 # and provide canonical form
 466 _machine_list := ${_machine_list:${DIRDEPS_TARGETS_SKIP_LIST:${M_ListToSkip}}:T:E}
 467
 468 # cater for local complexities
 469 # local.dirdeps.mk can set
 470 # DIRDEPS_ALL_MACHINES_FILTER and
 471 # DIRDEPS_ALL_MACHINES_FILTER_XTRAS for final tweaks
 472
 473 .if !empty(ALL_TARGET_SPEC_LIST)
 474 .if ${_debug_reldir}
 475 .info ALL_TARGET_SPEC_LIST=${ALL_TARGET_SPEC_LIST}
 476 .endif
 477 DIRDEPS_ALL_MACHINES_FILTER += \
 478         @x@$${ALL_TARGET_SPEC_LIST:@s@$${x:M$$s}@}@
 479 .elif !empty(ALL_MACHINE_LIST)
 480 .if ${_debug_reldir}
 481 .info ALL_MACHINE_LIST=${ALL_MACHINE_LIST}
 482 .endif
 483 .if ${TARGET_SPEC_VARS:[#]} > 1
 484 # the space below can result in extraneous ':'
 485 DIRDEPS_ALL_MACHINES_FILTER += \
 486         @x@$${ALL_MACHINE_LIST:@m@$${x:M$$m,*} $${x:M$$m}@}@
 487 .else
 488 DIRDEPS_ALL_MACHINES_FILTER += \
 489         @x@$${ALL_MACHINE_LIST:@m@$${x:M$$m}@}@
 490 .endif
 491 .endif
 492 # add local XTRAS - default to something benign
 493 DIRDEPS_ALL_MACHINES_FILTER += \
 494         ${DIRDEPS_ALL_MACHINES_FILTER_XTRAS:UNbak}
 495
 496 .if ${_debug_reldir}
 497 .info _machine_list=${_machine_list}
 498 .info DIRDEPS_ALL_MACHINES_FILTER=${DIRDEPS_ALL_MACHINES_FILTER}
 499 .endif
 500
 501 _only_machines := ${_machine_list:${DIRDEPS_ALL_MACHINES_FILTER:ts:}:S,:, ,g}
 502 .else
 503 _only_machines := ${ONLY_TARGET_SPEC_LIST:U} ${ONLY_MACHINE_LIST:U}
 504 .endif
 505
 506 .if empty(_only_machines)
 507 # we must be boot-strapping
 508 _only_machines := ${TARGET_MACHINE:U${ALL_TARGET_SPEC_LIST:U${ALL_MACHINE_LIST:U${DEP_MACHINE}}}}
 509 .endif
 510
 511 # cleanup the result
 512 _only_machines := ${_only_machines:O:u}
 513
 514 .if ${_debug_reldir}
 515 .info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: ALL_MACHINES _only_machines=${_only_machines}
 516 .endif
 517
 518 .else                           # ! ALL_MACHINES
 519 # if ONLY_TARGET_SPEC_LIST or ONLY_MACHINE_LIST is set, we are limited to that.
 520 # Note that ONLY_TARGET_SPEC_LIST should be fully qualified.
 521 # if TARGET_MACHINE is set - it is really the same as ONLY_MACHINE_LIST
 522 # otherwise DEP_MACHINE is it - so DEP_MACHINE will match.
 523 _only_machines := ${ONLY_TARGET_SPEC_LIST:U:M${DEP_MACHINE},*}
 524 .if empty(_only_machines)
 525 _only_machines := ${ONLY_MACHINE_LIST:U${TARGET_MACHINE:U${DEP_MACHINE}}:M${DEP_MACHINE}}
 526 .endif
 527 .endif
 528
 529 .if !empty(NOT_MACHINE_LIST)
 530 _only_machines := ${_only_machines:${NOT_MACHINE_LIST:${M_ListToSkip}}}
 531 .endif
 532 .if !empty(NOT_TARGET_SPEC_LIST)
 533 # we must first qualify
 534 _dm := ${DEP_MACHINE}
 535 _only_machines := ${_only_machines:M*,*} ${_only_machines:N*,*:@DEP_MACHINE@${DEP_TARGET_SPEC}@:S,^,.,:${M_dep_qual_fixes:ts:}:O:u:S,^.,,}
 536 DEP_MACHINE := ${_dm}
 537 _only_machines := ${_only_machines:${NOT_TARGET_SPEC_LIST:${M_ListToSkip}}}
 538 .endif
 539 # clean up
 540 _only_machines := ${_only_machines:O:u}
 541
 542 .if ${_debug_reldir}
 543 .info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: _only_machines=${_only_machines}
 544 .endif
 545
 546 # make sure we have a starting place?
 547 DIRDEPS ?= ${RELDIR}
 548 .endif                          # target
 549
 550 .if !defined(NO_DIRDEPS) && !defined(NO_DIRDEPS_BELOW)
 551 .if ${MK_DIRDEPS_CACHE} == "yes"
 552
 553 # just ensure this exists
 554 build-dirdeps:
 555
 556 M_oneperline = @x@\\${.newline} $$x@
 557
 558 .if ${BUILD_DIRDEPS_CACHE} == "no"
 559 .if !target(dirdeps-cached)
 560 # we do this via sub-make
 561 BUILD_DIRDEPS = no
 562
 563 # ignore anything but these
 564 .MAKE.META.IGNORE_FILTER = M*/${.MAKE.DEPENDFILE_PREFIX}*
 565
 566 dirdeps: dirdeps-cached
 567 dirdeps-cached: ${DIRDEPS_CACHE} .MAKE
 568         @echo "${TRACER}Using ${DIRDEPS_CACHE}"
 569         @MAKELEVEL=${.MAKE.LEVEL} \
 570         TARGET_SPEC=${TARGET_SPEC} \
 571         ${TARGET_SPEC_VARS:@v@$v=${$v}@} \
 572         ${.MAKE} -C ${_CURDIR} -f ${DIRDEPS_CACHE} \
 573                 dirdeps MK_DIRDEPS_CACHE=no BUILD_DIRDEPS=no
 574
 575 # leaf makefiles rarely work for building DIRDEPS_CACHE
 576 .if ${RELDIR} != "."
 577 BUILD_DIRDEPS_MAKEFILE ?= -f dirdeps.mk
 578 .endif
 579
 580 # these should generally do
 581 BUILD_DIRDEPS_MAKEFILE ?=
 582 BUILD_DIRDEPS_TARGETS ?= ${.TARGETS}
 583
 584 .if ${DIRDEPS_CACHE} != ${STATIC_DIRDEPS_CACHE:Uno} && ${DIRDEPS_CACHE:M${SRCTOP}/*} == ""
 585 # export this for dirdeps-cache-update.mk
 586 DYNAMIC_DIRDEPS_CACHE := ${DIRDEPS_CACHE}
 587 .export DYNAMIC_DIRDEPS_CACHE
 588 # we need the .meta file to ensure we update if
 589 # any of the Makefile.depend* changed.
 590 # We do not want to compare the command line though.
 591 ${DIRDEPS_CACHE}:       .META .NOMETA_CMP
 592         +@{ echo '# Autogenerated - do NOT edit!'; echo; \
 593         echo 'BUILD_DIRDEPS=no'; echo; \
 594         echo '.include <dirdeps.mk>'; echo; \
 595         } > ${.TARGET}.new
 596         +@MAKELEVEL=${.MAKE.LEVEL} DIRDEPS_CACHE=${DIRDEPS_CACHE} \
 597         DIRDEPS="${DIRDEPS}" \
 598         TARGET_SPEC=${TARGET_SPEC} \
 599         MAKEFLAGS= ${DIRDEP_CACHE_MAKE:U${.MAKE}} -C ${_CURDIR} \
 600         ${BUILD_DIRDEPS_MAKEFILE} \
 601         ${BUILD_DIRDEPS_TARGETS} BUILD_DIRDEPS_CACHE=yes \
 602         .MAKE.DEPENDFILE=.none \
 603         ${"${DEBUG_DIRDEPS:Nno}":?DEBUG_DIRDEPS='${DEBUG_DIRDEPS}':} \
 604         ${.MAKEFLAGS:tW:S,-D ,-D,g:tw:M*WITH*} \
 605         ${.MAKEFLAGS:tW:S,-d ,-d,g:tw:M-d*} \
 606         3>&1 1>&2 | sed 's,${SRCTOP},_{SRCTOP},g;s,_{SRCTOP}/_{SRCTOP},_{SRCTOP},g;s,_{,$${,g' >> ${.TARGET}.new && \
 607         mv ${.TARGET}.new ${.TARGET}
 608
 609 .endif
 610 .endif
 611 .elif !target(_count_dirdeps)
 612 # we want to capture the dirdeps count in the cache
 613 .END: _count_dirdeps
 614 _count_dirdeps: .NOMETA
 615         @{ echo; echo '.info $${.newline}$${TRACER}Makefiles read: total=${.MAKE.MAKEFILES:[#]} depend=${.MAKE.MAKEFILES:M*depend*:[#]} dirdeps=${.ALLTARGETS:M${SRCTOP}*:O:u:[#]} ${DIRDEP_INFO_XTRAS}'; } >&3
 616
 617 .endif
 618 .elif !make(dirdeps) && !target(_count_dirdeps)
 619 beforedirdeps: _count_dirdeps
 620 _count_dirdeps: .NOMETA
 621         @echo "${TRACER}Makefiles read: total=${.MAKE.MAKEFILES:[#]} depend=${.MAKE.MAKEFILES:M*depend*:[#]} dirdeps=${.ALLTARGETS:M${SRCTOP}*:O:u:[#]} ${DIRDEP_INFO_XTRAS} seconds=`expr ${now_utc} - ${start_utc}`"
 622
 623 .endif
 624 .endif
 625
 626 .if ${BUILD_DIRDEPS} == "yes"
 627
 628 # the rest is done repeatedly for every Makefile.depend we read.
 629 # if we are anything but the original dir we care only about the
 630 # machine type we were included for..
 631
 632 .if ${DEP_RELDIR} == "."
 633 _this_dir := ${SRCTOP}
 634 .else
 635 _this_dir := ${SRCTOP}/${DEP_RELDIR}
 636 .endif
 637
 638 # on rare occasions, there can be a need for extra help
 639 _dep_hack := ${_this_dir}/${.MAKE.DEPENDFILE_PREFIX}.inc
 640 .-include <${_dep_hack}>
 641 .-include <${_dep_hack:R}.options>
 642
 643 .if ${DEP_RELDIR} != ${_DEP_RELDIR} || ${DEP_TARGET_SPEC} != ${TARGET_SPEC}
 644 # this should be all
 645 _machines := ${DEP_MACHINE}
 646 .else
 647 # this is the machine list we actually use below
 648 _machines := ${_only_machines}
 649
 650 .if defined(HOSTPROG) || ${DEP_MACHINE:Nhost*} == ""
 651 # we need to build this guy's dependencies for host as well.
 652 .if ${DEP_MACHINE:Nhost*} == ""
 653 _machines += ${DEP_MACHINE}
 654 .else
 655 _machines += host
 656 .endif
 657 .endif
 658
 659 _machines := ${_machines:O:u}
 660 .endif
 661
 662 .if ${DEP_TARGET_SPEC_VARS:[#]} > 1
 663 # we need to tweak _machines
 664 _dm := ${DEP_MACHINE}
 665 # apply the same filtering that we do when qualifying DIRDEPS.
 666 # M_dep_qual_fixes expects .${MACHINE}* so add (and remove) '.'
 667 # Again we expect that any already qualified machines are fully qualified.
 668 _machines := ${_machines:M*,*} ${_machines:N*,*:@DEP_MACHINE@${DEP_TARGET_SPEC}@:S,^,.,:S,^.,,}
 669 DEP_MACHINE := ${_dm}
 670 _machines := ${_machines:${M_dep_qual_fixes.${DEP_MACHINE}:U${M_dep_qual_fixes}:ts:}:O:u}
 671 .endif
 672
 673 # reset each time through
 674 _build_dirs =
 675
 676 .if ${DEP_RELDIR} == ${_DEP_RELDIR} && ${_CURDIR} != ${SRCTOP}
 677 # pickup other machines for this dir if necessary
 678 _build_dirs += ${_machines:@m@${_CURDIR}.$m@}
 679 .endif
 680
 681 .if ${_debug_reldir}
 682 .info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: nDIRDEPS=${DIRDEPS:[#]}
 683 .info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: DIRDEPS='${DIRDEPS}'
 684 .info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: _machines='${_machines}'
 685 .endif
 686
 687 .if !empty(DIRDEPS)
 688 # these we reset each time through as they can depend on DEP_MACHINE
 689 DEP_DIRDEPS_FILTER = \
 690         ${DIRDEPS_FILTER.${DEP_TARGET_SPEC}:U} \
 691         ${TARGET_SPEC_VARS:@v@${DIRDEPS_FILTER.${DEP_$v}:U}@} \
 692         ${DIRDEPS_FILTER:U}
 693 .if empty(DEP_DIRDEPS_FILTER)
 694 # something harmless
 695 DEP_DIRDEPS_FILTER = U
 696 .endif
 697
 698 # this is what we start with
 699 __depdirs := ${DIRDEPS:${NSkipDir}:${DEP_DIRDEPS_FILTER:ts:}:C,//+,/,g:O:u:@d@${SRCTOP}/$d@}
 700
 701 # some entries may be qualified with .<machine> or .<target_spec>
 702 # we can tell the unqualified ones easily - because they exist
 703 __unqual_depdirs := ${__depdirs:@d@${exists($d):?$d:}@}
 704 __qual_depdirs := ${__depdirs:${__unqual_depdirs:Uno:${M_ListToSkip}}}
 705
 706 .if ${DEP_RELDIR} == ${_DEP_RELDIR}
 707 # if it was called out - we likely need it.
 708 __hostdpadd := ${DPADD:U.:M${HOST_OBJTOP}/*:S,${HOST_OBJTOP}/,,:H:${NSkipDir}:${DIRDEPS_FILTER:ts:}:S,$,.host,:N.*:@d@${SRCTOP}/$d@} \
 709         ${DPADD:U.:M${HOST_OBJTOP32:Uno}/*:S,${HOST_OBJTOP32:Uno}/,,:H:${NSkipDir}:${DIRDEPS_FILTER:ts:}:S,$,.host32,:N.*:@d@${SRCTOP}/$d@}
 710 __qual_depdirs += ${__hostdpadd}
 711 .endif
 712
 713 .if ${_debug_reldir}
 714 .info DEP_DIRDEPS_FILTER=${DEP_DIRDEPS_FILTER:ts:}
 715 .info depdirs=${__depdirs:S,^${SRCTOP}/,,}
 716 .info qualified=${__qual_depdirs:S,^${SRCTOP}/,,}
 717 .info unqualified=${__unqual_depdirs:S,^${SRCTOP}/,,}
 718 .endif
 719
 720 # _build_dirs is what we will feed to _DIRDEP_USE
 721 _build_dirs += \
 722         ${__qual_depdirs:M*.host:${NSkipHostDir}:N.host} \
 723         ${__qual_depdirs:N*.host} \
 724         ${_machines:Mhost*:@m@${__unqual_depdirs:@d@$d.$m@}@:${NSkipHostDir}:N.host} \
 725         ${_machines:Nhost*:@m@${__unqual_depdirs:@d@$d.$m@}@}
 726
 727 # qualify everything now
 728 .if ${_debug_reldir}
 729 .info _build_dirs=${_build_dirs}
 730 .endif
 731 # make sure we do not mess with qualifying "host" entries
 732 _build_dirs := ${_build_dirs:M*.host*:${M_dep_qual_fixes.host:ts:}} \
 733         ${_build_dirs:N*.host*:${M_dep_qual_fixes:ts:}}
 734 _build_dirs := ${_build_dirs:O:u}
 735 .if ${_debug_reldir}
 736 .info _build_dirs=${_build_dirs}
 737 .endif
 738
 739 .endif                          # empty DIRDEPS
 740
 741 _build_all_dirs += ${_build_dirs} ${_build_xtra_dirs}
 742 _build_all_dirs := ${_build_all_dirs:O:u}
 743
 744 # Normally if doing make -V something,
 745 # we do not want to waste time chasing DIRDEPS
 746 # but if we want to count the number of Makefile.depend* read, we do.
 747 .if ${.MAKEFLAGS:M-V${_V_READ_DIRDEPS:U}} == ""
 748 .if !empty(_build_all_dirs)
 749 .if ${BUILD_DIRDEPS_CACHE} == "yes"
 750 # we use _cache_script to minimize the number of times we fork the shell
 751 _cache_script = echo '\# ${DEP_RELDIR}.${DEP_TARGET_SPEC}';
 752 # guard against _new_dirdeps being too big for a single command line
 753 _new_dirdeps := ${_build_all_dirs:@x@${target($x):?:$x}@:S,^${SRCTOP}/,,}
 754 _cache_xtra_deps := ${_build_xtra_dirs:S,^${SRCTOP}/,,}
 755 .export _cache_xtra_deps _new_dirdeps
 756 .if !empty(DIRDEPS_EXPORT_VARS) || !empty(DEP_EXPORT_VARS)
 757 # Discouraged, but there are always exceptions.
 758 # Handle it here rather than explain how.
 759 DIRDEPS_EXPORT_VARS ?= ${DEP_EXPORT_VARS}
 760 _cache_xvars := echo; ${DIRDEPS_EXPORT_VARS:@v@echo '$v = ${$v}';@} echo '.export ${DIRDEPS_EXPORT_VARS}'; echo;
 761 _cache_script += ${_cache_xvars}
 762 .endif
 763 .else
 764 # this makes it all happen
 765 dirdeps: ${_build_all_dirs}
 766 .endif
 767 ${_build_all_dirs}:     _DIRDEP_USE
 768
 769 .if ${_debug_reldir}
 770 .info ${DEP_RELDIR}.${DEP_TARGET_SPEC}: needs: ${_build_dirs:S,^${SRCTOP}/,,}
 771 .endif
 772
 773 .if !empty(DIRDEPS_EXPORT_VARS) || !empty(DEP_EXPORT_VARS)
 774 .export ${DIRDEPS_EXPORT_VARS} ${DEP_EXPORT_VARS}
 775 DIRDEPS_EXPORT_VARS =
 776 DEP_EXPORT_VARS =
 777 .endif
 778
 779 # this builds the dependency graph
 780 .for m in ${_machines}
 781 .if ${BUILD_DIRDEPS_CACHE} == "yes" && !empty(_build_dirs)
 782 _cache_deps =
 783 _cache_script += echo; echo 'DIRDEPS.${_this_dir}.$m = \';
 784 .endif
 785 # it would be nice to do :N${.TARGET}
 786 .if !empty(__qual_depdirs)
 787 .for q in ${__qual_depdirs:M*.host*:${M_dep_qual_fixes.host:ts:}:E:O:u:N$m} \
 788         ${__qual_depdirs:N*.host*:${M_dep_qual_fixes:ts:}:E:O:u:N$m}
 789 .if ${_debug_reldir} || ${DEBUG_DIRDEPS:@x@${${DEP_RELDIR}.$m:L:M$x}${${DEP_RELDIR}.$q:L:M$x}@} != ""
 790 .info ${DEP_RELDIR}.$m: q=$q graph: ${_build_dirs:M*.$q:S,^${SRCTOP}/,,}
 791 .endif
 792 .if ${BUILD_DIRDEPS_CACHE} == "yes"
 793 _cache_deps += ${_build_dirs:M*.$q:S,^${SRCTOP}/,,}
 794 .else
 795 ${_this_dir}.$m: ${_build_dirs:M*.$q}
 796 .endif
 797 .endfor
 798 .endif
 799 .if ${_debug_reldir}
 800 .info ${DEP_RELDIR}.$m: graph: ${_build_dirs:M*.$m:N${_this_dir}.$m:S,^${SRCTOP}/,,}
 801 .endif
 802 .if ${BUILD_DIRDEPS_CACHE} == "yes"
 803 .if !empty(_build_dirs)
 804 _cache_deps += ${_build_dirs:M*.$m:N${_this_dir}.$m:S,^${SRCTOP}/,,}
 805 .if !empty(_cache_deps)
 806 .export _cache_deps
 807 _cache_script += for x in $$_cache_deps; do echo "      _{SRCTOP}/$$x \\"; done;
 808 .endif
 809 # anything in _{build,env}_xtra_dirs is hooked to dirdeps: only
 810 x!= echo; { echo; ${_cache_script} echo; echo '${_this_dir}.$m: $${DIRDEPS.${_this_dir}.$m}'; \
 811         echo; echo 'dirdeps: ${_this_dir}.$m \'; \
 812         for x in $$_cache_xtra_deps; do echo "  _{SRCTOP}/$$x \\"; done; \
 813         echo; for x in $$_new_dirdeps; do echo "_{SRCTOP}/$$x: _DIRDEP_USE"; done; } >&3
 814 .endif
 815 .else
 816 ${_this_dir}.$m: ${_build_dirs:M*.$m:N${_this_dir}.$m}
 817 .endif
 818 .endfor
 819
 820 .endif
 821
 822 # Now find more dependencies - and recurse.
 823 .for d in ${_build_all_dirs}
 824 .if !target(_dirdeps_checked.$d)
 825 # once only
 826 _dirdeps_checked.$d:
 827 _dr := ${d:S,^${SRCTOP}/,,}
 828 .if ${_debug_search}
 829 .info checking ${_dr}
 830 .endif
 831 # Note: _build_all_dirs is fully qualifed so d:R is always the directory
 832 .if exists(${d:R})
 833 # we pass _DEP_TARGET_SPEC to tell the next step what we want
 834 _DEP_TARGET_SPEC := ${d:E}
 835 # some makefiles may still look at this
 836 _DEP_MACHINE := ${d:E:C/,.*//}
 837 DEP_MACHINE := ${_DEP_MACHINE}
 838 # set these too in case Makefile.depend* uses them
 839 .if ${DEP_TARGET_SPEC_VARS:[#]} > 1
 840 _dtspec := ${_DEP_TARGET_SPEC:S/,/ /g}
 841 .for i in ${_tspec_x}
 842 DEP_${DEP_TARGET_SPEC_VARS:[$i]} := ${_dtspec:[$i]}
 843 .endfor
 844 .endif
 845 # Warning: there is an assumption here that MACHINE is always
 846 # the first entry in TARGET_SPEC_VARS.
 847 # If TARGET_SPEC and MACHINE are insufficient, you have a problem.
 848 _m := ${.MAKE.DEPENDFILE_PREFERENCE:T:S;${TARGET_SPEC}$;${d:E};:C;${MACHINE}((,.+)?)$;${d:E:C/,.*//}\1;:@m@${exists(${d:R}/$m):?${d:R}/$m:}@:[1]}
 849 .if !empty(_m)
 850 # M_dep_qual_fixes isn't geared to Makefile.depend
 851 _qm := ${_m:C;(\.depend)$;\1.${d:E};:${M_dep_qual_fixes.${d:E}:U${M_dep_qual_fixes}:ts:}}
 852 .if ${_debug_search}
 853 .info Looking for ${_qm}
 854 .endif
 855 # set this "just in case"
 856 # we can skip :tA since we computed the path above
 857 DEP_RELDIR := ${_m:H:S,^${SRCTOP}/,,}
 858 # and reset this
 859 DIRDEPS =
 860 .if ${_debug_reldir} && ${_qm} != ${_m}
 861 .info loading ${_m:S,${SRCTOP}/,,} for ${_dr}
 862 .endif
 863 .include <${_m}>
 864 .else
 865 # set these as if we found Makefile.depend*
 866 DEP_RELDIR := ${_dr:R}
 867 DIRDEPS =
 868 .if ${_debug_reldir}
 869 .info loading local.dirdeps-missing.mk for ${_dr}
 870 .endif
 871 .-include <local.dirdeps-missing.mk>
 872 .endif
 873 .endif
 874 .endif
 875 .endfor
 876
 877 .endif                          # -V
 878 .endif                          # BUILD_DIRDEPS
 879
 880 .elif ${.MAKE.LEVEL} > 42
 881 .error You should have stopped recursing by now.
 882 .else
 883 # we are building something
 884 DEP_RELDIR := ${RELDIR}
 885 _DEP_RELDIR := ${RELDIR}
 886 # Since we are/should be included by .MAKE.DEPENDFILE
 887 # This is a final opportunity to add/hook global rules.
 888 .-include <local.dirdeps-build.mk>
 889
 890 # skip _reldir_{finish,failed} if not included from Makefile.depend*
 891 # or not in meta mode
 892 .if !defined(WITHOUT_META_STATS) && ${.INCLUDEDFROMFILE:U:M${.MAKE.DEPENDFILE_PREFIX}*} != "" && ${.MAKE.MODE:Mmeta} != ""
 893
 894 meta_stats= meta=${empty(.MAKE.META.FILES):?0:${.MAKE.META.FILES:[#]}} \
 895         created=${empty(.MAKE.META.CREATED):?0:${.MAKE.META.CREATED:[#]}}
 896
 897 .if !target(_reldir_finish)
 898 .END: _reldir_finish
 899 _reldir_finish: .NOMETA
 900         @echo "${TRACER}Finished ${RELDIR}.${TARGET_SPEC} seconds=$$(( ${now_utc} - ${start_utc} )) ${meta_stats}"
 901 .endif
 902
 903 .if !target(_reldir_failed)
 904 .ERROR: _reldir_failed
 905 _reldir_failed: .NOMETA
 906         @echo "${TRACER}Failed ${RELDIR}.${TARGET_SPEC} seconds=$$(( ${now_utc} - ${start_utc} )) ${meta_stats}"
 907 .endif
 908
 909 .endif
 910
 911 # pickup local dependencies
 912 .if ${MAKE_VERSION} < 20160220
 913 .-include <.depend>
 914 .else
 915 .dinclude <.depend>
 916 .endif
 917 .endif
 918
 919 # bootstrapping new dependencies made easy?
 920 .if !target(bootstrap-empty)
 921 .if !target(bootstrap) && (make(bootstrap) || \
 922         make(bootstrap-this) || \
 923         make(bootstrap-recurse) || \
 924         make(bootstrap-empty))
 925
 926 # if we are bootstrapping create the default
 927 _want = ${.CURDIR}/${.MAKE.DEPENDFILE_DEFAULT:T}
 928
 929 .if exists(${_want})
 930 # stop here
 931 ${.TARGETS:Mboot*}:
 932 .elif !make(bootstrap-empty)
 933 # find a Makefile.depend to use as _src
 934 _src != cd ${.CURDIR} && for m in ${.MAKE.DEPENDFILE_PREFERENCE:T:S,${MACHINE},*,}; do test -s $$m || continue; echo $$m; break; done; echo
 935 .if empty(_src)
 936 .error cannot find any of ${.MAKE.DEPENDFILE_PREFERENCE:T}${.newline}Use: bootstrap-empty
 937 .endif
 938
 939 _src?= ${.MAKE.DEPENDFILE}
 940
 941 .MAKE.DEPENDFILE_BOOTSTRAP_SED+= -e 's/${_src:E:C/,.*//}/${MACHINE}/g'
 942
 943 # just create Makefile.depend* for this dir
 944 bootstrap-this: .NOTMAIN
 945         @echo Bootstrapping ${RELDIR}/${_want:T} from ${_src:T}; \
 946         echo You need to build ${RELDIR} to correctly populate it.
 947 .if ${_src:T} != ${.MAKE.DEPENDFILE_PREFIX:T}
 948         (cd ${.CURDIR} && sed ${.MAKE.DEPENDFILE_BOOTSTRAP_SED} ${_src} > ${_want:T})
 949 .else
 950         cp ${.CURDIR}/${_src:T} ${_want}
 951 .endif
 952
 953 # create Makefile.depend* for this dir and its dependencies
 954 bootstrap: bootstrap-recurse
 955 bootstrap-recurse: bootstrap-this
 956
 957 _mf := ${.PARSEFILE}
 958 bootstrap-recurse:      .NOTMAIN .MAKE
 959         @cd ${SRCTOP} && \
 960         for d in `cd ${RELDIR} && ${.MAKE} -B -f ${"${.MAKEFLAGS:M-n}":?${_src}:${.MAKE.DEPENDFILE:T}} -V DIRDEPS`; do \
 961                 test -d $$d || d=$${d%.*}; \
 962                 test -d $$d || continue; \
 963                 echo "Checking $$d for bootstrap ..."; \
 964                 (cd $$d && ${.MAKE} -f ${_mf} bootstrap-recurse); \
 965         done
 966
 967 .endif
 968
 969 # create an empty Makefile.depend* to get the ball rolling.
 970 bootstrap-empty: .NOTMAIN .NOMETA
 971         @echo Creating empty ${RELDIR}/${_want:T}; \
 972         echo You need to build ${RELDIR} to correctly populate it.
 973         @{ echo DIRDEPS=; echo ".include <dirdeps.mk>"; } > ${_want}
 974
 975 .endif
 976 .endif