Source file src/pkg/debug/dwarf/const.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.

// Constants

package dwarf

import "strconv"

// An Attr identifies the attribute type in a DWARF Entry's Field.
type Attr uint32

const (
    AttrSibling        Attr = 0x01
    AttrLocation       Attr = 0x02
    AttrName           Attr = 0x03
    AttrOrdering       Attr = 0x09
    AttrByteSize       Attr = 0x0B
    AttrBitOffset      Attr = 0x0C
    AttrBitSize        Attr = 0x0D
    AttrStmtList       Attr = 0x10
    AttrLowpc          Attr = 0x11
    AttrHighpc         Attr = 0x12
    AttrLanguage       Attr = 0x13
    AttrDiscr          Attr = 0x15
    AttrDiscrValue     Attr = 0x16
    AttrVisibility     Attr = 0x17
    AttrImport         Attr = 0x18
    AttrStringLength   Attr = 0x19
    AttrCommonRef      Attr = 0x1A
    AttrCompDir        Attr = 0x1B
    AttrConstValue     Attr = 0x1C
    AttrContainingType Attr = 0x1D
    AttrDefaultValue   Attr = 0x1E
    AttrInline         Attr = 0x20
    AttrIsOptional     Attr = 0x21
    AttrLowerBound     Attr = 0x22
    AttrProducer       Attr = 0x25
    AttrPrototyped     Attr = 0x27
    AttrReturnAddr     Attr = 0x2A
    AttrStartScope     Attr = 0x2C
    AttrStrideSize     Attr = 0x2E
    AttrUpperBound     Attr = 0x2F
    AttrAbstractOrigin Attr = 0x31
    AttrAccessibility  Attr = 0x32
    AttrAddrClass      Attr = 0x33
    AttrArtificial     Attr = 0x34
    AttrBaseTypes      Attr = 0x35
    AttrCalling        Attr = 0x36
    AttrCount          Attr = 0x37
    AttrDataMemberLoc  Attr = 0x38
    AttrDeclColumn     Attr = 0x39
    AttrDeclFile       Attr = 0x3A
    AttrDeclLine       Attr = 0x3B
    AttrDeclaration    Attr = 0x3C
    AttrDiscrList      Attr = 0x3D
    AttrEncoding       Attr = 0x3E
    AttrExternal       Attr = 0x3F
    AttrFrameBase      Attr = 0x40
    AttrFriend         Attr = 0x41
    AttrIdentifierCase Attr = 0x42
    AttrMacroInfo      Attr = 0x43
    AttrNamelistItem   Attr = 0x44
    AttrPriority       Attr = 0x45
    AttrSegment        Attr = 0x46
    AttrSpecification  Attr = 0x47
    AttrStaticLink     Attr = 0x48
    AttrType           Attr = 0x49
    AttrUseLocation    Attr = 0x4A
    AttrVarParam       Attr = 0x4B
    AttrVirtuality     Attr = 0x4C
    AttrVtableElemLoc  Attr = 0x4D
    AttrAllocated      Attr = 0x4E
    AttrAssociated     Attr = 0x4F
    AttrDataLocation   Attr = 0x50
    AttrStride         Attr = 0x51
    AttrEntrypc        Attr = 0x52
    AttrUseUTF8        Attr = 0x53
    AttrExtension      Attr = 0x54
    AttrRanges         Attr = 0x55
    AttrTrampoline     Attr = 0x56
    AttrCallColumn     Attr = 0x57
    AttrCallFile       Attr = 0x58
    AttrCallLine       Attr = 0x59
    AttrDescription    Attr = 0x5A
)

