1# 2# Copyright (c) 2020, Google, Inc. All rights reserved 3# 4# Licensed under the Apache License, Version 2.0 (the "License"); 5# you may not use this file except in compliance with the License. 6# You may obtain a copy of the License at 7# 8# http://www.apache.org/licenses/LICENSE-2.0 9# 10# Unless required by applicable law or agreed to in writing, software 11# distributed under the License is distributed on an "AS IS" BASIS, 12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13# See the License for the specific language governing permissions and 14# limitations under the License. 15# 16 17# Build a userspace library for Trusty 18# 19# args: 20# MODULE : module name (required) 21# MODULE_SRCS : list of source files, local path (not required for header-only 22# libraries) 23# MODULE_LIBRARY_DEPS : libraries that this module depends on. These libraries 24# must be built using the new library.mk system (i.e. include 25# make/library.mk at the end of the library's rules) 26# MODULE_DEPS : legacy dependencies that do not use the new library.mk system. 27# These dependencies will be built exclusively for this module and not 28# shared with other modules). Do not use this for library dependencies 29# compatible with library.mk, instead use MODULE_LIBRARY_DEPS. 30# MODULE_ADD_IMPLICIT_DEPS : Add basic libraries to MODULE_LIBRARY_DEPS. 31# Defaults to true. (currently adds libc-trusty) 32# MODULE_USE_WHOLE_ARCHIVE : use --whole-archive when linking this module 33# MODULE_DEFINES : #defines local to this module 34# MODULE_CONSTANTS : JSON files with constants used for both the manifest and C 35# headers (optional) (CONSTANTS is a deprecated equivalent to 36# MODULE_CONSTANTS) 37# MODULE_COMPILEFLAGS : COMPILEFLAGS local to this module 38# MODULE_CFLAGS : CFLAGS local to this module 39# MODULE_CPPFLAGS : CPPFLAGS local to this module 40# MODULE_ASMFLAGS : ASMFLAGS local to this module 41# MODULE_INCLUDES : include directories local to this module 42# MODULE_SRCDEPS : extra dependencies that all of this module's files depend on 43# MODULE_EXTRA_OBJECTS : extra .o files that should be linked with the module 44# MODULE_WHOLE_ARCHIVES : extra .a libraries that need --whole-archive, e.g., 45# prebuilt archive dependencies 46# MODULE_ARM_OVERRIDE_SRCS : list of source files, local path that should be 47# force compiled with ARM (if applicable) 48# MODULE_RUST_EDITION : Rust edition to compile this crate for (optional) 49# MODULE_RUST_TESTS : If true, this module will be built as both a crate library 50# and a Rust test service (optional, default is false) 51# MODULE_RUST_USE_CLIPPY: whether to require clippy be run for this library. 52# Compilation will fail if any clippy error is found. 53# MODULE_SKIP_DOCS : If true, no documentation will be generated for 54# this module (optional, default is false) 55# MODULE_SDK_LIB_NAME : Name of library in SDK (if applicable). Default is 56# libMODULE_NAME where MODULE_NAME is the final path component of MODULE. 57# MODULE_SDK_HEADERS : Headers to copy into the SDK. Any headers in 58# MODULE_EXPORT_INCLUDES will be included as well, but generated headers 59# must be listed explicitly. 60# MODULE_SDK_HEADER_INSTALL_DIR : Path under include prefix to install SDK 61# headers into. 62# MODULE_LICENSES : Any additional license files for the library other than 63# $(MODULE)/LICENSE and $(MODULE)/NOTICE 64# MODULE_RUST_STEM: The stem of the output .rlib file for this library. 65# Defaults to $(MODULE_CRATE_NAME) if left empty. 66# MANIFEST : App manifest JSON file, only applicable if this module is an app 67# MANIFEST_OVERLAY : Additional manifest overlay JSON files(s) 68# 69# Exported flags: 70# The following args are the same as their corresponding variables above, but 71# will be exported to all users of this library. These flags are also prepended 72# to this module's local flags. To override an exported flag, add the 73# corresponding override to e.g. MODULE_COMPILEFLAGS. 74# 75# MODULE_EXPORT_COMPILEFLAGS 76# MODULE_EXPORT_CONSTANTS 77# MODULE_EXPORT_CFLAGS 78# MODULE_EXPORT_CPPFLAGS 79# MODULE_EXPORT_ASMFLAGS 80# MODULE_EXPORT_LDFLAGS 81# MODULE_EXPORT_INCLUDES 82# MODULE_EXPORT_SRCDEPS 83 84# the minimum library rules.mk file is as follows: 85# 86# LOCAL_DIR := $(GET_LOCAL_DIR) 87# MODULE := $(LOCAL_DIR) 88# 89# MODULE_SRCS := $(LOCAL_DIR)/source_file.c 90# 91# include make/library.mk 92 93# if QUERY_MODULE is set, the rules.mk that included us was itself included not 94# to define a module's make targets but to query the variables it sets for the 95# rest of the build. in this case, skip all further processing 96ifeq ($(QUERY_MODULE),) 97 98ifeq ($(call TOBOOL,$(TRUSTY_NEW_MODULE_SYSTEM)),false) 99 100MODULE_LOG_NAME := $(MODULE) 101$(call INFO,$(MODULE_LOG_NAME),processing,kernel library) 102 103GLOBAL_INCLUDES += $(MODULE_EXPORT_INCLUDES) 104GLOBAL_COMPILEFLAGS += $(MODULE_EXPORT_COMPILEFLAGS) 105GLOBAL_SRCDEPS += $(MODULE_EXPORT_SRCDEPS) 106 107ifneq ($(MODULE_EXPORT_CONSTANTS),) 108$(error MODULE_EXPORT_CONSTANTS is not supported by library.mk for use in the kernel) 109endif 110ifneq ($(MODULE_EXPORT_CFLAGS),) 111$(error MODULE_EXPORT_CFLAGS is not supported by library.mk for use in the kernel) 112endif 113ifneq ($(MODULE_EXPORT_CPPFLAGS),) 114$(error MODULE_EXPORT_CPPFLAGS is not supported by library.mk for use in the kernel) 115endif 116ifneq ($(MODULE_EXPORT_ASMFLAGS),) 117$(error MODULE_EXPORT_ASMFLAGS is not supported by library.mk for use in the kernel) 118endif 119ifneq ($(MODULE_EXPORT_LDFLAGS),) 120$(error MODULE_EXPORT_LDFLAGS is not supported by library.mk for use in the kernel) 121endif 122 123# Building for the kernel, turn off independent library build and fall back to 124# lk module system. 125include make/module.mk 126 127$(call INFO_DONE_SILENT,$(MODULE_LOG_NAME),processing) 128 129else # TRUSTY_NEW_MODULE_SYSTEM is true 130 131ifeq ($(call TOBOOL,$(BUILD_AS_RUST_TEST_MODULE)),true) 132# Disable Rust tests on architectures that do not support Rust 133ifeq ($(call TOBOOL,$(ARCH_$(ARCH)_SUPPORTS_RUST)),true) 134# Allow a project to disable rust tests 135ifeq ($(call TOBOOL,$(TRUSTY_DISABLE_RUST_TESTS)),false) 136 137MODULE_RUST_LOG_NAME := $(MODULE) 138 139$(call INFO,$(MODULE_RUST_LOG_NAME),processing,as a rust test service) 140 141MODULE := $(MODULE)-test 142MODULE_RUSTFLAGS += --test 143MODULE_RUST_CRATE_TYPES := bin 144MODULE_LIBRARY_DEPS += trusty/user/base/lib/unittest-rust 145MODULE_RUST_ENV += TRUSTY_TEST_PORT=com.android.trusty.rust.$(MODULE_CRATE_NAME).test 146MODULE_RUST_TESTS := 147MODULE_SKIP_DOCS := true 148TRUSTY_APP_NAME := $(MODULE_CRATE_NAME)-test 149BUILD_AS_RUST_TEST_MODULE := 150 151TRUSTY_RUST_USER_TESTS += $(MODULE) 152 153include make/trusted_app.mk 154 155$(call INFO_DONE_SILENT,$(MODULE_RUST_LOG_NAME),processing) 156 157else 158 159MODULE_RUST_TESTS := false 160BUILD_AS_RUST_TEST_MODULE := 161 162endif 163endif 164else # Not building rust test app 165 166# Build with the new module system. Currently, the Trusty userspace libraries 167# and apps use the new module system, as does the bootloader/test-runner binary. 168$(call INFO,$(MODULE),processing,library or app) 169 170# Reset new module system marker. This will be set again in dependencies by 171# userspace_recurse.mk 172TRUSTY_NEW_MODULE_SYSTEM := 173 174MODULE_IS_RUST := $(if $(filter %.rs,$(MODULE_SRCS)),true,false) 175 176ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 177ifeq ($(strip $(MODULE_RUST_CRATE_TYPES)),) 178MODULE_RUST_CRATE_TYPES := rlib 179endif 180# Disable Rust modules on architectures that do not support Rust 181ifeq ($(call TOBOOL,$(ARCH_$(ARCH)_SUPPORTS_RUST)),false) 182MODULE_DISABLED := true 183endif 184endif 185 186ifeq ($(call TOBOOL,$(MODULE_DISABLED)),false) 187 188ifneq ($(filter proc-macro,$(MODULE_RUST_CRATE_TYPES)),) 189 190# proc macros must be host libraries, and all their dependencies are as well. 191# This will be reset after we recursively include all dependencies. 192MODULE_RUST_HOST_LIB := true 193 194ifneq ($(strip $(filter-out proc-macro,$(MODULE_RUST_CRATE_TYPES))),) 195$(error $(MODULE) cannot be built as both a proc-macro and a target crate) 196endif 197endif 198 199ifeq ($(call TOBOOL,$(TRUSTY_APP)),false) 200ifeq ($(call TOBOOL,$(MODULE_RUST_HOST_LIB)),false) 201BUILDDIR := $(TRUSTY_LIBRARY_BUILDDIR) 202else 203BUILDDIR := $(TRUSTY_HOST_LIBRARY_BUILDDIR) 204endif 205endif 206 207# Skip docs for apps because dependencies for apps are setup differently than 208# for rlibs (apps do use $MODULE_RSOBJS which is the variable we use as an input 209# to the rustdoc target to ensure that dependencies are built before generating 210# docs) and currently that breaks the rustdoc builds. We don't currently need 211# generated docs for apps, but if that changes it should be possible to fix 212# this. 213ifeq ($(call TOBOOL,$(TRUSTY_APP)),true) 214MODULE_SKIP_DOCS := true 215endif 216 217ifeq ($(call TOBOOL,$(MODULE_RUST_HOST_LIB)),false) 218# Add any common flags to the module 219include make/common_flags.mk 220endif 221 222ifneq ($(INCMODULES),) 223$(error $(MODULE) should only be included from other userspace modules that use library.mk. One of the following modules needs to be updated to use the new library system: $(LIB_SAVED_MODULE) $(ALLMODULES)) 224endif 225ifneq ($(GLOBAL_OPTFLAGS),) 226$(error $(MODULE) has modified GLOBAL_OPTFLAGS, this variable is deprecated) 227endif 228ifneq ($(GLOBAL_COMPILEFLAGS),) 229$(error $(MODULE) has modified GLOBAL_COMPILEFLAGS, this variable is deprecated, please use MODULE_EXPORT_COMPILEFLAGS) 230endif 231ifneq ($(GLOBAL_CFLAGS),) 232$(error $(MODULE) has modified GLOBAL_CFLAGS, this variable is deprecated, please use MODULE_EXPORT_CFLAGS) 233endif 234ifneq ($(GLOBAL_CPPFLAGS),) 235$(error $(MODULE) has modified GLOBAL_CPPFLAGS, this variable is deprecated, please use MODULE_EXPORT_CPPFLAGS) 236endif 237ifneq ($(GLOBAL_ASMFLAGS),) 238$(error $(MODULE) has modified GLOBAL_ASMFLAGS, this variable is deprecated, please use MODULE_EXPORT_ASMFLAGS) 239endif 240ifneq ($(GLOBAL_DEFINES),) 241$(error $(MODULE) has modified GLOBAL_DEFINES, this variable is deprecated) 242endif 243ifneq ($(GLOBAL_INCLUDES),) 244$(error $(MODULE) has modified GLOBAL_INCLUDES, this variable is deprecated, please use MODULE_EXPORT_INCLUDES) 245endif 246ifneq ($(MODULE_OPTFLAGS),) 247$(error $(MODULE) sets MODULE_OPTFLAGS, which is deprecated. Please move these flags to another variable.) 248endif 249 250ifneq ($(MODULE_EXPORT_RUSTFLAGS),) 251$(error $(MODULE) sets MODULE_EXPORT_RUSTFLAGS, which is not supported) 252endif 253 254ifneq ($(strip $(MODULE_DEPS)),) 255$(warning $(MODULE) is a userspace library module but has deprecated MODULE_DEPS: $(MODULE_DEPS).) 256endif 257 258# ALLMODULES is only used for the legacy dependency system, so if a library is 259# included in it, something must have gone wrong. 260ifneq ($(filter $(MODULE),$(ALLMODULES)),) 261ifeq ($(LIB_SAVED_MODULE),) 262# We don't know who our parent was because it was a legacy module, so we can't 263# give a very good error message here. 264$(error Please move $(MODULE) from MODULE_DEPS into MODULE_LIBRARY_DEPS) 265else 266$(error MODULE $(LIB_SAVED_MODULE) depends on $(MODULE) via MODULE_DEPS, but $(MODULE) is only compatible with MODULE_LIBRARY_DEPS) 267endif 268endif 269 270ifneq ($(CONSTANTS),) 271$(warning $(MODULE) has set CONSTANTS, this variable is deprecated, please use MODULE_CONSTANTS or MODULE_EXPORT_CONSTANTS) 272endif 273MODULE_CONSTANTS += $(CONSTANTS) 274 275ifneq ($(MODULE_SRCS)$(MODULE_SRCS_FIRST),) 276# Add this module to the SDK LDFLAGS and objects lists. This needs to be done 277# before including our dependencies in case of recursive deps. 278ifneq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 279ifeq ($(strip $(MODULE_SDK_LIB_NAME)),) 280MODULE_SDK_LIB_NAME := $(call TOSDKLIBNAME,$(MODULE)) 281endif 282 283ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),false) 284# If this module isn't rust, we can link against it from the sdk using -lmodule 285MODULE_SDK_LIBS += $(TRUSTY_SDK_LIB_DIR)/lib$(MODULE_SDK_LIB_NAME).a 286MODULE_EXPORT_LDFLAGS += $(filter-out $(MODULE_EXPORT_LDFLAGS),-l$(MODULE_SDK_LIB_NAME)) 287endif 288 289endif # SDK module 290endif # not header only 291 292# Add this library's headers to the SDK. 293ifneq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 294MODULE_EXPORT_SDK_HEADERS := 295 296define copy-headers-rule 297# Some libraries include symlinked headers. For now, follow 298# those symlinks and copy their targets instead so SDK users 299# can still include the symlink sources. 300HEADERS := $$(shell cd "$(1)" 2>/dev/null && find -L . -type f) 301OUTPUT_HEADERS := $$(filter-out $$(MODULE_EXPORT_SDK_HEADERS),$$(addprefix $(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/,$$(HEADERS))) 302MODULE_EXPORT_SDK_HEADERS += $$(OUTPUT_HEADERS) 303$$(OUTPUT_HEADERS): $(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/% : $(1)/% $(MODULE_SRCDEPS) 304 @$$(MKDIR) 305 $$(NOECHO)cp -L $$< $$@ 306endef 307 308$(foreach include_dir,$(MODULE_EXPORT_INCLUDES),$(eval $(call copy-headers-rule,$(include_dir)))) 309 310# Copy any generated headers explicitly listed in MODULE_SDK_HEADERS 311ifneq ($(strip $(MODULE_SDK_HEADERS)),) 312OUTPUT_HEADERS := $(foreach header,$(MODULE_SDK_HEADERS),$(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/$(notdir $(header))) 313MODULE_EXPORT_SDK_HEADERS += $(OUTPUT_HEADERS) 314$(OUTPUT_HEADERS): MODULE_SDK_HEADERS := $(MODULE_SDK_HEADERS) 315$(OUTPUT_HEADERS): MODULE_SDK_HEADER_INSTALL_DIR := $(MODULE_SDK_HEADER_INSTALL_DIR) 316$(OUTPUT_HEADERS): $(MODULE_SDK_HEADERS) $(MODULE_SRCDEPS) 317 @$(MKDIR) 318 $(NOECHO)cp $(MODULE_SDK_HEADERS) $(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/ 319OUTPUT_HEADERS := 320endif 321 322# Make sure we copy all SDK headers even if they are not needed by the build 323ALL_SDK_INCLUDES += $(MODULE_EXPORT_SDK_HEADERS) 324 325endif # SDK MODULE 326 327# Stem defaults to the crate name 328ifeq ($(MODULE_RUST_STEM),) 329MODULE_RUST_STEM := $(MODULE_CRATE_NAME) 330endif 331 332# Register the module in a global registry. This is used to avoid repeatedly 333# generating rules for this module from modules that depend on it. 334_MODULES_$(MODULE) := T 335 336# Cache exported flags for use in modules that depend on this library. 337_MODULES_$(MODULE)_COMPILEFLAGS := $(MODULE_EXPORT_COMPILEFLAGS) 338_MODULES_$(MODULE)_CONSTANTS := $(MODULE_EXPORT_CONSTANTS) 339_MODULES_$(MODULE)_CFLAGS := $(MODULE_EXPORT_CFLAGS) 340_MODULES_$(MODULE)_CPPFLAGS := $(MODULE_EXPORT_CPPFLAGS) 341_MODULES_$(MODULE)_ASMFLAGS := $(MODULE_EXPORT_ASMFLAGS) 342_MODULES_$(MODULE)_INCLUDES := $(MODULE_EXPORT_INCLUDES) 343_MODULES_$(MODULE)_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 344_MODULES_$(MODULE)_SRCDEPS := $(MODULE_EXPORT_SRCDEPS) 345_MODULES_$(MODULE)_RUST_STEM := $(MODULE_RUST_STEM) 346ifeq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 347ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 348_MODULES_$(MODULE)_CRATE_NAME := $(MODULE_CRATE_NAME) 349 350# Memorize the output headers for this module so that we can add them as srcdeps 351# to dependencies 352_MODULES_$(MODULE)_SDK_HEADERS := $(MODULE_EXPORT_SDK_HEADERS) 353 354# We need to populate rlibs here, before recursing, in case we have a circular 355# dependency. This is analogous to _INCLUDES above. 356ifneq ($(filter rlib,$(MODULE_RUST_CRATE_TYPES)),) 357_MODULES_$(MODULE)_LIBRARIES := $(call TOBUILDDIR,lib$(MODULE_RUST_STEM)).rlib 358_MODULES_$(MODULE)_RLIBS := $(MODULE_CRATE_NAME)=$(call TOBUILDDIR,lib$(MODULE_RUST_STEM).rlib) 359endif 360 361ifneq ($(filter proc-macro,$(MODULE_RUST_CRATE_TYPES)),) 362_MODULES_$(MODULE)_LIBRARIES := $(call TOBUILDDIR,lib$(MODULE_RUST_STEM)).so 363_MODULES_$(MODULE)_RLIBS := $(MODULE_CRATE_NAME)=$(call TOBUILDDIR,lib$(MODULE_RUST_STEM).so) 364endif 365 366else 367_MODULES_$(MODULE)_LIBRARIES := $(call TOBUILDDIR,$(MODULE)).mod.a 368endif 369endif # not SDK module 370 371# Will contain a list of SDK libraries that this library depends on. Used for 372# dependency resolution, not for including the libraries directly in the link. 373_MODULES_$(MODULE)_SDK_LIBS := $(MODULE_SDK_LIBS) 374 375DEPENDENCY_MODULE := 376DEPENDENCY_MODULE_PATH := 377 378# Recurse into dependencies that this module re-exports flags from. This needs 379# to happen before we recurse into regular dependencies in the case of recursive 380# dependencies, which need to pick up this module's re-exported flags. 381$(foreach dep,$(sort $(MODULE_LIBRARY_EXPORTED_DEPS)),\ 382 $(eval EXPORT_DEPENDENCY_MODULE := $(dep))\ 383 $(eval include make/userspace_recurse.mk)) 384 385# Re-cache exported flags after adding any flags from exported deps 386_MODULES_$(MODULE)_COMPILEFLAGS := $(MODULE_EXPORT_COMPILEFLAGS) 387_MODULES_$(MODULE)_CFLAGS := $(MODULE_EXPORT_CFLAGS) 388_MODULES_$(MODULE)_CPPFLAGS := $(MODULE_EXPORT_CPPFLAGS) 389_MODULES_$(MODULE)_ASMFLAGS := $(MODULE_EXPORT_ASMFLAGS) 390_MODULES_$(MODULE)_INCLUDES := $(MODULE_EXPORT_INCLUDES) 391_MODULES_$(MODULE)_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 392_MODULES_$(MODULE)_SDK_HEADERS := $(MODULE_EXPORT_SDK_HEADERS) 393_MODULES_$(MODULE)_SRCDEPS := $(MODULE_EXPORT_SRCDEPS) 394 395# We need to process each dependent module only once. 396# Therefore we get the realpath to avoid different relative-path references to the same module, 397# then sort to remove any duplicates. 398# Module dependencies are then make relative to to top of the build environment. 399MODULE_REAL_LIBRARY_DEPS := $(realpath $(MODULE_LIBRARY_DEPS)) 400ifneq ($(words MODULE_REAL_LIBRARY_DEPS), $(words MODULE_LIBRARY_DEPS)) 401 $(error some modules path do not exist) 402endif 403 404MODULE_UNIQUE_LIBRARY_DEPS := $(sort $(foreach dep, $(MODULE_REAL_LIBRARY_DEPS), $(subst $(TRUSTY_TOP)/,,$(dep)))) 405$(foreach dep,$(MODULE_UNIQUE_LIBRARY_DEPS),\ 406 $(eval DEPENDENCY_MODULE := $(dep))\ 407 $(eval include make/userspace_recurse.mk)) 408 409# Include exported flags in the local build 410MODULE_LIBRARIES := $(filter-out $(MODULE_LIBRARIES),$(MODULE_EXPORT_LIBRARIES)) $(MODULE_LIBRARIES) 411MODULE_EXTRA_OBJECTS := $(filter-out $(MODULE_EXTRA_OBJECTS),$(MODULE_EXPORT_EXTRA_OBJECTS)) $(MODULE_EXTRA_OBJECTS) 412MODULE_WHOLE_ARCHIVES := $(filter-out $(MODULE_WHOLE_ARCHIVES),$(MODULE_EXPORT_WHOLE_ARCHIVES)) $(MODULE_WHOLE_ARCHIVES) 413MODULE_RLIBS := $(filter-out $(MODULE_RLIBS),$(MODULE_EXPORT_RLIBS)) $(MODULE_RLIBS) 414MODULE_COMPILEFLAGS := $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_COMPILEFLAGS) 415MODULE_CONSTANTS := $(MODULE_EXPORT_CONSTANTS) $(MODULE_CONSTANTS) 416MODULE_CFLAGS := $(MODULE_EXPORT_CFLAGS) $(MODULE_CFLAGS) 417MODULE_CPPFLAGS := $(MODULE_EXPORT_CPPFLAGS) $(MODULE_CPPFLAGS) 418MODULE_ASMFLAGS := $(MODULE_EXPORT_ASMFLAGS) $(MODULE_ASMFLAGS) 419MODULE_LDFLAGS := $(filter-out $(MODULE_LDFLAGS),$(MODULE_EXPORT_LDFLAGS)) $(MODULE_LDFLAGS) 420MODULE_SDK_LIBS := $(filter-out $(MODULE_SDK_LIBS),$(MODULE_EXPORT_SDK_LIBS)) $(MODULE_SDK_LIBS) 421MODULE_SDK_HEADERS := $(filter-out $(MODULE_SDK_HEADERS),$(MODULE_EXPORT_SDK_HEADERS)) $(MODULE_SDK_HEADERS) 422MODULE_SRCDEPS := $(MODULE_EXPORT_SRCDEPS) $(MODULE_SRCDEPS) 423 424ifeq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 425# Only add in tree header paths to this module's include path if this module 426# isn't part of the SDK 427MODULE_INCLUDES := $(MODULE_EXPORT_INCLUDES) $(MODULE_INCLUDES) 428endif 429 430# Make sure the headers this module requires are copied before the module is 431# compiled 432MODULE_SRCDEPS += $(MODULE_SDK_HEADERS) 433MODULE_EXPORT_SRCDEPS += $(MODULE_SDK_HEADERS) 434 435# Generate constant headers and manifest, if needed. 436include make/gen_manifest.mk 437 438# Generate Rust bindings with bindgen if requested 439ifneq ($(strip $(MODULE_BINDGEN_SRC_HEADER)),) 440include make/bindgen.mk 441endif 442 443ifneq ($(MODULE_SRCS)$(MODULE_SRCS_FIRST),) 444# Not a header-only library, so we need to build the source files 445 446ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 447 448include make/rust.mk 449 450_MODULES_$(MODULE)_RUST_STATICLIB := $(filter %.a,$(MODULE_RSOBJS)) 451 452_MODULES_$(MODULE)_CRATE_INDEX := $(GLOBAL_CRATE_COUNT) 453GLOBAL_CRATE_COUNT := $(shell echo $$(($(GLOBAL_CRATE_COUNT)+1))) 454 455define CRATE_CONFIG := 456{ 457 "display_name": "$(MODULE_RUST_STEM)", 458 "root_module": "$(filter %.rs,$(MODULE_SRCS))", 459 "edition": "$(MODULE_RUST_EDITION)", 460 "deps": [ 461 $(call STRIP_TRAILING_COMMA,$(foreach dep,$(sort $(MODULE_LIBRARY_DEPS) $(MODULE_LIBRARY_EXPORTED_DEPS)),\ 462 $(if $(_MODULES_$(dep)_RUST_STEM),{"name": "$(_MODULES_$(dep)_RUST_STEM)"$(COMMA) "crate": $(_MODULES_$(dep)_CRATE_INDEX)}$(COMMA)))) 463 ], 464 "cfg": [ 465 $(call STRIP_TRAILING_COMMA,\ 466 $(foreach cfg, \ 467 $(filter --cfg=%, \ 468 # Look for any cfg flags that are separated by a space and coerce to '=' 469 $(shell echo "$(MODULE_RUSTFLAGS) $(GLOBAL_SHARED_RUSTFLAGS)" \ 470 | sed -e 's/--cfg /--cfg=/g'\ 471 )\ 472 # Now that we only have cfgs, remove the --cfg and setup escaped quotations around cfgs that have values 473 ),"$(shell echo $(cfg) \ 474 | sed -e 's/--cfg=//g' \ 475 | sed -E 's/=(.*)/=\\\\\x22\1\\\\\x22/g'\ 476 )"$(COMMA))) 477 ] 478}, 479 480endef 481RUST_ANALYZER_CONTENTS := $(RUST_ANALYZER_CONTENTS)$(CRATE_CONFIG) 482CRATE_CONFIG := 483 484endif # MODULE_IS_RUST 485 486# Save our current module because module.mk clears it. 487LIB_SAVED_MODULE := $(MODULE) 488LIB_SAVED_MODULE_LIBRARY_DEPS := $(MODULE_LIBRARY_DEPS) 489LIB_SAVED_MODULE_SRCDEPS := $(MODULE_SRCDEPS) 490 491# Save the rust flags for use in trusted_app.mk. userspace_recurse.mk will clean 492# up after us. 493LIB_SAVED_MODULE_RUSTFLAGS := $(MODULE_RUSTFLAGS) 494LIB_SAVED_MODULE_RUSTDOCFLAGS := $(MODULE_RUSTDOCFLAGS) 495LIB_SAVED_MODULE_RUSTDOC_OBJECT := $(MODULE_RUSTDOC_OBJECT) 496LIB_SAVED_MODULE_IS_RUST := $(MODULE_IS_RUST) 497LIB_SAVED_MODULE_RUST_USE_CLIPPY := $(MODULE_RUST_USE_CLIPPY) 498 499ALLMODULE_OBJS := 500MODULE_LIBRARY_DEPS := 501 502include make/module.mk 503 504# Handle any MODULE_DEPS 505include make/recurse.mk 506 507MODULE_LIBRARY_DEPS := $(LIB_SAVED_MODULE_LIBRARY_DEPS) 508MODULE_SRCDEPS := $(LIB_SAVED_MODULE_SRCDEPS) 509MODULE := $(LIB_SAVED_MODULE) 510MODULE_RUSTFLAGS := $(LIB_SAVED_MODULE_RUSTFLAGS) 511MODULE_RUSTDOCFLAGS := $(LIB_SAVED_MODULE_RUSTDOCFLAGS) 512MODULE_RUSTDOC_OBJECT := $(LIB_SAVED_MODULE_RUSTDOC_OBJECT) 513MODULE_IS_RUST := $(LIB_SAVED_MODULE_IS_RUST) 514MODULE_RUST_USE_CLIPPY := $(LIB_SAVED_MODULE_RUST_USE_CLIPPY) 515 516$(BUILDDIR)/%: CC := $(CCACHE) $(CLANG_BINDIR)/clang 517$(BUILDDIR)/%: RUSTC := $(RUST_BINDIR)/rustc 518$(BUILDDIR)/%: CLIPPY_DRIVER := $(RUST_BINDIR)/clippy-driver 519$(BUILDDIR)/%.o: GLOBAL_OPTFLAGS := $(GLOBAL_SHARED_OPTFLAGS) $(GLOBAL_USER_OPTFLAGS) $(GLOBAL_USER_IN_TREE_OPTFLAGS) $(ARCH_OPTFLAGS) 520$(BUILDDIR)/%.o: GLOBAL_COMPILEFLAGS := $(GLOBAL_SHARED_COMPILEFLAGS) $(GLOBAL_USER_COMPILEFLAGS) $(GLOBAL_USER_IN_TREE_COMPILEFLAGS) 521$(BUILDDIR)/%.o: GLOBAL_CFLAGS := $(GLOBAL_SHARED_CFLAGS) $(GLOBAL_USER_CFLAGS) $(GLOBAL_USER_IN_TREE_CFLAGS) 522$(BUILDDIR)/%.o: GLOBAL_CPPFLAGS := $(GLOBAL_SHARED_CPPFLAGS) $(GLOBAL_USER_CPPFLAGS) $(GLOBAL_USER_IN_TREE_CPPFLAGS) 523$(BUILDDIR)/%.o: GLOBAL_ASMFLAGS := $(GLOBAL_SHARED_ASMFLAGS) $(GLOBAL_USER_ASMFLAGS) $(GLOBAL_USER_IN_TREE_ASMFLAGS) 524$(BUILDDIR)/%.o: GLOBAL_INCLUDES := $(addprefix -I,$(GLOBAL_UAPI_INCLUDES) $(GLOBAL_SHARED_INCLUDES) $(GLOBAL_USER_INCLUDES)) 525$(BUILDDIR)/%.o: ARCH_COMPILEFLAGS := $(ARCH_$(ARCH)_COMPILEFLAGS) 526$(BUILDDIR)/%.o: ARCH_CFLAGS := $(ARCH_$(ARCH)_CFLAGS) 527$(BUILDDIR)/%.o: THUMBCFLAGS := $(ARCH_$(ARCH)_THUMBCFLAGS) 528$(BUILDDIR)/%.o: ARCH_CPPFLAGS := $(ARCH_$(ARCH)_CPPFLAGS) 529$(BUILDDIR)/%.o: ARCH_ASMFLAGS := $(ARCH_$(ARCH)_ASMFLAGS) 530 531ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 532LIBRARY_ARCHIVE := $(filter %.rlib %.so,$(ALLMODULE_OBJS)) 533else 534LIBRARY_ARCHIVE := $(filter %.mod.a,$(ALLMODULE_OBJS)) 535endif 536 537ifneq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 538# Install the library into the SDK 539 540ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 541# Rust modules aren't added to the SDK sysroot yet. We need to keep track of the 542# library archive here so that we can ensure it is built before its dependencies. 543# 544# TODO: Add proper support for SDK rlibs 545MODULE_EXPORT_LIBRARIES += $(LIBRARY_ARCHIVE) 546endif 547 548SDK_LIB := $(TRUSTY_SDK_LIB_DIR)/lib$(MODULE_SDK_LIB_NAME).a 549ALLMODULE_OBJS := $(filter-out $(LIBRARY_ARCHIVE),$(ALLMODULE_OBJS)) 550OTHER_SDK_OBJS := $(addprefix $(TRUSTY_SDK_LIB_DIR)/,$(notdir $(ALLMODULE_OBJS))) 551$(SDK_LIB): OTHER_OBJS := $(ALLMODULE_OBJS) 552$(SDK_LIB): $(LIBRARY_ARCHIVE) $(ALLMODULE_OBJS) 553 @$(MKDIR) 554 @cp $< $@ 555 @[ -z "$(OTHER_OBJS)" ] || cp $(OTHER_OBJS) $(TRUSTY_SDK_LIB_DIR)/ 556 557# Ensure that any extra SDK objects are copied if they are missing 558$(OTHER_SDK_OBJS): $(SDK_LIB) 559 560MODULE_SDK_LIBS += $(OTHER_SDK_OBJS) 561ALL_SDK_LIBS += $(SDK_LIB) $(OTHER_SDK_OBJS) 562 563# Add any module licenses, if found 564MODULE_LICENSES += $(wildcard $(MODULE)/LICENSE*) $(wildcard $(MODULE)/NOTICE) 565 566# Generate the library makefile 567 568SDK_MAKEFILE := $(TRUSTY_SDK_DIR)/make/lib$(MODULE_SDK_LIB_NAME).mk 569$(SDK_MAKEFILE): MODULE_EXPORT_DEFINES := $(MODULE_EXPORT_DEFINES) 570$(SDK_MAKEFILE): MODULE_EXPORT_CFLAGS := \ 571 $(MODULE_EXPORT_OPTFLAGS) $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_EXPORT_CFLAGS) 572$(SDK_MAKEFILE): MODULE_EXPORT_CXXFLAGS := \ 573 $(MODULE_EXPORT_OPTFLAGS) $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_EXPORT_CPPFLAGS) 574$(SDK_MAKEFILE): MODULE_EXPORT_ASMFLAGS := \ 575 $(MODULE_EXPORT_OPTFLAGS) $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_EXPORT_ASMFLAGS) 576$(SDK_MAKEFILE): MODULE_EXPORT_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 577$(SDK_MAKEFILE): MODULE_SDK_LIB_NAME := $(MODULE_SDK_LIB_NAME) 578$(SDK_MAKEFILE): OTHER_SDK_OBJS := $(addprefix $$(SDK_SYSROOT_DIR)/usr/lib/,$(notdir $(OTHER_SDK_OBJS))) 579$(SDK_MAKEFILE): 580 @$(MKDIR) 581 @$(call ECHO,sdk,generating makefile,for $(MODULE_SDK_LIB_NAME)) 582 $(NOECHO)rm -f $@.tmp 583 $(NOECHO)echo DEFINES += $(call prepare-sdk-flags,$(MODULE_EXPORT_DEFINES)) >> $@.tmp 584 $(NOECHO)echo CFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_CFLAGS)) >> $@.tmp 585 $(NOECHO)echo CXXFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_CXXFLAGS)) >> $@.tmp 586 $(NOECHO)echo ASMFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_ASMFLAGS)) >> $@.tmp 587 $(NOECHO)echo LDFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_LDFLAGS)) >> $@.tmp 588 $(NOECHO)echo 'TRUSTY_APP_OBJECTS += $(OTHER_SDK_OBJS)' >> $@.tmp 589 $(NOECHO)sed -i 's/ \+$$//' $@.tmp 590 @$(call TESTANDREPLACEFILE,$@.tmp,$@) 591 @$(call ECHO_DONE_SILENT,sdk,generating makefile,for $(MODULE_SDK_LIB_NAME)) 592 593ALL_SDK_EXTRA_FILES += $(SDK_MAKEFILE) 594 595else # not an SDK module 596 597# Libraries not in the SDK are included directly in the link as archives, rather 598# than via `-l`. 599MODULE_EXPORT_LIBRARIES += $(LIBRARY_ARCHIVE) 600 601endif # SDK module 602 603MODULE_EXPORT_EXTRA_OBJECTS += $(filter-out $(LIBRARY_ARCHIVE),$(ALLMODULE_OBJS)) 604 605ifeq ($(call TOBOOL,$(MODULE_USE_WHOLE_ARCHIVE)),true) 606MODULE_EXPORT_WHOLE_ARCHIVES += $(LIBRARY_ARCHIVE) 607# Include the current module explicitly in MODULE_WHOLE_ARCHIVES 608# in case we were included from trusted_app.mk 609MODULE_WHOLE_ARCHIVES += $(LIBRARY_ARCHIVE) 610endif 611 612# Append dependency libraries into ALLMODULE_OBJS. This needs to happen after we 613# set up the SDK library copies, if necessary, because we need ALLMODULE_OBJS 614# without dependencies there. 615ALLMODULE_OBJS := $(ALLMODULE_OBJS) $(filter-out $(ALLMODULE_OBJS),$(MODULE_LIBRARIES)) 616 617endif # MODULE is not a header-only library 618 619_MODULES_$(MODULE)_LIBRARIES := $(MODULE_EXPORT_LIBRARIES) 620_MODULES_$(MODULE)_LICENSES := $(MODULE_LICENSES) 621_MODULES_$(MODULE)_EXTRA_OBJECTS := $(MODULE_EXPORT_EXTRA_OBJECTS) 622_MODULES_$(MODULE)_WHOLE_ARCHIVES := $(MODULE_EXPORT_WHOLE_ARCHIVES) 623_MODULES_$(MODULE)_RLIBS := $(MODULE_EXPORT_RLIBS) 624_MODULES_$(MODULE)_SDK_LIBS := $(MODULE_SDK_LIBS) 625_MODULES_$(MODULE)_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 626_MODULES_$(MODULE)_SDK_HEADERS := $(MODULE_EXPORT_SDK_HEADERS) 627 628ifeq ($(call TOBOOL,$(MODULE_RUST_TESTS)),true) 629# Rebuild this module as a test service as well 630BUILD_AS_RUST_TEST_MODULE := true 631DEPENDENCY_MODULE := $(MODULE)-test 632DEPENDENCY_MODULE_PATH := $(MODULE) 633include make/userspace_recurse.mk 634endif 635endif # module is not disabled 636endif # not building rust test app 637 638$(call INFO_DONE_SILENT,$(MODULE),processing,library or app) 639 640endif # building userspace module 641 642# Reset all variables for the next module 643MODULE := 644MODULE_CRATE_NAME := 645MODULE_RUST_STEM := 646MODULE_SRCDEPS := 647MODULE_LIBRARY_DEPS := 648MODULE_LIBRARY_EXPORTED_DEPS := 649MODULE_USE_WHOLE_ARCHIVE := 650MODULE_LIBRARIES := 651MODULE_LICENSES := 652MODULE_RLIBS := 653MODULE_RSOBJS := 654MODULE_RUSTDOC_OBJECT := 655MODULE_RUSTDOCFLAGS := 656MODULE_RUST_USE_CLIPPY := 657MODULE_SKIP_DOCS := 658MODULE_DISABLED := 659MODULE_SDK_LIB_NAME := 660MODULE_SDK_HEADER_INSTALL_DIR := 661MODULE_SDK_HEADERS := 662# MODULE_WHOLE_ARCHIVES is used by trusted_app.mk 663# so we intentionally do not reset it here 664 665LIB_SAVED_MODULE := 666LIB_SAVED_ALLMODULE_OBJS := 667 668ifneq ($(filter proc-macro,$(MODULE_RUST_CRATE_TYPES)),) 669# Reset host build state only once we finish building the proc-macro and its deps 670MODULE_RUST_HOST_LIB := 671endif 672MODULE_RUST_CRATE_TYPES := 673MODULE_RUST_TESTS := 674OTHER_SDK_OBJS := 675SDK_LIB := 676OTHER_OBJS := 677OTHER_SDK_OBJS := 678 679MODULE_EXPORT_LIBRARIES := 680MODULE_EXPORT_RLIBS := 681MODULE_EXPORT_EXTRA_OBJECTS := 682MODULE_EXPORT_WHOLE_ARCHIVES := 683MODULE_EXPORT_COMPILEFLAGS := 684MODULE_EXPORT_CONSTANTS := 685MODULE_EXPORT_CFLAGS := 686MODULE_EXPORT_CPPFLAGS := 687MODULE_EXPORT_ASMFLAGS := 688MODULE_EXPORT_INCLUDES := 689MODULE_EXPORT_LDFLAGS := 690MODULE_EXPORT_SDK_HEADERS := 691MODULE_EXPORT_SRCDEPS := 692MODULE_UNIQUE_LIBRARY_DEPS := 693 694endif # QUERY_MODULE (this line should stay after all other processing) 695