| // Copyright 2017 syzkaller project authors. All rights reserved. |
| // Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file. |
| |
| // Package compiler generates sys descriptions of syscalls, types and resources |
| // from textual descriptions. |
| package compiler |
| |
| import ( |
| "fmt" |
| "strings" |
| |
| "github.com/google/syzkaller/pkg/ast" |
| "github.com/google/syzkaller/prog" |
| ) |
| |
| func (comp *compiler) typecheck() { |
| comp.checkDirectives() |
| comp.checkNames() |
| comp.checkFields() |
| comp.checkTypedefs() |
| comp.checkTypes() |
| } |
| |
| func (comp *compiler) check() { |
| comp.checkTypeValues() |
| comp.checkAttributeValues() |
| comp.checkUnused() |
| comp.checkRecursion() |
| comp.checkLenTargets() |
| comp.checkConstructors() |
| comp.checkVarlens() |
| comp.checkDupConsts() |
| } |
| |
| func (comp *compiler) checkDirectives() { |
| includes := make(map[string]bool) |
| incdirs := make(map[string]bool) |
| defines := make(map[string]bool) |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Include: |
| name := n.File.Value |
| path := n.Pos.File + "/" + name |
| if includes[path] { |
| comp.error(n.Pos, "duplicate include %q", name) |
| } |
| includes[path] = true |
| case *ast.Incdir: |
| name := n.Dir.Value |
| path := n.Pos.File + "/" + name |
| if incdirs[path] { |
| comp.error(n.Pos, "duplicate incdir %q", name) |
| } |
| incdirs[path] = true |
| case *ast.Define: |
| name := n.Name.Name |
| path := n.Pos.File + "/" + name |
| if defines[path] { |
| comp.error(n.Pos, "duplicate define %v", name) |
| } |
| defines[path] = true |
| } |
| } |
| } |
| |
| func (comp *compiler) checkNames() { |
| calls := make(map[string]*ast.Call) |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Resource, *ast.Struct, *ast.TypeDef: |
| pos, typ, name := decl.Info() |
| if reservedName[name] { |
| comp.error(pos, "%v uses reserved name %v", typ, name) |
| continue |
| } |
| if builtinTypes[name] != nil || builtinTypedefs[name] != nil { |
| comp.error(pos, "%v name %v conflicts with builtin type", typ, name) |
| continue |
| } |
| if prev := comp.resources[name]; prev != nil { |
| comp.error(pos, "type %v redeclared, previously declared as resource at %v", |
| name, prev.Pos) |
| continue |
| } |
| if prev := comp.typedefs[name]; prev != nil { |
| comp.error(pos, "type %v redeclared, previously declared as type alias at %v", |
| name, prev.Pos) |
| continue |
| } |
| if prev := comp.structs[name]; prev != nil { |
| _, typ, _ := prev.Info() |
| comp.error(pos, "type %v redeclared, previously declared as %v at %v", |
| name, typ, prev.Pos) |
| continue |
| } |
| switch n := decl.(type) { |
| case *ast.Resource: |
| comp.resources[name] = n |
| case *ast.TypeDef: |
| comp.typedefs[name] = n |
| case *ast.Struct: |
| comp.structs[name] = n |
| } |
| case *ast.IntFlags: |
| name := n.Name.Name |
| if name == "_" { |
| continue |
| } |
| if reservedName[name] { |
| comp.error(n.Pos, "flags uses reserved name %v", name) |
| continue |
| } |
| if prev := comp.intFlags[name]; prev != nil { |
| comp.error(n.Pos, "flags %v redeclared, previously declared at %v", |
| name, prev.Pos) |
| continue |
| } |
| comp.intFlags[name] = n |
| case *ast.StrFlags: |
| name := n.Name.Name |
| if reservedName[name] { |
| comp.error(n.Pos, "string flags uses reserved name %v", name) |
| continue |
| } |
| if builtinStrFlags[name] != nil { |
| comp.error(n.Pos, "string flags %v conflicts with builtin flags", name) |
| continue |
| } |
| if prev := comp.strFlags[name]; prev != nil { |
| comp.error(n.Pos, "string flags %v redeclared, previously declared at %v", |
| name, prev.Pos) |
| continue |
| } |
| comp.strFlags[name] = n |
| case *ast.Call: |
| name := n.Name.Name |
| if prev := calls[name]; prev != nil { |
| comp.error(n.Pos, "syscall %v redeclared, previously declared at %v", |
| name, prev.Pos) |
| } |
| calls[name] = n |
| } |
| } |
| } |
| |
| func (comp *compiler) checkFields() { |
| const maxArgs = 9 // executor does not support more |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Struct: |
| _, typ, name := n.Info() |
| comp.checkStructFields(n, typ, name) |
| case *ast.TypeDef: |
| if n.Struct != nil { |
| _, typ, _ := n.Struct.Info() |
| comp.checkStructFields(n.Struct, "template "+typ, n.Name.Name) |
| } |
| case *ast.Call: |
| name := n.Name.Name |
| comp.checkFieldGroup(n.Args, "argument", "syscall "+name) |
| if len(n.Args) > maxArgs { |
| comp.error(n.Pos, "syscall %v has %v arguments, allowed maximum is %v", |
| name, len(n.Args), maxArgs) |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkStructFields(n *ast.Struct, typ, name string) { |
| comp.checkFieldGroup(n.Fields, "field", typ+" "+name) |
| if len(n.Fields) < 1 { |
| comp.error(n.Pos, "%v %v has no fields, need at least 1 field", typ, name) |
| } |
| } |
| |
| func (comp *compiler) checkFieldGroup(fields []*ast.Field, what, ctx string) { |
| existing := make(map[string]bool) |
| for _, f := range fields { |
| fn := f.Name.Name |
| if fn == "parent" { |
| comp.error(f.Pos, "reserved %v name %v in %v", what, fn, ctx) |
| } |
| if existing[fn] { |
| comp.error(f.Pos, "duplicate %v %v in %v", what, fn, ctx) |
| } |
| existing[fn] = true |
| } |
| } |
| |
| func (comp *compiler) checkTypedefs() { |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.TypeDef: |
| if len(n.Args) == 0 { |
| // Non-template types are fully typed, so we check them ahead of time. |
| err0 := comp.errors |
| comp.checkType(checkCtx{}, n.Type, checkIsTypedef) |
| if err0 != comp.errors { |
| // To not produce confusing errors on broken type usage. |
| delete(comp.typedefs, n.Name.Name) |
| } |
| } else { |
| // For templates we only do basic checks of arguments. |
| names := make(map[string]bool) |
| for _, arg := range n.Args { |
| if names[arg.Name] { |
| comp.error(arg.Pos, "duplicate type argument %v", arg.Name) |
| } |
| names[arg.Name] = true |
| for _, c := range arg.Name { |
| if c >= 'A' && c <= 'Z' || |
| c >= '0' && c <= '9' || |
| c == '_' { |
| continue |
| } |
| comp.error(arg.Pos, "type argument %v must be ALL_CAPS", |
| arg.Name) |
| break |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkTypes() { |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Resource: |
| comp.checkType(checkCtx{}, n.Base, checkIsResourceBase) |
| case *ast.Struct: |
| comp.checkStruct(checkCtx{}, n) |
| case *ast.Call: |
| for _, a := range n.Args { |
| comp.checkType(checkCtx{}, a.Type, checkIsArg) |
| } |
| if n.Ret != nil { |
| comp.checkType(checkCtx{}, n.Ret, checkIsArg|checkIsRet) |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkTypeValues() { |
| for _, decl := range comp.desc.Nodes { |
| switch decl.(type) { |
| case *ast.Call, *ast.Struct, *ast.Resource, *ast.TypeDef: |
| comp.foreachType(decl, func(t *ast.Type, desc *typeDesc, |
| args []*ast.Type, base prog.IntTypeCommon) { |
| if desc.CheckConsts != nil { |
| desc.CheckConsts(comp, t, args, base) |
| } |
| for i, arg := range args { |
| if check := desc.Args[i].Type.CheckConsts; check != nil { |
| check(comp, arg) |
| } |
| } |
| }) |
| } |
| } |
| } |
| |
| func (comp *compiler) checkAttributeValues() { |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Struct: |
| for _, attr := range n.Attrs { |
| if attr.Ident == "size" { |
| _, typ, name := n.Info() |
| if comp.structIsVarlen(n.Name.Name) { |
| comp.error(attr.Pos, "varlen %v %v has size attribute", |
| typ, name) |
| } |
| sz := attr.Args[0].Value |
| if sz == 0 || sz > 1<<20 { |
| comp.error(attr.Args[0].Pos, "size attribute has bad value %v"+ |
| ", expect [1, 1<<20]", sz) |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkLenTargets() { |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Call: |
| for _, arg := range n.Args { |
| comp.checkLenType(arg.Type, arg.Name.Name, n.Args, nil, make(map[string]bool), true) |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkLenType(t *ast.Type, name string, fields []*ast.Field, |
| parents []*ast.Struct, checked map[string]bool, isArg bool) { |
| desc := comp.getTypeDesc(t) |
| if desc == typeStruct { |
| s := comp.structs[t.Ident] |
| // Prune recursion, can happen even on correct tree via opt pointers. |
| if checked[s.Name.Name] { |
| return |
| } |
| checked[s.Name.Name] = true |
| parents = append(parents, s) |
| if !s.IsUnion { |
| fields = s.Fields |
| } |
| for _, fld := range s.Fields { |
| comp.checkLenType(fld.Type, fld.Name.Name, fields, parents, checked, false) |
| } |
| return |
| } |
| _, args, _ := comp.getArgsBase(t, "", prog.DirIn, isArg) |
| for i, arg := range args { |
| argDesc := desc.Args[i] |
| if argDesc.Type == typeArgLenTarget { |
| comp.checkLenTarget(t, name, arg.Ident, fields, parents) |
| } else if argDesc.Type == typeArgType { |
| comp.checkLenType(arg, name, fields, parents, checked, argDesc.IsArg) |
| } |
| } |
| } |
| |
| func (comp *compiler) checkLenTarget(t *ast.Type, name, target string, fields []*ast.Field, parents []*ast.Struct) { |
| if target == name { |
| comp.error(t.Pos, "%v target %v refer to itself", t.Ident, target) |
| return |
| } |
| if target == "parent" { |
| if len(parents) == 0 { |
| comp.error(t.Pos, "%v target %v does not exist", t.Ident, target) |
| } |
| return |
| } |
| for _, fld := range fields { |
| if target != fld.Name.Name { |
| continue |
| } |
| if fld.Type == t { |
| comp.error(t.Pos, "%v target %v refer to itself", t.Ident, target) |
| } |
| if t.Ident == "len" { |
| inner := fld.Type |
| desc, args, _ := comp.getArgsBase(inner, "", prog.DirIn, false) |
| for desc == typePtr { |
| if desc != typePtr { |
| break |
| } |
| inner = args[1] |
| desc, args, _ = comp.getArgsBase(inner, "", prog.DirIn, false) |
| } |
| if desc == typeArray && comp.isVarlen(args[0]) { |
| comp.warning(t.Pos, "len target %v refer to an array with"+ |
| " variable-size elements (do you mean bytesize?)", target) |
| } |
| } |
| return |
| } |
| for _, parent := range parents { |
| parentName := parent.Name.Name |
| if pos := strings.IndexByte(parentName, '['); pos != -1 { |
| // For template parents name is "struct_name[ARG1, ARG2]", strip the part after '['. |
| parentName = parentName[:pos] |
| } |
| if target == parentName { |
| return |
| } |
| } |
| comp.error(t.Pos, "%v target %v does not exist", t.Ident, target) |
| } |
| |
| func (comp *compiler) collectUsed(all bool) (structs, flags, strflags map[string]bool) { |
| structs = make(map[string]bool) |
| flags = make(map[string]bool) |
| strflags = make(map[string]bool) |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Call: |
| if !all && n.NR == ^uint64(0) { |
| break |
| } |
| for _, arg := range n.Args { |
| comp.collectUsedType(structs, flags, strflags, arg.Type, true) |
| } |
| if n.Ret != nil { |
| comp.collectUsedType(structs, flags, strflags, n.Ret, true) |
| } |
| } |
| } |
| return |
| } |
| |
| func (comp *compiler) collectUsedType(structs, flags, strflags map[string]bool, t *ast.Type, isArg bool) { |
| desc := comp.getTypeDesc(t) |
| if desc == typeResource { |
| r := comp.resources[t.Ident] |
| for r != nil && !structs[r.Name.Name] { |
| structs[r.Name.Name] = true |
| r = comp.resources[r.Base.Ident] |
| } |
| return |
| } |
| if desc == typeStruct { |
| if structs[t.Ident] { |
| return |
| } |
| structs[t.Ident] = true |
| s := comp.structs[t.Ident] |
| for _, fld := range s.Fields { |
| comp.collectUsedType(structs, flags, strflags, fld.Type, false) |
| } |
| return |
| } |
| if desc == typeFlags { |
| flags[t.Args[0].Ident] = true |
| return |
| } |
| if desc == typeString { |
| if len(t.Args) != 0 && t.Args[0].Ident != "" { |
| strflags[t.Args[0].Ident] = true |
| } |
| return |
| } |
| _, args, _ := comp.getArgsBase(t, "", prog.DirIn, isArg) |
| for i, arg := range args { |
| if desc.Args[i].Type == typeArgType { |
| comp.collectUsedType(structs, flags, strflags, arg, desc.Args[i].IsArg) |
| } |
| } |
| } |
| |
| func (comp *compiler) checkUnused() { |
| comp.used, _, _ = comp.collectUsed(false) |
| structs, flags, strflags := comp.collectUsed(true) |
| _, _, _ = structs, flags, strflags |
| |
| for name, n := range comp.intFlags { |
| if !flags[name] { |
| comp.error(n.Pos, "unused flags %v", name) |
| } |
| } |
| for name, n := range comp.strFlags { |
| if !strflags[name] && builtinStrFlags[name] == nil { |
| comp.error(n.Pos, "unused string flags %v", name) |
| } |
| } |
| for name, n := range comp.resources { |
| if !structs[name] { |
| comp.error(n.Pos, "unused resource %v", name) |
| } |
| } |
| for name, n := range comp.structs { |
| if !structs[name] { |
| _, typ, _ := n.Info() |
| comp.error(n.Pos, "unused %v %v", typ, name) |
| } |
| } |
| for name, n := range comp.typedefs { |
| if !comp.usedTypedefs[name] { |
| comp.error(n.Pos, "unused type %v", name) |
| } |
| } |
| } |
| |
| type structDir struct { |
| Struct string |
| Dir prog.Dir |
| } |
| |
| func (comp *compiler) checkConstructors() { |
| ctors := make(map[string]bool) // resources for which we have ctors |
| checked := make(map[structDir]bool) |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Call: |
| for _, arg := range n.Args { |
| comp.checkTypeCtors(arg.Type, prog.DirIn, true, ctors, checked) |
| } |
| if n.Ret != nil { |
| comp.checkTypeCtors(n.Ret, prog.DirOut, true, ctors, checked) |
| } |
| } |
| } |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Resource: |
| name := n.Name.Name |
| if !ctors[name] && comp.used[name] { |
| comp.error(n.Pos, "resource %v can't be created"+ |
| " (never mentioned as a syscall return value or output argument/field)", |
| name) |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkTypeCtors(t *ast.Type, dir prog.Dir, isArg bool, |
| ctors map[string]bool, checked map[structDir]bool) { |
| desc := comp.getTypeDesc(t) |
| if desc == typeResource { |
| // TODO(dvyukov): consider changing this to "dir == prog.DirOut". |
| // We have few questionable cases where resources can be created |
| // only by inout struct fields. These structs should be split |
| // into two different structs: one is in and second is out. |
| // But that will require attaching dir to individual fields. |
| if dir != prog.DirIn { |
| r := comp.resources[t.Ident] |
| for r != nil && !ctors[r.Name.Name] { |
| ctors[r.Name.Name] = true |
| r = comp.resources[r.Base.Ident] |
| } |
| } |
| return |
| } |
| if desc == typeStruct { |
| s := comp.structs[t.Ident] |
| name := s.Name.Name |
| key := structDir{name, dir} |
| if checked[key] { |
| return |
| } |
| checked[key] = true |
| for _, fld := range s.Fields { |
| comp.checkTypeCtors(fld.Type, dir, false, ctors, checked) |
| } |
| return |
| } |
| if desc == typePtr { |
| dir = genDir(t.Args[0]) |
| } |
| _, args, _ := comp.getArgsBase(t, "", dir, isArg) |
| for i, arg := range args { |
| if desc.Args[i].Type == typeArgType { |
| comp.checkTypeCtors(arg, dir, desc.Args[i].IsArg, ctors, checked) |
| } |
| } |
| } |
| |
| func (comp *compiler) checkRecursion() { |
| checked := make(map[string]bool) |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Resource: |
| comp.checkResourceRecursion(n) |
| case *ast.Struct: |
| var path []pathElem |
| comp.checkStructRecursion(checked, n, path) |
| } |
| } |
| } |
| |
| func (comp *compiler) checkResourceRecursion(n *ast.Resource) { |
| var seen []string |
| for n != nil { |
| if arrayContains(seen, n.Name.Name) { |
| chain := "" |
| for _, r := range seen { |
| chain += r + "->" |
| } |
| chain += n.Name.Name |
| comp.error(n.Pos, "recursive resource %v", chain) |
| return |
| } |
| seen = append(seen, n.Name.Name) |
| n = comp.resources[n.Base.Ident] |
| } |
| } |
| |
| type pathElem struct { |
| Pos ast.Pos |
| Struct string |
| Field string |
| } |
| |
| func (comp *compiler) checkStructRecursion(checked map[string]bool, n *ast.Struct, path []pathElem) { |
| name := n.Name.Name |
| if checked[name] { |
| return |
| } |
| for i, elem := range path { |
| if elem.Struct != name { |
| continue |
| } |
| path = path[i:] |
| str := "" |
| for _, elem := range path { |
| str += fmt.Sprintf("%v.%v -> ", elem.Struct, elem.Field) |
| } |
| str += name |
| comp.error(path[0].Pos, "recursive declaration: %v (mark some pointers as opt)", str) |
| checked[name] = true |
| return |
| } |
| for _, f := range n.Fields { |
| path = append(path, pathElem{ |
| Pos: f.Pos, |
| Struct: name, |
| Field: f.Name.Name, |
| }) |
| comp.recurseField(checked, f.Type, path) |
| path = path[:len(path)-1] |
| } |
| checked[name] = true |
| } |
| |
| func (comp *compiler) recurseField(checked map[string]bool, t *ast.Type, path []pathElem) { |
| desc := comp.getTypeDesc(t) |
| if desc == typeStruct { |
| comp.checkStructRecursion(checked, comp.structs[t.Ident], path) |
| return |
| } |
| _, args, base := comp.getArgsBase(t, "", prog.DirIn, false) |
| if desc == typePtr && base.IsOptional { |
| return // optional pointers prune recursion |
| } |
| for i, arg := range args { |
| if desc.Args[i].Type == typeArgType { |
| comp.recurseField(checked, arg, path) |
| } |
| } |
| } |
| |
| func (comp *compiler) checkStruct(ctx checkCtx, n *ast.Struct) { |
| var flags checkFlags |
| if !n.IsUnion { |
| flags |= checkIsStruct |
| } |
| for _, f := range n.Fields { |
| comp.checkType(ctx, f.Type, flags) |
| } |
| for _, attr := range n.Attrs { |
| if unexpected, _, ok := checkTypeKind(attr, kindIdent); !ok { |
| comp.error(attr.Pos, "unexpected %v, expect attribute", unexpected) |
| return |
| } |
| if attr.HasColon { |
| comp.error(attr.Pos2, "unexpected ':'") |
| return |
| } |
| } |
| if n.IsUnion { |
| comp.parseUnionAttrs(n) |
| } else { |
| comp.parseStructAttrs(n) |
| } |
| } |
| |
| type checkFlags int |
| |
| const ( |
| checkIsArg checkFlags = 1 << iota // immediate syscall arg type |
| checkIsRet // immediate syscall ret type |
| checkIsStruct // immediate struct field type |
| checkIsResourceBase // immediate resource base type |
| checkIsTypedef // immediate type alias/template type |
| ) |
| |
| type checkCtx struct { |
| instantiationStack []string |
| } |
| |
| func (comp *compiler) checkType(ctx checkCtx, t *ast.Type, flags checkFlags) { |
| if unexpected, _, ok := checkTypeKind(t, kindIdent); !ok { |
| comp.error(t.Pos, "unexpected %v, expect type", unexpected) |
| return |
| } |
| desc := comp.getTypeDesc(t) |
| if desc == nil { |
| comp.error(t.Pos, "unknown type %v", t.Ident) |
| return |
| } |
| if desc == typeTypedef { |
| err0 := comp.errors |
| // Replace t with type alias/template target type inplace, |
| // and check the replaced type recursively. |
| comp.replaceTypedef(&ctx, t, flags) |
| if err0 == comp.errors { |
| comp.checkType(ctx, t, flags) |
| } |
| return |
| } |
| err0 := comp.errors |
| comp.checkTypeBasic(t, desc, flags) |
| if err0 != comp.errors { |
| return |
| } |
| args := comp.checkTypeArgs(t, desc, flags) |
| if err0 != comp.errors { |
| return |
| } |
| for i, arg := range args { |
| if desc.Args[i].Type == typeArgType { |
| var innerFlags checkFlags |
| if desc.Args[i].IsArg { |
| innerFlags |= checkIsArg |
| } |
| comp.checkType(ctx, arg, innerFlags) |
| } else { |
| comp.checkTypeArg(t, arg, desc.Args[i]) |
| } |
| } |
| if err0 != comp.errors { |
| return |
| } |
| if desc.Check != nil { |
| _, args, base := comp.getArgsBase(t, "", prog.DirIn, flags&checkIsArg != 0) |
| desc.Check(comp, t, args, base) |
| } |
| } |
| |
| func (comp *compiler) checkTypeBasic(t *ast.Type, desc *typeDesc, flags checkFlags) { |
| if t.HasColon { |
| if !desc.AllowColon { |
| comp.error(t.Pos2, "unexpected ':'") |
| return |
| } |
| if flags&checkIsStruct == 0 { |
| comp.error(t.Pos2, "unexpected ':', only struct fields can be bitfields") |
| return |
| } |
| } |
| if flags&checkIsTypedef != 0 && !desc.CanBeTypedef { |
| comp.error(t.Pos, "%v can't be type alias target", t.Ident) |
| return |
| } |
| if flags&checkIsResourceBase != 0 && !desc.ResourceBase { |
| comp.error(t.Pos, "%v can't be resource base (int types can)", t.Ident) |
| return |
| } |
| canBeArg, canBeRet := false, false |
| if desc.CanBeArgRet != nil { |
| canBeArg, canBeRet = desc.CanBeArgRet(comp, t) |
| } |
| if flags&checkIsRet != 0 && !canBeRet { |
| comp.error(t.Pos, "%v can't be syscall return", t.Ident) |
| return |
| } |
| if flags&checkIsArg != 0 && !canBeArg { |
| comp.error(t.Pos, "%v can't be syscall argument", t.Ident) |
| return |
| } |
| } |
| |
| func (comp *compiler) checkTypeArgs(t *ast.Type, desc *typeDesc, flags checkFlags) []*ast.Type { |
| args, opt := removeOpt(t) |
| if opt != nil { |
| if len(opt.Args) != 0 { |
| comp.error(opt.Pos, "opt can't have arguments") |
| } |
| if flags&checkIsResourceBase != 0 || desc.CantBeOpt { |
| what := "resource base" |
| if desc.CantBeOpt { |
| what = t.Ident |
| } |
| comp.error(opt.Pos, "%v can't be marked as opt", what) |
| return nil |
| } |
| } |
| addArgs := 0 |
| needBase := flags&checkIsArg == 0 && desc.NeedBase |
| if needBase { |
| addArgs++ // last arg must be base type, e.g. const[0, int32] |
| } |
| if len(args) > len(desc.Args)+addArgs || len(args) < len(desc.Args)-desc.OptArgs+addArgs { |
| comp.error(t.Pos, "wrong number of arguments for type %v, expect %v", |
| t.Ident, expectedTypeArgs(desc, needBase)) |
| return nil |
| } |
| if needBase { |
| base := args[len(args)-1] |
| args = args[:len(args)-1] |
| comp.checkTypeArg(t, base, typeArgBase) |
| } |
| return args |
| } |
| |
| func (comp *compiler) replaceTypedef(ctx *checkCtx, t *ast.Type, flags checkFlags) { |
| typedefName := t.Ident |
| comp.usedTypedefs[typedefName] = true |
| if t.HasColon { |
| comp.error(t.Pos, "type alias %v with ':'", t.Ident) |
| return |
| } |
| typedef := comp.typedefs[typedefName] |
| fullTypeName := ast.SerializeNode(t) |
| for i, prev := range ctx.instantiationStack { |
| if prev == fullTypeName { |
| ctx.instantiationStack = append(ctx.instantiationStack, fullTypeName) |
| path := "" |
| for j := i; j < len(ctx.instantiationStack); j++ { |
| if j != i { |
| path += " -> " |
| } |
| path += ctx.instantiationStack[j] |
| } |
| comp.error(t.Pos, "type instantiation loop: %v", path) |
| return |
| } |
| } |
| ctx.instantiationStack = append(ctx.instantiationStack, fullTypeName) |
| nargs := len(typedef.Args) |
| args := t.Args |
| if nargs != len(t.Args) { |
| if nargs == 0 { |
| comp.error(t.Pos, "type %v is not a template", typedefName) |
| } else { |
| comp.error(t.Pos, "template %v needs %v arguments instead of %v", |
| typedefName, nargs, len(t.Args)) |
| } |
| return |
| } |
| pos0 := t.Pos |
| if typedef.Type != nil { |
| *t = *typedef.Type.Clone().(*ast.Type) |
| if !comp.instantiate(t, typedef.Args, args) { |
| return |
| } |
| } else { |
| if comp.structs[fullTypeName] == nil { |
| inst := typedef.Struct.Clone().(*ast.Struct) |
| inst.Name.Name = fullTypeName |
| if !comp.instantiate(inst, typedef.Args, args) { |
| return |
| } |
| comp.checkStruct(*ctx, inst) |
| comp.desc.Nodes = append(comp.desc.Nodes, inst) |
| comp.structs[fullTypeName] = inst |
| } |
| *t = ast.Type{ |
| Ident: fullTypeName, |
| } |
| } |
| t.Pos = pos0 |
| |
| // Remove base type if it's not needed in this context. |
| desc := comp.getTypeDesc(t) |
| if flags&checkIsArg != 0 && desc.NeedBase { |
| baseTypePos := len(t.Args) - 1 |
| if t.Args[baseTypePos].Ident == "opt" { |
| baseTypePos-- |
| } |
| copy(t.Args[baseTypePos:], t.Args[baseTypePos+1:]) |
| t.Args = t.Args[:len(t.Args)-1] |
| } |
| } |
| |
| func (comp *compiler) instantiate(templ ast.Node, params []*ast.Ident, args []*ast.Type) bool { |
| if len(params) == 0 { |
| return true |
| } |
| argMap := make(map[string]*ast.Type) |
| for i, param := range params { |
| argMap[param.Name] = args[i] |
| } |
| err0 := comp.errors |
| templ.Walk(ast.Recursive(func(n ast.Node) { |
| templArg, ok := n.(*ast.Type) |
| if !ok { |
| return |
| } |
| if concreteArg := argMap[templArg.Ident]; concreteArg != nil { |
| origArgs := templArg.Args |
| if len(origArgs) != 0 && len(concreteArg.Args) != 0 { |
| comp.error(templArg.Pos, "both template parameter %v and its usage"+ |
| " have sub-arguments", templArg.Ident) |
| return |
| } |
| *templArg = *concreteArg.Clone().(*ast.Type) |
| if len(origArgs) != 0 { |
| templArg.Args = origArgs |
| } |
| } |
| // TODO(dvyukov): somewhat hacky, but required for int8[0:CONST_ARG] |
| // Need more checks here. E.g. that CONST_ARG does not have subargs. |
| // And if CONST_ARG is a value, then use concreteArg.Value. |
| // Also need to error if CONST_ARG is a string. |
| if concreteArg := argMap[templArg.Ident2]; concreteArg != nil { |
| templArg.Ident2 = concreteArg.Ident |
| templArg.Pos2 = concreteArg.Pos |
| } |
| })) |
| return err0 == comp.errors |
| } |
| |
| func (comp *compiler) checkTypeArg(t, arg *ast.Type, argDesc namedArg) { |
| desc := argDesc.Type |
| if len(desc.Names) != 0 { |
| if unexpected, _, ok := checkTypeKind(arg, kindIdent); !ok { |
| comp.error(arg.Pos, "unexpected %v for %v argument of %v type, expect %+v", |
| unexpected, argDesc.Name, t.Ident, desc.Names) |
| return |
| } |
| if !arrayContains(desc.Names, arg.Ident) { |
| comp.error(arg.Pos, "unexpected value %v for %v argument of %v type, expect %+v", |
| arg.Ident, argDesc.Name, t.Ident, desc.Names) |
| return |
| } |
| } else { |
| if unexpected, expect, ok := checkTypeKind(arg, desc.Kind); !ok { |
| comp.error(arg.Pos, "unexpected %v for %v argument of %v type, expect %v", |
| unexpected, argDesc.Name, t.Ident, expect) |
| return |
| } |
| } |
| if !desc.AllowColon && arg.HasColon { |
| comp.error(arg.Pos2, "unexpected ':'") |
| return |
| } |
| if len(arg.Args) > desc.MaxArgs { |
| comp.error(arg.Pos, "%v argument has subargs", argDesc.Name) |
| return |
| } |
| if desc.Check != nil { |
| desc.Check(comp, arg) |
| } |
| } |
| |
| func expectedTypeArgs(desc *typeDesc, needBase bool) string { |
| expect := "" |
| for i, arg := range desc.Args { |
| if expect != "" { |
| expect += ", " |
| } |
| opt := i >= len(desc.Args)-desc.OptArgs |
| if opt { |
| expect += "[" |
| } |
| expect += arg.Name |
| if opt { |
| expect += "]" |
| } |
| } |
| if needBase { |
| if expect != "" { |
| expect += ", " |
| } |
| expect += typeArgBase.Name |
| } |
| if !desc.CantBeOpt { |
| if expect != "" { |
| expect += ", " |
| } |
| expect += "[opt]" |
| } |
| if expect == "" { |
| expect = "no arguments" |
| } |
| return expect |
| } |
| |
| func checkTypeKind(t *ast.Type, kind int) (unexpected string, expect string, ok bool) { |
| switch { |
| case kind == kindAny: |
| ok = true |
| case t.HasString: |
| ok = kind == kindString |
| if !ok { |
| unexpected = fmt.Sprintf("string %q", t.String) |
| } |
| case t.Ident != "": |
| ok = kind == kindIdent || kind == kindInt |
| if !ok { |
| unexpected = fmt.Sprintf("identifier %v", t.Ident) |
| } |
| default: |
| ok = kind == kindInt |
| if !ok { |
| unexpected = fmt.Sprintf("int %v", t.Value) |
| } |
| } |
| if !ok { |
| switch kind { |
| case kindString: |
| expect = "string" |
| case kindIdent: |
| expect = "identifier" |
| case kindInt: |
| expect = "int" |
| } |
| } |
| return |
| } |
| |
| func (comp *compiler) checkVarlens() { |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Struct: |
| comp.checkVarlen(n) |
| } |
| } |
| } |
| |
| func (comp *compiler) isVarlen(t *ast.Type) bool { |
| desc, args, _ := comp.getArgsBase(t, "", prog.DirIn, false) |
| return desc.Varlen != nil && desc.Varlen(comp, t, args) |
| } |
| |
| func (comp *compiler) isZeroSize(t *ast.Type) bool { |
| desc, args, _ := comp.getArgsBase(t, "", prog.DirIn, false) |
| return desc.ZeroSize != nil && desc.ZeroSize(comp, t, args) |
| } |
| |
| func (comp *compiler) checkVarlen(n *ast.Struct) { |
| // Non-varlen unions can't have varlen fields. |
| // Non-packed structs can't have varlen fields in the middle. |
| if n.IsUnion { |
| if varlen, _ := comp.parseUnionAttrs(n); varlen { |
| return |
| } |
| } else { |
| if packed, _, _ := comp.parseStructAttrs(n); packed { |
| return |
| } |
| } |
| for i, f := range n.Fields { |
| if !n.IsUnion && i == len(n.Fields)-1 { |
| break |
| } |
| if comp.isVarlen(f.Type) { |
| if n.IsUnion { |
| comp.error(f.Pos, "variable size field %v in non-varlen union %v", |
| f.Name.Name, n.Name.Name) |
| } else { |
| comp.error(f.Pos, "variable size field %v in the middle of non-packed struct %v", |
| f.Name.Name, n.Name.Name) |
| } |
| } |
| } |
| } |
| |
| func (comp *compiler) checkDupConsts() { |
| // The idea is to detect copy-paste errors in const arguments, e.g.: |
| // call$FOO(fd fd, arg const[FOO]) |
| // call$BAR(fd fd, arg const[FOO]) |
| // The second one is meant to be const[BAR], |
| // Unfortunately, this does not fully work as it detects lots of false positives. |
| // But was useful to find real bugs as well. So for now it's disabled, but can be run manually. |
| if true { |
| return |
| } |
| dups := make(map[string]map[string]dupConstArg) |
| for _, decl := range comp.desc.Nodes { |
| switch n := decl.(type) { |
| case *ast.Call: |
| comp.checkDupConstsCall(n, dups) |
| } |
| } |
| } |
| |
| type dupConstArg struct { |
| pos ast.Pos |
| name string |
| } |
| |
| func (comp *compiler) checkDupConstsCall(n *ast.Call, dups map[string]map[string]dupConstArg) { |
| if n.NR == ^uint64(0) { |
| return |
| } |
| for dups[n.CallName] == nil { |
| dups[n.CallName] = make(map[string]dupConstArg) |
| } |
| hasConsts := false |
| constArgID := "" |
| for i, arg := range n.Args { |
| desc := comp.getTypeDesc(arg.Type) |
| if desc == typeConst { |
| v := arg.Type.Args[0].Value |
| if v != 0 && v != 18446744073709551516 { // AT_FDCWD |
| constArgID += fmt.Sprintf("(%v-%v)", i, fmt.Sprintf("%v", v)) |
| hasConsts = true |
| } |
| } else if desc == typeResource { |
| constArgID += fmt.Sprintf("(%v-%v)", i, arg.Type.Ident) |
| } |
| } |
| if !hasConsts { |
| return |
| } |
| dup, ok := dups[n.CallName][constArgID] |
| if !ok { |
| dups[n.CallName][constArgID] = dupConstArg{ |
| pos: n.Pos, |
| name: n.Name.Name, |
| } |
| return |
| } |
| comp.error(n.Pos, "call %v: duplicate const %v, previously used in call %v at %v", |
| n.Name.Name, constArgID, dup.name, dup.pos) |
| } |
