blob: c92182420dd4c97ab8013893ff8e201c8256b3e1 [file] [log] [blame]
Ivan Lozanoffee3342019-08-27 12:03:00 -07001// Copyright 2019 The Android Open Source Project
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package rust
16
17import (
18 "fmt"
19 "path/filepath"
20
Ivan Lozanoad8b18b2019-10-31 19:38:29 -070021 "github.com/google/blueprint/proptools"
22
Ivan Lozanoffee3342019-08-27 12:03:00 -070023 "android/soong/android"
24 "android/soong/rust/config"
25)
26
Ivan Lozanodd055472020-09-28 13:22:45 -040027type RustLinkage int
28
29const (
30 DefaultLinkage RustLinkage = iota
31 RlibLinkage
32 DylibLinkage
33)
34
Thiébaud Weksteene81c9242020-08-03 10:46:28 +020035func (compiler *baseCompiler) edition() string {
Chih-Hung Hsieh961a30c2019-10-03 09:47:06 -070036 return proptools.StringDefault(compiler.Properties.Edition, config.DefaultEdition)
37}
38
Matthew Maurer99020b02019-10-31 10:44:40 -070039func (compiler *baseCompiler) setNoStdlibs() {
40 compiler.Properties.No_stdlibs = proptools.BoolPtr(true)
41}
42
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +020043func (compiler *baseCompiler) disableLints() {
44 compiler.Properties.Lints = proptools.StringPtr("none")
Stephen Craneda931d42020-08-04 13:02:28 -070045}
46
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -080047func NewBaseCompiler(dir, dir64 string, location installLocation) *baseCompiler {
Ivan Lozanoffee3342019-08-27 12:03:00 -070048 return &baseCompiler{
Chih-Hung Hsieh961a30c2019-10-03 09:47:06 -070049 Properties: BaseCompilerProperties{},
50 dir: dir,
51 dir64: dir64,
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -080052 location: location,
Ivan Lozanoffee3342019-08-27 12:03:00 -070053 }
54}
55
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -080056type installLocation int
57
58const (
59 InstallInSystem installLocation = 0
60 InstallInData = iota
Ivan Lozano43845682020-07-09 21:03:28 -040061
62 incorrectSourcesError = "srcs can only contain one path for a rust file and source providers prefixed by \":\""
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -080063)
64
Ivan Lozanoffee3342019-08-27 12:03:00 -070065type BaseCompilerProperties struct {
Ivan Lozano8a23fa42020-06-16 10:26:57 -040066 // path to the source file that is the main entry point of the program (e.g. main.rs or lib.rs)
67 Srcs []string `android:"path,arch_variant"`
68
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +020069 // name of the lint set that should be used to validate this module.
70 //
71 // Possible values are "default" (for using a sensible set of lints
72 // depending on the module's location), "android" (for the strictest
73 // lint set that applies to all Android platform code), "vendor" (for
74 // a relaxed set) and "none" (for ignoring all lint warnings and
75 // errors). The default value is "default".
76 Lints *string
Chih-Hung Hsiehefdd7ac2019-09-26 18:59:27 -070077
Ivan Lozanoffee3342019-08-27 12:03:00 -070078 // flags to pass to rustc
79 Flags []string `android:"path,arch_variant"`
80
81 // flags to pass to the linker
82 Ld_flags []string `android:"path,arch_variant"`
83
84 // list of rust rlib crate dependencies
85 Rlibs []string `android:"arch_variant"`
86
87 // list of rust dylib crate dependencies
88 Dylibs []string `android:"arch_variant"`
89
Matthew Maurer0f003b12020-06-29 14:34:06 -070090 // list of rust automatic crate dependencies
91 Rustlibs []string `android:"arch_variant"`
92
Ivan Lozanoffee3342019-08-27 12:03:00 -070093 // list of rust proc_macro crate dependencies
94 Proc_macros []string `android:"arch_variant"`
95
96 // list of C shared library dependencies
97 Shared_libs []string `android:"arch_variant"`
98
99 // list of C static library dependencies
100 Static_libs []string `android:"arch_variant"`
101
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400102 // crate name, required for modules which produce Rust libraries: rust_library, rust_ffi and SourceProvider
103 // modules which create library variants (rust_bindgen). This must be the expected extern crate name used in
104 // source, and is required to conform to an enforced format matching library output files (if the output file is
105 // lib<someName><suffix>, the crate_name property must be <someName>).
Ivan Lozanoffee3342019-08-27 12:03:00 -0700106 Crate_name string `android:"arch_variant"`
107
108 // list of features to enable for this crate
109 Features []string `android:"arch_variant"`
110
111 // specific rust edition that should be used if the default version is not desired
112 Edition *string `android:"arch_variant"`
113
114 // sets name of the output
115 Stem *string `android:"arch_variant"`
116
117 // append to name of output
118 Suffix *string `android:"arch_variant"`
119
120 // install to a subdirectory of the default install path for the module
121 Relative_install_path *string `android:"arch_variant"`
Matthew Maurer99020b02019-10-31 10:44:40 -0700122
123 // whether to suppress inclusion of standard crates - defaults to false
124 No_stdlibs *bool
Ivan Lozanoea086132020-12-08 14:43:00 -0500125
126 // Change the rustlibs linkage to select rlib linkage by default for device targets.
127 // Also link libstd as an rlib as well on device targets.
128 // Note: This is the default behavior for host targets.
129 //
130 // This is primarily meant for rust_binary and rust_ffi modules where the default
131 // linkage of libstd might need to be overridden in some use cases. This should
132 // generally be avoided with other module types since it may cause collisions at
133 // linkage if all dependencies of the root binary module do not link against libstd\
134 // the same way.
135 Prefer_rlib *bool `android:"arch_variant"`
Ivan Lozanoffee3342019-08-27 12:03:00 -0700136}
137
138type baseCompiler struct {
Joel Galensonfa049382021-01-14 16:03:18 -0800139 Properties BaseCompilerProperties
Ivan Lozanoffee3342019-08-27 12:03:00 -0700140
141 // Install related
142 dir string
143 dir64 string
144 subDir string
145 relative string
Colin Cross70dda7e2019-10-01 22:05:35 -0700146 path android.InstallPath
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800147 location installLocation
Ivan Lozano6cd99e62020-02-11 08:24:25 -0500148 sanitize *sanitize
Ivan Lozano8a23fa42020-06-16 10:26:57 -0400149
Joel Galensonfa049382021-01-14 16:03:18 -0800150 distFile android.OptionalPath
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200151 // Stripped output file. If Valid(), this file will be installed instead of outputFile.
152 strippedOutputFile android.OptionalPath
Ivan Lozanoffee3342019-08-27 12:03:00 -0700153}
154
Ivan Lozano26ecd6c2020-07-31 13:40:31 -0400155func (compiler *baseCompiler) Disabled() bool {
156 return false
157}
158
159func (compiler *baseCompiler) SetDisabled() {
160 panic("baseCompiler does not implement SetDisabled()")
161}
162
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400163func (compiler *baseCompiler) coverageOutputZipPath() android.OptionalPath {
164 panic("baseCompiler does not implement coverageOutputZipPath()")
165}
166
Ivan Lozanoea086132020-12-08 14:43:00 -0500167func (compiler *baseCompiler) preferRlib() bool {
168 return Bool(compiler.Properties.Prefer_rlib)
169}
170
Ivan Lozanodd055472020-09-28 13:22:45 -0400171func (compiler *baseCompiler) stdLinkage(ctx *depsContext) RustLinkage {
Ivan Lozano2b081132020-09-08 12:46:52 -0400172 // For devices, we always link stdlibs in as dylibs by default.
Ivan Lozanoea086132020-12-08 14:43:00 -0500173 if compiler.preferRlib() {
174 return RlibLinkage
175 } else if ctx.Device() {
Ivan Lozanodd055472020-09-28 13:22:45 -0400176 return DylibLinkage
Ivan Lozano2b081132020-09-08 12:46:52 -0400177 } else {
Ivan Lozanodd055472020-09-28 13:22:45 -0400178 return RlibLinkage
Ivan Lozano2b081132020-09-08 12:46:52 -0400179 }
Ivan Lozano042504f2020-08-18 14:31:23 -0400180}
181
Ivan Lozanoffee3342019-08-27 12:03:00 -0700182var _ compiler = (*baseCompiler)(nil)
183
Chih-Hung Hsieh9a4a7ba2019-12-12 19:36:05 -0800184func (compiler *baseCompiler) inData() bool {
185 return compiler.location == InstallInData
186}
187
Ivan Lozanoffee3342019-08-27 12:03:00 -0700188func (compiler *baseCompiler) compilerProps() []interface{} {
189 return []interface{}{&compiler.Properties}
190}
191
192func (compiler *baseCompiler) featuresToFlags(features []string) []string {
193 flags := []string{}
194 for _, feature := range features {
195 flags = append(flags, "--cfg 'feature=\""+feature+"\"'")
196 }
197 return flags
198}
199
200func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags) Flags {
201
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +0200202 lintFlags, err := config.RustcLintsForDir(ctx.ModuleDir(), compiler.Properties.Lints)
203 if err != nil {
204 ctx.PropertyErrorf("lints", err.Error())
Chih-Hung Hsiehefdd7ac2019-09-26 18:59:27 -0700205 }
Thiébaud Weksteen9e8451e2020-08-13 12:55:59 +0200206 flags.RustFlags = append(flags.RustFlags, lintFlags)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700207 flags.RustFlags = append(flags.RustFlags, compiler.Properties.Flags...)
208 flags.RustFlags = append(flags.RustFlags, compiler.featuresToFlags(compiler.Properties.Features)...)
Thiébaud Weksteene81c9242020-08-03 10:46:28 +0200209 flags.RustFlags = append(flags.RustFlags, "--edition="+compiler.edition())
Ivan Lozanoffee3342019-08-27 12:03:00 -0700210 flags.LinkFlags = append(flags.LinkFlags, compiler.Properties.Ld_flags...)
Joel Galenson724286c2019-09-30 13:01:37 -0700211 flags.GlobalRustFlags = append(flags.GlobalRustFlags, config.GlobalRustFlags...)
Ivan Lozanof1c84332019-09-20 11:00:37 -0700212 flags.GlobalRustFlags = append(flags.GlobalRustFlags, ctx.toolchain().ToolchainRustFlags())
213 flags.GlobalLinkFlags = append(flags.GlobalLinkFlags, ctx.toolchain().ToolchainLinkFlags())
Ivan Lozanoffee3342019-08-27 12:03:00 -0700214
215 if ctx.Host() && !ctx.Windows() {
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800216 rpathPrefix := `\$$ORIGIN/`
Ivan Lozanoffee3342019-08-27 12:03:00 -0700217 if ctx.Darwin() {
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800218 rpathPrefix = "@loader_path/"
Ivan Lozanoffee3342019-08-27 12:03:00 -0700219 }
220
221 var rpath string
222 if ctx.toolchain().Is64Bit() {
223 rpath = "lib64"
224 } else {
225 rpath = "lib"
226 }
Jaewoong Jung18aefc12020-12-21 09:11:10 -0800227 flags.LinkFlags = append(flags.LinkFlags, "-Wl,-rpath,"+rpathPrefix+rpath)
228 flags.LinkFlags = append(flags.LinkFlags, "-Wl,-rpath,"+rpathPrefix+"../"+rpath)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700229 }
230
231 return flags
232}
233
234func (compiler *baseCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Path {
235 panic(fmt.Errorf("baseCrater doesn't know how to crate things!"))
236}
237
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500238func (compiler *baseCompiler) isDependencyRoot() bool {
239 return false
240}
241
Ivan Lozanoffee3342019-08-27 12:03:00 -0700242func (compiler *baseCompiler) compilerDeps(ctx DepsContext, deps Deps) Deps {
243 deps.Rlibs = append(deps.Rlibs, compiler.Properties.Rlibs...)
244 deps.Dylibs = append(deps.Dylibs, compiler.Properties.Dylibs...)
Matthew Maurer0f003b12020-06-29 14:34:06 -0700245 deps.Rustlibs = append(deps.Rustlibs, compiler.Properties.Rustlibs...)
Ivan Lozanoffee3342019-08-27 12:03:00 -0700246 deps.ProcMacros = append(deps.ProcMacros, compiler.Properties.Proc_macros...)
247 deps.StaticLibs = append(deps.StaticLibs, compiler.Properties.Static_libs...)
248 deps.SharedLibs = append(deps.SharedLibs, compiler.Properties.Shared_libs...)
249
Matthew Maurer99020b02019-10-31 10:44:40 -0700250 if !Bool(compiler.Properties.No_stdlibs) {
251 for _, stdlib := range config.Stdlibs {
Jiyong Parkb5d2dd22020-08-31 17:22:01 +0900252 // If we're building for the primary arch of the build host, use the compiler's stdlibs
253 if ctx.Target().Os == android.BuildOs && ctx.TargetPrimary() {
Matthew Maurer99020b02019-10-31 10:44:40 -0700254 stdlib = stdlib + "_" + ctx.toolchain().RustTriple()
255 }
256
Ivan Lozano2b081132020-09-08 12:46:52 -0400257 deps.Stdlibs = append(deps.Stdlibs, stdlib)
Matthew Maurer99020b02019-10-31 10:44:40 -0700258 }
259 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700260 return deps
261}
262
Ivan Lozanobf63d002020-10-02 10:03:23 -0400263func bionicDeps(deps Deps, static bool) Deps {
264 bionicLibs := []string{}
265 bionicLibs = append(bionicLibs, "liblog")
266 bionicLibs = append(bionicLibs, "libc")
267 bionicLibs = append(bionicLibs, "libm")
268 bionicLibs = append(bionicLibs, "libdl")
269
270 if static {
271 deps.StaticLibs = append(deps.StaticLibs, bionicLibs...)
272 } else {
273 deps.SharedLibs = append(deps.SharedLibs, bionicLibs...)
274 }
Ivan Lozanof1c84332019-09-20 11:00:37 -0700275
276 //TODO(b/141331117) libstd requires libgcc on Android
277 deps.StaticLibs = append(deps.StaticLibs, "libgcc")
278
279 return deps
280}
281
Ivan Lozanoffee3342019-08-27 12:03:00 -0700282func (compiler *baseCompiler) crateName() string {
283 return compiler.Properties.Crate_name
284}
285
Colin Cross70dda7e2019-10-01 22:05:35 -0700286func (compiler *baseCompiler) installDir(ctx ModuleContext) android.InstallPath {
Ivan Lozanoffee3342019-08-27 12:03:00 -0700287 dir := compiler.dir
288 if ctx.toolchain().Is64Bit() && compiler.dir64 != "" {
289 dir = compiler.dir64
290 }
Ivan Lozanod6fdca82020-04-07 12:30:33 -0400291 if ctx.Target().NativeBridge == android.NativeBridgeEnabled {
292 dir = filepath.Join(dir, ctx.Target().NativeBridgeRelativePath)
293 }
294 if !ctx.Host() && ctx.Config().HasMultilibConflict(ctx.Arch().ArchType) {
Ivan Lozanoffee3342019-08-27 12:03:00 -0700295 dir = filepath.Join(dir, ctx.Arch().ArchType.String())
296 }
297 return android.PathForModuleInstall(ctx, dir, compiler.subDir,
298 compiler.relativeInstallPath(), compiler.relative)
299}
300
Ivan Lozanoa0cd8f92020-04-09 09:56:02 -0400301func (compiler *baseCompiler) nativeCoverage() bool {
302 return false
303}
304
Thiébaud Weksteenfabaff62020-08-27 13:48:36 +0200305func (compiler *baseCompiler) install(ctx ModuleContext) {
306 path := ctx.RustModule().outputFile
307 if compiler.strippedOutputFile.Valid() {
308 path = compiler.strippedOutputFile
309 }
310 compiler.path = ctx.InstallFile(compiler.installDir(ctx), path.Path().Base(), path.Path())
Ivan Lozanoffee3342019-08-27 12:03:00 -0700311}
312
313func (compiler *baseCompiler) getStem(ctx ModuleContext) string {
314 return compiler.getStemWithoutSuffix(ctx) + String(compiler.Properties.Suffix)
315}
316
317func (compiler *baseCompiler) getStemWithoutSuffix(ctx BaseModuleContext) string {
Thiébaud Weksteen1f7f70f2020-06-24 11:32:48 +0200318 stem := ctx.ModuleName()
Ivan Lozanoffee3342019-08-27 12:03:00 -0700319 if String(compiler.Properties.Stem) != "" {
320 stem = String(compiler.Properties.Stem)
321 }
322
323 return stem
324}
Ivan Lozanoad8b18b2019-10-31 19:38:29 -0700325
Ivan Lozanoffee3342019-08-27 12:03:00 -0700326func (compiler *baseCompiler) relativeInstallPath() string {
327 return String(compiler.Properties.Relative_install_path)
328}
329
Ivan Lozano43845682020-07-09 21:03:28 -0400330// Returns the Path for the main source file along with Paths for generated source files from modules listed in srcs.
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700331func srcPathFromModuleSrcs(ctx ModuleContext, srcs []string) (android.Path, android.Paths) {
332 // The srcs can contain strings with prefix ":".
333 // They are dependent modules of this module, with android.SourceDepTag.
334 // They are not the main source file compiled by rustc.
335 numSrcs := 0
336 srcIndex := 0
337 for i, s := range srcs {
338 if android.SrcIsModule(s) == "" {
339 numSrcs++
340 srcIndex = i
341 }
Ivan Lozanoffee3342019-08-27 12:03:00 -0700342 }
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700343 if numSrcs != 1 {
Ivan Lozano43845682020-07-09 21:03:28 -0400344 ctx.PropertyErrorf("srcs", incorrectSourcesError)
Chih-Hung Hsiehbbd25ae2020-05-15 17:36:30 -0700345 }
346 if srcIndex != 0 {
347 ctx.PropertyErrorf("srcs", "main source file must be the first in srcs")
348 }
349 paths := android.PathsForModuleSrc(ctx, srcs)
Ivan Lozano43845682020-07-09 21:03:28 -0400350 return paths[srcIndex], paths[1:]
Ivan Lozanoffee3342019-08-27 12:03:00 -0700351}