Merge "Re-enable partition test" into main
diff --git a/android/prebuilt_build_tool.go b/android/prebuilt_build_tool.go
index 17b3230..aeae20f 100644
--- a/android/prebuilt_build_tool.go
+++ b/android/prebuilt_build_tool.go
@@ -17,7 +17,7 @@
import "path/filepath"
func init() {
- RegisterModuleType("prebuilt_build_tool", NewPrebuiltBuildTool)
+ RegisterModuleType("prebuilt_build_tool", prebuiltBuildToolFactory)
}
type prebuiltBuildToolProperties struct {
@@ -101,6 +101,10 @@
// prebuilt_build_tool is to declare prebuilts to be used during the build, particularly for use
// in genrules with the "tools" property.
+func prebuiltBuildToolFactory() Module {
+ return NewPrebuiltBuildTool()
+}
+
func NewPrebuiltBuildTool() Module {
module := &prebuiltBuildTool{}
module.AddProperties(&module.properties)
diff --git a/android/rule_builder.go b/android/rule_builder.go
index 97582db..777c1cf 100644
--- a/android/rule_builder.go
+++ b/android/rule_builder.go
@@ -474,23 +474,13 @@
Inputs(depFiles.Paths())
}
-// BuildWithNinjaVars adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
-// Outputs. This function will not escape Ninja variables, so it may be used to write sandbox manifests using Ninja variables.
-func (r *RuleBuilder) BuildWithUnescapedNinjaVars(name string, desc string) {
- r.build(name, desc, false)
-}
-
// Build adds the built command line to the build graph, with dependencies on Inputs and Tools, and output files for
// Outputs.
func (r *RuleBuilder) Build(name string, desc string) {
- r.build(name, desc, true)
-}
-
-func (r *RuleBuilder) build(name string, desc string, ninjaEscapeCommandString bool) {
name = ninjaNameEscape(name)
if len(r.missingDeps) > 0 {
- r.ctx.Build(r.pctx, BuildParams{
+ r.ctx.Build(pctx, BuildParams{
Rule: ErrorRule,
Outputs: r.Outputs(),
Description: desc,
@@ -629,35 +619,12 @@
name, r.sboxManifestPath.String(), r.outDir.String())
}
- // Create a rule to write the manifest as textproto.
+ // Create a rule to write the manifest as a the textproto.
pbText, err := prototext.Marshal(&manifest)
if err != nil {
ReportPathErrorf(r.ctx, "sbox manifest failed to marshal: %q", err)
}
- if ninjaEscapeCommandString {
- WriteFileRule(r.ctx, r.sboxManifestPath, string(pbText))
- } else {
- // We need to have a rule to write files that is
- // defined on the RuleBuilder's pctx in order to
- // write Ninja variables in the string.
- // The WriteFileRule function above rule can only write
- // raw strings because it is defined on the android
- // package's pctx, and it can't access variables defined
- // in another context.
- r.ctx.Build(r.pctx, BuildParams{
- Rule: r.ctx.Rule(r.pctx, "unescapedWriteFile", blueprint.RuleParams{
- Command: `rm -rf ${out} && cat ${out}.rsp > ${out}`,
- Rspfile: "${out}.rsp",
- RspfileContent: "${content}",
- Description: "write file",
- }, "content"),
- Output: r.sboxManifestPath,
- Description: "write sbox manifest " + r.sboxManifestPath.Base(),
- Args: map[string]string{
- "content": string(pbText),
- },
- })
- }
+ WriteFileRule(r.ctx, r.sboxManifestPath, string(pbText))
// Generate a new string to use as the command line of the sbox rule. This uses
// a RuleBuilderCommand as a convenience method of building the command line, then
@@ -757,7 +724,7 @@
}
r.ctx.Build(r.pctx, BuildParams{
- Rule: r.ctx.Rule(r.pctx, name, blueprint.RuleParams{
+ Rule: r.ctx.Rule(pctx, name, blueprint.RuleParams{
Command: proptools.NinjaEscape(commandString),
CommandDeps: proptools.NinjaEscapeList(tools.Strings()),
Restat: r.restat,
diff --git a/android/rule_builder_test.go b/android/rule_builder_test.go
index a6b3a27..86647eb 100644
--- a/android/rule_builder_test.go
+++ b/android/rule_builder_test.go
@@ -28,17 +28,6 @@
"android/soong/shared"
)
-var (
- pctx_ruleBuilderTest = NewPackageContext("android/soong/rule_builder")
- pctx_ruleBuilderTestSubContext = NewPackageContext("android/soong/rule_builder/config")
-)
-
-func init() {
- pctx_ruleBuilderTest.Import("android/soong/rule_builder/config")
- pctx_ruleBuilderTest.StaticVariable("cmdFlags", "${config.ConfigFlags}")
- pctx_ruleBuilderTestSubContext.StaticVariable("ConfigFlags", "--some-clang-flag")
-}
-
func builderContext() BuilderContext {
return BuilderContextForTesting(TestConfig("out", nil, "", map[string][]byte{
"ld": nil,
@@ -507,13 +496,11 @@
type testRuleBuilderModule struct {
ModuleBase
properties struct {
- Srcs []string
- Flags []string
+ Srcs []string
- Restat bool
- Sbox bool
- Sbox_inputs bool
- Unescape_ninja_vars bool
+ Restat bool
+ Sbox bool
+ Sbox_inputs bool
}
}
@@ -531,9 +518,8 @@
rspFileContents2 := PathsForSource(ctx, []string{"rsp_in2"})
manifestPath := PathForModuleOut(ctx, "sbox.textproto")
- testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, t.properties.Flags,
- out, outDep, outDir,
- manifestPath, t.properties.Restat, t.properties.Sbox, t.properties.Sbox_inputs, t.properties.Unescape_ninja_vars,
+ testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, out, outDep, outDir,
+ manifestPath, t.properties.Restat, t.properties.Sbox, t.properties.Sbox_inputs,
rspFile, rspFileContents, rspFile2, rspFileContents2)
}
@@ -557,18 +543,17 @@
rspFileContents2 := PathsForSource(ctx, []string{"rsp_in2"})
manifestPath := PathForOutput(ctx, "singleton/sbox.textproto")
- testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, nil, out, outDep, outDir,
- manifestPath, true, false, false, false,
+ testRuleBuilder_Build(ctx, in, implicit, orderOnly, validation, out, outDep, outDir,
+ manifestPath, true, false, false,
rspFile, rspFileContents, rspFile2, rspFileContents2)
}
func testRuleBuilder_Build(ctx BuilderContext, in Paths, implicit, orderOnly, validation Path,
- flags []string,
out, outDep, outDir, manifestPath WritablePath,
- restat, sbox, sboxInputs, unescapeNinjaVars bool,
+ restat, sbox, sboxInputs bool,
rspFile WritablePath, rspFileContents Paths, rspFile2 WritablePath, rspFileContents2 Paths) {
- rule := NewRuleBuilder(pctx_ruleBuilderTest, ctx)
+ rule := NewRuleBuilder(pctx, ctx)
if sbox {
rule.Sbox(outDir, manifestPath)
@@ -579,7 +564,6 @@
rule.Command().
Tool(PathForSource(ctx, "cp")).
- Flags(flags).
Inputs(in).
Implicit(implicit).
OrderOnly(orderOnly).
@@ -593,11 +577,7 @@
rule.Restat()
}
- if unescapeNinjaVars {
- rule.BuildWithUnescapedNinjaVars("rule", "desc")
- } else {
- rule.Build("rule", "desc")
- }
+ rule.Build("rule", "desc")
}
var prepareForRuleBuilderTest = FixtureRegisterWithContext(func(ctx RegistrationContext) {
@@ -812,47 +792,3 @@
})
}
}
-
-func TestRuleBuilderWithNinjaVarEscaping(t *testing.T) {
- bp := `
- rule_builder_test {
- name: "foo_sbox_escaped_ninja",
- flags: ["${cmdFlags}"],
- sbox: true,
- sbox_inputs: true,
- }
- rule_builder_test {
- name: "foo_sbox",
- flags: ["${cmdFlags}"],
- sbox: true,
- sbox_inputs: true,
- unescape_ninja_vars: true,
- }
- `
- result := GroupFixturePreparers(
- prepareForRuleBuilderTest,
- FixtureWithRootAndroidBp(bp),
- ).RunTest(t)
-
- escapedNinjaMod := result.ModuleForTests("foo_sbox_escaped_ninja", "").Rule("writeFile")
- AssertStringDoesContain(
- t,
- "",
- escapedNinjaMod.BuildParams.Args["content"],
- "$${cmdFlags}",
- )
-
- unescapedNinjaMod := result.ModuleForTests("foo_sbox", "").Rule("unescapedWriteFile")
- AssertStringDoesContain(
- t,
- "",
- unescapedNinjaMod.BuildParams.Args["content"],
- "${cmdFlags}",
- )
- AssertStringDoesNotContain(
- t,
- "",
- unescapedNinjaMod.BuildParams.Args["content"],
- "$${cmdFlags}",
- )
-}
diff --git a/bazel/aquery.go b/bazel/aquery.go
index 76cd972..c355712 100644
--- a/bazel/aquery.go
+++ b/bazel/aquery.go
@@ -177,6 +177,21 @@
if err != nil {
return nil, err
}
+ if artifact.IsTreeArtifact &&
+ !strings.HasPrefix(artifactPath, "bazel-out/io_bazel_rules_go/") &&
+ !strings.HasPrefix(artifactPath, "bazel-out/rules_java_builtin/") {
+ // Since we're using ninja as an executor, we can't use tree artifacts. Ninja only
+ // considers a file/directory "dirty" when it's mtime changes. Directories' mtimes will
+ // only change when a file in the directory is added/removed, but not when files in
+ // the directory are changed, or when files in subdirectories are changed/added/removed.
+ // Bazel handles this by walking the directory and generating a hash for it after the
+ // action runs, which we would have to do as well if we wanted to support these
+ // artifacts in mixed builds.
+ //
+ // However, there are some bazel built-in rules that use tree artifacts. Allow those,
+ // but keep in mind that they'll have incrementality issues.
+ return nil, fmt.Errorf("tree artifacts are currently not supported in mixed builds: " + artifactPath)
+ }
artifactIdToPath[artifactId(artifact.Id)] = artifactPath
}
diff --git a/cc/testing.go b/cc/testing.go
index dbdee9e..d1632aa 100644
--- a/cc/testing.go
+++ b/cc/testing.go
@@ -35,7 +35,6 @@
multitree.RegisterApiImportsModule(ctx)
- ctx.RegisterModuleType("prebuilt_build_tool", android.NewPrebuiltBuildTool)
ctx.RegisterModuleType("cc_benchmark", BenchmarkFactory)
ctx.RegisterModuleType("cc_object", ObjectFactory)
ctx.RegisterModuleType("cc_genrule", GenRuleFactory)
diff --git a/cmd/sbox/sbox.go b/cmd/sbox/sbox.go
index 3364f50..fc56dd5 100644
--- a/cmd/sbox/sbox.go
+++ b/cmd/sbox/sbox.go
@@ -119,9 +119,6 @@
}
manifest, err := readManifest(manifestFile)
- if err != nil {
- return err
- }
if len(manifest.Commands) == 0 {
return fmt.Errorf("at least one commands entry is required in %q", manifestFile)
diff --git a/rust/binary.go b/rust/binary.go
index 2c9f64d..1e24beb 100644
--- a/rust/binary.go
+++ b/rust/binary.go
@@ -137,14 +137,9 @@
func (binary *binaryDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) buildOutput {
fileName := binary.getStem(ctx) + ctx.toolchain().ExecutableSuffix()
+ srcPath, _ := srcPathFromModuleSrcs(ctx, binary.baseCompiler.Properties.Srcs)
outputFile := android.PathForModuleOut(ctx, fileName)
ret := buildOutput{outputFile: outputFile}
- var crateRootPath android.Path
- if binary.baseCompiler.Properties.Crate_root == nil {
- crateRootPath, _ = srcPathFromModuleSrcs(ctx, binary.baseCompiler.Properties.Srcs)
- } else {
- crateRootPath = android.PathForModuleSrc(ctx, *binary.baseCompiler.Properties.Crate_root)
- }
flags.RustFlags = append(flags.RustFlags, deps.depFlags...)
flags.LinkFlags = append(flags.LinkFlags, deps.depLinkFlags...)
@@ -159,7 +154,7 @@
}
binary.baseCompiler.unstrippedOutputFile = outputFile
- ret.kytheFile = TransformSrcToBinary(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+ ret.kytheFile = TransformSrcToBinary(ctx, srcPath, deps, flags, outputFile).kytheFile
return ret
}
diff --git a/rust/compiler.go b/rust/compiler.go
index d6c52e8..e6a7a93 100644
--- a/rust/compiler.go
+++ b/rust/compiler.go
@@ -73,15 +73,6 @@
// If no source file is defined, a single generated source module can be defined to be used as the main source.
Srcs []string `android:"path,arch_variant"`
- // Entry point that is passed to rustc to begin the compilation. E.g. main.rs or lib.rs.
- // When this property is set,
- // * sandboxing is enabled for this module, and
- // * the srcs attribute is interpreted as a list of all source files potentially
- // used in compilation, including the entrypoint, and
- // * compile_data can be used to add additional files used in compilation that
- // not directly used as source files.
- Crate_root *string `android:"path,arch_variant"`
-
// name of the lint set that should be used to validate this module.
//
// Possible values are "default" (for using a sensible set of lints
@@ -520,8 +511,6 @@
ctx.PropertyErrorf("srcs", "only a single generated source module can be defined without a main source file.")
}
- // TODO: b/297264540 - once all modules are sandboxed, we need to select the proper
- // entry point file from Srcs rather than taking the first one
paths := android.PathsForModuleSrc(ctx, srcs)
return paths[srcIndex], paths[1:]
}
diff --git a/rust/library.go b/rust/library.go
index 7432a12..3f031c1 100644
--- a/rust/library.go
+++ b/rust/library.go
@@ -489,7 +489,7 @@
var outputFile android.ModuleOutPath
var ret buildOutput
var fileName string
- crateRootPath := library.crateRootPath(ctx, deps)
+ srcPath := library.srcPath(ctx, deps)
if library.sourceProvider != nil {
deps.srcProviderFiles = append(deps.srcProviderFiles, library.sourceProvider.Srcs()...)
@@ -536,13 +536,13 @@
// Call the appropriate builder for this library type
if library.rlib() {
- ret.kytheFile = TransformSrctoRlib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+ ret.kytheFile = TransformSrctoRlib(ctx, srcPath, deps, flags, outputFile).kytheFile
} else if library.dylib() {
- ret.kytheFile = TransformSrctoDylib(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+ ret.kytheFile = TransformSrctoDylib(ctx, srcPath, deps, flags, outputFile).kytheFile
} else if library.static() {
- ret.kytheFile = TransformSrctoStatic(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+ ret.kytheFile = TransformSrctoStatic(ctx, srcPath, deps, flags, outputFile).kytheFile
} else if library.shared() {
- ret.kytheFile = TransformSrctoShared(ctx, crateRootPath, deps, flags, outputFile).kytheFile
+ ret.kytheFile = TransformSrctoShared(ctx, srcPath, deps, flags, outputFile).kytheFile
}
if library.rlib() || library.dylib() {
@@ -585,15 +585,13 @@
return ret
}
-func (library *libraryDecorator) crateRootPath(ctx ModuleContext, _ PathDeps) android.Path {
+func (library *libraryDecorator) srcPath(ctx ModuleContext, _ PathDeps) android.Path {
if library.sourceProvider != nil {
// Assume the first source from the source provider is the library entry point.
return library.sourceProvider.Srcs()[0]
- } else if library.baseCompiler.Properties.Crate_root == nil {
+ } else {
path, _ := srcPathFromModuleSrcs(ctx, library.baseCompiler.Properties.Srcs)
return path
- } else {
- return android.PathForModuleSrc(ctx, *library.baseCompiler.Properties.Crate_root)
}
}
@@ -608,7 +606,7 @@
return android.OptionalPath{}
}
- return android.OptionalPathForPath(Rustdoc(ctx, library.crateRootPath(ctx, deps),
+ return android.OptionalPathForPath(Rustdoc(ctx, library.srcPath(ctx, deps),
deps, flags))
}
diff --git a/rust/toolchain_library.go b/rust/toolchain_library.go
index e118f92..326d529 100644
--- a/rust/toolchain_library.go
+++ b/rust/toolchain_library.go
@@ -21,8 +21,6 @@
"android/soong/android"
"android/soong/rust/config"
-
- "github.com/google/blueprint/proptools"
)
// This module is used to compile the rust toolchain libraries
@@ -35,15 +33,11 @@
rustToolchainLibraryRlibFactory)
android.RegisterModuleType("rust_toolchain_library_dylib",
rustToolchainLibraryDylibFactory)
- android.RegisterModuleType("rust_toolchain_rustc_prebuilt",
- rustToolchainRustcPrebuiltFactory)
}
type toolchainLibraryProperties struct {
- // path to the toolchain crate root, relative to the top of the toolchain source
- Toolchain_crate_root *string `android:"arch_variant"`
- // path to the rest of the toolchain srcs, relative to the top of the toolchain source
- Toolchain_srcs []string `android:"arch_variant"`
+ // path to the toolchain source, relative to the top of the toolchain source
+ Toolchain_src *string `android:"arch_variant"`
}
type toolchainLibraryDecorator struct {
@@ -89,20 +83,15 @@
func rustSetToolchainSource(ctx android.LoadHookContext) {
if toolchainLib, ok := ctx.Module().(*Module).compiler.(*toolchainLibraryDecorator); ok {
prefix := "linux-x86/" + GetRustPrebuiltVersion(ctx)
- versionedCrateRoot := path.Join(prefix, android.String(toolchainLib.Properties.Toolchain_crate_root))
- versionedSrcs := make([]string, len(toolchainLib.Properties.Toolchain_srcs))
- for i, src := range toolchainLib.Properties.Toolchain_srcs {
- versionedSrcs[i] = path.Join(prefix, src)
- }
+ newSrcs := []string{path.Join(prefix, android.String(toolchainLib.Properties.Toolchain_src))}
type props struct {
- Crate_root *string
- Srcs []string
+ Srcs []string
}
p := &props{}
- p.Crate_root = &versionedCrateRoot
- p.Srcs = versionedSrcs
+ p.Srcs = newSrcs
ctx.AppendProperties(p)
+
} else {
ctx.ModuleErrorf("Called rustSetToolchainSource on a non-Rust Module.")
}
@@ -112,47 +101,3 @@
func GetRustPrebuiltVersion(ctx android.LoadHookContext) string {
return ctx.AConfig().GetenvWithDefault("RUST_PREBUILTS_VERSION", config.RustDefaultVersion)
}
-
-type toolchainRustcPrebuiltProperties struct {
- // path to rustc prebuilt, relative to the top of the toolchain source
- Toolchain_prebuilt_src *string
- // path to deps, relative to the top of the toolchain source
- Toolchain_deps []string
- // path to deps, relative to module directory
- Deps []string
-}
-
-func rustToolchainRustcPrebuiltFactory() android.Module {
- module := android.NewPrebuiltBuildTool()
- module.AddProperties(&toolchainRustcPrebuiltProperties{})
- android.AddLoadHook(module, func(ctx android.LoadHookContext) {
- var toolchainProps *toolchainRustcPrebuiltProperties
- for _, p := range ctx.Module().GetProperties() {
- toolchainProperties, ok := p.(*toolchainRustcPrebuiltProperties)
- if ok {
- toolchainProps = toolchainProperties
- }
- }
-
- if toolchainProps.Toolchain_prebuilt_src == nil {
- ctx.PropertyErrorf("toolchain_prebuilt_src", "must set path to rustc prebuilt")
- }
-
- prefix := "linux-x86/" + GetRustPrebuiltVersion(ctx)
- deps := make([]string, 0, len(toolchainProps.Toolchain_deps)+len(toolchainProps.Deps))
- for _, d := range toolchainProps.Toolchain_deps {
- deps = append(deps, path.Join(prefix, d))
- }
- deps = append(deps, toolchainProps.Deps...)
-
- props := struct {
- Src *string
- Deps []string
- }{
- Src: proptools.StringPtr(path.Join(prefix, *toolchainProps.Toolchain_prebuilt_src)),
- Deps: deps,
- }
- ctx.AppendProperties(&props)
- })
- return module
-}