var attrNames = [...]string{
    AttrSibling:        "Sibling",
    AttrLocation:       "Location",
    AttrName:           "Name",
    AttrOrdering:       "Ordering",
    AttrByteSize:       "ByteSize",
    AttrBitOffset:      "BitOffset",
    AttrBitSize:        "BitSize",
    AttrStmtList:       "StmtList",
    AttrLowpc:          "Lowpc",
    AttrHighpc:         "Highpc",
    AttrLanguage:       "Language",
    AttrDiscr:          "Discr",
    AttrDiscrValue:     "DiscrValue",
    AttrVisibility:     "Visibility",
    AttrImport:         "Import",
    AttrStringLength:   "StringLength",
    AttrCommonRef:      "CommonRef",
    AttrCompDir:        "CompDir",
    AttrConstValue:     "ConstValue",
    AttrContainingType: "ContainingType",
    AttrDefaultValue:   "DefaultValue",
    AttrInline:         "Inline",
    AttrIsOptional:     "IsOptional",
    AttrLowerBound:     "LowerBound",
    AttrProducer:       "Producer",
    AttrPrototyped:     "Prototyped",
    AttrReturnAddr:     "ReturnAddr",
    AttrStartScope:     "StartScope",
    AttrStrideSize:     "StrideSize",
    AttrUpperBound:     "UpperBound",
    AttrAbstractOrigin: "AbstractOrigin",
    AttrAccessibility:  "Accessibility",
    AttrAddrClass:      "AddrClass",
    AttrArtificial:     "Artificial",
    AttrBaseTypes:      "BaseTypes",
    AttrCalling:        "Calling",
    AttrCount:          "Count",
    AttrDataMemberLoc:  "DataMemberLoc",
    AttrDeclColumn:     "DeclColumn",
    AttrDeclFile:       "DeclFile",
    AttrDeclLine:       "DeclLine",
    AttrDeclaration:    "Declaration",
    AttrDiscrList:      "DiscrList",
    AttrEncoding:       "Encoding",
    AttrExternal:       "External",
    AttrFrameBase:      "FrameBase",
    AttrFriend:         "Friend",
    AttrIdentifierCase: "IdentifierCase",
    AttrMacroInfo:      "MacroInfo",
    AttrNamelistItem:   "NamelistItem",
    AttrPriority:       "Priority",
    AttrSegment:        "Segment",
    AttrSpecification:  "Specification",
    AttrStaticLink:     "StaticLink",
    AttrType:           "Type",
    AttrUseLocation:    "UseLocation",
    AttrVarParam:       "VarParam",
    AttrVirtuality:     "Virtuality",
    AttrVtableElemLoc:  "VtableElemLoc",
    AttrAllocated:      "Allocated",
    AttrAssociated:     "Associated",
    AttrDataLocation:   "DataLocation",
    AttrStride:         "Stride",
    AttrEntrypc:        "Entrypc",
    AttrUseUTF8:        "UseUTF8",
    AttrExtension:      "Extension",
    AttrRanges:         "Ranges",
    AttrTrampoline:     "Trampoline",
    AttrCallColumn:     "CallColumn",
    AttrCallFile:       "CallFile",
    AttrCallLine:       "CallLine",
    AttrDescription:    "Description",
}

func (a Attr) String() string {
    if int(a) < len(attrNames) {
        s := attrNames[a]
        if s != "" {
            return s
        }
    }
    return strconv.Itoa(int(a))
}

func (a Attr) GoString() string {
    if int(a) < len(attrNames) {
        s := attrNames[a]
        if s != "" {
            return "dwarf.Attr" + s
        }
    }
    return "dwarf.Attr(" + strconv.Itoa64(int64(a)) + ")"
}

// A format is a DWARF data encoding format.
type format uint32

const (
    // value formats
    formAddr        format = 0x01
    formDwarfBlock2 format = 0x03
    formDwarfBlock4 format = 0x04
    formData2       format = 0x05
    formData4       format = 0x06
    formData8       format = 0x07
    formString      format = 0x08
    formDwarfBlock  format = 0x09
    formDwarfBlock1 format = 0x0A
    formData1       format = 0x0B
    formFlag        format = 0x0C
    formSdata       format = 0x0D
    formStrp        format = 0x0E
    formUdata       format = 0x0F
    formRefAddr     format = 0x10
    formRef1        format = 0x11
    formRef2        format = 0x12
    formRef4        format = 0x13
    formRef8        format = 0x14
    formRefUdata    format = 0x15
    formIndirect    format = 0x16
)

// A Tag is the classification (the type) of an Entry.
type Tag uint32

