1// 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 "path/filepath" 19 "strings" 20 21 "github.com/google/blueprint" 22 23 "android/soong/android" 24 "android/soong/rust/config" 25) 26 27var ( 28 _ = pctx.SourcePathVariable("rustcCmd", "${config.RustBin}/rustc") 29 _ = pctx.SourcePathVariable("mkcraterspCmd", "build/soong/scripts/mkcratersp.py") 30 rustc = pctx.AndroidStaticRule("rustc", 31 blueprint.RuleParams{ 32 Command: "$envVars $rustcCmd " + 33 "-C linker=$mkcraterspCmd " + 34 "--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" + 35 " && grep \"^$out:\" $out.d.raw > $out.d", 36 CommandDeps: []string{"$rustcCmd", "$mkcraterspCmd"}, 37 // Rustc deps-info writes out make compatible dep files: https://github.com/rust-lang/rust/issues/7633 38 // Rustc emits unneeded dependency lines for the .d and input .rs files. 39 // Those extra lines cause ninja warning: 40 // "warning: depfile has multiple output paths" 41 // For ninja, we keep/grep only the dependency rule for the rust $out file. 42 Deps: blueprint.DepsGCC, 43 Depfile: "$out.d", 44 }, 45 "rustcFlags", "libFlags", "envVars") 46 rustLink = pctx.AndroidStaticRule("rustLink", 47 blueprint.RuleParams{ 48 Command: "${config.RustLinker} -o $out ${crtBegin} ${config.RustLinkerArgs} @$in ${linkFlags} ${crtEnd}", 49 }, 50 "linkFlags", "crtBegin", "crtEnd") 51 52 _ = pctx.SourcePathVariable("rustdocCmd", "${config.RustBin}/rustdoc") 53 rustdoc = pctx.AndroidStaticRule("rustdoc", 54 blueprint.RuleParams{ 55 Command: "$envVars $rustdocCmd $rustdocFlags $in -o $outDir && " + 56 "touch $out", 57 CommandDeps: []string{"$rustdocCmd"}, 58 }, 59 "rustdocFlags", "outDir", "envVars") 60 61 _ = pctx.SourcePathVariable("clippyCmd", "${config.RustBin}/clippy-driver") 62 clippyDriver = pctx.AndroidStaticRule("clippy", 63 blueprint.RuleParams{ 64 Command: "$envVars $clippyCmd " + 65 // Because clippy-driver uses rustc as backend, we need to have some output even during the linting. 66 // Use the metadata output as it has the smallest footprint. 67 "--emit metadata -o $out --emit dep-info=$out.d.raw $in ${libFlags} " + 68 "$rustcFlags $clippyFlags" + 69 " && grep \"^$out:\" $out.d.raw > $out.d", 70 CommandDeps: []string{"$clippyCmd"}, 71 Deps: blueprint.DepsGCC, 72 Depfile: "$out.d", 73 }, 74 "rustcFlags", "libFlags", "clippyFlags", "envVars") 75 76 zip = pctx.AndroidStaticRule("zip", 77 blueprint.RuleParams{ 78 Command: "cat $out.rsp | tr ' ' '\\n' | tr -d \\' | sort -u > ${out}.tmp && ${SoongZipCmd} -o ${out} -C $$OUT_DIR -l ${out}.tmp", 79 CommandDeps: []string{"${SoongZipCmd}"}, 80 Rspfile: "$out.rsp", 81 RspfileContent: "$in", 82 }) 83 84 cp = pctx.AndroidStaticRule("cp", 85 blueprint.RuleParams{ 86 Command: "cp `cat $outDir.rsp` $outDir", 87 Rspfile: "${outDir}.rsp", 88 RspfileContent: "$in", 89 }, 90 "outDir") 91 92 // Cross-referencing: 93 _ = pctx.SourcePathVariable("rustExtractor", 94 "prebuilts/build-tools/${config.HostPrebuiltTag}/bin/rust_extractor") 95 _ = pctx.VariableFunc("kytheCorpus", 96 func(ctx android.PackageVarContext) string { return ctx.Config().XrefCorpusName() }) 97 _ = pctx.VariableFunc("kytheCuEncoding", 98 func(ctx android.PackageVarContext) string { return ctx.Config().XrefCuEncoding() }) 99 _ = pctx.SourcePathVariable("kytheVnames", "build/soong/vnames.json") 100 kytheExtract = pctx.AndroidStaticRule("kythe", 101 blueprint.RuleParams{ 102 Command: `KYTHE_CORPUS=${kytheCorpus} ` + 103 `KYTHE_OUTPUT_FILE=$out ` + 104 `KYTHE_VNAMES=$kytheVnames ` + 105 `KYTHE_KZIP_ENCODING=${kytheCuEncoding} ` + 106 `KYTHE_CANONICALIZE_VNAME_PATHS=prefer-relative ` + 107 `$rustExtractor $envVars ` + 108 `$rustcCmd ` + 109 `-C linker=true ` + 110 `$in ${libFlags} $rustcFlags`, 111 CommandDeps: []string{"$rustExtractor", "$kytheVnames"}, 112 Rspfile: "${out}.rsp", 113 RspfileContent: "$in", 114 }, 115 "rustcFlags", "libFlags", "envVars") 116) 117 118type buildOutput struct { 119 outputFile android.Path 120 kytheFile android.Path 121} 122 123func init() { 124 pctx.HostBinToolVariable("SoongZipCmd", "soong_zip") 125} 126 127func TransformSrcToBinary(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags, 128 outputFile android.WritablePath) buildOutput { 129 flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin") 130 131 return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "bin") 132} 133 134func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags, 135 outputFile android.WritablePath) buildOutput { 136 return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib") 137} 138 139func TransformSrctoDylib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags, 140 outputFile android.WritablePath) buildOutput { 141 flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin") 142 143 return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "dylib") 144} 145 146func TransformSrctoStatic(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags, 147 outputFile android.WritablePath) buildOutput { 148 flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin") 149 return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "staticlib") 150} 151 152func TransformSrctoShared(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags, 153 outputFile android.WritablePath) buildOutput { 154 flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto=thin") 155 return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "cdylib") 156} 157 158func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps, 159 flags Flags, outputFile android.WritablePath) buildOutput { 160 return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro") 161} 162 163func rustLibsToPaths(libs RustLibraries) android.Paths { 164 var paths android.Paths 165 for _, lib := range libs { 166 paths = append(paths, lib.Path) 167 } 168 return paths 169} 170 171func makeLibFlags(deps PathDeps) []string { 172 var libFlags []string 173 174 // Collect library/crate flags 175 for _, lib := range deps.RLibs { 176 libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String()) 177 } 178 for _, lib := range deps.DyLibs { 179 libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String()) 180 } 181 for _, proc_macro := range deps.ProcMacros { 182 libFlags = append(libFlags, "--extern "+proc_macro.CrateName+"="+proc_macro.Path.String()) 183 } 184 185 for _, path := range deps.linkDirs { 186 libFlags = append(libFlags, "-L "+path) 187 } 188 189 return libFlags 190} 191 192func rustEnvVars(ctx ModuleContext, deps PathDeps) []string { 193 var envVars []string 194 195 // libstd requires a specific environment variable to be set. This is 196 // not officially documented and may be removed in the future. See 197 // https://github.com/rust-lang/rust/blob/master/library/std/src/env.rs#L866. 198 if ctx.RustModule().CrateName() == "std" { 199 envVars = append(envVars, "STD_ENV_ARCH="+config.StdEnvArch[ctx.RustModule().Arch().ArchType]) 200 } 201 202 if len(deps.SrcDeps) > 0 { 203 moduleGenDir := ctx.RustModule().compiler.CargoOutDir() 204 // We must calculate an absolute path for OUT_DIR since Rust's include! macro (which normally consumes this) 205 // assumes that paths are relative to the source file. 206 var outDirPrefix string 207 if !filepath.IsAbs(moduleGenDir.String()) { 208 // If OUT_DIR is not absolute, we use $$PWD to generate an absolute path (os.Getwd() returns '/') 209 outDirPrefix = "$$PWD/" 210 } else { 211 // If OUT_DIR is absolute, then moduleGenDir will be an absolute path, so we don't need to set this to anything. 212 outDirPrefix = "" 213 } 214 envVars = append(envVars, "OUT_DIR="+filepath.Join(outDirPrefix, moduleGenDir.String())) 215 } else { 216 // TODO(pcc): Change this to "OUT_DIR=" after fixing crates to not rely on this value. 217 envVars = append(envVars, "OUT_DIR=out") 218 } 219 220 return envVars 221} 222 223func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags, 224 outputFile android.WritablePath, crateType string) buildOutput { 225 226 var inputs android.Paths 227 var implicits, linkImplicits, linkOrderOnly android.Paths 228 var output buildOutput 229 var rustcFlags, linkFlags []string 230 231 output.outputFile = outputFile 232 crateName := ctx.RustModule().CrateName() 233 targetTriple := ctx.toolchain().RustTriple() 234 235 envVars := rustEnvVars(ctx, deps) 236 237 inputs = append(inputs, main) 238 239 // Collect rustc flags 240 rustcFlags = append(rustcFlags, flags.GlobalRustFlags...) 241 rustcFlags = append(rustcFlags, flags.RustFlags...) 242 rustcFlags = append(rustcFlags, "--crate-type="+crateType) 243 if crateName != "" { 244 rustcFlags = append(rustcFlags, "--crate-name="+crateName) 245 } 246 if targetTriple != "" { 247 rustcFlags = append(rustcFlags, "--target="+targetTriple) 248 linkFlags = append(linkFlags, "-target "+targetTriple) 249 } 250 251 // Suppress an implicit sysroot 252 rustcFlags = append(rustcFlags, "--sysroot=/dev/null") 253 254 // Enable incremental compilation if requested by user 255 if ctx.Config().IsEnvTrue("SOONG_RUSTC_INCREMENTAL") { 256 incrementalPath := android.PathForOutput(ctx, "rustc").String() 257 258 rustcFlags = append(rustcFlags, "-Cincremental="+incrementalPath) 259 } 260 261 // Disallow experimental features 262 modulePath := android.PathForModuleSrc(ctx).String() 263 if !(android.IsThirdPartyPath(modulePath) || strings.HasPrefix(modulePath, "prebuilts")) { 264 rustcFlags = append(rustcFlags, "-Zallow-features=\"custom_inner_attributes,mixed_integer_ops\"") 265 } 266 267 // Collect linker flags 268 linkFlags = append(linkFlags, flags.GlobalLinkFlags...) 269 linkFlags = append(linkFlags, flags.LinkFlags...) 270 271 // Check if this module needs to use the bootstrap linker 272 if ctx.RustModule().Bootstrap() && !ctx.RustModule().InRecovery() && !ctx.RustModule().InRamdisk() && !ctx.RustModule().InVendorRamdisk() { 273 dynamicLinker := "-Wl,-dynamic-linker,/system/bin/bootstrap/linker" 274 if ctx.toolchain().Is64Bit() { 275 dynamicLinker += "64" 276 } 277 linkFlags = append(linkFlags, dynamicLinker) 278 } 279 280 libFlags := makeLibFlags(deps) 281 282 // Collect dependencies 283 implicits = append(implicits, rustLibsToPaths(deps.RLibs)...) 284 implicits = append(implicits, rustLibsToPaths(deps.DyLibs)...) 285 implicits = append(implicits, rustLibsToPaths(deps.ProcMacros)...) 286 implicits = append(implicits, deps.AfdoProfiles...) 287 implicits = append(implicits, deps.srcProviderFiles...) 288 implicits = append(implicits, deps.WholeStaticLibs...) 289 290 linkImplicits = append(linkImplicits, deps.LibDeps...) 291 linkImplicits = append(linkImplicits, deps.CrtBegin...) 292 linkImplicits = append(linkImplicits, deps.CrtEnd...) 293 294 linkOrderOnly = append(linkOrderOnly, deps.linkObjects...) 295 296 if len(deps.SrcDeps) > 0 { 297 moduleGenDir := ctx.RustModule().compiler.CargoOutDir() 298 var outputs android.WritablePaths 299 300 for _, genSrc := range deps.SrcDeps { 301 if android.SuffixInList(outputs.Strings(), genSubDir+genSrc.Base()) { 302 ctx.PropertyErrorf("srcs", 303 "multiple source providers generate the same filename output: "+genSrc.Base()) 304 } 305 outputs = append(outputs, android.PathForModuleOut(ctx, genSubDir+genSrc.Base())) 306 } 307 308 ctx.Build(pctx, android.BuildParams{ 309 Rule: cp, 310 Description: "cp " + moduleGenDir.Path().Rel(), 311 Outputs: outputs, 312 Inputs: deps.SrcDeps, 313 Args: map[string]string{ 314 "outDir": moduleGenDir.String(), 315 }, 316 }) 317 implicits = append(implicits, outputs.Paths()...) 318 } 319 320 envVars = append(envVars, "ANDROID_RUST_VERSION="+config.GetRustVersion(ctx)) 321 322 if ctx.RustModule().compiler.CargoEnvCompat() { 323 if _, ok := ctx.RustModule().compiler.(*binaryDecorator); ok { 324 envVars = append(envVars, "CARGO_BIN_NAME="+strings.TrimSuffix(outputFile.Base(), outputFile.Ext())) 325 } 326 envVars = append(envVars, "CARGO_CRATE_NAME="+ctx.RustModule().CrateName()) 327 pkgVersion := ctx.RustModule().compiler.CargoPkgVersion() 328 if pkgVersion != "" { 329 envVars = append(envVars, "CARGO_PKG_VERSION="+pkgVersion) 330 } 331 } 332 333 envVars = append(envVars, "AR=${cc_config.ClangBin}/llvm-ar") 334 335 if flags.Clippy { 336 clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy") 337 ctx.Build(pctx, android.BuildParams{ 338 Rule: clippyDriver, 339 Description: "clippy " + main.Rel(), 340 Output: clippyFile, 341 Inputs: inputs, 342 Implicits: implicits, 343 Args: map[string]string{ 344 "rustcFlags": strings.Join(rustcFlags, " "), 345 "libFlags": strings.Join(libFlags, " "), 346 "clippyFlags": strings.Join(flags.ClippyFlags, " "), 347 "envVars": strings.Join(envVars, " "), 348 }, 349 }) 350 // Declare the clippy build as an implicit dependency of the original crate. 351 implicits = append(implicits, clippyFile) 352 } 353 354 rustcOutputFile := outputFile 355 usesLinker := crateType == "bin" || crateType == "dylib" || crateType == "cdylib" || crateType == "proc-macro" 356 if usesLinker { 357 rustcOutputFile = android.PathForModuleOut(ctx, outputFile.Base()+".rsp") 358 } 359 360 ctx.Build(pctx, android.BuildParams{ 361 Rule: rustc, 362 Description: "rustc " + main.Rel(), 363 Output: rustcOutputFile, 364 Inputs: inputs, 365 Implicits: implicits, 366 Args: map[string]string{ 367 "rustcFlags": strings.Join(rustcFlags, " "), 368 "libFlags": strings.Join(libFlags, " "), 369 "envVars": strings.Join(envVars, " "), 370 }, 371 }) 372 373 if usesLinker { 374 ctx.Build(pctx, android.BuildParams{ 375 Rule: rustLink, 376 Description: "rustLink " + main.Rel(), 377 Output: outputFile, 378 Inputs: android.Paths{rustcOutputFile}, 379 Implicits: linkImplicits, 380 OrderOnly: linkOrderOnly, 381 Args: map[string]string{ 382 "linkFlags": strings.Join(linkFlags, " "), 383 "crtBegin": strings.Join(deps.CrtBegin.Strings(), " "), 384 "crtEnd": strings.Join(deps.CrtEnd.Strings(), " "), 385 }, 386 }) 387 } 388 389 if flags.EmitXrefs { 390 kytheFile := android.PathForModuleOut(ctx, outputFile.Base()+".kzip") 391 ctx.Build(pctx, android.BuildParams{ 392 Rule: kytheExtract, 393 Description: "Xref Rust extractor " + main.Rel(), 394 Output: kytheFile, 395 Inputs: inputs, 396 Implicits: implicits, 397 Args: map[string]string{ 398 "rustcFlags": strings.Join(rustcFlags, " "), 399 "libFlags": strings.Join(libFlags, " "), 400 "envVars": strings.Join(envVars, " "), 401 }, 402 }) 403 output.kytheFile = kytheFile 404 } 405 return output 406} 407 408func Rustdoc(ctx ModuleContext, main android.Path, deps PathDeps, 409 flags Flags) android.ModuleOutPath { 410 411 rustdocFlags := append([]string{}, flags.RustdocFlags...) 412 rustdocFlags = append(rustdocFlags, "--sysroot=/dev/null") 413 414 // Build an index for all our crates. -Z unstable options is required to use 415 // this flag. 416 rustdocFlags = append(rustdocFlags, "-Z", "unstable-options", "--enable-index-page") 417 418 targetTriple := ctx.toolchain().RustTriple() 419 420 // Collect rustc flags 421 if targetTriple != "" { 422 rustdocFlags = append(rustdocFlags, "--target="+targetTriple) 423 } 424 425 crateName := ctx.RustModule().CrateName() 426 rustdocFlags = append(rustdocFlags, "--crate-name "+crateName) 427 428 rustdocFlags = append(rustdocFlags, makeLibFlags(deps)...) 429 docTimestampFile := android.PathForModuleOut(ctx, "rustdoc.timestamp") 430 431 // Silence warnings about renamed lints for third-party crates 432 modulePath := android.PathForModuleSrc(ctx).String() 433 if android.IsThirdPartyPath(modulePath) { 434 rustdocFlags = append(rustdocFlags, " -A warnings") 435 } 436 437 // Yes, the same out directory is used simultaneously by all rustdoc builds. 438 // This is what cargo does. The docs for individual crates get generated to 439 // a subdirectory named for the crate, and rustdoc synchronizes writes to 440 // shared pieces like the index and search data itself. 441 // https://github.com/rust-lang/rust/blob/master/src/librustdoc/html/render/write_shared.rs#L144-L146 442 docDir := android.PathForOutput(ctx, "rustdoc") 443 444 ctx.Build(pctx, android.BuildParams{ 445 Rule: rustdoc, 446 Description: "rustdoc " + main.Rel(), 447 Output: docTimestampFile, 448 Input: main, 449 Implicit: ctx.RustModule().UnstrippedOutputFile(), 450 Args: map[string]string{ 451 "rustdocFlags": strings.Join(rustdocFlags, " "), 452 "outDir": docDir.String(), 453 "envVars": strings.Join(rustEnvVars(ctx, deps), " "), 454 }, 455 }) 456 457 return docTimestampFile 458} 459