1# SPDX-License-Identifier: BSD-2-Clause 2# 3# $Id: meta.stage.mk,v 1.71 2025/03/14 20:28:42 sjg Exp $ 4# 5# @(#) Copyright (c) 2011-2025, Simon J. Gerraty 6# 7# This file is provided in the hope that it will 8# be of use. There is absolutely NO WARRANTY. 9# Permission to copy, redistribute or otherwise 10# use this file is hereby granted provided that 11# the above copyright notice and this notice are 12# left intact. 13# 14# Please send copies of changes and bug-fixes to: 15# sjg@crufty.net 16# 17 18.ifndef NO_STAGING 19 20.if !target(__${.PARSEFILE}__) 21# the guard target is defined later 22 23.-include <local.meta.stage.mk> 24 25.if ${.MAKE.DEPENDFILE_PREFERENCE:U${.MAKE.DEPENDFILE}:M*.${MACHINE}} != "" 26# this is generally safer anyway 27_dirdep ?= ${RELDIR}.${TARGET_SPEC:U${MACHINE}} 28.else 29_dirdep ?= ${RELDIR} 30.endif 31 32CLEANFILES+= .dirdep 33 34# this allows us to trace dependencies back to their src dir 35.dirdep: .NOPATH 36.if !commands(.dirdep) 37.dirdep: 38 @echo '${_dirdep}' > $@ 39.endif 40 41.if defined(NO_POSIX_SHELL) || ${type printf:L:sh:Mbuiltin} == "" 42_stage_file_basename = `basename $$f` 43_stage_file_dirname = `dirname $$f` 44_stage_target_dirname = `dirname $$t` 45.else 46_stage_file_basename = $${f\#\#*/} 47_stage_file_dirname = $${f%/*} 48_stage_target_dirname = $${t%/*} 49.endif 50 51_OBJROOT ?= ${OBJROOT:U${OBJTOP:H}} 52.if ${_OBJROOT:M*/} != "" 53_objroot ?= ${_OBJROOT:tA}/ 54.else 55_objroot ?= ${_OBJROOT:tA} 56.endif 57 58# make sure this is global 59_STAGED_DIRS ?= 60.export _STAGED_DIRS 61# add each dir we stage to _STAGED_DIRS 62# and make sure we have absolute paths so that bmake 63# will match against .MAKE.META.BAILIWICK 64STAGE_DIR_FILTER = tA:@d@$${_STAGED_DIRS::+=$$d}$$d@ 65# convert _STAGED_DIRS into suitable filters 66GENDIRDEPS_FILTER += Nnot-empty-is-important \ 67 ${_STAGED_DIRS:O:u:M${OBJTOP}*:S,${OBJTOP}/,N,} \ 68 ${_STAGED_DIRS:O:u:M${_objroot}*:N${OBJTOP}*:S,${_objroot},,:C,^([^/]+)/(.*),N\2.\1,:S,${HOST_TARGET},.host,} 69 70LN_CP_SCRIPT = LnCp() { \ 71 rm -f $$2 2> /dev/null; \ 72 { [ -z "$$mode" ] && ${LN:Uln} $$1 $$2 2> /dev/null; } || \ 73 cp -p $$1 $$2 2> /dev/null || cp $$1 $$2; } 74 75# a staging conflict should cause an error 76# a warning is handy when bootstapping different options. 77STAGE_CONFLICT?= ERROR 78.if ${STAGE_CONFLICT:tl} == "error" 79STAGE_CONFLICT_ACTION= exit 1 80.else 81STAGE_CONFLICT_ACTION= 82.endif 83 84# it is an error for more than one src dir to try and stage 85# the same file 86STAGE_DIRDEP_SCRIPT = ${LN_CP_SCRIPT}; StageDirdep() { \ 87 t=$$1; \ 88 if [ -s $$t.dirdep ]; then \ 89 cmp -s .dirdep $$t.dirdep && return; \ 90 x=`cat $$t.dirdep`; \ 91 case "${RELDIR}:${_dirdep}" in \ 92 $${x%.*}:$${x}*) ;; \ 93 *) echo "${STAGE_CONFLICT}: $$t installed by $$x not ${_dirdep}" >&2; \ 94 ${STAGE_CONFLICT_ACTION} ;; \ 95 esac; \ 96 fi; \ 97 LnCp .dirdep $$t.dirdep || exit 1; } 98 99# common logic for staging files 100# this all relies on RELDIR being set to a subdir of SRCTOP 101# we use ln(1) if we can, else cp(1) 102# if --subdir is given the dirname part of each file will be preserved 103STAGE_FILE_SCRIPT = ${STAGE_DIRDEP_SCRIPT}; StageFiles() { \ 104 mode= subdir=; \ 105 while : ; do \ 106 case "$$1" in \ 107 "") return;; \ 108 -m) mode=$$2; shift 2;; \ 109 --subdir) subdir=1; shift;; \ 110 *) break;; \ 111 esac; \ 112 done; \ 113 dest=$$1; shift; \ 114 mkdir -p $$dest; \ 115 [ -s .dirdep ] || echo '${_dirdep}' > .dirdep; \ 116 for f in "$$@"; do \ 117 case "$$subdir,$$f" in \ 118 1,*/*) t=$$dest/$$f; mkdir -p $$dest/${_stage_file_dirname};; \ 119 */*) t=$$dest/${_stage_file_basename};; \ 120 *) t=$$dest/$$f;; \ 121 esac; \ 122 StageDirdep $$t; \ 123 LnCp $$f $$t || exit 1; \ 124 [ -z "$$mode" ] || chmod $$mode $$t; \ 125 done; :; } 126 127STAGE_LINKS_SCRIPT = ${STAGE_DIRDEP_SCRIPT}; StageLinks() { \ 128 case "$$1" in "") return;; --) shift;; -*) ldest= lnf=$$1; shift;; /*) ldest=$$1/;; esac; \ 129 dest=$$1; shift; \ 130 mkdir -p $$dest; \ 131 [ -s .dirdep ] || echo '${_dirdep}' > .dirdep; \ 132 while test $$\# -ge 2; do \ 133 l=$$ldest$$1; shift; \ 134 t=$$dest/$$1; \ 135 case "$$1" in */*) mkdir -p ${_stage_target_dirname};; esac; \ 136 shift; \ 137 StageDirdep $$t; \ 138 rm -f $$t 2>/dev/null; \ 139 ln $$lnf $$l $$t || exit 1; \ 140 done; :; } 141 142STAGE_AS_SCRIPT = ${STAGE_DIRDEP_SCRIPT}; StageAs() { \ 143 case "$$1" in "") return;; -m) mode=$$2; shift 2;; *) mode=;; esac; \ 144 dest=$$1; shift; \ 145 mkdir -p $$dest; \ 146 [ -s .dirdep ] || echo '${_dirdep}' > .dirdep; \ 147 while test $$\# -ge 2; do \ 148 s=$$1; shift; \ 149 t=$$dest/$$1; \ 150 case "$$1" in */*) mkdir -p ${_stage_target_dirname};; esac; \ 151 shift; \ 152 StageDirdep $$t; \ 153 LnCp $$s $$t || exit 1; \ 154 [ -z "$$mode" ] || chmod $$mode $$t; \ 155 done; :; } 156 157# this is simple, a list of the "staged" files depends on this, 158_STAGE_BASENAME_USE: .USE .dirdep ${.TARGET:T} 159 @${STAGE_FILE_SCRIPT}; StageFiles ${.TARGET:H:${STAGE_DIR_FILTER}} ${.TARGET:T} 160 161_STAGE_AS_BASENAME_USE: .USE .dirdep ${.TARGET:T} 162 @${STAGE_AS_SCRIPT}; StageAs ${.TARGET:H:${STAGE_DIR_FILTER}} ${.TARGET:T} ${STAGE_AS_${.TARGET:T}:U${.TARGET:T}} 163 164 165.endif # first time 166 167 168.if !empty(STAGE_INCSDIR) 169.if !empty(STAGE_INCS) 170stage_incs: ${STAGE_INCS:N*\**} 171.endif 172.if target(stage_incs) || !empty(.ALLTARGETS:Mstage_includes) 173STAGE_TARGETS += stage_incs 174STAGE_INCS ?= ${.ALLSRC:N.dirdep:Nstage_*} 175stage_includes: stage_incs 176stage_incs: .dirdep 177 @${STAGE_FILE_SCRIPT}; StageFiles ${STAGE_INCSDIR:${STAGE_DIR_FILTER}} ${STAGE_INCS} 178 @touch $@ 179 180.endif 181.endif 182 183.if !empty(STAGE_LIBDIR) 184.if !empty(STAGE_LIBS) 185stage_libs: ${STAGE_LIBS:N*\**} 186.endif 187.if target(stage_libs) 188STAGE_TARGETS += stage_libs 189STAGE_LIBS ?= ${.ALLSRC:N.dirdep:Nstage_*} 190stage_libs: .dirdep 191 @${STAGE_FILE_SCRIPT}; StageFiles ${STAGE_LIBDIR:${STAGE_DIR_FILTER}} ${STAGE_LIBS} 192.if !defined(NO_SHLIB_LINKS) 193.if !empty(SHLIB_LINKS) 194 @${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_LIBDIR:${STAGE_DIR_FILTER}} \ 195 ${SHLIB_LINKS:@t@${STAGE_LIBS:T:M$t.*:${STAGE_SHLIB_LINKS_FILTER:U}} $t@} 196.elif !empty(SHLIB_LINK) && !empty(SHLIB_NAME) 197 @${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_LIBDIR:${STAGE_DIR_FILTER}} ${SHLIB_NAME} ${SHLIB_LINK} 198.endif 199.endif 200 @touch $@ 201.endif 202.endif 203 204.if !empty(STAGE_DIR) 205STAGE_SETS += _default 206STAGE_DIR._default = ${STAGE_DIR} 207STAGE_LINKS_DIR._default = ${STAGE_LINKS_DIR:U${STAGE_OBJTOP}} 208STAGE_SYMLINKS_DIR._default = ${STAGE_SYMLINKS_DIR:U${STAGE_OBJTOP}} 209STAGE_FILES._default = ${STAGE_FILES} 210STAGE_LINKS._default = ${STAGE_LINKS} 211STAGE_SYMLINKS._default = ${STAGE_SYMLINKS} 212.endif 213 214.if !empty(STAGE_SETS) 215CLEANFILES += ${STAGE_SETS:@s@stage*$s@} 216 217# some makefiles need to populate multiple directories 218.for s in ${STAGE_SETS:O:u} 219.if !empty(STAGE_FILES.$s) 220stage_files.$s: ${STAGE_FILES.$s:N*\**} 221.endif 222.if target(stage_files.$s) || target(stage_files${s:S,^,.,:N._default}) 223STAGE_TARGETS += stage_files 224STAGE_FILES.$s ?= ${.ALLSRC:N.dirdep:Nstage_*} 225.if !target(.stage_files.$s) 226.stage_files.$s: 227.if $s != "_default" 228stage_files: stage_files.$s 229stage_files.$s: .dirdep 230.else 231STAGE_FILES ?= ${.ALLSRC:N.dirdep:Nstage_*} 232stage_files: .dirdep 233.endif 234 @${STAGE_FILE_SCRIPT}; StageFiles ${FLAGS.$@:U} ${STAGE_FILES_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_FILES.$s:O} 235 @touch $@ 236.endif 237.endif 238 239.if !empty(STAGE_LINKS.$s) 240stage_links.$s: 241.endif 242.if target(stage_links.$s) || target(stage_links${s:S,^,.,:N._default}) 243STAGE_LINKS_DIR.$s ?= ${STAGE_OBJTOP} 244STAGE_TARGETS += stage_links 245.if !target(.stage_links.$s) 246.stage_links.$s: 247.if $s != "_default" 248stage_links: stage_links.$s 249stage_links.$s: .dirdep 250.else 251stage_links: .dirdep 252.endif 253 @${STAGE_LINKS_SCRIPT}; StageLinks ${STAGE_LINKS_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_LINKS.$s} 254 @touch $@ 255.endif 256.endif 257 258.if !empty(STAGE_SYMLINKS.$s) 259stage_symlinks.$s: 260.endif 261.if target(stage_symlinks.$s) || target(stage_symlinks${s:S,^,.,:N._default}) 262STAGE_SYMLINKS_DIR.$s ?= ${STAGE_OBJTOP} 263STAGE_TARGETS += stage_symlinks 264.if !target(.stage_symlinks.$s) 265.stage_symlinks.$s: 266.if $s != "_default" 267stage_symlinks: stage_symlinks.$s 268stage_symlinks.$s: .dirdep 269.else 270stage_symlinks: .dirdep 271.endif 272 @${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_SYMLINKS_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_SYMLINKS.$s} 273 @touch $@ 274.endif 275.endif 276 277.endfor 278.endif 279 280.if !empty(STAGE_AS_SETS) 281CLEANFILES += ${STAGE_AS_SETS:@s@stage*$s@} 282 283# sometimes things need to be renamed as they are staged 284# each ${file} will be staged as ${STAGE_AS_${file:T}} 285# one could achieve the same with SYMLINKS 286# stage_as_and_symlink makes the original name (or ${STAGE_LINK_AS_${name}}) 287# a symlink to the new name 288# it is the same as using stage_as and stage_symlinks but ensures 289# both operations happen together 290.for s in ${STAGE_AS_SETS:O:u} 291.if !empty(STAGE_AS.$s) 292stage_as.$s: ${STAGE_AS.$s:N*\**} 293.endif 294.if target(stage_as.$s) 295STAGE_TARGETS += stage_as 296STAGE_AS.$s ?= ${.ALLSRC:N.dirdep:Nstage_*} 297.if !target(.stage_as.$s) 298.stage_as.$s: 299stage_as: stage_as.$s 300stage_as.$s: .dirdep 301 @${STAGE_AS_SCRIPT}; StageAs ${FLAGS.$@} ${STAGE_FILES_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_AS.$s:O:@f@$f ${STAGE_AS_${f:tA}:U${STAGE_AS_${f:T}:U${f:T}}}@} 302 @touch $@ 303.endif 304.endif 305 306.if !empty(STAGE_AS_AND_SYMLINK.$s) 307stage_as_and_symlink.$s: ${STAGE_AS_AND_SYMLINK.$s:N*\**} 308.endif 309.if target(stage_as_and_symlink.$s) 310STAGE_TARGETS += stage_as_and_symlink 311STAGE_AS_AND_SYMLINK.$s ?= ${.ALLSRC:N.dirdep:Nstage_*} 312.if !target(.stage_as_and_symlink.$s) 313.stage_as_and_symlink.$s: 314stage_as_and_symlink: stage_as_and_symlink.$s 315stage_as_and_symlink.$s: .dirdep 316 @${STAGE_AS_SCRIPT}; StageAs ${FLAGS.$@} ${STAGE_FILES_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_AS_AND_SYMLINK.$s:O:@f@$f ${STAGE_AS_${f:tA}:U${STAGE_AS_${f:T}:U${f:T}}}@} 317 @${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_FILES_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_AS_AND_SYMLINK.$s:O:@f@${STAGE_AS_${f:tA}:U${STAGE_AS_${f:T}:U${f:T}}} ${STAGE_LINK_AS_${f}:U$f}@} 318 @touch $@ 319.endif 320.endif 321 322.endfor 323.endif 324 325CLEANFILES += ${STAGE_TARGETS} stage_incs stage_includes 326 327# this lot also only makes sense the first time... 328.if !target(__${.PARSEFILE}__) 329__${.PARSEFILE}__: .NOTMAIN 330 331# stage_*links usually needs to follow any others. 332# for non-jobs mode the order here matters 333staging: ${STAGE_TARGETS:N*_links} ${STAGE_TARGETS:M*_links} 334 335.if ${.MAKE.JOBS:U0} > 0 && ${STAGE_TARGETS:U:M*_links} != "" 336# the above isn't sufficient 337.for t in ${STAGE_TARGETS:N*links:O:u} 338.ORDER: $t stage_links 339.endfor 340.endif 341 342# generally we want staging to wait until everything else is done 343STAGING_WAIT ?= .WAIT 344 345.if ${.MAKE.LEVEL} > 0 346all: ${STAGING_WAIT} staging 347.endif 348 349.if exists(${.PARSEDIR}/stage-install.sh) && !defined(STAGE_INSTALL) 350# this will run install(1) and then followup with .dirdep files. 351STAGE_INSTALL := sh ${.PARSEDIR:tA}/stage-install.sh INSTALL="${INSTALL}" OBJDIR=${.OBJDIR:tA} 352.endif 353 354# if ${INSTALL} gets run during 'all' assume it is for staging? 355.if ${.TARGETS:Nall} == "" && defined(STAGE_INSTALL) 356INSTALL := ${STAGE_INSTALL} 357.if target(beforeinstall) 358beforeinstall: .dirdep 359.endif 360.endif 361.NOPATH: ${STAGE_FILES} 362 363.if !empty(STAGE_TARGETS) 364# for backwards compat make sure they exist 365${STAGE_TARGETS}: 366 367.NOPATH: ${CLEANFILES} 368 369MK_STALE_STAGED?= no 370.if ${MK_STALE_STAGED} == "yes" 371all: stale_staged 372# get a list of paths that we have just staged 373# get a list of paths that we have previously staged to those same dirs 374# anything in the 2nd list but not the first is stale - remove it. 375stale_staged: staging .NOMETA 376 @${EGREP:Uegrep} '^[WL] .*${STAGE_OBJTOP}' /dev/null ${.MAKE.META.FILES:M*stage_*} | \ 377 sed "/\.dirdep/d;s,.* '*\(${STAGE_OBJTOP}/[^ '][^ ']*\).*,\1," | \ 378 sort > ${.TARGET}.staged1 379 @grep -l '${_dirdep}' /dev/null ${_STAGED_DIRS:M${STAGE_OBJTOP}*:O:u:@d@$d/*.dirdep@} | \ 380 sed 's,\.dirdep,,' | sort > ${.TARGET}.staged2 381 @comm -13 ${.TARGET}.staged1 ${.TARGET}.staged2 > ${.TARGET}.stale 382 @test ! -s ${.TARGET}.stale || { \ 383 echo "Removing stale staged files..."; \ 384 sed 's,.*,& &.dirdep,' ${.TARGET}.stale | xargs rm -f; } 385 386.endif 387.endif 388.endif 389.endif 390