builder.go 9.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  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. package rust
  15. import (
  16. "path/filepath"
  17. "strings"
  18. "github.com/google/blueprint"
  19. "android/soong/android"
  20. "android/soong/rust/config"
  21. )
  22. var (
  23. _ = pctx.SourcePathVariable("rustcCmd", "${config.RustBin}/rustc")
  24. rustc = pctx.AndroidStaticRule("rustc",
  25. blueprint.RuleParams{
  26. Command: "$envVars $rustcCmd " +
  27. "-C linker=${config.RustLinker} " +
  28. "-C link-args=\"${crtBegin} ${config.RustLinkerArgs} ${linkFlags} ${crtEnd}\" " +
  29. "--emit link -o $out --emit dep-info=$out.d.raw $in ${libFlags} $rustcFlags" +
  30. " && grep \"^$out:\" $out.d.raw > $out.d",
  31. CommandDeps: []string{"$rustcCmd"},
  32. // Rustc deps-info writes out make compatible dep files: https://github.com/rust-lang/rust/issues/7633
  33. // Rustc emits unneeded dependency lines for the .d and input .rs files.
  34. // Those extra lines cause ninja warning:
  35. // "warning: depfile has multiple output paths"
  36. // For ninja, we keep/grep only the dependency rule for the rust $out file.
  37. Deps: blueprint.DepsGCC,
  38. Depfile: "$out.d",
  39. },
  40. "rustcFlags", "linkFlags", "libFlags", "crtBegin", "crtEnd", "envVars")
  41. _ = pctx.SourcePathVariable("clippyCmd", "${config.RustBin}/clippy-driver")
  42. clippyDriver = pctx.AndroidStaticRule("clippy",
  43. blueprint.RuleParams{
  44. Command: "$envVars $clippyCmd " +
  45. // Because clippy-driver uses rustc as backend, we need to have some output even during the linting.
  46. // Use the metadata output as it has the smallest footprint.
  47. "--emit metadata -o $out --emit dep-info=$out.d.raw $in ${libFlags} " +
  48. "$rustcFlags $clippyFlags" +
  49. " && grep \"^$out:\" $out.d.raw > $out.d",
  50. CommandDeps: []string{"$clippyCmd"},
  51. Deps: blueprint.DepsGCC,
  52. Depfile: "$out.d",
  53. },
  54. "rustcFlags", "libFlags", "clippyFlags", "envVars")
  55. zip = pctx.AndroidStaticRule("zip",
  56. blueprint.RuleParams{
  57. Command: "cat $out.rsp | tr ' ' '\\n' | tr -d \\' | sort -u > ${out}.tmp && ${SoongZipCmd} -o ${out} -C $$OUT_DIR -l ${out}.tmp",
  58. CommandDeps: []string{"${SoongZipCmd}"},
  59. Rspfile: "$out.rsp",
  60. RspfileContent: "$in",
  61. })
  62. cp = pctx.AndroidStaticRule("cp",
  63. blueprint.RuleParams{
  64. Command: "cp `cat $outDir.rsp` $outDir",
  65. Rspfile: "${outDir}.rsp",
  66. RspfileContent: "$in",
  67. },
  68. "outDir")
  69. )
  70. type buildOutput struct {
  71. outputFile android.Path
  72. }
  73. func init() {
  74. pctx.HostBinToolVariable("SoongZipCmd", "soong_zip")
  75. }
  76. func TransformSrcToBinary(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  77. outputFile android.WritablePath, linkDirs []string) buildOutput {
  78. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto")
  79. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "bin", linkDirs)
  80. }
  81. func TransformSrctoRlib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  82. outputFile android.WritablePath, linkDirs []string) buildOutput {
  83. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "rlib", linkDirs)
  84. }
  85. func TransformSrctoDylib(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  86. outputFile android.WritablePath, linkDirs []string) buildOutput {
  87. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "dylib", linkDirs)
  88. }
  89. func TransformSrctoStatic(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  90. outputFile android.WritablePath, linkDirs []string) buildOutput {
  91. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto")
  92. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "staticlib", linkDirs)
  93. }
  94. func TransformSrctoShared(ctx ModuleContext, mainSrc android.Path, deps PathDeps, flags Flags,
  95. outputFile android.WritablePath, linkDirs []string) buildOutput {
  96. flags.GlobalRustFlags = append(flags.GlobalRustFlags, "-C lto")
  97. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "cdylib", linkDirs)
  98. }
  99. func TransformSrctoProcMacro(ctx ModuleContext, mainSrc android.Path, deps PathDeps,
  100. flags Flags, outputFile android.WritablePath, linkDirs []string) buildOutput {
  101. return transformSrctoCrate(ctx, mainSrc, deps, flags, outputFile, "proc-macro", linkDirs)
  102. }
  103. func rustLibsToPaths(libs RustLibraries) android.Paths {
  104. var paths android.Paths
  105. for _, lib := range libs {
  106. paths = append(paths, lib.Path)
  107. }
  108. return paths
  109. }
  110. func transformSrctoCrate(ctx ModuleContext, main android.Path, deps PathDeps, flags Flags,
  111. outputFile android.WritablePath, crate_type string, linkDirs []string) buildOutput {
  112. var inputs android.Paths
  113. var implicits android.Paths
  114. var envVars []string
  115. var output buildOutput
  116. var libFlags, rustcFlags, linkFlags []string
  117. var implicitOutputs android.WritablePaths
  118. output.outputFile = outputFile
  119. crateName := ctx.RustModule().CrateName()
  120. targetTriple := ctx.toolchain().RustTriple()
  121. // libstd requires a specific environment variable to be set. This is
  122. // not officially documented and may be removed in the future. See
  123. // https://github.com/rust-lang/rust/blob/master/library/std/src/env.rs#L866.
  124. if crateName == "std" {
  125. envVars = append(envVars, "STD_ENV_ARCH="+config.StdEnvArch[ctx.RustModule().Arch().ArchType])
  126. }
  127. inputs = append(inputs, main)
  128. // Collect rustc flags
  129. rustcFlags = append(rustcFlags, flags.GlobalRustFlags...)
  130. rustcFlags = append(rustcFlags, flags.RustFlags...)
  131. rustcFlags = append(rustcFlags, "--crate-type="+crate_type)
  132. if crateName != "" {
  133. rustcFlags = append(rustcFlags, "--crate-name="+crateName)
  134. }
  135. if targetTriple != "" {
  136. rustcFlags = append(rustcFlags, "--target="+targetTriple)
  137. linkFlags = append(linkFlags, "-target "+targetTriple)
  138. }
  139. // Suppress an implicit sysroot
  140. rustcFlags = append(rustcFlags, "--sysroot=/dev/null")
  141. // Collect linker flags
  142. linkFlags = append(linkFlags, flags.GlobalLinkFlags...)
  143. linkFlags = append(linkFlags, flags.LinkFlags...)
  144. // Collect library/crate flags
  145. for _, lib := range deps.RLibs {
  146. libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
  147. }
  148. for _, lib := range deps.DyLibs {
  149. libFlags = append(libFlags, "--extern "+lib.CrateName+"="+lib.Path.String())
  150. }
  151. for _, proc_macro := range deps.ProcMacros {
  152. libFlags = append(libFlags, "--extern "+proc_macro.CrateName+"="+proc_macro.Path.String())
  153. }
  154. for _, path := range linkDirs {
  155. libFlags = append(libFlags, "-L "+path)
  156. }
  157. // Collect dependencies
  158. implicits = append(implicits, rustLibsToPaths(deps.RLibs)...)
  159. implicits = append(implicits, rustLibsToPaths(deps.DyLibs)...)
  160. implicits = append(implicits, rustLibsToPaths(deps.ProcMacros)...)
  161. implicits = append(implicits, deps.StaticLibs...)
  162. implicits = append(implicits, deps.SharedLibDeps...)
  163. implicits = append(implicits, deps.srcProviderFiles...)
  164. if deps.CrtBegin.Valid() {
  165. implicits = append(implicits, deps.CrtBegin.Path(), deps.CrtEnd.Path())
  166. }
  167. if len(deps.SrcDeps) > 0 {
  168. moduleGenDir := ctx.RustModule().compiler.CargoOutDir()
  169. var outputs android.WritablePaths
  170. for _, genSrc := range deps.SrcDeps {
  171. if android.SuffixInList(outputs.Strings(), genSubDir+genSrc.Base()) {
  172. ctx.PropertyErrorf("srcs",
  173. "multiple source providers generate the same filename output: "+genSrc.Base())
  174. }
  175. outputs = append(outputs, android.PathForModuleOut(ctx, genSubDir+genSrc.Base()))
  176. }
  177. ctx.Build(pctx, android.BuildParams{
  178. Rule: cp,
  179. Description: "cp " + moduleGenDir.Path().Rel(),
  180. Outputs: outputs,
  181. Inputs: deps.SrcDeps,
  182. Args: map[string]string{
  183. "outDir": moduleGenDir.String(),
  184. },
  185. })
  186. implicits = append(implicits, outputs.Paths()...)
  187. // We must calculate an absolute path for OUT_DIR since Rust's include! macro (which normally consumes this)
  188. // assumes that paths are relative to the source file.
  189. var outDirPrefix string
  190. if !filepath.IsAbs(moduleGenDir.String()) {
  191. // If OUT_DIR is not absolute, we use $$PWD to generate an absolute path (os.Getwd() returns '/')
  192. outDirPrefix = "$$PWD/"
  193. } else {
  194. // If OUT_DIR is absolute, then moduleGenDir will be an absolute path, so we don't need to set this to anything.
  195. outDirPrefix = ""
  196. }
  197. envVars = append(envVars, "OUT_DIR="+filepath.Join(outDirPrefix, moduleGenDir.String()))
  198. }
  199. envVars = append(envVars, "ANDROID_RUST_VERSION="+config.RustDefaultVersion)
  200. if flags.Clippy {
  201. clippyFile := android.PathForModuleOut(ctx, outputFile.Base()+".clippy")
  202. ctx.Build(pctx, android.BuildParams{
  203. Rule: clippyDriver,
  204. Description: "clippy " + main.Rel(),
  205. Output: clippyFile,
  206. ImplicitOutputs: nil,
  207. Inputs: inputs,
  208. Implicits: implicits,
  209. Args: map[string]string{
  210. "rustcFlags": strings.Join(rustcFlags, " "),
  211. "libFlags": strings.Join(libFlags, " "),
  212. "clippyFlags": strings.Join(flags.ClippyFlags, " "),
  213. "envVars": strings.Join(envVars, " "),
  214. },
  215. })
  216. // Declare the clippy build as an implicit dependency of the original crate.
  217. implicits = append(implicits, clippyFile)
  218. }
  219. ctx.Build(pctx, android.BuildParams{
  220. Rule: rustc,
  221. Description: "rustc " + main.Rel(),
  222. Output: outputFile,
  223. ImplicitOutputs: implicitOutputs,
  224. Inputs: inputs,
  225. Implicits: implicits,
  226. Args: map[string]string{
  227. "rustcFlags": strings.Join(rustcFlags, " "),
  228. "linkFlags": strings.Join(linkFlags, " "),
  229. "libFlags": strings.Join(libFlags, " "),
  230. "crtBegin": deps.CrtBegin.String(),
  231. "crtEnd": deps.CrtEnd.String(),
  232. "envVars": strings.Join(envVars, " "),
  233. },
  234. })
  235. return output
  236. }