GNU make has two 'flavors' of variable: simple and recursive. Everyone is familiar the the recursive style (which uses = for definition):
BAR = banana
FOO = one $(BAR), two $(BAR)s
BAR = guava
The value of FOO is determined each time FOO is used. In a large Makefile that can mean that FOO is expanded over and over again. If expanding FOO is an expensive operation then determining its value each time can slow down the Makefile. For example,
TODAY = $(shell date +%d/%m/%y)
would be very expensive is it would shell out to run date every time TODAY is used (and might have the strange effect of returning different dates if you run your make near midnight).
(I've written about that before and in my book on GNU make)
The other flavor of make variable is simple: its value is fixed the moment it's defined:
BAR = banana
FOO := one $(BAR), two $(BAR)s
BAR = guava
There FOO is set to one banana, two bananas and not one guava, two guavas (as was the case above) because the right hand side of the := is expanded when FOO is being defined and BAR has the value banana at that point.
But suppose you wanted a mixture of the two: a variable that is only ever expanded once and only expanded if it is used. This might be useful if the variable was used rarely as part of the build and was expensive to expand.
You can concoct a recipe for that like this. Suppose you want to define a variable FOO to have value expensive-to-calculate then you can use the following pattern:
FOO = $(eval FOO := expensive-to-evaluate)$(FOO)
It's initially a recursive variable and so the right-hand side is not expanded until it is used. But the first time it is used FOO is redefined (by the $(eval)) and becomes a simple variable with the value of expensive-to-evaluate.
Having become a simple variable it's possible to return its value (note that if FOO was still recursive it would not be allowed to reference itself like that).
You can see that in action with the following Makefile. To make it clear when NOW is actually expanded I've added a call to $(info). And calls to $(flavor) to show when NOW changes from recursive to simple.
$(info Start Parse)
NOW = $(eval NOW := $(info Expand NOW)$(shell date -u))$(NOW)
.PHONY: all foo
all: foo ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)"
foo: ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)" && sleep 1
$(info End Parse)
Which will output
Start Parse
End Parse
Expand NOW
foo / recursive / Sat Jul 23 15:01:15 UTC 2016 / simple
all / simple / Sat Jul 23 15:01:15 UTC 2016 / simple
The one gotcha with this is that you need to be sure that when NOW is expanded any variable it depends on have the values you expect.
It's possible to wrap that up in a function like this:
$(info Start Parse)
make-lazy = $(eval $1 = $$(eval $1 := $(value $(1)))$$($1))
NOW = $(info Expand NOW)$(shell date -u)
$(call make-lazy,NOW)
.PHONY: all foo
all: foo ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)"
foo: ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)" && sleep 1
$(info End Parse)
BAR = banana
FOO = one $(BAR), two $(BAR)s
BAR = guava
The value of FOO is determined each time FOO is used. In a large Makefile that can mean that FOO is expanded over and over again. If expanding FOO is an expensive operation then determining its value each time can slow down the Makefile. For example,
TODAY = $(shell date +%d/%m/%y)
would be very expensive is it would shell out to run date every time TODAY is used (and might have the strange effect of returning different dates if you run your make near midnight).
(I've written about that before and in my book on GNU make)
The other flavor of make variable is simple: its value is fixed the moment it's defined:
BAR = banana
FOO := one $(BAR), two $(BAR)s
BAR = guava
There FOO is set to one banana, two bananas and not one guava, two guavas (as was the case above) because the right hand side of the := is expanded when FOO is being defined and BAR has the value banana at that point.
But suppose you wanted a mixture of the two: a variable that is only ever expanded once and only expanded if it is used. This might be useful if the variable was used rarely as part of the build and was expensive to expand.
You can concoct a recipe for that like this. Suppose you want to define a variable FOO to have value expensive-to-calculate then you can use the following pattern:
FOO = $(eval FOO := expensive-to-evaluate)$(FOO)
It's initially a recursive variable and so the right-hand side is not expanded until it is used. But the first time it is used FOO is redefined (by the $(eval)) and becomes a simple variable with the value of expensive-to-evaluate.
Having become a simple variable it's possible to return its value (note that if FOO was still recursive it would not be allowed to reference itself like that).
You can see that in action with the following Makefile. To make it clear when NOW is actually expanded I've added a call to $(info). And calls to $(flavor) to show when NOW changes from recursive to simple.
$(info Start Parse)
NOW = $(eval NOW := $(info Expand NOW)$(shell date -u))$(NOW)
.PHONY: all foo
all: foo ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)"
foo: ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)" && sleep 1
$(info End Parse)
Which will output
Start Parse
End Parse
Expand NOW
foo / recursive / Sat Jul 23 15:01:15 UTC 2016 / simple
all / simple / Sat Jul 23 15:01:15 UTC 2016 / simple
The one gotcha with this is that you need to be sure that when NOW is expanded any variable it depends on have the values you expect.
It's possible to wrap that up in a function like this:
$(info Start Parse)
make-lazy = $(eval $1 = $$(eval $1 := $(value $(1)))$$($1))
NOW = $(info Expand NOW)$(shell date -u)
$(call make-lazy,NOW)
.PHONY: all foo
all: foo ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)"
foo: ; @echo "$@ / $(flavor NOW) / $(NOW) / $(flavor NOW)" && sleep 1
$(info End Parse)
Just $(call) make-lazy on any recursive variable to make it lazy.
3 comments:
I ran in to problems with GNU make sometimes crashing if I recursively modified a variable from within the variable.
I've ended up with the following macro:
cache = $(eval $1 = \
$$(if $$(cache.$1),,$$(eval cache.$1 := $(value 2)))$$(cache.$1))
Using it needs doubled $ signs, e.g:
$(call cache,LDSTDCXX,$$(realpath $$(shell g++ --print-file-name=libstdc++.so)))
My original macro that caused GNU make to crash sometimes was just:
cache = $(eval $1 = $$(eval $1 := $(value 2))$$($1))
I Wonder if this could this break make -j parallelism one day
I use this technique frequently, having seen it here.
This tended to segfault in GNU make around version 3.81 though, due this bug. This has been fixed in more recent versions, and there is even a patch for 3.81 mentioned.
One situation I haven't found a solution for is, is there a way to do this for pattern-specific variables?
Post a Comment