SVE intrinsics: Fold svdiv with all-zero operands to zero vector

[official-gcc.git] / libgo / go / debug / dwarf / type.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// DWARF type information structures.
// The format is heavily biased toward C, but for simplicity
// the String methods use a pseudo-Go syntax.

package dwarf

import "strconv"

// A Type conventionally represents a pointer to any of the
// specific Type structures (CharType, StructType, etc.).
type Type interface {
        Common() *CommonType
        String() string
        Size() int64
}

// A CommonType holds fields common to multiple types.
// If a field is not known or not applicable for a given type,
// the zero value is used.
type CommonType struct {
        ByteSize int64  // size of value of this type, in bytes
        Name     string // name that can be used to refer to type
}

func (c *CommonType) Common() *CommonType { return c }

func (c *CommonType) Size() int64 { return c.ByteSize }

// Basic types

// A BasicType holds fields common to all basic types.
//
// See the documentation for StructField for more info on the interpretation of
// the BitSize/BitOffset/DataBitOffset fields.
type BasicType struct {
        CommonType
        BitSize       int64
        BitOffset     int64
        DataBitOffset int64
}

func (b *BasicType) Basic() *BasicType { return b }

func (t *BasicType) String() string {
        if t.Name != "" {
                return t.Name
        }
        return "?"
}

// A CharType represents a signed character type.
type CharType struct {
        BasicType
}

// A UcharType represents an unsigned character type.
type UcharType struct {
        BasicType
}

// An IntType represents a signed integer type.
type IntType struct {
        BasicType
}

// A UintType represents an unsigned integer type.
type UintType struct {
        BasicType
}

// A FloatType represents a floating point type.
type FloatType struct {
        BasicType
}

// A ComplexType represents a complex floating point type.
type ComplexType struct {
        BasicType
}

// A BoolType represents a boolean type.
type BoolType struct {
        BasicType
}

// An AddrType represents a machine address type.
type AddrType struct {
        BasicType
}

// An UnspecifiedType represents an implicit, unknown, ambiguous or nonexistent type.
type UnspecifiedType struct {
        BasicType
}

// qualifiers

// A QualType represents a type that has the C/C++ "const", "restrict", or "volatile" qualifier.
type QualType struct {
        CommonType
        Qual string
        Type Type
}

func (t *QualType) String() string { return t.Qual + " " + t.Type.String() }

func (t *QualType) Size() int64 { return t.Type.Size() }

// An ArrayType represents a fixed size array type.
type ArrayType struct {
        CommonType
        Type          Type
        StrideBitSize int64 // if > 0, number of bits to hold each element
        Count         int64 // if == -1, an incomplete array, like char x[].
}

func (t *ArrayType) String() string {
        return "[" + strconv.FormatInt(t.Count, 10) + "]" + t.Type.String()
}

func (t *ArrayType) Size() int64 {
        if t.Count == -1 {
                return 0
        }
        return t.Count * t.Type.Size()
}

// A VoidType represents the C void type.
type VoidType struct {
        CommonType
}

func (t *VoidType) String() string { return "void" }

// A PtrType represents a pointer type.
type PtrType struct {
        CommonType
        Type Type
}

func (t *PtrType) String() string { return "*" + t.Type.String() }

// A StructType represents a struct, union, or C++ class type.
type StructType struct {
        CommonType
        StructName string
        Kind       string // "struct", "union", or "class".
        Field      []*StructField
        Incomplete bool // if true, struct, union, class is declared but not defined
}

