[efi] Veto the Itautec Ip4ConfigDxe driver
[ipxe.git] / src / Makefile.housekeeping
1 # -*- makefile -*- : Force emacs to use Makefile mode
2 #
3 # This file contains various boring housekeeping functions that would
4 # otherwise seriously clutter up the main Makefile.
5
6 ###############################################################################
7 #
8 # Find a usable "echo -e" substitute.
9 #
10 TAB                     := $(shell $(PRINTF) '\t')
11 ECHO_E_ECHO             := $(ECHO)
12 ECHO_E_ECHO_E           := $(ECHO) -e
13 ECHO_E_BIN_ECHO         := /bin/echo
14 ECHO_E_BIN_ECHO_E       := /bin/echo -e
15 ECHO_E_ECHO_TAB         := $(shell $(ECHO_E_ECHO) '\t' | cat)
16 ECHO_E_ECHO_E_TAB       := $(shell $(ECHO_E_ECHO_E) '\t' | cat)
17 ECHO_E_BIN_ECHO_TAB     := $(shell $(ECHO_E_BIN_ECHO) '\t')
18 ECHO_E_BIN_ECHO_E_TAB   := $(shell $(ECHO_E_BIN_ECHO_E) '\t')
19
20 ifeq ($(ECHO_E_ECHO_TAB),$(TAB))
21 ECHO_E          := $(ECHO_E_ECHO)
22 endif
23 ifeq ($(ECHO_E_ECHO_E_TAB),$(TAB))
24 ECHO_E          := $(ECHO_E_ECHO_E)
25 endif
26 ifeq ($(ECHO_E_BIN_ECHO_TAB),$(TAB))
27 ECHO_E          := $(ECHO_E_BIN_ECHO)
28 endif
29 ifeq ($(ECHO_E_BIN_ECHO_E_TAB),$(TAB))
30 ECHO_E          := $(ECHO_E_BIN_ECHO_E)
31 endif
32
33 .echocheck :
34 ifdef ECHO_E
35         @$(TOUCH) $@
36 else
37         @$(PRINTF) '%24s : x%sx\n' 'tab' '$(TAB)'
38         @$(PRINTF) '%24s : x%sx\n' '"$(ECHO_E_ECHO) \t"' \
39                                     '$(ECHO_E_ECHO_TAB)'
40         @$(PRINTF) '%24s : x%sx\n' '"$(ECHO_E_ECHO_E) \t"' \
41                                     '$(ECHO_E_ECHO_E_TAB)'
42         @$(PRINTF) '%24s : x%sx\n' '"$(ECHO_E_BIN_ECHO) \t"' \
43                                     '$(ECHO_E_BIN_ECHO_TAB)'
44         @$(PRINTF) '%24s : x%sx\n' '"$(ECHO_E_BIN_ECHO_E) \t"' \
45                                     '$(ECHO_E_BIN_ECHO_E_TAB)'
46         @$(ECHO) "No usable \"echo -e\" substitute found"
47         @exit 1
48 endif
49 MAKEDEPS        += .echocheck
50 VERYCLEANUP     += .echocheck
51
52 echo :
53         @$(ECHO) "Using \"$(ECHO_E)\" for \"echo -e\""
54
55 ###############################################################################
56 #
57 # Generate a usable "seq" substitute
58 #
59 define seq
60         $(shell awk 'BEGIN { for ( i = $(1) ; i <= $(2) ; i++ ) print i }')
61 endef
62
63 ###############################################################################
64 #
65 # Determine host OS
66 #
67 HOST_OS         := $(shell uname -s)
68 hostos :
69         @$(ECHO) $(HOST_OS)
70
71 ###############################################################################
72 #
73 # Determine compiler
74
75 CCDEFS          := $(shell $(CC) -E -x c -c /dev/null -dM | cut -d" " -f2)
76 ccdefs:
77         @$(ECHO) $(CCDEFS)
78
79 ifeq ($(filter __GNUC__,$(CCDEFS)),__GNUC__)
80 CCTYPE          := gcc
81 endif
82 cctype:
83         @$(ECHO) $(CCTYPE)
84
85 ###############################################################################
86 #
87 # Check for tools that can cause failed builds
88 #
89
90 ifeq ($(CCTYPE),gcc)
91 GCC_2_96_BANNER := $(shell $(CC) -v 2>&1 | grep -is 'gcc version 2\.96')
92 ifneq ($(GCC_2_96_BANNER),)
93 $(warning gcc 2.96 is unsuitable for compiling iPXE)
94 $(warning Use gcc 2.95 or a newer version instead)
95 $(error Unsuitable build environment found)
96 endif
97 endif
98
99 PERL_UNICODE_CHECK := $(shell $(PERL) -e 'use bytes; print chr(255)' | wc -c)
100 ifeq ($(PERL_UNICODE_CHECK),2)
101 $(warning Your Perl version has a Unicode handling bug)
102 $(warning Execute this command before building iPXE:)
103 $(warning export LANG=$${LANG%.UTF-8})
104 $(error Unsuitable build environment found)
105 endif
106
107 LD_GOLD_BANNER := $(shell $(LD) -v 2>&1 | grep 'GNU gold')
108 ifneq ($(LD_GOLD_BANNER),)
109 $(warning GNU gold is unsuitable for building iPXE)
110 $(warning Use GNU ld instead)
111 $(error Unsuitable build environment found)
112 endif
113
114 OBJCOPY_ETC_BANNER := $(shell $(OBJCOPY) --version | grep 'elftoolchain')
115 ifneq ($(OBJCOPY_ETC_BANNER),)
116 $(warning The elftoolchain objcopy is unsuitable for building iPXE)
117 $(warning Use binutils objcopy instead)
118 $(error Unsuitable build environment found)
119 endif
120
121 ###############################################################################
122 #
123 # Check if $(eval ...) is available to use
124 #
125
126 HAVE_EVAL :=
127 ifndef NO_EVAL
128 $(eval HAVE_EVAL := yes)
129 endif
130 eval :
131         @$(ECHO) $(HAVE_EVAL)
132
133 ###############################################################################
134 #
135 # Check for various tool workarounds
136 #
137
138 WORKAROUND_CFLAGS :=
139 WORKAROUND_ASFLAGS :=
140 WORKAROUND_LDFLAGS :=
141
142 # Make syntax does not allow use of comma or space in certain places.
143 # This ugly workaround is suggested in the manual.
144 #
145 COMMA   := ,
146 EMPTY   :=
147 SPACE   := $(EMPTY) $(EMPTY)
148 HASH    := \#
149 define NEWLINE
150
151
152 endef
153
154 # gcc 4.4 generates .eh_frame sections by default, which distort the
155 # output of "size".  Inhibit this.
156 #
157 ifeq ($(CCTYPE),gcc)
158 CFI_TEST = $(CC) -fno-dwarf2-cfi-asm -fno-exceptions -fno-unwind-tables \
159                  -fno-asynchronous-unwind-tables -x c -c /dev/null \
160                  -o /dev/null >/dev/null 2>&1
161 CFI_FLAGS := $(shell $(CFI_TEST) && \
162                $(ECHO) '-fno-dwarf2-cfi-asm -fno-exceptions ' \
163                        '-fno-unwind-tables -fno-asynchronous-unwind-tables')
164 WORKAROUND_CFLAGS += $(CFI_FLAGS)
165 endif
166
167 # gcc 4.6 generates spurious warnings if -Waddress is in force.
168 # Inhibit this.
169 #
170 ifeq ($(CCTYPE),gcc)
171 WNA_TEST = $(CC) -Waddress -x c -c /dev/null -o /dev/null >/dev/null 2>&1
172 WNA_FLAGS := $(shell $(WNA_TEST) && $(ECHO) '-Wno-address')
173 WORKAROUND_CFLAGS += $(WNA_FLAGS)
174
175 # gcc 8.0 generates warnings for certain suspect string operations. Our
176 # sources have been vetted for correct usage.  Turn off these warnings.
177 #
178 WNST_TEST = $(CC) -Wstringop-truncation -x c -c /dev/null -o /dev/null \
179                   >/dev/null 2>&1
180 WNST_FLAGS := $(shell $(WNST_TEST) && $(ECHO) '-Wno-stringop-truncation')
181 WORKAROUND_CFLAGS += $(WNST_FLAGS)
182
183 # gcc 9.1 generates warnings for taking address of packed member which
184 # may result in an unaligned pointer value.  Inhibit the warnings.
185 #
186 WNAPM_TEST = $(CC) -Wno-address-of-packed-member -x c -c /dev/null \
187                    -o /dev/null >/dev/null 2>&1
188 WNAPM_FLAGS := $(shell $(WNAPM_TEST) && \
189                  $(ECHO) '-Wno-address-of-packed-member')
190 WORKAROUND_CFLAGS += $(WNAPM_FLAGS)
191 endif
192
193 # Some versions of gas choke on division operators, treating them as
194 # comment markers.  Specifying --divide will work around this problem,
195 # but isn't available on older gas versions.
196 #
197 DIVIDE_TEST = $(AS) --divide /dev/null -o /dev/null 2>/dev/null
198 DIVIDE_FLAGS := $(shell $(DIVIDE_TEST) && $(ECHO) '--divide')
199 WORKAROUND_ASFLAGS += $(DIVIDE_FLAGS)
200
201 ###############################################################################
202 #
203 # Build verbosity
204 #
205 ifeq ($(V),1)
206 Q :=
207 QM := @\#
208 else
209 Q := @
210 QM := @
211 endif
212
213 ###############################################################################
214 #
215 # Checker
216 #
217 ifeq ($(C),1)
218 export REAL_CC := $(CC)
219 CC := cgcc
220 CFLAGS += -Wno-decl
221 endif
222
223 ###############################################################################
224 #
225 # Set BIN according to whatever was specified on the command line as
226 # the build target.
227 #
228
229 # Determine how many different BIN directories are mentioned in the
230 # make goals.
231 #
232 BIN_GOALS       := $(filter bin bin/% bin-%,$(MAKECMDGOALS))
233 BIN_GOALS_BINS  := $(sort $(foreach BG,$(BIN_GOALS),\
234                                     $(firstword $(subst /, ,$(BG)))))
235 NUM_BINS        := $(words $(BIN_GOALS_BINS))
236
237 ifeq ($(NUM_BINS),0)
238
239 # No BIN directory was specified.  Set BIN to "bin" as a sensible
240 # default.
241
242 BIN             := bin
243
244 else # NUM_BINS == 0
245
246 ifeq ($(NUM_BINS),1)
247
248 # If exactly one BIN directory was specified, set BIN to match this
249 # directory.
250 #
251 BIN             := $(firstword $(BIN_GOALS_BINS))
252
253 else # NUM_BINS == 1
254
255 # More than one BIN directory was specified.  We cannot handle the
256 # latter case within a single make invocation, so set up recursive
257 # targets for each BIN directory.  Use exactly one target for each BIN
258 # directory since running multiple make invocations within the same
259 # BIN directory is likely to cause problems.
260 #
261 # Leave $(BIN) undefined.  This has implications for any target that
262 # depends on $(BIN); such targets should be made conditional upon the
263 # existence of $(BIN).
264 #
265 BIN_GOALS_FIRST := $(foreach BGB,$(BIN_GOALS_BINS),\
266                              $(firstword $(filter $(BGB)/%,$(BIN_GOALS))))
267 BIN_GOALS_OTHER := $(filter-out $(BIN_GOALS_FIRST),$(BIN_GOALS))
268
269 $(BIN_GOALS_FIRST) : % : BIN_RECURSE
270         $(Q)$(MAKE) --no-print-directory BIN=$(firstword $(subst /, ,$@)) \
271             $(filter $(firstword $(subst /, ,$@))/%, $(BIN_GOALS))
272 $(BIN_GOALS_OTHER) : % : BIN_RECURSE
273         $(Q)$(TRUE)
274 .PHONY : BIN_RECURSE
275
276 endif # NUM_BINS == 1
277 endif # NUM_BINS == 0
278
279 ifdef BIN
280
281 # Create $(BIN) directory if it doesn't exist yet
282 #
283 ifeq ($(wildcard $(BIN)),)
284 $(shell $(MKDIR) -p $(BIN))
285 endif
286
287 # Target to allow e.g. "make bin-efi arch"
288 #
289 $(BIN) :
290         @# Do nothing, silently
291 .PHONY : $(BIN)
292
293 # Remove everything in $(BIN) for a "make clean"
294 #
295 CLEANUP += $(BIN)/*.* # Avoid picking up directories
296
297 endif # defined(BIN)
298
299 # Determine whether or not we need to include the dependency files
300 #
301 NO_DEP_TARGETS  := $(BIN) clean veryclean
302 ifeq ($(MAKECMDGOALS),)
303 NEED_DEPS       := 1
304 endif
305 ifneq ($(strip $(filter-out $(NO_DEP_TARGETS),$(MAKECMDGOALS))),)
306 NEED_DEPS       := 1
307 endif
308
309 ###############################################################################
310 #
311 # Select build architecture and platform based on $(BIN)
312 #
313 # BIN has the form bin[-[<arch>-]<platform>[-sb]]
314
315 ARCHS           := $(patsubst arch/%,%,$(wildcard arch/*))
316 PLATFORMS       := $(patsubst config/defaults/%.h,%,\
317                      $(wildcard config/defaults/*.h))
318 archs :
319         @$(ECHO) $(ARCHS)
320
321 platforms :
322         @$(ECHO) $(PLATFORMS)
323
324 ifdef BIN
325
326 # Split $(BIN) into architecture, platform, and security flag (where present)
327 BIN_ELEMENTS    := $(subst -,$(SPACE),$(BIN))
328 BIN_APS         := $(wordlist 2,4,$(BIN_ELEMENTS))
329 ifeq ($(lastword $(BIN_APS)),sb)
330 BIN_AP          := $(wordlist 2,$(words $(BIN_APS)),discard $(BIN_APS))
331 BIN_SECUREBOOT  := 1
332 else
333 BIN_AP          := $(BIN_APS)
334 BIN_SECUREBOOT  := 0
335 endif
336 BIN_PLATFORM    := $(lastword $(BIN_AP))
337 BIN_ARCH        := $(wordlist 2,$(words $(BIN_AP)),discard $(BIN_AP))
338
339 # Determine build architecture
340 DEFAULT_ARCH    := i386
341 ARCH            := $(firstword $(BIN_ARCH) $(DEFAULT_ARCH))
342 CFLAGS          += -DARCH=$(ARCH)
343 arch :
344         @$(ECHO) $(ARCH)
345 .PHONY : arch
346
347 # Determine build platform
348 DEFAULT_PLATFORM := pcbios
349 PLATFORM        := $(firstword $(BIN_PLATFORM) $(DEFAULT_PLATFORM))
350 CFLAGS          += -DPLATFORM=$(PLATFORM) -DPLATFORM_$(PLATFORM)
351 platform :
352         @$(ECHO) $(PLATFORM)
353
354 # Determine security flag
355 DEFAULT_SECUREBOOT := 0
356 SECUREBOOT      := $(firstword $(BIN_SECUREBOOT) $(DEFAULT_SECUREBOOT))
357 CFLAGS          += -DSECUREBOOT=$(SECUREBOOT)
358 secureboot :
359         @$(ECHO) $(SECUREBOOT)
360
361 endif # defined(BIN)
362
363 # Include architecture-specific Makefile
364 ifdef ARCH
365 MAKEDEPS        += arch/$(ARCH)/Makefile
366 include arch/$(ARCH)/Makefile
367 endif
368
369 # Include architecture-specific include path
370 ifdef ARCH
371 INCDIRS         += arch/$(ARCH)/include
372 INCDIRS         += arch/$(ARCH)/include/$(PLATFORM)
373 endif
374
375 ###############################################################################
376 #
377 # Especially ugly workarounds
378
379 # Some widespread patched versions of gcc include -fPIE -Wl,-pie by
380 # default.  Note that gcc will exit *successfully* if it fails to
381 # recognise an option that starts with "no", so we have to test for
382 # output on stderr instead of checking the exit status.
383 #
384 # Current versions of gcc require -no-pie; older versions require
385 # -nopie.  We therefore test for both.
386 #
387 # This workaround must be determined only after the
388 # architecture-specific Makefile has been included, since some
389 # platforms (e.g. bin-x86_64-efi) will explicitly require the use of
390 # -fpie.
391 #
392 ifeq ($(filter -fpie,$(CFLAGS)),)
393 ifeq ($(CCTYPE),gcc)
394 PIE_TEST = [ -z "`$(CC) -fno-PIE -no-pie -x c -c /dev/null -o /dev/null 2>&1`" ]
395 PIE_FLAGS := $(shell $(PIE_TEST) && $(ECHO) '-fno-PIE -no-pie')
396 PIE_TEST2 = [ -z "`$(CC) -fno-PIE -nopie -x c -c /dev/null -o /dev/null 2>&1`" ]
397 PIE_FLAGS2 := $(shell $(PIE_TEST2) && $(ECHO) '-fno-PIE -nopie')
398 WORKAROUND_CFLAGS += $(PIE_FLAGS) $(PIE_FLAGS2)
399 endif
400 endif
401
402 # Some widespread patched versions of gcc include -fcf-protection=full
403 # by default.
404 #
405 ifeq ($(CCTYPE),gcc)
406 CFP_TEST = $(CC) -fcf-protection=none -x c -c /dev/null -o /dev/null \
407                  >/dev/null 2>&1
408 CFP_FLAGS := $(shell $(CFP_TEST) && $(ECHO) '-fcf-protection=none')
409 WORKAROUND_CFLAGS += $(CFP_FLAGS)
410 endif
411
412 ###############################################################################
413 #
414 # Source file handling
415
416 # Exclude known-insecure files from Secure Boot builds
417 ifeq ($(SECUREBOOT),0)
418 SRCDIRS         += $(SRCDIRS_INSEC)
419 endif
420
421 # SRCDIRS lists all directories containing source files.
422 srcdirs :
423         @$(ECHO) $(SRCDIRS)
424
425 # SRCS lists all .c or .S files found in any SRCDIR
426 #
427 SRCS    += $(wildcard $(patsubst %,%/*.c,$(SRCDIRS)))
428 SRCS    += $(wildcard $(patsubst %,%/*.S,$(SRCDIRS)))
429 srcs :
430         @$(ECHO) $(SRCS)
431
432 # AUTO_SRCS lists all files in SRCS that are not mentioned in
433 # NON_AUTO_SRCS.  Files should be added to NON_AUTO_SRCS if they
434 # cannot be built using the standard build template.
435 #
436 AUTO_SRCS = $(filter-out $(NON_AUTO_SRCS),$(SRCS))
437 autosrcs :
438         @$(ECHO) $(AUTO_SRCS)
439
440 # Just about everything else in this section depends upon having
441 # $(BIN) set
442
443 ifdef BIN
444
445 # INCDIRS lists the include path
446 incdirs :
447         @$(ECHO) $(INCDIRS)
448
449 # Inhibit -fstack-protector (which is implicitly enabled in some
450 # patched gcc versions) unless explicitly mentioned in CFLAGS.
451 #
452 ifeq ($(findstring -fstack-protector,$(CFLAGS)),)
453 CFLAGS          += -fno-stack-protector
454 endif
455
456 # Common flags
457 #
458 CFLAGS          += $(foreach INC,$(INCDIRS),-I$(INC))
459 CFLAGS          += -Os
460 CFLAGS          += -g
461 ifeq ($(CCTYPE),gcc)
462 CFLAGS          += -ffreestanding
463 CFLAGS          += -fcommon
464 CFLAGS          += -Wall -W -Wformat-nonliteral
465 HOST_CFLAGS     += -Wall -W -Wformat-nonliteral
466 endif
467 CFLAGS          += $(WORKAROUND_CFLAGS) $(EXTRA_CFLAGS)
468 ASFLAGS         += $(WORKAROUND_ASFLAGS) $(EXTRA_ASFLAGS)
469 LDFLAGS         += $(WORKAROUND_LDFLAGS) $(EXTRA_LDFLAGS)
470 HOST_CFLAGS     += -O2 -g
471
472 # Inhibit -Werror if NO_WERROR is specified on make command line
473 #
474 ifneq ($(NO_WERROR),1)
475 CFLAGS          += -Werror
476 ASFLAGS         += --fatal-warnings
477 HOST_CFLAGS     += -Werror
478 endif
479
480 # Enable per-item sections and section garbage collection.  Note that
481 # some older versions of gcc support -fdata-sections but treat it as
482 # implying -fno-common, which would break our build.  Some other older
483 # versions issue a spurious and uninhibitable warning if
484 # -ffunction-sections is used with -g, which would also break our
485 # build since we use -Werror.
486 #
487 ifeq ($(CCTYPE),gcc)
488 DS_TEST         = $(ECHO) 'char x;' | \
489                   $(CC) -fdata-sections -S -x c - -o - 2>/dev/null | \
490                   grep -E '\.comm' > /dev/null
491 DS_FLAGS        := $(shell $(DS_TEST) && $(ECHO) '-fdata-sections')
492 FS_TEST         = $(CC) -ffunction-sections -g -c -x c /dev/null \
493                   -o /dev/null 2>/dev/null
494 FS_FLAGS        := $(shell $(FS_TEST) && $(ECHO) '-ffunction-sections')
495 CFLAGS          += $(FS_FLAGS) $(DS_FLAGS)
496 endif
497 LDFLAGS         += --gc-sections
498
499 # Force creation of static binaries (required for OpenBSD, does no
500 # harm on other platforms).
501 #
502 LDFLAGS         += -static
503
504 # compiler.h is needed for our linking and debugging system
505 #
506 CFLAGS          += -include include/compiler.h
507
508 # The section type character (e.g. "@" in "@progbits") varies by
509 # architecture.
510 #
511 CFLAGS          += -DASM_TCHAR='$(ASM_TCHAR)' -DASM_TCHAR_OPS='$(ASM_TCHAR_OPS)'
512
513 # CFLAGS for specific object types
514 #
515 CFLAGS_c        +=
516 CFLAGS_S        += -DASSEMBLY
517
518 # Base object name of the current target
519 #
520 OBJECT          = $(firstword $(subst ., ,$(@F)))
521
522 # CFLAGS for specific object files.  You can define
523 # e.g. CFLAGS_rtl8139, and have those flags automatically used when
524 # compiling bin/rtl8139.o.
525 #
526 OBJ_CFLAGS      = $(CFLAGS_$(OBJECT)) -DOBJECT=$(subst -,_,$(OBJECT))
527 $(BIN)/%.flags :
528         @$(ECHO) $(OBJ_CFLAGS)
529
530 # Debug level calculations
531 #
532 DBGLVL_MAX      = -DDBGLVL_MAX=$(firstword $(subst ., ,$(1)))
533 DBGLVL_DFLT     = -DDBGLVL_DFLT=$(lastword $(subst ., ,$(1)))
534 DBGLVL          = $(call DBGLVL_MAX,$(1)) $(call DBGLVL_DFLT,$(1))
535
536 # Rules for specific object types.
537 #
538 COMPILE_c       = $(CC) $(CFLAGS) $(CFLAGS_c) $(OBJ_CFLAGS)
539 RULE_c          = $(Q)$(COMPILE_c) -c $< -o $@
540 RULE_c_to_ids.o = $(Q)$(ECHO_E) '$(OBJ_IDS_ASM_NL)' | $(ASSEMBLE_S) -o $@
541 RULE_c_to_dbg%.o= $(Q)$(COMPILE_c) $(call DBGLVL,$*) -c $< -o $@
542 RULE_c_to_c     = $(Q)$(COMPILE_c) -E -c $< > $@
543 RULE_c_to_s     = $(Q)$(COMPILE_c) -S -g0 -c $< -o $@
544
545 PREPROCESS_S    = $(CPP) $(CFLAGS) $(CFLAGS_S) $(OBJ_CFLAGS)
546 ASSEMBLE_S      = $(AS) $(ASFLAGS)
547 RULE_S          = $(Q)$(PREPROCESS_S) $< | $(ASSEMBLE_S) -o $@
548 RULE_S_to_dbg%.o= $(Q)$(PREPROCESS_S) $(call DBGLVL,$*) $< | $(ASSEMBLE_S) -o $@
549 RULE_S_to_s     = $(Q)$(PREPROCESS_S) $< > $@
550
551 GENERIC_TARGETS += ids.o dbg%.o c s
552
553 # List of embedded images included in the last build of embedded.o.
554 # This is needed in order to correctly rebuild embedded.o whenever the
555 # list of objects changes.
556 #
557 EMBED           := $(EMBEDDED_IMAGE) # Maintain backwards compatibility
558 EMBEDDED_LIST   := $(BIN)/.embedded.list
559 ifeq ($(wildcard $(EMBEDDED_LIST)),)
560 EMBED_OLD := <invalid>
561 else
562 EMBED_OLD := $(shell cat $(EMBEDDED_LIST))
563 endif
564 ifneq ($(EMBED_OLD),$(EMBED))
565 $(shell $(ECHO) "$(EMBED)" > $(EMBEDDED_LIST))
566 endif
567
568 $(EMBEDDED_LIST) : $(MAKEDEPS)
569
570 VERYCLEANUP     += $(EMBEDDED_LIST)
571
572 EMBEDDED_FILES  := $(subst $(COMMA), ,$(EMBED))
573 EMBED_ALL       := $(foreach i,$(call seq,1,$(words $(EMBEDDED_FILES))),\
574                      EMBED ( $(i), \"$(word $(i), $(EMBEDDED_FILES))\",\
575                              \"$(notdir $(word $(i),$(EMBEDDED_FILES)))\" ))
576
577 embedded_DEPS += $(EMBEDDED_FILES) $(EMBEDDED_LIST)
578
579 CFLAGS_embedded = -DEMBED_ALL="$(EMBED_ALL)"
580
581 # List of trusted root certificates
582 #
583 TRUSTED_LIST    := $(BIN)/.trusted.list
584 ifeq ($(wildcard $(TRUSTED_LIST)),)
585 TRUST_OLD := <invalid>
586 else
587 TRUST_OLD := $(shell cat $(TRUSTED_LIST))
588 endif
589 ifneq ($(TRUST_OLD),$(TRUST))
590 $(shell $(ECHO) "$(TRUST)" > $(TRUSTED_LIST))
591 endif
592
593 $(TRUSTED_LIST) : $(MAKEDEPS)
594
595 VERYCLEANUP     += $(TRUSTED_LIST)
596
597 # Trusted root certificate fingerprints
598 #
599 TRUSTED_CERTS   := $(subst $(COMMA), ,$(TRUST))
600 TRUSTED_FPS     := $(foreach CERT,$(TRUSTED_CERTS),\
601                      0x$(subst :,$(COMMA) 0x,$(lastword $(subst =, ,\
602                          $(shell $(OPENSSL) x509 -in $(CERT) -noout -sha256 \
603                                  -fingerprint))))$(COMMA))
604
605 rootcert_DEPS += $(TRUSTED_FILES) $(TRUSTED_LIST)
606
607 CFLAGS_rootcert = $(if $(TRUSTED_FPS),-DTRUSTED="$(TRUSTED_FPS)")
608
609 # List of embedded certificates
610 #
611 CERT_LIST := $(BIN)/.certificate.list
612 ifeq ($(wildcard $(CERT_LIST)),)
613 CERT_OLD := <invalid>
614 else
615 CERT_OLD := $(shell cat $(CERT_LIST))
616 endif
617 ifneq ($(CERT_OLD),$(CERT))
618 $(shell $(ECHO) "$(CERT)" > $(CERT_LIST))
619 endif
620
621 $(CERT_LIST) : $(MAKEDEPS)
622
623 VERYCLEANUP += $(CERT_LIST)
624
625 # Embedded certificates concatenated and then split into one file per
626 # certificate (even if original files contained certificate chains)
627 #
628 CERT_FILES := $(subst $(COMMA), ,$(CERT))
629 CERT_CONCAT := $(BIN)/.certificates.pem
630
631 ifneq ($(CERT),)
632
633 CERT_COUNT := $(shell grep "BEGIN CERTIFICATE" $(CERT_FILES) | wc -l)
634
635 $(CERT_CONCAT) : $(CERT_FILES) $(CERT_LIST)
636         $(Q)cat $(CERT_FILES) > $@
637
638 # We must use an (otherwise unnecessary) pattern rule here to encode
639 # the fact that one "csplit" command generates multiple targets
640 CERT_PEMS := $(foreach i,$(call seq,1,$(CERT_COUNT)),\
641                $(BIN)/.certificate.pem.$(i))
642 $(subst .pem.,.%.,$(CERT_PEMS)) : $(BIN)/.certificates.%
643         $(Q)$(CSPLIT) -q -n 1 -f $(BIN)/.certificate.pem. $< \
644                 '/BEGIN CERTIFICATE/' '{*}'
645
646 CERT_DERS := $(subst .certificate.pem.,.certificate.der.,$(CERT_PEMS))
647 $(BIN)/.certificate.der.% : $(BIN)/.certificate.pem.%
648         $(Q)$(OPENSSL) x509 -in $< -outform DER -out $@
649
650 CERT_ALL := $(foreach i,$(call seq,1,$(CERT_COUNT)),\
651               CERT ( $(i), \"$(word $(i),$(CERT_DERS))\" ))
652
653 endif
654
655 certstore_DEPS += $(CERT_LIST) $(CERT_FILES) $(CERT_PEMS) $(CERT_DERS)
656
657 CFLAGS_certstore += -DCERT_ALL="$(CERT_ALL)"
658
659 CLEANUP += $(BIN)/.certificate.* $(BIN)/.certificates.*
660
661 # (Single-element) list of private keys
662 #
663 ifdef KEY
664 PRIVKEY := $(KEY) # Maintain backwards compatibility
665 endif
666 PRIVKEY_LIST := $(BIN)/.private_key.list
667 ifeq ($(wildcard $(PRIVKEY_LIST)),)
668 PRIVKEY_OLD := <invalid>
669 else
670 PRIVKEY_OLD := $(shell cat $(PRIVKEY_LIST))
671 endif
672 ifneq ($(PRIVKEY_OLD),$(PRIVKEY))
673 $(shell $(ECHO) "$(PRIVKEY)" > $(PRIVKEY_LIST))
674 endif
675
676 $(PRIVKEY_LIST) : $(MAKEDEPS)
677
678 VERYCLEANUP += $(PRIVKEY_LIST)
679
680 # Embedded private key
681 #
682 PRIVKEY_INC := $(BIN)/.private_key.der
683
684 ifdef PRIVKEY
685 $(PRIVKEY_INC) : $(PRIVKEY) $(PRIVKEY_LIST)
686         $(Q)$(OPENSSL) rsa -in $< -outform DER -out $@
687
688 privkey_DEPS += $(PRIVKEY_INC)
689 endif
690
691 CLEANUP += $(BIN)/.private_key.*
692
693 privkey_DEPS += $(PRIVKEY_LIST)
694
695 CFLAGS_privkey += $(if $(PRIVKEY),-DPRIVATE_KEY="\"$(PRIVKEY_INC)\"")
696
697 # (Single-element) list of named configurations
698 #
699 CONFIG_LIST := $(BIN)/.config.list
700 ifeq ($(wildcard $(CONFIG_LIST)),)
701 CONFIG_OLD := <invalid>
702 else
703 CONFIG_OLD := $(shell cat $(CONFIG_LIST))
704 endif
705 ifneq ($(CONFIG_OLD),$(CONFIG))
706 $(shell $(ECHO) "$(CONFIG)" > $(CONFIG_LIST))
707 endif
708
709 $(CONFIG_LIST) : $(MAKEDEPS)
710
711 VERYCLEANUP += $(CONFIG_LIST)
712
713 # Named configurations
714 #
715 ifneq ($(CONFIG),)
716 ifneq ($(wildcard config/$(CONFIG)),)
717 CFLAGS  += -DCONFIG=$(CONFIG)
718 endif
719 CFLAGS  += -DLOCAL_CONFIG=$(CONFIG)
720 endif
721
722 config/named.h : $(CONFIG_LIST)
723         $(Q)$(TOUCH) $@
724
725 .PRECIOUS : config/named.h
726
727 # (Single-element) list of assertion configuration
728 #
729 ASSERT_LIST := $(BIN)/.assert.list
730 ifeq ($(wildcard $(ASSERT_LIST)),)
731 ASSERT_OLD := <invalid>
732 else
733 ASSERT_OLD := $(shell cat $(ASSERT_LIST))
734 endif
735 ifneq ($(ASSERT_OLD),$(ASSERT))
736 $(shell $(ECHO) "$(ASSERT)" > $(ASSERT_LIST))
737 endif
738
739 $(ASSERT_LIST) : $(MAKEDEPS)
740
741 VERYCLEANUP += $(ASSERT_LIST)
742
743 # Assertion configuration
744 #
745 ifneq ($(ASSERT),)
746 CFLAGS  += -DASSERTING=$(ASSERT)
747 endif
748
749 include/assert.h : $(ASSERT_LIST)
750         $(Q)$(TOUCH) $@
751
752 .PRECIOUS : include/assert.h
753
754 # (Single-element) list of profiling configuration
755 #
756 PROFILE_LIST := $(BIN)/.profile.list
757 ifeq ($(wildcard $(PROFILE_LIST)),)
758 PROFILE_OLD := <invalid>
759 else
760 PROFILE_OLD := $(shell cat $(PROFILE_LIST))
761 endif
762 ifneq ($(PROFILE_OLD),$(PROFILE))
763 $(shell $(ECHO) "$(PROFILE)" > $(PROFILE_LIST))
764 endif
765
766 $(PROFILE_LIST) : $(MAKEDEPS)
767
768 VERYCLEANUP += $(PROFILE_LIST)
769
770 # Profiling configuration
771 #
772 ifneq ($(PROFILE),)
773 CFLAGS  += -DPROFILING=$(PROFILE)
774 endif
775
776 include/ipxe/profile.h : $(PROFILE_LIST)
777         $(Q)$(TOUCH) $@
778
779 .PRECIOUS : include/ipxe/profile.h
780
781 # (Single-element) list of function recorder configuration
782 #
783 FNREC_LIST := $(BIN)/.fnrec.list
784 ifeq ($(wildcard $(FNREC_LIST)),)
785 FNREC_OLD := <invalid>
786 else
787 FNREC_OLD := $(shell cat $(FNREC_LIST))
788 endif
789 ifneq ($(FNREC_OLD),$(FNREC))
790 $(shell $(ECHO) "$(FNREC)" > $(FNREC_LIST))
791 endif
792
793 $(FNREC_LIST) : $(MAKEDEPS)
794
795 VERYCLEANUP += $(FNREC_LIST)
796
797 # Function recorder configuration
798 #
799 ifeq ($(FNREC),1)
800 # Enabling -finstrument-functions affects gcc's analysis and leads to spurious
801 # warnings about use of uninitialised variables.
802 #
803 CFLAGS          += -Wno-uninitialized
804 CFLAGS          += -finstrument-functions
805 CFLAGS          += -finstrument-functions-exclude-file-list=core/fnrec.c
806 endif
807
808 include/compiler.h : $(FNREC_LIST)
809         $(Q)$(TOUCH) $@
810
811 .PRECIOUS : include/compiler.h
812
813 # These files use .incbin inline assembly to include a binary file.
814 # Unfortunately ccache does not detect this dependency and caches
815 # builds even when the binary file has changed.
816 #
817 $(BIN)/embedded.% : override CC := env CCACHE_DISABLE=1 $(CC)
818 $(BIN)/certstore.% : override CC := env CCACHE_DISABLE=1 $(CC)
819 $(BIN)/privkey.% : override CC := env CCACHE_DISABLE=1 $(CC)
820
821 # Debug message autocolourisation range
822 #
823 DBGCOL_LIST     := $(BIN)/.dbgcol.list
824 ifeq ($(wildcard $(DBGCOL_LIST)),)
825 DBGCOL_OLD := <invalid>
826 else
827 DBGCOL_OLD := $(shell cat $(DBGCOL_LIST))
828 endif
829 ifneq ($(DBGCOL_OLD),$(DBGCOL))
830 $(shell $(ECHO) "$(DBGCOL)" > $(DBGCOL_LIST))
831 endif
832
833 $(DBGCOL_LIST) : $(MAKEDEPS)
834
835 VERYCLEANUP += $(DBGCOL_LIST)
836
837 DBGCOL_COLOURS := $(subst -, ,$(DBGCOL))
838 DBGCOL_MIN := $(firstword $(DBGCOL_COLOURS))
839 DBGCOL_MAX := $(lastword $(DBGCOL_COLOURS))
840
841 debug_DEPS += $(DBGCOL_LIST)
842
843 CFLAGS_debug += $(if $(DBGCOL_MIN),-DDBGCOL_MIN=$(DBGCOL_MIN))
844 CFLAGS_debug += $(if $(DBGCOL_MAX),-DDBGCOL_MAX=$(DBGCOL_MAX))
845
846 # We automatically generate rules for any file mentioned in AUTO_SRCS
847 # using the following set of templates.  We use $(eval ...) if
848 # available, otherwise we generate separate Makefile fragments and
849 # include them.
850
851 # deps_template : generate dependency list for a given source file
852 #
853 # $(1) is the full path to the source file (e.g. "drivers/net/rtl8139.c")
854 #
855 define deps_template_file
856 $(call deps_template_parts,$(1),$(subst .,,$(suffix $(1))),$(basename $(notdir $(1))))
857 endef
858 #
859 # $(1) is the full path to the source file (e.g. "drivers/net/rtl8139.c")
860 # $(2) is the source type (e.g. "c")
861 # $(3) is the source base name (e.g. "rtl8139")
862 #
863 define deps_template_parts
864         @$(ECHO) "  [DEPS] $(1)"
865         @$(MKDIR) -p $(BIN)/deps/$(dir $(1))
866         $(Q)$(CPP) $(CFLAGS) $(CFLAGS_$(2)) $(CFLAGS_$(3)) -DOBJECT=$(3) \
867                 -Wno-error -M $(1) -MG -MP | \
868                 sed 's/\.o[[:blank:]]*:/_DEPS +=/' > $(BIN)/deps/$(1).d
869 endef
870
871 # rules_template : generate rules for a given source file
872 #
873 # $(1) is the full path to the source file (e.g. "drivers/net/rtl8139.c")
874 #
875 define rules_template
876 $(call rules_template_parts,$(1),$(subst .,,$(suffix $(1))),$(basename $(notdir $(1))))
877 endef
878 #
879 # $(1) is the full path to the source file (e.g. "drivers/net/rtl8139.c")
880 # $(2) is the source type (e.g. "c")
881 # $(3) is the source base name (e.g. "rtl8139")
882 #
883 define rules_template_parts
884 $$(BIN)/$(3).o : $(1) $$(MAKEDEPS) $$($(3)_DEPS)
885         $$(QM)$(ECHO) "  [BUILD] $$@"
886         $$(RULE_$(2))
887 BOBJS += $$(BIN)/$(3).o
888 $(foreach TGT,$(GENERIC_TARGETS),$(if $(RULE_$(2)_to_$(TGT)),$(NEWLINE)$(call rules_template_target,$(1),$(2),$(3),$(TGT))))
889 $$(BIN)/deps/$(1).d : $$($(3)_DEPS)
890 TAGS : $$($(3)_DEPS)
891 endef
892 #
893 # $(1) is the full path to the source file (e.g. "drivers/net/rtl8139.c")
894 # $(2) is the source type (e.g. "c")
895 # $(3) is the source base name (e.g. "rtl8139")
896 # $(4) is the destination type (e.g. "dbg%.o")
897 #
898 define rules_template_target
899 $$(BIN)/$(3).$(4) : $(1) $$(MAKEDEPS) $$($(3)_DEPS)
900         $$(QM)$(ECHO) "  [BUILD] $$@"
901         $$(RULE_$(2)_to_$(4))
902 $(TGT)_OBJS += $$(BIN)/$(3).$(4)
903 endef
904 #
905 # $(1) is the full path to the source file (e.g. "drivers/net/rtl8139.c")
906 #
907 define rules_template_file
908         @$(ECHO) "  [RULES] $(1)"
909         @$(MKDIR) -p $(BIN)/rules/$(dir $(1))
910         @$(ECHO_E) '$(subst $(NEWLINE),\n,$(call rules_template,$(1)))' \
911                  > $(BIN)/rules/$(1).r
912 endef
913
914 # Generate the dependency files
915 #
916 $(BIN)/deps/%.d : % $(MAKEDEPS)
917         $(call deps_template_file,$<)
918
919 # Calculate list of dependency files
920 #
921 AUTO_DEPS       = $(patsubst %,$(BIN)/deps/%.d,$(AUTO_SRCS))
922 autodeps :
923         @$(ECHO) $(AUTO_DEPS)
924 VERYCLEANUP     += $(BIN)/deps
925
926 # Include dependency files
927 #
928 ifdef NEED_DEPS
929 ifneq ($(AUTO_DEPS),)
930 -include $(AUTO_DEPS)
931 endif
932 endif
933
934 # Generate the rules files
935 #
936 $(BIN)/rules/%.r : % $(MAKEDEPS)
937         $(call rules_template_file,$<)
938
939 # Calculate list of rules files
940 #
941 AUTO_RULES      = $(patsubst %,$(BIN)/rules/%.r,$(AUTO_SRCS))
942 autorules :
943         @$(ECHO) $(AUTO_RULES)
944 VERYCLEANUP     += $(BIN)/rules
945
946 # Evaluate rules (or include rules files)
947 #
948 ifdef NEED_DEPS
949 ifneq ($(AUTO_RULES),)
950 ifneq ($(HAVE_EVAL),)
951 $(foreach SRC,$(AUTO_SRCS),$(eval $(call rules_template,$(SRC))))
952 else
953 -include $(AUTO_RULES)
954 endif
955 endif
956 endif
957
958 # Files to be parsed using parserom.pl
959 #
960 ROM_SRCS        = $(foreach SRC,$(AUTO_SRCS),\
961                     $(if $(findstring drivers/,$(SRC)),$(SRC)))
962 romsrcs :
963         @$(ECHO) $(ROM_SRCS)
964
965 # List of files to be parsed using parserom.pl
966 #
967 ROM_SRCS_LIST   := $(BIN)/.rom.list
968 ifeq ($(wildcard $(ROM_SRCS_LIST)),)
969 ROM_SRCS_OLD := <invalid>
970 else
971 ROM_SRCS_OLD := $(shell cat $(ROM_SRCS_LIST))
972 endif
973 ifneq ($(ROM_SRCS_OLD),$(ROM_SRCS))
974 $(shell $(ECHO) "$(ROM_SRCS)" > $(ROM_SRCS_LIST))
975 endif
976
977 $(ROM_SRCS_LIST) : $(MAKEDEPS)
978
979 VERYCLEANUP     += $(ROM_SRCS_LIST)
980
981 # ROM definition file
982 #
983 ROMDEFS         = $(BIN)/.rom.defs
984 $(ROMDEFS) : $(ROM_SRCS) $(ROM_SRCS_LIST) $(PARSEROM) $(MAKEDEPS)
985         $(QM)$(ECHO) "  [PARSEROM]"
986         $(Q)$(PERL) $(PARSEROM) $(ROM_SRCS) > $@
987
988 VERYCLEANUP     += $(ROMDEFS)
989
990 # Evaluate ROM definition file
991 ifdef NEED_DEPS
992 ifneq ($(ROM_SRCS),)
993 -include $(ROMDEFS)
994 endif
995 endif
996
997 # Device ID tables (using IDs from ROM definition file)
998 #
999 define obj_pci_id_asm
1000         .section ".pci_devlist.$(1)", "a", $(ASM_TCHAR)progbits
1001         .globl pci_devlist_$(1)
1002 pci_devlist_$(1):
1003         .short ( 0x$(1) & 0xffff )
1004
1005 endef
1006 define obj_isa_id_asm
1007 endef
1008 OBJ_IDS_ASM     = $(foreach ROM,$(ROMS_$(OBJECT)),$(call obj_$(ROM_TYPE_$(ROM))_id_asm,$(ROM)))
1009 OBJ_IDS_ASM_NL  = $(subst $(NEWLINE),\n,$(OBJ_IDS_ASM))
1010 $(BIN)/%.ids :
1011         @$(ECHO_E) '$(OBJ_IDS_ASM_NL)'
1012
1013 BOBJS   += $(patsubst %,$(BIN)/%.ids.o,$(DRIVERS))
1014
1015 # The following variables are created by the autogenerated rules
1016 #
1017 bobjs :
1018         @$(ECHO) $(BOBJS)
1019 drivers_% :
1020         @$(ECHO) $(DRIVERS_$*)
1021 drivers :
1022         @$(ECHO) $(DRIVERS)
1023 .PHONY : drivers
1024 roms :
1025         @$(ECHO) $(ROMS)
1026
1027 # Generate error usage information
1028 #
1029 $(BIN)/%.einfo : $(BIN)/%.o
1030         $(QM)$(ECHO) "  [EINFO] $@"
1031         $(Q)$(OBJCOPY) -O binary -j .einfo --set-section-flags .einfo=alloc \
1032                 $< $@
1033
1034 EINFOS          := $(patsubst $(BIN)/%.o,$(BIN)/%.einfo,$(BOBJS))
1035 $(BIN)/errors : $(EINFOS) $(EINFO)
1036         $(QM)$(ECHO) "  [EINFO] $@"
1037         $(Q)$(EINFO) $(EINFOS) | sort > $@
1038 CLEANUP         += $(BIN)/errors        # Doesn't match the $(BIN)/*.* pattern
1039
1040 # Generate the NIC file from the parsed source files.  The NIC file is
1041 # only for rom-o-matic.
1042 #
1043 $(BIN)/NIC : $(AUTO_DEPS)
1044         @$(ECHO) '# This is an automatically generated file, do not edit' > $@
1045         @$(ECHO) '# It does not affect anything in the build, ' \
1046              'it is only for rom-o-matic' >> $@
1047         @$(ECHO) >> $@
1048         @perl -ne 'chomp; print "$$1\n" if /\# NIC\t(.*)$$/' $^ >> $@
1049 CLEANUP         += $(BIN)/NIC   # Doesn't match the $(BIN)/*.* pattern
1050
1051 # Analyse a target name (e.g. "bin/dfe538--prism2_pci.rom.tmp") and
1052 # derive the variables:
1053
1054 # TGT_ELEMENTS : the elements of the target (e.g. "dfe538 prism2_pci")
1055 # TGT_PREFIX   : the prefix type (e.g. "pcirom")
1056 # TGT_DRIVERS  : the driver for each element (e.g. "rtl8139 prism2_pci")
1057 # TGT_ROM_NAME : the ROM name (e.g. "dfe538")
1058 #
1059 TGT_ELEMENTS    = $(subst --, ,$(firstword $(subst ., ,$(notdir $@))))
1060 TGT_ROM_NAME    = $(firstword $(TGT_ELEMENTS))
1061 TGT_DRIVERS     = $(strip $(foreach TGT_ELEMENT,$(TGT_ELEMENTS), \
1062                                     $(if $(DRIVERS_$(TGT_ELEMENT)), \
1063                                          $(DRIVERS_$(TGT_ELEMENT)), \
1064                                          $(firstword $(DRIVER_$(TGT_ELEMENT)) \
1065                                                      $(TGT_ELEMENT)))))
1066 TGT_PREFIX_NAME = $(word 2,$(subst ., ,$(notdir $@)))
1067 TGT_PREFIX      = $(strip $(if $(filter rom,$(TGT_PREFIX_NAME)), \
1068                                $(ROM_TYPE_$(TGT_ROM_NAME))rom, \
1069                                $(TGT_PREFIX_NAME)))
1070
1071 # Look up ROM IDs for the current target
1072 # (e.g. "bin/dfe538--prism2_pci.rom.tmp") and derive the variables:
1073 #
1074 # TGT_PCI_VENDOR : the PCI vendor ID (e.g. "0x1186")
1075 # TGT_PCI_DEVICE : the PCI device ID (e.g. "0x1300")
1076 #
1077 TGT_PCI_VENDOR  = $(PCI_VENDOR_$(TGT_ROM_NAME))
1078 TGT_PCI_DEVICE  = $(PCI_DEVICE_$(TGT_ROM_NAME))
1079
1080 # Calculate link-time options for the current target
1081 # (e.g. "bin/dfe538--prism2_pci.rom.tmp") and derive the variables:
1082 #
1083 # TGT_LD_DRIVERS : symbols to require in order to drag in the relevant drivers
1084 #                  (e.g. "obj_rtl8139 obj_prism2_pci")
1085 # TGT_LD_IDS :     symbols to define in order to fill in ID structures in the
1086 #                  ROM header (e.g."pci_vendor_id=0x1186 pci_device_id=0x1300")
1087 #
1088 TGT_LD_DRIVERS  = $(subst -,_,$(patsubst %,obj_%,$(TGT_DRIVERS)))
1089 TGT_LD_IDS      = pci_vendor_id=$(firstword $(TGT_PCI_VENDOR) 0) \
1090                   pci_device_id=$(firstword $(TGT_PCI_DEVICE) 0)
1091 TGT_LD_DEVLIST  = $(foreach ELEM,$(TGT_ELEMENTS),$(if $(PCI_VENDOR_$(ELEM)),\
1092                     pci_devlist_$(patsubst 0x%,%,$(PCI_VENDOR_$(ELEM)))$(patsubst 0x%,%,$(PCI_DEVICE_$(ELEM)))))
1093 TGT_LD_ENTRY    = _$(TGT_PREFIX)_start
1094
1095 # Calculate linker flags based on link-time options for the current
1096 # target type (e.g. "bin/dfe538--prism2_pci.rom.tmp") and derive the
1097 # variables:
1098 #
1099 # TGT_LD_FLAGS : target-specific flags to pass to linker (e.g.
1100 #                "-u obj_zpciprefix -u obj_rtl8139 -u obj_prism2_pci
1101 #                 --defsym pci_vendor=0x1186 --defsym pci_device=0x1300")
1102 #
1103 TGT_LD_FLAGS    = $(foreach SYM,$(TGT_LD_ENTRY) $(TGT_LD_DRIVERS) \
1104                     $(TGT_LD_DEVLIST) obj_config obj_config_$(PLATFORM),\
1105                     -u $(SYMBOL_PREFIX)$(SYM) \
1106                     --defsym check_$(SYM)=$(SYMBOL_PREFIX)$(SYM) ) \
1107                   $(patsubst %,--defsym %,$(TGT_LD_IDS)) \
1108                   -e $(SYMBOL_PREFIX)$(TGT_LD_ENTRY)
1109
1110 # Calculate list of debugging versions of objects to be included in
1111 # the target.
1112 #
1113 DEBUG_LIST      = $(subst $(COMMA), ,$(DEBUG))
1114 DEBUG_MAX       = $(firstword $(word 2,$(subst :, ,$(1))) 1)
1115 DEBUG_DFLT      = $(if $(word 3,$(subst :, ,$(1))),.$(word 3,$(subst :, ,$(1))))
1116 DEBUG_LEVEL     = $(call DEBUG_MAX,$(1))$(call DEBUG_DFLT,$(1))
1117 DEBUG_BASE      = $(firstword $(subst :, ,$(1))).dbg$(call DEBUG_LEVEL,$(1))
1118 DEBUG_OBJ       = $(BIN)/$(call DEBUG_BASE,$(1)).o
1119 DEBUG_ORIG_OBJ  = $(BIN)/$(firstword $(subst :, ,$(1))).o
1120 DEBUG_OBJS      = $(foreach D,$(DEBUG_LIST),$(call DEBUG_OBJ,$(D)))
1121 DEBUG_ORIG_OBJS = $(foreach D,$(DEBUG_LIST),$(call DEBUG_ORIG_OBJ,$(D)))
1122 BLIB_OBJS       = $(DEBUG_OBJS) $(filter-out $(DEBUG_ORIG_OBJS),$(BOBJS))
1123
1124 # Print out all derived information for a given target.
1125 #
1126 $(BIN)/%.info :
1127         @$(ECHO) 'Elements             : $(TGT_ELEMENTS)'
1128         @$(ECHO) 'Prefix               : $(TGT_PREFIX)'
1129         @$(ECHO) 'Drivers              : $(TGT_DRIVERS)'
1130         @$(ECHO) 'ROM name             : $(TGT_ROM_NAME)'
1131         @$(ECHO)
1132         @$(ECHO) 'PCI vendor           : $(TGT_PCI_VENDOR)'
1133         @$(ECHO) 'PCI device           : $(TGT_PCI_DEVICE)'
1134         @$(ECHO)
1135         @$(ECHO) 'LD driver symbols    : $(TGT_LD_DRIVERS)'
1136         @$(ECHO) 'LD ID symbols        : $(TGT_LD_IDS)'
1137         @$(ECHO) 'LD devlist symbols   : $(TGT_LD_DEVLIST)'
1138         @$(ECHO) 'LD entry point       : $(TGT_LD_ENTRY)'
1139         @$(ECHO)
1140         @$(ECHO) 'LD target flags      : $(TGT_LD_FLAGS)'
1141         @$(ECHO)
1142         @$(ECHO) 'Debugging objects    : $(DEBUG_OBJS)'
1143         @$(ECHO) 'Replaced objects     : $(DEBUG_ORIG_OBJS)'
1144
1145 # List of objects included in the last build of blib.  This is needed
1146 # in order to correctly rebuild blib whenever the list of objects
1147 # changes.
1148 #
1149 BLIB_LIST       := $(BIN)/.blib.list
1150 ifeq ($(wildcard $(BLIB_LIST)),)
1151 BLIB_OBJS_OLD   := <invalid>
1152 else
1153 BLIB_OBJS_OLD   := $(shell cat $(BLIB_LIST))
1154 endif
1155 ifneq ($(BLIB_OBJS_OLD),$(BLIB_OBJS))
1156 $(shell $(ECHO) "$(BLIB_OBJS)" > $(BLIB_LIST))
1157 endif
1158
1159 $(BLIB_LIST) : $(MAKEDEPS)
1160
1161 VERYCLEANUP     += $(BLIB_LIST)
1162
1163 # Library of all objects
1164 #
1165 BLIB            = $(BIN)/blib.a
1166 $(BLIB) : $(BLIB_OBJS) $(BLIB_LIST) $(MAKEDEPS)
1167         $(Q)$(RM) $(BLIB)
1168         $(QM)$(ECHO) "  [AR] $@"
1169         $(Q)$(AR) rD $@ $(sort $(BLIB_OBJS))
1170         $(Q)$(OBJCOPY) --prefix-symbols=$(SYMBOL_PREFIX) $@
1171         $(Q)$(RANLIB) -D $@
1172 blib : $(BLIB)
1173
1174 # Command to generate build ID.  Must be unique for each $(BIN)/%.tmp,
1175 # even within the same build run.
1176 #
1177 # The build ID is supposed to be collision-free across all ROMs that
1178 # might ever end up installed in the same system.  It doesn't just
1179 # disambiguate targets within a single build; it also disambiguates
1180 # different builds (such as builds for multiple ROMs all built from
1181 # the same blib.a).
1182 #
1183 BUILD_ID_CMD = cat $^ | cksum | awk '{print $$1}'
1184
1185 # Build timestamp
1186 #
1187 # Used as a means to automatically select the newest version of iPXE
1188 # if multiple iPXE drivers are loaded concurrently in a UEFI system.
1189 #
1190 # It gets rounded down to the nearest minute when used for this
1191 # purpose.
1192 #
1193 ifdef SOURCE_DATE_EPOCH
1194 BUILD_TIMESTAMP := $(SOURCE_DATE_EPOCH)
1195 else ifdef GITVERSION
1196 BUILD_TIMESTAMP := $(shell git log -1 --pretty=%ct)
1197 else
1198 BUILD_TIMESTAMP := $(shell date +%s)
1199 endif
1200
1201 # Build version
1202 #
1203 GIT_INDEX := $(if $(GITVERSION),$(if $(wildcard ../.git/index),../.git/index))
1204 $(BIN)/version.%.o : core/version.c $(MAKEDEPS) $(GIT_INDEX)
1205         $(QM)$(ECHO) "  [VERSION] $@"
1206         $(Q)$(COMPILE_c) -DBUILD_NAME="\"$*\"" \
1207                 -DVERSION_MAJOR=$(VERSION_MAJOR) \
1208                 -DVERSION_MINOR=$(VERSION_MINOR) \
1209                 -DVERSION_PATCH=$(VERSION_PATCH) \
1210                 -DVERSION="\"$(VERSION)\"" \
1211                 -c $< -o $@
1212         $(Q)$(OBJCOPY) --prefix-symbols=$(SYMBOL_PREFIX) $@
1213
1214 # Build an intermediate object file from the objects required for the
1215 # specified target.
1216 #
1217 $(BIN)/%.tmp : $(BIN)/version.%.o $(BLIB) $(MAKEDEPS) $(LDSCRIPT)
1218         $(QM)$(ECHO) "  [LD] $@"
1219         $(Q)$(LD) $(LDFLAGS) -T $(LDSCRIPT) $(TGT_LD_FLAGS) $< $(BLIB) -o $@ \
1220                 --defsym _build_id=$(shell $(BUILD_ID_CMD)) \
1221                 --defsym _build_timestamp=$(BUILD_TIMESTAMP) \
1222                 -Map $(BIN)/$*.tmp.map
1223         $(Q)$(OBJDUMP) -ht $@ | $(PERL) $(SORTOBJDUMP) >> $(BIN)/$*.tmp.map
1224
1225 # Keep intermediate object file (useful for debugging)
1226 .PRECIOUS : $(BIN)/%.tmp
1227
1228 # Show a linker map for the specified target
1229 #
1230 $(BIN)/%.map : $(BIN)/%.tmp
1231         @less $(BIN)/$*.tmp.map
1232
1233 # Get objects list for the specified target
1234 #
1235 define objs_list
1236         $(sort $(foreach OBJ_SYMBOL,\
1237                  $(filter obj_%,$(shell $(NM) $(1) | cut -d" " -f3)),\
1238                  $(patsubst obj_%,%,$(OBJ_SYMBOL))))
1239 endef
1240 $(BIN)/%.objs : $(BIN)/%.tmp
1241         $(Q)$(ECHO) $(call objs_list,$<)
1242 $(BIN)/%.sizes : $(BIN)/%.tmp
1243         $(Q)$(SIZE) -t $(foreach OBJ,$(call objs_list,$<),$(wildcard $(BIN)/$(subst _,?,$(OBJ)).o)) | \
1244                 sort -g
1245
1246 # Get dependency list for the specified target
1247 #
1248 define deps_list
1249         $(sort $(foreach OBJ,$(call objs_list,$(1)),$($(OBJ)_DEPS)))
1250 endef
1251 $(BIN)/%.deps : $(BIN)/%.tmp
1252         $(Q)$(ECHO) $(call deps_list,$<)
1253
1254 # Get unneeded source files for the specified target
1255 #
1256 define nodeps_list
1257         $(sort $(filter-out $(call deps_list,$(1)),\
1258                  $(foreach BOBJ,$(BOBJS),\
1259                    $($(basename $(notdir $(BOBJ)))_DEPS))))
1260 endef
1261 $(BIN)/%.nodeps : $(BIN)/%.tmp
1262         $(Q)$(ECHO) $(call nodeps_list,$<)
1263
1264 # Get licensing verdict for the specified target
1265 #
1266 define licensable_deps_list
1267         $(filter-out config/local/%.h,\
1268           $(filter-out $(BIN)/.%.list,\
1269             $(call deps_list,$(1))))
1270 endef
1271 define unlicensed_deps_list
1272         $(shell grep -L FILE_LICENCE $(call licensable_deps_list,$(1)))
1273 endef
1274 define licence_list
1275         $(sort $(foreach LICENCE,\
1276                  $(filter __licence__%,$(shell $(NM) $(1) | cut -d" " -f3)),\
1277                  $(word 2,$(subst __, ,$(LICENCE)))))
1278 endef
1279 $(BIN)/%.licence_list : $(BIN)/%.tmp
1280         $(Q)$(ECHO) $(call licence_list,$<)
1281 $(BIN)/%.licence : $(BIN)/%.tmp
1282         $(QM)$(ECHO) "  [LICENCE] $@"
1283         $(Q)$(if $(strip $(call unlicensed_deps_list,$<)),\
1284                 echo -n "Unable to determine licence because the following " ;\
1285                 echo "files are missing a licence declaration:" ;\
1286                 echo $(call unlicensed_deps_list,$<);\
1287                 exit 1,\
1288                 $(PERL) $(LICENCE) $(call licence_list,$<))
1289
1290 # Extract compression information from intermediate object file
1291 #
1292 $(BIN)/%.zinfo : $(BIN)/%.tmp
1293         $(QM)$(ECHO) "  [ZINFO] $@"
1294         $(Q)$(OBJCOPY) -O binary -j .zinfo $< $@
1295
1296 # Build raw binary file from intermediate object file
1297 #
1298 $(BIN)/%.bin : $(BIN)/%.tmp
1299         $(QM)$(ECHO) "  [BIN] $@"
1300         $(Q)$(OBJCOPY) -O binary -R .zinfo $< $@
1301
1302 # Compress raw binary file
1303 #
1304 $(BIN)/%.zbin : $(BIN)/%.bin $(BIN)/%.zinfo $(ZBIN)
1305         $(QM)$(ECHO) "  [ZBIN] $@"
1306         $(Q)$(ZBIN) $(BIN)/$*.bin $(BIN)/$*.zinfo > $@
1307
1308 # Rules for each media format.  These are generated and placed in an
1309 # external Makefile fragment.  We could do this via $(eval ...), but
1310 # that would require make >= 3.80.
1311
1312 # Note that there's an alternative way to generate most .rom images:
1313 # they can be copied from their 'master' ROM image using cp and
1314 # reprocessed with makerom to add the PCI IDs and ident string.  The
1315 # relevant rule would look something like:
1316 #
1317 #   $(BIN)/dfe538%rom : $(BIN)/rtl8139%rom
1318 #       cat $< $@
1319 #       $(FINALISE_rom)
1320
1321 # You can derive the ROM/driver relationships using the variables
1322 # DRIVER_<rom> and/or ROMS_<driver>.
1323
1324 # We don't currently do this, because (a) it would require generating
1325 # yet more Makefile fragments (since you need a rule for each ROM in
1326 # ROMS), and (b) the linker is so fast that it probably wouldn't make
1327 # much difference to the overall build time.
1328
1329 # Add NON_AUTO_MEDIA to the media list, so that they show up in the
1330 # output of "make"
1331 #
1332 MEDIA           += $(NON_AUTO_MEDIA)
1333
1334 media :
1335         @$(ECHO) $(MEDIA)
1336
1337 AUTO_MEDIA      = $(filter-out $(NON_AUTO_MEDIA),$(MEDIA))
1338 automedia :
1339         @$(ECHO) $(AUTO_MEDIA)
1340
1341 # media_template : create media rules
1342 #
1343 # $(1) is the media name (e.g. "rom")
1344 #
1345 define media_template
1346 $(if $(filter $(1),$(AUTO_MEDIA)),$(call auto_media_template,$(1)))
1347 LIST_$(1) := $$(if $$(LIST_NAME_$(1)),$$($$(LIST_NAME_$(1))),$$(DRIVERS))
1348 ALL_$(1) = $$(foreach ITEM,$$(LIST_$(1)),$$(BIN)/$$(ITEM).$(1))
1349 $$(BIN)/all$(1)s : $$(ALL_$(1))
1350 $$(BIN)/allall : $$(BIN)/all$(1)s
1351 all$(1)s : $$(BIN)/all$(1)s
1352 allall : $$(BIN)/allall
1353 endef
1354 #
1355 # $(1) is the media name (e.g. "rom")
1356 #
1357 define auto_media_template
1358 $$(BIN)/%.$(1) : $$(BIN)/%.$(1).zbin
1359         $$(QM)echo "  [FINISH] $$@"
1360         $$(Q)$$(CP) $$< $$@
1361         $$(Q)$$(if $$(PAD_$(1)),$$(PAD_$(1)) $$@)
1362         $$(Q)$$(if $$(FINALISE_$(1)),$$(FINALISE_$(1)) $$@)
1363 endef
1364 #
1365 # $(1) is the media name (e.g. "rom")
1366 #
1367 define media_template_file
1368         @$(ECHO) "  [MEDIARULES] $(1)"
1369         @$(MKDIR) -p $(BIN)/rules/$(dir $(1))
1370         @$(ECHO_E) '$(subst $(NEWLINE),\n,$(call media_template,$(1)))' \
1371                 > $(BIN)/rules/$(1).media.r
1372 endef
1373
1374 # Generate media rules files
1375 #
1376 $(BIN)/rules/%.media.r : $(MAKEDEPS)
1377         $(call media_template_file,$*)
1378
1379 # Calculate list of media rules files
1380 #
1381 MEDIA_RULES             = $(patsubst %,$(BIN)/rules/%.media.r,$(MEDIA))
1382 mediarules :
1383         @$(ECHO) $(MEDIA_RULES)
1384
1385 # Evaluate media rules (or include media rules files)
1386 #
1387 ifdef NEED_DEPS
1388 ifneq ($(MEDIA_RULES),)
1389 ifneq ($(HAVE_EVAL),)
1390 $(foreach MEDIUM,$(MEDIA),$(eval $(call media_template,$(MEDIUM))))
1391 else
1392 -include $(MEDIA_RULES)
1393 endif
1394 endif
1395 endif
1396
1397 # Alias for ipxe.%
1398 #
1399 $(BIN)/etherboot.% : $(BIN)/ipxe.%
1400         ln -sf $(notdir $<) $@
1401
1402 endif # defined(BIN)
1403
1404 ###############################################################################
1405 #
1406 # The compression utilities
1407 #
1408
1409 ZBIN_LDFLAGS := -llzma
1410
1411 $(ZBIN) : util/zbin.c $(MAKEDEPS)
1412         $(QM)$(ECHO) "  [HOSTCC] $@"
1413         $(Q)$(HOST_CC) $(HOST_CFLAGS) $< $(ZBIN_LDFLAGS) -o $@
1414 CLEANUP += $(ZBIN)
1415
1416 ###############################################################################
1417 #
1418 # The EFI image converter
1419 #
1420
1421 $(ELF2EFI32) : util/elf2efi.c $(MAKEDEPS)
1422         $(QM)$(ECHO) "  [HOSTCC] $@"
1423         $(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -DEFI_TARGET32 $< -o $@
1424 CLEANUP += $(ELF2EFI32)
1425
1426 $(ELF2EFI64) : util/elf2efi.c $(MAKEDEPS)
1427         $(QM)$(ECHO) "  [HOSTCC] $@"
1428         $(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -DEFI_TARGET64 $< -o $@
1429 CLEANUP += $(ELF2EFI64)
1430
1431 $(EFIROM) : util/efirom.c util/eficompress.c $(MAKEDEPS)
1432         $(QM)$(ECHO) "  [HOSTCC] $@"
1433         $(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -o $@ $<
1434 CLEANUP += $(EFIROM)
1435
1436 $(EFIFATBIN) : util/efifatbin.c $(MAKEDEPS)
1437         $(QM)$(ECHO) "  [HOSTCC] $@"
1438         $(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -o $@ $<
1439 CLEANUP += $(EFIFATBIN)
1440
1441 ###############################################################################
1442 #
1443 # The error usage information utility
1444 #
1445 $(EINFO) : util/einfo.c $(MAKEDEPS)
1446         $(QM)$(ECHO) "  [HOSTCC] $@"
1447         $(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -o $@ $<
1448 CLEANUP += $(EINFO)
1449
1450 ###############################################################################
1451 #
1452 # Local configs
1453 #
1454 CONFIG_HEADERS := $(patsubst config/%,%,$(wildcard config/*.h))
1455 CONFIG_LOCAL_HEADERS := $(foreach HEADER,$(CONFIG_HEADERS),\
1456                                   config/local/$(HEADER))
1457
1458 $(CONFIG_LOCAL_HEADERS) :
1459         $(Q)$(TOUCH) $@
1460
1461 .PRECIOUS : $(CONFIG_LOCAL_HEADERS)
1462
1463 ifneq ($(CONFIG),)
1464
1465 CONFIG_LOCAL_NAMED_HEADERS := $(foreach HEADER,$(CONFIG_HEADERS),\
1466                                         config/local/$(CONFIG)/$(HEADER))
1467
1468 $(CONFIG_LOCAL_NAMED_HEADERS) :
1469         $(Q)$(MKDIR) -p $(dir $@)
1470         $(Q)$(TOUCH) $@
1471
1472 .PRECIOUS : $(CONFIG_LOCAL_NAMED_HEADERS)
1473
1474 endif
1475
1476 ###############################################################################
1477 #
1478 # Build the TAGS file(s) for emacs
1479 #
1480 TAGS :
1481         ctags -e -R -f $@ --exclude=bin
1482
1483 CLEANUP += TAGS
1484
1485 ###############################################################################
1486 #
1487 # Force rebuild for any given target
1488 #
1489 %.rebuild :
1490         rm -f $*
1491         $(Q)$(MAKE) $*
1492
1493 ###############################################################################
1494 #
1495 # Symbol table checks
1496 #
1497
1498 ifdef BIN
1499
1500 SYMTAB  = $(BIN)/symtab
1501 $(SYMTAB) : $(BLIB)
1502         $(OBJDUMP) -w -t $< > $@
1503
1504 CLEANUP += $(BIN)/symtab
1505
1506 symcheck : $(SYMTAB)
1507         $(PERL) $(SYMCHECK) $<
1508
1509 endif # defined(BIN)
1510
1511 ###############################################################################
1512 #
1513 # Build bochs symbol table
1514 #
1515
1516 ifdef BIN
1517
1518 $(BIN)/%.bxs : $(BIN)/%.tmp
1519         $(NM) $< | cut -d" " -f1,3 > $@
1520
1521 endif # defined(BIN)
1522
1523 ###############################################################################
1524 #
1525 # Documentation
1526 #
1527
1528 ifdef BIN
1529
1530 $(BIN)/doxygen.cfg : doxygen.cfg $(MAKEDEPS)
1531         $(Q)$(PERL) -pe 's{\@SRCDIRS\@}{$(SRCDIRS)}; ' \
1532                 -e  's{\@INCDIRS\@}{$(filter-out .,$(INCDIRS))}; ' \
1533                 -e  's{\@BIN\@}{$(BIN)}; ' \
1534                 -e  's{\@ARCH\@}{$(ARCH)}; ' \
1535                 $< > $@
1536
1537 $(BIN)/doc : $(BIN)/doxygen.cfg
1538         $(Q)$(DOXYGEN) $<
1539
1540 .PHONY : $(BIN)/doc
1541
1542 doc : $(BIN)/doc
1543
1544 doc-clean :
1545         $(Q)$(RM) -r $(BIN)/doc
1546
1547 VERYCLEANUP     += $(BIN)/doc
1548
1549 docview :
1550         @[ -f $(BIN)/doc/html/index.html ] || $(MAKE) $(BIN)/doc
1551         @if [ -n "$$BROWSER" ] ; then \
1552                 ( $$BROWSER $(BIN)/doc/html/index.html & ) ; \
1553         else \
1554                 $(ECHO) "Documentation index in $(BIN)/doc/html/index.html" ; \
1555         fi
1556
1557 endif # defined(BIN)
1558
1559 ###############################################################################
1560 #
1561 # Keyboard maps
1562 #
1563
1564 hci/keymap/keymap_%.c :
1565         $(Q)$(PERL) $(GENKEYMAP) $* > $@
1566
1567 ###############################################################################
1568 #
1569 # Force deletion of incomplete targets
1570 #
1571
1572 .DELETE_ON_ERROR :
1573
1574 ###############################################################################
1575 #
1576 # Clean-up
1577 #
1578
1579 ifeq ($(NUM_BINS),0)
1580 ALLBINS         := bin bin-*
1581 ALLBIN          = $(foreach B,$(ALLBINS),$(patsubst $(BIN)/%,$(B)/%,$(1)))
1582 CLEANUP         := $(foreach C,$(CLEANUP),$(call ALLBIN,$(C)))
1583 VERYCLEANUP     := $(foreach V,$(VERYCLEANUP),$(call ALLBIN,$(V)))
1584 endif
1585
1586 clean :
1587         $(RM) -r $(CLEANUP)
1588
1589 veryclean : clean
1590         $(RM) -r $(VERYCLEANUP)