Subversion Repositories openrisc

// 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.

/*
 * Runtime type representation.
 *
 * The following files know the exact layout of these
 * data structures and must be kept in sync with this file:
 *
 *      ../../cmd/gc/reflect.c
 *      ../../cmd/ld/dwarf.c decodetype_*
 *      ../reflect/type.go
 *      type.h
 */

package runtime

import "unsafe"

// All types begin with a few common fields needed for
// the interface runtime.
type commonType struct {
        Kind       uint8   // type kind
        align      uint8   // alignment of variable with this type
        fieldAlign uint8   // alignment of struct field with this type
        size       uintptr // size in bytes
        hash       uint32  // hash of type; avoids computation in hash tables

        hashfn  func(unsafe.Pointer, uintptr) uintptr              // hash function
        equalfn func(unsafe.Pointer, unsafe.Pointer, uintptr) bool // equality function

        string        *string // string form; unnecessary  but undeniably useful
        *uncommonType         // (relatively) uncommon fields
        ptrToThis     *Type   // pointer to this type, if used in binary or has methods
}

// Values for commonType.kind.
const (
        kindBool = 1 + iota
        kindInt
        kindInt8
        kindInt16
        kindInt32
        kindInt64
        kindUint
        kindUint8
        kindUint16
        kindUint32
        kindUint64
        kindUintptr
        kindFloat32
        kindFloat64
        kindComplex64
        kindComplex128
        kindArray
        kindChan
        kindFunc
        kindInterface
        kindMap
        kindPtr
        kindSlice
        kindString
        kindStruct
        kindUnsafePointer

        // Not currently generated by gccgo.
        // kindNoPointers = 1 << 7 // OR'ed into kind
)

// Externally visible name.
type Type commonType

// Method on non-interface type
type _method struct { // underscore is to avoid collision with C
        name    *string        // name of method
        pkgPath *string        // nil for exported Names; otherwise import path
        mtyp    *Type          // method type (without receiver)
        typ     *Type          // .(*FuncType) underneath (with receiver)
        tfn     unsafe.Pointer // fn used for normal method call
}

// uncommonType is present only for types with names or methods
// (if T is a named type, the uncommonTypes for T and *T have methods).
// Using a pointer to this struct reduces the overall size required
// to describe an unnamed type with no methods.
type uncommonType struct {
        name    *string   // name of type
        pkgPath *string   // import path; nil for built-in types like int, string
        methods []_method // methods associated with type
}

// BoolType represents a boolean type.
type BoolType commonType

// FloatType represents a float type.
type FloatType commonType

// ComplexType represents a complex type.
type ComplexType commonType

// IntType represents an int type.
type IntType commonType

// UintType represents a uint type.
type UintType commonType

// StringType represents a string type.
type StringType commonType

// UintptrType represents a uintptr type.
type UintptrType commonType

// UnsafePointerType represents an unsafe.Pointer type.
type UnsafePointerType commonType

// ArrayType represents a fixed array type.
type ArrayType struct {
        commonType
        elem  *Type // array element type
        slice *Type // slice type
        len   uintptr
}

// SliceType represents a slice type.
type SliceType struct {
        commonType
        elem *Type // slice element type
}

// ChanDir represents a channel type's direction.
type ChanDir int

const (
        RecvDir ChanDir             = 1 << iota // <-chan
        SendDir                                 // chan<-
        BothDir = RecvDir | SendDir             // chan
)

// ChanType represents a channel type.
type ChanType struct {
        commonType
        elem *Type   // channel element type
        dir  uintptr // channel direction (ChanDir)
}

// FuncType represents a function type.
type FuncType struct {
        commonType
        dotdotdot bool    // last input parameter is ...
        in        []*Type // input parameter types
        out       []*Type // output parameter types
}

// Method on interface type
type _imethod struct { // underscore is to avoid collision with C
        name    *string // name of method
        pkgPath *string // nil for exported Names; otherwise import path
        typ     *Type   // .(*FuncType) underneath
}

// InterfaceType represents an interface type.
type InterfaceType struct {
        commonType
        methods []_imethod // sorted by hash
}

// MapType represents a map type.
type MapType struct {
        commonType
        key  *Type // map key type
        elem *Type // map element (value) type
}

// PtrType represents a pointer type.
type PtrType struct {
        commonType
        elem *Type // pointer element (pointed at) type
}

// Struct field
type structField struct {
        name    *string // nil for embedded fields
        pkgPath *string // nil for exported Names; otherwise import path
        typ     *Type   // type of field
        tag     *string // nil if no tag
        offset  uintptr // byte offset of field within struct
}

// StructType represents a struct type.
type StructType struct {
        commonType
        fields []structField // sorted by offset
}

/*
 * Must match iface.c:/Itab and compilers.
 * NOTE: this is the version used by the reflection code, there is another
 * one in iface_defs.go that is closer to the original C version.
 */
type Itable struct {
        Itype  *Type // (*tab.inter).(*InterfaceType) is the interface type
        Type   *Type
        link   *Itable
        bad    int32
        unused int32
        Fn     [100000]uintptr // bigger than we'll ever see
}