Android build System

[First written by Steve Guo, please keep the mark if
forwarding.]

Device/docs/design/build-system.html
is a good start point to understand Android build system. In this
topic, I will describe the behind details using mm to compile an
executable and shared library.

Basic

In envsetup.sh
, mm macro is defined.

function mm()

{

# If we're sitting in the root of the build tree, just do a

# normal make.

if [ -f config/envsetup.make -a -f Makefile ]; then

make $@

else

# Find the closest Android.mk file.

T=$(gettop)

M=$(findmakefile)

if [ ! "$T" ]; then

echo "Couldn't locate the top of the tree.
Try setting TOP."

elif [ ! "$M" ]; then

echo "Couldn't locate a makefile from the current directory."

else

ONE_SHOT_MAKEFILE=$M make -C $T files $@

fi

fi

}

In top layer Makefile

ifneq ($(
ONE_SHOT_MAKEFILE
),)

# We've probably been
invoked by the "mm" shell function

# with a
subdirectory's makefile.

include
$(ONE_SHOT_MAKEFILE)

# Change
CUSTOM_MODULES to include only modules that were

# defined by this
makefile; this will install all of those

# modules as a
side-effect.
Do this after including ONE_SHOT_MAKEFILE

# so that the modules
will be installed in the same place they

# would have been
with a normal make.

CUSTOM_MODULES :=
$(sort $(call get-tagged-modules,$(ALL_MODULE_TAGS),))

FULL_BUILD :=

INTERNAL_DEFAULT_DOCS_TARGETS
:=

# Stub out the notice
targets, which probably aren't defined

# when using
ONE_SHOT_MAKEFILE.

NOTICE-HOST-%: ;

NOTICE-TARGET-%: ;

So
if we type mm in a directory, it will finally include our own
Android.mk. Android will put every Android.mk into one huge Makefile.

In top layer Makefile, it includes base_rules.make
, while in base_rules.make it defines a target for LOCAL_MODULE which
must be specified in our own Android.mk.

# Provide a
short-hand for building this module.

# We name both BUILT
and INSTALLED in case

#
LOCAL_UNINSTALLABLE_MODULE is set.

.PHONY:
$(LOCAL_MODULE)

$(LOCAL_MODULE):
$(LOCAL_BUILT_MODULE) $(LOCAL_INSTALLED_MODULE)

definitions.make

contains the most important macros for building
source file. Here lists the two macros for building C++ and C source
files.

###########################################################

## Commands for
running gcc to compile a C++ file

###########################################################

define transform-cpp-to-o

@mkdir -p $(dir $@)

@echo "target
$(PRIVATE_ARM_MODE) C++: $(PRIVATE_MODULE) <= $<"

$(hide)
$(PRIVATE_CXX) /

$(foreach incdir, /

$(if $(PRIVATE_NO_DEFAULT_COMPILER_FLAGS),, /

$(TARGET_PROJECT_INCLUDES) /

$(TARGET_C_INCLUDES) /

) /

$(PRIVATE_C_INCLUDES) /

, /

-I $(incdir) /

) /

-c /

$(if $(PRIVATE_NO_DEFAULT_COMPILER_FLAGS),, /

$(TARGET_GLOBAL_CFLAGS) /

$(TARGET_GLOBAL_CPPFLAGS) /

$(PRIVATE_ARM_CFLAGS) /

) /

$(PRIVATE_CFLAGS) /

$(PRIVATE_CPPFLAGS) /

$(PRIVATE_DEBUG_CFLAGS) /

-fno-rtti /

-MD -o $@ $<

$(hide)
$(transform-d-to-p)

endef

###########################################################

## Commands for
running gcc to compile a C file

###########################################################

# $(1): extra flags

define
transform-c-or-s-to-o-no-deps

@mkdir -p $(dir $@)

$(hide) $(PRIVATE_CC)
/

$(foreach incdir, /

$(if $(PRIVATE_NO_DEFAULT_COMPILER_FLAGS),, /

$(TARGET_PROJECT_INCLUDES) /

$(TARGET_C_INCLUDES) /

) /

$(PRIVATE_C_INCLUDES) /

, /

-I $(incdir) /

) /

-c /

$(if $(PRIVATE_NO_DEFAULT_COMPILER_FLAGS),, /

$(TARGET_GLOBAL_CFLAGS) /

$(PRIVATE_ARM_CFLAGS) /

) /

$(PRIVATE_CFLAGS) /

$(1) /

$(PRIVATE_DEBUG_CFLAGS) /

-MD -o $@ $<

endef

Executable

In our own Android.mk we should add two lines.

LOCAL_MODULE := ***

include
$(BUILD_EXECUTABLE)

BUILD_EXECUTALE is defined in config.make
.

BUILD_EXECUTABLE:=
$(BUILD_SYSTEM)/executable.make

In executable.make

include
$(BUILD_SYSTEM)/dynamic_binary.make

ifeq
($(LOCAL_FORCE_STATIC_EXECUTABLE),true)

$(linked_module):
$(TARGET_CRTBEGIN_STATIC_O) $(all_objects) $(all_libraries)
$(TARGET_CRTEND_O)

$(transform-o-to-static-executable)

else

$(linked_module):
$(TARGET_CRTBEGIN_DYNAMIC_O) $(all_objects) $(all_libraries)
$(TARGET_CRTEND_O)

$(transform-o-to-executable)

Endif

So here defined a new target $(linked_module).

transform-o-to-exeuctable macro is defined in defintions.make
.

define
transform-o-to-executable

@mkdir -p $(dir $@)

@echo "target
Executable: $(PRIVATE_MODULE) ($@)"

$(hide)
$(transform-o-to-executable-inner)

endef

