• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1
2# modules
3#
4# args:
5# MODULE : module name (required)
6# MODULE_SRCS : list of source files, local path (required)
7# MODULE_DEPS : other modules that this one depends on
8# MODULE_DEFINES : #defines local to this module
9# MODULE_OPTFLAGS : OPTFLAGS local to this module
10# MODULE_COMPILEFLAGS : COMPILEFLAGS local to this module
11# MODULE_CFLAGS : CFLAGS local to this module
12# MODULE_CPPFLAGS : CPPFLAGS local to this module
13# MODULE_ASMFLAGS : ASMFLAGS local to this module
14# MODULE_RUSTFLAGS : RUSTFLAGS local to this module
15# MODULE_RUSTDOCFLAGS : RUSTDOCFLAGS local to this module
16# MODULE_RUSTDOC_OBJECT : marker file to use as target when building Rust docs
17# MODULE_INCLUDES : include directories local to this module
18# MODULE_SRCDEPS : extra dependencies that all of this module's files depend on
19# MODULE_EXTRA_ARCHIVES : extra .a files that should be linked with the module
20# MODULE_EXTRA_OBJS : extra .o files that should be linked with the module
21# MODULE_DISABLE_LTO : disable LTO for this module
22# MODULE_DISABLE_CFI : disable CFI for this module
23# MODULE_DISABLE_STACK_PROTECTOR : disable stack protector for this module
24# MODULE_DISABLE_SCS : disable shadow call stack for this module
25# MODULE_SKIP_DOCS : skip generating docs for this module
26
27# MODULE_ARM_OVERRIDE_SRCS : list of source files, local path that should be force compiled with ARM (if applicable)
28
29# the minimum module rules.mk file is as follows:
30#
31# LOCAL_DIR := $(GET_LOCAL_DIR)
32# MODULE := $(LOCAL_DIR)
33#
34# MODULE_SRCS := $(LOCAL_DIR)/at_least_one_source_file.c
35#
36# include make/module.mk
37
38# if QUERY_MODULE is set, the rules.mk that included us was itself included not
39# to define a module's make targets but to query the variables it sets for the
40# rest of the build. in this case, skip all further processing
41ifeq ($(QUERY_MODULE),)
42
43# test for old style rules.mk
44ifneq ($(MODULE_OBJS),)
45$(warning MODULE_OBJS = $(MODULE_OBJS))
46$(error MODULE $(MODULE) is setting MODULE_OBJS, change to MODULE_SRCS)
47endif
48ifneq ($(OBJS),)
49$(warning OBJS = $(OBJS))
50$(error MODULE $(MODULE) is probably setting OBJS, change to MODULE_SRCS)
51endif
52
53ifeq ($(call TOBOOL,$(TRUSTY_NEW_MODULE_SYSTEM)),true)
54$(error MODULE $(MODULE) was included through the new module system and therefore must include library.mk or trusted_app.mk)
55endif
56
57MODULE_SRCDIR := $(MODULE)
58MODULE_BUILDDIR := $(call TOBUILDDIR,$(MODULE_SRCDIR))
59
60# add a local include dir to the global include path
61GLOBAL_INCLUDES += $(MODULE_SRCDIR)/include
62
63$(foreach MOD,$(MODULE_DEPS), $(if $(call FIND_MODULE,$(MOD)),,$(error Module doesn't exist: $(MOD) (included from $(MODULE)))))
64
65# add the listed module deps to the global list
66MODULES += $(MODULE_DEPS)
67
68#$(info module $(MODULE))
69#$(info MODULE_SRCDIR $(MODULE_SRCDIR))
70#$(info MODULE_BUILDDIR $(MODULE_BUILDDIR))
71#$(info MODULE_DEPS $(MODULE_DEPS))
72#$(info MODULE_SRCS $(MODULE_SRCS))
73
74# Turn spaces into underscores and escape quotes for the module_config.h header
75define clean_defines
76$(subst $(SPACE),_,$(subst \",\\\\\",$(subst $(BUILDROOT),__BUILDROOT__,$(1))))
77endef
78
79MODULE_DEFINES += MODULE_COMPILEFLAGS=\"$(call clean_defines,$(MODULE_COMPILEFLAGS))\"
80MODULE_DEFINES += MODULE_CFLAGS=\"$(call clean_defines,$(MODULE_CFLAGS))\"
81MODULE_DEFINES += MODULE_CPPFLAGS=\"$(call clean_defines,$(MODULE_CPPFLAGS))\"
82MODULE_DEFINES += MODULE_ASMFLAGS=\"$(call clean_defines,$(MODULE_ASMFLAGS))\"
83MODULE_DEFINES += MODULE_RUSTFLAGS=\"$(call clean_defines,$(MODULE_RUSTFLAGS))\"
84MODULE_DEFINES += MODULE_RUSTDOCFLAGS=\"$(call clean_defines,$(MODULE_RUSTDOCFLAGS))\"
85MODULE_DEFINES += MODULE_RUST_ENV=\"$(call clean_defines,$(MODULE_RUST_ENV))\"
86MODULE_DEFINES += MODULE_LDFLAGS=\"$(call clean_defines,$(MODULE_LDFLAGS))\"
87MODULE_DEFINES += MODULE_OPTFLAGS=\"$(call clean_defines,$(MODULE_OPTFLAGS))\"
88MODULE_DEFINES += MODULE_INCLUDES=\"$(call clean_defines,$(MODULE_INCLUDES))\"
89MODULE_DEFINES += MODULE_SRCDEPS=\"$(call clean_defines,$(MODULE_SRCDEPS))\"
90MODULE_DEFINES += MODULE_DEPS=\"$(call clean_defines,$(MODULE_DEPS))\"
91MODULE_DEFINES += MODULE_SRCS=\"$(call clean_defines,$(MODULE_SRCS))\"
92
93# Handle common kernel module flags. Common userspace flags are found in
94# user/base/make/common_flags.mk
95ifneq (true,$(call TOBOOL,$(USER_TASK_MODULE)))
96
97# LTO
98ifneq (true,$(call TOBOOL,$(MODULE_DISABLE_LTO)))
99ifeq (true,$(call TOBOOL,$(KERNEL_LTO_ENABLED)))
100MODULE_COMPILEFLAGS += $(GLOBAL_LTO_COMPILEFLAGS)
101
102# CFI
103MODULE_CFI_ENABLED := false
104ifneq (true,$(call TOBOOL,$(MODULE_DISABLE_CFI)))
105ifeq (true,$(call TOBOOL,$(CFI_ENABLED)))
106MODULE_CFI_ENABLED := true
107endif
108
109ifdef KERNEL_CFI_ENABLED
110MODULE_CFI_ENABLED := $(call TOBOOL,$(KERNEL_CFI_ENABLED))
111endif
112
113endif
114
115ifeq (true,$(call TOBOOL,$(MODULE_CFI_ENABLED)))
116MODULE_COMPILEFLAGS += \
117	-fsanitize-blacklist=trusty/kernel/lib/ubsan/exemptlist \
118	-fsanitize=cfi \
119	-DCFI_ENABLED
120
121MODULES += trusty/kernel/lib/ubsan
122
123ifeq (true,$(call TOBOOL,$(CFI_DIAGNOSTICS)))
124MODULE_COMPILEFLAGS += -fno-sanitize-trap=cfi
125endif
126endif
127
128endif
129endif
130
131# Branch Target Identification
132ifeq (true,$(call TOBOOL,$(KERNEL_BTI_ENABLED)))
133MODULE_COMPILEFLAGS += -DKERNEL_BTI_ENABLED \
134                       -DBTI_ENABLED
135endif
136
137# Pointer Authentication Codes
138ifeq (true,$(call TOBOOL,$(KERNEL_PAC_ENABLED)))
139ifeq (true,$(call TOBOOL,$(SCS_ENABLED)))
140# See https://github.com/llvm/llvm-project/issues/63457
141$(error Error: Kernel shadow call stack is not supported when Kernel PAC is enabled)
142endif
143
144MODULE_COMPILEFLAGS += -DKERNEL_PAC_ENABLED
145endif
146
147# Decide on the branch protection scheme
148ifeq (true,$(call TOBOOL,$(KERNEL_BTI_ENABLED)))
149ifeq (true,$(call TOBOOL,$(KERNEL_PAC_ENABLED)))
150MODULE_COMPILEFLAGS += -mbranch-protection=bti+pac-ret
151else
152MODULE_COMPILEFLAGS += -mbranch-protection=bti
153endif
154else # !KERNEL_BTI_ENABLED
155ifeq (true,$(call TOBOOL,$(KERNEL_PAC_ENABLED)))
156MODULE_COMPILEFLAGS += -mbranch-protection=pac-ret
157endif
158endif
159
160# Shadow call stack
161ifeq (true,$(call TOBOOL,$(SCS_ENABLED)))
162# set in arch/$(ARCH)/toolchain.mk iff shadow call stack is supported
163ifeq (false,$(call TOBOOL,$(ARCH_$(ARCH)_SUPPORTS_SCS)))
164$(error Error: Shadow call stack is not supported for $(ARCH))
165endif
166
167ifeq (false,$(call TOBOOL,$(MODULE_DISABLE_SCS)))
168# architectures that support SCS should set the flag that reserves
169# a register for the shadow call stack in their toolchain.mk file
170MODULE_COMPILEFLAGS += \
171	-fsanitize=shadow-call-stack \
172
173endif
174endif
175
176endif
177
178# Initialize all automatic var to 0 if not initialized
179MODULE_COMPILEFLAGS += -ftrivial-auto-var-init=zero
180
181# Rebuild every module if the toolchain changes
182MODULE_SRCDEPS += $(TOOLCHAIN_CONFIG)
183
184MODULE_IS_RUST := $(if $(filter %.rs,$(MODULE_SRCS)),true,false)
185
186# generate a per-module config.h file
187ifeq ($(MODULE_IS_RUST),false)
188MODULE_CONFIG := $(MODULE_BUILDDIR)/module_config.h
189
190$(MODULE_CONFIG): MODULE_DEFINES:=$(MODULE_DEFINES)
191$(MODULE_CONFIG): MODULE:=$(MODULE)
192$(MODULE_CONFIG): configheader
193	@$(call INFO_DONE,$(MODULE),generating config header, $@)
194	@$(call MAKECONFIGHEADER,$@,MODULE_DEFINES)
195
196GENERATED += $(MODULE_CONFIG)
197
198MODULE_COMPILEFLAGS += --include=$(MODULE_CONFIG)
199
200MODULE_SRCDEPS += $(MODULE_CONFIG)
201
202MODULE_INCLUDES := $(addprefix -I,$(MODULE_INCLUDES))
203endif
204
205# include the rules to compile the module's object files
206include make/compile.mk
207
208# MODULE_OBJS is passed back from compile.mk
209#$(info MODULE_OBJS = $(MODULE_OBJS))
210
211ifeq ($(MODULE_IS_RUST),true)
212
213# ensure that proc-macro libraries are considered host libraries. userspace does
214# this in library.mk, but we also compile proc-macro crates for the kernel here
215ifeq ($(MODULE_RUST_CRATE_TYPES),proc-macro)
216MODULE_RUST_HOST_LIB := true
217endif
218
219MODULE_IS_KERNEL :=
220# is module using old module system? (using module.mk directly)
221ifeq ($(TRUSTY_USERSPACE),)
222ifeq ($(call TOBOOL,$(MODULE_RUST_HOST_LIB)),false)
223MODULE_IS_KERNEL := true
224endif
225endif
226
227# is module being built as kernel code?
228ifeq ($(call TOBOOL,$(MODULE_IS_KERNEL)),true)
229
230# validate crate name
231ifeq ($(MODULE_CRATE_NAME),)
232$(error rust module $(MODULE) does not set MODULE_CRATE_NAME)
233endif
234
235# Generate Rust bindings with bindgen if requested
236ifneq ($(strip $(MODULE_BINDGEN_SRC_HEADER)),)
237include make/bindgen.mk
238endif
239
240# library and module deps are set mutually exclusively, so it's safe to simply
241# concatenate them to use whichever is set
242MODULE_ALL_DEPS := $(MODULE_LIBRARY_DEPS) $(MODULE_LIBRARY_EXPORTED_DEPS) $(MODULE_DEPS)
243
244ifeq ($(call TOBOOL,$(MODULE_ADD_IMPLICIT_DEPS)),true)
245
246# In userspace, MODULE_ADD_IMPLICIT_DEPS adds std.
247# In the kernel, it adds core, compiler_builtins and
248# lib/rust_support (except for external crates).
249MODULE_ALL_DEPS += \
250	trusty/user/base/lib/libcore-rust/ \
251	trusty/user/base/lib/libcompiler_builtins-rust/ \
252
253# rust_support depends on some external crates. We cannot
254# add it as an implicit dependency to any of them because
255# that would create a circular dependency.
256ifeq ($(filter external/rust/crates/%,$(MODULE)),)
257MODULE_ALL_DEPS += $(LKROOT)/lib/rust_support
258endif
259
260endif
261
262define READ_CRATE_INFO
263QUERY_MODULE := $1
264QUERY_VARIABLES := MODULE_CRATE_NAME MODULE_RUST_STEM MODULE_RUST_CRATE_TYPES
265$$(eval include make/query.mk)
266
267# assign queried variables for later use
268MODULE_$(1)_CRATE_NAME := $$(QUERY_MODULE_CRATE_NAME)
269MODULE_$(1)_CRATE_STEM := $$(if $$(QUERY_MODULE_RUST_STEM),$$(QUERY_MODULE_RUST_STEM),$$(QUERY_MODULE_CRATE_NAME))
270MODULE_$(1)_RUST_CRATE_TYPES := $$(if $$(QUERY_MODULE_RUST_CRATE_TYPES),$$(QUERY_MODULE_RUST_CRATE_TYPES),rlib)
271endef
272
273# ensure that MODULE_..._CRATE_NAME, _CRATE_STEM, and _RUST_CRATE_TYPES are populated
274$(foreach rust_dep,$(MODULE_ALL_DEPS),$(eval $(call READ_CRATE_INFO,$(rust_dep))))
275
276MODULE_RUST_DEPS := $(foreach dep, $(MODULE_ALL_DEPS), $(if $(MODULE_$(dep)_CRATE_NAME),$(dep),))
277
278# split deps into proc-macro and non- because the former are built for the host
279KERNEL_RUST_DEPS := $(foreach dep, $(MODULE_RUST_DEPS), $(if $(filter proc-macro,$(MODULE_$(dep)_RUST_CRATE_TYPES)),,$(dep)))
280
281HOST_RUST_DEPS := $(foreach dep, $(MODULE_RUST_DEPS), $(if $(filter proc-macro,$(MODULE_$(dep)_RUST_CRATE_TYPES)),$(dep),))
282
283# add kernel rust deps to the set of modules
284MODULES += $(KERNEL_RUST_DEPS)
285HOST_MODULES += $(HOST_RUST_DEPS)
286
287# determine crate names of dependency modules so we can depend on their rlibs.
288# because of ordering, we cannot simply e.g. set/read MODULE_$(dep)_CRATE_NAME,
289# so we must manually read the variable value from the Makefile
290DEP_CRATE_NAMES := $(foreach dep, $(KERNEL_RUST_DEPS), $(MODULE_$(dep)_CRATE_NAME))
291DEP_CRATE_STEMS := $(foreach dep, $(KERNEL_RUST_DEPS), $(MODULE_$(dep)_CRATE_STEM))
292
293# compute paths of host (proc-macro) dependencies
294HOST_DEP_CRATE_NAMES := $(foreach dep, $(HOST_RUST_DEPS), $(MODULE_$(dep)_CRATE_NAME))
295HOST_DEP_CRATE_STEMS := $(foreach dep, $(HOST_RUST_DEPS), $(MODULE_$(dep)_CRATE_STEM))
296MODULE_KERNEL_RUST_HOST_LIBS := $(foreach stem, $(HOST_DEP_CRATE_STEMS), $(TRUSTY_HOST_LIBRARY_BUILDDIR)/lib$(stem).so)
297gen_host_rlib_assignment = $(1)=$(TRUSTY_HOST_LIBRARY_BUILDDIR)/lib$(2).so
298MODULE_RLIBS += $(call pairmap,gen_host_rlib_assignment,$(HOST_DEP_CRATE_NAMES),$(HOST_DEP_CRATE_STEMS))
299
300# Stem defaults to the crate name
301ifeq ($(MODULE_RUST_STEM),)
302MODULE_RUST_STEM := $(MODULE_CRATE_NAME)
303endif
304
305# save dep crate names so we can topologically sort them for top-level rust build
306MODULE_$(MODULE_RUST_STEM)_CRATE_DEPS := $(DEP_CRATE_STEMS)
307ALL_KERNEL_HOST_CRATE_NAMES := $(ALL_KERNEL_HOST_CRATE_NAMES) $(HOST_DEP_CRATE_NAMES)
308ALL_KERNEL_HOST_CRATE_STEMS := $(ALL_KERNEL_HOST_CRATE_STEMS) $(HOST_DEP_CRATE_STEMS)
309
310# change BUILDDIR so RSOBJS for kernel are distinct targets from userspace ones
311OLD_BUILDDIR := $(BUILDDIR)
312BUILDDIR := $(TRUSTY_KERNEL_LIBRARY_BUILDDIR)
313
314# compute paths of dependencies
315MODULE_KERNEL_RUST_LIBS := $(foreach dep, $(DEP_CRATE_STEMS), $(call TOBUILDDIR,lib$(dep).rlib))
316gen_rlib_assignment = $(1)=$(call TOBUILDDIR,lib$(2).rlib)
317MODULE_RLIBS += $(call pairmap,gen_rlib_assignment,$(DEP_CRATE_NAMES),$(DEP_CRATE_STEMS))
318
319# include rust lib deps in lib deps
320MODULE_LIBRARIES += $(MODULE_KERNEL_RUST_LIBS) $(MODULE_KERNEL_RUST_HOST_LIBS)
321
322# determine MODULE_RSOBJS and MODULE_RUST_CRATE_TYPES for rust kernel modules
323include make/rust.mk
324
325# save extra information for constructing kernel rust-project.json in rust-toplevel.mk
326MODULE_$(MODULE_RUST_STEM)_RUST_SRC := $(filter %.rs,$(MODULE_SRCS))
327MODULE_$(MODULE_RUST_STEM)_RUST_EDITION := $(MODULE_RUST_EDITION)
328
329# only allow rlibs because we build rlibs, then link them all into one .a
330ifneq ($(MODULE_RUST_CRATE_TYPES),rlib)
331$(error rust crates for the kernel must be built as rlibs only, but $(MODULE) builds $(MODULE_RUST_CRATE_TYPES))
332endif
333
334# accumulate list of all crates we built (for linking, so skip proc-macro crates)
335ALLMODULE_CRATE_STEMS := $(MODULE_RUST_STEM) $(ALLMODULE_CRATE_STEMS)
336
337# reset BUILDDIR
338BUILDDIR := $(OLD_BUILDDIR)
339
340else # userspace rust
341
342MODULE_OBJECT := $(MODULE_RSOBJS)
343
344# make the rest of the build depend on our output
345ALLMODULE_OBJS := $(MODULE_INIT_OBJS) $(ALLMODULE_OBJS) $(MODULE_OBJECT) $(MODULE_EXTRA_ARCHIVES)
346
347endif # kernel/userspace rust
348
349# Build Rust sources
350$(addsuffix .d,$(MODULE_RSOBJS)):
351
352MODULE_RSSRC := $(filter %.rs,$(MODULE_SRCS))
353$(MODULE_RSOBJS): MODULE := $(MODULE)
354$(MODULE_RSOBJS): $(MODULE_RSSRC) $(MODULE_SRCDEPS) $(MODULE_EXTRA_OBJECTS) $(MODULE_LIBRARIES) $(addsuffix .d,$(MODULE_RSOBJS))
355	@$(MKDIR)
356	@$(call ECHO,$(MODULE),compiling rust module,$<)
357ifeq ($(call TOBOOL,$(MODULE_RUST_USE_CLIPPY)),true)
358	$(NOECHO) set -e ; \
359		TEMP_CLIPPY_DIR=$$(mktemp -d) ;\
360		mkdir -p $(dir $$TEMP_CLIPPY_DIR/$@) ;\
361		$(MODULE_RUST_ENV) $(CLIPPY_DRIVER) $(GLOBAL_RUSTFLAGS) $(ARCH_RUSTFLAGS) $(MODULE_RUSTFLAGS) $< -o $$TEMP_CLIPPY_DIR/$@ ;\
362		rm -rf $$TEMP_CLIPPY_DIR
363endif
364	$(NOECHO)$(MODULE_RUST_ENV) $(RUSTC) $(GLOBAL_RUSTFLAGS) $(ARCH_RUSTFLAGS) $(MODULE_RUSTFLAGS) $< --emit "dep-info=$@.d" -o $@
365	@$(call ECHO_DONE_SILENT,$(MODULE),compiling rust module,$<)
366
367ifneq ($(call TOBOOL,$(MODULE_SKIP_DOCS)),true)
368
369# Pass rustdoc the same flags as rustc such that the generated documentation
370# matches the code that gets compiled and run. Note: $(GLOBAL_RUSTFLAGS) adds
371# $(TRUSTY_HOST_LIBRARY_BUILDDIR) to the library search path. This is necessary
372# to pick up dependencies that are proc macros and thus built in the host dir.
373$(MODULE_RUSTDOC_OBJECT): $(MODULE_RSSRC) | $(MODULE_RSOBJS)
374	@$(MKDIR)
375	@$(call ECHO,rustdoc,generating documentation,for $(MODULE_CRATE_NAME))
376	$(NOECHO)$(MODULE_RUST_ENV) $(RUSTDOC) $(GLOBAL_RUSTFLAGS) $(ARCH_RUSTFLAGS) $(MODULE_RUSTDOCFLAGS) -L $(TRUSTY_LIBRARY_BUILDDIR) --out-dir $(MODULE_RUSTDOC_OUT_DIR) $<
377	@touch $@
378	@$(call ECHO_DONE_SILENT,rustdoc,generating documentation,for $(MODULE_CRATE_NAME))
379
380EXTRA_BUILDDEPS += $(MODULE_RUSTDOC_OBJECT)
381
382endif
383
384-include $(addsuffix .d,$(MODULE_RSOBJS))
385
386# track the module rlib for make clean
387GENERATED += $(MODULE_RSOBJS)
388
389
390else # not rust
391# Archive the module's object files into a static library.
392MODULE_OBJECT := $(call TOBUILDDIR,$(MODULE_SRCDIR).mod.a)
393$(MODULE_OBJECT): MODULE := $(MODULE)
394$(MODULE_OBJECT): $(MODULE_OBJS) $(MODULE_EXTRA_OBJS)
395	@$(MKDIR)
396	@$(call ECHO,$(MODULE),creating,$@)
397	$(NOECHO)rm -f $@
398	$(NOECHO)$(AR) rcs $@ $^
399	@$(call ECHO_DONE_SILENT,$(MODULE),creating,$@)
400
401# track the module object for make clean
402GENERATED += $(MODULE_OBJECT)
403
404# make the rest of the build depend on our output
405ALLMODULE_OBJS := $(MODULE_INIT_OBJS) $(ALLMODULE_OBJS) $(MODULE_OBJECT) $(MODULE_EXTRA_ARCHIVES)
406
407endif # rust or not
408
409# track all of the source files compiled
410ALLSRCS += $(MODULE_SRCS_FIRST) $(MODULE_SRCS)
411
412# track all the objects built
413ALLOBJS += $(MODULE_INIT_OBJS) $(MODULE_OBJS)
414
415# empty out any vars set here
416MODULE :=
417MODULE_SRCDIR :=
418MODULE_BUILDDIR :=
419MODULE_DEPS :=
420MODULE_SRCS :=
421MODULE_OBJS :=
422MODULE_DEFINES :=
423MODULE_OPTFLAGS :=
424MODULE_COMPILEFLAGS :=
425MODULE_CFLAGS :=
426MODULE_CPPFLAGS :=
427MODULE_ASMFLAGS :=
428MODULE_RUSTFLAGS :=
429MODULE_RUSTDOCFLAGS :=
430MODULE_SRCDEPS :=
431MODULE_INCLUDES :=
432MODULE_EXTRA_ARCHIVES :=
433MODULE_EXTRA_OBJS :=
434MODULE_CONFIG :=
435MODULE_OBJECT :=
436MODULE_ARM_OVERRIDE_SRCS :=
437MODULE_SRCS_FIRST :=
438MODULE_INIT_OBJS :=
439MODULE_DISABLE_LTO :=
440MODULE_LTO_ENABLED :=
441MODULE_DISABLE_CFI :=
442MODULE_DISABLE_STACK_PROTECTOR :=
443MODULE_DISABLE_SCS :=
444MODULE_RSSRC :=
445MODULE_IS_RUST :=
446MODULE_RUST_USE_CLIPPY :=
447MODULE_RSOBJS :=
448MODULE_RUST_EDITION :=
449MODULE_RUSTDOC_OBJECT :=
450MODULE_RUSTDOCFLAGS :=
451MODULE_ALL_DEPS :=
452MODULE_RUST_DEPS :=
453MODULE_RUST_STEM :=
454MODULE_SKIP_DOCS :=
455MODULE_ADD_IMPLICIT_DEPS := true
456
457endif # QUERY_MODULE (this line should stay after all other processing)
458