_ = x[TagConstType-38]
	_ = x[TagConstant-39]
	_ = x[TagEnumerator-40]
	_ = x[TagFileType-41]
	_ = x[TagFriend-42]
	_ = x[TagNamelist-43]
	_ = x[TagNamelistItem-44]
	_ = x[TagPackedType-45]
	_ = x[TagSubprogram-46]
	_ = x[TagTemplateTypeParameter-47]
	_ = x[TagTemplateValueParameter-48]
	_ = x[TagThrownType-49]
	_ = x[TagTryDwarfBlock-50]
	_ = x[TagVariantPart-51]
	_ = x[TagVariable-52]
	_ = x[TagVolatileType-53]

		return nil
	}

	// Try to find the function name.
	name := ""
FindName:
	for entry, err := r.Next(); entry != nil && err == nil; entry, err = r.Next() {
		if entry.Tag == dwarf.TagSubprogram {
			ranges, err := f.dwarf.Ranges(entry)
			if err != nil {
				return nil
			}
			for _, pcs := range ranges {
				if pcs[0] <= addr && addr < pcs[1] {
					var ok bool

	TagFileType               Tag = 0x29
	TagFriend                 Tag = 0x2A
	TagNamelist               Tag = 0x2B
	TagNamelistItem           Tag = 0x2C
	TagPackedType             Tag = 0x2D
	TagSubprogram             Tag = 0x2E
	TagTemplateTypeParameter  Tag = 0x2F
	TagTemplateValueParameter Tag = 0x30
	TagThrownType             Tag = 0x31
	TagTryDwarfBlock          Tag = 0x32
	TagVariantPart            Tag = 0x33

		d := elfData(t, test.filename)
		subprograms := test.subprograms

		r := d.Reader()
		i := 0
		for entry, err := r.Next(); entry != nil && err == nil; entry, err = r.Next() {
			if entry.Tag != TagSubprogram {
				continue
			}

			if i > len(subprograms) {
				t.Fatalf("%s: too many subprograms (expected at most %d)", test.filename, i)
			}

	}

	// look for main.main
	r := d.Reader()
	for {
		e, err := r.Next()
		if err != nil {
			t.Fatal("r.Next:", err)
		}
		if e == nil {
			break
		}
		if e.Tag == dwarf.TagSubprogram {
			name, ok := e.Val(dwarf.AttrName).(string)
			if ok && name == "main.main" {
				t.Logf("Found main.main")
				addr, ok := e.Val(dwarf.AttrLowpc).(uint64)
				if !ok {
					t.Fatal("Failed to get AttrLowpc")

				return e, nil
			}
		}
		unit++
	}
	return nil, ErrUnknownPC
}

// Ranges returns the PC ranges covered by e, a slice of [low,high) pairs.
// Only some entry types, such as [TagCompileUnit] or [TagSubprogram], have PC
// ranges; for others, this will return nil with no error.
func (d *Data) Ranges(e *Entry) ([][2]uint64, error) {
	var ret [][2]uint64

	low, lowOK := e.Val(AttrLowpc).(uint64)

		t.Fatalf("unable to locate DIE for %s", sym)
	}
	if len(dies) != 1 {
		t.Fatalf("more than one %s DIE: %+v", sym, dies)
	}
	die := dies[0]

	// Vet the DIE.
	if die.Tag != dwarf.TagSubprogram {
		t.Fatalf("unexpected tag %v on %s DIE", die.Tag, sym)
	}

	return die
}

func TestEmbeddedStructMarker(t *testing.T) {
	t.Parallel()
	testenv.MustHaveGoBuild(t)

	mustHaveDWARF(t)

		{"TagRvalueReferenceType", Const, 3},
		{"TagSetType", Const, 0},
		{"TagSharedType", Const, 3},
		{"TagSkeletonUnit", Const, 14},
		{"TagStringType", Const, 0},
		{"TagStructType", Const, 0},
		{"TagSubprogram", Const, 0},
		{"TagSubrangeType", Const, 0},
		{"TagSubroutineType", Const, 0},
		{"TagTemplateAlias", Const, 3},
		{"TagTemplateTypeParameter", Const, 0},
		{"TagTemplateValueParameter", Const, 0},

pkg debug/dwarf, const TagRestrictType Tag
pkg debug/dwarf, const TagSetType Tag
pkg debug/dwarf, const TagStringType Tag
pkg debug/dwarf, const TagStructType Tag
pkg debug/dwarf, const TagSubprogram Tag
pkg debug/dwarf, const TagSubrangeType Tag
pkg debug/dwarf, const TagSubroutineType Tag
pkg debug/dwarf, const TagTemplateTypeParameter Tag
pkg debug/dwarf, const TagTemplateValueParameter Tag

pkg debug/dwarf, const TagRestrictType = 55
pkg debug/dwarf, const TagSetType = 32
pkg debug/dwarf, const TagStringType = 18
pkg debug/dwarf, const TagStructType = 19
pkg debug/dwarf, const TagSubprogram = 46
pkg debug/dwarf, const TagSubrangeType = 33
pkg debug/dwarf, const TagSubroutineType = 21
pkg debug/dwarf, const TagTemplateTypeParameter = 47
pkg debug/dwarf, const TagTemplateValueParameter = 48