combo/linux-arm.make

contains macros to transform o to executable for
ARM.

define
transform-o-to-executable-inner

$(TARGET_CXX)
-nostdlib -Bdynamic -Wl,-T,$(BUILD_SYSTEM)/armelf.x /

-Wl,-dynamic-linker,/system/bin/linker /

-Wl,--gc-sections /

-Wl,-z,nocopyreloc /

-o $@ /

$(TARGET_GLOBAL_LD_DIRS) /

-Wl,-rpath-link=$(TARGET_OUT_INTERMEDIATE_LIBRARIES) /

$(call normalize-target-libraries,$(PRIVATE_ALL_SHARED_LIBRARIES)) /

$(TARGET_CRTBEGIN_DYNAMIC_O) /

$(PRIVATE_ALL_OBJECTS) /

$(call normalize-target-libraries,$(PRIVATE_ALL_STATIC_LIBRARIES)) /

$(PRIVATE_LDFLAGS) /

$(TARGET_LIBGCC) /

$(TARGET_CRTEND_O)

endef

binary.make

contains some PRIVATE_* definitions used by the
above macros.

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_YACCFLAGS := $(LOCAL_YACCFLAGS)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_ASFLAGS := $(LOCAL_ASFLAGS)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_CFLAGS := $(LOCAL_CFLAGS)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_CPPFLAGS := $(LOCAL_CPPFLAGS)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_DEBUG_CFLAGS := $(debug_cflags)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_C_INCLUDES := $(LOCAL_C_INCLUDES)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_LDFLAGS := $(LOCAL_LDFLAGS)

$(LOCAL_INTERMEDIATE_TARGETS):
PRIVATE_LDLIBS := $(LOCAL_LDLIBS)

combo/linux-arm.make

contains default CFLAGS/CPPFLAGS/C_INCLUDES
definitions.

$(combo_target)GLOBAL_CFLAGS
+= /

-march=armv5te -mtune=xscale /

-msoft-float -fpic /

-mthumb-interwork /

-ffunction-sections /

-funwind-tables /

-fstack-protector /

-D__ARM_ARCH_5__ -D__ARM_ARCH_5T__ /

-D__ARM_ARCH_5E__ -D__ARM_ARCH_5TE__ /

-include include/arch/linux-arm/AndroidConfig.h

$(combo_target)GLOBAL_CPPFLAGS
+= -fvisibility-inlines-hidden

$(combo_target)RELEASE_CFLAGS
:= /

-DSK_RELEASE -DNDEBUG /

-O2 -g /

-Wstrict-aliasing=2 /

-finline-functions /

-fno-inline-functions-called-once /

-fgcse-after-reload /

-frerun-cse-after-loop /

-frename-registers

# unless
CUSTOM_KERNEL_HEADERS is defined, we're going to use

# symlinks located in
out/ to point to the appropriate kernel

# headers. see
'config/kernel_headers.make' for more details

#

KERNEL_HEADERS_COMMON
:= system/bionic/kernel/common

KERNEL_HEADERS_ARCH

:= system/bionic/kernel/arch-$(TARGET_ARCH)

ifneq
($(CUSTOM_KERNEL_HEADERS),)

KERNEL_HEADERS_COMMON := $(CUSTOM_KERNEL_HEADERS)

KERNEL_HEADERS_ARCH
:= $(CUSTOM_KERNEL_HEADERS)

endif

KERNEL_HEADERS :=
$(KERNEL_HEADERS_COMMON) $(KERNEL_HEADERS_ARCH)

$(combo_target)C_INCLUDES
:= /

system/bionic/arch-arm/include /

system/bionic/include /

system/libstdc++/include /

$(KERNEL_HEADERS) /

system/libm/include /

system/libm/include/arch/arm /

system/libthread_db/include

Shared Library

In our own Android.mk we should add two lines.

LOCAL_MODULE := ***

include
$(BUILD_SHARED_LIBRARY)

BUILD_SHARED_LIBRARY is defined in config.make
.

BUILD_SHARED_LIBRARY:=
$(BUILD_SYSTEM)/shared_library.make

In shared_library.make

include
$(BUILD_SYSTEM)/dynamic_binary.make

$(linked_module):
$(all_objects) $(all_libraries) $(LOCAL_ADDITIONAL_DEPENDENCIES)

$(transform-o-to-shared-lib)

So here defined a new target $(linked_module).

transform-o-to-shared-lib macro is defined in defintions.make
.

define
transform-o-to-shared-lib

@mkdir -p $(dir $@)

@echo "target
SharedLib: $(PRIVATE_MODULE) ($@)"

$(hide)
$(transform-o-to-shared-lib-inner)

endef

combo/linux-arm.make

contains macro to transform o to shared lib for ARM.

define
transform-o-to-shared-lib-inner

$(TARGET_CXX) /

-nostdlib -Wl,-soname,$(notdir $@) -Wl,-T,$(BUILD_SYSTEM)/armelf.xsc /

-Wl,--gc-sections /

-Wl,-shared,-Bsymbolic /

$(TARGET_GLOBAL_LD_DIRS) /

$(PRIVATE_ALL_OBJECTS) /

-Wl,--whole-archive /

$(call normalize-host-libraries,$(PRIVATE_ALL_WHOLE_STATIC_LIBRARIES)) /

-Wl,--no-whole-archive /

$(call normalize-target-libraries,$(PRIVATE_ALL_STATIC_LIBRARIES)) /

$(call normalize-target-libraries,$(PRIVATE_ALL_SHARED_LIBRARIES)) /

-o $@ /

$(PRIVATE_LDFLAGS) /

$(TARGET_LIBGCC)

endef

Tips: “make *** showcommands”can let build system show the
original compile commands.