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

Merge changes I43e61218,Iea36ecaa

Browse source 
* changes:
  Add an option to gather CPU profile.
  Allow $(filter ...) with arbitrary args if its result is compared to the empty string
This commit is contained in:
Treehugger Robot 2021-08-02 20:18:17 +00:00 committed by Gerrit Code Review
commit e083a05ad0
4 changed files with 87 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
mk2rbc/cmd/mk2rbc.go
View file

@ -28,6 +28,7 @@ import (
"path/filepath"
"regexp"
"runtime/debug"
"runtime/pprof"
"sort"
"strings"
"time"
@ -52,6 +53,7 @@ var (
outputTop = flag.String("outdir", "", "write output files into this directory hierarchy")
launcher = flag.String("launcher", "", "generated launcher path. If set, the non-flag argument is _product_name_")
printProductConfigMap = flag.Bool("print_product_config_map", false, "print product config map and exit")
cpuProfile = flag.String("cpu_profile", "", "write cpu profile to file")
traceCalls = flag.Bool("trace_calls", false, "trace function calls")
)
@ -122,6 +124,14 @@ func main() {
tracedVariables = strings.Split(*traceVar, ",")
}
if *cpuProfile != "" {
f, err := os.Create(*cpuProfile)
if err != nil {
quit(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
// Find out global variables
getConfigVariables()
getSoongVariables()

26
mk2rbc/expr.go
View file

@ -240,22 +240,21 @@ func (eq *eqExpr) eval(valueMap map[string]starlarkExpr) (res starlarkExpr, same
}
func (eq *eqExpr) emit(gctx *generationContext) {
// Are we checking that a variable is empty?
var varRef *variableRefExpr
if s, ok := maybeString(eq.left); ok && s == "" {
varRef, ok = eq.right.(*variableRefExpr)
} else if s, ok := maybeString(eq.right); ok && s == "" {
varRef, ok = eq.left.(*variableRefExpr)
}
if varRef != nil {
// Yes.
emitSimple := func(expr starlarkExpr) {
if eq.isEq {
gctx.write("not ")
}
varRef.emit(gctx)
return
expr.emit(gctx)
}
// Are we checking that a variable is empty?
if isEmptyString(eq.left) {
emitSimple(eq.right)
return
} else if isEmptyString(eq.right) {
emitSimple(eq.left)
return
}
// General case
eq.left.emit(gctx)
if eq.isEq {
@ -578,3 +577,8 @@ func maybeConvertToStringList(expr starlarkExpr) starlarkExpr {
}
return expr
}
func isEmptyString(expr starlarkExpr) bool {
x, ok := expr.(*stringLiteralExpr)
return ok && x.literal == ""
}

72
mk2rbc/mk2rbc.go
View file

@ -938,14 +938,14 @@ func (ctx *parseContext) parseCheckFunctionCallResult(directive *mkparser.Direct
func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
filterFuncCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
// We handle:
// * ifeq/ifneq (,$(filter v1 v2 ..., $(VAR)) becomes if VAR not in/in ["v1", "v2", ...]
// * ifeq/ifneq (,$(filter $(VAR), v1 v2 ...) becomes if VAR not in/in ["v1", "v2", ...]
// * ifeq/ifneq (,$(filter v1 v2 ..., EXPR) becomes if EXPR not in/in ["v1", "v2", ...]
// * ifeq/ifneq (,$(filter EXPR, v1 v2 ...) becomes if EXPR not in/in ["v1", "v2", ...]
// * ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...) becomes if VAR in/not in ["v1", "v2"]
// TODO(Asmundak): check the last case works for filter-out, too.
xPattern := filterFuncCall.args[0]
xText := filterFuncCall.args[1]
var xInList *stringLiteralExpr
var xVar starlarkExpr
var expr starlarkExpr
var ok bool
switch x := xValue.(type) {
case *stringLiteralExpr:
@ -955,34 +955,42 @@ func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
// Either pattern or text should be const, and the
// non-const one should be varRefExpr
if xInList, ok = xPattern.(*stringLiteralExpr); ok {
xVar = xText
expr = xText
} else if xInList, ok = xText.(*stringLiteralExpr); ok {
xVar = xPattern
expr = xPattern
} else {
return &callExpr{
object: nil,
name: filterFuncCall.name,
args: filterFuncCall.args,
returnType: starlarkTypeBool,
}
}
case *variableRefExpr:
if v, ok := xPattern.(*variableRefExpr); ok {
if xInList, ok = xText.(*stringLiteralExpr); ok && v.ref.name() == x.ref.name() {
// ifeq/ifneq ($(VAR),$(filter $(VAR), v1 v2 ...), flip negate,
// it's the opposite to what is done when comparing to empty.
xVar = xPattern
expr = xPattern
negate = !negate
}
}
}
if xVar != nil && xInList != nil {
if _, ok := xVar.(*variableRefExpr); ok {
slExpr := newStringListExpr(strings.Fields(xInList.literal))
// Generate simpler code for the common cases:
if xVar.typ() == starlarkTypeList {
if len(slExpr.items) == 1 {
// Checking that a string belongs to list
return &inExpr{isNot: negate, list: xVar, expr: slExpr.items[0]}
} else {
// TODO(asmundak):
panic("TBD")
}
if expr != nil && xInList != nil {
slExpr := newStringListExpr(strings.Fields(xInList.literal))
// Generate simpler code for the common cases:
if expr.typ() == starlarkTypeList {
if len(slExpr.items) == 1 {
// Checking that a string belongs to list
return &inExpr{isNot: negate, list: expr, expr: slExpr.items[0]}
} else {
// TODO(asmundak):
panic("TBD")
}
return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: xVar}
} else if len(slExpr.items) == 1 {
return &eqExpr{left: expr, right: slExpr.items[0], isEq: !negate}
} else {
return &inExpr{isNot: negate, list: newStringListExpr(strings.Fields(xInList.literal)), expr: expr}
}
}
return ctx.newBadExpr(cond, "filter arguments are too complex: %s", cond.Dump())
@ -990,7 +998,7 @@ func (ctx *parseContext) parseCompareFilterFuncResult(cond *mkparser.Directive,
func (ctx *parseContext) parseCompareWildcardFuncResult(directive *mkparser.Directive,
xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
if x, ok := xValue.(*stringLiteralExpr); !ok || x.literal != "" {
if !isEmptyString(xValue) {
return ctx.newBadExpr(directive, "wildcard result can be compared only to empty: %s", xValue)
}
callFunc := wildcardExistsPhony
@ -1006,19 +1014,19 @@ func (ctx *parseContext) parseCompareWildcardFuncResult(directive *mkparser.Dire
func (ctx *parseContext) parseCheckFindstringFuncResult(directive *mkparser.Directive,
xCall *callExpr, xValue starlarkExpr, negate bool) starlarkExpr {
if x, ok := xValue.(*stringLiteralExpr); !ok || x.literal != "" {
return ctx.newBadExpr(directive, "findstring result can be compared only to empty: %s", xValue)
}
return &eqExpr{
left: &callExpr{
object: xCall.args[1],
name: "find",
args: []starlarkExpr{xCall.args[0]},
returnType: starlarkTypeInt,
},
right: &intLiteralExpr{-1},
isEq: !negate,
if isEmptyString(xValue) {
return &eqExpr{
left: &callExpr{
object: xCall.args[1],
name: "find",
args: []starlarkExpr{xCall.args[0]},
returnType: starlarkTypeInt,
},
right: &intLiteralExpr{-1},
isEq: !negate,
}
}
return ctx.newBadExpr(directive, "findstring result can be compared only to empty: %s", xValue)
}
func (ctx *parseContext) parseCompareStripFuncResult(directive *mkparser.Directive,

25
mk2rbc/mk2rbc_test.go
View file

@ -342,6 +342,8 @@ ifneq (,$(filter plaf,$(PLATFORM_LIST)))
endif
ifeq ($(TARGET_BUILD_VARIANT), $(filter $(TARGET_BUILD_VARIANT), userdebug eng))
endif
ifneq (,$(filter true, $(v1)$(v2)))
endif
`,
expected: `load("//build/make/core:product_config.rbc", "rblf")
@ -349,12 +351,14 @@ def init(g, handle):
cfg = rblf.cfg(handle)
if g["TARGET_BUILD_VARIANT"] not in ["userdebug", "eng"]:
pass
if g["TARGET_BUILD_VARIANT"] in ["userdebug"]:
if g["TARGET_BUILD_VARIANT"] == "userdebug":
pass
if "plaf" in g.get("PLATFORM_LIST", []):
pass
if g["TARGET_BUILD_VARIANT"] in ["userdebug", "eng"]:
pass
if "%s%s" % (_v1, _v2) == "true":
pass
`,
},
{
@ -385,8 +389,23 @@ endif
def init(g, handle):
cfg = rblf.cfg(handle)
if g["TARGET_PRODUCT"] not in ["yukawa_gms", "yukawa_sei510_gms"]:
if g["TARGET_PRODUCT"] in ["yukawa_gms"]:
if g["TARGET_PRODUCT"] == "yukawa_gms":
pass
`,
},
{
desc: "filter $(V1), $(V2)",
mkname: "product.mk",
in: `
ifneq (, $(filter $(PRODUCT_LIST), $(TARGET_PRODUCT)))
endif
`,
expected: `load("//build/make/core:product_config.rbc", "rblf")
def init(g, handle):
cfg = rblf.cfg(handle)
if rblf.filter(g.get("PRODUCT_LIST", ""), g["TARGET_PRODUCT"]):
pass
`,
},
{
@ -779,7 +798,7 @@ endif
def init(g, handle):
cfg = rblf.cfg(handle)
if rblf.mkstrip(g.get("TARGET_VENDOR", "")) != "":
if rblf.mkstrip(g.get("TARGET_VENDOR", "")):
pass
`,
},