diff --git a/rust/Android.bp b/rust/Android.bp index d56de870f..26a5a08da 100644 --- a/rust/Android.bp +++ b/rust/Android.bp @@ -10,6 +10,7 @@ bootstrap_go_package { srcs: [ "androidmk.go", "binary.go", + "bindgen.go", "builder.go", "clippy.go", "compiler.go", @@ -19,11 +20,13 @@ bootstrap_go_package { "proc_macro.go", "project_json.go", "rust.go", + "source_provider.go", "test.go", "testing.go", ], testSrcs: [ "binary_test.go", + "bindgen_test.go", "clippy_test.go", "compiler_test.go", "coverage_test.go", diff --git a/rust/androidmk.go b/rust/androidmk.go index aea899baa..babbf9123 100644 --- a/rust/androidmk.go +++ b/rust/androidmk.go @@ -55,6 +55,7 @@ func (mod *Module) AndroidMk() android.AndroidMkData { ret := android.AndroidMkData{ OutputFile: mod.outputFile, Include: "$(BUILD_SYSTEM)/soong_rust_prebuilt.mk", + SubName: mod.subName, Extra: []android.AndroidMkExtraFunc{ func(w io.Writer, outputFile android.Path) { if len(mod.Properties.AndroidMkRlibs) > 0 { @@ -75,9 +76,11 @@ func (mod *Module) AndroidMk() android.AndroidMkData { }, }, } - - mod.subAndroidMk(&ret, mod.compiler) - + if mod.compiler != nil { + mod.subAndroidMk(&ret, mod.compiler) + } else if mod.sourceProvider != nil { + mod.subAndroidMk(&ret, mod.sourceProvider) + } ret.SubName += mod.Properties.SubName return ret @@ -155,6 +158,25 @@ func (procMacro *procMacroDecorator) AndroidMk(ctx AndroidMkContext, ret *androi } +func (sourceProvider *baseSourceProvider) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) { + outFile := sourceProvider.outputFile + ret.Class = "ETC" + ret.OutputFile = android.OptionalPathForPath(outFile) + ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) { + _, file := filepath.Split(outFile.String()) + stem, suffix, _ := android.SplitFileExt(file) + fmt.Fprintln(w, "LOCAL_MODULE_SUFFIX := "+suffix) + fmt.Fprintln(w, "LOCAL_MODULE_STEM := "+stem) + }) +} + +func (bindgen *bindgenDecorator) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) { + ctx.subAndroidMk(ret, bindgen.baseSourceProvider) + ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) { + fmt.Fprintln(w, "LOCAL_UNINSTALLABLE_MODULE := true") + }) +} + func (compiler *baseCompiler) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) { // Soong installation is only supported for host modules. Have Make // installation trigger Soong installation. diff --git a/rust/bindgen.go b/rust/bindgen.go new file mode 100644 index 000000000..859223abf --- /dev/null +++ b/rust/bindgen.go @@ -0,0 +1,172 @@ +// Copyright 2020 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rust + +import ( + "github.com/google/blueprint" + "strings" + + "android/soong/android" + "android/soong/cc" + ccConfig "android/soong/cc/config" +) + +var ( + defaultBindgenFlags = []string{"--no-rustfmt-bindings"} + + // bindgen should specify its own Clang revision so updating Clang isn't potentially blocked on bindgen failures. + bindgenClangVersion = "clang-r383902c" + bindgenLibClangSoGit = "11git" + + //TODO(b/160803703) Use a prebuilt bindgen instead of the built bindgen. + _ = pctx.SourcePathVariable("bindgenCmd", "out/host/${config.HostPrebuiltTag}/bin/bindgen") + _ = pctx.SourcePathVariable("bindgenClang", + "${ccConfig.ClangBase}/${config.HostPrebuiltTag}/"+bindgenClangVersion+"/bin/clang") + _ = pctx.SourcePathVariable("bindgenLibClang", + "${ccConfig.ClangBase}/${config.HostPrebuiltTag}/"+bindgenClangVersion+"/lib64/libclang.so."+bindgenLibClangSoGit) + + //TODO(ivanlozano) Switch this to RuleBuilder + bindgen = pctx.AndroidStaticRule("bindgen", + blueprint.RuleParams{ + Command: "CLANG_PATH=$bindgenClang LIBCLANG_PATH=$bindgenLibClang $bindgenCmd $flags $in -o $out -- $cflags", + CommandDeps: []string{"$bindgenCmd"}, + }, + "flags", "cflags") +) + +func init() { + android.RegisterModuleType("rust_bindgen", RustBindgenFactory) +} + +var _ SourceProvider = (*bindgenDecorator)(nil) + +type BindgenProperties struct { + // The wrapper header file + Wrapper_src *string `android:"path,arch_variant"` + + // list of bindgen-specific flags and options + Flags []string `android:"arch_variant"` + + // list of clang flags required to correctly interpret the headers. + Cflags []string `android:"arch_variant"` + + // list of directories relative to the Blueprints file that will + // be added to the include path using -I + Local_include_dirs []string `android:"arch_variant,variant_prepend"` + + // list of static libraries that provide headers for this binding. + Static_libs []string `android:"arch_variant,variant_prepend"` + + // list of shared libraries that provide headers for this binding. + Shared_libs []string `android:"arch_variant"` + + //TODO(b/161141999) Add support for headers from cc_library_header modules. +} + +type bindgenDecorator struct { + *baseSourceProvider + + Properties BindgenProperties +} + +func (b *bindgenDecorator) libraryExports(ctx android.ModuleContext) (android.Paths, []string) { + var libraryPaths android.Paths + var libraryFlags []string + + for _, static_lib := range b.Properties.Static_libs { + if dep, ok := ctx.GetDirectDepWithTag(static_lib, cc.StaticDepTag).(*cc.Module); ok { + libraryPaths = append(libraryPaths, dep.ExportedIncludeDirs()...) + libraryFlags = append(libraryFlags, dep.ExportedFlags()...) + } + } + for _, shared_lib := range b.Properties.Shared_libs { + if dep, ok := ctx.GetDirectDepWithTag(shared_lib, cc.SharedDepTag).(*cc.Module); ok { + libraryPaths = append(libraryPaths, dep.ExportedIncludeDirs()...) + libraryFlags = append(libraryFlags, dep.ExportedFlags()...) + } + } + + return libraryPaths, libraryFlags +} + +func (b *bindgenDecorator) generateSource(ctx android.ModuleContext) android.Path { + ccToolchain := ccConfig.FindToolchain(ctx.Os(), ctx.Arch()) + includes, exportedFlags := b.libraryExports(ctx) + + var cflags []string + cflags = append(cflags, b.Properties.Cflags...) + cflags = append(cflags, "-target "+ccToolchain.ClangTriple()) + cflags = append(cflags, strings.ReplaceAll(ccToolchain.ToolchainClangCflags(), "${config.", "${ccConfig.")) + cflags = append(cflags, exportedFlags...) + for _, include := range includes { + cflags = append(cflags, "-I"+include.String()) + } + for _, include := range b.Properties.Local_include_dirs { + cflags = append(cflags, "-I"+android.PathForModuleSrc(ctx, include).String()) + } + + bindgenFlags := defaultBindgenFlags + bindgenFlags = append(bindgenFlags, strings.Join(b.Properties.Flags, " ")) + + wrapperFile := android.OptionalPathForModuleSrc(ctx, b.Properties.Wrapper_src) + if !wrapperFile.Valid() { + ctx.PropertyErrorf("wrapper_src", "invalid path to wrapper source") + } + + outputFile := android.PathForModuleOut(ctx, b.baseSourceProvider.getStem(ctx)+".rs") + + ctx.Build(pctx, android.BuildParams{ + Rule: bindgen, + Description: "bindgen " + wrapperFile.Path().Rel(), + Output: outputFile, + Input: wrapperFile.Path(), + Implicits: includes, + Args: map[string]string{ + "flags": strings.Join(bindgenFlags, " "), + "cflags": strings.Join(cflags, " "), + }, + }) + b.baseSourceProvider.outputFile = outputFile + return outputFile +} + +func (b *bindgenDecorator) sourceProviderProps() []interface{} { + return append(b.baseSourceProvider.sourceProviderProps(), + &b.Properties) +} + +func RustBindgenFactory() android.Module { + module, _ := NewRustBindgen(android.HostAndDeviceSupported) + return module.Init() +} + +func NewRustBindgen(hod android.HostOrDeviceSupported) (*Module, *bindgenDecorator) { + module := newModule(hod, android.MultilibBoth) + + bindgen := &bindgenDecorator{ + baseSourceProvider: NewSourceProvider(), + Properties: BindgenProperties{}, + } + module.sourceProvider = bindgen + + return module, bindgen +} + +func (b *bindgenDecorator) sourceProviderDeps(ctx DepsContext, deps Deps) Deps { + deps = b.baseSourceProvider.sourceProviderDeps(ctx, deps) + deps.SharedLibs = append(deps.SharedLibs, b.Properties.Shared_libs...) + deps.StaticLibs = append(deps.StaticLibs, b.Properties.Static_libs...) + return deps +} diff --git a/rust/bindgen_test.go b/rust/bindgen_test.go new file mode 100644 index 000000000..18e188f22 --- /dev/null +++ b/rust/bindgen_test.go @@ -0,0 +1,56 @@ +// Copyright 2020 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rust + +import ( + "strings" + "testing" +) + +func TestRustBindgen(t *testing.T) { + ctx := testRust(t, ` + rust_bindgen { + name: "libbindgen", + wrapper_src: "src/any.h", + stem: "bindings", + flags: ["--bindgen-flag"], + cflags: ["--clang-flag"], + shared_libs: ["libfoo_shared"], + static_libs: ["libfoo_static"], + } + cc_library_shared { + name: "libfoo_shared", + export_include_dirs: ["shared_include"], + } + cc_library_static { + name: "libfoo_static", + export_include_dirs: ["static_include"], + } + + `) + libbindgen := ctx.ModuleForTests("libbindgen", "android_arm64_armv8-a").Output("bindings.rs") + if !strings.Contains(libbindgen.Args["flags"], "--bindgen-flag") { + t.Errorf("missing bindgen flags in rust_bindgen rule: flags %#v", libbindgen.Args["flags"]) + } + if !strings.Contains(libbindgen.Args["cflags"], "--clang-flag") { + t.Errorf("missing clang cflags in rust_bindgen rule: cflags %#v", libbindgen.Args["cflags"]) + } + if !strings.Contains(libbindgen.Args["cflags"], "-Ishared_include") { + t.Errorf("missing clang cflags in rust_bindgen rule: cflags %#v", libbindgen.Args["cflags"]) + } + if !strings.Contains(libbindgen.Args["cflags"], "-Istatic_include") { + t.Errorf("missing clang cflags in rust_bindgen rule: cflags %#v", libbindgen.Args["cflags"]) + } +} diff --git a/rust/rust.go b/rust/rust.go index 7a98c6468..51eaf6838 100644 --- a/rust/rust.go +++ b/rust/rust.go @@ -42,6 +42,7 @@ func init() { ctx.BottomUp("rust_begin", BeginMutator).Parallel() }) pctx.Import("android/soong/rust/config") + pctx.ImportAs("ccConfig", "android/soong/cc/config") } type Flags struct { @@ -79,8 +80,11 @@ type Module struct { coverage *coverage clippy *clippy cachedToolchain config.Toolchain + sourceProvider SourceProvider subAndroidMkOnce map[subAndroidMkProvider]bool outputFile android.OptionalPath + + subName string } var _ android.ImageInterface = (*Module)(nil) @@ -348,6 +352,7 @@ func DefaultsFactory(props ...interface{}) android.Module { &LibraryCompilerProperties{}, &ProcMacroCompilerProperties{}, &PrebuiltProperties{}, + &SourceProviderProperties{}, &TestProperties{}, &cc.CoverageProperties{}, &ClippyProperties{}, @@ -507,6 +512,9 @@ func (mod *Module) Init() android.Module { if mod.clippy != nil { mod.AddProperties(mod.clippy.props()...) } + if mod.sourceProvider != nil { + mod.AddProperties(mod.sourceProvider.sourceProviderProps()...) + } android.InitAndroidArchModule(mod, mod.hod, mod.multilib) @@ -645,6 +653,10 @@ func (mod *Module) GenerateAndroidBuildActions(actx android.ModuleContext) { if !mod.Properties.PreventInstall { mod.compiler.install(ctx, mod.outputFile.Path()) } + } else if mod.sourceProvider != nil { + outputFile := mod.sourceProvider.generateSource(ctx) + mod.outputFile = android.OptionalPathForPath(outputFile) + mod.subName = ctx.ModuleSubDir() } } @@ -653,6 +665,8 @@ func (mod *Module) deps(ctx DepsContext) Deps { if mod.compiler != nil { deps = mod.compiler.compilerDeps(ctx, deps) + } else if mod.sourceProvider != nil { + deps = mod.sourceProvider.sourceProviderDeps(ctx, deps) } if mod.coverage != nil { diff --git a/rust/source_provider.go b/rust/source_provider.go new file mode 100644 index 000000000..e034d2c28 --- /dev/null +++ b/rust/source_provider.go @@ -0,0 +1,70 @@ +// Copyright 2020 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rust + +import ( + "android/soong/android" +) + +type SourceProviderProperties struct { + // sets name of the output + Stem *string `android:"arch_variant"` +} + +type baseSourceProvider struct { + Properties SourceProviderProperties + + outputFile android.Path + subAndroidMkOnce map[subAndroidMkProvider]bool +} + +var _ SourceProvider = (*baseSourceProvider)(nil) + +type SourceProvider interface { + generateSource(ctx android.ModuleContext) android.Path + Srcs() android.Paths + sourceProviderProps() []interface{} + sourceProviderDeps(ctx DepsContext, deps Deps) Deps +} + +func (sp *baseSourceProvider) Srcs() android.Paths { + return android.Paths{sp.outputFile} +} + +func (sp *baseSourceProvider) generateSource(ctx android.ModuleContext) android.Path { + panic("baseSourceProviderModule does not implement generateSource()") +} + +func (sp *baseSourceProvider) sourceProviderProps() []interface{} { + return []interface{}{&sp.Properties} +} + +func NewSourceProvider() *baseSourceProvider { + return &baseSourceProvider{ + Properties: SourceProviderProperties{}, + } +} + +func (sp *baseSourceProvider) getStem(ctx android.ModuleContext) string { + stem := ctx.ModuleName() + if String(sp.Properties.Stem) != "" { + stem = String(sp.Properties.Stem) + } + return stem +} + +func (sp *baseSourceProvider) sourceProviderDeps(ctx DepsContext, deps Deps) Deps { + return deps +} diff --git a/rust/testing.go b/rust/testing.go index 430b40bfd..f2d4c5eba 100644 --- a/rust/testing.go +++ b/rust/testing.go @@ -81,6 +81,7 @@ func CreateTestContext() *android.TestContext { ctx.RegisterModuleType("genrule", genrule.GenRuleFactory) ctx.RegisterModuleType("rust_binary", RustBinaryFactory) ctx.RegisterModuleType("rust_binary_host", RustBinaryHostFactory) + ctx.RegisterModuleType("rust_bindgen", RustBindgenFactory) ctx.RegisterModuleType("rust_test", RustTestFactory) ctx.RegisterModuleType("rust_test_host", RustTestHostFactory) ctx.RegisterModuleType("rust_library", RustLibraryFactory)