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.

// 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.FormatInt(int64(a), 10) + ")"
}

// 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.FormatInt(int64(t), 10) + ")"
}

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