const (
    TagArrayType              Tag = 0x01
    TagClassType              Tag = 0x02
    TagEntryPoint             Tag = 0x03
    TagEnumerationType        Tag = 0x04
    TagFormalParameter        Tag = 0x05
    TagImportedDeclaration    Tag = 0x08
    TagLabel                  Tag = 0x0A
    TagLexDwarfBlock          Tag = 0x0B
    TagMember                 Tag = 0x0D
    TagPointerType            Tag = 0x0F
    TagReferenceType          Tag = 0x10
    TagCompileUnit            Tag = 0x11
    TagStringType             Tag = 0x12
    TagStructType             Tag = 0x13
    TagSubroutineType         Tag = 0x15
    TagTypedef                Tag = 0x16
    TagUnionType              Tag = 0x17
    TagUnspecifiedParameters  Tag = 0x18
    TagVariant                Tag = 0x19
    TagCommonDwarfBlock       Tag = 0x1A
    TagCommonInclusion        Tag = 0x1B
    TagInheritance            Tag = 0x1C
    TagInlinedSubroutine      Tag = 0x1D
    TagModule                 Tag = 0x1E
    TagPtrToMemberType        Tag = 0x1F
    TagSetType                Tag = 0x20
    TagSubrangeType           Tag = 0x21
    TagWithStmt               Tag = 0x22
    TagAccessDeclaration      Tag = 0x23
    TagBaseType               Tag = 0x24
    TagCatchDwarfBlock        Tag = 0x25
    TagConstType              Tag = 0x26
    TagConstant               Tag = 0x27
    TagEnumerator             Tag = 0x28
    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
    TagVariable               Tag = 0x34
    TagVolatileType           Tag = 0x35
    TagDwarfProcedure         Tag = 0x36
    TagRestrictType           Tag = 0x37
    TagInterfaceType          Tag = 0x38
    TagNamespace              Tag = 0x39
    TagImportedModule         Tag = 0x3A
    TagUnspecifiedType        Tag = 0x3B
    TagPartialUnit            Tag = 0x3C
    TagImportedUnit           Tag = 0x3D
    TagMutableType            Tag = 0x3E
)

var tagNames = [...]string{
    TagArrayType:              "ArrayType",
    TagClassType:              "ClassType",
    TagEntryPoint:             "EntryPoint",
    TagEnumerationType:        "EnumerationType",
    TagFormalParameter:        "FormalParameter",
    TagImportedDeclaration:    "ImportedDeclaration",
    TagLabel:                  "Label",
    TagLexDwarfBlock:          "LexDwarfBlock",
    TagMember:                 "Member",
    TagPointerType:            "PointerType",
    TagReferenceType:          "ReferenceType",
    TagCompileUnit:            "CompileUnit",
    TagStringType:             "StringType",
    TagStructType:             "StructType",
    TagSubroutineType:         "SubroutineType",
    TagTypedef:                "Typedef",
    TagUnionType:              "UnionType",
    TagUnspecifiedParameters:  "UnspecifiedParameters",
    TagVariant:                "Variant",
    TagCommonDwarfBlock:       "CommonDwarfBlock",
    TagCommonInclusion:        "CommonInclusion",
    TagInheritance:            "Inheritance",
    TagInlinedSubroutine:      "InlinedSubroutine",
    TagModule:                 "Module",
    TagPtrToMemberType:        "PtrToMemberType",
    TagSetType:                "SetType",
    TagSubrangeType:           "SubrangeType",
    TagWithStmt:               "WithStmt",
    TagAccessDeclaration:      "AccessDeclaration",
    TagBaseType:               "BaseType",
    TagCatchDwarfBlock:        "CatchDwarfBlock",
    TagConstType:              "ConstType",
    TagConstant:               "Constant",
    TagEnumerator:             "Enumerator",
    TagFileType:               "FileType",
    TagFriend:                 "Friend",
    TagNamelist:               "Namelist",
    TagNamelistItem:           "NamelistItem",
    TagPackedType:             "PackedType",
    TagSubprogram:             "Subprogram",
    TagTemplateTypeParameter:  "TemplateTypeParameter",
    TagTemplateValueParameter: "TemplateValueParameter",
    TagThrownType:             "ThrownType",
    TagTryDwarfBlock:          "TryDwarfBlock",
    TagVariantPart:            "VariantPart",
    TagVariable:               "Variable",
    TagVolatileType:           "VolatileType",
    TagDwarfProcedure:         "DwarfProcedure",
    TagRestrictType:           "RestrictType",
    TagInterfaceType:          "InterfaceType",
    TagNamespace:              "Namespace",
    TagImportedModule:         "ImportedModule",
    TagUnspecifiedType:        "UnspecifiedType",
    TagPartialUnit:            "PartialUnit",
    TagImportedUnit:           "ImportedUnit",
    TagMutableType:            "MutableType",
}