// A StructField represents a field in a struct, union, or C++ class type.
//
// Bit Fields
//
// The BitSize, BitOffset, and DataBitOffset fields describe the bit
// size and offset of data members declared as bit fields in C/C++
// struct/union/class types.
//
// BitSize is the number of bits in the bit field.
//
// DataBitOffset, if non-zero, is the number of bits from the start of
// the enclosing entity (e.g. containing struct/class/union) to the
// start of the bit field. This corresponds to the DW_AT_data_bit_offset
// DWARF attribute that was introduced in DWARF 4.
//
// BitOffset, if non-zero, is the number of bits between the most
// significant bit of the storage unit holding the bit field to the
// most significant bit of the bit field. Here "storage unit" is the
// type name before the bit field (for a field "unsigned x:17", the
// storage unit is "unsigned"). BitOffset values can vary depending on
// the endianness of the system. BitOffset corresponds to the
// DW_AT_bit_offset DWARF attribute that was deprecated in DWARF 4 and
// removed in DWARF 5.
//
// At most one of DataBitOffset and BitOffset will be non-zero;
// DataBitOffset/BitOffset will only be non-zero if BitSize is
// non-zero. Whether a C compiler uses one or the other
// will depend on compiler vintage and command line options.
//
// Here is an example of C/C++ bit field use, along with what to
// expect in terms of DWARF bit offset info. Consider this code:
//
// struct S {
//   int q;
//   int j:5;
//   int k:6;
//   int m:5;
//   int n:8;
// } s;
//
// For the code above, one would expect to see the following for
// DW_AT_bit_offset values (using GCC 8):
//
//          Little   |     Big
//          Endian   |    Endian
//                   |
//   "j":     27     |     0
//   "k":     21     |     5
//   "m":     16     |     11
//   "n":     8      |     16
//
// Note that in the above the offsets are purely with respect to the
// containing storage unit for j/k/m/n -- these values won't vary based
// on the size of prior data members in the containing struct.
//
// If the compiler emits DW_AT_data_bit_offset, the expected values
// would be:
//
//   "j":     32
//   "k":     37
//   "m":     43
//   "n":     48
//
// Here the value 32 for "j" reflects the fact that the bit field is
// preceded by other data members (recall that DW_AT_data_bit_offset
// values are relative to the start of the containing struct). Hence
// DW_AT_data_bit_offset values can be quite large for structs with
// many fields.
//
// DWARF also allow for the possibility of base types that have
// non-zero bit size and bit offset, so this information is also
// captured for base types, but it is worth noting that it is not
// possible to trigger this behavior using mainstream languages.
//
type StructField struct {
        Name          string
        Type          Type
        ByteOffset    int64
        ByteSize      int64 // usually zero; use Type.Size() for normal fields
        BitOffset     int64
        DataBitOffset int64
        BitSize       int64 // zero if not a bit field
}

func (t *StructType) String() string {
        if t.StructName != "" {
                return t.Kind + " " + t.StructName
        }
        return t.Defn()
}

func (f *StructField) bitOffset() int64 {
        if f.BitOffset != 0 {
                return f.BitOffset
        }
        return f.DataBitOffset
}

func (t *StructType) Defn() string {
        s := t.Kind
        if t.StructName != "" {
                s += " " + t.StructName
        }
        if t.Incomplete {
                s += " /*incomplete*/"
                return s
        }
        s += " {"
        for i, f := range t.Field {
                if i > 0 {
                        s += "; "
                }
                s += f.Name + " " + f.Type.String()
                s += "@" + strconv.FormatInt(f.ByteOffset, 10)
                if f.BitSize > 0 {
                        s += " : " + strconv.FormatInt(f.BitSize, 10)
                        s += "@" + strconv.FormatInt(f.bitOffset(), 10)
                }
        }
        s += "}"
        return s
}

// An EnumType represents an enumerated type.
// The only indication of its native integer type is its ByteSize
// (inside CommonType).
type EnumType struct {
        CommonType
        EnumName string
        Val      []*EnumValue
}

// An EnumValue represents a single enumeration value.
type EnumValue struct {
        Name string
        Val  int64
}

func (t *EnumType) String() string {
        s := "enum"
        if t.EnumName != "" {
                s += " " + t.EnumName
        }
        s += " {"
        for i, v := range t.Val {
                if i > 0 {
                        s += "; "
                }
                s += v.Name + "=" + strconv.FormatInt(v.Val, 10)
        }
        s += "}"
        return s
}

// A FuncType represents a function type.
type FuncType struct {
        CommonType
        ReturnType Type
        ParamType  []Type
}

func (t *FuncType) String() string {
        s := "func("
        for i, t := range t.ParamType {
                if i > 0 {
                        s += ", "
                }
                s += t.String()
        }
        s += ")"
        if t.ReturnType != nil {
                s += " " + t.ReturnType.String()
        }
        return s
}

// A DotDotDotType represents the variadic ... function parameter.
type DotDotDotType struct {
        CommonType
}

