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