tequilaOS/platform_build_soong
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add soong_build primary builder

Browse source 
Initial build logic for building android with soong.  It can build
a variety of C and C++ files for arm/arm64 and host.

Change-Id: I10eb37c2c2a50be6af1bb5fd568c0962b9476bf0
This commit is contained in:
Colin Cross 2015-01-30 17:27:36 -08:00
parent e441b9df9a
commit 3f40fa460d
30 changed files with 6178 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
Blueprints
View file

@ -0,0 +1,112 @@
//
// WARNING: Modifying this file will NOT automatically regenerate build.ninja.in!
//
// Before modifying this file make sure minibp is up to date:
// 1) "repo sync build/soong" to make sure you have the latest build.ninja.in
// 2) build minibp, which builds automicatically through the normal build steps. For example:
//
// After modifying this file regenerate build.ninja.in and build your changes:
// 1) In your build directory, execute "../bootstrap.bash -r" to regenerate build.ninja.in
// 2) Build again
//
bootstrap_go_binary(
name = "soong_build",
deps = [
"blueprint",
"blueprint-bootstrap",
"soong-cc",
"soong-common",
"soong-config",
],
srcs = [
"cmd/soong_build/main.go",
],
primaryBuilder = true,
)
bootstrap_go_binary(
name = "soong_glob",
deps = [
"soong-glob",
],
srcs = [
"cmd/soong_glob/soong_glob.go",
],
)
bootstrap_go_package(
name = "soong-glob",
pkgPath = "android/soong/glob",
deps = [
"blueprint-deptools",
],
srcs = [
"glob/glob.go",
],
)
bootstrap_go_package(
name = "soong-common",
pkgPath = "android/soong/common",
deps = [
"blueprint",
"blueprint-bootstrap",
"soong-glob"
],
srcs = [
"common/arch.go",
"common/defs.go",
"common/glob.go",
"common/module.go",
"common/paths.go",
],
)
bootstrap_go_package(
name = "soong-config",
pkgPath = "android/soong/config",
deps = [
"blueprint",
"blueprint-bootstrap",
"soong-common",
],
srcs = [
"config/config.go",
],
)
bootstrap_go_package(
name = "soong-cc",
pkgPath = "android/soong/cc",
deps = [
"blueprint",
"blueprint-pathtools",
"soong-common",
"soong-config",
],
srcs = [
"cc/builder.go",
"cc/cc.go",
"cc/clang.go",
"cc/toolchain.go",
"cc/util.go",
"cc/arm_device.go",
"cc/arm64_device.go",
"cc/x86_linux_host.go",
],
)
toolchain_library(
name = "libatomic",
)
toolchain_library(
name = "libgcc",
)
toolchain_library(
name = "libgcov",
)

115
androidmk/cmd/androidmk/android.go Normal file
View file

@ -0,0 +1,115 @@
package main
import (
"android/soong/androidmk/parser"
)
const (
clear_vars = "__android_mk_clear_vars"
build_shared_library = "cc_library_shared"
build_static_library = "cc_library_static"
build_host_static_library = "cc_library_host_static"
build_host_shared_library = "cc_library_host_shared"
build_executable = "cc_binary"
build_host_executable = "cc_binary_host"
build_native_test = "cc_test"
build_prebuilt = "prebuilt"
)
var stringProperties = map[string]string{
"LOCAL_MODULE": "name",
"LOCAL_MODULE_STEM": "stem",
"LOCAL_MODULE_CLASS": "class",
"LOCAL_CXX_STL": "cxx_stl",
"LOCAL_STRIP_MODULE": "strip",
"LOCAL_MULTILIB": "compile_multilib",
}
var listProperties = map[string]string{
"LOCAL_SRC_FILES": "srcs",
"LOCAL_SHARED_LIBRARIES": "shared_libs",
"LOCAL_STATIC_LIBRARIES": "static_libs",
"LOCAL_WHOLE_STATIC_LIBRARIES": "whole_static_libs",
"LOCAL_SYSTEM_SHARED_LIBRARIES": "system_shared_libs",
"LOCAL_C_INCLUDES": "include_dirs",
"LOCAL_EXPORT_C_INCLUDE_DIRS": "export_include_dirs",
"LOCAL_ASFLAGS": "asflags",
"LOCAL_CLANG_ASFLAGS": "clang_asflags",
"LOCAL_CFLAGS": "cflags",
"LOCAL_CONLYFLAGS": "conlyflags",
"LOCAL_CPPFLAGS": "cppflags",
"LOCAL_LDFLAGS": "ldflags",
"LOCAL_REQUIRED_MODULES": "required",
"LOCAL_MODULE_TAGS": "tags",
"LOCAL_LDLIBS": "host_ldlibs",
"LOCAL_CLANG_CFLAGS": "clang_cflags",
}
var boolProperties = map[string]string{
"LOCAL_IS_HOST_MODULE": "host",
"LOCAL_CLANG": "clang",
"LOCAL_FORCE_STATIC_EXECUTABLE": "static",
"LOCAL_ADDRESS_SANITIZER": "asan",
"LOCAL_NATIVE_COVERAGE": "native_coverage",
"LOCAL_NO_CRT": "nocrt",
"LOCAL_ALLOW_UNDEFINED_SYMBOLS": "allow_undefined_symbols",
"LOCAL_RTTI_FLAG": "rtti",
}
var propertySuffixes = []struct {
suffix string
class string
}{
{"arm", "arch"},
{"arm64", "arch"},
{"mips", "arch"},
{"mips64", "arch"},
{"x86", "arch"},
{"x86_64", "arch"},
{"32", "multilib"},
{"64", "multilib"},
}
var propertySuffixTranslations = map[string]string{
"32": "lib32",
"64": "lib64",
}
var conditionalTranslations = map[string]struct {
class string
suffix string
}{
"($(HOST_OS),darwin)": {"host_os", "darwin"},
"($(HOST_OS), darwin)": {"host_os", "darwin"},
"($(HOST_OS),windows)": {"host_os", "windows"},
"($(HOST_OS), windows)": {"host_os", "windows"},
}
func mydir(args []string) string {
return "."
}
func androidScope() parser.Scope {
globalScope := parser.NewScope(nil)
globalScope.Set("CLEAR_VARS", clear_vars)
globalScope.Set("BUILD_HOST_EXECUTABLE", build_host_executable)
globalScope.Set("BUILD_SHARED_LIBRARY", build_shared_library)
globalScope.Set("BUILD_STATIC_LIBRARY", build_static_library)
globalScope.Set("BUILD_HOST_STATIC_LIBRARY", build_host_static_library)
globalScope.Set("BUILD_HOST_SHARED_LIBRARY", build_host_shared_library)
globalScope.Set("BUILD_NATIVE_TEST", build_native_test)
globalScope.Set("BUILD_EXECUTABLE", build_executable)
globalScope.Set("BUILD_PREBUILT", build_prebuilt)
globalScope.SetFunc("my-dir", mydir)
globalScope.Set("lib32", "lib32")
globalScope.Set("lib64", "lib64")
globalScope.Set("arm", "arm")
globalScope.Set("arm64", "arm64")
globalScope.Set("mips", "mips")
globalScope.Set("mips64", "mips64")
globalScope.Set("x86", "x86")
globalScope.Set("x86_64", "x86_64")
return globalScope
}

438
androidmk/cmd/androidmk/androidmk.go Normal file
View file

@ -0,0 +1,438 @@
package main
import (
"bytes"
"fmt"
"io/ioutil"
"os"
"strings"
"text/scanner"
mkparser "android/soong/androidmk/parser"
bpparser "blueprint/parser"
)
// TODO: non-expanded variables with expressions
type bpFile struct {
comments []bpparser.Comment
defs []bpparser.Definition
localAssignments map[string]*bpparser.Property
globalAssignments map[string]*bpparser.Value
scope mkparser.Scope
module *bpparser.Module
pos scanner.Position
prevLine, line int
}
func (f *bpFile) errorf(thing mkparser.MakeThing, s string, args ...interface{}) {
orig := thing.Dump()
s = fmt.Sprintf(s, args...)
f.comments = append(f.comments, bpparser.Comment{
Comment: fmt.Sprintf("// ANDROIDMK TRANSLATION ERROR: %s", s),
Pos: f.pos,
})
lines := strings.Split(orig, "\n")
for _, l := range lines {
f.incPos()
f.comments = append(f.comments, bpparser.Comment{
Comment: "// " + l,
Pos: f.pos,
})
}
}
func (f *bpFile) setPos(pos, endPos scanner.Position) {
f.pos = pos
f.line++
if f.pos.Line > f.prevLine+1 {
f.line++
}
f.pos.Line = f.line
f.prevLine = endPos.Line
}
func (f *bpFile) incPos() {
f.pos.Line++
f.line++
f.prevLine++
}
type conditional struct {
cond string
eq bool
}
func main() {
b, err := ioutil.ReadFile(os.Args[1])
if err != nil {
fmt.Println(err.Error())
return
}
p := mkparser.NewParser(os.Args[1], bytes.NewBuffer(b))
things, errs := p.Parse()
if len(errs) > 0 {
for _, err := range errs {
fmt.Println("ERROR: ", err)
}
return
}
file := &bpFile{
scope: androidScope(),
localAssignments: make(map[string]*bpparser.Property),
globalAssignments: make(map[string]*bpparser.Value),
}
var conds []*conditional
var cond *conditional
for _, t := range things {
file.setPos(t.Pos(), t.EndPos())
if comment, ok := t.AsComment(); ok {
file.comments = append(file.comments, bpparser.Comment{
Pos: file.pos,
Comment: "//" + comment.Comment,
})
} else if assignment, ok := t.AsAssignment(); ok {
handleAssignment(file, assignment, cond)
} else if directive, ok := t.AsDirective(); ok {
switch directive.Name {
case "include":
val := directive.Args.Value(file.scope)
switch val {
case build_shared_library, build_static_library,
build_executable, build_host_executable,
build_prebuilt, build_host_static_library,
build_host_shared_library, build_native_test:
handleModuleConditionals(file, directive, cond)
makeModule(file, val)
case clear_vars:
resetModule(file)
default:
file.errorf(directive, "unsupported include")
continue
}
case "ifeq", "ifneq":
args := directive.Args.Dump()
eq := directive.Name == "ifeq"
switch args {
case "($(HOST_OS),windows)", "($(HOST_OS), windows)",
"($(HOST_OS),darwin)", "($(HOST_OS), darwin)":
newCond := conditional{args, eq}
conds = append(conds, &newCond)
if cond == nil {
cond = &newCond
} else {
file.errorf(directive, "unsupported nested conditional")
}
default:
file.errorf(directive, "unsupported conditional")
conds = append(conds, nil)
continue
}
case "else":
if len(conds) == 0 {
file.errorf(directive, "missing if before else")
continue
} else if conds[len(conds)-1] == nil {
file.errorf(directive, "else from unsupported contitional")
continue
}
cond.eq = !cond.eq
case "endif":
if len(conds) == 0 {
file.errorf(directive, "missing if before endif")
continue
} else if conds[len(conds)-1] == nil {
file.errorf(directive, "endif from unsupported contitional")
conds = conds[:len(conds)-1]
} else {
if cond == conds[len(conds)-1] {
cond = nil
}
conds = conds[:len(conds)-1]
}
default:
file.errorf(directive, "unsupported directive")
continue
}
}
}
out, err := bpparser.Print(&bpparser.File{
Defs: file.defs,
Comments: file.comments,
})
if err != nil {
fmt.Println(err)
return
}
fmt.Print(string(out))
}
func handleAssignment(file *bpFile, assignment mkparser.Assignment, c *conditional) {
if !assignment.Name.Const() {
file.errorf(assignment, "unsupported non-const variable name")
return
}
if assignment.Target != nil {
file.errorf(assignment, "unsupported target assignment")
return
}
name := assignment.Name.Value(nil)
suffix := ""
class := ""
if strings.HasPrefix(name, "LOCAL_") {
for _, v := range propertySuffixes {
s, c := v.suffix, v.class
if strings.HasSuffix(name, "_"+s) {
name = strings.TrimSuffix(name, "_"+s)
suffix = s
if s, ok := propertySuffixTranslations[s]; ok {
suffix = s
}
class = c
break
}
}
if c != nil {
if class != "" {
file.errorf(assignment, "suffix assignment inside conditional, skipping conditional")
} else {
if v, ok := conditionalTranslations[c.cond]; ok {
class = v.class
suffix = v.suffix
if !c.eq {
suffix = "not_" + suffix
}
} else {
panic("unknown conditional")
}
}
}
} else {
if c != nil {
eq := "eq"
if !c.eq {
eq = "neq"
}
file.errorf(assignment, "conditional %s %s on global assignment", eq, c.cond)
}
}
var err error
if prop, ok := stringProperties[name]; ok {
err = setVariable(file, assignment.Value, assignment.Type == "+=", prop, bpparser.String, true, class, suffix)
} else if prop, ok := listProperties[name]; ok {
err = setVariable(file, assignment.Value, assignment.Type == "+=", prop, bpparser.List, true, class, suffix)
} else if prop, ok := boolProperties[name]; ok {
err = setVariable(file, assignment.Value, assignment.Type == "+=", prop, bpparser.Bool, true, class, suffix)
} else {
if name == "LOCAL_PATH" {
// Nothing to do, except maybe avoid the "./" in paths?
} else if strings.HasPrefix(name, "LOCAL_") {
//setVariable(file, assignment, name, bpparser.String, true)
switch name {
case "LOCAL_ADDITIONAL_DEPENDENCIES":
// TODO: check for only .mk files?
default:
file.errorf(assignment, "unsupported assignment to %s", name)
return
}
} else {
err = setVariable(file, assignment.Value, assignment.Type == "+=", name, bpparser.List, false, class, suffix)
}
}
if err != nil {
file.errorf(assignment, err.Error())
}
}
func handleModuleConditionals(file *bpFile, directive mkparser.Directive, c *conditional) {
if c == nil {
return
}
if v, ok := conditionalTranslations[c.cond]; ok {
class := v.class
suffix := v.suffix
disabledSuffix := v.suffix
if !c.eq {
suffix = "not_" + suffix
} else {
disabledSuffix = "not_" + disabledSuffix
}
// Hoist all properties inside the condtional up to the top level
file.module.Properties = file.localAssignments[class+"___"+suffix].Value.MapValue
file.module.Properties = append(file.module.Properties, file.localAssignments[class])
file.localAssignments[class+"___"+suffix].Value.MapValue = nil
for i := range file.localAssignments[class].Value.MapValue {
if file.localAssignments[class].Value.MapValue[i].Name.Name == suffix {
file.localAssignments[class].Value.MapValue =
append(file.localAssignments[class].Value.MapValue[:i],
file.localAssignments[class].Value.MapValue[i+1:]...)
}
}
// Create a fake assignment with enabled = false
err := setVariable(file, mkparser.SimpleMakeString("true", file.pos), false,
"disabled", bpparser.Bool, true, class, disabledSuffix)
if err != nil {
file.errorf(directive, err.Error())
}
} else {
panic("unknown conditional")
}
}
func makeModule(file *bpFile, t string) {
file.module.Type = bpparser.Ident{
Name: t,
Pos: file.module.LbracePos,
}
file.module.RbracePos = file.pos
file.defs = append(file.defs, file.module)
}
func resetModule(file *bpFile) {
file.module = &bpparser.Module{}
file.module.LbracePos = file.pos
file.localAssignments = make(map[string]*bpparser.Property)
}
func setVariable(file *bpFile, val *mkparser.MakeString, plusequals bool, name string,
typ bpparser.ValueType, local bool, class string, suffix string) error {
pos := file.pos
var oldValue *bpparser.Value
if local {
var oldProp *bpparser.Property
if class != "" {
oldProp = file.localAssignments[name+"___"+class+"___"+suffix]
} else {
oldProp = file.localAssignments[name]
}
if oldProp != nil {
oldValue = &oldProp.Value
}
} else {
oldValue = file.globalAssignments[name]
}
var exp *bpparser.Value
var err error
switch typ {
case bpparser.List:
exp, err = makeToListExpression(val)
case bpparser.String:
exp, err = makeToStringExpression(val)
case bpparser.Bool:
exp, err = makeToBoolExpression(val)
default:
panic("unknown type")
}
if err != nil {
return err
}
if local {
if oldValue != nil && plusequals {
val, err := addValues(oldValue, exp)
if err != nil {
return fmt.Errorf("unsupported addition: %s", err.Error())
}
val.Expression.Pos = pos
*oldValue = *val
} else if class == "" {
prop := &bpparser.Property{
Name: bpparser.Ident{Name: name, Pos: pos},
Pos: pos,
Value: *exp,
}
file.localAssignments[name] = prop
file.module.Properties = append(file.module.Properties, prop)
} else {
classProp := file.localAssignments[class]
if classProp == nil {
classProp = &bpparser.Property{
Name: bpparser.Ident{Name: class, Pos: pos},
Pos: pos,
Value: bpparser.Value{
Type: bpparser.Map,
MapValue: []*bpparser.Property{},
},
}
file.localAssignments[class] = classProp
file.module.Properties = append(file.module.Properties, classProp)
}
suffixProp := file.localAssignments[class+"___"+suffix]
if suffixProp == nil {
suffixProp = &bpparser.Property{
Name: bpparser.Ident{Name: suffix, Pos: pos},
Pos: pos,
Value: bpparser.Value{
Type: bpparser.Map,
MapValue: []*bpparser.Property{},
},
}
file.localAssignments[class+"___"+suffix] = suffixProp
classProp.Value.MapValue = append(classProp.Value.MapValue, suffixProp)
}
prop := &bpparser.Property{
Name: bpparser.Ident{Name: name, Pos: pos},
Pos: pos,
Value: *exp,
}
file.localAssignments[class+"___"+suffix+"___"+name] = prop
suffixProp.Value.MapValue = append(suffixProp.Value.MapValue, prop)
}
} else {
if oldValue != nil && plusequals {
a := &bpparser.Assignment{
Name: bpparser.Ident{
Name: name,
Pos: pos,
},
Value: *exp,
OrigValue: *exp,
Pos: pos,
Assigner: "+=",
}
file.defs = append(file.defs, a)
} else {
a := &bpparser.Assignment{
Name: bpparser.Ident{
Name: name,
Pos: pos,
},
Value: *exp,
OrigValue: *exp,
Pos: pos,
Assigner: "=",
}
file.globalAssignments[name] = &a.Value
file.defs = append(file.defs, a)
}
}
return nil
}

