Black Lives Matter. Support the Equal Justice Initiative.

Source file src/debug/dwarf/type.go

Documentation: debug/dwarf

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // DWARF type information structures.
     6  // The format is heavily biased toward C, but for simplicity
     7  // the String methods use a pseudo-Go syntax.
     8  
     9  package dwarf
    10  
    11  import "strconv"
    12  
    13  // A Type conventionally represents a pointer to any of the
    14  // specific Type structures (CharType, StructType, etc.).
    15  type Type interface {
    16  	Common() *CommonType
    17  	String() string
    18  	Size() int64
    19  }
    20  
    21  // A CommonType holds fields common to multiple types.
    22  // If a field is not known or not applicable for a given type,
    23  // the zero value is used.
    24  type CommonType struct {
    25  	ByteSize int64  // size of value of this type, in bytes
    26  	Name     string // name that can be used to refer to type
    27  }
    28  
    29  func (c *CommonType) Common() *CommonType { return c }
    30  
    31  func (c *CommonType) Size() int64 { return c.ByteSize }
    32  
    33  // Basic types
    34  
    35  // A BasicType holds fields common to all basic types.
    36  type BasicType struct {
    37  	CommonType
    38  	BitSize   int64
    39  	BitOffset int64
    40  }
    41  
    42  func (b *BasicType) Basic() *BasicType { return b }
    43  
    44  func (t *BasicType) String() string {
    45  	if t.Name != "" {
    46  		return t.Name
    47  	}
    48  	return "?"
    49  }
    50  
    51  // A CharType represents a signed character type.
    52  type CharType struct {
    53  	BasicType
    54  }
    55  
    56  // A UcharType represents an unsigned character type.
    57  type UcharType struct {
    58  	BasicType
    59  }
    60  
    61  // An IntType represents a signed integer type.
    62  type IntType struct {
    63  	BasicType
    64  }
    65  
    66  // A UintType represents an unsigned integer type.
    67  type UintType struct {
    68  	BasicType
    69  }
    70  
    71  // A FloatType represents a floating point type.
    72  type FloatType struct {
    73  	BasicType
    74  }
    75  
    76  // A ComplexType represents a complex floating point type.
    77  type ComplexType struct {
    78  	BasicType
    79  }
    80  
    81  // A BoolType represents a boolean type.
    82  type BoolType struct {
    83  	BasicType
    84  }
    85  
    86  // An AddrType represents a machine address type.
    87  type AddrType struct {
    88  	BasicType
    89  }
    90  
    91  // An UnspecifiedType represents an implicit, unknown, ambiguous or nonexistent type.
    92  type UnspecifiedType struct {
    93  	BasicType
    94  }
    95  
    96  // qualifiers
    97  
    98  // A QualType represents a type that has the C/C++ "const", "restrict", or "volatile" qualifier.
    99  type QualType struct {
   100  	CommonType
   101  	Qual string
   102  	Type Type
   103  }
   104  
   105  func (t *QualType) String() string { return t.Qual + " " + t.Type.String() }
   106  
   107  func (t *QualType) Size() int64 { return t.Type.Size() }
   108  
   109  // An ArrayType represents a fixed size array type.
   110  type ArrayType struct {
   111  	CommonType
   112  	Type          Type
   113  	StrideBitSize int64 // if > 0, number of bits to hold each element
   114  	Count         int64 // if == -1, an incomplete array, like char x[].
   115  }
   116  
   117  func (t *ArrayType) String() string {
   118  	return "[" + strconv.FormatInt(t.Count, 10) + "]" + t.Type.String()
   119  }
   120  
   121  func (t *ArrayType) Size() int64 {
   122  	if t.Count == -1 {
   123  		return 0
   124  	}
   125  	return t.Count * t.Type.Size()
   126  }
   127  
   128  // A VoidType represents the C void type.
   129  type VoidType struct {
   130  	CommonType
   131  }
   132  
   133  func (t *VoidType) String() string { return "void" }
   134  
   135  // A PtrType represents a pointer type.
   136  type PtrType struct {
   137  	CommonType
   138  	Type Type
   139  }
   140  
   141  func (t *PtrType) String() string { return "*" + t.Type.String() }
   142  
   143  // A StructType represents a struct, union, or C++ class type.
   144  type StructType struct {
   145  	CommonType
   146  	StructName string
   147  	Kind       string // "struct", "union", or "class".
   148  	Field      []*StructField
   149  	Incomplete bool // if true, struct, union, class is declared but not defined
   150  }
   151  
   152  // A StructField represents a field in a struct, union, or C++ class type.
   153  type StructField struct {
   154  	Name       string
   155  	Type       Type
   156  	ByteOffset int64
   157  	ByteSize   int64 // usually zero; use Type.Size() for normal fields
   158  	BitOffset  int64 // within the ByteSize bytes at ByteOffset
   159  	BitSize    int64 // zero if not a bit field
   160  }
   161  
   162  func (t *StructType) String() string {
   163  	if t.StructName != "" {
   164  		return t.Kind + " " + t.StructName
   165  	}
   166  	return t.Defn()
   167  }
   168  
   169  func (t *StructType) Defn() string {
   170  	s := t.Kind
   171  	if t.StructName != "" {
   172  		s += " " + t.StructName
   173  	}
   174  	if t.Incomplete {
   175  		s += " /*incomplete*/"
   176  		return s
   177  	}
   178  	s += " {"
   179  	for i, f := range t.Field {
   180  		if i > 0 {
   181  			s += "; "
   182  		}
   183  		s += f.Name + " " + f.Type.String()
   184  		s += "@" + strconv.FormatInt(f.ByteOffset, 10)
   185  		if f.BitSize > 0 {
   186  			s += " : " + strconv.FormatInt(f.BitSize, 10)
   187  			s += "@" + strconv.FormatInt(f.BitOffset, 10)
   188  		}
   189  	}
   190  	s += "}"
   191  	return s
   192  }
   193  
   194  // An EnumType represents an enumerated type.
   195  // The only indication of its native integer type is its ByteSize
   196  // (inside CommonType).
   197  type EnumType struct {
   198  	CommonType
   199  	EnumName string
   200  	Val      []*EnumValue
   201  }
   202  
   203  // An EnumValue represents a single enumeration value.
   204  type EnumValue struct {
   205  	Name string
   206  	Val  int64
   207  }
   208  
   209  func (t *EnumType) String() string {
   210  	s := "enum"
   211  	if t.EnumName != "" {
   212  		s += " " + t.EnumName
   213  	}
   214  	s += " {"
   215  	for i, v := range t.Val {
   216  		if i > 0 {
   217  			s += "; "
   218  		}
   219  		s += v.Name + "=" + strconv.FormatInt(v.Val, 10)
   220  	}
   221  	s += "}"
   222  	return s
   223  }
   224  
   225  // A FuncType represents a function type.
   226  type FuncType struct {
   227  	CommonType
   228  	ReturnType Type
   229  	ParamType  []Type
   230  }
   231  
   232  func (t *FuncType) String() string {
   233  	s := "func("
   234  	for i, t := range t.ParamType {
   235  		if i > 0 {
   236  			s += ", "
   237  		}
   238  		s += t.String()
   239  	}
   240  	s += ")"
   241  	if t.ReturnType != nil {
   242  		s += " " + t.ReturnType.String()
   243  	}
   244  	return s
   245  }
   246  
   247  // A DotDotDotType represents the variadic ... function parameter.
   248  type DotDotDotType struct {
   249  	CommonType
   250  }
   251  
   252  func (t *DotDotDotType) String() string { return "..." }
   253  
   254  // A TypedefType represents a named type.
   255  type TypedefType struct {
   256  	CommonType
   257  	Type Type
   258  }
   259  
   260  func (t *TypedefType) String() string { return t.Name }
   261  
   262  func (t *TypedefType) Size() int64 { return t.Type.Size() }
   263  
   264  // An UnsupportedType is a placeholder returned in situations where we
   265  // encounter a type that isn't supported.
   266  type UnsupportedType struct {
   267  	CommonType
   268  	Tag Tag
   269  }
   270  
   271  func (t *UnsupportedType) String() string {
   272  	if t.Name != "" {
   273  		return t.Name
   274  	}
   275  	return t.Name + "(unsupported type " + t.Tag.String() + ")"
   276  }
   277  
   278  // typeReader is used to read from either the info section or the
   279  // types section.
   280  type typeReader interface {
   281  	Seek(Offset)
   282  	Next() (*Entry, error)
   283  	clone() typeReader
   284  	offset() Offset
   285  	// AddressSize returns the size in bytes of addresses in the current
   286  	// compilation unit.
   287  	AddressSize() int
   288  }
   289  
   290  // Type reads the type at off in the DWARF ``info'' section.
   291  func (d *Data) Type(off Offset) (Type, error) {
   292  	return d.readType("info", d.Reader(), off, d.typeCache, nil)
   293  }
   294  
   295  type typeFixer struct {
   296  	typedefs   []*TypedefType
   297  	arraytypes []*Type
   298  }
   299  
   300  func (tf *typeFixer) recordArrayType(t *Type) {
   301  	if t == nil {
   302  		return
   303  	}
   304  	_, ok := (*t).(*ArrayType)
   305  	if ok {
   306  		tf.arraytypes = append(tf.arraytypes, t)
   307  	}
   308  }
   309  
   310  func (tf *typeFixer) apply() {
   311  	for _, t := range tf.typedefs {
   312  		t.Common().ByteSize = t.Type.Size()
   313  	}
   314  	for _, t := range tf.arraytypes {
   315  		zeroArray(t)
   316  	}
   317  }
   318  
   319  // readType reads a type from r at off of name. It adds types to the
   320  // type cache, appends new typedef types to typedefs, and computes the
   321  // sizes of types. Callers should pass nil for typedefs; this is used
   322  // for internal recursion.
   323  func (d *Data) readType(name string, r typeReader, off Offset, typeCache map[Offset]Type, fixups *typeFixer) (Type, error) {
   324  	if t, ok := typeCache[off]; ok {
   325  		return t, nil
   326  	}
   327  	r.Seek(off)
   328  	e, err := r.Next()
   329  	if err != nil {
   330  		return nil, err
   331  	}
   332  	addressSize := r.AddressSize()
   333  	if e == nil || e.Offset != off {
   334  		return nil, DecodeError{name, off, "no type at offset"}
   335  	}
   336  
   337  	// If this is the root of the recursion, prepare to resolve
   338  	// typedef sizes and perform other fixups once the recursion is
   339  	// done. This must be done after the type graph is constructed
   340  	// because it may need to resolve cycles in a different order than
   341  	// readType encounters them.
   342  	if fixups == nil {
   343  		var fixer typeFixer
   344  		defer func() {
   345  			fixer.apply()
   346  		}()
   347  		fixups = &fixer
   348  	}
   349  
   350  	// Parse type from Entry.
   351  	// Must always set typeCache[off] before calling
   352  	// d.readType recursively, to handle circular types correctly.
   353  	var typ Type
   354  
   355  	nextDepth := 0
   356  
   357  	// Get next child; set err if error happens.
   358  	next := func() *Entry {
   359  		if !e.Children {
   360  			return nil
   361  		}
   362  		// Only return direct children.
   363  		// Skip over composite entries that happen to be nested
   364  		// inside this one. Most DWARF generators wouldn't generate
   365  		// such a thing, but clang does.
   366  		// See golang.org/issue/6472.
   367  		for {
   368  			kid, err1 := r.Next()
   369  			if err1 != nil {
   370  				err = err1
   371  				return nil
   372  			}
   373  			if kid == nil {
   374  				err = DecodeError{name, r.offset(), "unexpected end of DWARF entries"}
   375  				return nil
   376  			}
   377  			if kid.Tag == 0 {
   378  				if nextDepth > 0 {
   379  					nextDepth--
   380  					continue
   381  				}
   382  				return nil
   383  			}
   384  			if kid.Children {
   385  				nextDepth++
   386  			}
   387  			if nextDepth > 0 {
   388  				continue
   389  			}
   390  			return kid
   391  		}
   392  	}
   393  
   394  	// Get Type referred to by Entry's AttrType field.
   395  	// Set err if error happens. Not having a type is an error.
   396  	typeOf := func(e *Entry) Type {
   397  		tval := e.Val(AttrType)
   398  		var t Type
   399  		switch toff := tval.(type) {
   400  		case Offset:
   401  			if t, err = d.readType(name, r.clone(), toff, typeCache, fixups); err != nil {
   402  				return nil
   403  			}
   404  		case uint64:
   405  			if t, err = d.sigToType(toff); err != nil {
   406  				return nil
   407  			}
   408  		default:
   409  			// It appears that no Type means "void".
   410  			return new(VoidType)
   411  		}
   412  		return t
   413  	}
   414  
   415  	switch e.Tag {
   416  	case TagArrayType:
   417  		// Multi-dimensional array.  (DWARF v2 §5.4)
   418  		// Attributes:
   419  		//	AttrType:subtype [required]
   420  		//	AttrStrideSize: size in bits of each element of the array
   421  		//	AttrByteSize: size of entire array
   422  		// Children:
   423  		//	TagSubrangeType or TagEnumerationType giving one dimension.
   424  		//	dimensions are in left to right order.
   425  		t := new(ArrayType)
   426  		typ = t
   427  		typeCache[off] = t
   428  		if t.Type = typeOf(e); err != nil {
   429  			goto Error
   430  		}
   431  		t.StrideBitSize, _ = e.Val(AttrStrideSize).(int64)
   432  
   433  		// Accumulate dimensions,
   434  		var dims []int64
   435  		for kid := next(); kid != nil; kid = next() {
   436  			// TODO(rsc): Can also be TagEnumerationType
   437  			// but haven't seen that in the wild yet.
   438  			switch kid.Tag {
   439  			case TagSubrangeType:
   440  				count, ok := kid.Val(AttrCount).(int64)
   441  				if !ok {
   442  					// Old binaries may have an upper bound instead.
   443  					count, ok = kid.Val(AttrUpperBound).(int64)
   444  					if ok {
   445  						count++ // Length is one more than upper bound.
   446  					} else if len(dims) == 0 {
   447  						count = -1 // As in x[].
   448  					}
   449  				}
   450  				dims = append(dims, count)
   451  			case TagEnumerationType:
   452  				err = DecodeError{name, kid.Offset, "cannot handle enumeration type as array bound"}
   453  				goto Error
   454  			}
   455  		}
   456  		if len(dims) == 0 {
   457  			// LLVM generates this for x[].
   458  			dims = []int64{-1}
   459  		}
   460  
   461  		t.Count = dims[0]
   462  		for i := len(dims) - 1; i >= 1; i-- {
   463  			t.Type = &ArrayType{Type: t.Type, Count: dims[i]}
   464  		}
   465  
   466  	case TagBaseType:
   467  		// Basic type.  (DWARF v2 §5.1)
   468  		// Attributes:
   469  		//	AttrName: name of base type in programming language of the compilation unit [required]
   470  		//	AttrEncoding: encoding value for type (encFloat etc) [required]
   471  		//	AttrByteSize: size of type in bytes [required]
   472  		//	AttrBitOffset: for sub-byte types, size in bits
   473  		//	AttrBitSize: for sub-byte types, bit offset of high order bit in the AttrByteSize bytes
   474  		name, _ := e.Val(AttrName).(string)
   475  		enc, ok := e.Val(AttrEncoding).(int64)
   476  		if !ok {
   477  			err = DecodeError{name, e.Offset, "missing encoding attribute for " + name}
   478  			goto Error
   479  		}
   480  		switch enc {
   481  		default:
   482  			err = DecodeError{name, e.Offset, "unrecognized encoding attribute value"}
   483  			goto Error
   484  
   485  		case encAddress:
   486  			typ = new(AddrType)
   487  		case encBoolean:
   488  			typ = new(BoolType)
   489  		case encComplexFloat:
   490  			typ = new(ComplexType)
   491  			if name == "complex" {
   492  				// clang writes out 'complex' instead of 'complex float' or 'complex double'.
   493  				// clang also writes out a byte size that we can use to distinguish.
   494  				// See issue 8694.
   495  				switch byteSize, _ := e.Val(AttrByteSize).(int64); byteSize {
   496  				case 8:
   497  					name = "complex float"
   498  				case 16:
   499  					name = "complex double"
   500  				}
   501  			}
   502  		case encFloat:
   503  			typ = new(FloatType)
   504  		case encSigned:
   505  			typ = new(IntType)
   506  		case encUnsigned:
   507  			typ = new(UintType)
   508  		case encSignedChar:
   509  			typ = new(CharType)
   510  		case encUnsignedChar:
   511  			typ = new(UcharType)
   512  		}
   513  		typeCache[off] = typ
   514  		t := typ.(interface {
   515  			Basic() *BasicType
   516  		}).Basic()
   517  		t.Name = name
   518  		t.BitSize, _ = e.Val(AttrBitSize).(int64)
   519  		t.BitOffset, _ = e.Val(AttrBitOffset).(int64)
   520  
   521  	case TagClassType, TagStructType, TagUnionType:
   522  		// Structure, union, or class type.  (DWARF v2 §5.5)
   523  		// Attributes:
   524  		//	AttrName: name of struct, union, or class
   525  		//	AttrByteSize: byte size [required]
   526  		//	AttrDeclaration: if true, struct/union/class is incomplete
   527  		// Children:
   528  		//	TagMember to describe one member.
   529  		//		AttrName: name of member [required]
   530  		//		AttrType: type of member [required]
   531  		//		AttrByteSize: size in bytes
   532  		//		AttrBitOffset: bit offset within bytes for bit fields
   533  		//		AttrBitSize: bit size for bit fields
   534  		//		AttrDataMemberLoc: location within struct [required for struct, class]
   535  		// There is much more to handle C++, all ignored for now.
   536  		t := new(StructType)
   537  		typ = t
   538  		typeCache[off] = t
   539  		switch e.Tag {
   540  		case TagClassType:
   541  			t.Kind = "class"
   542  		case TagStructType:
   543  			t.Kind = "struct"
   544  		case TagUnionType:
   545  			t.Kind = "union"
   546  		}
   547  		t.StructName, _ = e.Val(AttrName).(string)
   548  		t.Incomplete = e.Val(AttrDeclaration) != nil
   549  		t.Field = make([]*StructField, 0, 8)
   550  		var lastFieldType *Type
   551  		var lastFieldBitOffset int64
   552  		for kid := next(); kid != nil; kid = next() {
   553  			if kid.Tag != TagMember {
   554  				continue
   555  			}
   556  			f := new(StructField)
   557  			if f.Type = typeOf(kid); err != nil {
   558  				goto Error
   559  			}
   560  			switch loc := kid.Val(AttrDataMemberLoc).(type) {
   561  			case []byte:
   562  				// TODO: Should have original compilation
   563  				// unit here, not unknownFormat.
   564  				b := makeBuf(d, unknownFormat{}, "location", 0, loc)
   565  				if b.uint8() != opPlusUconst {
   566  					err = DecodeError{name, kid.Offset, "unexpected opcode"}
   567  					goto Error
   568  				}
   569  				f.ByteOffset = int64(b.uint())
   570  				if b.err != nil {
   571  					err = b.err
   572  					goto Error
   573  				}
   574  			case int64:
   575  				f.ByteOffset = loc
   576  			}
   577  
   578  			haveBitOffset := false
   579  			f.Name, _ = kid.Val(AttrName).(string)
   580  			f.ByteSize, _ = kid.Val(AttrByteSize).(int64)
   581  			f.BitOffset, haveBitOffset = kid.Val(AttrBitOffset).(int64)
   582  			f.BitSize, _ = kid.Val(AttrBitSize).(int64)
   583  			t.Field = append(t.Field, f)
   584  
   585  			bito := f.BitOffset
   586  			if !haveBitOffset {
   587  				bito = f.ByteOffset * 8
   588  			}
   589  			if bito == lastFieldBitOffset && t.Kind != "union" {
   590  				// Last field was zero width. Fix array length.
   591  				// (DWARF writes out 0-length arrays as if they were 1-length arrays.)
   592  				fixups.recordArrayType(lastFieldType)
   593  			}
   594  			lastFieldType = &f.Type
   595  			lastFieldBitOffset = bito
   596  		}
   597  		if t.Kind != "union" {
   598  			b, ok := e.Val(AttrByteSize).(int64)
   599  			if ok && b*8 == lastFieldBitOffset {
   600  				// Final field must be zero width. Fix array length.
   601  				fixups.recordArrayType(lastFieldType)
   602  			}
   603  		}
   604  
   605  	case TagConstType, TagVolatileType, TagRestrictType:
   606  		// Type modifier (DWARF v2 §5.2)
   607  		// Attributes:
   608  		//	AttrType: subtype
   609  		t := new(QualType)
   610  		typ = t
   611  		typeCache[off] = t
   612  		if t.Type = typeOf(e); err != nil {
   613  			goto Error
   614  		}
   615  		switch e.Tag {
   616  		case TagConstType:
   617  			t.Qual = "const"
   618  		case TagRestrictType:
   619  			t.Qual = "restrict"
   620  		case TagVolatileType:
   621  			t.Qual = "volatile"
   622  		}
   623  
   624  	case TagEnumerationType:
   625  		// Enumeration type (DWARF v2 §5.6)
   626  		// Attributes:
   627  		//	AttrName: enum name if any
   628  		//	AttrByteSize: bytes required to represent largest value
   629  		// Children:
   630  		//	TagEnumerator:
   631  		//		AttrName: name of constant
   632  		//		AttrConstValue: value of constant
   633  		t := new(EnumType)
   634  		typ = t
   635  		typeCache[off] = t
   636  		t.EnumName, _ = e.Val(AttrName).(string)
   637  		t.Val = make([]*EnumValue, 0, 8)
   638  		for kid := next(); kid != nil; kid = next() {
   639  			if kid.Tag == TagEnumerator {
   640  				f := new(EnumValue)
   641  				f.Name, _ = kid.Val(AttrName).(string)
   642  				f.Val, _ = kid.Val(AttrConstValue).(int64)
   643  				n := len(t.Val)
   644  				if n >= cap(t.Val) {
   645  					val := make([]*EnumValue, n, n*2)
   646  					copy(val, t.Val)
   647  					t.Val = val
   648  				}
   649  				t.Val = t.Val[0 : n+1]
   650  				t.Val[n] = f
   651  			}
   652  		}
   653  
   654  	case TagPointerType:
   655  		// Type modifier (DWARF v2 §5.2)
   656  		// Attributes:
   657  		//	AttrType: subtype [not required!  void* has no AttrType]
   658  		//	AttrAddrClass: address class [ignored]
   659  		t := new(PtrType)
   660  		typ = t
   661  		typeCache[off] = t
   662  		if e.Val(AttrType) == nil {
   663  			t.Type = &VoidType{}
   664  			break
   665  		}
   666  		t.Type = typeOf(e)
   667  
   668  	case TagSubroutineType:
   669  		// Subroutine type.  (DWARF v2 §5.7)
   670  		// Attributes:
   671  		//	AttrType: type of return value if any
   672  		//	AttrName: possible name of type [ignored]
   673  		//	AttrPrototyped: whether used ANSI C prototype [ignored]
   674  		// Children:
   675  		//	TagFormalParameter: typed parameter
   676  		//		AttrType: type of parameter
   677  		//	TagUnspecifiedParameter: final ...
   678  		t := new(FuncType)
   679  		typ = t
   680  		typeCache[off] = t
   681  		if t.ReturnType = typeOf(e); err != nil {
   682  			goto Error
   683  		}
   684  		t.ParamType = make([]Type, 0, 8)
   685  		for kid := next(); kid != nil; kid = next() {
   686  			var tkid Type
   687  			switch kid.Tag {
   688  			default:
   689  				continue
   690  			case TagFormalParameter:
   691  				if tkid = typeOf(kid); err != nil {
   692  					goto Error
   693  				}
   694  			case TagUnspecifiedParameters:
   695  				tkid = &DotDotDotType{}
   696  			}
   697  			t.ParamType = append(t.ParamType, tkid)
   698  		}
   699  
   700  	case TagTypedef:
   701  		// Typedef (DWARF v2 §5.3)
   702  		// Attributes:
   703  		//	AttrName: name [required]
   704  		//	AttrType: type definition [required]
   705  		t := new(TypedefType)
   706  		typ = t
   707  		typeCache[off] = t
   708  		t.Name, _ = e.Val(AttrName).(string)
   709  		t.Type = typeOf(e)
   710  
   711  	case TagUnspecifiedType:
   712  		// Unspecified type (DWARF v3 §5.2)
   713  		// Attributes:
   714  		//	AttrName: name
   715  		t := new(UnspecifiedType)
   716  		typ = t
   717  		typeCache[off] = t
   718  		t.Name, _ = e.Val(AttrName).(string)
   719  
   720  	default:
   721  		// This is some other type DIE that we're currently not
   722  		// equipped to handle. Return an abstract "unsupported type"
   723  		// object in such cases.
   724  		t := new(UnsupportedType)
   725  		typ = t
   726  		typeCache[off] = t
   727  		t.Tag = e.Tag
   728  		t.Name, _ = e.Val(AttrName).(string)
   729  	}
   730  
   731  	if err != nil {
   732  		goto Error
   733  	}
   734  
   735  	{
   736  		b, ok := e.Val(AttrByteSize).(int64)
   737  		if !ok {
   738  			b = -1
   739  			switch t := typ.(type) {
   740  			case *TypedefType:
   741  				// Record that we need to resolve this
   742  				// type's size once the type graph is
   743  				// constructed.
   744  				fixups.typedefs = append(fixups.typedefs, t)
   745  			case *PtrType:
   746  				b = int64(addressSize)
   747  			}
   748  		}
   749  		typ.Common().ByteSize = b
   750  	}
   751  	return typ, nil
   752  
   753  Error:
   754  	// If the parse fails, take the type out of the cache
   755  	// so that the next call with this offset doesn't hit
   756  	// the cache and return success.
   757  	delete(typeCache, off)
   758  	return nil, err
   759  }
   760  
   761  func zeroArray(t *Type) {
   762  	at := (*t).(*ArrayType)
   763  	if at.Type.Size() == 0 {
   764  		return
   765  	}
   766  	// Make a copy to avoid invalidating typeCache.
   767  	tt := *at
   768  	tt.Count = 0
   769  	*t = &tt
   770  }
   771  

View as plain text