| // Copyright 2023 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package coding_tables |
| |
| import ( |
| "fmt" |
| "math" |
| "strconv" |
| "strings" |
| "unicode" |
| |
| "go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen" |
| cpp "go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen_cpp" |
| "golang.org/x/exp/slices" |
| ) |
| |
| type Root struct { |
| // Forward declarations of coding tables. |
| // Includes both our own and ones linked in from direct dependencies. |
| ForwardDecls []forwardDecl |
| |
| // Declarations (external linkage) |
| Bits []bits |
| Enums []enum |
| Structs []struct_ |
| Tables []table |
| Unions []union |
| |
| // Types used in declarations (internal linkage) |
| Arrays []array |
| Vectors []vector |
| Strings []string_ |
| Handles []handle |
| Boxes []box |
| } |
| |
| type forwardDecl struct { |
| Name string |
| CType string |
| StorageClass string |
| } |
| |
| type bits struct { |
| Name string |
| FidlName fidlgen.EncodedCompoundIdentifier |
| UnderlyingType string |
| Strictness string |
| Mask uint64 |
| } |
| |
| type enum struct { |
| Name string |
| FidlName fidlgen.EncodedCompoundIdentifier |
| UnderlyingType string |
| Strictness string |
| Validator string |
| Values []string |
| } |
| |
| type struct_ struct { |
| Name string |
| FidlName fidlgen.EncodedCompoundIdentifier |
| Emptiness string |
| InlineSize int |
| MembersName string |
| Members []structMember |
| } |
| |
| type structMember struct { |
| Offset int |
| // Set for non-padding members. |
| Type string |
| Resourceness string |
| // Set for padding members. |
| PaddingMaskBitWidth int |
| PaddingMask uint64 |
| } |
| |
| type table struct { |
| Name string |
| FidlName fidlgen.EncodedCompoundIdentifier |
| Resourceness string |
| MembersName string |
| Members []tableMember |
| } |
| |
| type tableMember struct { |
| Ordinal int |
| Type string |
| } |
| |
| type union struct { |
| Name string |
| FidlName fidlgen.EncodedCompoundIdentifier |
| NullableName string |
| Strictness string |
| Resourceness string |
| MembersName string |
| Members []unionMember |
| } |
| |
| type unionMember struct { |
| Type string |
| } |
| |
| type array struct { |
| Name string |
| ElementType string |
| InlineSize int |
| ElementSize int |
| } |
| |
| type vector struct { |
| Name string |
| ElementType string |
| MaxCount uint32 |
| Nullability string |
| ElementSize int |
| } |
| |
| type string_ struct { |
| Name string |
| MaxCount uint32 |
| Nullability string |
| } |
| |
| type handle struct { |
| Name string |
| ObjectType string |
| Rights string |
| Nullability string |
| } |
| |
| type box struct { |
| Name string |
| StructName string |
| } |
| |
| type compiler struct { |
| library fidlgen.EncodedLibraryIdentifier |
| decls fidlgen.DeclInfoMap |
| structs map[fidlgen.EncodedCompoundIdentifier]*fidlgen.Struct |
| seenTypes map[string]struct{} |
| out Root |
| } |
| |
| func (c *compiler) compileForwardDecl(name string, typ fidlgen.Type) forwardDecl { |
| storage := "static" |
| if typ.Kind == fidlgen.IdentifierType { |
| info, ok := c.decls[typ.Identifier] |
| if !ok { |
| panic(fmt.Sprintf("identifier not in decl map: %s", typ.Identifier)) |
| } |
| if info.Type != fidlgen.ProtocolDeclType && !(info.Type == fidlgen.StructDeclType && typ.Nullable) { |
| if typ.Identifier.LibraryName() == c.library { |
| storage = "" |
| } else { |
| // Extern is the default, but we use it to emphasize that this |
| // coding table will be linked in from another translation unit. |
| storage = "extern" |
| } |
| } |
| } |
| return forwardDecl{ |
| Name: name, |
| CType: forwardDeclCType(typ, c.decls), |
| StorageClass: storage, |
| } |
| } |
| |
| func (c *compiler) compileDecl(decl fidlgen.Decl) { |
| // Skip decls from other libraries, e.g. from "external_structs". |
| if decl.GetName().LibraryName() != c.library { |
| return |
| } |
| switch decl := decl.(type) { |
| case *fidlgen.Bits: |
| c.out.Bits = append(c.out.Bits, c.compileBits(*decl)) |
| case *fidlgen.Enum: |
| c.out.Enums = append(c.out.Enums, c.compileEnum(*decl)) |
| case *fidlgen.Struct: |
| c.out.Structs = append(c.out.Structs, c.compileStruct(*decl)) |
| case *fidlgen.Table: |
| c.out.Tables = append(c.out.Tables, c.compileTable(*decl)) |
| case *fidlgen.Union: |
| c.out.Unions = append(c.out.Unions, c.compileUnion(*decl)) |
| case *fidlgen.Alias, *fidlgen.Const, *fidlgen.NewType, *fidlgen.Overlay, |
| *fidlgen.Protocol, *fidlgen.Resource, *fidlgen.Service: |
| // These declarations don't go in coding tables. |
| default: |
| panic(fmt.Sprintf("unexpected decl type: %T", decl)) |
| } |
| } |
| |
| func (c *compiler) compileBits(v fidlgen.Bits) bits { |
| mask, err := strconv.ParseUint(v.Mask, 10, 64) |
| if err != nil { |
| panic(fmt.Sprintf("cannot parse bits mask: %s", err)) |
| } |
| return bits{ |
| FidlName: v.Name, |
| Name: compileDeclName(v.Name), |
| UnderlyingType: compilePrimitiveSubtype(v.Type.PrimitiveSubtype), |
| Strictness: compileStrictness(v.Strictness), |
| Mask: mask, |
| } |
| } |
| |
| func (c *compiler) compileEnum(v fidlgen.Enum) enum { |
| var validator string |
| if v.IsStrict() { |
| validator = "EnumValidatorFor_" + nameDecl(v.Name) |
| } |
| var values []string |
| for _, m := range v.Members { |
| // TODO(https://fxbug.dev/42086098): Centralize C++ integer literal logic. |
| var expr string |
| if m.Value.Value == "-9223372036854775808" { |
| expr = "-9223372036854775807 - 1" |
| } else if strings.HasPrefix(m.Value.Value, "-") { |
| expr = m.Value.Value |
| } else { |
| expr = m.Value.Value + "u" |
| } |
| values = append(values, expr) |
| } |
| return enum{ |
| FidlName: v.Name, |
| Name: compileDeclName(v.Name), |
| UnderlyingType: compilePrimitiveSubtype(v.Type), |
| Strictness: compileStrictness(v.Strictness), |
| Validator: validator, |
| Values: values, |
| } |
| } |
| |
| func (c *compiler) compileStruct(v fidlgen.Struct) struct_ { |
| var members []structMember |
| c.fillStructNonPaddingMembers(v, 0, &members) |
| c.fillStructPaddingMembers(v, &members) |
| slices.SortFunc(members, func(a, b structMember) int { return a.Offset - b.Offset }) |
| return struct_{ |
| FidlName: v.Name, |
| Name: compileDeclName(v.Name), |
| Emptiness: compileEmptiness(v.Members), |
| InlineSize: v.TypeShapeV2.InlineSize, |
| MembersName: compileMembersName(v.Name, len(members)), |
| Members: members, |
| } |
| } |
| |
| func (c *compiler) fillStructNonPaddingMembers(v fidlgen.Struct, baseOffset int, members *[]structMember) { |
| for _, m := range v.Members { |
| offset := baseOffset + m.FieldShapeV2.Offset |
| if nested, ok := c.structs[m.Type.Identifier]; ok && !m.Type.Nullable { |
| c.fillStructNonPaddingMembers(*nested, offset, members) |
| } else if c.canCopyWithoutValidation(m.Type) { |
| // No coding table member is needed. |
| } else { |
| *members = append(*members, structMember{ |
| Offset: offset, |
| Type: c.compilePointerToType(m.Type), |
| Resourceness: compileResourceness(c.decls.LookupResourceness(m.Type)), |
| }) |
| } |
| } |
| } |
| |
| func (c *compiler) fillStructPaddingMembers(v fidlgen.Struct, members *[]structMember) { |
| markers := v.BuildPaddingMarkers(fidlgen.PaddingConfig{ |
| FlattenStructs: true, |
| ResolveStruct: func(eci fidlgen.EncodedCompoundIdentifier) *fidlgen.Struct { return c.structs[eci] }, |
| }) |
| for _, marker := range markers { |
| *members = append(*members, structMember{ |
| Offset: marker.Offset, |
| PaddingMaskBitWidth: marker.MaskBitWidth, |
| PaddingMask: marker.Mask, |
| }) |
| } |
| } |
| |
| func (c *compiler) canCopyWithoutValidation(typ fidlgen.Type) bool { |
| switch typ.Kind { |
| case fidlgen.PrimitiveType: |
| return typ.PrimitiveSubtype != fidlgen.Bool |
| case fidlgen.ArrayType: |
| return c.canCopyWithoutValidation(*typ.ElementType) |
| case fidlgen.IdentifierType: |
| if s, ok := c.structs[typ.Identifier]; ok && !typ.Nullable && !s.TypeShapeV2.HasPadding { |
| for _, m := range s.Members { |
| if !c.canCopyWithoutValidation(m.Type) { |
| return false |
| } |
| } |
| return true |
| } |
| } |
| return false |
| } |
| |
| func (c *compiler) compileTable(v fidlgen.Table) table { |
| var members []tableMember |
| for _, m := range v.Members { |
| members = append(members, tableMember{ |
| Ordinal: m.Ordinal, |
| Type: c.compilePointerToType(m.Type), |
| }) |
| } |
| return table{ |
| FidlName: v.Name, |
| Name: compileDeclName(v.Name), |
| Resourceness: compileResourceness(v.Resourceness), |
| MembersName: compileMembersName(v.Name, len(members)), |
| Members: members, |
| } |
| } |
| |
| func (c *compiler) compileUnion(v fidlgen.Union) union { |
| nullableType := fidlgen.Type{ |
| Kind: fidlgen.IdentifierType, |
| Identifier: v.Name, |
| Nullable: true, |
| } |
| var members []unionMember |
| for _, m := range v.Members { |
| for len(members) < m.Ordinal-1 { |
| members = append(members, unionMember{Type: "NULL"}) |
| } |
| members = append(members, unionMember{ |
| Type: c.compilePointerToType(m.Type), |
| }) |
| } |
| return union{ |
| FidlName: v.Name, |
| Name: compileDeclName(v.Name), |
| NullableName: compileTypeName(nullableType, c.decls), |
| Strictness: compileStrictness(v.Strictness), |
| Resourceness: compileResourceness(v.Resourceness), |
| MembersName: compileMembersName(v.Name, len(v.Members)), |
| Members: members, |
| } |
| } |
| |
| func (c *compiler) compilePointerToType(typ fidlgen.Type) string { |
| return "(const fidl_type_t*)&" + c.compilePointerToTypeWithoutCast(typ) |
| } |
| |
| func (c *compiler) compilePointerToTypeWithoutCast(typ fidlgen.Type) string { |
| name := compileTypeName(typ, c.decls) |
| if _, ok := c.seenTypes[name]; !ok { |
| c.seenTypes[name] = struct{}{} |
| c.compileType(name, typ) |
| } |
| return name |
| } |
| |
| func (c *compiler) compileType(name string, typ fidlgen.Type) { |
| // Skip the forward declaration for types from #include <lib/fidl/internal.h>. |
| if !strings.HasPrefix(name, "fidl_internal_k") { |
| c.out.ForwardDecls = append(c.out.ForwardDecls, c.compileForwardDecl(name, typ)) |
| } |
| switch typ.Kind { |
| case fidlgen.ArrayType: |
| c.out.Arrays = append(c.out.Arrays, c.compileArray(name, typ)) |
| case fidlgen.VectorType: |
| c.out.Vectors = append(c.out.Vectors, c.compileVector(name, typ)) |
| case fidlgen.StringType: |
| c.out.Strings = append(c.out.Strings, c.compileString(name, typ)) |
| case fidlgen.HandleType, fidlgen.RequestType: |
| c.out.Handles = append(c.out.Handles, c.compileHandle(name, typ)) |
| case fidlgen.IdentifierType: |
| info, ok := c.decls[typ.Identifier] |
| if !ok { |
| panic(fmt.Sprintf("identifier not in decl map: %s", typ.Identifier)) |
| } |
| switch info.Type { |
| case fidlgen.StructDeclType: |
| if typ.Nullable { |
| c.out.Boxes = append(c.out.Boxes, c.compileBox(name, typ)) |
| } |
| case fidlgen.BitsDeclType, fidlgen.EnumDeclType, fidlgen.TableDeclType, fidlgen.UnionDeclType: |
| // Do nothing. All we need for these is the forward declaration above. |
| case fidlgen.ProtocolDeclType: |
| c.out.Handles = append(c.out.Handles, c.compileHandle(name, typ)) |
| default: |
| panic(fmt.Sprintf("identifier type refers to unexpected decl type: %s", info.Type)) |
| } |
| case fidlgen.PrimitiveType, fidlgen.InternalType: |
| // Do nothing. |
| case fidlgen.ZxExperimentalPointerType, fidlgen.StringArray: |
| panic(fmt.Sprintf("unsupported type kind for coding tables: %s", typ.Kind)) |
| default: |
| panic(fmt.Sprintf("unexpected type kind: %s", typ.Kind)) |
| } |
| } |
| |
| func (c *compiler) compileArray(name string, typ fidlgen.Type) array { |
| return array{ |
| Name: name, |
| ElementType: c.compilePointerToType(*typ.ElementType), |
| InlineSize: typ.TypeShapeV2.InlineSize, |
| ElementSize: typ.ElementType.TypeShapeV2.InlineSize, |
| } |
| } |
| |
| func (c *compiler) compileVector(name string, typ fidlgen.Type) vector { |
| return vector{ |
| Name: name, |
| ElementType: c.compilePointerToType(*typ.ElementType), |
| MaxCount: compileMaxCount(typ.ElementCount), |
| Nullability: compileNullability(typ.Nullable), |
| ElementSize: typ.ElementType.TypeShapeV2.InlineSize, |
| } |
| } |
| |
| func (c *compiler) compileString(name string, typ fidlgen.Type) string_ { |
| return string_{ |
| Name: name, |
| MaxCount: compileMaxCount(typ.ElementCount), |
| Nullability: compileNullability(typ.Nullable), |
| } |
| } |
| |
| func (c *compiler) compileHandle(name string, typ fidlgen.Type) handle { |
| info := cpp.FieldHandleInformation(typ, c.decls) |
| return handle{ |
| Name: name, |
| ObjectType: info.ObjectType, |
| Rights: info.Rights, |
| Nullability: compileNullability(typ.Nullable), |
| } |
| } |
| |
| func (c *compiler) compileBox(name string, typ fidlgen.Type) box { |
| return box{ |
| Name: name, |
| StructName: c.compilePointerToTypeWithoutCast(fidlgen.Type{ |
| Kind: fidlgen.IdentifierType, |
| Identifier: typ.Identifier, |
| Nullable: false, |
| }), |
| } |
| } |
| |
| func compileDeclName(eci fidlgen.EncodedCompoundIdentifier) string { |
| return nameDecl(eci) + "Table" |
| } |
| |
| func compileTypeName(typ fidlgen.Type, decls fidlgen.DeclInfoMap) string { |
| return nameType(typ, decls) + "Table" |
| } |
| |
| func compileMembersName(eci fidlgen.EncodedCompoundIdentifier, numMembers int) string { |
| if numMembers == 0 { |
| return "NULL" |
| } |
| return "Fields" + lengthPrefixed(nameDecl(eci)) |
| } |
| |
| func compileStrictness(s fidlgen.Strictness) string { |
| switch s { |
| case fidlgen.IsStrict: |
| return "kFidlStrictness_Strict" |
| case fidlgen.IsFlexible: |
| return "kFidlStrictness_Flexible" |
| default: |
| panic("unexpected strictness") |
| } |
| } |
| |
| func compileResourceness(r fidlgen.Resourceness) string { |
| switch fidlgen.Resourceness(r) { |
| case fidlgen.IsValueType: |
| return "kFidlIsResource_NotResource" |
| case fidlgen.IsResourceType: |
| return "kFidlIsResource_Resource" |
| default: |
| panic("unexpected resourceness") |
| } |
| } |
| |
| func compileNullability(nullable bool) string { |
| if nullable { |
| return "kFidlNullability_Nullable" |
| } |
| return "kFidlNullability_Nonnullable" |
| } |
| |
| func compilePrimitiveSubtype(p fidlgen.PrimitiveSubtype) string { |
| return "kFidlCodedPrimitiveSubtype_" + namePrimitiveSubtype(p) |
| } |
| |
| func compileEmptiness(members []fidlgen.StructMember) string { |
| if len(members) == 0 { |
| return "kFidlEmpty_IsEmpty" |
| } |
| return "kFidlEmpty_IsNotEmpty" |
| } |
| |
| func compileMaxCount(n *int) uint32 { |
| if n == nil { |
| return math.MaxUint32 |
| } |
| return uint32(*n) |
| } |
| |
| func forwardDeclCType(typ fidlgen.Type, decls fidlgen.DeclInfoMap) string { |
| switch typ.Kind { |
| case fidlgen.ArrayType: |
| return "FidlCodedArray" |
| case fidlgen.VectorType: |
| return "FidlCodedVector" |
| case fidlgen.StringType: |
| return "FidlCodedString" |
| case fidlgen.HandleType, fidlgen.RequestType: |
| return "FidlCodedHandle" |
| case fidlgen.IdentifierType: |
| info, ok := decls[typ.Identifier] |
| if !ok { |
| panic(fmt.Sprintf("identifier not in decl map: %s", typ.Identifier)) |
| } |
| switch info.Type { |
| case fidlgen.BitsDeclType: |
| return "FidlCodedBits" |
| case fidlgen.EnumDeclType: |
| return "FidlCodedEnum" |
| case fidlgen.StructDeclType: |
| if typ.Nullable { |
| return "FidlCodedStructPointer" |
| } |
| return "FidlCodedStruct" |
| case fidlgen.TableDeclType: |
| return "FidlCodedTable" |
| case fidlgen.UnionDeclType: |
| return "FidlCodedUnion" |
| case fidlgen.ProtocolDeclType: |
| return "FidlCodedHandle" |
| default: |
| panic(fmt.Sprintf("identifier type refers to unexpected decl type: %s", info.Type)) |
| } |
| case fidlgen.PrimitiveType, fidlgen.InternalType: |
| panic(fmt.Sprintf("should not need to forward declare type kind: %s", typ.Kind)) |
| case fidlgen.ZxExperimentalPointerType, fidlgen.StringArray: |
| panic(fmt.Sprintf("unsupported type kind for coding tables: %s", typ.Kind)) |
| default: |
| panic(fmt.Sprintf("unexpected type kind: %s", typ.Kind)) |
| } |
| } |
| |
| func nameType(typ fidlgen.Type, decls fidlgen.DeclInfoMap) string { |
| switch typ.Kind { |
| case fidlgen.ArrayType: |
| return fmt.Sprintf("Array%s_%s", nameSize(typ.ElementCount), lengthPrefixed(nameType(*typ.ElementType, decls))) |
| case fidlgen.VectorType: |
| return fmt.Sprintf("Vector%s%s_%s", nameSize(typ.ElementCount), nameNullability(typ.Nullable), lengthPrefixed(nameType(*typ.ElementType, decls))) |
| case fidlgen.StringType: |
| return fmt.Sprintf("String%s%s", nameSize(typ.ElementCount), nameNullability(typ.Nullable)) |
| case fidlgen.HandleType: |
| return fmt.Sprintf("Handle%s%d%s", typ.HandleSubtype, typ.HandleRights, nameNullability(typ.Nullable)) |
| case fidlgen.RequestType: |
| return fmt.Sprintf("Request%s%s", lengthPrefixed(nameDecl(typ.Identifier)), nameNullability(typ.Nullable)) |
| case fidlgen.PrimitiveType: |
| return fmt.Sprintf("fidl_internal_k%s", namePrimitiveSubtype(typ.PrimitiveSubtype)) |
| case fidlgen.InternalType: |
| return fmt.Sprintf("fidl_internal_k%s", nameInternalSubtype(typ.InternalSubtype)) |
| case fidlgen.IdentifierType: |
| info, ok := decls[typ.Identifier] |
| if !ok { |
| panic(fmt.Sprintf("identifier not in decl map: %s", typ.Identifier)) |
| } |
| if typ.Identifier.LibraryName() == "zx" { |
| switch typ.Identifier { |
| // We emit zx_obj_type_t and zx_rights_t for these types in |
| // bindings, so treat them as such in coding tables as well. |
| case "zx/ObjType", "zx/Rights": |
| return nameType(fidlgen.Type{Kind: fidlgen.PrimitiveType, PrimitiveSubtype: fidlgen.Uint32}, decls) |
| default: |
| panic(fmt.Sprintf("unexpected zx type: %s", typ.Identifier)) |
| } |
| } |
| switch info.Type { |
| case fidlgen.BitsDeclType, fidlgen.EnumDeclType, fidlgen.TableDeclType: |
| return nameDecl(typ.Identifier) |
| case fidlgen.StructDeclType: |
| if typ.Nullable { |
| return fmt.Sprintf("Pointer%s", lengthPrefixed(nameDecl(typ.Identifier))) |
| } |
| return nameDecl(typ.Identifier) |
| case fidlgen.UnionDeclType: |
| if typ.Nullable { |
| return fmt.Sprintf("%sNullableRef", nameDecl(typ.Identifier)) |
| } |
| return nameDecl(typ.Identifier) |
| case fidlgen.ProtocolDeclType: |
| return fmt.Sprintf("Protocol%s%s", lengthPrefixed(nameDecl(typ.Identifier)), nameNullability(typ.Nullable)) |
| default: |
| panic(fmt.Sprintf("identifier type refers to unexpected decl type: %s", info.Type)) |
| } |
| case fidlgen.ZxExperimentalPointerType, fidlgen.StringArray: |
| panic(fmt.Sprintf("unsupported type kind for coding tables: %s", typ.Kind)) |
| default: |
| panic(fmt.Sprintf("unexpected type kind: %s", typ.Kind)) |
| } |
| } |
| |
| func nameDecl(eci fidlgen.EncodedCompoundIdentifier) string { |
| s := string(eci) |
| s = strings.Replace(s, "/", "_", 1) |
| s = strings.ReplaceAll(s, ".", "_") |
| return s |
| } |
| |
| func nameSize(n *int) string { |
| if n == nil { |
| return "unbounded" |
| } |
| return strconv.Itoa(*n) |
| } |
| |
| func nameNullability(nullable bool) string { |
| if nullable { |
| return "nullable" |
| } |
| return "notnullable" |
| } |
| |
| func namePrimitiveSubtype(t fidlgen.PrimitiveSubtype) string { |
| s := string(t) |
| return string(unicode.ToUpper(rune(s[0]))) + s[1:] |
| } |
| |
| func nameInternalSubtype(t fidlgen.InternalSubtype) string { |
| switch t { |
| case fidlgen.FrameworkErr: |
| return "FrameworkErr" |
| default: |
| panic(fmt.Sprintf("unexpected internal subtype: %s", t)) |
| } |
| } |
| |
| func lengthPrefixed(s string) string { |
| return fmt.Sprintf("%d%s", len(s), s) |
| } |
| |
| func Compile(r fidlgen.Root) Root { |
| c := compiler{ |
| library: r.Name, |
| decls: r.DeclInfo(), |
| structs: make(map[fidlgen.EncodedCompoundIdentifier]*fidlgen.Struct), |
| seenTypes: make(map[string]struct{}), |
| } |
| for i := range r.Structs { |
| s := &r.Structs[i] |
| c.structs[s.Name] = s |
| } |
| r.ForEachDecl(c.compileDecl) |
| return c.out |
| } |