func (t *DotDotDotType) String() string { return "..." }

// A TypedefType represents a named type.
type TypedefType struct {
        CommonType
        Type Type
}

func (t *TypedefType) String() string { return t.Name }

func (t *TypedefType) Size() int64 { return t.Type.Size() }

// An UnsupportedType is a placeholder returned in situations where we
// encounter a type that isn't supported.
type UnsupportedType struct {
        CommonType
        Tag Tag
}

func (t *UnsupportedType) String() string {
        if t.Name != "" {
                return t.Name
        }
        return t.Name + "(unsupported type " + t.Tag.String() + ")"
}

// typeReader is used to read from either the info section or the
// types section.
type typeReader interface {
        Seek(Offset)
        Next() (*Entry, error)
        clone() typeReader
        offset() Offset
        // AddressSize returns the size in bytes of addresses in the current
        // compilation unit.
        AddressSize() int
}

// Type reads the type at off in the DWARF ``info'' section.
func (d *Data) Type(off Offset) (Type, error) {
        return d.readType("info", d.Reader(), off, d.typeCache, nil)
}

type typeFixer struct {
        typedefs   []*TypedefType
        arraytypes []*Type
}

func (tf *typeFixer) recordArrayType(t *Type) {
        if t == nil {
                return
        }
        _, ok := (*t).(*ArrayType)
        if ok {
                tf.arraytypes = append(tf.arraytypes, t)
        }
}

func (tf *typeFixer) apply() {
        for _, t := range tf.typedefs {
                t.Common().ByteSize = t.Type.Size()
        }
        for _, t := range tf.arraytypes {
                zeroArray(t)
        }
}

