btf: export DeclTag and TypeTag

Makefile

@@ -49,6 +49,7 @@ TARGETS := \
 	btf/testdata/relocs_read \
 	btf/testdata/relocs_read_tgt \
 	btf/testdata/relocs_enum \
+	btf/testdata/tags \
 	cmd/bpf2go/testdata/minimal
 
 .PHONY: all clean container-all container-shell generate

btf/btf.go

@@ -695,5 +695,13 @@ func (iter *TypesIterator) Next() bool {
 	iter.Type, ok = iter.spec.typeByID(iter.id)
 	iter.id++
 	iter.done = !ok
+	if !iter.done {
+		// Skip declTags, during unmarshaling declTags become `Tags` fields of other types.
+		// We keep them in the spec to avoid holes in the ID space, but for the purposes of
+		// iteration, they are not useful to the user.
+		if _, ok := iter.Type.(*declTag); ok {
+			return iter.Next()
+		}
+	}
 	return !iter.done
 }

btf/marshal.go

@@ -409,7 +409,7 @@ func (e *encoder) deflateType(typ Type) (err error) {
 		raw.data = &btfDeclTag{uint32(v.Index)}
 		raw.NameOff, err = e.strings.Add(v.Value)
 
-	case *typeTag:
+	case *TypeTag:
 		raw.SetKind(kindTypeTag)
 		raw.SetType(e.id(v.Type))
 		raw.NameOff, err = e.strings.Add(v.Value)
@@ -521,7 +521,7 @@ func (e *encoder) deflateEnum64(raw *rawType, enum *Enum) (err error) {
 			})
 		}
 
-		return e.deflateUnion(raw, &Union{enum.Name, enum.Size, members})
+		return e.deflateUnion(raw, &Union{enum.Name, enum.Size, members, nil})
 	}
 
 	raw.SetKind(kindEnum64)

btf/marshal_test.go

@@ -24,7 +24,7 @@ func TestBuilderMarshal(t *testing.T) {
 		(*Void)(nil),
 		typ,
 		&Pointer{typ},
-		&Typedef{"baz", typ},
+		&Typedef{"baz", typ, nil},
 	}
 
 	b, err := NewBuilder(want)
@@ -65,7 +65,7 @@ func TestBuilderAdd(t *testing.T) {
 	qt.Assert(t, qt.IsNil(err))
 	qt.Assert(t, qt.Equals(id, TypeID(2)), qt.Commentf("Adding a type twice returns different ids"))
 
-	id, err = b.Add(&Typedef{"baz", i})
+	id, err = b.Add(&Typedef{"baz", i, nil})
 	qt.Assert(t, qt.IsNil(err))
 	qt.Assert(t, qt.Equals(id, TypeID(3)))
 }

btf/testdata/tags.c

@@ -0,0 +1,37 @@
+#include "../../testdata/common.h"
+
+#define tagA __attribute__((btf_decl_tag("a")))
+#define tagB __attribute__((btf_decl_tag("b")))
+#define tagC __attribute__((btf_decl_tag("c")))
+#define tagD __attribute__((btf_decl_tag("d")))
+#define tagE __attribute__((btf_decl_tag("e")))
+
+struct s {
+	char tagA foo;
+	char tagB bar;
+} tagC;
+
+union u {
+	char tagA foo;
+	char tagB bar;
+} tagC;
+
+typedef tagB char td;
+
+struct s tagD s1;
+union u tagE u1;
+td tagA t1;
+
+int tagA tagB fwdDecl(char tagC x, char tagD y);
+
+int tagE normalDecl1(char tagB x, char tagC y) {
+	return fwdDecl(x, y);
+}
+
+int tagE normalDecl2(char tagB x, char tagC y) {
+	return fwdDecl(x, y);
+}
+
+__section("syscall") int prog(char *ctx) {
+	return normalDecl1(ctx[0], ctx[1]) + normalDecl2(ctx[2], ctx[3]);
+}

btf/traversal.go

@@ -40,9 +40,12 @@ func children(typ Type, yield func(child *Type) bool) bool {
 	// Explicitly type switch on the most common types to allow the inliner to
 	// do its work. This avoids allocating intermediate slices from walk() on
 	// the heap.
+	var tags []string
 	switch v := typ.(type) {
-	case *Void, *Int, *Enum, *Fwd, *Float:
+	case *Void, *Int, *Enum, *Fwd, *Float, *declTag:
 		// No children to traverse.
+		// declTags is declared as a leaf type since it's parsed into .Tags fields of other types
+		// during unmarshaling.
 	case *Pointer:
 		if !yield(&v.Target) {
 			return false
@@ -59,17 +62,32 @@ func children(typ Type, yield func(child *Type) bool) bool {
 			if !yield(&v.Members[i].Type) {
 				return false
 			}
+			for _, t := range v.Members[i].Tags {
+				var tag Type = &declTag{v, t, i}
+				if !yield(&tag) {
+					return false
+				}
+			}
 		}
+		tags = v.Tags
 	case *Union:
 		for i := range v.Members {
 			if !yield(&v.Members[i].Type) {
 				return false
 			}
+			for _, t := range v.Members[i].Tags {
+				var tag Type = &declTag{v, t, i}
+				if !yield(&tag) {
+					return false
+				}
+			}
 		}
+		tags = v.Tags
 	case *Typedef:
 		if !yield(&v.Type) {
 			return false
 		}
+		tags = v.Tags
 	case *Volatile:
 		if !yield(&v.Type) {
 			return false
@@ -86,6 +104,20 @@ func children(typ Type, yield func(child *Type) bool) bool {
 		if !yield(&v.Type) {
 			return false
 		}
+		if fp, ok := v.Type.(*FuncProto); ok {
+			for i := range fp.Params {
+				if len(v.ParamTags) <= i {
+					continue
+				}
+				for _, t := range v.ParamTags[i] {
+					var tag Type = &declTag{v, t, i}
+					if !yield(&tag) {
+						return false
+					}
+				}
+			}
+		}
+		tags = v.Tags
 	case *FuncProto:
 		if !yield(&v.Return) {
 			return false
@@ -99,17 +131,14 @@ func children(typ Type, yield func(child *Type) bool) bool {
 		if !yield(&v.Type) {
 			return false
 		}
+		tags = v.Tags
 	case *Datasec:
 		for i := range v.Vars {
 			if !yield(&v.Vars[i].Type) {
 				return false
 			}
 		}
-	case *declTag:
-		if !yield(&v.Type) {
-			return false
-		}
-	case *typeTag:
+	case *TypeTag:
 		if !yield(&v.Type) {
 			return false
 		}
@@ -119,5 +148,12 @@ func children(typ Type, yield func(child *Type) bool) bool {
 		panic(fmt.Sprintf("don't know how to walk Type %T", v))
 	}
 
+	for _, t := range tags {
+		var tag Type = &declTag{typ, t, -1}
+		if !yield(&tag) {
+			return false
+		}
+	}
+
 	return true
 }