< prev index next >

make/common/MakeBase.gmk

Print this page


   1 #
   2 # Copyright (c) 2011, 2019, Oracle and/or its affiliates. All rights reserved.
   3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 #
   5 # This code is free software; you can redistribute it and/or modify it
   6 # under the terms of the GNU General Public License version 2 only, as
   7 # published by the Free Software Foundation.  Oracle designates this
   8 # particular file as subject to the "Classpath" exception as provided
   9 # by Oracle in the LICENSE file that accompanied this code.
  10 #
  11 # This code is distributed in the hope that it will be useful, but WITHOUT
  12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 # version 2 for more details (a copy is included in the LICENSE file that
  15 # accompanied this code).
  16 #
  17 # You should have received a copy of the GNU General Public License version
  18 # 2 along with this work; if not, write to the Free Software Foundation,
  19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20 #
  21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22 # or visit www.oracle.com if you need additional information or have any


  47 
  48 # When calling macros, the spaces between arguments are
  49 # often semantically important! Sometimes we need to subst
  50 # spaces and commas, therefore we need the following macros.
  51 X:=
  52 SPACE:=$(X) $(X)
  53 COMMA:=,
  54 DOLLAR:=$$
  55 HASH:=\#
  56 LEFT_PAREN:=(
  57 RIGHT_PAREN:=)
  58 SQUOTE:='
  59 #'
  60 DQUOTE:="
  61 #"
  62 define NEWLINE
  63 
  64 
  65 endef
  66 
  67 # Certain features only work in newer version of GNU Make. The build will still
  68 # function in 3.81, but will be less performant.
  69 ifeq (4.0, $(firstword $(sort 4.0 $(MAKE_VERSION))))
  70   HAS_FILE_FUNCTION := true
  71   CORRECT_FUNCTION_IN_RECIPE_EVALUATION := true
  72   RWILDCARD_WORKS := true
  73 endif
  74 



  75 
  76 # For convenience, MakeBase.gmk continues to include these separate files, at
  77 # least for now.
  78 
  79 include $(TOPDIR)/make/common/Utils.gmk
  80 include $(TOPDIR)/make/common/MakeIO.gmk
  81 include $(TOPDIR)/make/common/CopyFiles.gmk
  82 
  83 ################################################################################
  84 # Functions for timers
  85 ################################################################################
  86 
  87 # Store the build times in this directory.
  88 BUILDTIMESDIR=$(OUTPUTDIR)/make-support/build-times
  89 
  90 # Record starting time for build of a sub repository.
  91 define RecordStartTime
  92         $(DATE) '+%Y %m %d %H %M %S' | $(NAWK) '{ print $$1,$$2,$$3,$$4,$$5,$$6,($$4*3600+$$5*60+$$6) }' > $(BUILDTIMESDIR)/build_time_start_$(strip $1) && \
  93         $(DATE) '+%Y-%m-%d %H:%M:%S' > $(BUILDTIMESDIR)/build_time_start_$(strip $1)_human_readable
  94 endef
  95 
  96 # Record ending time and calculate the difference and store it in a
  97 # easy to read format. Handles builds that cross midnight. Expects
  98 # that a build will never take 24 hours or more.
  99 define RecordEndTime
 100         $(DATE) '+%Y %m %d %H %M %S' | $(NAWK) '{ print $$1,$$2,$$3,$$4,$$5,$$6,($$4*3600+$$5*60+$$6) }' > $(BUILDTIMESDIR)/build_time_end_$(strip $1)
 101         $(DATE) '+%Y-%m-%d %H:%M:%S' > $(BUILDTIMESDIR)/build_time_end_$(strip $1)_human_readable
 102         $(ECHO) `$(CAT) $(BUILDTIMESDIR)/build_time_start_$(strip $1)` `$(CAT) $(BUILDTIMESDIR)/build_time_end_$(strip $1)` $1 | \
 103             $(NAWK) '{ F=$$7; T=$$14; if (F > T) { T+=3600*24 }; D=T-F; H=int(D/3600); \
 104             M=int((D-H*3600)/60); S=D-H*3600-M*60; printf("%02d:%02d:%02d %s\n",H,M,S,$$15); }' \
 105             > $(BUILDTIMESDIR)/build_time_diff_$(strip $1)
 106 endef
 107 
 108 # Hook to be called when starting to execute a top-level target
 109 define TargetEnter
 110         $(PRINTF) "## Starting $(patsubst %-only,%,$@)\n"
 111         $(call RecordStartTime,$(patsubst %-only,%,$@))
 112 endef
 113 
 114 # Hook to be called when finish executing a top-level target
 115 define TargetExit
 116         $(call RecordEndTime,$(patsubst %-only,%,$@))
 117         $(PRINTF) "## Finished $(patsubst %-only,%,$@) (build time %s)\n\n" \
 118             "`$(CAT) $(BUILDTIMESDIR)/build_time_diff_$(patsubst %-only,%,$@) | $(CUT) -f 1 -d ' '`"
 119 endef
 120 
 121 ################################################################################





























































































































































































































 122 
 123 # A file containing a way to uniquely identify the source code revision that
 124 # the build was created from
 125 SOURCE_REVISION_TRACKER := $(SUPPORT_OUTPUTDIR)/src-rev/source-revision-tracker
 126 
 127 # Locate all hg repositories included in the forest, as absolute paths
 128 FindAllReposAbs = \
 129     $(strip $(sort $(dir $(filter-out $(TOPDIR)/build/%, $(wildcard \
 130         $(addprefix $(TOPDIR)/, .hg */.hg */*/.hg */*/*/.hg */*/*/*/.hg) \
 131         $(addprefix $(TOPDIR)/, .git */.git */*/.git */*/*/.git */*/*/*/.git) \
 132     )))))
 133 
 134 # Locate all hg repositories included in the forest, as relative paths
 135 FindAllReposRel = \
 136     $(strip $(subst $(TOPDIR)/,.,$(patsubst $(TOPDIR)/%/, %, $(FindAllReposAbs))))
 137 
 138 ################################################################################
 139 
 140 define SetupLogging
 141   ifeq ($$(LOG_PROFILE_TIMES_FILE), true)


 143       SHELL :=  $$(BASH) $$(TOPDIR)/make/scripts/shell-profiler.sh \
 144                 gnutime $$(TIME) \
 145                 $$(OUTPUTDIR)/build-profile.log $$(SHELL)
 146     else ifneq ($$(FLOCK), )
 147       SHELL :=  $$(BASH) $$(TOPDIR)/make/scripts/shell-profiler.sh \
 148                 flock $$(FLOCK) \
 149                 $$(OUTPUTDIR)/build-profile.log $$(SHELL)
 150     endif
 151   endif
 152 
 153   ifeq ($$(LOG_LEVEL), trace)
 154     SHELL_NO_RECURSE := $$(SHELL)
 155     # Shell redefinition trick inspired by http://www.cmcrossroads.com/ask-mr-make/6535-tracing-rule-execution-in-gnu-make
 156     # For each target executed, will print
 157     # Building <TARGET> (from <FIRST PREREQUISITE>) (<ALL NEWER PREREQUISITES> newer)
 158     # but with a limit of 20 on <ALL NEWER PREREQUISITES>, to avoid cluttering logs too much
 159     # (and causing a crash on Cygwin).
 160     SHELL = $$(warning $$(if $$@,Building $$@,Running shell command) $$(if $$<, (from $$<))$$(if $$?, ($$(wordlist 1, 20, $$?) $$(if $$(wordlist 21, 22, $$?), ... [in total $$(words $$?) files]) newer)))$$(SHELL_NO_RECURSE) -x
 161   endif
 162 
 163   # The LOG_PREFIX is set for sub recursive calls like buildjdk and bootcycle.
 164   # The warn level can never be turned off
 165   LogWarn = $$(info $(LOG_PREFIX)$$(strip $$1))
 166   LOG_WARN :=
 167   ifneq ($$(findstring $$(LOG_LEVEL), info debug trace),)
 168     LogInfo = $$(info $(LOG_PREFIX)$$(strip $$1))
 169     LOG_INFO :=
 170   else
 171     LogInfo =
 172     LOG_INFO := > /dev/null
 173   endif
 174   ifneq ($$(findstring $$(LOG_LEVEL), debug trace),)
 175     LogDebug = $$(info $(LOG_PREFIX)$$(strip $$1))
 176     LOG_DEBUG :=
 177   else
 178     LogDebug =
 179     LOG_DEBUG := > /dev/null
 180   endif
 181   ifneq ($$(findstring $$(LOG_LEVEL), trace),)
 182     LogTrace = $$(info $(LOG_PREFIX)$$(strip $$1))
 183     LOG_TRACE :=
 184   else
 185     LogTrace =
 186     LOG_TRACE := > /dev/null
 187   endif
 188 endef
 189 
 190 # Make sure logging is setup for everyone that includes MakeBase.gmk.
 191 $(eval $(call SetupLogging))
 192 
 193 ################################################################################















 194 
 195 MAX_PARAMS := 36
 196 PARAM_SEQUENCE := $(call sequence, 2, $(MAX_PARAMS))
 197 
 198 # Template for creating a macro taking named parameters. To use it, assign the
 199 # template to a variable with the name you want for your macro, using '='
 200 # assignment. Then define a macro body with the suffix "Body". The Body macro
 201 # should take 1 parameter which should be a unique string for that invocation
 202 # of the macro.
 203 # Ex:
 204 # SetupFoo = $(NamedParamsMacroTemplate)
 205 # define SetupFooBody
 206 #   # do something
 207 #   # access parameters as $$($1_BAR)
 208 # endef
 209 # Call it like this
 210 # $(eval $(call SetupFoo, BUILD_SOMETHING, \
 211 #     BAR := some parameter value, \
 212 # ))
 213 define NamedParamsMacroTemplate


 215       Too many named arguments to macro, please update MAX_PARAMS in MakeBase.gmk))
 216   # Iterate over 2 3 4... and evaluate the named parameters with $1_ as prefix
 217   $(foreach i,$(PARAM_SEQUENCE), $(if $(strip $($i)),\
 218     $(strip $1)_$(strip $(call EscapeHash, $(call DoubleDollar, $($i))))$(NEWLINE)))
 219   # Debug print all named parameter names and values
 220   $(if $(findstring $(LOG_LEVEL),debug trace), \
 221     $(info $0 $(strip $1) $(foreach i,$(PARAM_SEQUENCE), \
 222       $(if $(strip $($i)),$(NEWLINE) $(strip [$i] $(if $(filter $(LOG_LEVEL), trace), \
 223         $($i), $(wordlist 1, 20, $($(i))) $(if $(word 21, $($(i))), ...)))))))
 224 
 225   $(if $(DEBUG_$(strip $1)),
 226     $(info -------- <<< Begin expansion of $(strip $1)) \
 227     $(info $(call $(0)Body,$(strip $1))) \
 228     $(info -------- >>> End expansion of $(strip $1)) \
 229   )
 230 
 231   $(call $(0)Body,$(strip $1))
 232 endef
 233 
 234 ################################################################################










 235 # Make directory without forking mkdir if not needed.
 236 #
 237 # If a directory with an encoded space is provided, the wildcard function
 238 # sometimes returns false answers (typically if the dir existed when the
 239 # makefile was parsed, but was deleted by a previous rule). In that case, always
 240 # call mkdir regardless of what wildcard says.
 241 #
 242 # 1: List of directories to create
 243 MakeDir = \
 244     $(strip \
 245         $(eval MakeDir_dirs_to_make := $(strip $(foreach d, $1, \
 246           $(if $(findstring ?, $d), '$(call DecodeSpace, $d)', \
 247             $(if $(wildcard $d), , $d) \
 248           ) \
 249         ))) \
 250         $(if $(MakeDir_dirs_to_make), $(shell $(MKDIR) -p $(MakeDir_dirs_to_make))) \
 251     )
 252 
 253 # Make directory for target file. Should handle spaces in filenames. Just
 254 # calling $(call MakeDir $(@D)) will not work if the directory contains a space
 255 # and the target file already exists. In that case, the target file will have
 256 # its wildcard ? resolved and the $(@D) will evaluate each space separated dir
 257 # part on its own.
 258 MakeTargetDir = \
 259     $(call MakeDir, $(dir $(call EncodeSpace, $@)))
 260 
 261 ################################################################################







 262 # All install-file and related macros automatically call DecodeSpace when needed.
 263 
 264 ifeq ($(call isTargetOs, solaris), true)
 265   # On Solaris, if the target is a symlink and exists, cp won't overwrite.
 266   # Cp has to operate in recursive mode to allow for -P flag, to preserve soft links. If the
 267   # name of the target file differs from the source file, rename after copy.
 268   # If the source and target parent directories are the same, recursive copy doesn't work
 269   # so we fall back on regular copy, which isn't preserving symlinks.
 270   define install-file
 271         $(call MakeTargetDir)
 272         $(RM) '$(call DecodeSpace, $@)'
 273         if [ '$(call DecodeSpace, $(dir $(call EncodeSpace, $@)))' != \
 274             '$(call DecodeSpace, $(dir $(call EncodeSpace, $<)))' ]; then \
 275           $(CP) -f -r -P '$(call DecodeSpace, $<)' \
 276               '$(call DecodeSpace, $(dir $(call EncodeSpace, $@)))'; \
 277           if [ '$(call DecodeSpace, $(notdir $(call EncodeSpace, $@)))' != \
 278               '$(call DecodeSpace, $(notdir $(call EncodeSpace, $(<))))' ]; then \
 279             $(MV) '$(call DecodeSpace, $(dir $(call EncodeSpace, $@))/$(notdir $(call EncodeSpace, $<)))' \
 280                 '$(call DecodeSpace, $@)'; \
 281           fi; \
 282         else \
 283           if [ -L '$(call DecodeSpace, $<)' ]; then \
 284             $(ECHO) "Source file is a symlink and target is in the same directory: $< $@" ; \
 285             exit 1; \
 286           fi; \
 287           $(CP) -f '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'; \
 288         fi
 289   endef
 290 else ifeq ($(call isTargetOs, macosx), true)
 291   # On mac, extended attributes sometimes creep into the source files, which may later
 292   # cause the creation of ._* files which confuses testing. Clear these with xattr if
 293   # set. Some files get their write permissions removed after being copied to the
 294   # output dir. When these are copied again to images, xattr would fail. By only clearing
 295   # attributes when they are present, failing on this is avoided.
 296   #
 297   # If copying a soft link to a directory, need to delete the target first to avoid
 298   # weird errors.
 299   define install-file
 300         $(call MakeTargetDir)
 301         $(RM) '$(call DecodeSpace, $@)'
 302         # Work around a weirdness with cp on Macosx. When copying a symlink, if
 303         # the target of the link is write protected (e.g. 444), cp will add
 304         # write permission for the user on the target file (644). Avoid this by
 305         # using ln to create a new link instead.
 306         if [ -h '$(call DecodeSpace, $<)' ]; then \
 307           $(LN) -s "`$(READLINK) '$(call DecodeSpace, $<)'`" '$(call DecodeSpace, $@)'; \
 308         else \
 309           $(CP) -fRP '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'; \
 310         fi
 311         if [ -n "`$(XATTR) -ls '$(call DecodeSpace, $@)'`" ]; then \
 312           $(XATTR) -cs '$(call DecodeSpace, $@)'; \
 313         fi
 314   endef
 315 else
 316   define install-file
 317         $(call MakeTargetDir)
 318         $(CP) -fP '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'
 319   endef
 320 endif
 321 
 322 # Variant of install file that does not preserve symlinks
 323 define install-file-nolink
 324         $(call MakeTargetDir)
 325         $(CP) -f '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'
 326 endef
 327 
 328 ################################################################################








































 329 # link-file-* works similarly to install-file but creates a symlink instead.
 330 # There are two versions, either creating a relative or an absolute link. Be
 331 # careful when using this on Windows since the symlink created is only valid in
 332 # the unix emulation environment.
 333 define link-file-relative
 334         $(call MakeTargetDir)
 335         $(RM) '$(call DecodeSpace, $@)'
 336         $(LN) -s '$(call DecodeSpace, $(call RelativePath, $<, $(@D)))' '$(call DecodeSpace, $@)'
 337 endef
 338 
 339 define link-file-absolute
 340         $(call MakeTargetDir)
 341         $(RM) '$(call DecodeSpace, $@)'
 342         $(LN) -s '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'
 343 endef
 344 
 345 ################################################################################
 346 
 347 # Recursive wildcard function. Walks down directories recursively and matches
 348 # files with the search patterns. Patterns use standard file wildcards (* and
 349 # ?).
 350 #
 351 # $1 - Directories to start search in
 352 # $2 - Search patterns
 353 rwildcard = \
 354     $(strip \
 355         $(foreach d, \
 356           $(patsubst %/,%,$(sort $(dir $(wildcard $(addsuffix /*/*, $(strip $1)))))), \
 357           $(call rwildcard,$d,$2) \
 358         ) \
 359         $(call DoubleDollar, $(wildcard $(foreach p, $2, $(addsuffix /$(strip $p), $(strip $1))))) \














 360     )
 361 
 362 # Find non directories using recursive wildcard function. This function may
 363 # be used directly when a small amount of directories is expected to be
 364 # searched and caching is not expected to be of use.
 365 #
 366 # $1 - Directory to start search in
 367 # $2 - Optional search patterns, defaults to '*'.
 368 WildcardFindFiles = \
 369     $(sort $(strip \
 370         $(eval WildcardFindFiles_result := $(call rwildcard,$(patsubst %/,%,$1),$(if $(strip $2),$2,*))) \
 371         $(filter-out $(patsubst %/,%,$(sort $(dir $(WildcardFindFiles_result)))), \
 372             $(WildcardFindFiles_result) \
 373         ) \
 374     ))










 375 
 376 # Find non directories using the find utility in the shell. Safe to call for
 377 # non existing directories, or directories containing wildcards.
 378 #
 379 # Files containing space will get spaces replaced with ? because GNU Make
 380 # cannot handle lists of files with space in them. By using ?, make will match
 381 # the wildcard to space in many situations so we don't need to replace back
 382 # to space on every use. While not a complete solution it does allow some uses
 383 # of FindFiles to function with spaces in file names, including for
 384 # SetupCopyFiles. Unfortunately this does not work for WildcardFindFiles so
 385 # if files with spaces are anticipated, use ShellFindFiles directly.
 386 #
 387 # $1 - Directories to start search in.
 388 # $2 - Optional search patterns, empty means find everything. Patterns use
 389 #      standard file wildcards (* and ?) and should not be quoted.
 390 # $3 - Optional options to find.
 391 ShellFindFiles = \
 392     $(if $(wildcard $1), \
 393       $(sort \
 394           $(shell $(FIND) $3 $(patsubst %/,%,$(wildcard $1)) \( -type f -o -type l \) \
 395               $(if $(strip $2), -a \( -name "$(firstword $2)" \
 396               $(foreach p, $(filter-out $(firstword $2), $2), -o -name "$(p)") \)) \
 397               | $(TR) ' ' '?' \
 398           ) \
 399       ) \
 400     )


































 401 
 402 # Find non directories using the method most likely to work best for the
 403 # current build host
 404 #
 405 # $1 - Directory to start search in
 406 # $2 - Optional search patterns, defaults to '*'.
 407 ifeq ($(OPENJDK_BUILD_OS)-$(RWILDCARD_WORKS), windows-true)
 408   DirectFindFiles = $(WildcardFindFiles)
 409 else
 410   DirectFindFiles = $(ShellFindFiles)







 411 endif
 412 
 413 # Finds files using a cache that is populated by FillFindCache below. If any of
 414 # the directories given have not been cached, DirectFindFiles is used for
 415 # everything. Caching is especially useful in Cygwin, where file finds are very
 416 # costly.
 417 #
 418 # $1 - Directories to start search in.
 419 # $2 - Optional search patterns. If used, no caching is done.
 420 CacheFindFiles_CACHED_DIRS :=
 421 CacheFindFiles_CACHED_FILES :=
 422 CacheFindFiles = \
 423     $(if $2, \
 424       $(call DirectFindFiles, $1, $2) \
 425     , \
 426       $(if $(filter-out $(addsuffix /%, $(CacheFindFiles_CACHED_DIRS)) \
 427           $(CacheFindFiles_CACHED_DIRS), $1), \
 428         $(call DirectFindFiles, $1) \
 429       , \
 430         $(filter $(addsuffix /%,$(patsubst %/,%,$1)) $1,$(CacheFindFiles_CACHED_FILES)) \










































































































 431       ) \
 432     )


 433 
 434 # Explicitly adds files to the find cache used by CacheFindFiles.

 435 #
 436 # $1 - Directories to start search in
 437 FillFindCache = \
 438     $(eval CacheFindFiles_NEW_DIRS := $$(filter-out $$(addsuffix /%,\
 439         $$(CacheFindFiles_CACHED_DIRS)) $$(CacheFindFiles_CACHED_DIRS), $1)) \
 440     $(if $(CacheFindFiles_NEW_DIRS), \
 441       $(eval CacheFindFiles_CACHED_DIRS += $$(patsubst %/,%,$$(CacheFindFiles_NEW_DIRS))) \
 442       $(eval CacheFindFiles_CACHED_FILES := $$(sort $$(CacheFindFiles_CACHED_FILES) \
 443           $$(call DirectFindFiles, $$(CacheFindFiles_NEW_DIRS)))) \
 444     )
 445 
 446 # Findfiles is the default macro that should be used to find files in the file
 447 # system. This function does not always support files with spaces in the names.
 448 # If files with spaces are anticipated, use ShellFindFiles directly.
 449 #
 450 # $1 - Directories to start search in.
 451 # $2 - Optional search patterns, empty means find everything. Patterns use
 452 #      standard file wildcards (* and ?) and should not be quoted.
 453 ifeq ($(DISABLE_CACHE_FIND), true)
 454   FindFiles = $(DirectFindFiles)
 455 else
 456   FindFiles = $(CacheFindFiles)
 457 endif
 458 
 459 ################################################################################
 460 # FixPath
 461 #
 462 # On Windows, converts a path from cygwin/unix style (e.g. /bin/foo) into
 463 # "mixed mode" (e.g. c:/cygwin/bin/foo). On other platforms, return the path
 464 # unchanged.
 465 # This is normally not needed since we use the FIXPATH prefix for command lines,
 466 # but might be needed in certain circumstances.
 467 ifeq ($(call isTargetOs, windows), true)
 468   FixPath = \
 469       $(shell $(CYGPATH) -m $1)
 470 else
 471   FixPath = \
 472       $1
 473 endif
 474 
 475 ################################################################################
 476 # FixPathList
 477 #
 478 # On Windows, converts a cygwin/unix style path list (colon-separated) into
 479 # the native format (mixed mode, semicolon-separated). On other platforms,
 480 # return the path list unchanged.
 481 ################################################################################
 482 ifeq ($(call isTargetOs, windows), true)
 483   FixPathList = \
 484       $(subst @,$(SPACE),$(subst $(SPACE),;,$(foreach entry,$(subst :,$(SPACE),\
 485       $(subst $(SPACE),@,$(strip $1))),$(call FixPath, $(entry)))))

 486 else
 487   FixPathList = \
 488       $1












 489 endif
 490 
 491 ################################################################################
 492 # DependOnVariable
 493 #
 494 # This macro takes a variable name and puts the value in a file only if the
 495 # value has changed since last. The name of the file is returned. This can be
 496 # used to create rule dependencies on make variable values. The following
 497 # example would get rebuilt if the value of SOME_VAR was changed:
 498 #
 499 # path/to/some-file: $(call DependOnVariable, SOME_VAR)
 500 #         echo $(SOME_VAR) > $@
 501 #
 502 # Note that leading and trailing white space in the value is ignored.
 503 #
 504 
 505 # Defines the sub directory structure to store variable value file in
 506 DependOnVariableDirName = \
 507     $(strip $(addsuffix $(if $(MODULE),/$(MODULE)), \
 508         $(subst $(TOPDIR)/,, $(if $(filter /%, $(firstword $(MAKEFILE_LIST))), \


 555 # The output is stored in a specified log file, which is displayed at the end
 556 # of the build in case of failure. The  command line itself is stored in a file,
 557 # and also logged to stdout if the LOG=cmdlines option has been given.
 558 #
 559 # NOTE: If the command redirects stdout, the caller needs to wrap it in a
 560 # subshell (by adding parentheses around it), otherwise the redirect to the
 561 # subshell tee process will create a race condition where the target file may
 562 # not be fully written when the make recipe is done.
 563 #
 564 # Param 1 - The path to base the name of the log file / command line file on
 565 # Param 2 - The command to run
 566 ExecuteWithLog = \
 567   $(call LogCmdlines, Exececuting: [$(strip $2)]) \
 568   $(call MakeDir, $(dir $(strip $1))) \
 569   $(call WriteFile, $2, $(strip $1).cmdline) \
 570   ( $(RM) $(strip $1).log && $(strip $2) > >($(TEE) -a $(strip $1).log) 2> >($(TEE) -a $(strip $1).log >&2) || \
 571       ( exitcode=$(DOLLAR)? && \
 572       $(CP) $(strip $1).log $(MAKESUPPORT_OUTPUTDIR)/failure-logs/$(subst /,_,$(patsubst $(OUTPUTDIR)/%,%,$(strip $1))).log && \
 573       $(CP) $(strip $1).cmdline $(MAKESUPPORT_OUTPUTDIR)/failure-logs/$(subst /,_,$(patsubst $(OUTPUTDIR)/%,%,$(strip $1))).cmdline && \
 574       exit $(DOLLAR)exitcode ) )





































































 575 
 576 ################################################################################
 577 
 578 # Hook to include the corresponding custom file, if present.
 579 $(eval $(call IncludeCustomExtension, common/MakeBase.gmk))
 580 
 581 endif # _MAKEBASE_GMK
   1 #
   2 # Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
   3 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4 #
   5 # This code is free software; you can redistribute it and/or modify it
   6 # under the terms of the GNU General Public License version 2 only, as
   7 # published by the Free Software Foundation.  Oracle designates this
   8 # particular file as subject to the "Classpath" exception as provided
   9 # by Oracle in the LICENSE file that accompanied this code.
  10 #
  11 # This code is distributed in the hope that it will be useful, but WITHOUT
  12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 # version 2 for more details (a copy is included in the LICENSE file that
  15 # accompanied this code).
  16 #
  17 # You should have received a copy of the GNU General Public License version
  18 # 2 along with this work; if not, write to the Free Software Foundation,
  19 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20 #
  21 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22 # or visit www.oracle.com if you need additional information or have any


  47 
  48 # When calling macros, the spaces between arguments are
  49 # often semantically important! Sometimes we need to subst
  50 # spaces and commas, therefore we need the following macros.
  51 X:=
  52 SPACE:=$(X) $(X)
  53 COMMA:=,
  54 DOLLAR:=$$
  55 HASH:=\#
  56 LEFT_PAREN:=(
  57 RIGHT_PAREN:=)
  58 SQUOTE:='
  59 #'
  60 DQUOTE:="
  61 #"
  62 define NEWLINE
  63 
  64 
  65 endef
  66 
  67 # In GNU Make 4.0 and higher, there is a file function for writing to files.

  68 ifeq (4.0, $(firstword $(sort 4.0 $(MAKE_VERSION))))
  69   HAS_FILE_FUNCTION := true
  70   CORRECT_FUNCTION_IN_RECIPE_EVALUATION := true

  71 endif
  72 
  73 ##############################
  74 # Functions
  75 ##############################
  76 
  77 ### Debug functions

  78 
  79 # Prints the name and value of a variable
  80 PrintVar = \
  81     $(info $(strip $1) >$($(strip $1))<)
  82 
  83 ### Functions for timers


  84 
  85 # Store the build times in this directory.
  86 BUILDTIMESDIR=$(OUTPUTDIR)/make-support/build-times
  87 
  88 # Record starting time for build of a sub repository.
  89 define RecordStartTime
  90         $(DATE) '+%Y %m %d %H %M %S' | $(NAWK) '{ print $$1,$$2,$$3,$$4,$$5,$$6,($$4*3600+$$5*60+$$6) }' > $(BUILDTIMESDIR)/build_time_start_$(strip $1) && \
  91         $(DATE) '+%Y-%m-%d %H:%M:%S' > $(BUILDTIMESDIR)/build_time_start_$(strip $1)_human_readable
  92 endef
  93 
  94 # Record ending time and calculate the difference and store it in a
  95 # easy to read format. Handles builds that cross midnight. Expects
  96 # that a build will never take 24 hours or more.
  97 define RecordEndTime
  98         $(DATE) '+%Y %m %d %H %M %S' | $(NAWK) '{ print $$1,$$2,$$3,$$4,$$5,$$6,($$4*3600+$$5*60+$$6) }' > $(BUILDTIMESDIR)/build_time_end_$(strip $1)
  99         $(DATE) '+%Y-%m-%d %H:%M:%S' > $(BUILDTIMESDIR)/build_time_end_$(strip $1)_human_readable
 100         $(ECHO) `$(CAT) $(BUILDTIMESDIR)/build_time_start_$(strip $1)` `$(CAT) $(BUILDTIMESDIR)/build_time_end_$(strip $1)` $1 | \
 101             $(NAWK) '{ F=$$7; T=$$14; if (F > T) { T+=3600*24 }; D=T-F; H=int(D/3600); \
 102             M=int((D-H*3600)/60); S=D-H*3600-M*60; printf("%02d:%02d:%02d %s\n",H,M,S,$$15); }' \
 103             > $(BUILDTIMESDIR)/build_time_diff_$(strip $1)
 104 endef
 105 
 106 # Hook to be called when starting to execute a top-level target
 107 define TargetEnter
 108         $(PRINTF) "## Starting $(patsubst %-only,%,$@)\n"
 109         $(call RecordStartTime,$(patsubst %-only,%,$@))
 110 endef
 111 
 112 # Hook to be called when finish executing a top-level target
 113 define TargetExit
 114         $(call RecordEndTime,$(patsubst %-only,%,$@))
 115         $(PRINTF) "## Finished $(patsubst %-only,%,$@) (build time %s)\n\n" \
 116             "`$(CAT) $(BUILDTIMESDIR)/build_time_diff_$(patsubst %-only,%,$@) | $(CUT) -f 1 -d ' '`"
 117 endef
 118 
 119 ################################################################################
 120 # This macro translates $ into \$ to protect the $ from expansion in the shell.
 121 # To make this macro resilient against already escaped strings, first remove
 122 # any present escapes before escaping so that no double escapes are added.
 123 EscapeDollar = $(subst $$,\$$,$(subst \$$,$$,$(strip $1)))
 124 
 125 ################################################################################
 126 # This macro works just like EscapeDollar above, but for #.
 127 EscapeHash = $(subst \#,\\\#,$(subst \\\#,\#,$(strip $1)))
 128 
 129 ################################################################################
 130 # This macro translates $ into $$ to protect the string from make itself.
 131 DoubleDollar = $(subst $$,$$$$,$(strip $1))
 132 
 133 ################################################################################
 134 # ListPathsSafely can be used to print command parameters to a file. This is
 135 # typically done if the command line lenght risk being too long for the
 136 # OS/shell. In later make versions, the file function can be used for this
 137 # purpose. For earlier versions, a more complex implementation is provided.
 138 #
 139 # The function ListPathsSafely can be called either directly or, more commonly
 140 # from a recipe line. If called from a recipe, it will be executed in the
 141 # evaluation phase of that recipe, which means that it will write to the file
 142 # before any other line in the recipe has been run.
 143 ifeq ($(HAS_FILE_FUNCTION), true)
 144   # Param 1 - Name of variable containing paths/arguments to output
 145   # Param 2 - File to print to
 146   # Param 3 - Set to true to append to file instead of overwriting
 147   define ListPathsSafely
 148     $$(call MakeDir, $$(dir $$(strip $2)))
 149     $$(file $$(if $$(filter true, $$(strip $3)),>>,>) \
 150         $$(strip $2),$$(subst $$(SPACE),$$(NEWLINE),$$(strip $$($$(strip $1)))))
 151   endef
 152 
 153 else # HAS_FILE_FUNCTION = false
 154 
 155   $(eval compress_paths = \
 156       $(strip $(shell $(CAT) $(TOPDIR)/make/common/support/ListPathsSafely-pre-compress.incl)))
 157   compress_paths += \
 158       $(subst $(TOPDIR),X97, \
 159       $(subst $(OUTPUTDIR),X98, \
 160       $(subst X,X00, \
 161       $(subst $(SPACE),\n,$(strip $1)))))
 162   $(eval compress_paths += \
 163       $(strip $(shell $(CAT) $(TOPDIR)/make/common/support/ListPathsSafely-post-compress.incl)))
 164 
 165   decompress_paths=$(SED) -f $(TOPDIR)/make/common/support/ListPathsSafely-uncompress.sed \
 166       -e 's|X99|\\n|g' \
 167       -e 's|X98|$(OUTPUTDIR)|g' -e 's|X97|$(TOPDIR)|g' \
 168       -e 's|X00|X|g'
 169 
 170   ListPathsSafely_IfPrintf = \
 171       $(if $(word $3,$($(strip $1))), \
 172           $(shell $(PRINTF) -- "$(strip $(call EscapeDollar, \
 173               $(call compress_paths, $(wordlist $3,$4,$($(strip $1))))))\n" \
 174               | $(decompress_paths) >> $2))
 175 
 176   # Param 1 - Name of variable containing paths/arguments to output
 177   # Param 2 - File to print to
 178   # Param 3 - Set to true to append to file instead of overwriting
 179   define ListPathsSafely
 180     ifneq (,$$(word 30001,$$($$(strip $1))))
 181       $$(error Cannot list safely more than 30000 paths. $1 has $$(words $$($$(strip $1))) paths!)
 182     endif
 183     $$(call MakeDir, $$(dir $2))
 184     ifneq ($$(strip $3), true)
 185       $$(shell $(RM) $$(strip $2))
 186     endif
 187 
 188     $$(call ListPathsSafely_IfPrintf,$1,$2,1,250)
 189     $$(call ListPathsSafely_IfPrintf,$1,$2,251,500)
 190     $$(call ListPathsSafely_IfPrintf,$1,$2,501,750)
 191     $$(call ListPathsSafely_IfPrintf,$1,$2,751,1000)
 192 
 193     $$(call ListPathsSafely_IfPrintf,$1,$2,1001,1250)
 194     $$(call ListPathsSafely_IfPrintf,$1,$2,1251,1500)
 195     $$(call ListPathsSafely_IfPrintf,$1,$2,1501,1750)
 196     $$(call ListPathsSafely_IfPrintf,$1,$2,1751,2000)
 197 
 198     $$(call ListPathsSafely_IfPrintf,$1,$2,2001,2250)
 199     $$(call ListPathsSafely_IfPrintf,$1,$2,2251,2500)
 200     $$(call ListPathsSafely_IfPrintf,$1,$2,2501,2750)
 201     $$(call ListPathsSafely_IfPrintf,$1,$2,2751,3000)
 202 
 203     $$(call ListPathsSafely_IfPrintf,$1,$2,3001,3250)
 204     $$(call ListPathsSafely_IfPrintf,$1,$2,3251,3500)
 205     $$(call ListPathsSafely_IfPrintf,$1,$2,3501,3750)
 206     $$(call ListPathsSafely_IfPrintf,$1,$2,3751,4000)
 207 
 208     $$(call ListPathsSafely_IfPrintf,$1,$2,4001,4250)
 209     $$(call ListPathsSafely_IfPrintf,$1,$2,4251,4500)
 210     $$(call ListPathsSafely_IfPrintf,$1,$2,4501,4750)
 211     $$(call ListPathsSafely_IfPrintf,$1,$2,4751,5000)
 212 
 213     $$(call ListPathsSafely_IfPrintf,$1,$2,5001,5250)
 214     $$(call ListPathsSafely_IfPrintf,$1,$2,5251,5500)
 215     $$(call ListPathsSafely_IfPrintf,$1,$2,5501,5750)
 216     $$(call ListPathsSafely_IfPrintf,$1,$2,5751,6000)
 217 
 218     $$(call ListPathsSafely_IfPrintf,$1,$2,6001,6250)
 219     $$(call ListPathsSafely_IfPrintf,$1,$2,6251,6500)
 220     $$(call ListPathsSafely_IfPrintf,$1,$2,6501,6750)
 221     $$(call ListPathsSafely_IfPrintf,$1,$2,6751,7000)
 222 
 223     $$(call ListPathsSafely_IfPrintf,$1,$2,7001,7250)
 224     $$(call ListPathsSafely_IfPrintf,$1,$2,7251,7500)
 225     $$(call ListPathsSafely_IfPrintf,$1,$2,7501,7750)
 226     $$(call ListPathsSafely_IfPrintf,$1,$2,7751,8000)
 227 
 228     $$(call ListPathsSafely_IfPrintf,$1,$2,8001,8250)
 229     $$(call ListPathsSafely_IfPrintf,$1,$2,8251,8500)
 230     $$(call ListPathsSafely_IfPrintf,$1,$2,8501,8750)
 231     $$(call ListPathsSafely_IfPrintf,$1,$2,8751,9000)
 232 
 233     $$(call ListPathsSafely_IfPrintf,$1,$2,9001,9250)
 234     $$(call ListPathsSafely_IfPrintf,$1,$2,9251,9500)
 235     $$(call ListPathsSafely_IfPrintf,$1,$2,9501,9750)
 236     $$(call ListPathsSafely_IfPrintf,$1,$2,9751,10000)
 237 
 238     $$(call ListPathsSafely_IfPrintf,$1,$2,10001,10250)
 239     $$(call ListPathsSafely_IfPrintf,$1,$2,10251,10500)
 240     $$(call ListPathsSafely_IfPrintf,$1,$2,10501,10750)
 241     $$(call ListPathsSafely_IfPrintf,$1,$2,10751,11000)
 242 
 243     $$(call ListPathsSafely_IfPrintf,$1,$2,11001,11250)
 244     $$(call ListPathsSafely_IfPrintf,$1,$2,11251,11500)
 245     $$(call ListPathsSafely_IfPrintf,$1,$2,11501,11750)
 246     $$(call ListPathsSafely_IfPrintf,$1,$2,11751,12000)
 247 
 248     $$(call ListPathsSafely_IfPrintf,$1,$2,12001,12250)
 249     $$(call ListPathsSafely_IfPrintf,$1,$2,12251,12500)
 250     $$(call ListPathsSafely_IfPrintf,$1,$2,12501,12750)
 251     $$(call ListPathsSafely_IfPrintf,$1,$2,12751,13000)
 252 
 253     $$(call ListPathsSafely_IfPrintf,$1,$2,13001,13250)
 254     $$(call ListPathsSafely_IfPrintf,$1,$2,13251,13500)
 255     $$(call ListPathsSafely_IfPrintf,$1,$2,13501,13750)
 256     $$(call ListPathsSafely_IfPrintf,$1,$2,13751,14000)
 257 
 258     $$(call ListPathsSafely_IfPrintf,$1,$2,14001,14250)
 259     $$(call ListPathsSafely_IfPrintf,$1,$2,14251,14500)
 260     $$(call ListPathsSafely_IfPrintf,$1,$2,14501,14750)
 261     $$(call ListPathsSafely_IfPrintf,$1,$2,14751,15000)
 262 
 263     $$(call ListPathsSafely_IfPrintf,$1,$2,15001,15250)
 264     $$(call ListPathsSafely_IfPrintf,$1,$2,15251,15500)
 265     $$(call ListPathsSafely_IfPrintf,$1,$2,15501,15750)
 266     $$(call ListPathsSafely_IfPrintf,$1,$2,15751,16000)
 267 
 268     $$(call ListPathsSafely_IfPrintf,$1,$2,16001,16250)
 269     $$(call ListPathsSafely_IfPrintf,$1,$2,16251,16500)
 270     $$(call ListPathsSafely_IfPrintf,$1,$2,16501,16750)
 271     $$(call ListPathsSafely_IfPrintf,$1,$2,16751,17000)
 272 
 273     $$(call ListPathsSafely_IfPrintf,$1,$2,17001,17250)
 274     $$(call ListPathsSafely_IfPrintf,$1,$2,17251,17500)
 275     $$(call ListPathsSafely_IfPrintf,$1,$2,17501,17750)
 276     $$(call ListPathsSafely_IfPrintf,$1,$2,17751,18000)
 277 
 278     $$(call ListPathsSafely_IfPrintf,$1,$2,18001,18250)
 279     $$(call ListPathsSafely_IfPrintf,$1,$2,18251,18500)
 280     $$(call ListPathsSafely_IfPrintf,$1,$2,18501,18750)
 281     $$(call ListPathsSafely_IfPrintf,$1,$2,18751,19000)
 282 
 283     $$(call ListPathsSafely_IfPrintf,$1,$2,19001,19250)
 284     $$(call ListPathsSafely_IfPrintf,$1,$2,19251,19500)
 285     $$(call ListPathsSafely_IfPrintf,$1,$2,19501,19750)
 286     $$(call ListPathsSafely_IfPrintf,$1,$2,19751,20000)
 287 
 288     $$(call ListPathsSafely_IfPrintf,$1,$2,20001,20250)
 289     $$(call ListPathsSafely_IfPrintf,$1,$2,20251,20500)
 290     $$(call ListPathsSafely_IfPrintf,$1,$2,20501,20750)
 291     $$(call ListPathsSafely_IfPrintf,$1,$2,20751,21000)
 292 
 293     $$(call ListPathsSafely_IfPrintf,$1,$2,21001,21250)
 294     $$(call ListPathsSafely_IfPrintf,$1,$2,21251,21500)
 295     $$(call ListPathsSafely_IfPrintf,$1,$2,21501,21750)
 296     $$(call ListPathsSafely_IfPrintf,$1,$2,21751,22000)
 297 
 298     $$(call ListPathsSafely_IfPrintf,$1,$2,22001,22250)
 299     $$(call ListPathsSafely_IfPrintf,$1,$2,22251,22500)
 300     $$(call ListPathsSafely_IfPrintf,$1,$2,22501,22750)
 301     $$(call ListPathsSafely_IfPrintf,$1,$2,22751,23000)
 302 
 303     $$(call ListPathsSafely_IfPrintf,$1,$2,23001,23250)
 304     $$(call ListPathsSafely_IfPrintf,$1,$2,23251,23500)
 305     $$(call ListPathsSafely_IfPrintf,$1,$2,23501,23750)
 306     $$(call ListPathsSafely_IfPrintf,$1,$2,23751,24000)
 307 
 308     $$(call ListPathsSafely_IfPrintf,$1,$2,24001,24250)
 309     $$(call ListPathsSafely_IfPrintf,$1,$2,24251,24500)
 310     $$(call ListPathsSafely_IfPrintf,$1,$2,24501,24750)
 311     $$(call ListPathsSafely_IfPrintf,$1,$2,24751,25000)
 312 
 313     $$(call ListPathsSafely_IfPrintf,$1,$2,25001,25250)
 314     $$(call ListPathsSafely_IfPrintf,$1,$2,25251,25500)
 315     $$(call ListPathsSafely_IfPrintf,$1,$2,25501,25750)
 316     $$(call ListPathsSafely_IfPrintf,$1,$2,25751,26000)
 317 
 318     $$(call ListPathsSafely_IfPrintf,$1,$2,26001,26250)
 319     $$(call ListPathsSafely_IfPrintf,$1,$2,26251,26500)
 320     $$(call ListPathsSafely_IfPrintf,$1,$2,26501,26750)
 321     $$(call ListPathsSafely_IfPrintf,$1,$2,26751,27000)
 322 
 323     $$(call ListPathsSafely_IfPrintf,$1,$2,27001,27250)
 324     $$(call ListPathsSafely_IfPrintf,$1,$2,27251,27500)
 325     $$(call ListPathsSafely_IfPrintf,$1,$2,27501,27750)
 326     $$(call ListPathsSafely_IfPrintf,$1,$2,27751,28000)
 327 
 328     $$(call ListPathsSafely_IfPrintf,$1,$2,28001,28250)
 329     $$(call ListPathsSafely_IfPrintf,$1,$2,28251,28500)
 330     $$(call ListPathsSafely_IfPrintf,$1,$2,28501,28750)
 331     $$(call ListPathsSafely_IfPrintf,$1,$2,28751,29000)
 332 
 333     $$(call ListPathsSafely_IfPrintf,$1,$2,29001,29250)
 334     $$(call ListPathsSafely_IfPrintf,$1,$2,29251,29500)
 335     $$(call ListPathsSafely_IfPrintf,$1,$2,29501,29750)
 336     $$(call ListPathsSafely_IfPrintf,$1,$2,29751,30000)
 337   endef
 338 endif # HAS_FILE_FUNCTION
 339 
 340 ################################################################################
 341 
 342 # A file containing a way to uniquely identify the source code revision that
 343 # the build was created from
 344 SOURCE_REVISION_TRACKER := $(SUPPORT_OUTPUTDIR)/src-rev/source-revision-tracker
 345 
 346 # Locate all hg repositories included in the forest, as absolute paths
 347 FindAllReposAbs = \
 348     $(strip $(sort $(dir $(filter-out $(TOPDIR)/build/%, $(wildcard \
 349         $(addprefix $(TOPDIR)/, .hg */.hg */*/.hg */*/*/.hg */*/*/*/.hg) \
 350         $(addprefix $(TOPDIR)/, .git */.git */*/.git */*/*/.git */*/*/*/.git) \
 351     )))))
 352 
 353 # Locate all hg repositories included in the forest, as relative paths
 354 FindAllReposRel = \
 355     $(strip $(subst $(TOPDIR)/,.,$(patsubst $(TOPDIR)/%/, %, $(FindAllReposAbs))))
 356 
 357 ################################################################################
 358 
 359 define SetupLogging
 360   ifeq ($$(LOG_PROFILE_TIMES_FILE), true)


 362       SHELL :=  $$(BASH) $$(TOPDIR)/make/scripts/shell-profiler.sh \
 363                 gnutime $$(TIME) \
 364                 $$(OUTPUTDIR)/build-profile.log $$(SHELL)
 365     else ifneq ($$(FLOCK), )
 366       SHELL :=  $$(BASH) $$(TOPDIR)/make/scripts/shell-profiler.sh \
 367                 flock $$(FLOCK) \
 368                 $$(OUTPUTDIR)/build-profile.log $$(SHELL)
 369     endif
 370   endif
 371 
 372   ifeq ($$(LOG_LEVEL), trace)
 373     SHELL_NO_RECURSE := $$(SHELL)
 374     # Shell redefinition trick inspired by http://www.cmcrossroads.com/ask-mr-make/6535-tracing-rule-execution-in-gnu-make
 375     # For each target executed, will print
 376     # Building <TARGET> (from <FIRST PREREQUISITE>) (<ALL NEWER PREREQUISITES> newer)
 377     # but with a limit of 20 on <ALL NEWER PREREQUISITES>, to avoid cluttering logs too much
 378     # (and causing a crash on Cygwin).
 379     SHELL = $$(warning $$(if $$@,Building $$@,Running shell command) $$(if $$<, (from $$<))$$(if $$?, ($$(wordlist 1, 20, $$?) $$(if $$(wordlist 21, 22, $$?), ... [in total $$(words $$?) files]) newer)))$$(SHELL_NO_RECURSE) -x
 380   endif
 381 

 382   # The warn level can never be turned off
 383   LogWarn = $$(info $$(strip $$1))
 384   LOG_WARN :=
 385   ifneq ($$(findstring $$(LOG_LEVEL), info debug trace),)
 386     LogInfo = $$(info $$(strip $$1))
 387     LOG_INFO :=
 388   else
 389     LogInfo =
 390     LOG_INFO := > /dev/null
 391   endif
 392   ifneq ($$(findstring $$(LOG_LEVEL), debug trace),)
 393     LogDebug = $$(info $$(strip $$1))
 394     LOG_DEBUG :=
 395   else
 396     LogDebug =
 397     LOG_DEBUG := > /dev/null
 398   endif
 399   ifneq ($$(findstring $$(LOG_LEVEL), trace),)
 400     LogTrace = $$(info $$(strip $$1))
 401     LOG_TRACE :=
 402   else
 403     LogTrace =
 404     LOG_TRACE := > /dev/null
 405   endif
 406 endef
 407 
 408 # Make sure logging is setup for everyone that includes MakeBase.gmk.
 409 $(eval $(call SetupLogging))
 410 
 411 ################################################################################
 412 # Creates a sequence of increasing numbers (inclusive).
 413 # Param 1 - starting number
 414 # Param 2 - ending number
 415 sequence = \
 416     $(wordlist $1, $2, $(strip \
 417         $(eval SEQUENCE_COUNT :=) \
 418         $(call _sequence-do,$(strip $2))))
 419 
 420 _sequence-do = \
 421     $(if $(word $1, $(SEQUENCE_COUNT)),, \
 422       $(eval SEQUENCE_COUNT += .) \
 423       $(words $(SEQUENCE_COUNT)) \
 424       $(call _sequence-do,$1))
 425 
 426 ################################################################################
 427 
 428 MAX_PARAMS := 36
 429 PARAM_SEQUENCE := $(call sequence, 2, $(MAX_PARAMS))
 430 
 431 # Template for creating a macro taking named parameters. To use it, assign the
 432 # template to a variable with the name you want for your macro, using '='
 433 # assignment. Then define a macro body with the suffix "Body". The Body macro
 434 # should take 1 parameter which should be a unique string for that invocation
 435 # of the macro.
 436 # Ex:
 437 # SetupFoo = $(NamedParamsMacroTemplate)
 438 # define SetupFooBody
 439 #   # do something
 440 #   # access parameters as $$($1_BAR)
 441 # endef
 442 # Call it like this
 443 # $(eval $(call SetupFoo, BUILD_SOMETHING, \
 444 #     BAR := some parameter value, \
 445 # ))
 446 define NamedParamsMacroTemplate


 448       Too many named arguments to macro, please update MAX_PARAMS in MakeBase.gmk))
 449   # Iterate over 2 3 4... and evaluate the named parameters with $1_ as prefix
 450   $(foreach i,$(PARAM_SEQUENCE), $(if $(strip $($i)),\
 451     $(strip $1)_$(strip $(call EscapeHash, $(call DoubleDollar, $($i))))$(NEWLINE)))
 452   # Debug print all named parameter names and values
 453   $(if $(findstring $(LOG_LEVEL),debug trace), \
 454     $(info $0 $(strip $1) $(foreach i,$(PARAM_SEQUENCE), \
 455       $(if $(strip $($i)),$(NEWLINE) $(strip [$i] $(if $(filter $(LOG_LEVEL), trace), \
 456         $($i), $(wordlist 1, 20, $($(i))) $(if $(word 21, $($(i))), ...)))))))
 457 
 458   $(if $(DEBUG_$(strip $1)),
 459     $(info -------- <<< Begin expansion of $(strip $1)) \
 460     $(info $(call $(0)Body,$(strip $1))) \
 461     $(info -------- >>> End expansion of $(strip $1)) \
 462   )
 463 
 464   $(call $(0)Body,$(strip $1))
 465 endef
 466 
 467 ################################################################################
 468 # Replace question marks with space in string. This macro needs to be called on
 469 # files from CacheFind in case any of them contains space in their file name,
 470 # since CacheFind replaces space with ?.
 471 # Param 1 - String to replace in
 472 DecodeSpace = \
 473     $(subst ?,$(SPACE),$(strip $1))
 474 EncodeSpace = \
 475     $(subst $(SPACE),?,$(strip $1))
 476 
 477 ################################################################################
 478 # Make directory without forking mkdir if not needed.
 479 #
 480 # If a directory with an encoded space is provided, the wildcard function
 481 # sometimes returns false answers (typically if the dir existed when the
 482 # makefile was parsed, but was deleted by a previous rule). In that case, always
 483 # call mkdir regardless of what wildcard says.
 484 #
 485 # 1: List of directories to create
 486 MakeDir = \
 487     $(strip \
 488         $(eval MakeDir_dirs_to_make := $(strip $(foreach d, $1, \
 489           $(if $(findstring ?, $d), '$(call DecodeSpace, $d)', \
 490             $(if $(wildcard $d), , $d) \
 491           ) \
 492         ))) \
 493         $(if $(MakeDir_dirs_to_make), $(shell $(MKDIR) -p $(MakeDir_dirs_to_make))) \
 494     )
 495 
 496 # Make directory for target file. Should handle spaces in filenames. Just
 497 # calling $(call MakeDir $(@D)) will not work if the directory contains a space
 498 # and the target file already exists. In that case, the target file will have
 499 # its wildcard ? resolved and the $(@D) will evaluate each space separated dir
 500 # part on its own.
 501 MakeTargetDir = \
 502     $(call MakeDir, $(dir $(call EncodeSpace, $@)))
 503 
 504 ################################################################################
 505 # Assign a variable only if it is empty
 506 # Param 1 - Variable to assign
 507 # Param 2 - Value to assign
 508 SetIfEmpty = \
 509     $(if $($(strip $1)),,$(eval $(strip $1) := $2))
 510 
 511 ################################################################################
 512 # All install-file and related macros automatically call DecodeSpace when needed.
 513 
 514 ifeq ($(OPENJDK_TARGET_OS),solaris)
 515   # On Solaris, if the target is a symlink and exists, cp won't overwrite.
 516   # Cp has to operate in recursive mode to allow for -P flag, to preserve soft links. If the
 517   # name of the target file differs from the source file, rename after copy.
 518   # If the source and target parent directories are the same, recursive copy doesn't work
 519   # so we fall back on regular copy, which isn't preserving symlinks.
 520   define install-file
 521         $(call MakeTargetDir)
 522         $(RM) '$(call DecodeSpace, $@)'
 523         if [ '$(call DecodeSpace, $(dir $(call EncodeSpace, $@)))' != \
 524             '$(call DecodeSpace, $(dir $(call EncodeSpace, $<)))' ]; then \
 525           $(CP) -f -r -P '$(call DecodeSpace, $<)' \
 526               '$(call DecodeSpace, $(dir $(call EncodeSpace, $@)))'; \
 527           if [ '$(call DecodeSpace, $(notdir $(call EncodeSpace, $@)))' != \
 528               '$(call DecodeSpace, $(notdir $(call EncodeSpace, $(<))))' ]; then \
 529             $(MV) '$(call DecodeSpace, $(dir $(call EncodeSpace, $@))/$(notdir $(call EncodeSpace, $<)))' \
 530                 '$(call DecodeSpace, $@)'; \
 531           fi; \
 532         else \
 533           if [ -L '$(call DecodeSpace, $<)' ]; then \
 534             $(ECHO) "Source file is a symlink and target is in the same directory: $< $@" ; \
 535             exit 1; \
 536           fi; \
 537           $(CP) -f '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'; \
 538         fi
 539   endef
 540 else ifeq ($(OPENJDK_TARGET_OS),macosx)
 541   # On mac, extended attributes sometimes creep into the source files, which may later
 542   # cause the creation of ._* files which confuses testing. Clear these with xattr if
 543   # set. Some files get their write permissions removed after being copied to the
 544   # output dir. When these are copied again to images, xattr would fail. By only clearing
 545   # attributes when they are present, failing on this is avoided.
 546   #
 547   # If copying a soft link to a directory, need to delete the target first to avoid
 548   # weird errors.
 549   define install-file
 550         $(call MakeTargetDir)
 551         $(RM) '$(call DecodeSpace, $@)'
 552         # Work around a weirdness with cp on Macosx. When copying a symlink, if
 553         # the target of the link is write protected (e.g. 444), cp will add
 554         # write permission for the user on the target file (644). Avoid this by
 555         # using ln to create a new link instead.
 556         if [ -h '$(call DecodeSpace, $<)' ]; then \
 557           $(LN) -s "`$(READLINK) '$(call DecodeSpace, $<)'`" '$(call DecodeSpace, $@)'; \
 558         else \
 559           $(CP) -fRP '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'; \
 560         fi
 561         if [ -n "`$(XATTR) -ls '$(call DecodeSpace, $@)'`" ]; then \
 562           $(XATTR) -cs '$(call DecodeSpace, $@)'; \
 563         fi
 564   endef
 565 else
 566   define install-file
 567         $(call MakeTargetDir)
 568         $(CP) -fP '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'
 569   endef
 570 endif
 571 
 572 # Variant of install file that does not preserve symlinks
 573 define install-file-nolink
 574         $(call MakeTargetDir)
 575         $(CP) -f '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'
 576 endef
 577 
 578 ################################################################################
 579 # Take two paths and return the path of the last common directory.
 580 # Ex: /foo/bar/baz, /foo/bar/banan -> /foo/bar
 581 #     foo/bar/baz, /foo/bar -> <empty>
 582 #
 583 # The x prefix is used to preserve the presence of the initial slash
 584 #
 585 # $1 - Path to compare
 586 # $2 - Other path to compare
 587 FindCommonPathPrefix = \
 588     $(patsubst x%,%,$(subst $(SPACE),/,$(strip \
 589         $(call FindCommonPathPrefixHelper, \
 590             $(subst /,$(SPACE),x$(strip $1)), $(subst /,$(SPACE),x$(strip $2))) \
 591     )))
 592 
 593 FindCommonPathPrefixHelper = \
 594     $(if $(call equals, $(firstword $1), $(firstword $2)), \
 595       $(firstword $1) \
 596       $(call FindCommonPathPrefixHelper, \
 597           $(wordlist 2, $(words $1), $1), $(wordlist 2, $(words $2), $2) \
 598       ) \
 599     )
 600 
 601 # Convert a partial path into as many directory levels of ../, removing
 602 # leading and following /.
 603 # Ex: foo/bar/baz/ -> ../../..
 604 #     foo/bar -> ../..
 605 #     /foo -> ..
 606 DirToDotDot = \
 607     $(subst $(SPACE),/,$(foreach d, $(subst /,$(SPACE),$1),..))
 608 
 609 # Computes the relative path from a directory to a file
 610 # $1 - File to compute the relative path to
 611 # $2 - Directory to compute the relative path from
 612 RelativePath = \
 613     $(eval $1_prefix := $(call FindCommonPathPrefix, $1, $2)) \
 614     $(eval $1_dotdots := $(call DirToDotDot, $(patsubst $($(strip $1)_prefix)/%, %, $2))) \
 615     $(eval $1_suffix := $(patsubst $($(strip $1)_prefix)/%, %, $1)) \
 616     $($(strip $1)_dotdots)/$($(strip $1)_suffix)
 617 
 618 ################################################################################
 619 # link-file-* works similarly to install-file but creates a symlink instead.
 620 # There are two versions, either creating a relative or an absolute link. Be
 621 # careful when using this on Windows since the symlink created is only valid in
 622 # the unix emulation environment.
 623 define link-file-relative
 624         $(call MakeTargetDir)
 625         $(RM) '$(call DecodeSpace, $@)'
 626         $(LN) -s '$(call DecodeSpace, $(call RelativePath, $<, $(@D)))' '$(call DecodeSpace, $@)'
 627 endef
 628 
 629 define link-file-absolute
 630         $(call MakeTargetDir)
 631         $(RM) '$(call DecodeSpace, $@)'
 632         $(LN) -s '$(call DecodeSpace, $<)' '$(call DecodeSpace, $@)'
 633 endef
 634 
 635 ################################################################################
 636 # Filter out duplicate sub strings while preserving order. Keeps the first occurance.
 637 uniq = \
 638     $(strip $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1))))
 639 
 640 # Returns all whitespace-separated words in $2 where at least one of the
 641 # whitespace-separated words in $1 is a substring.
 642 containing = \

 643     $(strip \
 644         $(foreach v,$(strip $2),\
 645           $(call uniq,$(foreach p,$(strip $1),$(if $(findstring $p,$v),$v)))))
 646 
 647 # Returns all whitespace-separated words in $2 where none of the
 648 # whitespace-separated words in $1 is a substring.
 649 not-containing = \
 650     $(strip $(filter-out $(call containing,$1,$2),$2))
 651 
 652 # Return a list of all string elements that are duplicated in $1.
 653 dups = \
 654     $(strip $(foreach v, $(sort $1), $(if $(filter-out 1, \
 655         $(words $(filter $v, $1))), $v)))
 656 
 657 # String equals
 658 equals = \
 659     $(if $(strip $1)$(strip $2),$(strip \
 660       $(and $(findstring $(strip $1),$(strip $2)),\
 661         $(findstring $(strip $2),$(strip $1)))), \
 662       true \
 663     )
 664 
 665 # Remove a whole list of prefixes
 666 # $1 - List of prefixes
 667 # $2 - List of elements to process
 668 remove-prefixes = \
 669     $(strip $(if $1,$(patsubst $(firstword $1)%,%,\
 670       $(call remove-prefixes,$(filter-out $(firstword $1),$1),$2)),$2))
 671 
 672 # Convert the string given to upper case, without any $(shell)
 673 # Inspired by http://lists.gnu.org/archive/html/help-make/2013-09/msg00009.html
 674 uppercase_table := a,A b,B c,C d,D e,E f,F g,G h,H i,I j,J k,K l,L m,M n,N o,O \
 675     p,P q,Q r,R s,S t,T u,U v,V w,W x,X y,Y z,Z
 676 
 677 uppercase_internal = \
 678   $(if $(strip $1), $$(subst $(firstword $1), $(call uppercase_internal, \
 679       $(wordlist 2, $(words $1), $1), $2)), $2)
 680 
 681 # Convert a string to upper case. Works only on a-z.
 682 # $1 - The string to convert
 683 uppercase = \
 684   $(strip \
 685     $(eval uppercase_result := $(call uppercase_internal, $(uppercase_table), $1)) \
 686     $(uppercase_result) \
 687   )
 688 
 689 ################################################################################
 690 
 691 ifneq ($(DISABLE_CACHE_FIND), true)
 692   # In Cygwin, finds are very costly, both because of expensive forks and because
 693   # of bad file system caching. Find is used extensively in $(shell) commands to
 694   # find source files. This makes rerunning make with no or few changes rather
 695   # expensive. To speed this up, these two macros are used to cache the results
 696   # of simple find commands for reuse.
 697   #
 698   # Runs a find and stores both the directories where it was run and the results.
 699   # This macro can be called multiple times to add to the cache. Only finds files
 700   # with no filters.
 701   #
 702   # Files containing space will get spaces replaced with ? because GNU Make
 703   # cannot handle lists of files with space in them. By using ?, make will match
 704   # the wildcard to space in many situations so we don't need to replace back
 705   # to space on every use. While not a complete solution it does allow some uses
 706   # of CacheFind to function with spaces in file names, including for
 707   # SetupCopyFiles.
 708   #
 709   # Needs to be called with $(eval )
 710   #
 711   # Even if the performance benifit is negligible on other platforms, keep the
 712   # functionality active unless explicitly disabled to exercise it more.
 713   #
 714   # Initialize FIND_CACHE_DIRS with := to make it a non recursively-expanded variable
 715   FIND_CACHE_DIRS :=
 716   # Param 1 - Dirs to find in
 717   # Param 2 - (optional) specialization. Normally "-a \( ... \)" expression.
 718   define FillCacheFind
 719     # Filter out already cached dirs. The - is needed when FIND_CACHE_DIRS is empty
 720     # since filter out will then return empty.
 721     FIND_CACHE_NEW_DIRS := $$(filter-out $$(addsuffix /%,\
 722         - $(FIND_CACHE_DIRS)) $(FIND_CACHE_DIRS), $1)
 723     ifneq ($$(FIND_CACHE_NEW_DIRS), )
 724       # Remove any trailing slash from dirs in the cache dir list
 725       FIND_CACHE_DIRS += $$(patsubst %/,%, $$(FIND_CACHE_NEW_DIRS))
 726       FIND_CACHE := $$(sort $$(FIND_CACHE) \
 727           $$(shell $(FIND) $$(wildcard $$(FIND_CACHE_NEW_DIRS)) \
 728               \( -type f -o -type l \) $2 | $(TR) ' ' '?'))
 729     endif
 730   endef
 731 
 732   # Mimics find by looking in the cache if all of the directories have been cached.
 733   # Otherwise reverts to shell find. This is safe to call on all platforms, even if
 734   # cache is deactivated.
 735   #
 736   # $1 can be either a directory or a file. If it's a directory, make
 737   # sure we have exactly one trailing slash before the wildcard.
 738   # The extra - is needed when FIND_CACHE_DIRS is empty but should be harmless.
 739   #
 740   # Param 1 - Dirs to find in
 741   # Param 2 - (optional) specialization. Normally "-a \( ... \)" expression.
 742   define CacheFind
 743     $(if $(filter-out $(addsuffix /%,- $(FIND_CACHE_DIRS)) $(FIND_CACHE_DIRS),$1), \
 744       $(if $(wildcard $1), $(shell $(FIND) $(wildcard $1) \( -type f -o -type l \) $2 \
 745           | $(TR) ' ' '?')), \
 746       $(filter $(addsuffix /%,$(patsubst %/,%,$1)) $1,$(FIND_CACHE)))
 747   endef
 748 







 749 else
 750   # If CacheFind is disabled, just run the find command.
 751   # Param 1 - Dirs to find in
 752   # Param 2 - (optional) specialization. Normally "-a \( ... \)" expression.
 753   define CacheFind
 754     $(if $(wildcard $1, \
 755       $(shell $(FIND) $(wildcard $1) \( -type f -o -type l \) $2 | $(TR) ' ' '?') \
 756     )
 757   endef
 758 endif
 759 
 760 ################################################################################
 761 
 762 define AddFileToCopy
 763   # Helper macro for SetupCopyFiles
 764   # 1 : Source file
 765   # 2 : Dest file
 766   # 3 : Variable to add targets to
 767   # 4 : Macro to call for copy operation
 768   # 5 : Action text to log
 769   $2: $1
 770         $$(call LogInfo, $(strip $5) $$(patsubst $(OUTPUTDIR)/%,%,$$(call DecodeSpace, $$@)))
 771         $$($$(strip $4))
 772 
 773   $3 += $2
 774   $3_SOURCES += $1
 775 endef
 776 
 777 # Returns the value of the first argument
 778 identity = \
 779     $(strip $1)
 780 
 781 # Setup make rules for copying files, with an option to do more complex
 782 # processing instead of copying.
 783 #
 784 # Parameter 1 is the name of the rule. This name is used as variable prefix,
 785 # and the targets generated are listed in a variable by that name.
 786 #
 787 # The list of all source files is returned in $1_SOURCES.
 788 #
 789 # Remaining parameters are named arguments. These include:
 790 #   SRC     : Source root dir (defaults to dir of first file)
 791 #   DEST    : Dest root dir
 792 #   FILES   : List of files to copy with absolute paths, or path relative to SRC.
 793 #             Must be in SRC.
 794 #   FLATTEN : Set to flatten the directory structure in the DEST dir.
 795 #   MACRO   : Optionally override the default macro used for making the copy.
 796 #             Default is 'install-file'
 797 #   NAME_MACRO : Optionally supply a macro that rewrites the target file name
 798 #                based on the source file name
 799 #   LOG_ACTION : Optionally specify a different action text for log messages
 800 SetupCopyFiles = $(NamedParamsMacroTemplate)
 801 define SetupCopyFilesBody
 802 
 803   ifeq ($$($1_MACRO), )
 804     $1_MACRO := install-file
 805   endif
 806 
 807   # Default SRC to the dir of the first file.
 808   ifeq ($$($1_SRC), )
 809     $1_SRC := $$(dir $$(firstword $$($1_FILES)))
 810   endif
 811 
 812   ifeq ($$($1_NAME_MACRO), )
 813     $1_NAME_MACRO := identity
 814   endif
 815 
 816   ifeq ($$($1_LOG_ACTION), )
 817     $1_LOG_ACTION := Copying
 818   endif
 819 
 820   # Remove any trailing slash from SRC and DEST
 821   $1_SRC := $$(patsubst %/,%,$$($1_SRC))
 822   $1_DEST := $$(patsubst %/,%,$$($1_DEST))
 823 
 824   # Need to wrap arguments in DoubleDollar because of the eval nested inside an
 825   # eval macro body.
 826   $$(foreach f, $$(patsubst $$($1_SRC)/%,%,$$($1_FILES)), \
 827     $$(eval $$(call AddFileToCopy, \
 828         $$(call DoubleDollar, $$($1_SRC)/$$f), \
 829         $$(call DoubleDollar, \
 830             $$($1_DEST)/$$(call $$(strip $$($1_NAME_MACRO)),$$(if $$($1_FLATTEN),$$(notdir $$f),$$f)) \
 831         ), \
 832         $1, \
 833         $$($1_MACRO), \
 834         $$($1_LOG_ACTION) \
 835     )) \
 836   )
 837 
 838 endef
 839 
 840 ################################################################################
 841 # Parse a multiple-keyword variable, like FOO="KEYWORD1=val1;KEYWORD2=val2;..."
 842 # These will be converted into a series of variables like FOO_KEYWORD1=val1,
 843 # FOO_KEYWORD2=val2, etc. Unknown keywords will cause an error.
 844 #
 845 # Parameter 1 is the name of the rule, and is also the name of the variable.
 846 #
 847 # Remaining parameters are named arguments. These include:
 848 #   SINGLE_KEYWORDS   A list of valid keywords with single string values
 849 #   STRING_KEYWORDS   A list of valid keywords, processed as string. This means
 850 #       that '%20' will be replaced by ' ' to allow for multi-word strings.
 851 #
 852 ParseKeywordVariable = $(NamedParamsMacroTemplate)
 853 define ParseKeywordVariableBody
 854   ifneq ($$($1), )
 855     # To preserve spaces, substitute them with a hopefully unique pattern
 856     # before splitting and then re-substitute spaces back.
 857     $1_MANGLED := $$(subst $$(SPACE),||||,$$($1))
 858     $$(foreach mangled_part, $$(subst ;, , $$($1_MANGLED)), \
 859       $$(eval mangled_part_eval := $$(call DoubleDollar, $$(mangled_part))) \
 860       $$(eval part := $$$$(subst ||||,$$$$(SPACE),$$$$(mangled_part_eval))) \
 861       $$(eval $1_NO_MATCH := true) \
 862       $$(foreach keyword, $$($1_SINGLE_KEYWORDS), \
 863         $$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \
 864         $$(if $$(filter $$(keyword)=%, $$(part)), \
 865           $$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part)))) \
 866           $$(eval $1_NO_MATCH := ) \
 867         ) \
 868       ) \
 869       $$(foreach keyword, $$($1_STRING_KEYWORDS), \
 870         $$(eval keyword_eval := $$(call DoubleDollar, $$(keyword))) \
 871         $$(if $$(filter $$(keyword)=%, $$(part)), \
 872           $$(eval $(strip $1)_$$$$(keyword_eval) := $$$$(strip $$$$(subst %20, , $$$$(patsubst $$$$(keyword_eval)=%, %, $$$$(part))))) \
 873           $$(eval $1_NO_MATCH := ) \
 874         ) \
 875       ) \
 876       $$(if $$($1_NO_MATCH), \
 877         $$(if $$(filter $$(part), $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS)), \
 878           $$(info Keyword $$(part) for $1 needs to be assigned a value.) \
 879         , \
 880           $$(info $$(part) is not a valid keyword for $1.) \
 881           $$(info Valid keywords: $$($1_SINGLE_KEYWORDS) $$($1_STRING_KEYWORDS).) \
 882         ) \
 883         $$(error Cannot continue) \
 884       ) \
 885     )
 886   endif
 887 endef
 888 
 889 ################################################################################
 890 # ShellQuote
 891 #
 892 # Quotes a string with single quotes and replaces single quotes with '\'' so
 893 # that the contents survives being given to the shell.







 894 
 895 ShellQuote = \
 896     $(SQUOTE)$(subst $(SQUOTE),$(SQUOTE)\$(SQUOTE)$(SQUOTE),$(strip $1))$(SQUOTE)










 897 
 898 ################################################################################
 899 # FixPath
 900 #
 901 # On Windows, converts a path from cygwin/unix style (e.g. /bin/foo) into
 902 # "mixed mode" (e.g. c:/cygwin/bin/foo). On other platforms, return the path
 903 # unchanged.
 904 # This is normally not needed since we use the FIXPATH prefix for command lines,
 905 # but might be needed in certain circumstances.
 906 ifeq ($(OPENJDK_TARGET_OS), windows)
 907   FixPath = \
 908       $(shell $(CYGPATH) -m $1)
 909 else
 910   FixPath = \
 911       $1
 912 endif
 913 
 914 ################################################################################
 915 # Write to and read from file
 916 
 917 # Param 1 - File to read
 918 ReadFile = \
 919     $(shell $(CAT) $1)
 920 
 921 # Param 1 - Text to write
 922 # Param 2 - File to write to
 923 ifeq ($(HAS_FILE_FUNCTION), true)
 924   WriteFile = \
 925       $(file >$2,$(strip $1))
 926 else
 927   # Use printf to get consistent behavior on all platforms.
 928   WriteFile = \
 929       $(shell $(PRINTF) "%s" $(call ShellQuote, $1) > $2)
 930 endif
 931 
 932 # Param 1 - Text to write
 933 # Param 2 - File to write to
 934 ifeq ($(HAS_FILE_FUNCTION), true)
 935   AppendFile = \
 936       $(file >>$2,$(strip $1))
 937 else
 938   # Use printf to get consistent behavior on all platforms.
 939   AppendFile = \
 940       $(shell $(PRINTF) "%s" $(call ShellQuote, $1) >> $2)
 941 endif
 942 
 943 ################################################################################
 944 # DependOnVariable
 945 #
 946 # This macro takes a variable name and puts the value in a file only if the
 947 # value has changed since last. The name of the file is returned. This can be
 948 # used to create rule dependencies on make variable values. The following
 949 # example would get rebuilt if the value of SOME_VAR was changed:
 950 #
 951 # path/to/some-file: $(call DependOnVariable, SOME_VAR)
 952 #         echo $(SOME_VAR) > $@
 953 #
 954 # Note that leading and trailing white space in the value is ignored.
 955 #
 956 
 957 # Defines the sub directory structure to store variable value file in
 958 DependOnVariableDirName = \
 959     $(strip $(addsuffix $(if $(MODULE),/$(MODULE)), \
 960         $(subst $(TOPDIR)/,, $(if $(filter /%, $(firstword $(MAKEFILE_LIST))), \


1007 # The output is stored in a specified log file, which is displayed at the end
1008 # of the build in case of failure. The  command line itself is stored in a file,
1009 # and also logged to stdout if the LOG=cmdlines option has been given.
1010 #
1011 # NOTE: If the command redirects stdout, the caller needs to wrap it in a
1012 # subshell (by adding parentheses around it), otherwise the redirect to the
1013 # subshell tee process will create a race condition where the target file may
1014 # not be fully written when the make recipe is done.
1015 #
1016 # Param 1 - The path to base the name of the log file / command line file on
1017 # Param 2 - The command to run
1018 ExecuteWithLog = \
1019   $(call LogCmdlines, Exececuting: [$(strip $2)]) \
1020   $(call MakeDir, $(dir $(strip $1))) \
1021   $(call WriteFile, $2, $(strip $1).cmdline) \
1022   ( $(RM) $(strip $1).log && $(strip $2) > >($(TEE) -a $(strip $1).log) 2> >($(TEE) -a $(strip $1).log >&2) || \
1023       ( exitcode=$(DOLLAR)? && \
1024       $(CP) $(strip $1).log $(MAKESUPPORT_OUTPUTDIR)/failure-logs/$(subst /,_,$(patsubst $(OUTPUTDIR)/%,%,$(strip $1))).log && \
1025       $(CP) $(strip $1).cmdline $(MAKESUPPORT_OUTPUTDIR)/failure-logs/$(subst /,_,$(patsubst $(OUTPUTDIR)/%,%,$(strip $1))).cmdline && \
1026       exit $(DOLLAR)exitcode ) )
1027 
1028 ################################################################################
1029 # Find lib dir for module
1030 # Param 1 - module name
1031 FindLibDirForModule = \
1032     $(SUPPORT_OUTPUTDIR)/modules_libs/$(strip $1)
1033 
1034 ################################################################################
1035 # Find executable dir for module
1036 # Param 1 - module name
1037 FindExecutableDirForModule = \
1038     $(SUPPORT_OUTPUTDIR)/modules_cmds/$(strip $1)
1039 
1040 ################################################################################
1041 # Return a string suitable for use after a -classpath or --module-path option. It
1042 # will be correct and safe to use on all platforms. Arguments are given as space
1043 # separate classpath entries. Safe for multiple nested calls.
1044 # param 1 : A space separated list of classpath entries
1045 # The surrounding strip is needed to keep additional whitespace out
1046 PathList = \
1047   "$(subst $(SPACE),$(PATH_SEP),$(strip $(subst $(DQUOTE),,$1)))"
1048 
1049 ################################################################################
1050 # Check if a specified hotspot variant is being built, or at least one of a
1051 # list of variants. Will return 'true' or 'false'.
1052 # $1 - the variant to test for
1053 check-jvm-variant = \
1054   $(strip \
1055     $(if $(filter-out $(VALID_JVM_VARIANTS), $1), \
1056       $(error Internal error: Invalid variant tested: $1)) \
1057     $(if $(filter $1, $(JVM_VARIANTS)), true, false))
1058 
1059 ################################################################################
1060 # Converts a space separated list to a comma separated list.
1061 #
1062 # Replacing double-comma with a single comma is to workaround the issue with
1063 # some version of make on windows that doesn't substitute spaces with one comma
1064 # properly.
1065 CommaList = \
1066   $(strip \
1067       $(subst $(COMMA)$(COMMA),$(COMMA),$(subst $(SPACE),$(COMMA),$(strip $1))) \
1068   )
1069 
1070 ################################################################################
1071 # Converts a space separated list to a colon separated list.
1072 #
1073 # Replacing double-colon with a single colon is to workaround the issue with
1074 # some version of make on windows that doesn't substitute spaces with one colon
1075 # properly.
1076 ColonList = \
1077   $(strip \
1078       $(subst ::,:,$(subst $(SPACE),:,$(strip $1))) \
1079   )
1080 
1081 ################################################################################
1082 # Given a list of files, filters out locale specific files for translations
1083 # that should be excluded from this build.
1084 # $1 - The list of files to filter
1085 # $2 - The suffix of the files that should be considered (.java or .properties)
1086 FilterExcludedTranslations = \
1087   $(strip $(if $(EXCLUDE_TRANSLATIONS), \
1088     $(filter-out \
1089         $(foreach suffix, $2, \
1090           $(addprefix %_, $(addsuffix $(suffix), $(EXCLUDE_TRANSLATIONS))) \
1091         ), \
1092         $1 \
1093     ), \
1094     $1 \
1095   ))
1096 
1097 ################################################################################
1098 
1099 # Hook to include the corresponding custom file, if present.
1100 $(eval $(call IncludeCustomExtension, common/MakeBase.gmk))
1101 
1102 endif # _MAKEBASE_GMK
< prev index next >