]>
Commit | Line | Data |
---|---|---|
1 | ||
2 | # Don't use implicit rules or variables | |
3 | # we have explicit rules for everything | |
4 | MAKEFLAGS += -rR | |
5 | ||
6 | # Files with this suffixes are final, don't try to generate them | |
7 | # using implicit rules | |
8 | %.d: | |
9 | %.h: | |
10 | %.c: | |
11 | %.cc: | |
12 | %.cpp: | |
13 | %.m: | |
14 | %.mak: | |
15 | ||
16 | # Flags for C++ compilation | |
17 | QEMU_CXXFLAGS = -D__STDC_LIMIT_MACROS $(filter-out -Wstrict-prototypes -Wmissing-prototypes -Wnested-externs -Wold-style-declaration -Wold-style-definition -Wredundant-decls, $(QEMU_CFLAGS)) | |
18 | ||
19 | # Flags for dependency generation | |
20 | QEMU_DGFLAGS += -MMD -MP -MT $@ -MF $(@D)/$(*F).d | |
21 | ||
22 | # Same as -I$(SRC_PATH) -I., but for the nested source/object directories | |
23 | QEMU_INCLUDES += -I$(<D) -I$(@D) | |
24 | ||
25 | WL_U := -Wl,-u, | |
26 | find-symbols = $(if $1, $(sort $(shell $(NM) -P -g $1 | $2))) | |
27 | defined-symbols = $(call find-symbols,$1,awk '$$2!="U"{print $$1}') | |
28 | undefined-symbols = $(call find-symbols,$1,awk '$$2=="U"{print $$1}') | |
29 | ||
30 | # All the .mo objects in -m variables are also added into corresponding -y | |
31 | # variable in unnest-vars, but filtered out here, when LINK is called. | |
32 | # | |
33 | # The .mo objects are supposed to be linked as a DSO, for module build. So here | |
34 | # they are only used as a placeholders to generate those "archive undefined" | |
35 | # symbol options (-Wl,-u,$symbol_name), which are the archive functions | |
36 | # referenced by the code in the DSO. | |
37 | # | |
38 | # Also the presence in -y variables will also guarantee they are built before | |
39 | # linking executables that will load them. So we can look up symbol reference | |
40 | # in LINK. | |
41 | # | |
42 | # This is necessary because the exectuable itself may not use the function, in | |
43 | # which case the function would not be linked in. Then the DSO loading will | |
44 | # fail because of the missing symbol. | |
45 | process-archive-undefs = $(filter-out %.a %.mo,$1) \ | |
46 | $(addprefix $(WL_U), \ | |
47 | $(filter $(call defined-symbols,$(filter %.a, $1)), \ | |
48 | $(call undefined-symbols,$(filter %.mo,$1)))) \ | |
49 | $(filter %.a,$1) | |
50 | ||
51 | extract-libs = $(strip $(foreach o,$1,$($o-libs))) | |
52 | expand-objs = $(strip $(sort $(filter %.o,$1)) \ | |
53 | $(foreach o,$(filter %.mo,$1),$($o-objs)) \ | |
54 | $(filter-out %.o %.mo,$1)) | |
55 | ||
56 | %.o: %.c | |
57 | $(call quiet-command,$(CC) $(QEMU_INCLUDES) $(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($@-cflags) -c -o $@ $<," CC $(TARGET_DIR)$@") | |
58 | %.o: %.rc | |
59 | $(call quiet-command,$(WINDRES) -I. -o $@ $<," RC $(TARGET_DIR)$@") | |
60 | ||
61 | # If we have a CXX we might have some C++ objects, in which case we | |
62 | # must link with the C++ compiler, not the plain C compiler. | |
63 | LINKPROG = $(or $(CXX),$(CC)) | |
64 | ||
65 | ifeq ($(LIBTOOL),) | |
66 | LINK = $(call quiet-command, $(LINKPROG) $(QEMU_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ \ | |
67 | $(call process-archive-undefs, $1) \ | |
68 | $(version-obj-y) $(call extract-libs,$1) $(LIBS)," LINK $(TARGET_DIR)$@") | |
69 | else | |
70 | LIBTOOL += $(if $(V),,--quiet) | |
71 | %.lo: %.c | |
72 | $(call quiet-command,$(LIBTOOL) --mode=compile --tag=CC $(CC) $(QEMU_INCLUDES) $(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($*.o-cflags) -c -o $@ $<," lt CC $@") | |
73 | %.lo: %.rc | |
74 | $(call quiet-command,$(LIBTOOL) --mode=compile --tag=RC $(WINDRES) -I. -o $@ $<,"lt RC $(TARGET_DIR)$@") | |
75 | %.lo: %.dtrace | |
76 | $(call quiet-command,$(LIBTOOL) --mode=compile --tag=CC dtrace -o $@ -G -s $<, " lt GEN $(TARGET_DIR)$@") | |
77 | ||
78 | LINK = $(call quiet-command,\ | |
79 | $(if $(filter %.lo %.la,$1),$(LIBTOOL) --mode=link --tag=CC \ | |
80 | )$(LINKPROG) $(QEMU_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ \ | |
81 | $(call process-archive-undefs, $1)\ | |
82 | $(if $(filter %.lo %.la,$1),$(version-lobj-y),$(version-obj-y)) \ | |
83 | $(if $(filter %.lo %.la,$1),$(LIBTOOLFLAGS)) \ | |
84 | $(call extract-libs,$(1:.lo=.o)) $(LIBS),$(if $(filter %.lo %.la,$1),"lt LINK ", " LINK ")"$(TARGET_DIR)$@") | |
85 | endif | |
86 | ||
87 | %.asm: %.S | |
88 | $(call quiet-command,$(CPP) $(QEMU_INCLUDES) $(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) -o $@ $<," CPP $(TARGET_DIR)$@") | |
89 | ||
90 | %.o: %.asm | |
91 | $(call quiet-command,$(AS) $(ASFLAGS) -o $@ $<," AS $(TARGET_DIR)$@") | |
92 | ||
93 | %.o: %.cc | |
94 | $(call quiet-command,$(CXX) $(QEMU_INCLUDES) $(QEMU_CXXFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($@-cflags) -c -o $@ $<," CXX $(TARGET_DIR)$@") | |
95 | ||
96 | %.o: %.cpp | |
97 | $(call quiet-command,$(CXX) $(QEMU_INCLUDES) $(QEMU_CXXFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($@-cflags) -c -o $@ $<," CXX $(TARGET_DIR)$@") | |
98 | ||
99 | %.o: %.m | |
100 | $(call quiet-command,$(OBJCC) $(QEMU_INCLUDES) $(QEMU_CFLAGS) $(QEMU_DGFLAGS) $(CFLAGS) $($@-cflags) -c -o $@ $<," OBJC $(TARGET_DIR)$@") | |
101 | ||
102 | %.o: %.dtrace | |
103 | $(call quiet-command,dtrace -o $@ -G -s $<, " GEN $(TARGET_DIR)$@") | |
104 | ||
105 | DSO_OBJ_CFLAGS := -fPIC -DBUILD_DSO | |
106 | module-common.o: CFLAGS += $(DSO_OBJ_CFLAGS) | |
107 | %$(DSOSUF): LDFLAGS += $(LDFLAGS_SHARED) | |
108 | %$(DSOSUF): %.mo | |
109 | $(call LINK,$^) | |
110 | @# Copy to build root so modules can be loaded when program started without install | |
111 | $(if $(findstring /,$@),$(call quiet-command,cp $@ $(subst /,-,$@), " CP $(subst /,-,$@)")) | |
112 | ||
113 | ||
114 | LD_REL := $(CC) -nostdlib -Wl,-r | |
115 | ||
116 | %.mo: | |
117 | $(call quiet-command,$(LD_REL) -o $@ $^," LD -r $(TARGET_DIR)$@") | |
118 | ||
119 | .PHONY: modules | |
120 | modules: | |
121 | ||
122 | %$(EXESUF): %.o | |
123 | $(call LINK,$^) | |
124 | ||
125 | %.a: | |
126 | $(call quiet-command,rm -f $@ && $(AR) rcs $@ $^," AR $(TARGET_DIR)$@") | |
127 | ||
128 | quiet-command = $(if $(V),$1,$(if $(2),@echo $2 && $1, @$1)) | |
129 | ||
130 | # cc-option | |
131 | # Usage: CFLAGS+=$(call cc-option, -falign-functions=0, -malign-functions=0) | |
132 | ||
133 | cc-option = $(if $(shell $(CC) $1 $2 -S -o /dev/null -xc /dev/null \ | |
134 | >/dev/null 2>&1 && echo OK), $2, $3) | |
135 | ||
136 | VPATH_SUFFIXES = %.c %.h %.S %.cc %.cpp %.m %.mak %.texi %.sh %.rc | |
137 | set-vpath = $(if $1,$(foreach PATTERN,$(VPATH_SUFFIXES),$(eval vpath $(PATTERN) $1))) | |
138 | ||
139 | # install-prog list, dir | |
140 | define install-prog | |
141 | $(INSTALL_DIR) "$2" | |
142 | $(INSTALL_PROG) $1 "$2" | |
143 | $(if $(STRIP),$(STRIP) $(foreach T,$1,"$2/$(notdir $T)"),) | |
144 | endef | |
145 | ||
146 | # find-in-path | |
147 | # Usage: $(call find-in-path, prog) | |
148 | # Looks in the PATH if the argument contains no slash, else only considers one | |
149 | # specific directory. Returns an # empty string if the program doesn't exist | |
150 | # there. | |
151 | find-in-path = $(if $(find-string /, $1), \ | |
152 | $(wildcard $1), \ | |
153 | $(wildcard $(patsubst %, %/$1, $(subst :, ,$(PATH))))) | |
154 | ||
155 | # Logical functions (for operating on y/n values like CONFIG_FOO vars) | |
156 | # Inputs to these must be either "y" (true) or "n" or "" (both false) | |
157 | # Output is always either "y" or "n". | |
158 | # Usage: $(call land,$(CONFIG_FOO),$(CONFIG_BAR)) | |
159 | # Logical NOT | |
160 | lnot = $(if $(subst n,,$1),n,y) | |
161 | # Logical AND | |
162 | land = $(if $(findstring yy,$1$2),y,n) | |
163 | # Logical OR | |
164 | lor = $(if $(findstring y,$1$2),y,n) | |
165 | # Logical XOR (note that this is the inverse of leqv) | |
166 | lxor = $(if $(filter $(call lnot,$1),$(call lnot,$2)),n,y) | |
167 | # Logical equivalence (note that leqv "","n" is true) | |
168 | leqv = $(if $(filter $(call lnot,$1),$(call lnot,$2)),y,n) | |
169 | # Logical if: like make's $(if) but with an leqv-like test | |
170 | lif = $(if $(subst n,,$1),$2,$3) | |
171 | ||
172 | # String testing functions: inputs to these can be any string; | |
173 | # the output is always either "y" or "n". Leading and trailing whitespace | |
174 | # is ignored when comparing strings. | |
175 | # String equality | |
176 | eq = $(if $(subst $2,,$1)$(subst $1,,$2),n,y) | |
177 | # String inequality | |
178 | ne = $(if $(subst $2,,$1)$(subst $1,,$2),y,n) | |
179 | # Emptiness/non-emptiness tests: | |
180 | isempty = $(if $1,n,y) | |
181 | notempty = $(if $1,y,n) | |
182 | ||
183 | # Generate files with tracetool | |
184 | TRACETOOL=$(PYTHON) $(SRC_PATH)/scripts/tracetool.py | |
185 | ||
186 | # Generate timestamp files for .h include files | |
187 | ||
188 | config-%.h: config-%.h-timestamp | |
189 | @cmp $< $@ >/dev/null 2>&1 || cp $< $@ | |
190 | ||
191 | config-%.h-timestamp: config-%.mak | |
192 | $(call quiet-command, sh $(SRC_PATH)/scripts/create_config < $< > $@, " GEN $(TARGET_DIR)config-$*.h") | |
193 | ||
194 | .PHONY: clean-timestamp | |
195 | clean-timestamp: | |
196 | rm -f *.timestamp | |
197 | clean: clean-timestamp | |
198 | ||
199 | # will delete the target of a rule if commands exit with a nonzero exit status | |
200 | .DELETE_ON_ERROR: | |
201 | ||
202 | # save-vars | |
203 | # Usage: $(call save-vars, vars) | |
204 | # Save each variable $v in $vars as save-vars-$v, save their object's | |
205 | # variables, then clear $v. | |
206 | define save-vars | |
207 | $(foreach v,$1, | |
208 | $(eval save-vars-$v := $(value $v)) | |
209 | $(foreach o,$($v), | |
210 | $(foreach k,cflags libs objs, | |
211 | $(if $($o-$k), | |
212 | $(eval save-vars-$o-$k := $($o-$k)) | |
213 | $(eval $o-$k := )))) | |
214 | $(eval $v := )) | |
215 | endef | |
216 | ||
217 | # load-vars | |
218 | # Usage: $(call load-vars, vars, add_var) | |
219 | # Load the saved value for each variable in @vars, and the per object | |
220 | # variables. | |
221 | # Append @add_var's current value to the loaded value. | |
222 | define load-vars | |
223 | $(eval $2-new-value := $(value $2)) | |
224 | $(foreach v,$1, | |
225 | $(eval $v := $(value save-vars-$v)) | |
226 | $(foreach o,$($v), | |
227 | $(foreach k,cflags libs objs, | |
228 | $(if $(save-vars-$o-$k), | |
229 | $(eval $o-$k := $(save-vars-$o-$k)) | |
230 | $(eval save-vars-$o-$k := )))) | |
231 | $(eval save-vars-$v := )) | |
232 | $(eval $2 := $(value $2) $($2-new-value)) | |
233 | endef | |
234 | ||
235 | # fix-paths | |
236 | # Usage: $(call fix-paths, obj_path, src_path, vars) | |
237 | # Add prefix @obj_path to all objects in @vars, and add prefix @src_path to all | |
238 | # directories in @vars. | |
239 | define fix-paths | |
240 | $(foreach v,$3, | |
241 | $(foreach o,$($v), | |
242 | $(if $($o-libs), | |
243 | $(eval $1$o-libs := $($o-libs))) | |
244 | $(if $($o-cflags), | |
245 | $(eval $1$o-cflags := $($o-cflags))) | |
246 | $(if $($o-objs), | |
247 | $(eval $1$o-objs := $(addprefix $1,$($o-objs))))) | |
248 | $(eval $v := $(addprefix $1,$(filter-out %/,$($v))) \ | |
249 | $(addprefix $2,$(filter %/,$($v))))) | |
250 | endef | |
251 | ||
252 | # unnest-var-recursive | |
253 | # Usage: $(call unnest-var-recursive, obj_prefix, vars, var) | |
254 | # | |
255 | # Unnest @var by including subdir Makefile.objs, while protect others in @vars | |
256 | # unchanged. | |
257 | # | |
258 | # @obj_prefix is the starting point of object path prefix. | |
259 | # | |
260 | define unnest-var-recursive | |
261 | $(eval dirs := $(sort $(filter %/,$($3)))) | |
262 | $(eval $3 := $(filter-out %/,$($3))) | |
263 | $(foreach d,$(dirs:%/=%), | |
264 | $(call save-vars,$2) | |
265 | $(eval obj := $(if $1,$1/)$d) | |
266 | $(eval -include $(SRC_PATH)/$d/Makefile.objs) | |
267 | $(call fix-paths,$(if $1,$1/)$d/,$d/,$2) | |
268 | $(call load-vars,$2,$3) | |
269 | $(call unnest-var-recursive,$1,$2,$3)) | |
270 | endef | |
271 | ||
272 | # unnest-vars | |
273 | # Usage: $(call unnest-vars, obj_prefix, vars) | |
274 | # | |
275 | # @obj_prefix: object path prefix, can be empty, or '..', etc. Don't include | |
276 | # ending '/'. | |
277 | # | |
278 | # @vars: the list of variable names to unnest. | |
279 | # | |
280 | # This macro will scan subdirectories's Makefile.objs, include them, to build | |
281 | # up each variable listed in @vars. | |
282 | # | |
283 | # Per object and per module cflags and libs are saved with relative path fixed | |
284 | # as well, those variables include -libs, -cflags and -objs. Items in -objs are | |
285 | # also fixed to relative path against SRC_PATH plus the prefix @obj_prefix. | |
286 | # | |
287 | # All nested variables postfixed by -m in names are treated as DSO variables, | |
288 | # and will be built as modules, if enabled. | |
289 | # | |
290 | # A simple example of the unnest: | |
291 | # | |
292 | # obj_prefix = .. | |
293 | # vars = hot cold | |
294 | # hot = fire.o sun.o season/ | |
295 | # cold = snow.o water/ season/ | |
296 | # | |
297 | # Unnest through a faked source directory structure: | |
298 | # | |
299 | # SRC_PATH | |
300 | # ├── water | |
301 | # │ └── Makefile.objs──────────────────┐ | |
302 | # │ │ hot += steam.o │ | |
303 | # │ │ cold += ice.mo │ | |
304 | # │ │ ice.mo-libs := -licemaker │ | |
305 | # │ │ ice.mo-objs := ice1.o ice2.o │ | |
306 | # │ └──────────────────────────────┘ | |
307 | # │ | |
308 | # └── season | |
309 | # └── Makefile.objs──────┐ | |
310 | # │ hot += summer.o │ | |
311 | # │ cold += winter.o │ | |
312 | # └──────────────────┘ | |
313 | # | |
314 | # In the end, the result will be: | |
315 | # | |
316 | # hot = ../fire.o ../sun.o ../season/summer.o | |
317 | # cold = ../snow.o ../water/ice.mo ../season/winter.o | |
318 | # ../water/ice.mo-libs = -licemaker | |
319 | # ../water/ice.mo-objs = ../water/ice1.o ../water/ice2.o | |
320 | # | |
321 | # Note that 'hot' didn't include 'season/' in the input, so 'summer.o' is not | |
322 | # included. | |
323 | # | |
324 | define unnest-vars | |
325 | # In the case of target build (i.e. $1 == ..), fix path for top level | |
326 | # Makefile.objs objects | |
327 | $(if $1,$(call fix-paths,$1/,,$2)) | |
328 | ||
329 | # Descend and include every subdir Makefile.objs | |
330 | $(foreach v, $2, | |
331 | $(call unnest-var-recursive,$1,$2,$v) | |
332 | # Pass the .mo-cflags and .mo-libs along to its member objects | |
333 | $(foreach o, $(filter %.mo,$($v)), | |
334 | $(foreach p,$($o-objs), | |
335 | $(if $($o-cflags), $(eval $p-cflags += $($o-cflags))) | |
336 | $(if $($o-libs), $(eval $p-libs += $($o-libs)))))) | |
337 | ||
338 | # For all %.mo objects that are directly added into -y, just expand them | |
339 | $(foreach v,$(filter %-y,$2), | |
340 | $(eval $v := $(foreach o,$($v),$(if $($o-objs),$($o-objs),$o)))) | |
341 | ||
342 | $(foreach v,$(filter %-m,$2), | |
343 | # All .o found in *-m variables are single object modules, create .mo | |
344 | # for them | |
345 | $(foreach o,$(filter %.o,$($v)), | |
346 | $(eval $(o:%.o=%.mo)-objs := $o)) | |
347 | # Now unify .o in -m variable to .mo | |
348 | $(eval $v := $($v:%.o=%.mo)) | |
349 | $(eval modules-m += $($v)) | |
350 | ||
351 | # For module build, build shared libraries during "make modules" | |
352 | # For non-module build, add -m to -y | |
353 | $(if $(CONFIG_MODULES), | |
354 | $(foreach o,$($v), | |
355 | $(eval $($o-objs): CFLAGS += $(DSO_OBJ_CFLAGS)) | |
356 | $(eval $o: $($o-objs))) | |
357 | $(eval $(patsubst %-m,%-y,$v) += $($v)) | |
358 | $(eval modules: $($v:%.mo=%$(DSOSUF))), | |
359 | $(eval $(patsubst %-m,%-y,$v) += $(call expand-objs, $($v))))) | |
360 | ||
361 | # Post-process all the unnested vars | |
362 | $(foreach v,$2, | |
363 | $(foreach o, $(filter %.mo,$($v)), | |
364 | # Find all the .mo objects in variables and add dependency rules | |
365 | # according to .mo-objs. Report error if not set | |
366 | $(if $($o-objs), | |
367 | $(eval $(o:%.mo=%$(DSOSUF)): module-common.o $($o-objs)), | |
368 | $(error $o added in $v but $o-objs is not set))) | |
369 | $(shell mkdir -p ./ $(sort $(dir $($v)))) | |
370 | # Include all the .d files | |
371 | $(eval -include $(patsubst %.o,%.d,$(patsubst %.mo,%.d,$($v)))) | |
372 | $(eval $v := $(filter-out %/,$($v)))) | |
373 | endef |