2007-10-16 00:25:06 +04:00
# Backward compatibility
asflags-y += $( EXTRA_AFLAGS)
ccflags-y += $( EXTRA_CFLAGS)
cppflags-y += $( EXTRA_CPPFLAGS)
ldflags-y += $( EXTRA_LDFLAGS)
2009-04-19 13:04:26 +04:00
#
# flags that take effect in sub directories
export KBUILD_SUBDIR_ASFLAGS := $( KBUILD_SUBDIR_ASFLAGS) $( subdir-asflags-y)
export KBUILD_SUBDIR_CCFLAGS := $( KBUILD_SUBDIR_CCFLAGS) $( subdir-ccflags-y)
2005-04-17 02:20:36 +04:00
# Figure out what we need to build from the various variables
# ===========================================================================
# When an object is listed to be built compiled-in and modular,
# only build the compiled-in version
obj-m := $( filter-out $( obj-y) ,$( obj-m) )
# Libraries are always collected in one lib file.
# Filter out objects already built-in
lib-y := $( filter-out $( obj-y) , $( sort $( lib-y) $( lib-m) ) )
# Handle objects in subdirs
# ---------------------------------------------------------------------------
# o if we encounter foo/ in $(obj-y), replace it by foo/built-in.o
# and add the directory to the list of dirs to descend into: $(subdir-y)
# o if we encounter foo/ in $(obj-m), remove it from $(obj-m)
# and add the directory to the list of dirs to descend into: $(subdir-m)
2007-12-07 15:04:30 +03:00
# Determine modorder.
# Unfortunately, we don't have information about ordering between -y
# and -m subdirs. Just put -y's first.
modorder := $( patsubst %/,%/modules.order, $( filter %/, $( obj-y) ) $( obj-m:.o= .ko) )
2005-04-17 02:20:36 +04:00
__subdir-y := $( patsubst %/,%,$( filter %/, $( obj-y) ) )
subdir-y += $( __subdir-y)
__subdir-m := $( patsubst %/,%,$( filter %/, $( obj-m) ) )
subdir-m += $( __subdir-m)
obj-y := $( patsubst %/, %/built-in.o, $( obj-y) )
obj-m := $( filter-out %/, $( obj-m) )
# Subdirectories we need to descend into
subdir-ym := $( sort $( subdir-y) $( subdir-m) )
# if $(foo-objs) exists, foo.o is a composite object
multi-used-y := $( sort $( foreach m,$( obj-y) , $( if $( strip $( $( m:.o= -objs) ) $( $( m:.o= -y) ) ) , $( m) ) ) )
multi-used-m := $( sort $( foreach m,$( obj-m) , $( if $( strip $( $( m:.o= -objs) ) $( $( m:.o= -y) ) ) , $( m) ) ) )
multi-used := $( multi-used-y) $( multi-used-m)
single-used-m := $( sort $( filter-out $( multi-used-m) ,$( obj-m) ) )
# Build list of the parts of our composite objects, our composite
# objects depend on those (obviously)
multi-objs-y := $( foreach m, $( multi-used-y) , $( $( m:.o= -objs) ) $( $( m:.o= -y) ) )
multi-objs-m := $( foreach m, $( multi-used-m) , $( $( m:.o= -objs) ) $( $( m:.o= -y) ) )
multi-objs := $( multi-objs-y) $( multi-objs-m)
2007-09-15 10:55:39 +04:00
# $(subdir-obj-y) is the list of objects in $(obj-y) which uses dir/ to
# tell kbuild to descend
subdir-obj-y := $( filter %/built-in.o, $( obj-y) )
2005-04-17 02:20:36 +04:00
# $(obj-dirs) is a list of directories that contain object files
obj-dirs := $( dir $( multi-objs) $( subdir-obj-y) )
# Replace multi-part objects by their individual parts, look at local dir only
real-objs-y := $( foreach m, $( filter-out $( subdir-obj-y) , $( obj-y) ) , $( if $( strip $( $( m:.o= -objs) ) $( $( m:.o= -y) ) ) ,$( $( m:.o= -objs) ) $( $( m:.o= -y) ) ,$( m) ) ) $( extra-y)
real-objs-m := $( foreach m, $( obj-m) , $( if $( strip $( $( m:.o= -objs) ) $( $( m:.o= -y) ) ) ,$( $( m:.o= -objs) ) $( $( m:.o= -y) ) ,$( m) ) )
# Add subdir path
extra-y := $( addprefix $( obj) /,$( extra-y) )
always := $( addprefix $( obj) /,$( always) )
targets := $( addprefix $( obj) /,$( targets) )
2007-12-07 15:04:30 +03:00
modorder := $( addprefix $( obj) /,$( modorder) )
2005-04-17 02:20:36 +04:00
obj-y := $( addprefix $( obj) /,$( obj-y) )
obj-m := $( addprefix $( obj) /,$( obj-m) )
lib-y := $( addprefix $( obj) /,$( lib-y) )
subdir-obj-y := $( addprefix $( obj) /,$( subdir-obj-y) )
real-objs-y := $( addprefix $( obj) /,$( real-objs-y) )
real-objs-m := $( addprefix $( obj) /,$( real-objs-m) )
single-used-m := $( addprefix $( obj) /,$( single-used-m) )
multi-used-y := $( addprefix $( obj) /,$( multi-used-y) )
multi-used-m := $( addprefix $( obj) /,$( multi-used-m) )
multi-objs-y := $( addprefix $( obj) /,$( multi-objs-y) )
multi-objs-m := $( addprefix $( obj) /,$( multi-objs-m) )
subdir-ym := $( addprefix $( obj) /,$( subdir-ym) )
obj-dirs := $( addprefix $( obj) /,$( obj-dirs) )
# These flags are needed for modversions and compiling, so we define them here
# already
# $(modname_flags) #defines KBUILD_MODNAME as the name of the module it will
# end up in (or would, if it gets compiled in)
2012-01-09 00:54:43 +04:00
# Note: Files that end up in two or more modules are compiled without the
# KBUILD_MODNAME definition. The reason is that any made-up name would
# differ in different configs.
2005-09-23 08:42:11 +04:00
name-fix = $( subst $( comma) ,_,$( subst -,_,$1 ) )
2006-07-01 11:58:02 +04:00
basename_flags = -D" KBUILD_BASENAME=KBUILD_STR( $( call name-fix,$( basetarget) ) ) "
2005-09-23 08:42:11 +04:00
modname_flags = $( if $( filter 1,$( words $( modname) ) ) ,\
-D" KBUILD_MODNAME=KBUILD_STR( $( call name-fix,$( modname) ) ) " )
2005-04-17 02:20:36 +04:00
2009-04-19 13:04:26 +04:00
orig_c_flags = $( KBUILD_CPPFLAGS) $( KBUILD_CFLAGS) $( KBUILD_SUBDIR_CCFLAGS) \
2008-11-21 23:50:02 +03:00
$( ccflags-y) $( CFLAGS_$( basetarget) .o)
2008-05-15 05:30:29 +04:00
_c_flags = $( filter-out $( CFLAGS_REMOVE_$( basetarget) .o) , $( orig_c_flags) )
2009-04-19 13:04:26 +04:00
_a_flags = $( KBUILD_CPPFLAGS) $( KBUILD_AFLAGS) $( KBUILD_SUBDIR_ASFLAGS) \
2008-11-21 23:50:02 +03:00
$( asflags-y) $( AFLAGS_$( basetarget) .o)
2007-10-16 00:25:06 +04:00
_cpp_flags = $( KBUILD_CPPFLAGS) $( cppflags-y) $( CPPFLAGS_$( @F) )
2005-04-17 02:20:36 +04:00
2009-06-18 03:28:08 +04:00
#
# Enable gcov profiling flags for a file, directory or for all files depending
# on variables GCOV_PROFILE_obj.o, GCOV_PROFILE and CONFIG_GCOV_PROFILE_ALL
# (in this order)
#
i f e q ( $( CONFIG_GCOV_KERNEL ) , y )
_c_flags += $( if $( patsubst n%,, \
$( GCOV_PROFILE_$( basetarget) .o) $( GCOV_PROFILE) $( CONFIG_GCOV_PROFILE_ALL) ) , \
$( CFLAGS_GCOV) )
e n d i f
2009-11-08 00:03:54 +03:00
i f d e f C O N F I G _ S Y M B O L _ P R E F I X
2010-10-20 00:11:53 +04:00
_sym_flags = -DSYMBOL_PREFIX= $( patsubst "%" ,%,$( CONFIG_SYMBOL_PREFIX) )
_cpp_flags += $( _sym_flags)
_a_flags += $( _sym_flags)
2009-11-08 00:03:54 +03:00
e n d i f
2005-04-17 02:20:36 +04:00
# If building the kernel in a separate objtree expand all occurrences
# of -Idir to -I$(srctree)/dir except for absolute paths (starting with '/').
i f e q ( $( KBUILD_SRC ) , )
__c_flags = $( _c_flags)
__a_flags = $( _a_flags)
__cpp_flags = $( _cpp_flags)
e l s e
# -I$(obj) locates generated .h files
# $(call addtree,-I$(obj)) locates .h files in srctree, from generated .c files
# and locates generated .h files
# FIXME: Replace both with specific CFLAGS* statements in the makefiles
__c_flags = $( call addtree,-I$( obj) ) $( call flags,_c_flags)
__a_flags = $( call flags,_a_flags)
__cpp_flags = $( call flags,_cpp_flags)
e n d i f
2008-11-21 23:50:02 +03:00
c_flags = -Wp,-MD,$( depfile) $( NOSTDINC_FLAGS) $( LINUXINCLUDE) \
$( __c_flags) $( modkern_cflags) \
2010-09-17 19:09:17 +04:00
-D"KBUILD_STR(s)=\#s" $( basename_flags) $( modname_flags)
2005-04-17 02:20:36 +04:00
2008-11-21 23:50:02 +03:00
a_flags = -Wp,-MD,$( depfile) $( NOSTDINC_FLAGS) $( LINUXINCLUDE) \
2005-04-17 02:20:36 +04:00
$( __a_flags) $( modkern_aflags)
2008-11-21 23:50:02 +03:00
cpp_flags = -Wp,-MD,$( depfile) $( NOSTDINC_FLAGS) $( LINUXINCLUDE) \
$( __cpp_flags)
2005-04-17 02:20:36 +04:00
2007-10-16 00:25:06 +04:00
ld_flags = $( LDFLAGS) $( ldflags-y)
2005-04-17 02:20:36 +04:00
# Finds the multi-part object the current object will be linked into
modname-multi = $( sort $( foreach m,$( multi-used) ,\
$( if $( filter $( subst $( obj) /,,$* .o) , $( $( m:.o= -objs) ) $( $( m:.o= -y) ) ) ,$( m:.o= ) ) ) )
2011-05-23 08:04:43 +04:00
i f d e f R E G E N E R A T E _ P A R S E R S
# GPERF
# ---------------------------------------------------------------------------
quiet_cmd_gperf = GPERF $@
cmd_gperf = gperf -t --output-file $@ -a -C -E -g -k 1,3,$$ -p -t $<
2011-07-31 22:45:40 +04:00
.PRECIOUS : $( src ) /%.hash .c_shipped
2011-05-23 08:04:43 +04:00
$(src)/%.hash.c_shipped : $( src ) /%.gperf
$( call cmd,gperf)
# LEX
# ---------------------------------------------------------------------------
LEX_PREFIX = $( if $( LEX_PREFIX_${ baseprereq } ) ,$( LEX_PREFIX_${ baseprereq } ) ,yy)
quiet_cmd_flex = LEX $@
cmd_flex = flex -o$@ -L -P $( LEX_PREFIX) $<
2011-07-31 22:45:40 +04:00
.PRECIOUS : $( src ) /%.lex .c_shipped
2011-05-23 08:04:43 +04:00
$(src)/%.lex.c_shipped : $( src ) /%.l
$( call cmd,flex)
# YACC
# ---------------------------------------------------------------------------
YACC_PREFIX = $( if $( YACC_PREFIX_${ baseprereq } ) ,$( YACC_PREFIX_${ baseprereq } ) ,yy)
quiet_cmd_bison = YACC $@
cmd_bison = bison -o$@ -t -l -p $( YACC_PREFIX) $<
2011-07-31 22:45:40 +04:00
.PRECIOUS : $( src ) /%.tab .c_shipped
2011-05-23 08:04:43 +04:00
$(src)/%.tab.c_shipped : $( src ) /%.y
$( call cmd,bison)
quiet_cmd_bison_h = YACC $@
cmd_bison_h = bison -o/dev/null --defines= $@ -t -l -p $( YACC_PREFIX) $<
2011-07-31 22:45:40 +04:00
.PRECIOUS : $( src ) /%.tab .h_shipped
2011-05-23 08:04:43 +04:00
$(src)/%.tab.h_shipped : $( src ) /%.y
$( call cmd,bison_h)
e n d i f
2005-04-17 02:20:36 +04:00
# Shipped files
# ===========================================================================
quiet_cmd_shipped = SHIPPED $@
cmd_shipped = cat $< > $@
2011-06-07 21:09:28 +04:00
$(obj)/% : $( src ) /%_shipped
2005-04-17 02:20:36 +04:00
$( call cmd,shipped)
# Commands useful for building a boot image
# ===========================================================================
#
# Use as following:
#
# target: source(s) FORCE
# $(if_changed,ld/objcopy/gzip)
#
2007-09-30 22:34:36 +04:00
# and add target to extra-y so that we know we have to
2005-04-17 02:20:36 +04:00
# read in the saved command line
# Linking
# ---------------------------------------------------------------------------
quiet_cmd_ld = LD $@
2007-10-16 00:25:06 +04:00
cmd_ld = $( LD) $( LDFLAGS) $( ldflags-y) $( LDFLAGS_$( @F) ) \
2005-04-17 02:20:36 +04:00
$( filter-out FORCE,$^) -o $@
# Objcopy
# ---------------------------------------------------------------------------
quiet_cmd_objcopy = OBJCOPY $@
cmd_objcopy = $( OBJCOPY) $( OBJCOPYFLAGS) $( OBJCOPYFLAGS_$( @F) ) $< $@
# Gzip
# ---------------------------------------------------------------------------
quiet_cmd_gzip = GZIP $@
2011-03-31 17:47:55 +04:00
cmd_gzip = ( cat $( filter-out FORCE,$^) | gzip -n -f -9 > $@ ) || \
2009-05-06 08:17:15 +04:00
( rm -f $@ ; false )
2005-04-17 02:20:36 +04:00
2010-12-22 22:57:26 +03:00
# DTC
# ---------------------------------------------------------------------------
# Generate an assembly file to wrap the output of the device tree compiler
quiet_cmd_dt_S_dtb = DTB $@
cmd_dt_S_dtb = \
( \
echo '\#include <asm-generic/vmlinux.lds.h>' ; \
echo '.section .dtb.init.rodata,"a"' ; \
echo '.balign STRUCT_ALIGNMENT' ; \
echo '.global __dtb_$(*F)_begin' ; \
echo '__dtb_$(*F)_begin:' ; \
echo '.incbin "$<" ' ; \
echo '__dtb_$(*F)_end:' ; \
echo '.global __dtb_$(*F)_end' ; \
echo '.balign STRUCT_ALIGNMENT' ; \
) > $@
$(obj)/%.dtb.S : $( obj ) /%.dtb
$( call cmd,dt_S_dtb)
quiet_cmd_dtc = DTC $@
2012-01-09 22:38:15 +04:00
cmd_dtc = $( objtree) /scripts/dtc/dtc -O dtb -o $@ -b 0 $( DTC_FLAGS) -d $( depfile) $<
2005-04-17 02:20:36 +04:00
2012-11-28 03:29:10 +04:00
$(obj)/%.dtb : $( src ) /%.dts FORCE
$( call if_changed_dep,dtc)
2009-01-05 00:46:16 +03:00
# Bzip2
# ---------------------------------------------------------------------------
2009-05-06 08:17:15 +04:00
# Bzip2 and LZMA do not include size in file... so we have to fake that;
# append the size as a 32-bit littleendian number as gzip does.
2009-10-14 00:22:46 +04:00
size_append = printf $( shell \
2009-05-06 08:17:15 +04:00
dec_size = 0; \
f o r F i n $ 1 ; d o \
fsize = $$ ( stat -c "%s" $$ F) ; \
dec_size = $$ ( expr $$ dec_size + $$ fsize) ; \
d o n e ; \
2009-12-28 22:38:27 +03:00
p r i n t f "%08x\n" $$ d e c _ s i z e | \
sed 's/\(..\)/\1 /g' | { \
read ch0 ch1 ch2 ch3; \
for ch in $$ ch3 $$ ch2 $$ ch1 $$ ch0; do \
printf '%s%03o' '\\' $$ ( ( 0x$$ ch) ) ; \
done ; \
} \
2009-05-06 08:17:15 +04:00
)
quiet_cmd_bzip2 = BZIP2 $@
cmd_bzip2 = ( cat $( filter-out FORCE,$^) | \
bzip2 -9 && $( call size_append, $( filter-out FORCE,$^) ) ) > $@ || \
( rm -f $@ ; false )
2009-01-05 00:46:16 +03:00
# Lzma
# ---------------------------------------------------------------------------
quiet_cmd_lzma = LZMA $@
2009-05-06 08:17:15 +04:00
cmd_lzma = ( cat $( filter-out FORCE,$^) | \
lzma -9 && $( call size_append, $( filter-out FORCE,$^) ) ) > $@ || \
( rm -f $@ ; false )
lib: add support for LZO-compressed kernels
This patch series adds generic support for creating and extracting
LZO-compressed kernel images, as well as support for using such images on
the x86 and ARM architectures, and support for creating and using
LZO-compressed initrd and initramfs images.
Russell King said:
: Testing on a Cortex A9 model:
: - lzo decompressor is 65% of the time gzip takes to decompress a kernel
: - lzo kernel is 9% larger than a gzip kernel
:
: which I'm happy to say confirms your figures when comparing the two.
:
: However, when comparing your new gzip code to the old gzip code:
: - new is 99% of the size of the old code
: - new takes 42% of the time to decompress than the old code
:
: What this means is that for a proper comparison, the results get even better:
: - lzo is 7.5% larger than the old gzip'd kernel image
: - lzo takes 28% of the time that the old gzip code took
:
: So the expense seems definitely worth the effort. The only reason I
: can think of ever using gzip would be if you needed the additional
: compression (eg, because you have limited flash to store the image.)
:
: I would argue that the default for ARM should therefore be LZO.
This patch:
The lzo compressor is worse than gzip at compression, but faster at
extraction. Here are some figures for an ARM board I'm working on:
Uncompressed size: 3.24Mo
gzip 1.61Mo 0.72s
lzo 1.75Mo 0.48s
So for a compression ratio that is still relatively close to gzip, it's
much faster to extract, at least in that case.
This part contains:
- Makefile routine to support lzo compression
- Fixes to the existing lzo compressor so that it can be used in
compressed kernels
- wrapper around the existing lzo1x_decompress, as it only extracts one
block at a time, while we need to extract a whole file here
- config dialog for kernel compression
[akpm@linux-foundation.org: coding-style fixes]
[akpm@linux-foundation.org: cleanup]
Signed-off-by: Albin Tonnerre <albin.tonnerre@free-electrons.com>
Tested-by: Wu Zhangjin <wuzhangjin@gmail.com>
Acked-by: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Russell King <rmk@arm.linux.org.uk>
Acked-by: Russell King <rmk@arm.linux.org.uk>
Cc: Ralf Baechle <ralf@linux-mips.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-01-09 01:42:42 +03:00
2010-03-11 12:42:14 +03:00
quiet_cmd_lzo = LZO $@
lib: add support for LZO-compressed kernels
This patch series adds generic support for creating and extracting
LZO-compressed kernel images, as well as support for using such images on
the x86 and ARM architectures, and support for creating and using
LZO-compressed initrd and initramfs images.
Russell King said:
: Testing on a Cortex A9 model:
: - lzo decompressor is 65% of the time gzip takes to decompress a kernel
: - lzo kernel is 9% larger than a gzip kernel
:
: which I'm happy to say confirms your figures when comparing the two.
:
: However, when comparing your new gzip code to the old gzip code:
: - new is 99% of the size of the old code
: - new takes 42% of the time to decompress than the old code
:
: What this means is that for a proper comparison, the results get even better:
: - lzo is 7.5% larger than the old gzip'd kernel image
: - lzo takes 28% of the time that the old gzip code took
:
: So the expense seems definitely worth the effort. The only reason I
: can think of ever using gzip would be if you needed the additional
: compression (eg, because you have limited flash to store the image.)
:
: I would argue that the default for ARM should therefore be LZO.
This patch:
The lzo compressor is worse than gzip at compression, but faster at
extraction. Here are some figures for an ARM board I'm working on:
Uncompressed size: 3.24Mo
gzip 1.61Mo 0.72s
lzo 1.75Mo 0.48s
So for a compression ratio that is still relatively close to gzip, it's
much faster to extract, at least in that case.
This part contains:
- Makefile routine to support lzo compression
- Fixes to the existing lzo compressor so that it can be used in
compressed kernels
- wrapper around the existing lzo1x_decompress, as it only extracts one
block at a time, while we need to extract a whole file here
- config dialog for kernel compression
[akpm@linux-foundation.org: coding-style fixes]
[akpm@linux-foundation.org: cleanup]
Signed-off-by: Albin Tonnerre <albin.tonnerre@free-electrons.com>
Tested-by: Wu Zhangjin <wuzhangjin@gmail.com>
Acked-by: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Tested-by: Russell King <rmk@arm.linux.org.uk>
Acked-by: Russell King <rmk@arm.linux.org.uk>
Cc: Ralf Baechle <ralf@linux-mips.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2010-01-09 01:42:42 +03:00
cmd_lzo = ( cat $( filter-out FORCE,$^) | \
lzop -9 && $( call size_append, $( filter-out FORCE,$^) ) ) > $@ || \
( rm -f $@ ; false )
2010-03-05 19:34:46 +03:00
2012-03-17 01:03:55 +04:00
# U-Boot mkimage
# ---------------------------------------------------------------------------
MKIMAGE := $( srctree) /scripts/mkuboot.sh
# SRCARCH just happens to match slightly more than ARCH (on sparc), so reduces
# the number of overrides in arch makefiles
UIMAGE_ARCH ?= $( SRCARCH)
UIMAGE_COMPRESSION ?= $( if $( 2) ,$( 2) ,none)
UIMAGE_OPTS-y ?=
UIMAGE_TYPE ?= kernel
UIMAGE_LOADADDR ?= arch_must_set_this
UIMAGE_ENTRYADDR ?= $( UIMAGE_LOADADDR)
UIMAGE_NAME ?= 'Linux-$(KERNELRELEASE)'
UIMAGE_IN ?= $<
UIMAGE_OUT ?= $@
quiet_cmd_uimage = UIMAGE $( UIMAGE_OUT)
cmd_uimage = $( CONFIG_SHELL) $( MKIMAGE) -A $( UIMAGE_ARCH) -O linux \
-C $( UIMAGE_COMPRESSION) $( UIMAGE_OPTS-y) \
-T $( UIMAGE_TYPE) \
-a $( UIMAGE_LOADADDR) -e $( UIMAGE_ENTRYADDR) \
-n $( UIMAGE_NAME) -d $( UIMAGE_IN) $( UIMAGE_OUT)
2011-01-13 04:01:22 +03:00
# XZ
# ---------------------------------------------------------------------------
# Use xzkern to compress the kernel image and xzmisc to compress other things.
#
# xzkern uses a big LZMA2 dictionary since it doesn't increase memory usage
# of the kernel decompressor. A BCJ filter is used if it is available for
# the target architecture. xzkern also appends uncompressed size of the data
# using size_append. The .xz format has the size information available at
# the end of the file too, but it's in more complex format and it's good to
# avoid changing the part of the boot code that reads the uncompressed size.
# Note that the bytes added by size_append will make the xz tool think that
# the file is corrupt. This is expected.
#
# xzmisc doesn't use size_append, so it can be used to create normal .xz
# files. xzmisc uses smaller LZMA2 dictionary than xzkern, because a very
# big dictionary would increase the memory usage too much in the multi-call
# decompression mode. A BCJ filter isn't used either.
quiet_cmd_xzkern = XZKERN $@
cmd_xzkern = ( cat $( filter-out FORCE,$^) | \
sh $( srctree) /scripts/xz_wrap.sh && \
$( call size_append, $( filter-out FORCE,$^) ) ) > $@ || \
( rm -f $@ ; false )
quiet_cmd_xzmisc = XZMISC $@
cmd_xzmisc = ( cat $( filter-out FORCE,$^) | \
xz --check= crc32 --lzma2= dict = 1MiB) > $@ || \
( rm -f $@ ; false )
2010-03-05 19:34:46 +03:00
# misc stuff
# ---------------------------------------------------------------------------
quote := "