tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

kbuild: rename LDFLAGS to KBUILD_LDFLAGS

Commit a0f97e06a43c ("kbuild: enable 'make CFLAGS=...' to add
additional options to CC") renamed CFLAGS to KBUILD_CFLAGS.

Commit 222d394d30e7 ("kbuild: enable 'make AFLAGS=...' to add
additional options to AS") renamed AFLAGS to KBUILD_AFLAGS.

Commit 06c5040cdb13 ("kbuild: enable 'make CPPFLAGS=...' to add
additional options to CPP") renamed CPPFLAGS to KBUILD_CPPFLAGS.

For some reason, LDFLAGS was not renamed.

Using a well-known variable like LDFLAGS may result in accidental
override of the variable.

Kbuild generally uses KBUILD_ prefixed variables for the internally
appended options, so here is one more conversion to sanitize the
naming convention.

I did not touch Makefiles under tools/ since the tools build system
is a different world.

Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
Acked-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Reviewed-by: Palmer Dabbelt <palmer@sifive.com>

Masahiro Yamada d503ac53 87a32e62

+48 -51
+3 -3
Makefile
··· 440 440 KBUILD_AFLAGS_MODULE := -DMODULE 441 441 KBUILD_CFLAGS_MODULE := -DMODULE 442 442 KBUILD_LDFLAGS_MODULE := -T $(srctree)/scripts/module-common.lds 443 - LDFLAGS := 443 + KBUILD_LDFLAGS := 444 444 GCC_PLUGINS_CFLAGS := 445 445 446 446 export ARCH SRCARCH CONFIG_SHELL HOSTCC KBUILD_HOSTCFLAGS CROSS_COMPILE AS LD CC ··· 448 448 export MAKE LEX YACC AWK GENKSYMS INSTALLKERNEL PERL PYTHON PYTHON2 PYTHON3 UTS_MACHINE 449 449 export HOSTCXX KBUILD_HOSTCXXFLAGS LDFLAGS_MODULE CHECK CHECKFLAGS 450 450 451 - export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS LDFLAGS 451 + export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS KBUILD_LDFLAGS 452 452 export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE 453 453 export CFLAGS_KASAN CFLAGS_KASAN_NOSANITIZE CFLAGS_UBSAN 454 454 export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE ··· 1020 1020 1021 1021 # Final link of vmlinux with optional arch pass after final link 1022 1022 cmd_link-vmlinux = \ 1023 - $(CONFIG_SHELL) $< $(LD) $(LDFLAGS) $(LDFLAGS_vmlinux) ; \ 1023 + $(CONFIG_SHELL) $< $(LD) $(KBUILD_LDFLAGS) $(LDFLAGS_vmlinux) ; \ 1024 1024 $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true) 1025 1025 1026 1026 vmlinux: scripts/link-vmlinux.sh autoksyms_recursive $(vmlinux-deps) FORCE
+1 -1
arch/arc/Makefile
··· 95 95 # Finally dump eveything into kernel build system 96 96 KBUILD_CFLAGS += $(cflags-y) 97 97 KBUILD_AFLAGS += $(KBUILD_CFLAGS) 98 - LDFLAGS += $(ldflags-y) 98 + KBUILD_LDFLAGS += $(ldflags-y) 99 99 100 100 head-y := arch/arc/kernel/head.o 101 101
+2 -2
arch/arm/Makefile
··· 43 43 KBUILD_CPPFLAGS += -mbig-endian 44 44 CHECKFLAGS += -D__ARMEB__ 45 45 AS += -EB 46 - LDFLAGS += -EB 46 + KBUILD_LDFLAGS += -EB 47 47 else 48 48 KBUILD_CPPFLAGS += -mlittle-endian 49 49 CHECKFLAGS += -D__ARMEL__ 50 50 AS += -EL 51 - LDFLAGS += -EL 51 + KBUILD_LDFLAGS += -EL 52 52 endif 53 53 54 54 #
+2 -2
arch/arm64/Makefile
··· 62 62 AS += -EB 63 63 # Prefer the baremetal ELF build target, but not all toolchains include 64 64 # it so fall back to the standard linux version if needed. 65 - LDFLAGS += -EB $(call ld-option, -maarch64elfb, -maarch64linuxb) 65 + KBUILD_LDFLAGS += -EB $(call ld-option, -maarch64elfb, -maarch64linuxb) 66 66 UTS_MACHINE := aarch64_be 67 67 else 68 68 KBUILD_CPPFLAGS += -mlittle-endian 69 69 CHECKFLAGS += -D__AARCH64EL__ 70 70 AS += -EL 71 71 # Same as above, prefer ELF but fall back to linux target if needed. 72 - LDFLAGS += -EL $(call ld-option, -maarch64elf, -maarch64linux) 72 + KBUILD_LDFLAGS += -EL $(call ld-option, -maarch64elf, -maarch64linux) 73 73 UTS_MACHINE := aarch64 74 74 endif 75 75
+1 -2
arch/c6x/Makefile
··· 23 23 KBUILD_CFLAGS += -mbig-endian 24 24 KBUILD_AFLAGS += -mbig-endian 25 25 LINKFLAGS += -mbig-endian 26 - KBUILD_LDFLAGS += -mbig-endian 27 - LDFLAGS += -EB 26 + KBUILD_LDFLAGS += -mbig-endian -EB 28 27 CHECKFLAGS += -D_BIG_ENDIAN 29 28 endif 30 29
+1 -1
arch/h8300/Makefile
··· 20 20 KBUILD_CFLAGS += -D__linux__ 21 21 KBUILD_CFLAGS += -DUTS_SYSNAME=\"uClinux\" 22 22 KBUILD_AFLAGS += $(aflags-y) 23 - LDFLAGS += $(ldflags-y) 23 + KBUILD_LDFLAGS += $(ldflags-y) 24 24 25 25 ifeq ($(CROSS_COMPILE),) 26 26 CROSS_COMPILE := h8300-unknown-linux-
+1 -3
arch/hexagon/Makefile
··· 22 22 23 23 KBUILD_CFLAGS += $(cflags-y) 24 24 KBUILD_AFLAGS += $(aflags-y) 25 - 26 - # no KBUILD_LDFLAGS? 27 - LDFLAGS += $(ldflags-y) 25 + KBUILD_LDFLAGS += $(ldflags-y) 28 26 29 27 # Thread-info register will be r19. This value is not configureable; 30 28 # it is hard-coded in several files.
+1 -1
arch/m68k/Makefile
··· 69 69 KBUILD_AFLAGS += -D__uClinux__ 70 70 endif 71 71 72 - LDFLAGS := -m m68kelf 72 + KBUILD_LDFLAGS := -m m68kelf 73 73 KBUILD_LDFLAGS_MODULE += -T $(srctree)/arch/m68k/kernel/module.lds 74 74 75 75 ifdef CONFIG_SUN3
+2 -2
arch/microblaze/Makefile
··· 40 40 ifdef CONFIG_CPU_BIG_ENDIAN 41 41 KBUILD_CFLAGS += -mbig-endian 42 42 KBUILD_AFLAGS += -mbig-endian 43 - LDFLAGS += -EB 43 + KBUILD_LDFLAGS += -EB 44 44 else 45 45 KBUILD_CFLAGS += -mlittle-endian 46 46 KBUILD_AFLAGS += -mlittle-endian 47 - LDFLAGS += -EL 47 + KBUILD_LDFLAGS += -EL 48 48 endif 49 49 50 50 CPUFLAGS-1 += $(call cc-option,-mcpu=v$(CPU_VER))
+1 -1
arch/mips/Makefile
··· 309 309 # instead of .eh_frame so we don't discard them. 310 310 KBUILD_CFLAGS += -fno-asynchronous-unwind-tables 311 311 312 - LDFLAGS += -m $(ld-emul) 312 + KBUILD_LDFLAGS += -m $(ld-emul) 313 313 314 314 ifdef CONFIG_MIPS 315 315 CHECKFLAGS += $(shell $(CC) $(KBUILD_CFLAGS) -dM -E -x c /dev/null | \
+1 -1
arch/mips/boot/compressed/Makefile
··· 92 92 vmlinuzobjs-y += $(obj)/piggy.o 93 93 94 94 quiet_cmd_zld = LD $@ 95 - cmd_zld = $(LD) $(LDFLAGS) -Ttext $(VMLINUZ_LOAD_ADDRESS) -T $< $(vmlinuzobjs-y) -o $@ 95 + cmd_zld = $(LD) $(KBUILD_LDFLAGS) -Ttext $(VMLINUZ_LOAD_ADDRESS) -T $< $(vmlinuzobjs-y) -o $@ 96 96 quiet_cmd_strip = STRIP $@ 97 97 cmd_strip = $(STRIP) -s $@ 98 98 vmlinuz: $(src)/ld.script $(vmlinuzobjs-y) $(obj)/calc_vmlinuz_load_addr
+1 -1
arch/mips/lasat/image/Makefile
··· 38 38 39 39 # Rule to make the bootloader 40 40 $(obj)/rom: $(addprefix $(obj)/,$(OBJECTS)) 41 - $(LD) $(LDFLAGS) $(LDSCRIPT) -o $@ $^ 41 + $(LD) $(KBUILD_LDFLAGS) $(LDSCRIPT) -o $@ $^ 42 42 43 43 $(obj)/%.o: $(obj)/%.gz 44 44 $(LD) -r -o $@ -b binary $<
+2 -2
arch/nds32/Makefile
··· 33 33 ifdef CONFIG_CPU_LITTLE_ENDIAN 34 34 KBUILD_CFLAGS += $(call cc-option, -EL) 35 35 KBUILD_AFLAGS += $(call cc-option, -EL) 36 - LDFLAGS += $(call cc-option, -EL) 36 + KBUILD_LDFLAGS += $(call cc-option, -EL) 37 37 CHECKFLAGS += -D__NDS32_EL__ 38 38 else 39 39 KBUILD_CFLAGS += $(call cc-option, -EB) 40 40 KBUILD_AFLAGS += $(call cc-option, -EB) 41 - LDFLAGS += $(call cc-option, -EB) 41 + KBUILD_LDFLAGS += $(call cc-option, -EB) 42 42 CHECKFLAGS += -D__NDS32_EB__ 43 43 endif 44 44
+3 -3
arch/powerpc/Makefile
··· 76 76 77 77 ifdef CONFIG_CPU_LITTLE_ENDIAN 78 78 KBUILD_CFLAGS += -mlittle-endian 79 - LDFLAGS += -EL 79 + KBUILD_LDFLAGS += -EL 80 80 LDEMULATION := lppc 81 81 GNUTARGET := powerpcle 82 82 MULTIPLEWORD := -mno-multiple 83 83 KBUILD_CFLAGS_MODULE += $(call cc-option,-mno-save-toc-indirect) 84 84 else 85 85 KBUILD_CFLAGS += $(call cc-option,-mbig-endian) 86 - LDFLAGS += -EB 86 + KBUILD_LDFLAGS += -EB 87 87 LDEMULATION := ppc 88 88 GNUTARGET := powerpc 89 89 MULTIPLEWORD := -mmultiple ··· 108 108 ifeq ($(HAS_BIARCH),y) 109 109 KBUILD_CFLAGS += -m$(BITS) 110 110 KBUILD_AFLAGS += -m$(BITS) -Wl,-a$(BITS) 111 - LDFLAGS += -m elf$(BITS)$(LDEMULATION) 111 + KBUILD_LDFLAGS += -m elf$(BITS)$(LDEMULATION) 112 112 KBUILD_ARFLAGS += --target=elf$(BITS)-$(GNUTARGET) 113 113 endif 114 114
+2 -2
arch/riscv/Makefile
··· 29 29 KBUILD_CFLAGS += $(call cc-ifversion, -ge, 0500, -DCONFIG_ARCH_SUPPORTS_INT128) 30 30 31 31 KBUILD_MARCH = rv64im 32 - LDFLAGS += -melf64lriscv 32 + KBUILD_LDFLAGS += -melf64lriscv 33 33 else 34 34 BITS := 32 35 35 UTS_MACHINE := riscv32 ··· 37 37 KBUILD_CFLAGS += -mabi=ilp32 38 38 KBUILD_AFLAGS += -mabi=ilp32 39 39 KBUILD_MARCH = rv32im 40 - LDFLAGS += -melf32lriscv 40 + KBUILD_LDFLAGS += -melf32lriscv 41 41 endif 42 42 43 43 KBUILD_CFLAGS += -Wall
+1 -1
arch/s390/Makefile
··· 11 11 # 12 12 13 13 LD_BFD := elf64-s390 14 - LDFLAGS := -m elf64_s390 14 + KBUILD_LDFLAGS := -m elf64_s390 15 15 KBUILD_AFLAGS_MODULE += -fPIC 16 16 KBUILD_CFLAGS_MODULE += -fPIC 17 17 KBUILD_AFLAGS += -m64
+2 -2
arch/sh/Makefile
··· 122 122 ifdef CONFIG_CPU_LITTLE_ENDIAN 123 123 ld-bfd := elf32-$(UTS_MACHINE)-linux 124 124 LDFLAGS_vmlinux += --defsym jiffies=jiffies_64 --oformat $(ld-bfd) 125 - LDFLAGS += -EL 125 + KBUILD_LDFLAGS += -EL 126 126 else 127 127 ld-bfd := elf32-$(UTS_MACHINE)big-linux 128 128 LDFLAGS_vmlinux += --defsym jiffies=jiffies_64+4 --oformat $(ld-bfd) 129 - LDFLAGS += -EB 129 + KBUILD_LDFLAGS += -EB 130 130 endif 131 131 132 132 export ld-bfd BITS
+2 -2
arch/sparc/Makefile
··· 21 21 # 22 22 23 23 CHECKFLAGS += -D__sparc__ 24 - LDFLAGS := -m elf32_sparc 24 + KBUILD_LDFLAGS := -m elf32_sparc 25 25 export BITS := 32 26 26 UTS_MACHINE := sparc 27 27 ··· 40 40 # 41 41 42 42 CHECKFLAGS += -D__sparc__ -D__sparc_v9__ -D__arch64__ 43 - LDFLAGS := -m elf64_sparc 43 + KBUILD_LDFLAGS := -m elf64_sparc 44 44 export BITS := 64 45 45 UTS_MACHINE := sparc64 46 46
+1 -1
arch/um/Makefile
··· 133 133 # The wrappers will select whether using "malloc" or the kernel allocator. 134 134 LINK_WRAPS = -Wl,--wrap,malloc -Wl,--wrap,free -Wl,--wrap,calloc 135 135 136 - LD_FLAGS_CMDLINE = $(foreach opt,$(LDFLAGS),-Wl,$(opt)) 136 + LD_FLAGS_CMDLINE = $(foreach opt,$(KBUILD_LDFLAGS),-Wl,$(opt)) 137 137 138 138 # Used by link-vmlinux.sh which has special support for um link 139 139 export CFLAGS_vmlinux := $(LINK-y) $(LINK_WRAPS) $(LD_FLAGS_CMDLINE)
+2 -2
arch/x86/Makefile
··· 219 219 KBUILD_AFLAGS += $(cfi) $(cfi-sigframe) $(cfi-sections) $(asinstr) $(avx_instr) $(avx2_instr) $(avx512_instr) $(sha1_ni_instr) $(sha256_ni_instr) 220 220 KBUILD_CFLAGS += $(cfi) $(cfi-sigframe) $(cfi-sections) $(asinstr) $(avx_instr) $(avx2_instr) $(avx512_instr) $(sha1_ni_instr) $(sha256_ni_instr) 221 221 222 - LDFLAGS := -m elf_$(UTS_MACHINE) 222 + KBUILD_LDFLAGS := -m elf_$(UTS_MACHINE) 223 223 224 224 # 225 225 # The 64-bit kernel must be aligned to 2MB. Pass -z max-page-size=0x200000 to ··· 227 227 # by the linker. 228 228 # 229 229 ifdef CONFIG_X86_64 230 - LDFLAGS += $(call ld-option, -z max-page-size=0x200000) 230 + KBUILD_LDFLAGS += $(call ld-option, -z max-page-size=0x200000) 231 231 endif 232 232 233 233 # Speed up the build
+2 -2
arch/x86/Makefile.um
··· 4 4 ifeq ($(CONFIG_X86_32),y) 5 5 START := 0x8048000 6 6 7 - LDFLAGS += -m elf_i386 7 + KBUILD_LDFLAGS += -m elf_i386 8 8 ELF_ARCH := i386 9 9 ELF_FORMAT := elf32-i386 10 10 CHECKFLAGS += -D__i386__ ··· 43 43 44 44 CHECKFLAGS += -m64 -D__x86_64__ 45 45 KBUILD_AFLAGS += -m64 46 - LDFLAGS += -m elf_x86_64 46 + KBUILD_LDFLAGS += -m elf_x86_64 47 47 KBUILD_CPPFLAGS += -m64 48 48 49 49 ELF_ARCH := i386:x86-64
+3 -3
arch/x86/boot/compressed/Makefile
··· 42 42 GCOV_PROFILE := n 43 43 UBSAN_SANITIZE :=n 44 44 45 - LDFLAGS := -m elf_$(UTS_MACHINE) 45 + KBUILD_LDFLAGS := -m elf_$(UTS_MACHINE) 46 46 # Compressed kernel should be built as PIE since it may be loaded at any 47 47 # address by the bootloader. 48 48 ifeq ($(CONFIG_X86_32),y) 49 - LDFLAGS += $(call ld-option, -pie) $(call ld-option, --no-dynamic-linker) 49 + KBUILD_LDFLAGS += $(call ld-option, -pie) $(call ld-option, --no-dynamic-linker) 50 50 else 51 51 # To build 64-bit compressed kernel as PIE, we disable relocation 52 52 # overflow check to avoid relocation overflow error with a new linker 53 53 # command-line option, -z noreloc-overflow. 54 - LDFLAGS += $(shell $(LD) --help 2>&1 | grep -q "\-z noreloc-overflow" \ 54 + KBUILD_LDFLAGS += $(shell $(LD) --help 2>&1 | grep -q "\-z noreloc-overflow" \ 55 55 && echo "-z noreloc-overflow -pie --no-dynamic-linker") 56 56 endif 57 57 LDFLAGS_vmlinux := -T
+1 -1
arch/xtensa/Makefile
··· 49 49 KBUILD_AFLAGS += -mlongcalls -mtext-section-literals 50 50 51 51 ifneq ($(CONFIG_LD_NO_RELAX),) 52 - LDFLAGS := --no-relax 52 + KBUILD_LDFLAGS := --no-relax 53 53 endif 54 54 55 55 ifeq ($(shell echo __XTENSA_EB__ | $(CC) -E - | grep -v "\#"),1)
+1 -1
arch/xtensa/boot/boot-elf/Makefile
··· 25 25 $(OBJS) $@ 26 26 27 27 $(obj)/../Image.elf: $(obj)/Image.o $(obj)/boot.lds 28 - $(Q)$(LD) $(LDFLAGS) $(LDFLAGS_vmlinux) \ 28 + $(Q)$(LD) $(KBUILD_LDFLAGS) $(LDFLAGS_vmlinux) \ 29 29 -T $(obj)/boot.lds \ 30 30 --build-id=none \ 31 31 -o $@ $(obj)/Image.o
+2 -2
scripts/Kbuild.include
··· 163 163 $(CC) $(1) $(KBUILD_CPPFLAGS) $(CC_OPTION_CFLAGS) -nostdlib -x c /dev/null -o "$$TMP",$(1),$(2)) 164 164 165 165 # ld-option 166 - # Usage: LDFLAGS += $(call ld-option, -X, -Y) 167 - ld-option = $(call try-run, $(LD) $(LDFLAGS) $(1) -v,$(1),$(2),$(3)) 166 + # Usage: KBUILD_LDFLAGS += $(call ld-option, -X, -Y) 167 + ld-option = $(call try-run, $(LD) $(KBUILD_LDFLAGS) $(1) -v,$(1),$(2),$(3)) 168 168 169 169 # ar-option 170 170 # Usage: KBUILD_ARFLAGS := $(call ar-option,D)
+3 -3
scripts/Makefile.build
··· 190 190 $(call cmd_gensymtypes_c,$(KBUILD_SYMTYPES),$(@:.o=.symtypes)) \ 191 191 > $(@D)/.tmp_$(@F:.o=.ver); \ 192 192 \ 193 - $(LD) $(LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F) \ 193 + $(LD) $(KBUILD_LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F) \ 194 194 -T $(@D)/.tmp_$(@F:.o=.ver); \ 195 195 rm -f $(@D)/.tmp_$(@F) $(@D)/.tmp_$(@F:.o=.ver); \ 196 196 else \ ··· 220 220 "$(if $(CONFIG_CPU_BIG_ENDIAN),big,little)" \ 221 221 "$(if $(CONFIG_64BIT),64,32)" \ 222 222 "$(OBJDUMP)" "$(OBJCOPY)" "$(CC) $(KBUILD_CFLAGS)" \ 223 - "$(LD) $(LDFLAGS)" "$(NM)" "$(RM)" "$(MV)" \ 223 + "$(LD) $(KBUILD_LDFLAGS)" "$(NM)" "$(RM)" "$(MV)" \ 224 224 "$(if $(part-of-module),1,0)" "$(@)"; 225 225 recordmcount_source := $(srctree)/scripts/recordmcount.pl 226 226 endif # BUILD_C_RECORDMCOUNT ··· 394 394 $(call cmd_gensymtypes_S,$(KBUILD_SYMTYPES),$(@:.o=.symtypes)) \ 395 395 > $(@D)/.tmp_$(@F:.o=.ver); \ 396 396 \ 397 - $(LD) $(LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F) \ 397 + $(LD) $(KBUILD_LDFLAGS) -r -o $@ $(@D)/.tmp_$(@F) \ 398 398 -T $(@D)/.tmp_$(@F:.o=.ver); \ 399 399 rm -f $(@D)/.tmp_$(@F) $(@D)/.tmp_$(@F:.o=.ver); \ 400 400 else \
+1 -1
scripts/Makefile.lib
··· 162 162 cpp_flags = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ 163 163 $(__cpp_flags) 164 164 165 - ld_flags = $(LDFLAGS) $(ldflags-y) $(LDFLAGS_$(@F)) 165 + ld_flags = $(KBUILD_LDFLAGS) $(ldflags-y) $(LDFLAGS_$(@F)) 166 166 167 167 DTC_INCLUDE := $(srctree)/scripts/dtc/include-prefixes 168 168
+1 -1
scripts/Makefile.modpost
··· 120 120 # Step 6), final link of the modules with optional arch pass after final link 121 121 quiet_cmd_ld_ko_o = LD [M] $@ 122 122 cmd_ld_ko_o = \ 123 - $(LD) -r $(LDFLAGS) \ 123 + $(LD) -r $(KBUILD_LDFLAGS) \ 124 124 $(KBUILD_LDFLAGS_MODULE) $(LDFLAGS_MODULE) \ 125 125 -o $@ $(filter-out FORCE,$^) ; \ 126 126 $(if $(ARCH_POSTLINK), $(MAKE) -f $(ARCH_POSTLINK) $@, true)