192
androidmk/cmd/androidmk/values.go Normal file
View file

@ -0,0 +1,192 @@
package main
import (
"fmt"
"strings"
mkparser "android/soong/androidmk/parser"
bpparser "blueprint/parser"
)
func stringToStringValue(s string) *bpparser.Value {
return &bpparser.Value{
Type: bpparser.String,
StringValue: s,
}
}
func addValues(val1, val2 *bpparser.Value) (*bpparser.Value, error) {
if val1.Type == bpparser.String && val2.Type == bpparser.List {
val1 = &bpparser.Value{
Type: bpparser.List,
ListValue: []bpparser.Value{*val1},
}
} else if val2.Type == bpparser.String && val1.Type == bpparser.List {
val2 = &bpparser.Value{
Type: bpparser.List,
ListValue: []bpparser.Value{*val1},
}
} else if val1.Type != val2.Type {
return nil, fmt.Errorf("cannot add mismatched types")
}
return &bpparser.Value{
Type: val1.Type,
Expression: &bpparser.Expression{
Operator: '+',
Args: [2]bpparser.Value{*val1, *val2},
},
}, nil
}
func makeToStringExpression(ms *mkparser.MakeString) (*bpparser.Value, error) {
var val *bpparser.Value
var err error
if ms.Strings[0] != "" {
val = stringToStringValue(ms.Strings[0])
}
for i, s := range ms.Strings[1:] {
name := ms.Variables[i].Name
if !name.Const() {
return nil, fmt.Errorf("Unsupported non-const variable name %s", name.Dump())
}
tmp := &bpparser.Value{
Type: bpparser.String,
Variable: name.Value(nil),
}
if val != nil {
val, err = addValues(val, tmp)
if err != nil {
return nil, err
}
} else {
val = tmp
}
if s != "" {
tmp := stringToStringValue(s)
val, err = addValues(val, tmp)
if err != nil {
return nil, err
}
}
}
return val, nil
}
func stringToListValue(s string) *bpparser.Value {
list := strings.Fields(s)
valList := make([]bpparser.Value, len(list))
for i, l := range list {
valList[i] = bpparser.Value{
Type: bpparser.String,
StringValue: l,
}
}
return &bpparser.Value{
Type: bpparser.List,
ListValue: valList,
}
}
func makeToListExpression(ms *mkparser.MakeString) (*bpparser.Value, error) {
fields := ms.Split(" \t")
var listOfListValues []*bpparser.Value
listValue := &bpparser.Value{
Type: bpparser.List,
}
for _, f := range fields {
if len(f.Variables) == 1 && f.Strings[0] == "" && f.Strings[1] == "" {
// Variable by itself, variable is probably a list
if !f.Variables[0].Name.Const() {
return nil, fmt.Errorf("unsupported non-const variable name")
}
if len(listValue.ListValue) > 0 {
listOfListValues = append(listOfListValues, listValue)
}
listOfListValues = append(listOfListValues, &bpparser.Value{
Type: bpparser.List,
Variable: f.Variables[0].Name.Value(nil),
})
listValue = &bpparser.Value{
Type: bpparser.List,
}
} else {
s, err := makeToStringExpression(f)
if err != nil {
return nil, err
}
if s == nil {
continue
}
listValue.ListValue = append(listValue.ListValue, *s)
}
}
if len(listValue.ListValue) > 0 {
listOfListValues = append(listOfListValues, listValue)
}
if len(listOfListValues) == 0 {
return listValue, nil
}
val := listOfListValues[0]
for _, tmp := range listOfListValues[1:] {
var err error
val, err = addValues(val, tmp)
if err != nil {
return nil, err
}
}
return val, nil
}
func stringToBoolValue(s string) (*bpparser.Value, error) {
var b bool
s = strings.TrimSpace(s)
switch s {
case "true":
b = true
case "false", "":
b = false
case "-frtti": // HACK for LOCAL_RTTI_VALUE
b = true
default:
return nil, fmt.Errorf("unexpected bool value %s", s)
}
return &bpparser.Value{
Type: bpparser.Bool,
BoolValue: b,
}, nil
}
func makeToBoolExpression(ms *mkparser.MakeString) (*bpparser.Value, error) {
if !ms.Const() {
if len(ms.Variables) == 1 && ms.Strings[0] == "" && ms.Strings[1] == "" {
name := ms.Variables[0].Name
if !name.Const() {
return nil, fmt.Errorf("unsupported non-const variable name")
}
return &bpparser.Value{
Type: bpparser.Bool,
Variable: name.Value(nil),
}, nil
} else {
return nil, fmt.Errorf("non-const bool expression %s", ms.Dump())
}
}
return stringToBoolValue(ms.Value(nil))
}

170
androidmk/parser/make_strings.go Normal file
View file

@ -0,0 +1,170 @@
package parser
import (
"strings"
"text/scanner"
"unicode"
)
// A MakeString is a string that may contain variable substitutions in it.
// It can be considered as an alternating list of raw Strings and variable
// substitutions, where the first and last entries in the list must be raw
// Strings (possibly empty). A MakeString that starts with a variable
// will have an empty first raw string, and a MakeString that ends with a
// variable will have an empty last raw string. Two sequential Variables
// will have an empty raw string between them.
//
// The MakeString is stored as two lists, a list of raw Strings and a list
// of Variables. The raw string list is always one longer than the variable
// list.
type MakeString struct {
Pos scanner.Position
Strings []string
Variables []Variable
}
func SimpleMakeString(s string, pos scanner.Position) *MakeString {
return &MakeString{
Pos: pos,
Strings: []string{s},
}
}
func (ms *MakeString) appendString(s string) {
if len(ms.Strings) == 0 {
ms.Strings = []string{s}
return
} else {
ms.Strings[len(ms.Strings)-1] += s
}
}
func (ms *MakeString) appendVariable(v Variable) {
if len(ms.Strings) == 0 {
ms.Strings = []string{"", ""}
ms.Variables = []Variable{v}
} else {
ms.Strings = append(ms.Strings, "")
ms.Variables = append(ms.Variables, v)
}
}
func (ms *MakeString) appendMakeString(other *MakeString) {
last := len(ms.Strings) - 1
ms.Strings[last] += other.Strings[0]
ms.Strings = append(ms.Strings, other.Strings[1:]...)
ms.Variables = append(ms.Variables, other.Variables...)
}
func (ms *MakeString) Value(scope Scope) string {
if len(ms.Strings) == 0 {
return ""
} else {
ret := ms.Strings[0]
for i := range ms.Strings[1:] {
ret += ms.Variables[i].Value(scope)
ret += ms.Strings[i+1]
}
return ret
}
}
func (ms *MakeString) Dump() string {
if len(ms.Strings) == 0 {
return ""
} else {
ret := ms.Strings[0]
for i := range ms.Strings[1:] {
ret += ms.Variables[i].Dump()
ret += ms.Strings[i+1]
}
return ret
}
}
func (ms *MakeString) Const() bool {
return len(ms.Strings) <= 1
}
func (ms *MakeString) Empty() bool {
return len(ms.Strings) == 0 || (len(ms.Strings) == 1 && ms.Strings[0] == "")
}
func (ms *MakeString) Split(sep string) []*MakeString {
return ms.SplitN(sep, -1)
}
func (ms *MakeString) SplitN(sep string, n int) []*MakeString {
ret := []*MakeString{}
curMs := SimpleMakeString("", ms.Pos)
var i int
var s string
for i, s = range ms.Strings {
if n != 0 {
split := splitAnyN(s, sep, n)
if n != -1 {
if len(split) > n {
panic("oops!")
} else {
n -= len(split)
}
}
curMs.appendString(split[0])
for _, r := range split[1:] {
ret = append(ret, curMs)
curMs = SimpleMakeString(r, ms.Pos)
}
} else {
curMs.appendString(s)
}
if i < len(ms.Strings)-1 {
curMs.appendVariable(ms.Variables[i])
}
}
ret = append(ret, curMs)
return ret
}
func (ms *MakeString) TrimLeftSpaces() {
ms.Strings[0] = strings.TrimLeftFunc(ms.Strings[0], unicode.IsSpace)
}
func (ms *MakeString) TrimRightSpaces() {
last := len(ms.Strings) - 1
ms.Strings[last] = strings.TrimRightFunc(ms.Strings[last], unicode.IsSpace)
}
func (ms *MakeString) TrimRightOne() {
last := len(ms.Strings) - 1
if len(ms.Strings[last]) > 1 {
ms.Strings[last] = ms.Strings[last][0 : len(ms.Strings[last])-1]
}
}
func (ms *MakeString) EndsWith(ch rune) bool {
s := ms.Strings[len(ms.Strings)-1]
return s[len(s)-1] == uint8(ch)
}
func splitAnyN(s, sep string, n int) []string {
ret := []string{}
for n == -1 || n > 1 {
index := strings.IndexAny(s, sep)
if index >= 0 {
ret = append(ret, s[0:index])
s = s[index+1:]
if n > 0 {
n--
}
} else {
break
}
}
ret = append(ret, s)
return ret
}

96
androidmk/parser/make_strings_test.go Normal file
View file

@ -0,0 +1,96 @@
package parser
import (
"strings"
"testing"
)
var splitNTestCases = []struct {
in *MakeString
expected []*MakeString
sep string
n int
}{
{
in: &MakeString{
strings: []string{
"a b c",
"d e f",
" h i j",
},
variables: []Variable{
variable{name: SimpleMakeString("var1")},
variable{name: SimpleMakeString("var2")},
},
},
sep: " ",
n: -1,
expected: []*MakeString{
SimpleMakeString("a"),
SimpleMakeString("b"),
&MakeString{
strings: []string{"c", "d"},
variables: []Variable{
variable{name: SimpleMakeString("var1")},
},
},
SimpleMakeString("e"),
&MakeString{
strings: []string{"f", ""},
variables: []Variable{
variable{name: SimpleMakeString("var2")},
},
},
SimpleMakeString("h"),
SimpleMakeString("i"),
SimpleMakeString("j"),
},
},
{
in: &MakeString{
strings: []string{
"a b c",
"d e f",
" h i j",
},
variables: []Variable{
variable{name: SimpleMakeString("var1")},
variable{name: SimpleMakeString("var2")},
},
},
sep: " ",
n: 3,
expected: []*MakeString{
SimpleMakeString("a"),
SimpleMakeString("b"),
&MakeString{
strings: []string{"c", "d e f", " h i j"},
variables: []Variable{
variable{name: SimpleMakeString("var1")},
variable{name: SimpleMakeString("var2")},
},
},
},
},
}
func TestMakeStringSplitN(t *testing.T) {
for _, test := range splitNTestCases {
got := test.in.SplitN(test.sep, test.n)
gotString := dumpArray(got)
expectedString := dumpArray(test.expected)
if gotString != expectedString {
t.Errorf("expected:\n%s\ngot:\n%s", expectedString, gotString)
}
}
}
func dumpArray(a []*MakeString) string {
ret := make([]string, len(a))
for i, s := range a {
ret[i] = s.Dump()
}
return strings.Join(ret, "|||")
}

142
androidmk/parser/makething.go Normal file
View file

@ -0,0 +1,142 @@
package parser
import (
"text/scanner"
)
type MakeThing interface {
AsAssignment() (Assignment, bool)
AsComment() (Comment, bool)
AsDirective() (Directive, bool)
AsRule() (Rule, bool)
AsVariable() (Variable, bool)
Dump() string
Pos() scanner.Position
EndPos() scanner.Position
}
type Assignment struct {
makeThing
Name *MakeString
Value *MakeString
Target *MakeString
Type string
}
type Comment struct {
makeThing
Comment string
}
type Directive struct {
makeThing
Name string
Args *MakeString
}
type Rule struct {
makeThing
Target *MakeString
Prerequisites *MakeString
Recipe string
}
type Variable struct {
makeThing
Name *MakeString
}
type makeThing struct {
pos scanner.Position
endPos scanner.Position
}
func (m makeThing) Pos() scanner.Position {
return m.pos
}
func (m makeThing) EndPos() scanner.Position {
return m.endPos
}
func (makeThing) AsAssignment() (a Assignment, ok bool) {
return
}
func (a Assignment) AsAssignment() (Assignment, bool) {
return a, true
}
func (a Assignment) Dump() string {
target := ""
if a.Target != nil {
target = a.Target.Dump() + ": "
}
return target + a.Name.Dump() + a.Type + a.Value.Dump()
}
func (makeThing) AsComment() (c Comment, ok bool) {
return
}
func (c Comment) AsComment() (Comment, bool) {
return c, true
}
func (c Comment) Dump() string {
return "#" + c.Comment
}
func (makeThing) AsDirective() (d Directive, ok bool) {
return
}
func (d Directive) AsDirective() (Directive, bool) {
return d, true
}
func (d Directive) Dump() string {
return d.Name + " " + d.Args.Dump()
}
func (makeThing) AsRule() (r Rule, ok bool) {
return
}
func (r Rule) AsRule() (Rule, bool) {
return r, true
}
func (r Rule) Dump() string {
recipe := ""
if r.Recipe != "" {
recipe = "\n" + r.Recipe
}
return "rule: " + r.Target.Dump() + ": " + r.Prerequisites.Dump() + recipe
}
func (makeThing) AsVariable() (v Variable, ok bool) {
return
}
func (v Variable) AsVariable() (Variable, bool) {
return v, true
}
func (v Variable) Dump() string {
return "$(" + v.Name.Dump() + ")"
}
type byPosition []MakeThing
func (s byPosition) Len() int {
return len(s)
}
func (s byPosition) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
func (s byPosition) Less(i, j int) bool {
return s[i].Pos().Offset < s[j].Pos().Offset
}

633
androidmk/parser/parser.go Normal file
View file