func (t Tag) String() string {
    if int(t) < len(tagNames) {
        s := tagNames[t]
        if s != "" {
            return s
        }
    }
    return strconv.Itoa(int(t))
}

func (t Tag) GoString() string {
    if int(t) < len(tagNames) {
        s := tagNames[t]
        if s != "" {
            return "dwarf.Tag" + s
        }
    }
    return "dwarf.Tag(" + strconv.Itoa64(int64(t)) + ")"
}

// Location expression operators.
// The debug info encodes value locations like 8(R3)
// as a sequence of these op codes.
// This package does not implement full expressions;
// the opPlusUconst operator is expected by the type parser.
const (
    opAddr       = 0x03 /* 1 op, const addr */
    opDeref      = 0x06
    opConst1u    = 0x08 /* 1 op, 1 byte const */
    opConst1s    = 0x09 /*	" signed */
    opConst2u    = 0x0A /* 1 op, 2 byte const  */
    opConst2s    = 0x0B /*	" signed */
    opConst4u    = 0x0C /* 1 op, 4 byte const */
    opConst4s    = 0x0D /*	" signed */
    opConst8u    = 0x0E /* 1 op, 8 byte const */
    opConst8s    = 0x0F /*	" signed */
    opConstu     = 0x10 /* 1 op, LEB128 const */
    opConsts     = 0x11 /*	" signed */
    opDup        = 0x12
    opDrop       = 0x13
    opOver       = 0x14
    opPick       = 0x15 /* 1 op, 1 byte stack index */
    opSwap       = 0x16
    opRot        = 0x17
    opXderef     = 0x18
    opAbs        = 0x19
    opAnd        = 0x1A
    opDiv        = 0x1B
    opMinus      = 0x1C
    opMod        = 0x1D
    opMul        = 0x1E
    opNeg        = 0x1F
    opNot        = 0x20
    opOr         = 0x21
    opPlus       = 0x22
    opPlusUconst = 0x23 /* 1 op, ULEB128 addend */
    opShl        = 0x24
    opShr        = 0x25
    opShra       = 0x26
    opXor        = 0x27
    opSkip       = 0x2F /* 1 op, signed 2-byte constant */
    opBra        = 0x28 /* 1 op, signed 2-byte constant */
    opEq         = 0x29
    opGe         = 0x2A
    opGt         = 0x2B
    opLe         = 0x2C
    opLt         = 0x2D
    opNe         = 0x2E
    opLit0       = 0x30
    /* OpLitN = OpLit0 + N for N = 0..31 */
    opReg0 = 0x50
    /* OpRegN = OpReg0 + N for N = 0..31 */
    opBreg0 = 0x70 /* 1 op, signed LEB128 constant */
    /* OpBregN = OpBreg0 + N for N = 0..31 */
    opRegx       = 0x90 /* 1 op, ULEB128 register */
    opFbreg      = 0x91 /* 1 op, SLEB128 offset */
    opBregx      = 0x92 /* 2 op, ULEB128 reg; SLEB128 off */
    opPiece      = 0x93 /* 1 op, ULEB128 size of piece */
    opDerefSize  = 0x94 /* 1-byte size of data retrieved */
    opXderefSize = 0x95 /* 1-byte size of data retrieved */
    opNop        = 0x96
    /* next four new in Dwarf v3 */
    opPushObjAddr = 0x97
    opCall2       = 0x98 /* 2-byte offset of DIE */
    opCall4       = 0x99 /* 4-byte offset of DIE */
    opCallRef     = 0x9A /* 4- or 8- byte offset of DIE */
    /* 0xE0-0xFF reserved for user-specific */
)

// Basic type encodings -- the value for AttrEncoding in a TagBaseType Entry.
const (
    encAddress        = 0x01
    encBoolean        = 0x02
    encComplexFloat   = 0x03
    encFloat          = 0x04
    encSigned         = 0x05
    encSignedChar     = 0x06
    encUnsigned       = 0x07
    encUnsignedChar   = 0x08
    encImaginaryFloat = 0x09
)