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# Create a fake dependency on configheader to trigger coping the file again 304# in case the copy source file path changes due to configuration change. 305# E.g. for headers copied from prebuilts/build-tools/sysroots/* 306$$(OUTPUT_HEADERS): $(CONFIGHEADER) 307$$(OUTPUT_HEADERS): $(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/% : $(1)/% $(MODULE_SRCDEPS) 308 @$$(MKDIR) 309 $$(NOECHO)cp -L $$< $$@ 310endef 311 312$(foreach include_dir,$(MODULE_EXPORT_INCLUDES),$(eval $(call copy-headers-rule,$(include_dir)))) 313 314# Copy any generated headers explicitly listed in MODULE_SDK_HEADERS 315ifneq ($(strip $(MODULE_SDK_HEADERS)),) 316OUTPUT_HEADERS := $(foreach header,$(MODULE_SDK_HEADERS),$(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/$(notdir $(header))) 317MODULE_EXPORT_SDK_HEADERS += $(OUTPUT_HEADERS) 318$(OUTPUT_HEADERS): MODULE_SDK_HEADERS := $(MODULE_SDK_HEADERS) 319$(OUTPUT_HEADERS): MODULE_SDK_HEADER_INSTALL_DIR := $(MODULE_SDK_HEADER_INSTALL_DIR) 320$(OUTPUT_HEADERS): $(MODULE_SDK_HEADERS) $(MODULE_SRCDEPS) 321 @$(MKDIR) 322 $(NOECHO)cp $(MODULE_SDK_HEADERS) $(TRUSTY_SDK_INCLUDE_DIR)/$(MODULE_SDK_HEADER_INSTALL_DIR)/ 323OUTPUT_HEADERS := 324endif 325 326# Make sure we copy all SDK headers even if they are not needed by the build 327ALL_SDK_INCLUDES += $(MODULE_EXPORT_SDK_HEADERS) 328 329endif # SDK MODULE 330 331# Stem defaults to the crate name 332ifeq ($(MODULE_RUST_STEM),) 333MODULE_RUST_STEM := $(MODULE_CRATE_NAME) 334endif 335 336# Register the module in a global registry. This is used to avoid repeatedly 337# generating rules for this module from modules that depend on it. 338_MODULES_$(MODULE) := T 339 340# Cache exported flags for use in modules that depend on this library. 341_MODULES_$(MODULE)_COMPILEFLAGS := $(MODULE_EXPORT_COMPILEFLAGS) 342_MODULES_$(MODULE)_CONSTANTS := $(MODULE_EXPORT_CONSTANTS) 343_MODULES_$(MODULE)_CFLAGS := $(MODULE_EXPORT_CFLAGS) 344_MODULES_$(MODULE)_CPPFLAGS := $(MODULE_EXPORT_CPPFLAGS) 345_MODULES_$(MODULE)_ASMFLAGS := $(MODULE_EXPORT_ASMFLAGS) 346_MODULES_$(MODULE)_INCLUDES := $(MODULE_EXPORT_INCLUDES) 347_MODULES_$(MODULE)_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 348_MODULES_$(MODULE)_SRCDEPS := $(MODULE_EXPORT_SRCDEPS) 349_MODULES_$(MODULE)_RUST_STEM := $(MODULE_RUST_STEM) 350ifeq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 351ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 352_MODULES_$(MODULE)_CRATE_NAME := $(MODULE_CRATE_NAME) 353 354# Memorize the output headers for this module so that we can add them as srcdeps 355# to dependencies 356_MODULES_$(MODULE)_SDK_HEADERS := $(MODULE_EXPORT_SDK_HEADERS) 357 358# We need to populate rlibs here, before recursing, in case we have a circular 359# dependency. This is analogous to _INCLUDES above. 360ifneq ($(filter rlib,$(MODULE_RUST_CRATE_TYPES)),) 361_MODULES_$(MODULE)_LIBRARIES := $(call TOBUILDDIR,lib$(MODULE_RUST_STEM)).rlib 362_MODULES_$(MODULE)_RLIBS := $(MODULE_CRATE_NAME)=$(call TOBUILDDIR,lib$(MODULE_RUST_STEM).rlib) 363endif 364 365ifneq ($(filter proc-macro,$(MODULE_RUST_CRATE_TYPES)),) 366_MODULES_$(MODULE)_LIBRARIES := $(call TOBUILDDIR,lib$(MODULE_RUST_STEM)).so 367_MODULES_$(MODULE)_RLIBS := $(MODULE_CRATE_NAME)=$(call TOBUILDDIR,lib$(MODULE_RUST_STEM).so) 368endif 369 370else 371_MODULES_$(MODULE)_LIBRARIES := $(call TOBUILDDIR,$(MODULE)).mod.a 372endif 373endif # not SDK module 374 375# Will contain a list of SDK libraries that this library depends on. Used for 376# dependency resolution, not for including the libraries directly in the link. 377_MODULES_$(MODULE)_SDK_LIBS := $(MODULE_SDK_LIBS) 378 379DEPENDENCY_MODULE := 380DEPENDENCY_MODULE_PATH := 381 382# Recurse into dependencies that this module re-exports flags from. This needs 383# to happen before we recurse into regular dependencies in the case of recursive 384# dependencies, which need to pick up this module's re-exported flags. 385$(foreach dep,$(sort $(MODULE_LIBRARY_EXPORTED_DEPS)),\ 386 $(eval EXPORT_DEPENDENCY_MODULE := $(dep))\ 387 $(eval include make/userspace_recurse.mk)) 388 389# Re-cache exported flags after adding any flags from exported deps 390_MODULES_$(MODULE)_COMPILEFLAGS := $(MODULE_EXPORT_COMPILEFLAGS) 391_MODULES_$(MODULE)_CFLAGS := $(MODULE_EXPORT_CFLAGS) 392_MODULES_$(MODULE)_CPPFLAGS := $(MODULE_EXPORT_CPPFLAGS) 393_MODULES_$(MODULE)_ASMFLAGS := $(MODULE_EXPORT_ASMFLAGS) 394_MODULES_$(MODULE)_INCLUDES := $(MODULE_EXPORT_INCLUDES) 395_MODULES_$(MODULE)_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 396_MODULES_$(MODULE)_SDK_HEADERS := $(MODULE_EXPORT_SDK_HEADERS) 397_MODULES_$(MODULE)_SRCDEPS := $(MODULE_EXPORT_SRCDEPS) 398 399# We need to process each dependent module only once. 400# Therefore we get the realpath to avoid different relative-path references to the same module, 401# then sort to remove any duplicates. 402# Module dependencies are then make relative to to top of the build environment. 403MODULE_REAL_LIBRARY_DEPS := $(realpath $(MODULE_LIBRARY_DEPS)) 404ifneq ($(words MODULE_REAL_LIBRARY_DEPS), $(words MODULE_LIBRARY_DEPS)) 405 $(error some modules path do not exist) 406endif 407 408MODULE_UNIQUE_LIBRARY_DEPS := $(sort $(foreach dep, $(MODULE_REAL_LIBRARY_DEPS), $(subst $(TRUSTY_TOP)/,,$(dep)))) 409$(foreach dep,$(MODULE_UNIQUE_LIBRARY_DEPS),\ 410 $(eval DEPENDENCY_MODULE := $(dep))\ 411 $(eval include make/userspace_recurse.mk)) 412 413# Include exported flags in the local build 414MODULE_LIBRARIES := $(filter-out $(MODULE_LIBRARIES),$(MODULE_EXPORT_LIBRARIES)) $(MODULE_LIBRARIES) 415MODULE_EXTRA_OBJECTS := $(filter-out $(MODULE_EXTRA_OBJECTS),$(MODULE_EXPORT_EXTRA_OBJECTS)) $(MODULE_EXTRA_OBJECTS) 416MODULE_WHOLE_ARCHIVES := $(filter-out $(MODULE_WHOLE_ARCHIVES),$(MODULE_EXPORT_WHOLE_ARCHIVES)) $(MODULE_WHOLE_ARCHIVES) 417MODULE_RLIBS := $(filter-out $(MODULE_RLIBS),$(MODULE_EXPORT_RLIBS)) $(MODULE_RLIBS) 418MODULE_COMPILEFLAGS := $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_COMPILEFLAGS) 419MODULE_CONSTANTS := $(MODULE_EXPORT_CONSTANTS) $(MODULE_CONSTANTS) 420MODULE_CFLAGS := $(MODULE_EXPORT_CFLAGS) $(MODULE_CFLAGS) 421MODULE_CPPFLAGS := $(MODULE_EXPORT_CPPFLAGS) $(MODULE_CPPFLAGS) 422MODULE_ASMFLAGS := $(MODULE_EXPORT_ASMFLAGS) $(MODULE_ASMFLAGS) 423MODULE_LDFLAGS := $(filter-out $(MODULE_LDFLAGS),$(MODULE_EXPORT_LDFLAGS)) $(MODULE_LDFLAGS) 424MODULE_SDK_LIBS := $(filter-out $(MODULE_SDK_LIBS),$(MODULE_EXPORT_SDK_LIBS)) $(MODULE_SDK_LIBS) 425MODULE_SDK_HEADERS := $(filter-out $(MODULE_SDK_HEADERS),$(MODULE_EXPORT_SDK_HEADERS)) $(MODULE_SDK_HEADERS) 426MODULE_SRCDEPS := $(MODULE_EXPORT_SRCDEPS) $(MODULE_SRCDEPS) 427 428ifeq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 429# Only add in tree header paths to this module's include path if this module 430# isn't part of the SDK 431MODULE_INCLUDES := $(MODULE_EXPORT_INCLUDES) $(MODULE_INCLUDES) 432endif 433 434# Make sure the headers this module requires are copied before the module is 435# compiled 436MODULE_SRCDEPS += $(MODULE_SDK_HEADERS) 437MODULE_EXPORT_SRCDEPS += $(MODULE_SDK_HEADERS) 438 439# Generate constant headers and manifest, if needed. 440include make/gen_manifest.mk 441 442# Generate Rust bindings with bindgen if requested 443ifneq ($(strip $(MODULE_BINDGEN_SRC_HEADER)),) 444include make/bindgen.mk 445endif 446 447ifneq ($(MODULE_SRCS)$(MODULE_SRCS_FIRST),) 448# Not a header-only library, so we need to build the source files 449 450ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 451 452include make/rust.mk 453 454_MODULES_$(MODULE)_RUST_STATICLIB := $(filter %.a,$(MODULE_RSOBJS)) 455 456_MODULES_$(MODULE)_CRATE_INDEX := $(GLOBAL_CRATE_COUNT) 457GLOBAL_CRATE_COUNT := $(shell echo $$(($(GLOBAL_CRATE_COUNT)+1))) 458 459define CRATE_CONFIG := 460{ 461 "display_name": "$(MODULE_RUST_STEM)", 462 "root_module": "$(filter %.rs,$(MODULE_SRCS))", 463 "edition": "$(MODULE_RUST_EDITION)", 464 "deps": [ 465 $(call STRIP_TRAILING_COMMA,$(foreach dep,$(sort $(MODULE_LIBRARY_DEPS) $(MODULE_LIBRARY_EXPORTED_DEPS)),\ 466 $(if $(_MODULES_$(dep)_RUST_STEM),{"name": "$(_MODULES_$(dep)_RUST_STEM)"$(COMMA) "crate": $(_MODULES_$(dep)_CRATE_INDEX)}$(COMMA)))) 467 ], 468 "cfg": [ 469 $(call STRIP_TRAILING_COMMA,\ 470 $(foreach cfg, \ 471 $(filter --cfg=%, \ 472 # Look for any cfg flags that are separated by a space and coerce to '=' 473 $(shell echo "$(MODULE_RUSTFLAGS) $(GLOBAL_SHARED_RUSTFLAGS)" \ 474 | sed -e 's/--cfg /--cfg=/g'\ 475 )\ 476 # Now that we only have cfgs, remove the --cfg and setup escaped quotations around cfgs that have values 477 ),"$(shell echo $(cfg) \ 478 | sed -e 's/--cfg=//g' \ 479 | sed -E 's/=(.*)/=\\\\\x22\1\\\\\x22/g'\ 480 )"$(COMMA))) 481 ] 482}, 483 484endef 485RUST_ANALYZER_CONTENTS := $(RUST_ANALYZER_CONTENTS)$(CRATE_CONFIG) 486CRATE_CONFIG := 487 488endif # MODULE_IS_RUST 489 490# Save our current module because module.mk clears it. 491LIB_SAVED_MODULE := $(MODULE) 492LIB_SAVED_MODULE_LIBRARY_DEPS := $(MODULE_LIBRARY_DEPS) 493LIB_SAVED_MODULE_SRCDEPS := $(MODULE_SRCDEPS) 494 495# Save the rust flags for use in trusted_app.mk. userspace_recurse.mk will clean 496# up after us. 497LIB_SAVED_MODULE_RUSTFLAGS := $(MODULE_RUSTFLAGS) 498LIB_SAVED_MODULE_RUSTDOCFLAGS := $(MODULE_RUSTDOCFLAGS) 499LIB_SAVED_MODULE_RUSTDOC_OBJECT := $(MODULE_RUSTDOC_OBJECT) 500LIB_SAVED_MODULE_IS_RUST := $(MODULE_IS_RUST) 501LIB_SAVED_MODULE_RUST_USE_CLIPPY := $(MODULE_RUST_USE_CLIPPY) 502 503ALLMODULE_OBJS := 504MODULE_LIBRARY_DEPS := 505 506include make/module.mk 507 508# Handle any MODULE_DEPS 509include make/recurse.mk 510 511MODULE_LIBRARY_DEPS := $(LIB_SAVED_MODULE_LIBRARY_DEPS) 512MODULE_SRCDEPS := $(LIB_SAVED_MODULE_SRCDEPS) 513MODULE := $(LIB_SAVED_MODULE) 514MODULE_RUSTFLAGS := $(LIB_SAVED_MODULE_RUSTFLAGS) 515MODULE_RUSTDOCFLAGS := $(LIB_SAVED_MODULE_RUSTDOCFLAGS) 516MODULE_RUSTDOC_OBJECT := $(LIB_SAVED_MODULE_RUSTDOC_OBJECT) 517MODULE_IS_RUST := $(LIB_SAVED_MODULE_IS_RUST) 518MODULE_RUST_USE_CLIPPY := $(LIB_SAVED_MODULE_RUST_USE_CLIPPY) 519 520$(BUILDDIR)/%: CC := $(CCACHE) $(CLANG_BINDIR)/clang 521$(BUILDDIR)/%: RUSTC := $(RUST_BINDIR)/rustc 522$(BUILDDIR)/%: CLIPPY_DRIVER := $(RUST_BINDIR)/clippy-driver 523$(BUILDDIR)/%.o: GLOBAL_OPTFLAGS := $(GLOBAL_SHARED_OPTFLAGS) $(GLOBAL_USER_OPTFLAGS) $(GLOBAL_USER_IN_TREE_OPTFLAGS) $(ARCH_OPTFLAGS) 524$(BUILDDIR)/%.o: GLOBAL_COMPILEFLAGS := $(GLOBAL_SHARED_COMPILEFLAGS) $(GLOBAL_USER_COMPILEFLAGS) $(GLOBAL_USER_IN_TREE_COMPILEFLAGS) 525$(BUILDDIR)/%.o: GLOBAL_CFLAGS := $(GLOBAL_SHARED_CFLAGS) $(GLOBAL_USER_CFLAGS) $(GLOBAL_USER_IN_TREE_CFLAGS) 526$(BUILDDIR)/%.o: GLOBAL_CPPFLAGS := $(GLOBAL_SHARED_CPPFLAGS) $(GLOBAL_USER_CPPFLAGS) $(GLOBAL_USER_IN_TREE_CPPFLAGS) 527$(BUILDDIR)/%.o: GLOBAL_ASMFLAGS := $(GLOBAL_SHARED_ASMFLAGS) $(GLOBAL_USER_ASMFLAGS) $(GLOBAL_USER_IN_TREE_ASMFLAGS) 528$(BUILDDIR)/%.o: GLOBAL_INCLUDES := $(addprefix -I,$(GLOBAL_UAPI_INCLUDES) $(GLOBAL_SHARED_INCLUDES) $(GLOBAL_USER_INCLUDES)) 529$(BUILDDIR)/%.o: ARCH_COMPILEFLAGS := $(ARCH_$(ARCH)_COMPILEFLAGS) 530$(BUILDDIR)/%.o: ARCH_CFLAGS := $(ARCH_$(ARCH)_CFLAGS) 531$(BUILDDIR)/%.o: THUMBCFLAGS := $(ARCH_$(ARCH)_THUMBCFLAGS) 532$(BUILDDIR)/%.o: ARCH_CPPFLAGS := $(ARCH_$(ARCH)_CPPFLAGS) 533$(BUILDDIR)/%.o: ARCH_ASMFLAGS := $(ARCH_$(ARCH)_ASMFLAGS) 534 535ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 536LIBRARY_ARCHIVE := $(filter %.rlib %.so,$(ALLMODULE_OBJS)) 537else 538LIBRARY_ARCHIVE := $(filter %.mod.a,$(ALLMODULE_OBJS)) 539endif 540 541ifneq ($(filter $(MODULE),$(TRUSTY_SDK_MODULES)),) 542# Install the library into the SDK 543 544ifeq ($(call TOBOOL,$(MODULE_IS_RUST)),true) 545# Rust modules aren't added to the SDK sysroot yet. We need to keep track of the 546# library archive here so that we can ensure it is built before its dependencies. 547# 548# TODO: Add proper support for SDK rlibs 549MODULE_EXPORT_LIBRARIES += $(LIBRARY_ARCHIVE) 550endif 551 552SDK_LIB := $(TRUSTY_SDK_LIB_DIR)/lib$(MODULE_SDK_LIB_NAME).a 553ALLMODULE_OBJS := $(filter-out $(LIBRARY_ARCHIVE),$(ALLMODULE_OBJS)) 554OTHER_SDK_OBJS := $(addprefix $(TRUSTY_SDK_LIB_DIR)/,$(notdir $(ALLMODULE_OBJS))) 555$(SDK_LIB): OTHER_OBJS := $(ALLMODULE_OBJS) 556$(SDK_LIB): $(LIBRARY_ARCHIVE) $(ALLMODULE_OBJS) 557 @$(MKDIR) 558 @cp $< $@ 559 @[ -z "$(OTHER_OBJS)" ] || cp $(OTHER_OBJS) $(TRUSTY_SDK_LIB_DIR)/ 560 561# Ensure that any extra SDK objects are copied if they are missing 562$(OTHER_SDK_OBJS): $(SDK_LIB) 563 564MODULE_SDK_LIBS += $(OTHER_SDK_OBJS) 565ALL_SDK_LIBS += $(SDK_LIB) $(OTHER_SDK_OBJS) 566 567# Add any module licenses, if found 568MODULE_LICENSES += $(wildcard $(MODULE)/LICENSE*) $(wildcard $(MODULE)/NOTICE) 569 570# Generate the library makefile 571 572SDK_MAKEFILE := $(TRUSTY_SDK_DIR)/make/lib$(MODULE_SDK_LIB_NAME).mk 573$(SDK_MAKEFILE): MODULE_EXPORT_DEFINES := $(MODULE_EXPORT_DEFINES) 574$(SDK_MAKEFILE): MODULE_EXPORT_CFLAGS := \ 575 $(MODULE_EXPORT_OPTFLAGS) $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_EXPORT_CFLAGS) 576$(SDK_MAKEFILE): MODULE_EXPORT_CXXFLAGS := \ 577 $(MODULE_EXPORT_OPTFLAGS) $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_EXPORT_CPPFLAGS) 578$(SDK_MAKEFILE): MODULE_EXPORT_ASMFLAGS := \ 579 $(MODULE_EXPORT_OPTFLAGS) $(MODULE_EXPORT_COMPILEFLAGS) $(MODULE_EXPORT_ASMFLAGS) 580$(SDK_MAKEFILE): MODULE_EXPORT_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 581$(SDK_MAKEFILE): MODULE_SDK_LIB_NAME := $(MODULE_SDK_LIB_NAME) 582$(SDK_MAKEFILE): OTHER_SDK_OBJS := $(addprefix $$(SDK_SYSROOT_DIR)/usr/lib/,$(notdir $(OTHER_SDK_OBJS))) 583$(SDK_MAKEFILE): 584 @$(MKDIR) 585 @$(call ECHO,sdk,generating makefile,for $(MODULE_SDK_LIB_NAME)) 586 $(NOECHO)rm -f $@.tmp 587 $(NOECHO)echo DEFINES += $(call prepare-sdk-flags,$(MODULE_EXPORT_DEFINES)) >> $@.tmp 588 $(NOECHO)echo CFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_CFLAGS)) >> $@.tmp 589 $(NOECHO)echo CXXFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_CXXFLAGS)) >> $@.tmp 590 $(NOECHO)echo ASMFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_ASMFLAGS)) >> $@.tmp 591 $(NOECHO)echo LDFLAGS += $(call prepare-sdk-flags,$(MODULE_EXPORT_LDFLAGS)) >> $@.tmp 592 $(NOECHO)echo 'TRUSTY_APP_OBJECTS += $(OTHER_SDK_OBJS)' >> $@.tmp 593 $(NOECHO)sed -i 's/ \+$$//' $@.tmp 594 @$(call TESTANDREPLACEFILE,$@.tmp,$@) 595 @$(call ECHO_DONE_SILENT,sdk,generating makefile,for $(MODULE_SDK_LIB_NAME)) 596 597ALL_SDK_EXTRA_FILES += $(SDK_MAKEFILE) 598 599else # not an SDK module 600 601# Libraries not in the SDK are included directly in the link as archives, rather 602# than via `-l`. 603MODULE_EXPORT_LIBRARIES += $(LIBRARY_ARCHIVE) 604 605endif # SDK module 606 607MODULE_EXPORT_EXTRA_OBJECTS += $(filter-out $(LIBRARY_ARCHIVE),$(ALLMODULE_OBJS)) 608 609ifeq ($(call TOBOOL,$(MODULE_USE_WHOLE_ARCHIVE)),true) 610MODULE_EXPORT_WHOLE_ARCHIVES += $(LIBRARY_ARCHIVE) 611# Include the current module explicitly in MODULE_WHOLE_ARCHIVES 612# in case we were included from trusted_app.mk 613MODULE_WHOLE_ARCHIVES += $(LIBRARY_ARCHIVE) 614endif 615 616# Append dependency libraries into ALLMODULE_OBJS. This needs to happen after we 617# set up the SDK library copies, if necessary, because we need ALLMODULE_OBJS 618# without dependencies there. 619ALLMODULE_OBJS := $(ALLMODULE_OBJS) $(filter-out $(ALLMODULE_OBJS),$(MODULE_LIBRARIES)) 620 621endif # MODULE is not a header-only library 622 623_MODULES_$(MODULE)_LIBRARIES := $(MODULE_EXPORT_LIBRARIES) 624_MODULES_$(MODULE)_LICENSES := $(MODULE_LICENSES) 625_MODULES_$(MODULE)_EXTRA_OBJECTS := $(MODULE_EXPORT_EXTRA_OBJECTS) 626_MODULES_$(MODULE)_WHOLE_ARCHIVES := $(MODULE_EXPORT_WHOLE_ARCHIVES) 627_MODULES_$(MODULE)_RLIBS := $(MODULE_EXPORT_RLIBS) 628_MODULES_$(MODULE)_SDK_LIBS := $(MODULE_SDK_LIBS) 629_MODULES_$(MODULE)_LDFLAGS := $(MODULE_EXPORT_LDFLAGS) 630_MODULES_$(MODULE)_SDK_HEADERS := $(MODULE_EXPORT_SDK_HEADERS) 631 632ifeq ($(call TOBOOL,$(MODULE_RUST_TESTS)),true) 633# Rebuild this module as a test service as well 634BUILD_AS_RUST_TEST_MODULE := true 635DEPENDENCY_MODULE := $(MODULE)-test 636DEPENDENCY_MODULE_PATH := $(MODULE) 637include make/userspace_recurse.mk 638endif 639endif # module is not disabled 640endif # not building rust test app 641 642$(call INFO_DONE_SILENT,$(MODULE),processing,library or app) 643 644endif # building userspace module 645 646# Reset all variables for the next module 647MODULE := 648MODULE_CRATE_NAME := 649MODULE_RUST_STEM := 650MODULE_SRCDEPS := 651MODULE_LIBRARY_DEPS := 652MODULE_LIBRARY_EXPORTED_DEPS := 653MODULE_USE_WHOLE_ARCHIVE := 654MODULE_LIBRARIES := 655MODULE_LICENSES := 656MODULE_RLIBS := 657MODULE_RSOBJS := 658MODULE_RUSTDOC_OBJECT := 659MODULE_RUSTDOCFLAGS := 660MODULE_RUST_USE_CLIPPY := 661MODULE_SKIP_DOCS := 662MODULE_DISABLED := 663MODULE_SDK_LIB_NAME := 664MODULE_SDK_HEADER_INSTALL_DIR := 665MODULE_SDK_HEADERS := 666# MODULE_WHOLE_ARCHIVES is used by trusted_app.mk 667# so we intentionally do not reset it here 668 669LIB_SAVED_MODULE := 670LIB_SAVED_ALLMODULE_OBJS := 671 672ifneq ($(filter proc-macro,$(MODULE_RUST_CRATE_TYPES)),) 673# Reset host build state only once we finish building the proc-macro and its deps 674MODULE_RUST_HOST_LIB := 675endif 676MODULE_RUST_CRATE_TYPES := 677MODULE_RUST_TESTS := 678OTHER_SDK_OBJS := 679SDK_LIB := 680OTHER_OBJS := 681OTHER_SDK_OBJS := 682 683MODULE_EXPORT_LIBRARIES := 684MODULE_EXPORT_RLIBS := 685MODULE_EXPORT_EXTRA_OBJECTS := 686MODULE_EXPORT_WHOLE_ARCHIVES := 687MODULE_EXPORT_COMPILEFLAGS := 688MODULE_EXPORT_CONSTANTS := 689MODULE_EXPORT_CFLAGS := 690MODULE_EXPORT_CPPFLAGS := 691MODULE_EXPORT_ASMFLAGS := 692MODULE_EXPORT_INCLUDES := 693MODULE_EXPORT_LDFLAGS := 694MODULE_EXPORT_SDK_HEADERS := 695MODULE_EXPORT_SRCDEPS := 696MODULE_UNIQUE_LIBRARY_DEPS := 697 698endif # QUERY_MODULE (this line should stay after all other processing) 699