@ -0,0 +1,633 @@
package parser
import (
"errors"
"fmt"
"io"
"sort"
"text/scanner"
)
var errTooManyErrors = errors.New("too many errors")
const maxErrors = 100
type ParseError struct {
Err error
Pos scanner.Position
}
func (e *ParseError) Error() string {
return fmt.Sprintf("%s: %s", e.Pos, e.Err)
}
func (p *parser) Parse() ([]MakeThing, []error) {
defer func() {
if r := recover(); r != nil {
if r == errTooManyErrors {
return
}
panic(r)
}
}()
p.parseLines()
p.accept(scanner.EOF)
p.things = append(p.things, p.comments...)
sort.Sort(byPosition(p.things))
return p.things, p.errors
}
type parser struct {
scanner scanner.Scanner
tok rune
errors []error
comments []MakeThing
things []MakeThing
}
func NewParser(filename string, r io.Reader) *parser {
p := &parser{}
p.scanner.Init(r)
p.scanner.Error = func(sc *scanner.Scanner, msg string) {
p.errorf(msg)
}
p.scanner.Whitespace = 0
p.scanner.IsIdentRune = func(ch rune, i int) bool {
return ch > 0 && ch != ':' && ch != '#' && ch != '=' && ch != '+' && ch != '$' &&
ch != '\\' && ch != '(' && ch != ')' && ch != '{' && ch != '}' && ch != ';' &&
ch != '|' && ch != '?' && ch != '\r' && !isWhitespace(ch)
}
p.scanner.Mode = scanner.ScanIdents
p.scanner.Filename = filename
p.next()
return p
}
func (p *parser) errorf(format string, args ...interface{}) {
pos := p.scanner.Position
if !pos.IsValid() {
pos = p.scanner.Pos()
}
err := &ParseError{
Err: fmt.Errorf(format, args...),
Pos: pos,
}
p.errors = append(p.errors, err)
if len(p.errors) >= maxErrors {
panic(errTooManyErrors)
}
}
func (p *parser) accept(toks ...rune) bool {
for _, tok := range toks {
if p.tok != tok {
p.errorf("expected %s, found %s", scanner.TokenString(tok),
scanner.TokenString(p.tok))
return false
}
p.next()
}
return true
}
func (p *parser) next() {
if p.tok != scanner.EOF {
p.tok = p.scanner.Scan()
for p.tok == '\r' {
p.tok = p.scanner.Scan()
}
}
return
}
func (p *parser) parseLines() {
for {
p.ignoreWhitespace()
if p.parseDirective() {
continue
}
ident, _ := p.parseExpression('=', '?', ':', '#', '\n')
p.ignoreSpaces()
switch p.tok {
case '?':
p.accept('?')
if p.tok == '=' {
p.parseAssignment("?=", nil, ident)
} else {
p.errorf("expected = after ?")
}
case '+':
p.accept('+')
if p.tok == '=' {
p.parseAssignment("+=", nil, ident)
} else {
p.errorf("expected = after +")
}
case ':':
p.accept(':')
switch p.tok {
case '=':
p.parseAssignment(":=", nil, ident)
default:
p.parseRule(ident)
}
case '=':
p.parseAssignment("=", nil, ident)
case '#', '\n', scanner.EOF:
ident.TrimRightSpaces()
if v, ok := toVariable(ident); ok {
p.things = append(p.things, v)
} else if !ident.Empty() {
p.errorf("expected directive, rule, or assignment after ident " + ident.Dump())
}
switch p.tok {
case scanner.EOF:
return
case '\n':
p.accept('\n')
case '#':
p.parseComment()
}
default:
p.errorf("expected assignment or rule definition, found %s\n",
p.scanner.TokenText())
return
}
}
}
func (p *parser) parseDirective() bool {
if p.tok != scanner.Ident || !isDirective(p.scanner.TokenText()) {
return false
}
d := p.scanner.TokenText()
pos := p.scanner.Position
endPos := pos
p.accept(scanner.Ident)
expression := SimpleMakeString("", pos)
switch d {
case "endif", "endef", "else":
// Nothing
case "define":
expression = p.parseDefine()
default:
p.ignoreSpaces()
expression, endPos = p.parseExpression()
}
p.things = append(p.things, Directive{
makeThing: makeThing{
pos: pos,
endPos: endPos,
},
Name: d,
Args: expression,
})
return true
}
func (p *parser) parseDefine() *MakeString {
value := SimpleMakeString("", p.scanner.Position)
loop:
for {
switch p.tok {
case scanner.Ident:
if p.scanner.TokenText() == "endef" {
p.accept(scanner.Ident)
break loop
}
value.appendString(p.scanner.TokenText())
p.accept(scanner.Ident)
case '\\':
p.parseEscape()
switch p.tok {
case '\n':
value.appendString(" ")
case scanner.EOF:
p.errorf("expected escaped character, found %s",
scanner.TokenString(p.tok))
break loop
default:
value.appendString(`\` + string(p.tok))
}
p.accept(p.tok)
//TODO: handle variables inside defines? result depends if
//define is used in make or rule context
//case '$':
// variable := p.parseVariable()
// value.appendVariable(variable)
case scanner.EOF:
p.errorf("unexpected EOF while looking for endef")
break loop
default:
value.appendString(p.scanner.TokenText())
p.accept(p.tok)
}
}
return value
}
func (p *parser) parseEscape() {
p.scanner.Mode = 0
p.accept('\\')
p.scanner.Mode = scanner.ScanIdents
}
func (p *parser) parseExpression(end ...rune) (*MakeString, scanner.Position) {
value := SimpleMakeString("", p.scanner.Position)
endParen := false
for _, r := range end {
if r == ')' {
endParen = true
}
}
parens := 0
endPos := p.scanner.Position
loop:
for {
if endParen && parens > 0 && p.tok == ')' {
parens--
value.appendString(")")
endPos = p.scanner.Position
p.accept(')')
continue
}
for _, r := range end {
if p.tok == r {
break loop
}
}
switch p.tok {
case '\n':
break loop
case scanner.Ident:
value.appendString(p.scanner.TokenText())
endPos = p.scanner.Position
p.accept(scanner.Ident)
case '\\':
p.parseEscape()
switch p.tok {
case '\n':
value.appendString(" ")
case scanner.EOF:
p.errorf("expected escaped character, found %s",
scanner.TokenString(p.tok))
return value, endPos
default:
value.appendString(`\` + string(p.tok))
}
endPos = p.scanner.Position
p.accept(p.tok)
case '#':
p.parseComment()
break loop
case '$':
var variable Variable
variable, endPos = p.parseVariable()
value.appendVariable(variable)
case scanner.EOF:
break loop
case '(':
if endParen {
parens++
}
value.appendString("(")
endPos = p.scanner.Position
p.accept('(')
default:
value.appendString(p.scanner.TokenText())
endPos = p.scanner.Position
p.accept(p.tok)
}
}
if parens > 0 {
p.errorf("expected closing paren %s", value.Dump())
}
return value, endPos
}
func (p *parser) parseVariable() (Variable, scanner.Position) {
pos := p.scanner.Position
endPos := pos
p.accept('$')
var name *MakeString
switch p.tok {
case '(':
return p.parseBracketedVariable('(', ')', pos)
case '{':
return p.parseBracketedVariable('{', '}', pos)
case '$':
name = SimpleMakeString("__builtin_dollar", scanner.Position{})
case scanner.EOF:
p.errorf("expected variable name, found %s",
scanner.TokenString(p.tok))
default:
name, endPos = p.parseExpression(variableNameEndRunes...)
}
return p.nameToVariable(name, pos, endPos), endPos
}
func (p *parser) parseBracketedVariable(start, end rune, pos scanner.Position) (Variable, scanner.Position) {
p.accept(start)
name, endPos := p.parseExpression(end)
p.accept(end)
return p.nameToVariable(name, pos, endPos), endPos
}
func (p *parser) nameToVariable(name *MakeString, pos, endPos scanner.Position) Variable {
return Variable{
makeThing: makeThing{
pos: pos,
endPos: endPos,
},
Name: name,
}
}
func (p *parser) parseRule(target *MakeString) {
prerequisites, newLine := p.parseRulePrerequisites(target)
recipe := ""
endPos := p.scanner.Position
loop:
for {
if newLine {
if p.tok == '\t' {
endPos = p.scanner.Position
p.accept('\t')
newLine = false
continue loop
} else if p.parseDirective() {
newLine = false
continue
} else {
break loop
}
}
newLine = false
switch p.tok {
case '\\':
p.parseEscape()
recipe += string(p.tok)
endPos = p.scanner.Position
p.accept(p.tok)
case '\n':
newLine = true
recipe += "\n"
endPos = p.scanner.Position
p.accept('\n')
case scanner.EOF:
break loop
default:
recipe += p.scanner.TokenText()
endPos = p.scanner.Position
p.accept(p.tok)
}
}
if prerequisites != nil {
p.things = append(p.things, Rule{
makeThing: makeThing{
pos: target.Pos,
endPos: endPos,
},
Target: target,
Prerequisites: prerequisites,
Recipe: recipe,
})
}
}
func (p *parser) parseRulePrerequisites(target *MakeString) (*MakeString, bool) {
newLine := false
p.ignoreSpaces()
prerequisites, _ := p.parseExpression('#', '\n', ';', ':', '=')
switch p.tok {
case '\n':
p.accept('\n')
newLine = true
case '#':
p.parseComment()
newLine = true
case ';':
p.accept(';')
case ':':
p.accept(':')
if p.tok == '=' {
p.parseAssignment(":=", target, prerequisites)
return nil, true
} else {
more, _ := p.parseExpression('#', '\n', ';')
prerequisites.appendMakeString(more)
}
case '=':
p.parseAssignment("=", target, prerequisites)
return nil, true
default:
p.errorf("unexpected token %s after rule prerequisites", scanner.TokenString(p.tok))
}
return prerequisites, newLine
}
func (p *parser) parseComment() {
pos := p.scanner.Position
p.accept('#')
comment := ""
endPos := pos
loop:
for {
switch p.tok {
case '\\':
p.parseEscape()
if p.tok == '\n' {
comment += "\n"
} else {
comment += "\\" + p.scanner.TokenText()
}
endPos = p.scanner.Position
p.accept(p.tok)
case '\n':
endPos = p.scanner.Position
p.accept('\n')
break loop
case scanner.EOF:
break loop
default:
comment += p.scanner.TokenText()
endPos = p.scanner.Position
p.accept(p.tok)
}
}
p.comments = append(p.comments, Comment{
makeThing: makeThing{
pos: pos,
endPos: endPos,
},
Comment: comment,
})
}
func (p *parser) parseAssignment(t string, target *MakeString, ident *MakeString) {
// The value of an assignment is everything including and after the first
// non-whitespace character after the = until the end of the logical line,
// which may included escaped newlines
p.accept('=')
value, endPos := p.parseExpression()
value.TrimLeftSpaces()
if ident.EndsWith('+') && t == "=" {
ident.TrimRightOne()
t = "+="
}
ident.TrimRightSpaces()
p.things = append(p.things, Assignment{
makeThing: makeThing{
pos: ident.Pos,
endPos: endPos,
},
Name: ident,
Value: value,
Target: target,
Type: t,
})
}
type androidMkModule struct {
assignments map[string]string
}
type androidMkFile struct {
assignments map[string]string
modules []androidMkModule
includes []string
}
var directives = [...]string{
"define",
"else",
"endef",
"endif",
"ifdef",
"ifeq",
"ifndef",
"ifneq",
"include",
"-include",
}
var functions = [...]string{
"abspath",
"addprefix",
"addsuffix",
"basename",
"dir",
"notdir",
"subst",
"suffix",
"filter",
"filter-out",
"findstring",
"firstword",
"flavor",
"join",
"lastword",
"patsubst",
"realpath",
"shell",
"sort",
"strip",
"wildcard",
"word",
"wordlist",
"words",
"origin",
"foreach",
"call",
"info",
"error",
"warning",
"if",
"or",
"and",
"value",
"eval",
"file",
}
func init() {
sort.Strings(directives[:])
sort.Strings(functions[:])
}
func isDirective(s string) bool {
for _, d := range directives {
if s == d {
return true
} else if s < d {
return false
}
}
return false
}
func isFunctionName(s string) bool {
for _, f := range functions {
if s == f {
return true
} else if s < f {
return false
}
}
return false
}
func isWhitespace(ch rune) bool {
return ch == ' ' || ch == '\t' || ch == '\n'
}
func isValidVariableRune(ch rune) bool {
return ch != scanner.Ident && ch != ':' && ch != '=' && ch != '#'
}
var whitespaceRunes = []rune{' ', '\t', '\n'}
var variableNameEndRunes = append([]rune{':', '=', '#', ')', '}'}, whitespaceRunes...)
func (p *parser) ignoreSpaces() int {
skipped := 0
for p.tok == ' ' || p.tok == '\t' {
p.accept(p.tok)
skipped++
}
return skipped
}
func (p *parser) ignoreWhitespace() {
for isWhitespace(p.tok) {
p.accept(p.tok)
}
}

88
androidmk/parser/scope.go Normal file
View file

@ -0,0 +1,88 @@
package parser
import "strings"
type Scope interface {
Get(name string) string
Set(name, value string)
Call(name string, args []string) string
SetFunc(name string, f func([]string) string)
}
type scope struct {
variables map[string]string
functions map[string]func([]string) string
parent Scope
}
func (s *scope) Get(name string) string {
if val, ok := s.variables[name]; ok {
return val
} else if s.parent != nil {
return s.parent.Get(name)
} else if val, ok := builtinScope[name]; ok {
return val
} else {
return "<'" + name + "' unset>"
}
}
func (s *scope) Set(name, value string) {
s.variables[name] = value
}
func (s *scope) Call(name string, args []string) string {
if f, ok := s.functions[name]; ok {
return f(args)
}
return "<func:'" + name + "' unset>"
}
func (s *scope) SetFunc(name string, f func([]string) string) {
s.functions[name] = f
}
func NewScope(parent Scope) Scope {
return &scope{
variables: make(map[string]string),
functions: make(map[string]func([]string) string),
parent: parent,
}
}
var builtinScope map[string]string
func init() {
builtinScope := make(map[string]string)
builtinScope["__builtin_dollar"] = "$"
}
func (v Variable) Value(scope Scope) string {
f := v.Name.SplitN(" \t", 2)
if len(f) > 1 && f[0].Const() {
fname := f[0].Value(nil)
if isFunctionName(fname) {
args := f[1].Split(",")
argVals := make([]string, len(args))
for i, a := range args {
argVals[i] = a.Value(scope)
}
if fname == "call" {
return scope.Call(argVals[0], argVals[1:])
} else {
return "__builtin_func:" + fname + " " + strings.Join(argVals, " ")
}
}
}
return scope.Get(v.Name.Value(scope))
}
func toVariable(ms *MakeString) (Variable, bool) {
if len(ms.Variables) == 1 && ms.Strings[0] == "" && ms.Strings[1] == "" {
return ms.Variables[0], true
}
return Variable{}, false
}

165
build.ninja.in
View file

@ -50,6 +50,7 @@ rule g.bootstrap.link
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: blueprint
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/blueprint/Blueprints:1:1
@ -74,6 +75,7 @@ default .bootstrap/blueprint/pkg/blueprint.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: blueprint-bootstrap
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/blueprint/Blueprints:55:1
@ -96,6 +98,7 @@ default .bootstrap/blueprint-bootstrap/pkg/blueprint/bootstrap.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: blueprint-deptools
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/blueprint/Blueprints:34:1
@ -108,6 +111,7 @@ default .bootstrap/blueprint-deptools/pkg/blueprint/deptools.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: blueprint-parser
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/blueprint/Blueprints:23:1
@ -123,6 +127,7 @@ default .bootstrap/blueprint-parser/pkg/blueprint/parser.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: blueprint-pathtools
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/blueprint/Blueprints:40:1
@ -136,6 +141,7 @@ default .bootstrap/blueprint-pathtools/pkg/blueprint/pathtools.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: blueprint-proptools
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/blueprint/Blueprints:49:1
@ -148,6 +154,7 @@ default .bootstrap/blueprint-proptools/pkg/blueprint/proptools.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: bpfmt
# Variant:
# Type: bootstrap_go_binary
# Factory: blueprint/bootstrap.newGoBinaryModule
# Defined: build/blueprint/Blueprints:81:1
@ -170,6 +177,7 @@ default .bootstrap/bin/bpfmt
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: bpmodify
# Variant:
# Type: bootstrap_go_binary
# Factory: blueprint/bootstrap.newGoBinaryModule
# Defined: build/blueprint/Blueprints:87:1
@ -192,6 +200,7 @@ default .bootstrap/bin/bpmodify
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: minibp
# Variant:
# Type: bootstrap_go_binary
# Factory: blueprint/bootstrap.newGoBinaryModule
# Defined: build/blueprint/Blueprints:72:1
@ -217,14 +226,163 @@ default .bootstrap/minibp/obj/a.out
build .bootstrap/bin/minibp: g.bootstrap.cp .bootstrap/minibp/obj/a.out
default .bootstrap/bin/minibp
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: soong-cc
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/soong/Blueprints:79:1
build .bootstrap/soong-cc/pkg/android/soong/cc.a: g.bootstrap.gc $
${g.bootstrap.srcDir}/build/soong/cc/builder.go $
${g.bootstrap.srcDir}/build/soong/cc/cc.go $
${g.bootstrap.srcDir}/build/soong/cc/clang.go $
${g.bootstrap.srcDir}/build/soong/cc/toolchain.go $
${g.bootstrap.srcDir}/build/soong/cc/util.go $
${g.bootstrap.srcDir}/build/soong/cc/arm_device.go $
${g.bootstrap.srcDir}/build/soong/cc/arm64_device.go $
${g.bootstrap.srcDir}/build/soong/cc/x86_linux_host.go | $
${g.bootstrap.gcCmd} $
.bootstrap/blueprint-parser/pkg/blueprint/parser.a $
.bootstrap/blueprint-proptools/pkg/blueprint/proptools.a $
.bootstrap/blueprint/pkg/blueprint.a $
.bootstrap/blueprint-pathtools/pkg/blueprint/pathtools.a $
.bootstrap/blueprint-deptools/pkg/blueprint/deptools.a $
.bootstrap/blueprint-bootstrap/pkg/blueprint/bootstrap.a $
.bootstrap/soong-glob/pkg/android/soong/glob.a $
.bootstrap/soong-common/pkg/android/soong/common.a $
.bootstrap/soong-config/pkg/android/soong/config.a
incFlags = -I .bootstrap/blueprint-parser/pkg -I .bootstrap/blueprint-proptools/pkg -I .bootstrap/blueprint/pkg -I .bootstrap/blueprint-pathtools/pkg -I .bootstrap/blueprint-deptools/pkg -I .bootstrap/blueprint-bootstrap/pkg -I .bootstrap/soong-glob/pkg -I .bootstrap/soong-common/pkg -I .bootstrap/soong-config/pkg
pkgPath = android/soong/cc
default .bootstrap/soong-cc/pkg/android/soong/cc.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: soong-common
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/soong/Blueprints:49:1
build .bootstrap/soong-common/pkg/android/soong/common.a: g.bootstrap.gc $
${g.bootstrap.srcDir}/build/soong/common/arch.go $
${g.bootstrap.srcDir}/build/soong/common/defs.go $
${g.bootstrap.srcDir}/build/soong/common/glob.go $
${g.bootstrap.srcDir}/build/soong/common/module.go $
${g.bootstrap.srcDir}/build/soong/common/paths.go | $
${g.bootstrap.gcCmd} $
.bootstrap/blueprint-parser/pkg/blueprint/parser.a $
.bootstrap/blueprint-proptools/pkg/blueprint/proptools.a $
.bootstrap/blueprint/pkg/blueprint.a $
.bootstrap/blueprint-deptools/pkg/blueprint/deptools.a $
.bootstrap/blueprint-pathtools/pkg/blueprint/pathtools.a $
.bootstrap/blueprint-bootstrap/pkg/blueprint/bootstrap.a $
.bootstrap/soong-glob/pkg/android/soong/glob.a
incFlags = -I .bootstrap/blueprint-parser/pkg -I .bootstrap/blueprint-proptools/pkg -I .bootstrap/blueprint/pkg -I .bootstrap/blueprint-deptools/pkg -I .bootstrap/blueprint-pathtools/pkg -I .bootstrap/blueprint-bootstrap/pkg -I .bootstrap/soong-glob/pkg
pkgPath = android/soong/common
default .bootstrap/soong-common/pkg/android/soong/common.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: soong-config
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/soong/Blueprints:66:1
build .bootstrap/soong-config/pkg/android/soong/config.a: g.bootstrap.gc $
${g.bootstrap.srcDir}/build/soong/config/config.go | $
${g.bootstrap.gcCmd} $
.bootstrap/blueprint-parser/pkg/blueprint/parser.a $
.bootstrap/blueprint-proptools/pkg/blueprint/proptools.a $
.bootstrap/blueprint/pkg/blueprint.a $
.bootstrap/blueprint-deptools/pkg/blueprint/deptools.a $
.bootstrap/blueprint-pathtools/pkg/blueprint/pathtools.a $
.bootstrap/blueprint-bootstrap/pkg/blueprint/bootstrap.a $
.bootstrap/soong-glob/pkg/android/soong/glob.a $
.bootstrap/soong-common/pkg/android/soong/common.a
incFlags = -I .bootstrap/blueprint-parser/pkg -I .bootstrap/blueprint-proptools/pkg -I .bootstrap/blueprint/pkg -I .bootstrap/blueprint-deptools/pkg -I .bootstrap/blueprint-pathtools/pkg -I .bootstrap/blueprint-bootstrap/pkg -I .bootstrap/soong-glob/pkg -I .bootstrap/soong-common/pkg
pkgPath = android/soong/config
default .bootstrap/soong-config/pkg/android/soong/config.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: soong-glob
# Variant:
# Type: bootstrap_go_package
# Factory: blueprint/bootstrap.newGoPackageModule
# Defined: build/soong/Blueprints:38:1
build .bootstrap/soong-glob/pkg/android/soong/glob.a: g.bootstrap.gc $
${g.bootstrap.srcDir}/build/soong/glob/glob.go | ${g.bootstrap.gcCmd} $
.bootstrap/blueprint-deptools/pkg/blueprint/deptools.a
incFlags = -I .bootstrap/blueprint-deptools/pkg
pkgPath = android/soong/glob
default .bootstrap/soong-glob/pkg/android/soong/glob.a
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: soong_build
# Variant:
# Type: bootstrap_go_binary
# Factory: blueprint/bootstrap.newGoBinaryModule
# Defined: build/soong/Blueprints:13:1
build .bootstrap/soong_build/obj/soong_build.a: g.bootstrap.gc $
${g.bootstrap.srcDir}/build/soong/cmd/soong_build/main.go | $
${g.bootstrap.gcCmd} $
.bootstrap/blueprint-parser/pkg/blueprint/parser.a $
.bootstrap/blueprint-proptools/pkg/blueprint/proptools.a $
.bootstrap/blueprint/pkg/blueprint.a $
.bootstrap/blueprint-deptools/pkg/blueprint/deptools.a $
.bootstrap/blueprint-pathtools/pkg/blueprint/pathtools.a $
.bootstrap/blueprint-bootstrap/pkg/blueprint/bootstrap.a $
.bootstrap/soong-glob/pkg/android/soong/glob.a $
.bootstrap/soong-common/pkg/android/soong/common.a $
.bootstrap/soong-config/pkg/android/soong/config.a $
.bootstrap/soong-cc/pkg/android/soong/cc.a
incFlags = -I .bootstrap/blueprint-parser/pkg -I .bootstrap/blueprint-proptools/pkg -I .bootstrap/blueprint/pkg -I .bootstrap/blueprint-deptools/pkg -I .bootstrap/blueprint-pathtools/pkg -I .bootstrap/blueprint-bootstrap/pkg -I .bootstrap/soong-glob/pkg -I .bootstrap/soong-common/pkg -I .bootstrap/soong-config/pkg -I .bootstrap/soong-cc/pkg
pkgPath = soong_build
default .bootstrap/soong_build/obj/soong_build.a
build .bootstrap/soong_build/obj/a.out: g.bootstrap.link $
.bootstrap/soong_build/obj/soong_build.a | ${g.bootstrap.linkCmd}
libDirFlags = -L .bootstrap/blueprint-parser/pkg -L .bootstrap/blueprint-proptools/pkg -L .bootstrap/blueprint/pkg -L .bootstrap/blueprint-deptools/pkg -L .bootstrap/blueprint-pathtools/pkg -L .bootstrap/blueprint-bootstrap/pkg -L .bootstrap/soong-glob/pkg -L .bootstrap/soong-common/pkg -L .bootstrap/soong-config/pkg -L .bootstrap/soong-cc/pkg
default .bootstrap/soong_build/obj/a.out
build .bootstrap/bin/soong_build: g.bootstrap.cp $
.bootstrap/soong_build/obj/a.out
default .bootstrap/bin/soong_build
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Module: soong_glob
# Variant:
# Type: bootstrap_go_binary
# Factory: blueprint/bootstrap.newGoBinaryModule
# Defined: build/soong/Blueprints:28:1
build .bootstrap/soong_glob/obj/soong_glob.a: g.bootstrap.gc $
${g.bootstrap.srcDir}/build/soong/cmd/soong_glob/soong_glob.go | $
${g.bootstrap.gcCmd} $
.bootstrap/blueprint-deptools/pkg/blueprint/deptools.a $
.bootstrap/soong-glob/pkg/android/soong/glob.a
incFlags = -I .bootstrap/blueprint-deptools/pkg -I .bootstrap/soong-glob/pkg
pkgPath = soong_glob
default .bootstrap/soong_glob/obj/soong_glob.a
build .bootstrap/soong_glob/obj/a.out: g.bootstrap.link $
.bootstrap/soong_glob/obj/soong_glob.a | ${g.bootstrap.linkCmd}
libDirFlags = -L .bootstrap/blueprint-deptools/pkg -L .bootstrap/soong-glob/pkg
default .bootstrap/soong_glob/obj/a.out
build .bootstrap/bin/soong_glob: g.bootstrap.cp $
.bootstrap/soong_glob/obj/a.out
default .bootstrap/bin/soong_glob
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
# Singleton: bootstrap
# Factory: blueprint/bootstrap.newSingleton
rule s.bootstrap.bigbp
command = .bootstrap/bin/minibp -p -d .bootstrap/main.ninja.in.d -m ${g.bootstrap.bootstrapManifest} -o ${out} ${in}
command = .bootstrap/bin/soong_build -d .bootstrap/main.ninja.in.d -m ${g.bootstrap.bootstrapManifest} -o ${out} ${in}
depfile = .bootstrap/main.ninja.in.d
description = minibp ${out}
description = soong_build ${out}
rule s.bootstrap.minibp
command = .bootstrap/bin/minibp -c ${checkFile} -m ${g.bootstrap.bootstrapManifest} -d ${out}.d -o ${out} ${in}
@ -234,7 +392,8 @@ rule s.bootstrap.minibp
build .bootstrap/main.ninja.in: s.bootstrap.bigbp $
${g.bootstrap.srcDir}/Blueprints | .bootstrap/bin/bpfmt $
.bootstrap/bin/bpmodify .bootstrap/bin/minibp
.bootstrap/bin/bpmodify .bootstrap/bin/minibp $
.bootstrap/bin/soong_build .bootstrap/bin/soong_glob
default .bootstrap/main.ninja.in
build .bootstrap/notAFile: phony
default .bootstrap/notAFile

137
cc/arm64_device.go Normal file
View file

@ -0,0 +1,137 @@
package cc
import (
"strings"
"android/soong/common"
)
var (
arm64Cflags = []string{
"-fno-exceptions", // from build/core/combo/select.mk
"-Wno-multichar", // from build/core/combo/select.mk
"-fno-strict-aliasing",
"-fstack-protector",
"-ffunction-sections",
"-fdata-sections",
"-funwind-tables",
"-Wa,--noexecstack",
"-Werror=format-security",
"-D_FORTIFY_SOURCE=2",
"-fno-short-enums",
"-no-canonical-prefixes",
"-fno-canonical-system-headers",
"-include ${SrcDir}/build/core/combo/include/arch/linux-arm64/AndroidConfig.h",
// Help catch common 32/64-bit errors.
"-Werror=pointer-to-int-cast",
"-Werror=int-to-pointer-cast",
"-fno-strict-volatile-bitfields",
// TARGET_RELEASE_CFLAGS
"-DNDEBUG",
"-O2 -g",
"-Wstrict-aliasing=2",
"-fgcse-after-reload",
"-frerun-cse-after-loop",
"-frename-registers",
}
arm64Ldflags = []string{
"-Wl,-z,noexecstack",
"-Wl,-z,relro",
"-Wl,-z,now",
"-Wl,--build-id=md5",
"-Wl,--warn-shared-textrel",
"-Wl,--fatal-warnings",
"-Wl,-maarch64linux",
"-Wl,--hash-style=gnu",
// Disable transitive dependency library symbol resolving.
"-Wl,--allow-shlib-undefined",
}
arm64Cppflags = []string{
"-fvisibility-inlines-hidden",
}
)
func init() {
pctx.StaticVariable("arm64GccVersion", "4.9")
pctx.StaticVariable("arm64GccRoot",
"${SrcDir}/prebuilts/gcc/${HostPrebuiltTag}/aarch64/aarch64-linux-android-${arm64GccVersion}")
pctx.StaticVariable("arm64GccTriple", "aarch64-linux-android")
pctx.StaticVariable("arm64Cflags", strings.Join(arm64Cflags, " "))
pctx.StaticVariable("arm64Ldflags", strings.Join(arm64Ldflags, " "))
pctx.StaticVariable("arm64Cppflags", strings.Join(arm64Cppflags, " "))
pctx.StaticVariable("arm64IncludeFlags", strings.Join([]string{
"-isystem ${LibcRoot}/arch-arm64/include",
"-isystem ${LibcRoot}/include",
"-isystem ${LibcRoot}/kernel/uapi",
"-isystem ${LibcRoot}/kernel/uapi/asm-arm64",
"-isystem ${LibmRoot}/include",
"-isystem ${LibmRoot}/include/arm64",
}, " "))
pctx.StaticVariable("arm64ClangCflags", strings.Join(clangFilterUnknownCflags(arm64Cflags), " "))
pctx.StaticVariable("arm64ClangLdflags", strings.Join(clangFilterUnknownCflags(arm64Ldflags), " "))
pctx.StaticVariable("arm64ClangCppflags", strings.Join(clangFilterUnknownCflags(arm64Cppflags), " "))
}
type toolchainArm64 struct {
toolchain64Bit
}
var toolchainArm64Singleton = &toolchainArm64{}
func (t *toolchainArm64) GccRoot() string {
return "${arm64GccRoot}"
}
func (t *toolchainArm64) GccTriple() string {
return "${arm64GccTriple}"
}
func (t *toolchainArm64) Cflags() string {
return "${arm64Cflags} ${arm64IncludeFlags}"
}
func (t *toolchainArm64) Cppflags() string {
return "${arm64Cppflags}"
}
func (t *toolchainArm64) Ldflags() string {
return "${arm64Ldflags}"
}
func (t *toolchainArm64) IncludeFlags() string {
return "${arm64IncludeFlags}"
}
func (t *toolchainArm64) ClangTriple() string {
return "${arm64GccTriple}"
}
func (t *toolchainArm64) ClangCflags() string {
return "${arm64ClangCflags}"
}
func (t *toolchainArm64) ClangCppflags() string {
return "${arm64ClangCppflags}"
}
func (t *toolchainArm64) ClangLdflags() string {
return "${arm64Ldflags}"
}
func arm64ToolchainFactory(archVariant string, cpuVariant string) toolchain {
return toolchainArm64Singleton
}
func init() {
registerToolchainFactory(common.Device, common.Arm64, arm64ToolchainFactory)
}

301
cc/arm_device.go Normal file
View file

@ -0,0 +1,301 @@
package cc
import (
"fmt"
"strings"
"android/soong/common"
)
var (
armCflags = []string{
"-fno-exceptions", // from build/core/combo/select.mk
"-Wno-multichar", // from build/core/combo/select.mk
"-fno-strict-aliasing",
"-fstack-protector",
"-ffunction-sections",
"-fdata-sections",
"-funwind-tables",
"-fstack-protector",
"-Wa,--noexecstack",
"-Werror=format-security",
"-D_FORTIFY_SOURCE=2",
"-fno-short-enums",
"-no-canonical-prefixes",
"-fno-canonical-system-headers",
"-include ${SrcDir}/build/core/combo/include/arch/linux-arm/AndroidConfig.h",
"-fno-builtin-sin",
"-fno-strict-volatile-bitfields",
// TARGET_RELEASE_CFLAGS
"-DNDEBUG",
"-g",
"-Wstrict-aliasing=2",
"-fgcse-after-reload",
"-frerun-cse-after-loop",
"-frename-registers",
}
armCppflags = []string{
"-fvisibility-inlines-hidden",
}
armLdflags = []string{
"-Wl,-z,noexecstack",
"-Wl,-z,relro",
"-Wl,-z,now",
"-Wl,--build-id=md5",
"-Wl,--warn-shared-textrel",
"-Wl,--fatal-warnings",
"-Wl,-icf=safe",
"-Wl,--hash-style=gnu",
// Disable transitive dependency library symbol resolving.
"-Wl,--allow-shlib-undefined",
}
armArmCflags = []string{
"-O2",
"-fomit-frame-pointer",
"-fstrict-aliasing",
"-funswitch-loops",
}
armThumbCflags = []string{
"-mthumb",
"-Os",
"-fomit-frame-pointer",
"-fno-strict-aliasing",
}
armArchVariantCflags = map[string][]string{
"armv5te": []string{
"-march=armv5te",
"-mtune=xscale",
"-D__ARM_ARCH_5__",
"-D__ARM_ARCH_5T__",
"-D__ARM_ARCH_5E__",
"-D__ARM_ARCH_5TE__",
},
"armv7-a": []string{
"-march=armv7-a",
"-mfloat-abi=softfp",
"-mfpu=vfpv3-d16",
},
"armv7-a-neon": []string{
"-mfloat-abi=softfp",
"-mfpu=neon",
},
}
armArchVariantLdflags = map[string][]string{
"armv7-a": []string{
"-Wl,--fix-cortex-a8",
},
}
armCpuVariantCflags = map[string][]string{
"cortex-a7": []string{
"-mcpu=cortex-a7",
},
"cortex-a8": []string{
"-mcpu=cortex-a8",
},
"cortex-a15": []string{
"-mcpu=cortex-a15",
// Fake an ARM compiler flag as these processors support LPAE which GCC/clang
// don't advertise.
"-D__ARM_FEATURE_LPAE=1",
},
}
armClangCpuVariantCflags = armCpuVariantCflags
armClangArchVariantCflags = armArchVariantCflags
)
func init() {
replaceFirst := func(slice []string, from, to string) {
if slice[0] != from {
panic(fmt.Errorf("Expected %q, found %q", from, to))
}
slice[0] = to
}
replaceFirst(armClangArchVariantCflags["armv5te"], "-march=armv5te", "-march=armv5t")
replaceFirst(armClangCpuVariantCflags["cortex-a15"], "-mcpu=cortex-a15", "-march=armv7-a")
armClangCpuVariantCflags["krait"] = []string{
"-mcpu=krait",
}
pctx.StaticVariable("armGccVersion", "4.9")
pctx.StaticVariable("armGccRoot",
"${SrcDir}/prebuilts/gcc/${HostPrebuiltTag}/arm/arm-linux-androideabi-${armGccVersion}")
pctx.StaticVariable("armGccTriple", "arm-linux-androideabi")
pctx.StaticVariable("armCflags", strings.Join(armCflags, " "))
pctx.StaticVariable("armLdflags", strings.Join(armLdflags, " "))
pctx.StaticVariable("armCppflags", strings.Join(armCppflags, " "))
pctx.StaticVariable("armIncludeFlags", strings.Join([]string{
"-isystem ${LibcRoot}/arch-arm/include",
"-isystem ${LibcRoot}/include",
"-isystem ${LibcRoot}/kernel/uapi",
"-isystem ${LibcRoot}/kernel/uapi/asm-arm",
"-isystem ${LibmRoot}/include",
"-isystem ${LibmRoot}/include/arm",
}, " "))
// Extended cflags
// ARM mode vs. Thumb mode
pctx.StaticVariable("armArmCflags", strings.Join(armArmCflags, " "))
pctx.StaticVariable("armThumbCflags", strings.Join(armThumbCflags, " "))
// Architecture variant cflags
pctx.StaticVariable("armArmv5TECflags", strings.Join(armArchVariantCflags["armv5te"], " "))
pctx.StaticVariable("armArmv7ACflags", strings.Join(armArchVariantCflags["armv7-a"], " "))
pctx.StaticVariable("armArmv7ANeonCflags", strings.Join(armArchVariantCflags["armv7-a-neon"], " "))
// Architecture variant ldflags
pctx.StaticVariable("armArmv7ALdflags", strings.Join(armArchVariantLdflags["armv7-a"], " "))
// Cpu variant cflags
pctx.StaticVariable("armCortexA7Cflags", strings.Join(armCpuVariantCflags["cortex-a7"], " "))
pctx.StaticVariable("armCortexA8Cflags", strings.Join(armCpuVariantCflags["cortex-a8"], " "))
pctx.StaticVariable("armCortexA15Cflags", strings.Join(armCpuVariantCflags["cortex-a15"], " "))
// Clang cflags
pctx.StaticVariable("armClangCflags", strings.Join(clangFilterUnknownCflags(armCflags), " "))
pctx.StaticVariable("armClangLdflags", strings.Join(clangFilterUnknownCflags(armLdflags), " "))
pctx.StaticVariable("armClangCppflags", strings.Join(clangFilterUnknownCflags(armCppflags), " "))
// Clang cpu variant cflags
pctx.StaticVariable("armClangArmv5TECflags",
strings.Join(armClangArchVariantCflags["armv5te"], " "))
pctx.StaticVariable("armClangArmv7ACflags",
strings.Join(armClangArchVariantCflags["armv7-a"], " "))
pctx.StaticVariable("armClangArmv7ANeonCflags",
strings.Join(armClangArchVariantCflags["armv7-a-neon"], " "))
// Clang cpu variant cflags
pctx.StaticVariable("armClangCortexA7Cflags",
strings.Join(armClangCpuVariantCflags["cortex-a7"], " "))
pctx.StaticVariable("armClangCortexA8Cflags",
strings.Join(armClangCpuVariantCflags["cortex-a8"], " "))
pctx.StaticVariable("armClangCortexA15Cflags",
strings.Join(armClangCpuVariantCflags["cortex-a15"], " "))
pctx.StaticVariable("armClangKraitCflags",
strings.Join(armClangCpuVariantCflags["krait"], " "))
}
var (
armArchVariantCflagsVar = map[string]string{
"armv5te": "${armArmv5TECflags}",
"armv7-a": "${armArmv7ACflags}",
"armv7-a-neon": "${armArmv7ANeonCflags}",
}
armArchVariantLdflagsVar = map[string]string{
"armv7-a": "${armArmv7ALdflags}",
"armv7-a-neon": "${armArmv7ALdflags}",
}
armCpuVariantCflagsVar = map[string]string{
"": "",
"cortex-a7": "${armCortexA7Cflags}",
"cortex-a8": "${armCortexA8Cflags}",
"cortex-a15": "${armCortexA15Cflags}",
"krait": "${armCortexA15Cflags}",
"denver": "${armCortexA15Cflags}",
}
armClangArchVariantCflagsVar = map[string]string{
"armv5te": "${armClangArmv5TECflags}",
"armv7-a": "${armClangArmv7ACflags}",
"armv7-a-neon": "${armClangArmv7ANeonCflags}",
}
armClangCpuVariantCflagsVar = map[string]string{
"": "",
"cortex-a7": "${armClangCortexA7Cflags}",
"cortex-a8": "${armClangCortexA8Cflags}",
"cortex-a15": "${armClangCortexA15Cflags}",
"krait": "${armClangKraitCflags}",
"denver": "${armClangCortexA15Cflags}",
}
)
type toolchainArm struct {
toolchain32Bit
cflags, ldflags, clangCflags string
}
func (t *toolchainArm) GccRoot() string {
return "${armGccRoot}"
}
func (t *toolchainArm) GccTriple() string {
return "${armGccTriple}"
}
func (t *toolchainArm) Cflags() string {
return t.cflags
}
func (t *toolchainArm) Cppflags() string {
return "${armCppflags}"
}
func (t *toolchainArm) Ldflags() string {
return t.ldflags
}
func (t *toolchainArm) IncludeFlags() string {
return "${armIncludeFlags}"
}
func (t *toolchainArm) ClangTriple() string {
return "${armGccTriple}"
}
func (t *toolchainArm) ClangCflags() string {
return t.clangCflags
}
func (t *toolchainArm) ClangCppflags() string {
return "${armClangCppflags}"
}
func (t *toolchainArm) ClangLdflags() string {
return t.ldflags
}
func armToolchainFactory(archVariant string, cpuVariant string) toolchain {
return &toolchainArm{
cflags: strings.Join([]string{
"${armCflags}",
"${armIncludeFlags}",
"${armThumbCflags}",
armArchVariantCflagsVar[archVariant],
armCpuVariantCflagsVar[cpuVariant],
}, " "),
ldflags: strings.Join([]string{
"${armLdflags}",
armArchVariantLdflagsVar[archVariant],
}, " "),
clangCflags: strings.Join([]string{
"${armClangCflags}",
"${armIncludeFlags}",
"${armThumbCflags}",
armClangArchVariantCflagsVar[archVariant],
armClangCpuVariantCflagsVar[cpuVariant],
}, " "),
}
}
func init() {
registerToolchainFactory(common.Device, common.Arm, armToolchainFactory)
}

285
cc/builder.go Normal file
View file

@ -0,0 +1,285 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 cc
// This file generates the final rules for compiling all C/C++. All properties related to
// compiling should have been translated into builderFlags or another argument to the Transform*
// functions.
import (
"android/soong/common"
"blueprint"
"blueprint/pathtools"
"path/filepath"
"strings"
)
const (
sharedLibraryExtension = ".so"
staticLibraryExtension = ".a"
)
var (
pctx = blueprint.NewPackageContext("android/soong/cc")
cc = pctx.StaticRule("cc",
blueprint.RuleParams{
Depfile: "${out}.d",
Deps: blueprint.DepsGCC,
Command: "$ccCmd $incFlags -c $cFlags -MD -MF ${out}.d -o $out $in",
Description: "cc $out",
},
"ccCmd", "incFlags", "cFlags")
ld = pctx.StaticRule("ld",
blueprint.RuleParams{
Command: "$ldCmd ${ldDirFlags} ${crtBegin} ${in} " +
"${libFlags} ${crtEnd} -o ${out} ${ldFlags} ${ldLibs}",
Description: "ld $out",
},
"ldCmd", "ldDirFlags", "crtBegin", "libFlags", "crtEnd", "ldFlags", "ldLibs")
partialLd = pctx.StaticRule("partialLd",
blueprint.RuleParams{
Command: "$ldCmd -r ${in} -o ${out}",
Description: "partialLd $out",
},
"ldCmd")
ar = pctx.StaticRule("ar",
blueprint.RuleParams{
Command: "rm -f ${out} && $arCmd $arFlags $out $in",
Description: "ar $out",
},
"arCmd", "arFlags")
copyGccLibPath = pctx.StaticVariable("copyGccLibPath", "${SrcDir}/build/soong/copygcclib.sh")
copyGccLib = pctx.StaticRule("copyGccLib",
blueprint.RuleParams{
Depfile: "${out}.d",
Deps: blueprint.DepsGCC,
Command: "$copyGccLibPath $out $ccCmd $cFlags -print-file-name=${libName}",
Description: "copy gcc $out",
},
"ccCmd", "cFlags", "libName")
)
type builderFlags struct {
globalFlags string
asFlags string
cFlags string
conlyFlags string
cppFlags string
ldFlags string
ldLibs string
incFlags string
nocrt bool
toolchain toolchain
clang bool
}
// Generate rules for compiling multiple .c, .cpp, or .S files to individual .o files
func TransformSourceToObj(ctx common.AndroidModuleContext, subdir string, srcFiles []string,
flags builderFlags) (objFiles []string) {
objFiles = make([]string, len(srcFiles))
objDir := common.ModuleObjDir(ctx)
if subdir != "" {
objDir = filepath.Join(objDir, subdir)
}
cflags := flags.globalFlags + " " + flags.cFlags + " " + flags.conlyFlags
cppflags := flags.globalFlags + " " + flags.cFlags + " " + flags.cppFlags
asflags := flags.globalFlags + " " + flags.asFlags
for i, srcFile := range srcFiles {
objFile := strings.TrimPrefix(srcFile, common.ModuleSrcDir(ctx))
objFile = filepath.Join(objDir, objFile)
objFile = pathtools.ReplaceExtension(objFile, "o")
objFiles[i] = objFile
var moduleCflags string
var ccCmd string
switch filepath.Ext(srcFile) {
case ".S", ".s":
ccCmd = "gcc"
moduleCflags = asflags
case ".c":
ccCmd = "gcc"
moduleCflags = cflags
case ".cpp", ".cc":
ccCmd = "g++"
moduleCflags = cppflags
default:
ctx.ModuleErrorf("File %s has unknown extension", srcFile)
continue
}
if flags.clang {
switch ccCmd {
case "gcc":
ccCmd = "clang"
case "g++":
ccCmd = "clang++"
default:
panic("unrecoginzied ccCmd")
}
ccCmd = "${clangPath}" + ccCmd
} else {
ccCmd = gccCmd(flags.toolchain, ccCmd)
}
ctx.Build(pctx, blueprint.BuildParams{
Rule: cc,
Outputs: []string{objFile},
Inputs: []string{srcFile},
Implicits: []string{ccCmd},
Args: map[string]string{
"cFlags": moduleCflags,
"incFlags": flags.incFlags,
"ccCmd": ccCmd,
},
})
}
return objFiles
}
// Generate a rule for compiling multiple .o files to a static library (.a)
func TransformObjToStaticLib(ctx common.AndroidModuleContext, objFiles []string,
flags builderFlags, outputFile string) {
arCmd := gccCmd(flags.toolchain, "ar")
arFlags := "crsPD"
ctx.Build(pctx, blueprint.BuildParams{
Rule: ar,
Outputs: []string{outputFile},
Inputs: objFiles,
Implicits: []string{arCmd},
Args: map[string]string{
"arFlags": arFlags,
"arCmd": arCmd,
},
})
}
// Generate a rule for compiling multiple .o files, plus static libraries, whole static libraries,
// and shared libraires, to a shared library (.so) or dynamic executable
func TransformObjToDynamicBinary(ctx common.AndroidModuleContext,
objFiles, sharedLibs, staticLibs, wholeStaticLibs []string, crtBegin, crtEnd string,
flags builderFlags, outputFile string) {
var ldCmd string
if flags.clang {
ldCmd = "${clangPath}clang++"
} else {
ldCmd = gccCmd(flags.toolchain, "g++")
}
var ldDirs []string
var libFlagsList []string
if len(wholeStaticLibs) > 0 {
libFlagsList = append(libFlagsList, "-Wl,--whole-archive ")
libFlagsList = append(libFlagsList, wholeStaticLibs...)
libFlagsList = append(libFlagsList, "-Wl,--no-whole-archive ")
}
libFlagsList = append(libFlagsList, staticLibs...)
for _, lib := range sharedLibs {
dir, file := filepath.Split(lib)
if !strings.HasPrefix(file, "lib") {
panic("shared library " + lib + " does not start with lib")
}
if !strings.HasSuffix(file, sharedLibraryExtension) {
panic("shared library " + lib + " does not end with " + sharedLibraryExtension)
}
libFlagsList = append(libFlagsList,
"-l"+strings.TrimSuffix(strings.TrimPrefix(file, "lib"), sharedLibraryExtension))
ldDirs = append(ldDirs, dir)
}
deps := []string{ldCmd}
deps = append(deps, sharedLibs...)
deps = append(deps, staticLibs...)
deps = append(deps, wholeStaticLibs...)
if crtBegin != "" {
deps = append(deps, crtBegin, crtEnd)
}
ctx.Build(pctx, blueprint.BuildParams{
Rule: ld,
Outputs: []string{outputFile},
Inputs: objFiles,
Implicits: deps,
Args: map[string]string{
"ldCmd": ldCmd,
"ldDirFlags": ldDirsToFlags(ldDirs),
"crtBegin": crtBegin,
"libFlags": strings.Join(libFlagsList, " "),
"ldFlags": flags.ldFlags,
"crtEnd": crtEnd,
"ldLibs": flags.ldLibs,
},
})
}
// Generate a rule for compiling multiple .o files to a .o using ld partial linking
func TransformObjsToObj(ctx common.AndroidModuleContext, objFiles []string,
flags builderFlags, outputFile string) {
ldCmd := gccCmd(flags.toolchain, "ld")
deps := []string{ldCmd}
ctx.Build(pctx, blueprint.BuildParams{
Rule: partialLd,
Outputs: []string{outputFile},
Inputs: objFiles,
Implicits: deps,
Args: map[string]string{
"ldCmd": ldCmd,
},
})
}
func CopyGccLib(ctx common.AndroidModuleContext, libName string,
flags builderFlags, outputFile string) {
ctx.Build(pctx, blueprint.BuildParams{
Rule: copyGccLib,
Outputs: []string{outputFile},
Implicits: []string{
"$copyGccLibPath",
gccCmd(flags.toolchain, "gcc"),
},
Args: map[string]string{
"ccCmd": gccCmd(flags.toolchain, "gcc"),
"cFlags": flags.globalFlags,
"libName": libName,
},
})
}
func gccCmd(toolchain toolchain, cmd string) string {
return filepath.Join(toolchain.GccRoot(), "bin", toolchain.GccTriple()+"-"+cmd)
}

1194
cc/cc.go Normal file
View file

File diff suppressed because it is too large Load diff

104
cc/clang.go Normal file
View file

@ -0,0 +1,104 @@
package cc
import (
"sort"
"strings"
)
// Cflags that should be filtered out when compiling with clang
var clangUnknownCflags = []string{
"-finline-functions",
"-finline-limit=64",
"-fno-canonical-system-headers",
"-fno-tree-sra",
"-funswitch-loops",
"-Wmaybe-uninitialized",
"-Wno-error=maybe-uninitialized",
"-Wno-free-nonheap-object",
"-Wno-literal-suffix",
"-Wno-maybe-uninitialized",
"-Wno-old-style-declaration",
"-Wno-psabi",
"-Wno-unused-but-set-variable",
"-Wno-unused-but-set-parameter",
"-Wno-unused-local-typedefs",
// arm + arm64 + mips + mips64
"-fgcse-after-reload",
"-frerun-cse-after-loop",
"-frename-registers",
"-fno-strict-volatile-bitfields",
// arm + arm64
"-fno-align-jumps",
"-Wa,--noexecstack",
// arm
"-mthumb-interwork",
"-fno-builtin-sin",
"-fno-caller-saves",
"-fno-early-inlining",
"-fno-move-loop-invariants",
"-fno-partial-inlining",
"-fno-tree-copy-prop",
"-fno-tree-loop-optimize",
// mips + mips64
"-msynci",
"-mno-fused-madd",
// x86 + x86_64
"-finline-limit=300",
"-fno-inline-functions-called-once",
"-mfpmath=sse",
"-mbionic",
}
func init() {
sort.Strings(clangUnknownCflags)
pctx.StaticVariable("clangExtraCflags", strings.Join([]string{
"-D__compiler_offsetof=__builtin_offsetof",
// Help catch common 32/64-bit errors.
"-Werror=int-conversion",
// Workaround for ccache with clang.
// See http://petereisentraut.blogspot.com/2011/05/ccache-and-clang.html.
"-Wno-unused-command-line-argument",
// Disable -Winconsistent-missing-override until we can clean up the existing
// codebase for it.
"-Wno-inconsistent-missing-override",
}, " "))
pctx.StaticVariable("clangExtraConlyflags", strings.Join([]string{
"-std=gnu99",
}, " "))
pctx.StaticVariable("clangExtraTargetCflags", strings.Join([]string{
"-nostdlibinc",
}, " "))
}
func clangFilterUnknownCflags(cflags []string) []string {
ret := make([]string, 0, len(cflags))
for _, f := range cflags {
if !inListSorted(f, clangUnknownCflags) {
ret = append(ret, f)
}
}
return ret
}
func inListSorted(s string, list []string) bool {
for _, l := range list {
if s == l {
return true
} else if s < l {
return false
}
}
return false
}

62
cc/toolchain.go Normal file
View file

@ -0,0 +1,62 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 cc
import (
"android/soong/common"
)
type toolchainFactory func(archVariant string, cpuVariant string) toolchain
var toolchainFactories = map[common.HostOrDevice]map[common.ArchType]toolchainFactory{
common.Host: make(map[common.ArchType]toolchainFactory),
common.Device: make(map[common.ArchType]toolchainFactory),
}
func registerToolchainFactory(hod common.HostOrDevice, arch common.ArchType,
factory toolchainFactory) {
toolchainFactories[hod][arch] = factory
}
type toolchain interface {
GccRoot() string
GccTriple() string
Cflags() string
Cppflags() string
Ldflags() string
IncludeFlags() string
ClangTriple() string
ClangCflags() string
ClangCppflags() string
ClangLdflags() string
Is64Bit() bool
}
type toolchain64Bit struct {
}
func (toolchain64Bit) Is64Bit() bool {
return true
}
type toolchain32Bit struct {
}
func (toolchain32Bit) Is64Bit() bool {
return false
}

96
cc/util.go Normal file
View file

@ -0,0 +1,96 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 cc
import (
"fmt"
"regexp"
"strings"
)
// Efficiently converts a list of include directories to a single string
// of cflags with -I prepended to each directory.
func includeDirsToFlags(dirs []string) string {
return joinWithPrefix(dirs, "-I")
}
func ldDirsToFlags(dirs []string) string {
return joinWithPrefix(dirs, "-L")
}
func libNamesToFlags(names []string) string {
return joinWithPrefix(names, "-l")
}
func joinWithPrefix(strs []string, prefix string) string {
if len(strs) == 0 {
return ""
}
if len(strs) == 1 {
return prefix + strs[0]
}
n := len(" ") * (len(strs) - 1)
for _, s := range strs {
n += len(prefix) + len(s)
}
ret := make([]byte, 0, n)
for i, s := range strs {
if i != 0 {
ret = append(ret, ' ')
}
ret = append(ret, prefix...)
ret = append(ret, s...)
}
return string(ret)
}
func inList(s string, list []string) bool {
for _, l := range list {
if l == s {
return true
}
}
return false
}
var libNameRegexp = regexp.MustCompile(`^lib(.*)$`)
func moduleToLibName(module string) (string, error) {
matches := libNameRegexp.FindStringSubmatch(module)
if matches == nil {
return "", fmt.Errorf("Library module name %s does not start with lib", module)
}
return matches[1], nil
}
func ccFlagsToBuilderFlags(in ccFlags) builderFlags {
return builderFlags{
globalFlags: strings.Join(in.globalFlags, " "),
asFlags: strings.Join(in.asFlags, " "),
cFlags: strings.Join(in.cFlags, " "),
conlyFlags: strings.Join(in.conlyFlags, " "),
cppFlags: strings.Join(in.cppFlags, " "),
ldFlags: strings.Join(in.ldFlags, " "),
ldLibs: strings.Join(in.ldLibs, " "),
incFlags: includeDirsToFlags(in.includeDirs),
nocrt: in.nocrt,
toolchain: in.toolchain,
clang: in.clang,
}
}

231
cc/x86_linux_host.go Normal file
View file

@ -0,0 +1,231 @@
package cc
import (
"runtime"
"strings"
"android/soong/common"
)
var (
linuxCflags = []string{
"-fno-exceptions", // from build/core/combo/select.mk
"-Wno-multichar", // from build/core/combo/select.mk
"-Wa,--noexecstack",
"-fPIC",
"-no-canonical-prefixes",
"-include ${SrcDir}/build/core/combo/include/arch/linux-x86/AndroidConfig.h",
// Disable new longjmp in glibc 2.11 and later. See bug 2967937. Same for 2.15?
"-U_FORTIFY_SOURCE",
"-D_FORTIFY_SOURCE=0",
// Workaround differences in inttypes.h between host and target.
//See bug 12708004.
"-D__STDC_FORMAT_MACROS",
"-D__STDC_CONSTANT_MACROS",
// HOST_RELEASE_CFLAGS
"-O2", // from build/core/combo/select.mk
"-g", // from build/core/combo/select.mk
"-fno-strict-aliasing", // from build/core/combo/select.mk
}
linuxLdflags = []string{
"-Wl,-z,noexecstack",
"-Wl,-z,relro",
"-Wl,-z,now",
"-Wl,--build-id=md5",
"-Wl,--warn-shared-textrel",
"-Wl,--fatal-warnings",
"-Wl,-icf=safe",
"-Wl,--hash-style=gnu",
// Disable transitive dependency library symbol resolving.
"-Wl,--allow-shlib-undefined",
}
// Extended cflags
linuxX86Cflags = []string{
"-msse3",
"-mfpmath=sse",
"-m32",
"-march=prescott",
}
linuxX8664Cflags = []string{
"-m64",
}
linuxX86Ldflags = []string{
"-m32",
}
linuxX8664Ldflags = []string{
"-m64",
}
linuxClangCflags = append([]string{
"--gcc-toolchain=${linuxGccRoot}",
"--sysroot=${linuxGccRoot}/sysroot",
}, clangFilterUnknownCflags(linuxCflags)...)
linuxClangLdflags = append([]string{
"--gcc-toolchain=${linuxGccRoot}",
"--sysroot=${linuxGccRoot}/sysroot",
}, clangFilterUnknownCflags(linuxLdflags)...)
linuxX86ClangLdflags = append([]string{
"-B${linuxGccRoot}/lib/gcc/${linuxGccTriple}/${linuxGccVersion}/32",
"-L${linuxGccRoot}/lib/gcc/${linuxGccTriple}/${linuxGccVersion}/32",
"-L${linuxGccRoot}/${linuxGccTriple}/lib32",
}, clangFilterUnknownCflags(linuxX86Ldflags)...)
linuxX8664ClangLdflags = append([]string{
"-B${linuxGccRoot}/lib/gcc/${linuxGccTriple}/${linuxGccVersion}",
"-L${linuxGccRoot}/lib/gcc/${linuxGccTriple}/${linuxGccVersion}",
"-L${linuxGccRoot}/${linuxGccTriple}/lib64",
}, clangFilterUnknownCflags(linuxX8664Ldflags)...)
linuxClangCppflags = []string{
"-isystem ${linuxGccRoot}/${linuxGccTriple}/include/c++/${linuxGccVersion}",
"-isystem ${linuxGccRoot}/${linuxGccTriple}/include/c++/${linuxGccVersion}/backward",
}
linuxX86ClangCppflags = []string{
"-isystem ${linuxGccRoot}/${linuxGccTriple}/include/c++/${linuxGccVersion}/${linuxGccTriple}/32",
}
linuxX8664ClangCppflags = []string{
"-isystem ${linuxGccRoot}/${linuxGccTriple}/include/c++/${linuxGccVersion}/${linuxGccTriple}",
}
)
func init() {
pctx.StaticVariable("linuxGccVersion", "4.8")
pctx.StaticVariable("linuxGccRoot",
"${SrcDir}/prebuilts/gcc/${HostPrebuiltTag}/host/x86_64-linux-glibc2.15-${linuxGccVersion}")
pctx.StaticVariable("linuxGccTriple", "x86_64-linux")
pctx.StaticVariable("linuxCflags", strings.Join(linuxCflags, " "))
pctx.StaticVariable("linuxLdflags", strings.Join(linuxLdflags, " "))
pctx.StaticVariable("linuxClangCflags", strings.Join(linuxClangCflags, " "))
pctx.StaticVariable("linuxClangLdflags", strings.Join(linuxClangLdflags, " "))
pctx.StaticVariable("linuxClangCppflags", strings.Join(linuxClangCppflags, " "))
// Extended cflags
pctx.StaticVariable("linuxX86Cflags", strings.Join(linuxX86Cflags, " "))
pctx.StaticVariable("linuxX8664Cflags", strings.Join(linuxX8664Cflags, " "))
pctx.StaticVariable("linuxX86Ldflags", strings.Join(linuxX86Ldflags, " "))
pctx.StaticVariable("linuxX8664Ldflags", strings.Join(linuxX8664Ldflags, " "))
pctx.StaticVariable("linuxX86ClangCflags",
strings.Join(clangFilterUnknownCflags(linuxX86Cflags), " "))
pctx.StaticVariable("linuxX8664ClangCflags",
strings.Join(clangFilterUnknownCflags(linuxX8664Cflags), " "))
pctx.StaticVariable("linuxX86ClangLdflags", strings.Join(linuxX86ClangLdflags, " "))
pctx.StaticVariable("linuxX8664ClangLdflags", strings.Join(linuxX8664ClangLdflags, " "))
pctx.StaticVariable("linuxX86ClangCppflags", strings.Join(linuxX86ClangCppflags, " "))
pctx.StaticVariable("linuxX8664ClangCppflags", strings.Join(linuxX8664ClangCppflags, " "))
}
type toolchainLinux struct {
cFlags, ldFlags string
}
type toolchainLinuxX86 struct {
toolchain32Bit
toolchainLinux
}
type toolchainLinuxX8664 struct {
toolchain64Bit
toolchainLinux
}
func (t *toolchainLinux) GccRoot() string {
return "${linuxGccRoot}"
}
func (t *toolchainLinux) GccTriple() string {
return "${linuxGccTriple}"
}
func (t *toolchainLinuxX86) Cflags() string {
return "${linuxCflags} ${linuxX86Cflags}"
}
func (t *toolchainLinuxX8664) Cflags() string {
return "${linuxCflags} ${linuxX8664Cflags}"
}
func (t *toolchainLinux) Cppflags() string {
return ""
}
func (t *toolchainLinuxX86) Ldflags() string {
return "${linuxLdflags} ${linuxX86Ldflags}"
}
func (t *toolchainLinuxX8664) Ldflags() string {
return "${linuxLdflags} ${linuxX8664Ldflags}"
}
func (t *toolchainLinux) IncludeFlags() string {
return ""
}
func (t *toolchainLinuxX86) ClangTriple() string {
return "i686-linux-gnu"
}
func (t *toolchainLinuxX86) ClangCflags() string {
return "${linuxClangCflags} ${linuxX86ClangCflags}"
}
func (t *toolchainLinuxX86) ClangCppflags() string {
return "${linuxClangCppflags} ${linuxX86ClangCppflags}"
}
func (t *toolchainLinuxX8664) ClangTriple() string {
return "x86_64-linux-gnu"
}
func (t *toolchainLinuxX8664) ClangCflags() string {
return "${linuxClangCflags} ${linuxX8664ClangCflags}"
}
func (t *toolchainLinuxX8664) ClangCppflags() string {
return "${linuxClangCppflags} ${linuxX8664ClangCppflags}"
}
func (t *toolchainLinuxX86) ClangLdflags() string {
return "${linuxClangLdflags} ${linuxX86ClangLdflags}"
}
func (t *toolchainLinuxX8664) ClangLdflags() string {
return "${linuxClangLdflags} ${linuxX8664ClangLdflags}"
}
var toolchainLinuxX86Singleton toolchain = &toolchainLinuxX86{}
var toolchainLinuxX8664Singleton toolchain = &toolchainLinuxX8664{}
func linuxX86ToolchainFactory(archVariant string, cpuVariant string) toolchain {
return toolchainLinuxX86Singleton
}
func linuxX8664ToolchainFactory(archVariant string, cpuVariant string) toolchain {
return toolchainLinuxX8664Singleton
}
func init() {
if runtime.GOOS == "linux" {
registerToolchainFactory(common.Host, common.X86, linuxX86ToolchainFactory)
registerToolchainFactory(common.Host, common.X86_64, linuxX8664ToolchainFactory)
}
}

68
cmd/soong_build/main.go Normal file
View file

@ -0,0 +1,68 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 main
import (
"flag"
"fmt"
"os"
"path/filepath"
"blueprint"
"blueprint/bootstrap"
"android/soong/cc"
"android/soong/common"
"android/soong/config"
)
func main() {
flag.Parse()
// The top-level Blueprints file is passed as the first argument.
srcDir := filepath.Dir(flag.Arg(0))
ctx := blueprint.NewContext()
// Module types
ctx.RegisterModuleType("cc_library_static", cc.NewCCLibraryStatic)
ctx.RegisterModuleType("cc_library_shared", cc.NewCCLibraryShared)
ctx.RegisterModuleType("cc_library", cc.NewCCLibrary)
ctx.RegisterModuleType("cc_object", cc.NewCCObject)
ctx.RegisterModuleType("cc_binary", cc.NewCCBinary)
ctx.RegisterModuleType("toolchain_library", cc.NewToolchainLibrary)
ctx.RegisterModuleType("cc_library_host_static", cc.NewCCLibraryHostStatic)
ctx.RegisterModuleType("cc_library_host_shared", cc.NewCCLibraryHostShared)
ctx.RegisterModuleType("cc_binary_host", cc.NewCCBinaryHost)
// Mutators
ctx.RegisterEarlyMutator("arch", common.ArchMutator)
ctx.RegisterEarlyMutator("link", cc.LinkageMutator)
// Singletons
configuration, err := config.New(srcDir)
if err != nil {
fmt.Fprintf(os.Stderr, "%s", err)
os.Exit(1)
}
// Temporary hack
//ctx.SetIgnoreUnknownModuleTypes(true)
bootstrap.Main(ctx, configuration, config.ConfigFileName)
}

56
cmd/soong_glob/soong_glob.go Normal file
View file

@ -0,0 +1,56 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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.
// soong_glob is the command line tool that checks if the list of files matching a glob has
// changed, and only updates the output file list if it has changed. It is used to optimize
// out build.ninja regenerations when non-matching files are added. See
// android/soong/common/glob.go for a longer description.
package main
import (
"flag"
"fmt"
"os"
"android/soong/glob"
)
var (
out = flag.String("o", "", "file to write list of files that match glob")
)
func usage() {
fmt.Fprintf(os.Stderr, "usage: soong_glob -o out glob\n")
flag.PrintDefaults()
os.Exit(2)
}
func main() {
flag.Parse()
if *out == "" {
fmt.Fprintln(os.Stderr, "error: -o is required\n")
usage()
}
if flag.NArg() != 1 {
usage()
}
_, err := glob.GlobWithDepFile(flag.Arg(0), *out, *out+".d")
if err != nil {
fmt.Fprintf(os.Stderr, "error: %s\n", err.Error())
os.Exit(1)
}
}

545
common/arch.go Normal file
View file

@ -0,0 +1,545 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 common
import (
"blueprint"
"blueprint/proptools"
"fmt"
"reflect"
"runtime"
"strings"
)
var (
Arm = newArch32("Arm")
Arm64 = newArch64("Arm64")
Mips = newArch32("Mips")
Mips64 = newArch64("Mips64")
X86 = newArch32("X86")
X86_64 = newArch64("X86_64")
)
/*
Example blueprints file containing all variant property groups, with comment listing what type
of variants get properties in that group:
module {
arch: {
arm: {
// Host or device variants with arm architecture
},
arm64: {
// Host or device variants with arm64 architecture
},
mips: {
// Host or device variants with mips architecture
},
mips64: {
// Host or device variants with mips64 architecture
},
x86: {
// Host or device variants with x86 architecture
},
x86_64: {
// Host or device variants with x86_64 architecture
},
},
multilib: {
lib32: {
// Host or device variants for 32-bit architectures
},
lib64: {
// Host or device variants for 64-bit architectures
},
},
target: {
android: {
// Device variants
},
host: {
// Host variants
},
linux: {
// Linux host variants
},
darwin: {
// Darwin host variants
},
windows: {
// Windows host variants
},
not_windows: {
// Non-windows host variants
},
},
}
*/
type archProperties struct {
Arch struct {
Arm interface{}
Arm64 interface{}
Mips interface{}
Mips64 interface{}
X86 interface{}
X86_64 interface{}
}
Multilib struct {
Lib32 interface{}
Lib64 interface{}
}
Target struct {
Host interface{}
Android interface{}
Linux interface{}
Darwin interface{}
Windows interface{}
Not_windows interface{}
}
}
// An Arch indicates a single CPU architecture.
type Arch struct {
HostOrDevice HostOrDevice
ArchType ArchType
ArchVariant string
CpuVariant string
}
func (a Arch) String() string {
s := a.HostOrDevice.String() + "_" + a.ArchType.String()
if a.ArchVariant != "" {
s += "_" + a.ArchVariant
}
if a.CpuVariant != "" {
s += "_" + a.CpuVariant
}
return s
}
type ArchType struct {
Name string
Field string
Multilib string
MultilibField string
}
func newArch32(field string) ArchType {
return ArchType{
Name: strings.ToLower(field),
Field: field,
Multilib: "lib32",
MultilibField: "Lib32",
}
}
func newArch64(field string) ArchType {
return ArchType{
Name: strings.ToLower(field),
Field: field,
Multilib: "lib64",
MultilibField: "Lib64",
}
}
func (a ArchType) String() string {
return a.Name
}
type HostOrDeviceSupported int
const (
_ HostOrDeviceSupported = iota
HostSupported
DeviceSupported
HostAndDeviceSupported
)
type HostOrDevice int
const (
_ HostOrDevice = iota
Host
Device
)
func (hod HostOrDevice) String() string {
switch hod {
case Device:
return "device"
case Host:
return "host"
default:
panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
}
}
func (hod HostOrDevice) FieldLower() string {
switch hod {
case Device:
return "android"
case Host:
return "host"
default:
panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
}
}
func (hod HostOrDevice) Field() string {
switch hod {
case Device:
return "Android"
case Host:
return "Host"
default:
panic(fmt.Sprintf("unexpected HostOrDevice value %d", hod))
}
}
func (hod HostOrDevice) Host() bool {
if hod == 0 {
panic("HostOrDevice unset")
}
return hod == Host
}
func (hod HostOrDevice) Device() bool {
if hod == 0 {
panic("HostOrDevice unset")
}
return hod == Device
}
var hostOrDeviceName = map[HostOrDevice]string{
Device: "device",
Host: "host",
}
var (
armArch = Arch{
HostOrDevice: Device,
ArchType: Arm,
ArchVariant: "armv7-a-neon",
CpuVariant: "cortex-a15",
}
arm64Arch = Arch{
HostOrDevice: Device,
ArchType: Arm64,
ArchVariant: "armv8-a",
CpuVariant: "denver",
}
hostArch = Arch{
HostOrDevice: Host,
ArchType: X86,
}
host64Arch = Arch{
HostOrDevice: Host,
ArchType: X86_64,
}
)
func ArchMutator(mctx blueprint.EarlyMutatorContext) {
var module AndroidModule
var ok bool
if module, ok = mctx.Module().(AndroidModule); !ok {
return
}
// TODO: this is all hardcoded for arm64 primary, arm secondary for now
// Replace with a configuration file written by lunch or bootstrap
arches := []Arch{}
if module.base().HostSupported() {
arches = append(arches, host64Arch)
}
if module.base().DeviceSupported() {
switch module.base().commonProperties.Compile_multilib {
case "both":
arches = append(arches, arm64Arch, armArch)
case "first", "64":
arches = append(arches, arm64Arch)
case "32":
arches = append(arches, armArch)
default:
mctx.ModuleErrorf(`compile_multilib must be "both", "first", "32", or "64", found %q`,
module.base().commonProperties.Compile_multilib)
}
}
archNames := []string{}
for _, arch := range arches {
archNames = append(archNames, arch.String())
}
modules := mctx.CreateVariations(archNames...)
for i, m := range modules {
m.(AndroidModule).base().SetArch(arches[i])
m.(AndroidModule).base().setArchProperties(mctx, arches[i])
}
}
func InitArchModule(m AndroidModule, defaultMultilib string,
propertyStructs ...interface{}) (blueprint.Module, []interface{}) {
base := m.base()
base.commonProperties.Compile_multilib = defaultMultilib
base.generalProperties = append(base.generalProperties,
&base.commonProperties)
base.generalProperties = append(base.generalProperties,
propertyStructs...)
for _, properties := range base.generalProperties {
propertiesValue := reflect.ValueOf(properties)
if propertiesValue.Kind() != reflect.Ptr {
panic("properties must be a pointer to a struct")
}
propertiesValue = propertiesValue.Elem()
if propertiesValue.Kind() != reflect.Struct {
panic("properties must be a pointer to a struct")
}
archProperties := &archProperties{}
forEachInterface(reflect.ValueOf(archProperties), func(v reflect.Value) {
newValue := proptools.CloneProperties(propertiesValue)
proptools.ZeroProperties(newValue.Elem())
v.Set(newValue)
})
base.archProperties = append(base.archProperties, archProperties)
}
var allProperties []interface{}
allProperties = append(allProperties, base.generalProperties...)
for _, asp := range base.archProperties {
allProperties = append(allProperties, asp)
}
return m, allProperties
}
// Rewrite the module's properties structs to contain arch-specific values.
func (a *AndroidModuleBase) setArchProperties(ctx blueprint.EarlyMutatorContext, arch Arch) {
for i := range a.generalProperties {
generalPropsValue := reflect.ValueOf(a.generalProperties[i]).Elem()
// Handle arch-specific properties in the form:
// arch {
// arm64 {
// key: value,
// },
// },
t := arch.ArchType
extendProperties(ctx, "arch", t.Name, generalPropsValue,
reflect.ValueOf(a.archProperties[i].Arch).FieldByName(t.Field).Elem().Elem())
// Handle multilib-specific properties in the form:
// multilib {
// lib32 {
// key: value,
// },
// },
extendProperties(ctx, "multilib", t.Multilib, generalPropsValue,
reflect.ValueOf(a.archProperties[i].Multilib).FieldByName(t.MultilibField).Elem().Elem())
// Handle host-or-device-specific properties in the form:
// target {
// host {
// key: value,
// },
// },
hod := arch.HostOrDevice
extendProperties(ctx, "target", hod.FieldLower(), generalPropsValue,
reflect.ValueOf(a.archProperties[i].Target).FieldByName(hod.Field()).Elem().Elem())
// Handle host target properties in the form:
// target {
// linux {
// key: value,
// },
// not_windows {
// key: value,
// },
// },
var osList = []struct {
goos string
field string
}{
{"darwin", "Darwin"},
{"linux", "Linux"},
{"windows", "Windows"},
}
if hod.Host() {
for _, v := range osList {
if v.goos == runtime.GOOS {
extendProperties(ctx, "target", v.goos, generalPropsValue,
reflect.ValueOf(a.archProperties[i].Target).FieldByName(v.field).Elem().Elem())
}
}
extendProperties(ctx, "target", "not_windows", generalPropsValue,
reflect.ValueOf(a.archProperties[i].Target).FieldByName("Not_windows").Elem().Elem())
}
if ctx.Failed() {
return
}
}
}
func forEachInterface(v reflect.Value, f func(reflect.Value)) {
switch v.Kind() {
case reflect.Interface:
f(v)
case reflect.Struct:
for i := 0; i < v.NumField(); i++ {
forEachInterface(v.Field(i), f)
}
case reflect.Ptr:
forEachInterface(v.Elem(), f)
default:
panic(fmt.Errorf("Unsupported kind %s", v.Kind()))
}
}
// TODO: move this to proptools
func extendProperties(ctx blueprint.EarlyMutatorContext, variationType, variationName string,
dstValue, srcValue reflect.Value) {
extendPropertiesRecursive(ctx, variationType, variationName, dstValue, srcValue, "")
}
func extendPropertiesRecursive(ctx blueprint.EarlyMutatorContext, variationType, variationName string,
dstValue, srcValue reflect.Value, recursePrefix string) {
typ := dstValue.Type()
if srcValue.Type() != typ {
panic(fmt.Errorf("can't extend mismatching types (%s <- %s)",
dstValue.Kind(), srcValue.Kind()))
}
for i := 0; i < srcValue.NumField(); i++ {
field := typ.Field(i)
if field.PkgPath != "" {
// The field is not exported so just skip it.
continue
}
srcFieldValue := srcValue.Field(i)
dstFieldValue := dstValue.Field(i)
localPropertyName := proptools.PropertyNameForField(field.Name)
propertyName := fmt.Sprintf("%s.%s.%s%s", variationType, variationName,
recursePrefix, localPropertyName)
propertyPresentInVariation := ctx.ContainsProperty(propertyName)
if !propertyPresentInVariation {
continue
}
tag := field.Tag.Get("android")
tags := map[string]bool{}
for _, entry := range strings.Split(tag, ",") {
if entry != "" {
tags[entry] = true
}
}
if !tags["arch_variant"] {
ctx.PropertyErrorf(propertyName, "property %q can't be specific to a build variant",
recursePrefix+proptools.PropertyNameForField(field.Name))
continue
}
switch srcFieldValue.Kind() {
case reflect.Bool:
// Replace the original value.
dstFieldValue.Set(srcFieldValue)
case reflect.String:
// Append the extension string.
dstFieldValue.SetString(dstFieldValue.String() +
srcFieldValue.String())
case reflect.Struct:
// Recursively extend the struct's fields.
newRecursePrefix := fmt.Sprintf("%s%s.", recursePrefix, strings.ToLower(field.Name))
extendPropertiesRecursive(ctx, variationType, variationName,
dstFieldValue, srcFieldValue,
newRecursePrefix)
case reflect.Slice:
val, err := archCombineSlices(dstFieldValue, srcFieldValue, tags["arch_subtract"])
if err != nil {
ctx.PropertyErrorf(propertyName, err.Error())
continue
}
dstFieldValue.Set(val)
case reflect.Ptr, reflect.Interface:
// Recursively extend the pointed-to struct's fields.
if dstFieldValue.IsNil() != srcFieldValue.IsNil() {
panic(fmt.Errorf("can't extend field %q: nilitude mismatch"))
}
if dstFieldValue.Type() != srcFieldValue.Type() {
panic(fmt.Errorf("can't extend field %q: type mismatch"))
}
if !dstFieldValue.IsNil() {
newRecursePrefix := fmt.Sprintf("%s.%s", recursePrefix, field.Name)
extendPropertiesRecursive(ctx, variationType, variationName,
dstFieldValue.Elem(), srcFieldValue.Elem(),
newRecursePrefix)
}
default:
panic(fmt.Errorf("unexpected kind for property struct field %q: %s",
field.Name, srcFieldValue.Kind()))
}
}
}
func archCombineSlices(general, arch reflect.Value, canSubtract bool) (reflect.Value, error) {
if !canSubtract {
// Append the extension slice.
return reflect.AppendSlice(general, arch), nil
}
// Support -val in arch list to subtract a value from original list
l := general.Interface().([]string)
for archIndex := 0; archIndex < arch.Len(); archIndex++ {
archString := arch.Index(archIndex).String()
if strings.HasPrefix(archString, "-") {
generalIndex := findStringInSlice(archString[1:], l)
if generalIndex == -1 {
return reflect.Value{},
fmt.Errorf("can't find %q to subtract from general properties", archString[1:])
}
l = append(l[:generalIndex], l[generalIndex+1:]...)
} else {
l = append(l, archString)
}
}
return reflect.ValueOf(l), nil
}
func findStringInSlice(str string, slice []string) int {
for i, s := range slice {
if s == str {
return i
}
}
return -1
}

61
common/defs.go Normal file
View file

@ -0,0 +1,61 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 common
import (
"blueprint"
)
var (
pctx = blueprint.NewPackageContext("android/soong/common")
cpPreserveSymlinks = pctx.VariableConfigMethod("cpPreserveSymlinks",
Config.CpPreserveSymlinksFlags)
// A phony rule that is not the built-in Ninja phony rule. The built-in
// phony rule has special behavior that is sometimes not desired. See the
// Ninja docs for more details.
Phony = pctx.StaticRule("Phony",
blueprint.RuleParams{
Command: "# phony $out",
Description: "phony $out",
})
// GeneratedFile is a rule for indicating that a given file was generated
// while running soong. This allows the file to be cleaned up if it ever
// stops being generated by soong.
GeneratedFile = pctx.StaticRule("GeneratedFile",
blueprint.RuleParams{
Command: "# generated $out",
Description: "generated $out",
Generator: true,
})
// A copy rule.
Cp = pctx.StaticRule("Cp",
blueprint.RuleParams{
Command: "cp $cpPreserveSymlinks $cpFlags $in $out",
Description: "cp $out",
},
"cpFlags")
// A symlink rule.
Symlink = pctx.StaticRule("Symlink",
blueprint.RuleParams{
Command: "ln -f -s $fromPath $out",
Description: "symlink $out",
},
"fromPath")
)

133
common/glob.go Normal file
View file

@ -0,0 +1,133 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 common
import (
"fmt"
"path/filepath"
"blueprint"
"blueprint/bootstrap"
"android/soong/glob"
)
// This file supports globbing source files in Blueprints files.
//
// The build.ninja file needs to be regenerated any time a file matching the glob is added
// or removed. The naive solution is to have the build.ninja file depend on all the
// traversed directories, but this will cause the regeneration step to run every time a
// non-matching file is added to a traversed directory, including backup files created by
// editors.
//
// The solution implemented here optimizes out regenerations when the directory modifications
// don't match the glob by having the build.ninja file depend on an intermedate file that
// is only updated when a file matching the glob is added or removed. The intermediate file
// depends on the traversed directories via a depfile. The depfile is used to avoid build
// errors if a directory is deleted - a direct dependency on the deleted directory would result
// in a build failure with a "missing and no known rule to make it" error.
var (
globCmd = filepath.Join(bootstrap.BinDir, "soong_glob")
// globRule rule traverses directories to produce a list of files that match $glob
// and writes it to $out if it has changed, and writes the directories to $out.d
globRule = pctx.StaticRule("globRule",
blueprint.RuleParams{
Command: fmt.Sprintf(`%s -o $out "$glob"`, globCmd),
Description: "glob $glob",
Restat: true,
Generator: true,
Deps: blueprint.DepsGCC,
Depfile: "$out.d",
},
"glob")
)
func hasGlob(in []string) bool {
for _, s := range in {
if glob.IsGlob(s) {
return true
}
}
return false
}
func ExpandGlobs(ctx AndroidModuleContext, in []string) []string {
if !hasGlob(in) {
return in
}
out := make([]string, 0, len(in))
for _, s := range in {
if glob.IsGlob(s) {
out = append(out, Glob(ctx, s)...)
} else {
out = append(out, s)
}
}
return out
}
func Glob(ctx AndroidModuleContext, globPattern string) []string {
fileListFile := filepath.Join(ModuleOutDir(ctx), "glob", globToString(globPattern))
depFile := fileListFile + ".d"
// Get a globbed file list, and write out fileListFile and depFile
files, err := glob.GlobWithDepFile(globPattern, fileListFile, depFile)
if err != nil {
ctx.ModuleErrorf("glob: %s", err.Error())
return []string{globPattern}
}
// Create a rule to rebuild fileListFile if a directory in depFile changes. fileListFile
// will only be rewritten if it has changed, preventing unnecesary build.ninja regenerations.
ctx.Build(pctx, blueprint.BuildParams{
Rule: globRule,
Outputs: []string{fileListFile},
Implicits: []string{globCmd},
Args: map[string]string{
"glob": globPattern,
},
})
// Phony rule so the cleanup phase doesn't delete the depFile
ctx.Build(pctx, blueprint.BuildParams{
Rule: blueprint.Phony,
Outputs: []string{depFile},
})
// Make build.ninja depend on the fileListFile
ctx.AddNinjaFileDeps(fileListFile)
return files
}
func globToString(glob string) string {
ret := ""
for _, c := range glob {
if c >= 'a' && c <= 'z' ||
c >= 'A' && c <= 'Z' ||
c >= '0' && c <= '9' ||
c == '_' || c == '-' || c == '/' {
ret += string(c)
}
}
return ret
}

327
common/module.go Normal file
View file

@ -0,0 +1,327 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 common
import (
"blueprint"
"path/filepath"
)
var (
DeviceSharedLibrary = "shared_library"
DeviceStaticLibrary = "static_library"
DeviceExecutable = "executable"
HostSharedLibrary = "host_shared_library"
HostStaticLibrary = "host_static_library"
HostExecutable = "host_executable"
)
type AndroidModuleContext interface {
blueprint.ModuleContext
Arch() Arch
InstallFile(installPath, srcPath string)
CheckbuildFile(srcPath string)
}
type AndroidModule interface {
blueprint.Module
GenerateAndroidBuildActions(AndroidModuleContext)
base() *AndroidModuleBase
Disabled() bool
HostOrDevice() HostOrDevice
}
type AndroidDynamicDepender interface {
AndroidDynamicDependencies(ctx AndroidDynamicDependerModuleContext) []string
}
type AndroidDynamicDependerModuleContext interface {
blueprint.DynamicDependerModuleContext
}
type commonProperties struct {
Name string
Deps []string
ResourceDirs []string
// disabled: don't emit any build rules for this module
Disabled bool `android:"arch_variant"`
// multilib: control whether this module compiles for 32-bit, 64-bit, or both. Possible values
// are "32" (compile for 32-bit only), "64" (compile for 64-bit only), "both" (compile for both
// architectures), or "first" (compile for 64-bit on a 64-bit platform, and 32-bit on a 32-bit
// platform
Compile_multilib string
// Set by ArchMutator
CompileArch Arch `blueprint:"mutated"`
// Set by InitAndroidModule
HostOrDeviceSupported HostOrDeviceSupported `blueprint:"mutated"`
}
type hostAndDeviceProperties struct {
Host_supported bool
Device_supported bool
}
func InitAndroidModule(m AndroidModule, hod HostOrDeviceSupported, defaultMultilib string,
propertyStructs ...interface{}) (blueprint.Module, []interface{}) {
base := m.base()
base.module = m
base.commonProperties.HostOrDeviceSupported = hod
if hod == HostAndDeviceSupported {
// Default to module to device supported, host not supported, can override in module
// properties
base.hostAndDeviceProperties.Device_supported = true
propertyStructs = append(propertyStructs, &base.hostAndDeviceProperties)
}
return InitArchModule(m, defaultMultilib, propertyStructs...)
}
// A AndroidModuleBase object contains the properties that are common to all Android
// modules. It should be included as an anonymous field in every module
// struct definition. InitAndroidModule should then be called from the module's
// factory function, and the return values from InitAndroidModule should be
// returned from the factory function.
//
// The AndroidModuleBase type is responsible for implementing the
// GenerateBuildActions method to support the blueprint.Module interface. This
// method will then call the module's GenerateAndroidBuildActions method once
// for each build variant that is to be built. GenerateAndroidBuildActions is
// passed a AndroidModuleContext rather than the usual blueprint.ModuleContext.
// AndroidModuleContext exposes extra functionality specific to the Android build
// system including details about the particular build variant that is to be
// generated.
//
// For example:
//
// import (
// "android/soong/common"
// "blueprint"
// )
//
// type myModule struct {
// common.AndroidModuleBase
// properties struct {
// MyProperty string
// }
// }
//
// func NewMyModule() (blueprint.Module, []interface{}) {
// m := &myModule{}
// return common.InitAndroidModule(m, &m.properties)
// }
//
// func (m *myModule) GenerateAndroidBuildActions(ctx common.AndroidModuleContext) {
// // Get the CPU architecture for the current build variant.
// variantArch := ctx.Arch()
//
// // ...
// }
type AndroidModuleBase struct {
// Putting the curiously recurring thing pointing to the thing that contains
// the thing pattern to good use.
module AndroidModule
commonProperties commonProperties
hostAndDeviceProperties hostAndDeviceProperties
generalProperties []interface{}
archProperties []*archProperties
noAddressSanitizer bool
installFiles []string
checkbuildFiles []string
}
func (a *AndroidModuleBase) base() *AndroidModuleBase {
return a
}
func (a *AndroidModuleBase) SetArch(arch Arch) {
a.commonProperties.CompileArch = arch
}
func (a *AndroidModuleBase) HostOrDevice() HostOrDevice {
return a.commonProperties.CompileArch.HostOrDevice
}
func (a *AndroidModuleBase) HostSupported() bool {
return a.commonProperties.HostOrDeviceSupported == HostSupported ||
a.commonProperties.HostOrDeviceSupported == HostAndDeviceSupported &&
a.hostAndDeviceProperties.Host_supported
}
func (a *AndroidModuleBase) DeviceSupported() bool {
return a.commonProperties.HostOrDeviceSupported == DeviceSupported ||
a.commonProperties.HostOrDeviceSupported == HostAndDeviceSupported &&
a.hostAndDeviceProperties.Device_supported
}
func (a *AndroidModuleBase) Disabled() bool {
return a.commonProperties.Disabled
}
func (a *AndroidModuleBase) computeInstallDeps(
ctx blueprint.ModuleContext) []string {
result := []string{}
ctx.VisitDepsDepthFirstIf(isFileInstaller,
func(m blueprint.Module) {
fileInstaller := m.(fileInstaller)
files := fileInstaller.filesToInstall()
result = append(result, files...)
})
return result
}
func (a *AndroidModuleBase) filesToInstall() []string {
return a.installFiles
}
func (p *AndroidModuleBase) NoAddressSanitizer() bool {
return p.noAddressSanitizer
}
func (p *AndroidModuleBase) resourceDirs() []string {
return p.commonProperties.ResourceDirs
}
func (a *AndroidModuleBase) generateModuleTarget(ctx blueprint.ModuleContext) {
if a != ctx.FinalModule().(AndroidModule).base() {
return
}
allInstalledFiles := []string{}
ctx.VisitAllModuleVariants(func(module blueprint.Module) {
if androidModule, ok := module.(AndroidModule); ok {
files := androidModule.base().installFiles
allInstalledFiles = append(allInstalledFiles, files...)
}
})
if len(allInstalledFiles) > 0 {
ctx.Build(pctx, blueprint.BuildParams{
Rule: blueprint.Phony,
Outputs: []string{ctx.ModuleName()},
Inputs: allInstalledFiles,
})
}
}
func (a *AndroidModuleBase) DynamicDependencies(ctx blueprint.DynamicDependerModuleContext) []string {
actx := &androidDynamicDependerContext{
DynamicDependerModuleContext: ctx,
module: a,
}
if dynamic, ok := a.module.(AndroidDynamicDepender); ok {
return dynamic.AndroidDynamicDependencies(actx)
}
return nil
}
func (a *AndroidModuleBase) GenerateBuildActions(ctx blueprint.ModuleContext) {
androidCtx := &androidModuleContext{
ModuleContext: ctx,
installDeps: a.computeInstallDeps(ctx),
installFiles: a.installFiles,
arch: a.commonProperties.CompileArch,
}
if a.commonProperties.Disabled {
return
}
a.module.GenerateAndroidBuildActions(androidCtx)
if ctx.Failed() {
return
}
a.generateModuleTarget(ctx)
if ctx.Failed() {
return
}
}
type androidModuleContext struct {
blueprint.ModuleContext
arch Arch
installDeps []string
installFiles []string
checkbuildFiles []string
}
func (a *androidModuleContext) Build(pctx *blueprint.PackageContext, params blueprint.BuildParams) {
params.Optional = true
a.ModuleContext.Build(pctx, params)
}
func (a *androidModuleContext) Arch() Arch {
return a.arch
}
func (a *androidModuleContext) InstallFile(installPath, srcPath string) {
var fullInstallPath string
if a.arch.HostOrDevice.Device() {
// TODO: replace unset with a device name once we have device targeting
fullInstallPath = filepath.Join("out/target/product/unset/system", installPath,
filepath.Base(srcPath))
} else {
// TODO: replace unset with a host name
fullInstallPath = filepath.Join("out/host/unset/", installPath, filepath.Base(srcPath))
}
a.ModuleContext.Build(pctx, blueprint.BuildParams{
Rule: Cp,
Outputs: []string{fullInstallPath},
Inputs: []string{srcPath},
OrderOnly: a.installDeps,
})
a.installFiles = append(a.installFiles, fullInstallPath)
a.checkbuildFiles = append(a.checkbuildFiles, srcPath)
}
func (a *androidModuleContext) CheckbuildFile(srcPath string) {
a.checkbuildFiles = append(a.checkbuildFiles, srcPath)
}
type androidDynamicDependerContext struct {
blueprint.DynamicDependerModuleContext
module *AndroidModuleBase
}
type fileInstaller interface {
filesToInstall() []string
}
func isFileInstaller(m blueprint.Module) bool {
_, ok := m.(fileInstaller)
return ok
}
func isAndroidModule(m blueprint.Module) bool {
_, ok := m.(AndroidModule)
return ok
}

83
common/paths.go Normal file
View file

@ -0,0 +1,83 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 common
import (
"path/filepath"
"blueprint"
)
type Config interface {
CpPreserveSymlinksFlags() string
SrcDir() string
}
// ModuleOutDir returns the path to the module-specific output directory.
func ModuleOutDir(ctx AndroidModuleContext) string {
return filepath.Join(".intermediates", ctx.ModuleDir(), ctx.ModuleName(), ctx.ModuleSubDir())
}
// ModuleSrcDir returns the path of the directory that all source file paths are
// specified relative to.
func ModuleSrcDir(ctx blueprint.ModuleContext) string {
config := ctx.Config().(Config)
return filepath.Join(config.SrcDir(), ctx.ModuleDir())
}
// ModuleBinDir returns the path to the module- and architecture-specific binary
// output directory.
func ModuleBinDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "bin")
}
// ModuleLibDir returns the path to the module- and architecture-specific
// library output directory.
func ModuleLibDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "lib")
}
// ModuleGenDir returns the module directory for generated files
// path.
func ModuleGenDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "gen")
}
// ModuleObjDir returns the module- and architecture-specific object directory
// path.
func ModuleObjDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "obj")
}
// ModuleGoPackageDir returns the module-specific package root directory path.
// This directory is where the final package .a files are output and where
// dependent modules search for this package via -I arguments.
func ModuleGoPackageDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "pkg")
}
// ModuleIncludeDir returns the module-specific public include directory path.
func ModuleIncludeDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "include")
}
// ModuleProtoDir returns the module-specific public proto include directory path.
func ModuleProtoDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "proto")
}
func ModuleJSCompiledDir(ctx AndroidModuleContext) string {
return filepath.Join(ModuleOutDir(ctx), "js")
}

152
config/config.go Normal file
View file

@ -0,0 +1,152 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 config
import (
"android/soong/common"
"encoding/json"
"fmt"
"os"
"runtime"
)
var _ common.Config = (*Config)(nil)
// The configuration file name
const ConfigFileName = "soong.config"
// A FileConfigurableOptions contains options which can be configured by the
// config file. These will be included in the config struct.
type FileConfigurableOptions struct {
}
func NewFileConfigurableOptions() FileConfigurableOptions {
f := FileConfigurableOptions{}
return f
}
// A Config object represents the entire build configuration for Blue.
type Config struct {
FileConfigurableOptions
srcDir string // the path of the root source directory
}
// loads configuration options from a JSON file in the cwd.
func loadFromConfigFile(config *Config) error {
// Make a proxy config
var configProxy FileConfigurableOptions
// Try to open the file
configFileReader, err := os.Open(ConfigFileName)
defer configFileReader.Close()
if os.IsNotExist(err) {
// Need to create a file, so that blueprint & ninja don't get in
// a dependency tracking loop.
// Make a file-configurable-options with defaults, write it out using
// a json writer.
configProxy = NewFileConfigurableOptions()
err = saveToConfigFile(configProxy)
if err != nil {
return err
}
} else {
// Make a decoder for it
jsonDecoder := json.NewDecoder(configFileReader)
err = jsonDecoder.Decode(&configProxy)
if err != nil {
return fmt.Errorf("config file: %s did not parse correctly: "+err.Error(), ConfigFileName)
}
}
// Copy the configurable options out of the config_proxy into the config,
// and we're done!
config.FileConfigurableOptions = configProxy
// No error
return nil
}
func saveToConfigFile(config FileConfigurableOptions) error {
data, err := json.MarshalIndent(&config, "", " ")
if err != nil {
return fmt.Errorf("cannot marshal config data: %s", err.Error())
}
configFileWriter, err := os.Create(ConfigFileName)
if err != nil {
return fmt.Errorf("cannot create empty config file %s: %s\n", ConfigFileName, err.Error())
}
defer configFileWriter.Close()
_, err = configFileWriter.Write(data)
if err != nil {
return fmt.Errorf("default config file: %s could not be written: %s", ConfigFileName, err.Error())
}
return nil
}
// New creates a new Config object. The srcDir argument specifies the path to
// the root source directory. It also loads the config file, if found.
func New(srcDir string) (*Config, error) {
// Make a config with default options
config := &Config{srcDir: srcDir}
// Load any configurable options from the configuration file
err := loadFromConfigFile(config)
if err != nil {
return nil, err
}
return config, nil
}
func (c *Config) SrcDir() string {
return c.srcDir
}
// HostGoOS returns the OS of the system that the Go toolchain is being run on.
func (c *Config) HostGoOS() string {
return runtime.GOOS
}
// PrebuiltOS returns the name of the host OS used in prebuilts directories
func (c *Config) PrebuiltOS() string {
switch runtime.GOOS {
case "linux":
return "linux-x86"
case "darwin":
return "darwin-x86"
default:
panic("Unknown GOOS")
}
}
// GoRoot returns the path to the root directory of the Go toolchain.
func (c *Config) GoRoot() string {
return fmt.Sprintf("%s/prebuilts/go/%s", c.srcDir, c.PrebuiltOS())
}
func (c *Config) CpPreserveSymlinksFlags() string {
switch c.HostGoOS() {
case "darwin":
return "-R"
case "linux":
return "-d"
default:
return ""
}
}

7
copygcclib.sh Executable file
View file

@ -0,0 +1,7 @@
#!/bin/bash -e
OUT=$1
shift
LIBPATH=$($@)
cp -f $LIBPATH $OUT
echo "$OUT: $LIBPATH" > ${OUT}.d

56
doc.go Normal file
View file

@ -0,0 +1,56 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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.
// Soong is a builder for Android that uses Blueprint to parse Blueprints
// files and Ninja to do the dependency tracking and subprocess management.
// Soong itself is responsible for converting the modules read by Blueprint
// into build rules, which will be written to a build.ninja file by Blueprint.
//
// Android build concepts:
//
// Device
// A device is a piece of hardware that will be running Android. It may specify
// global settings like architecture, filesystem configuration, initialization
// scripts, and device drivers. A device may support all variants of a single
// piece of hardware, or multiple devices may be used for different variants.
// A build is never targeted directly at a device, it is always targeted at a
// "product".
//
// Product
// A product is a configuration of a device, often for a specific market or
// use case. It is sometimes referred to as a "SKU". A product defines
// global settings like supported languages, supported use cases, preinstalled
// modules, and user-visible behavior choices. A product selects one and only
// one device.
//
// Module
// A module is a definition of something to be built. It may be a C library or
// binary, a java library, an Android app, etc. A module may be built for multiple
// targets, even in a single build, for example host and device, or 32-bit device
// and 64-bit device.
//
// Installed module
// An installed module is one that has been requested by the selected product,
// or a dependency of an installed module.
//
// Target architecture
// The target architecture is the preferred architecture supported by the selected
// device. It is most commonly 32-bit arm, but may also be 64-bit arm, 32-bit or
// 64-bit x86, or mips.
//
// Secondary architecture
// The secondary architecture specifies the architecture to compile a second copy
// of some modules for devices that support multiple architectures, for example
// 64-bit devices that also support 32-bit binaries.
package soong

129
glob/glob.go Normal file
View file

@ -0,0 +1,129 @@
// Copyright 2015 Google Inc. All rights reserved.
//
// 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 glob
import (
"io/ioutil"
"os"
"path/filepath"
"strings"
"blueprint/deptools"
)
func IsGlob(glob string) bool {
return strings.IndexAny(glob, "*?[") >= 0
}
// GlobWithDepFile finds all files that match glob. It compares the list of files
// against the contents of fileListFile, and rewrites fileListFile if it has changed. It also
// writes all of the the directories it traversed as a depenencies on fileListFile to depFile.
//
// The format of glob is either path/*.ext for a single directory glob, or path/**/*.ext
// for a recursive glob.
//
// Returns a list of file paths, and an error.
func GlobWithDepFile(glob, fileListFile, depFile string) (files []string, err error) {
globPattern := filepath.Base(glob)
globDir := filepath.Dir(glob)
recursive := false
if filepath.Base(globDir) == "**" {
recursive = true
globDir = filepath.Dir(globDir)
}
var dirs []string
err = filepath.Walk(globDir,
func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.Mode().IsDir() {
dirs = append(dirs, path)
if !recursive && path != globDir {
return filepath.SkipDir
}
} else if info.Mode().IsRegular() {
match, err := filepath.Match(globPattern, info.Name())
if err != nil {
return err
}
if match {
files = append(files, path)
}
}
return nil
})
fileList := strings.Join(files, "\n")
writeFileIfChanged(fileListFile, []byte(fileList), 0666)
deptools.WriteDepFile(depFile, fileListFile, dirs)
return
}
func writeFileIfChanged(filename string, data []byte, perm os.FileMode) error {
var isChanged bool
dir := filepath.Dir(filename)
err := os.MkdirAll(dir, 0777)
if err != nil {
return err
}
info, err := os.Stat(filename)
if err != nil {
if os.IsNotExist(err) {
// The file does not exist yet.
isChanged = true
} else {
return err
}
} else {
if info.Size() != int64(len(data)) {
isChanged = true
} else {
oldData, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
if len(oldData) != len(data) {
isChanged = true
} else {
for i := range data {
if oldData[i] != data[i] {
isChanged = true
break
}
}
}
}
}
if isChanged {
err = ioutil.WriteFile(filename, data, perm)
if err != nil {
return err
}
}
return nil
}

3
root.bp
View file

@ -1,4 +1,7 @@
subdirs = [
"build/blueprint",
"build/soong",
"bionic/*",
"external/*",
"system/core/*",
]