// readType reads a type from r at off of name. It adds types to the
// type cache, appends new typedef types to typedefs, and computes the
// sizes of types. Callers should pass nil for typedefs; this is used
// for internal recursion.
func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type, fixups *typeFixer) (Type, error) {
        if t, ok := typeCache[off]; ok {
                return t, nil
        }
        r.Seek(off)
        e, err := r.Next()
        if err != nil {
                return nil, err
        }
        addressSize := r.AddressSize()
        if e == nil || e.Offset != off {
                return nil, DecodeError{name, off, "no type at offset"}
        }

        // If this is the root of the recursion, prepare to resolve
        // typedef sizes and perform other fixups once the recursion is
        // done. This must be done after the type graph is constructed
        // because it may need to resolve cycles in a different order than
        // readType encounters them.
        if fixups == nil {
                var fixer typeFixer
                defer func() {
                        fixer.apply()
                }()
                fixups = &fixer
        }

        // Parse type from Entry.
        // Must always set typeCache[off] before calling
        // d.readType recursively, to handle circular types correctly.
        var typ Type

        nextDepth := 0

        // Get next child; set err if error happens.
        next := func() *Entry {
                if !e.Children {
                        return nil
                }
                // Only return direct children.
                // Skip over composite entries that happen to be nested
                // inside this one. Most DWARF generators wouldn't generate
                // such a thing, but clang does.
                // See golang.org/issue/6472.
                for {
                        kid, err1 := r.Next()
                        if err1 != nil {
                                err = err1
                                return nil
                        }
                        if kid == nil {
                                err = DecodeError{name, r.offset(), "unexpected end of DWARF entries"}
                                return nil
                        }
                        if kid.Tag == 0 {
                                if nextDepth > 0 {
                                        nextDepth--
                                        continue
                                }
                                return nil
                        }
                        if kid.Children {
                                nextDepth++
                        }
                        if nextDepth > 0 {
                                continue
                        }
                        return kid
                }
        }

        // Get Type referred to by Entry's AttrType field.
        // Set err if error happens. Not having a type is an error.
        typeOf := func(e *Entry) Type {
                tval := e.Val(AttrType)
                var t Type
                switch toff := tval.(type) {
                case Offset:
                        if t, err = d.readType(name, r.clone(), toff, typeCache, fixups); err != nil {
                                return nil
                        }
                case uint64:
                        if t, err = d.sigToType(toff); err != nil {
                                return nil
                        }
                default:
                        // It appears that no Type means "void".
                        return new(VoidType)
                }
                return t
        }

        switch e.Tag {
        case TagArrayType:
                // Multi-dimensional array.  (DWARF v2 §5.4)
                // Attributes:
                //      AttrType:subtype [required]
                //      AttrStrideSize: size in bits of each element of the array
                //      AttrByteSize: size of entire array
                // Children:
                //      TagSubrangeType or TagEnumerationType giving one dimension.
                //      dimensions are in left to right order.
                t := new(ArrayType)
                typ = t
                typeCache[off] = t
                if t.Type = typeOf(e); err != nil {
                        goto Error
                }
                t.StrideBitSize, _ = e.Val(AttrStrideSize).(int64)

                // Accumulate dimensions,
                var dims []int64
                for kid := next(); kid != nil; kid = next() {
                        // TODO(rsc): Can also be TagEnumerationType
                        // but haven't seen that in the wild yet.
                        switch kid.Tag {
                        case TagSubrangeType:
                                count, ok := kid.Val(AttrCount).(int64)
                                if !ok {
                                        // Old binaries may have an upper bound instead.
                                        count, ok = kid.Val(AttrUpperBound).(int64)
                                        if ok {
                                                count++ // Length is one more than upper bound.
                                        } else if len(dims) == 0 {
                                                count = -1 // As in x[].
                                        }
                                }
                                dims = append(dims, count)
                        case TagEnumerationType:
                                err = DecodeError{name, kid.Offset, "cannot handle enumeration type as array bound"}
                                goto Error
                        }
                }
                if len(dims) == 0 {
                        // LLVM generates this for x[].
                        dims = []int64{-1}
                }

                t.Count = dims[0]
                for i := len(dims) - 1; i >= 1; i-- {
                        t.Type = &ArrayType{Type: t.Type, Count: dims[i]}
                }

        case TagBaseType:
                // Basic type.  (DWARF v2 §5.1)
                // Attributes:
                //      AttrName: name of base type in programming language of the compilation unit [required]
                //      AttrEncoding: encoding value for type (encFloat etc) [required]
                //      AttrByteSize: size of type in bytes [required]
                //      AttrBitOffset: bit offset of value within containing storage unit
                //      AttrDataBitOffset: bit offset of value within containing storage unit
                //      AttrBitSize: size in bits
                //
                // For most languages BitOffset/DataBitOffset/BitSize will not be present
                // for base types.
                name, _ := e.Val(AttrName).(string)
                enc, ok := e.Val(AttrEncoding).(int64)
                if !ok {
                        err = DecodeError{name, e.Offset, "missing encoding attribute for " + name}
                        goto Error
                }
                switch enc {
                default:
                        err = DecodeError{name, e.Offset, "unrecognized encoding attribute value"}
                        goto Error

                case encAddress:
                        typ = new(AddrType)
                case encBoolean:
                        typ = new(BoolType)
                case encComplexFloat:
                        typ = new(ComplexType)
                        if name == "complex" {
                                // clang writes out 'complex' instead of 'complex float' or 'complex double'.
                                // clang also writes out a byte size that we can use to distinguish.
                                // See issue 8694.
                                switch byteSize, _ := e.Val(AttrByteSize).(int64); byteSize {
                                case 8:
                                        name = "complex float"
                                case 16:
                                        name = "complex double"
                                }
                        }
                case encFloat:
                        typ = new(FloatType)
                case encSigned:
                        typ = new(IntType)
                case encUnsigned:
                        typ = new(UintType)
                case encSignedChar:
                        typ = new(CharType)
                case encUnsignedChar:
                        typ = new(UcharType)
                }
                typeCache[off] = typ
                t := typ.(interface {
                        Basic() *BasicType
                }).Basic()
                t.Name = name
                t.BitSize, _ = e.Val(AttrBitSize).(int64)
                haveBitOffset := false
                haveDataBitOffset := false
                t.BitOffset, haveBitOffset = e.Val(AttrBitOffset).(int64)
                t.DataBitOffset, haveDataBitOffset = e.Val(AttrDataBitOffset).(int64)
                if haveBitOffset && haveDataBitOffset {
                        err = DecodeError{name, e.Offset, "duplicate bit offset attributes"}
                        goto Error
                }

        case TagClassType, TagStructType, TagUnionType:
                // Structure, union, or class type.  (DWARF v2 §5.5)
                // Attributes:
                //      AttrName: name of struct, union, or class
                //      AttrByteSize: byte size [required]
                //      AttrDeclaration: if true, struct/union/class is incomplete
                // Children:
                //      TagMember to describe one member.
                //              AttrName: name of member [required]
                //              AttrType: type of member [required]
                //              AttrByteSize: size in bytes
                //              AttrBitOffset: bit offset within bytes for bit fields
                //              AttrDataBitOffset: field bit offset relative to struct start
                //              AttrBitSize: bit size for bit fields
                //              AttrDataMemberLoc: location within struct [required for struct, class]
                // There is much more to handle C++, all ignored for now.
                t := new(StructType)
                typ = t
                typeCache[off] = t
                switch e.Tag {
                case TagClassType:
                        t.Kind = "class"
                case TagStructType:
                        t.Kind = "struct"
                case TagUnionType:
                        t.Kind = "union"
                }
                t.StructName, _ = e.Val(AttrName).(string)
                t.Incomplete = e.Val(AttrDeclaration) != nil
                t.Field = make([]*StructField, 0, 8)
                var lastFieldType *Type
                var lastFieldBitSize int64
                var lastFieldByteOffset int64
                for kid := next(); kid != nil; kid = next() {
                        if kid.Tag != TagMember {
                                continue
                        }
                        f := new(StructField)
                        if f.Type = typeOf(kid); err != nil {
                                goto Error
                        }
                        switch loc := kid.Val(AttrDataMemberLoc).(type) {
                        case []byte:
                                // TODO: Should have original compilation
                                // unit here, not unknownFormat.
                                b := makeBuf(d, unknownFormat{}, "location", 0, loc)
                                if b.uint8() != opPlusUconst {
                                        err = DecodeError{name, kid.Offset, "unexpected opcode"}
                                        goto Error
                                }
                                f.ByteOffset = int64(b.uint())
                                if b.err != nil {
                                        err = b.err
                                        goto Error
                                }
                        case int64:
                                f.ByteOffset = loc
                        }

                        f.Name, _ = kid.Val(AttrName).(string)
                        f.ByteSize, _ = kid.Val(AttrByteSize).(int64)
                        haveBitOffset := false
                        haveDataBitOffset := false
                        f.BitOffset, haveBitOffset = kid.Val(AttrBitOffset).(int64)
                        f.DataBitOffset, haveDataBitOffset = kid.Val(AttrDataBitOffset).(int64)
                        if haveBitOffset && haveDataBitOffset {
                                err = DecodeError{name, e.Offset, "duplicate bit offset attributes"}
                                goto Error
                        }
                        f.BitSize, _ = kid.Val(AttrBitSize).(int64)
                        t.Field = append(t.Field, f)

                        if lastFieldBitSize == 0 && lastFieldByteOffset == f.ByteOffset && t.Kind != "union" {
                                // Last field was zero width. Fix array length.
                                // (DWARF writes out 0-length arrays as if they were 1-length arrays.)
                                fixups.recordArrayType(lastFieldType)
                        }
                        lastFieldType = &f.Type
                        lastFieldByteOffset = f.ByteOffset
                        lastFieldBitSize = f.BitSize
                }
                if t.Kind != "union" {
                        b, ok := e.Val(AttrByteSize).(int64)
                        if ok && b == lastFieldByteOffset {
                                // Final field must be zero width. Fix array length.
                                fixups.recordArrayType(lastFieldType)
                        }
                }

        case TagConstType, TagVolatileType, TagRestrictType:
                // Type modifier (DWARF v2 §5.2)
                // Attributes:
                //      AttrType: subtype
                t := new(QualType)
                typ = t
                typeCache[off] = t
                if t.Type = typeOf(e); err != nil {
                        goto Error
                }
                switch e.Tag {
                case TagConstType:
                        t.Qual = "const"
                case TagRestrictType:
                        t.Qual = "restrict"
                case TagVolatileType:
                        t.Qual = "volatile"
                }

        case TagEnumerationType:
                // Enumeration type (DWARF v2 §5.6)
                // Attributes:
                //      AttrName: enum name if any
                //      AttrByteSize: bytes required to represent largest value
                // Children:
                //      TagEnumerator:
                //              AttrName: name of constant
                //              AttrConstValue: value of constant
                t := new(EnumType)
                typ = t
                typeCache[off] = t
                t.EnumName, _ = e.Val(AttrName).(string)
                t.Val = make([]*EnumValue, 0, 8)
                for kid := next(); kid != nil; kid = next() {
                        if kid.Tag == TagEnumerator {
                                f := new(EnumValue)
                                f.Name, _ = kid.Val(AttrName).(string)
                                f.Val, _ = kid.Val(AttrConstValue).(int64)
                                n := len(t.Val)
                                if n >= cap(t.Val) {
                                        val := make([]*EnumValue, n, n*2)
                                        copy(val, t.Val)
                                        t.Val = val
                                }
                                t.Val = t.Val[0 : n+1]
                                t.Val[n] = f
                        }
                }

        case TagPointerType:
                // Type modifier (DWARF v2 §5.2)
                // Attributes:
                //      AttrType: subtype [not required!  void* has no AttrType]
                //      AttrAddrClass: address class [ignored]
                t := new(PtrType)
                typ = t
                typeCache[off] = t
                if e.Val(AttrType) == nil {
                        t.Type = &VoidType{}
                        break
                }
                t.Type = typeOf(e)

        case TagSubroutineType:
                // Subroutine type.  (DWARF v2 §5.7)
                // Attributes:
                //      AttrType: type of return value if any
                //      AttrName: possible name of type [ignored]
                //      AttrPrototyped: whether used ANSI C prototype [ignored]
                // Children:
                //      TagFormalParameter: typed parameter
                //              AttrType: type of parameter
                //      TagUnspecifiedParameter: final ...
                t := new(FuncType)
                typ = t
                typeCache[off] = t
                if t.ReturnType = typeOf(e); err != nil {
                        goto Error
                }
                t.ParamType = make([]Type, 0, 8)
                for kid := next(); kid != nil; kid = next() {
                        var tkid Type
                        switch kid.Tag {
                        default:
                                continue
                        case TagFormalParameter:
                                if tkid = typeOf(kid); err != nil {
                                        goto Error
                                }
                        case TagUnspecifiedParameters:
                                tkid = &DotDotDotType{}
                        }
                        t.ParamType = append(t.ParamType, tkid)
                }

        case TagTypedef:
                // Typedef (DWARF v2 §5.3)
                // Attributes:
                //      AttrName: name [required]
                //      AttrType: type definition [required]
                t := new(TypedefType)
                typ = t
                typeCache[off] = t
                t.Name, _ = e.Val(AttrName).(string)
                t.Type = typeOf(e)

        case TagUnspecifiedType:
                // Unspecified type (DWARF v3 §5.2)
                // Attributes:
                //      AttrName: name
                t := new(UnspecifiedType)
                typ = t
                typeCache[off] = t
                t.Name, _ = e.Val(AttrName).(string)

        default:
                // This is some other type DIE that we're currently not
                // equipped to handle. Return an abstract "unsupported type"
                // object in such cases.
                t := new(UnsupportedType)
                typ = t
                typeCache[off] = t
                t.Tag = e.Tag
                t.Name, _ = e.Val(AttrName).(string)
        }

        if err != nil {
                goto Error
        }

        {
                b, ok := e.Val(AttrByteSize).(int64)
                if !ok {
                        b = -1
                        switch t := typ.(type) {
                        case *TypedefType:
                                // Record that we need to resolve this
                                // type's size once the type graph is
                                // constructed.
                                fixups.typedefs = append(fixups.typedefs, t)
                        case *PtrType:
                                b = int64(addressSize)
                        }
                }
                typ.Common().ByteSize = b
        }
        return typ, nil

Error:
        // If the parse fails, take the type out of the cache
        // so that the next call with this offset doesn't hit
        // the cache and return success.
        delete(typeCache, off)
        return nil, err
}

func zeroArray(t *Type) {
        at := (*t).(*ArrayType)
        if at.Type.Size() == 0 {
                return
        }
        // Make a copy to avoid invalidating typeCache.
        tt := *at
        tt.Count = 0
        *t = &tt
}