gofmt on crypto, debug

R=gri
DELTA=2560  (127 added, 177 deleted, 2256 changed)
OCL=35388
CL=35395

22 files changed, 1778 insertions, 1679 deletions

diff --git a/src/pkg/debug/binary/binary_test.go b/src/pkg/debug/binary/binary_test.go
index 7f0c226ce7..a04684b72b 100644
--- a/src/pkg/debug/binary/binary_test.go
+++ b/src/pkg/debug/binary/binary_test.go
@@ -12,19 +12,19 @@ import (
 )
 
 type Struct struct {
-	Int8 int8;
-	Int16 int16;
-	Int32 int32;
-	Int64 int64;
-	Uint8 uint8;
-	Uint16 uint16;
-	Uint32 uint32;
-	Uint64 uint64;
-	Float64 float64;
-	Array [4]uint8;
+	Int8	int8;
+	Int16	int16;
+	Int32	int32;
+	Int64	int64;
+	Uint8	uint8;
+	Uint16	uint16;
+	Uint32	uint32;
+	Uint64	uint64;
+	Float64	float64;
+	Array	[4]uint8;
 }
 
-var s = Struct {
+var s = Struct{
 	0x01,
 	0x0203,
 	0x04050607,
@@ -34,7 +34,7 @@ var s = Struct {
 	0x13141516,
 	0x1718191a1b1c1d1e,
 	math.Float64frombits(0x1f20212223242526),
-	[4]uint8 { 0x27, 0x28, 0x29, 0x2a },
+	[4]uint8{0x27, 0x28, 0x29, 0x2a},
 }
 
 var big = []byte{
@@ -84,4 +84,3 @@ little:
 		t.Errorf("Read big-endian:\n\thave %+v\n\twant %+v", sl, s);
 	}
 }
-
diff --git a/src/pkg/debug/dwarf/buf.go b/src/pkg/debug/dwarf/buf.go
index 3089180ac0..e4cb28e5dd 100644
--- a/src/pkg/debug/dwarf/buf.go
+++ b/src/pkg/debug/dwarf/buf.go
@@ -14,17 +14,17 @@ import (
 
 // Data buffer being decoded.
 type buf struct {
-	dwarf *Data;
-	order binary.ByteOrder;
-	name string;
-	off Offset;
-	data []byte;
-	addrsize int;
-	err os.Error;
+	dwarf		*Data;
+	order		binary.ByteOrder;
+	name		string;
+	off		Offset;
+	data		[]byte;
+	addrsize	int;
+	err		os.Error;
 }
 
 func makeBuf(d *Data, name string, off Offset, data []byte, addrsize int) buf {
-	return buf{d, d.order, name, off, data, addrsize, nil}
+	return buf{d, d.order, name, off, data, addrsize, nil};
 }
 
 func (b *buf) uint8() uint8 {
@@ -33,7 +33,7 @@ func (b *buf) uint8() uint8 {
 		return 0;
 	}
 	val := b.data[0];
-	b.data = b.data[1:len(b.data)];
+	b.data = b.data[1 : len(b.data)];
 	b.off++;
 	return val;
 }
@@ -44,7 +44,7 @@ func (b *buf) bytes(n int) []byte {
 		return nil;
 	}
 	data := b.data[0:n];
-	b.data = b.data[n:len(b.data)];
+	b.data = b.data[n : len(b.data)];
 	b.off += Offset(n);
 	return data;
 }
@@ -57,7 +57,7 @@ func (b *buf) string() string {
 	for i := 0; i < len(b.data); i++ {
 		if b.data[i] == 0 {
 			s := string(b.data[0:i]);
-			b.data = b.data[i+1:len(b.data)];
+			b.data = b.data[i+1 : len(b.data)];
 			b.off += Offset(i+1);
 			return s;
 		}
@@ -66,7 +66,7 @@ func (b *buf) string() string {
 	return "";
 }
 
-func (b *buf) uint16() uint16{
+func (b *buf) uint16() uint16 {
 	a := b.bytes(2);
 	if a == nil {
 		return 0;
@@ -99,7 +99,7 @@ func (b *buf) varint() (c uint64, bits uint) {
 		bits += 7;
 		if byte&0x80 == 0 {
 			b.off += Offset(i+1);
-			b.data = b.data[i+1:len(b.data)];
+			b.data = b.data[i+1 : len(b.data)];
 			return c, bits;
 		}
 	}
@@ -116,8 +116,8 @@ func (b *buf) uint() uint64 {
 func (b *buf) int() int64 {
 	ux, bits := b.varint();
 	x := int64(ux);
-	if x & (1<<(bits-1)) != 0 {
-		x |= -1<<bits;
+	if x&(1<<(bits-1)) != 0 {
+		x |= -1 << bits;
 	}
 	return x;
 }
@@ -141,17 +141,16 @@ func (b *buf) addr() uint64 {
 func (b *buf) error(s string) {
 	if b.err == nil {
 		b.data = nil;
-		b.err = DecodeError{b.name, b.off, s}
+		b.err = DecodeError{b.name, b.off, s};
 	}
 }
 
 type DecodeError struct {
-	Name string;
-	Offset Offset;
-	Error string;
+	Name	string;
+	Offset	Offset;
+	Error	string;
 }
 
 func (e DecodeError) String() string {
 	return "decoding dwarf section " + e.Name + " at offset 0x" + strconv.Itob64(int64(e.Offset), 16) + ": " + e.Error;
 }
-
diff --git a/src/pkg/debug/dwarf/const.go b/src/pkg/debug/dwarf/const.go
index c2878bd6f5..b476b29b6c 100644
--- a/src/pkg/debug/dwarf/const.go
+++ b/src/pkg/debug/dwarf/const.go
@@ -12,81 +12,81 @@ import "strconv"
 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;
+	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 {
+var attrNames = [...]string{
 	AttrSibling: "Sibling",
 	AttrLocation: "Location",
 	AttrName: "Name",
@@ -186,92 +186,92 @@ 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;
+	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;
+	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 {
+var tagNames = [...]string{
 	TagArrayType: "ArrayType",
 	TagClassType: "ClassType",
 	TagEntryPoint: "EntryPoint",
@@ -356,78 +356,78 @@ func (t Tag) GoString() string {
 // 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;
+	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 */
+	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;
+	encAddress		= 0x01;
+	encBoolean		= 0x02;
+	encComplexFloat		= 0x03;
+	encFloat		= 0x04;
+	encSigned		= 0x05;
+	encSignedChar		= 0x06;
+	encUnsigned		= 0x07;
+	encUnsignedChar		= 0x08;
+	encImaginaryFloat	= 0x09;
 )
diff --git a/src/pkg/debug/dwarf/entry.go b/src/pkg/debug/dwarf/entry.go
index 986e098a80..0554a249bf 100644
--- a/src/pkg/debug/dwarf/entry.go
+++ b/src/pkg/debug/dwarf/entry.go
@@ -14,14 +14,14 @@ import "os"
 
 // a single entry's description: a sequence of attributes
 type abbrev struct {
-	tag Tag;
-	children bool;
-	field []afield;
+	tag		Tag;
+	children	bool;
+	field		[]afield;
 }
 
 type afield struct {
-	attr Attr;
-	fmt format;
+	attr	Attr;
+	fmt	format;
 }
 
 // a map from entry format ids to their descriptions
@@ -92,16 +92,16 @@ func (d *Data) parseAbbrev(off uint32) (abbrevTable, os.Error) {
 
 // An entry is a sequence of attribute/value pairs.
 type Entry struct {
-	Offset Offset;	// offset of Entry in DWARF info
-	Tag Tag;	// tag (kind of Entry)
-	Children bool;	// whether Entry is followed by children
-	Field []Field;
+	Offset		Offset;	// offset of Entry in DWARF info
+	Tag		Tag;	// tag (kind of Entry)
+	Children	bool;	// whether Entry is followed by children
+	Field		[]Field;
 }
 
 // A Field is a single attribute/value pair in an Entry.
 type Field struct {
-	Attr Attr;
-	Val interface{};
+	Attr	Attr;
+	Val	interface{};
 }
 
 // Val returns the value associated with attribute Attr in Entry,
@@ -141,7 +141,7 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
 		Offset: off,
 		Tag: a.tag,
 		Children: a.children,
-		Field: make([]Field, len(a.field))
+		Field: make([]Field, len(a.field)),
 	};
 	for i := range e.Field {
 		e.Field[i].Attr = a.field[i].attr;
@@ -149,7 +149,7 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
 		if fmt == formIndirect {
 			fmt = format(b.uint());
 		}
-		var val interface{};
+		var val interface{}
 		switch fmt {
 		default:
 			b.error("unknown entry attr format");
@@ -230,12 +230,12 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
 // If an entry has children, its Children field will be true, and the children
 // follow, terminated by an Entry with Tag 0.
 type Reader struct {
-	b buf;
-	d *Data;
-	err os.Error;
-	unit int;
-	lastChildren bool;	// .Children of last entry returned by Next
-	lastSibling Offset;	// .Val(AttrSibling) of last entry returned by Next
+	b		buf;
+	d		*Data;
+	err		os.Error;
+	unit		int;
+	lastChildren	bool;	// .Children of last entry returned by Next
+	lastSibling	Offset;	// .Val(AttrSibling) of last entry returned by Next
 }
 
 // Reader returns a new Reader for Data.
@@ -267,9 +267,9 @@ func (r *Reader) Seek(off Offset) {
 	var u *unit;
 	for i = range d.unit {
 		u = &d.unit[i];
-		if u.off <= off && off < u.off+Offset(len(u.data)) {
+		if u.off <= off && off < u.off + Offset(len(u.data)) {
 			r.unit = i;
-			r.b = makeBuf(r.d, "info", off, u.data[off-u.off:len(u.data)], u.addrsize);
+			r.b = makeBuf(r.d, "info", off, u.data[off - u.off : len(u.data)], u.addrsize);
 			return;
 		}
 	}
@@ -278,7 +278,7 @@ func (r *Reader) Seek(off Offset) {
 
 // maybeNextUnit advances to the next unit if this one is finished.
 func (r *Reader) maybeNextUnit() {
-	for len(r.b.data) == 0 && r.unit+1 < len(r.d.unit) {
+	for len(r.b.data) == 0 && r.unit + 1 < len(r.d.unit) {
 		r.unit++;
 		u := &r.d.unit[r.unit];
 		r.b = makeBuf(r.d, "info", u.off, u.data, u.addrsize);
@@ -318,7 +318,7 @@ func (r *Reader) Next() (*Entry, os.Error) {
 // the last Entry returned by Next.  If that Entry did not have
 // children or Next has not been called, SkipChildren is a no-op.
 func (r *Reader) SkipChildren() {
-	if r.err != nil || !r.lastChildren{
+	if r.err != nil || !r.lastChildren {
 		return;
 	}
 
@@ -341,4 +341,3 @@ func (r *Reader) SkipChildren() {
 		}
 	}
 }
-
diff --git a/src/pkg/debug/dwarf/open.go b/src/pkg/debug/dwarf/open.go
index 15d0b6ea6b..f2cfa4c930 100644
--- a/src/pkg/debug/dwarf/open.go
+++ b/src/pkg/debug/dwarf/open.go
@@ -16,21 +16,21 @@ import (
 // loaded from an executable file (for example, an ELF or Mach-O executable).
 type Data struct {
 	// raw data
-	abbrev []byte;
-	aranges []byte;
-	frame []byte;
-	info []byte;
-	line []byte;
-	pubnames []byte;
-	ranges []byte;
-	str []byte;
+	abbrev		[]byte;
+	aranges		[]byte;
+	frame		[]byte;
+	info		[]byte;
+	line		[]byte;
+	pubnames	[]byte;
+	ranges		[]byte;
+	str		[]byte;
 
 	// parsed data
-	abbrevCache map[uint32] abbrevTable;
-	addrsize int;
-	order binary.ByteOrder;
-	typeCache map[Offset] Type;
-	unit []unit;
+	abbrevCache	map[uint32]abbrevTable;
+	addrsize	int;
+	order		binary.ByteOrder;
+	typeCache	map[Offset]Type;
+	unit		[]unit;
 }
 
 // New returns a new Data object initialized from the given parameters.
diff --git a/src/pkg/debug/dwarf/type.go b/src/pkg/debug/dwarf/type.go
index 63b63db04e..91334bdf29 100644
--- a/src/pkg/debug/dwarf/type.go
+++ b/src/pkg/debug/dwarf/type.go
@@ -25,8 +25,8 @@ type Type interface {
 // If a field is not known or not applicable for a given type,
 // the zero value is used.
 type CommonType struct {
-	ByteSize int64;		// size of value of this type, in bytes
-	Name string;		// name that can be used to refer to type
+	ByteSize	int64;	// size of value of this type, in bytes
+	Name		string;	// name that can be used to refer to type
 }
 
 func (c *CommonType) Common() *CommonType {
@@ -42,8 +42,8 @@ func (c *CommonType) Size() int64 {
 // A BasicType holds fields common to all basic types.
 type BasicType struct {
 	CommonType;
-	BitSize int64;
-	BitOffset int64;
+	BitSize		int64;
+	BitOffset	int64;
 }
 
 func (b *BasicType) Basic() *BasicType {
@@ -54,7 +54,7 @@ func (t *BasicType) String() string {
 	if t.Name != "" {
 		return t.Name;
 	}
-	return "?"
+	return "?";
 }
 
 // A CharType represents a signed character type.
@@ -102,8 +102,8 @@ type AddrType struct {
 // A QualType represents a type that has the C/C++ "const", "restrict", or "volatile" qualifier.
 type QualType struct {
 	CommonType;
-	Qual string;
-	Type Type;
+	Qual	string;
+	Type	Type;
 }
 
 func (t *QualType) String() string {
@@ -117,9 +117,9 @@ func (t *QualType) Size() int64 {
 // An ArrayType represents a fixed size array type.
 type ArrayType struct {
 	CommonType;
-	Type Type;
-	StrideBitSize int64;	// if > 0, number of bits to hold each element
-	Count int64;	// if == -1, an incomplete array, like char x[].
+	Type		Type;
+	StrideBitSize	int64;	// if > 0, number of bits to hold each element
+	Count		int64;	// if == -1, an incomplete array, like char x[].
 }
 
 func (t *ArrayType) String() string {
@@ -142,7 +142,7 @@ func (t *VoidType) String() string {
 // A PtrType represents a pointer type.
 type PtrType struct {
 	CommonType;
-	Type Type;
+	Type	Type;
 }
 
 func (t *PtrType) String() string {
@@ -152,20 +152,20 @@ func (t *PtrType) String() string {
 // A StructType represents a struct, union, or C++ class type.
 type StructType struct {
 	CommonType;
-	StructName string;
-	Kind string;	// "struct", "union", or "class".
-	Field []*StructField;
-	Incomplete bool;	// if true, struct, union, class is declared but not defined
+	StructName	string;
+	Kind		string;	// "struct", "union", or "class".
+	Field		[]*StructField;
+	Incomplete	bool;	// if true, struct, union, class is declared but not defined
 }
 
 // A StructField represents a field in a struct, union, or C++ class type.
 type StructField struct {
-	Name string;
-	Type Type;
-	ByteOffset int64;
-	ByteSize int64;
-	BitOffset int64;	// within the ByteSize bytes at ByteOffset
-	BitSize int64;	// zero if not a bit field
+	Name		string;
+	Type		Type;
+	ByteOffset	int64;
+	ByteSize	int64;
+	BitOffset	int64;	// within the ByteSize bytes at ByteOffset
+	BitSize		int64;	// zero if not a bit field
 }
 
 func (t *StructType) String() string {
@@ -205,14 +205,14 @@ func (t *StructType) Defn() string {
 // (inside CommonType).
 type EnumType struct {
 	CommonType;
-	EnumName string;
-	Val []*EnumValue;
+	EnumName	string;
+	Val		[]*EnumValue;
 }
 
 // An EnumValue represents a single enumeration value.
 type EnumValue struct {
-	Name string;
-	Val int64;
+	Name	string;
+	Val	int64;
 }
 
 func (t *EnumType) String() string {
@@ -234,8 +234,8 @@ func (t *EnumType) String() string {
 // A FuncType represents a function type.
 type FuncType struct {
 	CommonType;
-	ReturnType Type;
-	ParamType []Type;
+	ReturnType	Type;
+	ParamType	[]Type;
 }
 
 func (t *FuncType) String() string {
@@ -265,7 +265,7 @@ func (t *DotDotDotType) String() string {
 // A TypedefType represents a named type.
 type TypedefType struct {
 	CommonType;
-	Type Type;
+	Type	Type;
 }
 
 func (t *TypedefType) String() string {
@@ -358,7 +358,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 			case TagSubrangeType:
 				max, ok := kid.Val(AttrUpperBound).(int64);
 				if !ok {
-					max = -2;	 // Count == -1, as in x[].
+					max = -2;	// Count == -1, as in x[].
 				}
 				if ndim == 0 {
 					t.Count = max+1;
@@ -415,7 +415,9 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 			typ = new(UcharType);
 		}
 		d.typeCache[off] = typ;
-		t := typ.(interface{Basic() *BasicType}).Basic();
+		t := typ.(interface {
+			Basic() *BasicType;
+		}).Basic();
 		t.Name = name;
 		t.BitSize, _ = e.Val(AttrBitSize).(int64);
 		t.BitOffset, _ = e.Val(AttrBitOffset).(int64);
@@ -479,7 +481,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 					}
 					t.Field = fld;
 				}
-				t.Field = t.Field[0:n+1];
+				t.Field = t.Field[0 : n+1];
 				t.Field[n] = f;
 			}
 		}
@@ -530,7 +532,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 					}
 					t.Val = val;
 				}
-				t.Val = t.Val[0:n+1];
+				t.Val = t.Val[0 : n+1];
 				t.Val[n] = f;
 			}
 		}
@@ -586,7 +588,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 				}
 				t.ParamType = param;
 			}
-			t.ParamType = t.ParamType[0:n+1];
+			t.ParamType = t.ParamType[0 : n+1];
 			t.ParamType[n] = tkid;
 		}
 
diff --git a/src/pkg/debug/dwarf/type_test.go b/src/pkg/debug/dwarf/type_test.go
index d3aa6aa632..22a00c21c5 100644
--- a/src/pkg/debug/dwarf/type_test.go
+++ b/src/pkg/debug/dwarf/type_test.go
@@ -5,13 +5,13 @@
 package dwarf_test
 
 import (
-	. "debug/dwarf";
-	"debug/elf";
-	"debug/macho";
-	"testing";
+	.	"debug/dwarf";
+		"debug/elf";
+		"debug/macho";
+		"testing";
 )
 
-var typedefTests = map[string]string {
+var typedefTests = map[string]string{
 	"t_ptr_volatile_int": "*volatile int",
 	"t_ptr_const_char": "*const char",
 	"t_long": "long int",
@@ -26,8 +26,8 @@ var typedefTests = map[string]string {
 	"t_my_union": "union my_union {vi volatile int@0; x char@0 : 1@7; y int@0 : 4@28; array [40]long long int@0}",
 	"t_my_enum": "enum my_enum {e1=1; e2=2; e3=-5; e4=1000000000000000}",
 	"t_my_list": "struct list {val short int@0; next *t_my_list@8}",
-	"t_my_tree": "struct tree {left *struct tree@0; right *struct tree@8; val long long unsigned int@16}"
-};
+	"t_my_tree": "struct tree {left *struct tree@0; right *struct tree@8; val long long unsigned int@16}",
+}
 
 func elfData(t *testing.T, name string) *Data {
 	f, err := elf.Open(name);
diff --git a/src/pkg/debug/dwarf/unit.go b/src/pkg/debug/dwarf/unit.go
index 040151f39d..d4bcf5889d 100644
--- a/src/pkg/debug/dwarf/unit.go
+++ b/src/pkg/debug/dwarf/unit.go
@@ -13,11 +13,11 @@ import (
 // Each unit has its own abbreviation table and address size.
 
 type unit struct {
-	base Offset;	// byte offset of header within the aggregate info
-	off Offset;	// byte offset of data within the aggregate info
-	data []byte;
-	atable abbrevTable;
-	addrsize int;
+	base		Offset;	// byte offset of header within the aggregate info
+	off		Offset;	// byte offset of data within the aggregate info
+	data		[]byte;
+	atable		abbrevTable;
+	addrsize	int;
 }
 
 func (d *Data) parseUnits() ([]unit, os.Error) {
@@ -53,11 +53,10 @@ func (d *Data) parseUnits() ([]unit, os.Error) {
 		u.atable = atable;
 		u.addrsize = int(b.uint8());
 		u.off = b.off;
-		u.data = b.bytes(int(n - (2+4+1)));
+		u.data = b.bytes(int(n-(2+4+1)));
 	}
 	if b.err != nil {
 		return nil, b.err;
 	}
 	return units, nil;
 }
-
diff --git a/src/pkg/debug/elf/elf.go b/src/pkg/debug/elf/elf.go
index e2adf6bbe2..9a8d2d3491 100644
--- a/src/pkg/debug/elf/elf.go
+++ b/src/pkg/debug/elf/elf.go
@@ -48,667 +48,718 @@ import "strconv"
 
 // Indexes into the Header.Ident array.
 const (
-	EI_CLASS =	4;	/* Class of machine. */
-	EI_DATA =		5;	/* Data format. */
-	EI_VERSION =	6;	/* ELF format version. */
-	EI_OSABI =	7;	/* Operating system / ABI identification */
-	EI_ABIVERSION =	8;	/* ABI version */
-	EI_PAD =		9;	/* Start of padding (per SVR4 ABI). */
-	EI_NIDENT =	16;	/* Size of e_ident array. */
+	EI_CLASS	= 4;	/* Class of machine. */
+	EI_DATA		= 5;	/* Data format. */
+	EI_VERSION	= 6;	/* ELF format version. */
+	EI_OSABI	= 7;	/* Operating system / ABI identification */
+	EI_ABIVERSION	= 8;	/* ABI version */
+	EI_PAD		= 9;	/* Start of padding (per SVR4 ABI). */
+	EI_NIDENT	= 16;	/* Size of e_ident array. */
 )
 
 // Initial magic number for ELF files.
-const ELFMAG =		"\177ELF"
+const ELFMAG = "\177ELF"
 
 // Version is found in Header.Ident[EI_VERSION] and Header.Version.
 type Version byte
+
 const (
-	EV_NONE Version =		0;
-	EV_CURRENT Version =	1;
+	EV_NONE		Version	= 0;
+	EV_CURRENT	Version	= 1;
 )
-var versionStrings = []intName {
-	intName{ 0, "EV_NONE" },
-	intName{ 1, "EV_CURRENT" },
+
+var versionStrings = []intName{
+	intName{0, "EV_NONE"},
+	intName{1, "EV_CURRENT"},
 }
+
 func (i Version) String() string {
-	return stringName(uint32(i), versionStrings, false)
+	return stringName(uint32(i), versionStrings, false);
 }
 func (i Version) GoString() string {
-	return stringName(uint32(i), versionStrings, true)
+	return stringName(uint32(i), versionStrings, true);
 }
 
 // Class is found in Header.Ident[EI_CLASS] and Header.Class.
 type Class byte
+
 const (
-	ELFCLASSNONE Class =	0;	/* Unknown class. */
-	ELFCLASS32 Class =	1;	/* 32-bit architecture. */
-	ELFCLASS64 Class =	2;	/* 64-bit architecture. */
+	ELFCLASSNONE	Class	= 0;	/* Unknown class. */
+	ELFCLASS32	Class	= 1;	/* 32-bit architecture. */
+	ELFCLASS64	Class	= 2;	/* 64-bit architecture. */
 )
-var classStrings = []intName {
-	intName{ 0, "ELFCLASSNONE" },
-	intName{ 1, "ELFCLASS32" },
-	intName{ 2, "ELFCLASS64" },
+
+var classStrings = []intName{
+	intName{0, "ELFCLASSNONE"},
+	intName{1, "ELFCLASS32"},
+	intName{2, "ELFCLASS64"},
 }
+
 func (i Class) String() string {
-	return stringName(uint32(i), classStrings, false)
+	return stringName(uint32(i), classStrings, false);
 }
 func (i Class) GoString() string {
-	return stringName(uint32(i), classStrings, true)
+	return stringName(uint32(i), classStrings, true);
 }
 
 // Data is found in Header.Ident[EI_DATA] and Header.Data.
 type Data byte
+
 const (
-	ELFDATANONE Data =	0;	/* Unknown data format. */
-	ELFDATA2LSB Data =	1;	/* 2's complement little-endian. */
-	ELFDATA2MSB Data =	2;	/* 2's complement big-endian. */
+	ELFDATANONE	Data	= 0;	/* Unknown data format. */
+	ELFDATA2LSB	Data	= 1;	/* 2's complement little-endian. */
+	ELFDATA2MSB	Data	= 2;	/* 2's complement big-endian. */
 )
-var dataStrings = []intName {
-	intName{ 0, "ELFDATANONE" },
-	intName{ 1, "ELFDATA2LSB" },
-	intName{ 2, "ELFDATA2MSB" },
+
+var dataStrings = []intName{
+	intName{0, "ELFDATANONE"},
+	intName{1, "ELFDATA2LSB"},
+	intName{2, "ELFDATA2MSB"},
 }
+
 func (i Data) String() string {
-	return stringName(uint32(i), dataStrings, false)
+	return stringName(uint32(i), dataStrings, false);
 }
 func (i Data) GoString() string {
-	return stringName(uint32(i), dataStrings, true)
+	return stringName(uint32(i), dataStrings, true);
 }
 
 // OSABI is found in Header.Ident[EI_OSABI] and Header.OSABI.
 type OSABI byte
+
 const (
-	ELFOSABI_NONE OSABI =		0;	/* UNIX System V ABI */
-	ELFOSABI_HPUX OSABI =		1;	/* HP-UX operating system */
-	ELFOSABI_NETBSD OSABI =		2;	/* NetBSD */
-	ELFOSABI_LINUX OSABI =		3;	/* GNU/Linux */
-	ELFOSABI_HURD OSABI =		4;	/* GNU/Hurd */
-	ELFOSABI_86OPEN OSABI =		5;	/* 86Open common IA32 ABI */
-	ELFOSABI_SOLARIS OSABI =	6;	/* Solaris */
-	ELFOSABI_AIX OSABI =		7;	/* AIX */
-	ELFOSABI_IRIX OSABI =		8;	/* IRIX */
-	ELFOSABI_FREEBSD OSABI =	9;	/* FreeBSD */
-	ELFOSABI_TRU64 OSABI =		10;	/* TRU64 UNIX */
-	ELFOSABI_MODESTO OSABI =	11;	/* Novell Modesto */
-	ELFOSABI_OPENBSD OSABI =	12;	/* OpenBSD */
-	ELFOSABI_OPENVMS OSABI =	13;	/* Open VMS */
-	ELFOSABI_NSK OSABI =		14;	/* HP Non-Stop Kernel */
-	ELFOSABI_ARM OSABI =		97;	/* ARM */
-	ELFOSABI_STANDALONE OSABI =	255;	/* Standalone (embedded) application */
+	ELFOSABI_NONE		OSABI	= 0;	/* UNIX System V ABI */
+	ELFOSABI_HPUX		OSABI	= 1;	/* HP-UX operating system */
+	ELFOSABI_NETBSD		OSABI	= 2;	/* NetBSD */
+	ELFOSABI_LINUX		OSABI	= 3;	/* GNU/Linux */
+	ELFOSABI_HURD		OSABI	= 4;	/* GNU/Hurd */
+	ELFOSABI_86OPEN		OSABI	= 5;	/* 86Open common IA32 ABI */
+	ELFOSABI_SOLARIS	OSABI	= 6;	/* Solaris */
+	ELFOSABI_AIX		OSABI	= 7;	/* AIX */
+	ELFOSABI_IRIX		OSABI	= 8;	/* IRIX */
+	ELFOSABI_FREEBSD	OSABI	= 9;	/* FreeBSD */
+	ELFOSABI_TRU64		OSABI	= 10;	/* TRU64 UNIX */
+	ELFOSABI_MODESTO	OSABI	= 11;	/* Novell Modesto */
+	ELFOSABI_OPENBSD	OSABI	= 12;	/* OpenBSD */
+	ELFOSABI_OPENVMS	OSABI	= 13;	/* Open VMS */
+	ELFOSABI_NSK		OSABI	= 14;	/* HP Non-Stop Kernel */
+	ELFOSABI_ARM		OSABI	= 97;	/* ARM */
+	ELFOSABI_STANDALONE	OSABI	= 255;	/* Standalone (embedded) application */
 )
-var osabiStrings = []intName {
-	intName{ 0, "ELFOSABI_NONE" },
-	intName{ 1, "ELFOSABI_HPUX" },
-	intName{ 2, "ELFOSABI_NETBSD" },
-	intName{ 3, "ELFOSABI_LINUX" },
-	intName{ 4, "ELFOSABI_HURD" },
-	intName{ 5, "ELFOSABI_86OPEN" },
-	intName{ 6, "ELFOSABI_SOLARIS" },
-	intName{ 7, "ELFOSABI_AIX" },
-	intName{ 8, "ELFOSABI_IRIX" },
-	intName{ 9, "ELFOSABI_FREEBSD" },
-	intName{ 10, "ELFOSABI_TRU64" },
-	intName{ 11, "ELFOSABI_MODESTO" },
-	intName{ 12, "ELFOSABI_OPENBSD" },
-	intName{ 13, "ELFOSABI_OPENVMS" },
-	intName{ 14, "ELFOSABI_NSK" },
-	intName{ 97, "ELFOSABI_ARM" },
-	intName{ 255, "ELFOSABI_STANDALONE" },
+
+var osabiStrings = []intName{
+	intName{0, "ELFOSABI_NONE"},
+	intName{1, "ELFOSABI_HPUX"},
+	intName{2, "ELFOSABI_NETBSD"},
+	intName{3, "ELFOSABI_LINUX"},
+	intName{4, "ELFOSABI_HURD"},
+	intName{5, "ELFOSABI_86OPEN"},
+	intName{6, "ELFOSABI_SOLARIS"},
+	intName{7, "ELFOSABI_AIX"},
+	intName{8, "ELFOSABI_IRIX"},
+	intName{9, "ELFOSABI_FREEBSD"},
+	intName{10, "ELFOSABI_TRU64"},
+	intName{11, "ELFOSABI_MODESTO"},
+	intName{12, "ELFOSABI_OPENBSD"},
+	intName{13, "ELFOSABI_OPENVMS"},
+	intName{14, "ELFOSABI_NSK"},
+	intName{97, "ELFOSABI_ARM"},
+	intName{255, "ELFOSABI_STANDALONE"},
 }
+
 func (i OSABI) String() string {
-	return stringName(uint32(i), osabiStrings, false)
+	return stringName(uint32(i), osabiStrings, false);
 }
 func (i OSABI) GoString() string {
-	return stringName(uint32(i), osabiStrings, true)
+	return stringName(uint32(i), osabiStrings, true);
 }
 
 // Type is found in Header.Type.
 type Type uint16
+
 const (
-	ET_NONE Type =		0;	/* Unknown type. */
-	ET_REL Type =		1;	/* Relocatable. */
-	ET_EXEC Type =		2;	/* Executable. */
-	ET_DYN Type =		3;	/* Shared object. */
-	ET_CORE Type =		4;	/* Core file. */
-	ET_LOOS Type =		0xfe00;	/* First operating system specific. */
-	ET_HIOS Type =		0xfeff;	/* Last operating system-specific. */
-	ET_LOPROC Type =	0xff00;	/* First processor-specific. */
-	ET_HIPROC Type =	0xffff;	/* Last processor-specific. */
+	ET_NONE		Type	= 0;		/* Unknown type. */
+	ET_REL		Type	= 1;		/* Relocatable. */
+	ET_EXEC		Type	= 2;		/* Executable. */
+	ET_DYN		Type	= 3;		/* Shared object. */
+	ET_CORE		Type	= 4;		/* Core file. */
+	ET_LOOS		Type	= 0xfe00;	/* First operating system specific. */
+	ET_HIOS		Type	= 0xfeff;	/* Last operating system-specific. */
+	ET_LOPROC	Type	= 0xff00;	/* First processor-specific. */
+	ET_HIPROC	Type	= 0xffff;	/* Last processor-specific. */
 )
+
 var typeStrings = []intName{
-	intName{ 0, "ET_NONE" },
-	intName{ 1, "ET_REL" },
-	intName{ 2, "ET_EXEC" },
-	intName{ 3, "ET_DYN" },
-	intName{ 4, "ET_CORE" },
-	intName{ 0xfe00, "ET_LOOS" },
-	intName{ 0xfeff, "ET_HIOS" },
-	intName{ 0xff00, "ET_LOPROC" },
-	intName{ 0xffff, "ET_HIPROC" },
+	intName{0, "ET_NONE"},
+	intName{1, "ET_REL"},
+	intName{2, "ET_EXEC"},
+	intName{3, "ET_DYN"},
+	intName{4, "ET_CORE"},
+	intName{0xfe00, "ET_LOOS"},
+	intName{0xfeff, "ET_HIOS"},
+	intName{0xff00, "ET_LOPROC"},
+	intName{0xffff, "ET_HIPROC"},
 }
+
 func (i Type) String() string {
-	return stringName(uint32(i), typeStrings, false)
+	return stringName(uint32(i), typeStrings, false);
 }
 func (i Type) GoString() string {
-	return stringName(uint32(i), typeStrings, true)
+	return stringName(uint32(i), typeStrings, true);
 }
 
 // Machine is found in Header.Machine.
 type Machine uint16
+
 const (
-	EM_NONE Machine =		0;	/* Unknown machine. */
-	EM_M32 Machine =		1;	/* AT&T WE32100. */
-	EM_SPARC Machine =	2;	/* Sun SPARC. */
-	EM_386 Machine =		3;	/* Intel i386. */
-	EM_68K Machine =		4;	/* Motorola 68000. */
-	EM_88K Machine =		5;	/* Motorola 88000. */
-	EM_860 Machine =		7;	/* Intel i860. */
-	EM_MIPS Machine =		8;	/* MIPS R3000 Big-Endian only. */
-	EM_S370 Machine =		9;	/* IBM System/370. */
-	EM_MIPS_RS3_LE Machine =	10;	/* MIPS R3000 Little-Endian. */
-	EM_PARISC Machine =	15;	/* HP PA-RISC. */
-	EM_VPP500 Machine =	17;	/* Fujitsu VPP500. */
-	EM_SPARC32PLUS Machine =	18;	/* SPARC v8plus. */
-	EM_960 Machine =		19;	/* Intel 80960. */
-	EM_PPC Machine =		20;	/* PowerPC 32-bit. */
-	EM_PPC64 Machine =	21;	/* PowerPC 64-bit. */
-	EM_S390 Machine =		22;	/* IBM System/390. */
-	EM_V800 Machine =		36;	/* NEC V800. */
-	EM_FR20 Machine =		37;	/* Fujitsu FR20. */
-	EM_RH32 Machine =		38;	/* TRW RH-32. */
-	EM_RCE Machine =		39;	/* Motorola RCE. */
-	EM_ARM Machine =		40;	/* ARM. */
-	EM_SH Machine =		42;	/* Hitachi SH. */
-	EM_SPARCV9 Machine =	43;	/* SPARC v9 64-bit. */
-	EM_TRICORE Machine =	44;	/* Siemens TriCore embedded processor. */
-	EM_ARC Machine =		45;	/* Argonaut RISC Core. */
-	EM_H8_300 Machine =	46;	/* Hitachi H8/300. */
-	EM_H8_300H Machine =	47;	/* Hitachi H8/300H. */
-	EM_H8S Machine =		48;	/* Hitachi H8S. */
-	EM_H8_500 Machine =	49;	/* Hitachi H8/500. */
-	EM_IA_64 Machine =	50;	/* Intel IA-64 Processor. */
-	EM_MIPS_X Machine =	51;	/* Stanford MIPS-X. */
-	EM_COLDFIRE Machine =	52;	/* Motorola ColdFire. */
-	EM_68HC12 Machine =	53;	/* Motorola M68HC12. */
-	EM_MMA Machine =		54;	/* Fujitsu MMA. */
-	EM_PCP Machine =		55;	/* Siemens PCP. */
-	EM_NCPU Machine =		56;	/* Sony nCPU. */
-	EM_NDR1 Machine =		57;	/* Denso NDR1 microprocessor. */
-	EM_STARCORE Machine =	58;	/* Motorola Star*Core processor. */
-	EM_ME16 Machine =		59;	/* Toyota ME16 processor. */
-	EM_ST100 Machine =	60;	/* STMicroelectronics ST100 processor. */
-	EM_TINYJ Machine =	61;	/* Advanced Logic Corp. TinyJ processor. */
-	EM_X86_64 Machine =	62;	/* Advanced Micro Devices x86-64 */
+	EM_NONE		Machine	= 0;	/* Unknown machine. */
+	EM_M32		Machine	= 1;	/* AT&T WE32100. */
+	EM_SPARC	Machine	= 2;	/* Sun SPARC. */
+	EM_386		Machine	= 3;	/* Intel i386. */
+	EM_68K		Machine	= 4;	/* Motorola 68000. */
+	EM_88K		Machine	= 5;	/* Motorola 88000. */
+	EM_860		Machine	= 7;	/* Intel i860. */
+	EM_MIPS		Machine	= 8;	/* MIPS R3000 Big-Endian only. */
+	EM_S370		Machine	= 9;	/* IBM System/370. */
+	EM_MIPS_RS3_LE	Machine	= 10;	/* MIPS R3000 Little-Endian. */
+	EM_PARISC	Machine	= 15;	/* HP PA-RISC. */
+	EM_VPP500	Machine	= 17;	/* Fujitsu VPP500. */
+	EM_SPARC32PLUS	Machine	= 18;	/* SPARC v8plus. */
+	EM_960		Machine	= 19;	/* Intel 80960. */
+	EM_PPC		Machine	= 20;	/* PowerPC 32-bit. */
+	EM_PPC64	Machine	= 21;	/* PowerPC 64-bit. */
+	EM_S390		Machine	= 22;	/* IBM System/390. */
+	EM_V800		Machine	= 36;	/* NEC V800. */
+	EM_FR20		Machine	= 37;	/* Fujitsu FR20. */
+	EM_RH32		Machine	= 38;	/* TRW RH-32. */
+	EM_RCE		Machine	= 39;	/* Motorola RCE. */
+	EM_ARM		Machine	= 40;	/* ARM. */
+	EM_SH		Machine	= 42;	/* Hitachi SH. */
+	EM_SPARCV9	Machine	= 43;	/* SPARC v9 64-bit. */
+	EM_TRICORE	Machine	= 44;	/* Siemens TriCore embedded processor. */
+	EM_ARC		Machine	= 45;	/* Argonaut RISC Core. */
+	EM_H8_300	Machine	= 46;	/* Hitachi H8/300. */
+	EM_H8_300H	Machine	= 47;	/* Hitachi H8/300H. */
+	EM_H8S		Machine	= 48;	/* Hitachi H8S. */
+	EM_H8_500	Machine	= 49;	/* Hitachi H8/500. */
+	EM_IA_64	Machine	= 50;	/* Intel IA-64 Processor. */
+	EM_MIPS_X	Machine	= 51;	/* Stanford MIPS-X. */
+	EM_COLDFIRE	Machine	= 52;	/* Motorola ColdFire. */
+	EM_68HC12	Machine	= 53;	/* Motorola M68HC12. */
+	EM_MMA		Machine	= 54;	/* Fujitsu MMA. */
+	EM_PCP		Machine	= 55;	/* Siemens PCP. */
+	EM_NCPU		Machine	= 56;	/* Sony nCPU. */
+	EM_NDR1		Machine	= 57;	/* Denso NDR1 microprocessor. */
+	EM_STARCORE	Machine	= 58;	/* Motorola Star*Core processor. */
+	EM_ME16		Machine	= 59;	/* Toyota ME16 processor. */
+	EM_ST100	Machine	= 60;	/* STMicroelectronics ST100 processor. */
+	EM_TINYJ	Machine	= 61;	/* Advanced Logic Corp. TinyJ processor. */
+	EM_X86_64	Machine	= 62;	/* Advanced Micro Devices x86-64 */
 
 	/* Non-standard or deprecated. */
-	EM_486 Machine =		6;	/* Intel i486. */
-	EM_MIPS_RS4_BE Machine =	10;	/* MIPS R4000 Big-Endian */
-	EM_ALPHA_STD Machine =	41;	/* Digital Alpha (standard value). */
-	EM_ALPHA Machine =	0x9026;	/* Alpha (written in the absence of an ABI) */
+	EM_486		Machine	= 6;		/* Intel i486. */
+	EM_MIPS_RS4_BE	Machine	= 10;		/* MIPS R4000 Big-Endian */
+	EM_ALPHA_STD	Machine	= 41;		/* Digital Alpha (standard value). */
+	EM_ALPHA	Machine	= 0x9026;	/* Alpha (written in the absence of an ABI) */
 )
-var machineStrings = []intName {
-	intName{ 0, "EM_NONE" },
-	intName{ 1, "EM_M32" },
-	intName{ 2, "EM_SPARC" },
-	intName{ 3, "EM_386" },
-	intName{ 4, "EM_68K" },
-	intName{ 5, "EM_88K" },
-	intName{ 7, "EM_860" },
-	intName{ 8, "EM_MIPS" },
-	intName{ 9, "EM_S370" },
-	intName{ 10, "EM_MIPS_RS3_LE" },
-	intName{ 15, "EM_PARISC" },
-	intName{ 17, "EM_VPP500" },
-	intName{ 18, "EM_SPARC32PLUS" },
-	intName{ 19, "EM_960" },
-	intName{ 20, "EM_PPC" },
-	intName{ 21, "EM_PPC64" },
-	intName{ 22, "EM_S390" },
-	intName{ 36, "EM_V800" },
-	intName{ 37, "EM_FR20" },
-	intName{ 38, "EM_RH32" },
-	intName{ 39, "EM_RCE" },
-	intName{ 40, "EM_ARM" },
-	intName{ 42, "EM_SH" },
-	intName{ 43, "EM_SPARCV9" },
-	intName{ 44, "EM_TRICORE" },
-	intName{ 45, "EM_ARC" },
-	intName{ 46, "EM_H8_300" },
-	intName{ 47, "EM_H8_300H" },
-	intName{ 48, "EM_H8S" },
-	intName{ 49, "EM_H8_500" },
-	intName{ 50, "EM_IA_64" },
-	intName{ 51, "EM_MIPS_X" },
-	intName{ 52, "EM_COLDFIRE" },
-	intName{ 53, "EM_68HC12" },
-	intName{ 54, "EM_MMA" },
-	intName{ 55, "EM_PCP" },
-	intName{ 56, "EM_NCPU" },
-	intName{ 57, "EM_NDR1" },
-	intName{ 58, "EM_STARCORE" },
-	intName{ 59, "EM_ME16" },
-	intName{ 60, "EM_ST100" },
-	intName{ 61, "EM_TINYJ" },
-	intName{ 62, "EM_X86_64" },
+
+var machineStrings = []intName{
+	intName{0, "EM_NONE"},
+	intName{1, "EM_M32"},
+	intName{2, "EM_SPARC"},
+	intName{3, "EM_386"},
+	intName{4, "EM_68K"},
+	intName{5, "EM_88K"},
+	intName{7, "EM_860"},
+	intName{8, "EM_MIPS"},
+	intName{9, "EM_S370"},
+	intName{10, "EM_MIPS_RS3_LE"},
+	intName{15, "EM_PARISC"},
+	intName{17, "EM_VPP500"},
+	intName{18, "EM_SPARC32PLUS"},
+	intName{19, "EM_960"},
+	intName{20, "EM_PPC"},
+	intName{21, "EM_PPC64"},
+	intName{22, "EM_S390"},
+	intName{36, "EM_V800"},
+	intName{37, "EM_FR20"},
+	intName{38, "EM_RH32"},
+	intName{39, "EM_RCE"},
+	intName{40, "EM_ARM"},
+	intName{42, "EM_SH"},
+	intName{43, "EM_SPARCV9"},
+	intName{44, "EM_TRICORE"},
+	intName{45, "EM_ARC"},
+	intName{46, "EM_H8_300"},
+	intName{47, "EM_H8_300H"},
+	intName{48, "EM_H8S"},
+	intName{49, "EM_H8_500"},
+	intName{50, "EM_IA_64"},
+	intName{51, "EM_MIPS_X"},
+	intName{52, "EM_COLDFIRE"},
+	intName{53, "EM_68HC12"},
+	intName{54, "EM_MMA"},
+	intName{55, "EM_PCP"},
+	intName{56, "EM_NCPU"},
+	intName{57, "EM_NDR1"},
+	intName{58, "EM_STARCORE"},
+	intName{59, "EM_ME16"},
+	intName{60, "EM_ST100"},
+	intName{61, "EM_TINYJ"},
+	intName{62, "EM_X86_64"},
 
 	/* Non-standard or deprecated. */
-	intName{ 6, "EM_486" },
-	intName{ 10, "EM_MIPS_RS4_BE" },
-	intName{ 41, "EM_ALPHA_STD" },
-	intName{ 0x9026, "EM_ALPHA" },
+	intName{6, "EM_486"},
+	intName{10, "EM_MIPS_RS4_BE"},
+	intName{41, "EM_ALPHA_STD"},
+	intName{0x9026, "EM_ALPHA"},
 }
+
 func (i Machine) String() string {
-	return stringName(uint32(i), machineStrings, false)
+	return stringName(uint32(i), machineStrings, false);
 }
 func (i Machine) GoString() string {
-	return stringName(uint32(i), machineStrings, true)
+	return stringName(uint32(i), machineStrings, true);
 }
 
 // Special section indices.
 type SectionIndex int
+
 const (
-	SHN_UNDEF SectionIndex =	     0;		/* Undefined, missing, irrelevant. */
-	SHN_LORESERVE SectionIndex =	0xff00;		/* First of reserved range. */
-	SHN_LOPROC SectionIndex =	0xff00;		/* First processor-specific. */
-	SHN_HIPROC SectionIndex =	0xff1f;		/* Last processor-specific. */
-	SHN_LOOS SectionIndex =	0xff20;		/* First operating system-specific. */
-	SHN_HIOS SectionIndex =	0xff3f;		/* Last operating system-specific. */
-	SHN_ABS SectionIndex =		0xfff1;		/* Absolute values. */
-	SHN_COMMON SectionIndex =	0xfff2;		/* Common data. */
-	SHN_XINDEX SectionIndex =	0xffff;		/* Escape -- index stored elsewhere. */
-	SHN_HIRESERVE SectionIndex =	0xffff;		/* Last of reserved range. */
+	SHN_UNDEF	SectionIndex	= 0;		/* Undefined, missing, irrelevant. */
+	SHN_LORESERVE	SectionIndex	= 0xff00;	/* First of reserved range. */
+	SHN_LOPROC	SectionIndex	= 0xff00;	/* First processor-specific. */
+	SHN_HIPROC	SectionIndex	= 0xff1f;	/* Last processor-specific. */
+	SHN_LOOS	SectionIndex	= 0xff20;	/* First operating system-specific. */
+	SHN_HIOS	SectionIndex	= 0xff3f;	/* Last operating system-specific. */
+	SHN_ABS		SectionIndex	= 0xfff1;	/* Absolute values. */
+	SHN_COMMON	SectionIndex	= 0xfff2;	/* Common data. */
+	SHN_XINDEX	SectionIndex	= 0xffff;	/* Escape -- index stored elsewhere. */
+	SHN_HIRESERVE	SectionIndex	= 0xffff;	/* Last of reserved range. */
 )
-var shnStrings = []intName {
-	intName{ 0, "SHN_UNDEF" },
-	intName{ 0xff00, "SHN_LOPROC" },
-	intName{ 0xff20, "SHN_LOOS" },
-	intName{ 0xfff1, "SHN_ABS" },
-	intName{ 0xfff2, "SHN_COMMON" },
-	intName{ 0xffff, "SHN_XINDEX" },
+
+var shnStrings = []intName{
+	intName{0, "SHN_UNDEF"},
+	intName{0xff00, "SHN_LOPROC"},
+	intName{0xff20, "SHN_LOOS"},
+	intName{0xfff1, "SHN_ABS"},
+	intName{0xfff2, "SHN_COMMON"},
+	intName{0xffff, "SHN_XINDEX"},
 }
+
 func (i SectionIndex) String() string {
-	return stringName(uint32(i), shnStrings, false)
+	return stringName(uint32(i), shnStrings, false);
 }
 func (i SectionIndex) GoString() string {
-	return stringName(uint32(i), shnStrings, true)
+	return stringName(uint32(i), shnStrings, true);
 }
 
 // Section type.
 type SectionType uint32
+
 const (
-	SHT_NULL SectionType =		0;	/* inactive */
-	SHT_PROGBITS SectionType =		1;	/* program defined information */
-	SHT_SYMTAB SectionType =		2;	/* symbol table section */
-	SHT_STRTAB SectionType =		3;	/* string table section */
-	SHT_RELA SectionType =		4;	/* relocation section with addends */
-	SHT_HASH SectionType =		5;	/* symbol hash table section */
-	SHT_DYNAMIC SectionType =		6;	/* dynamic section */
-	SHT_NOTE SectionType =		7;	/* note section */
-	SHT_NOBITS SectionType =		8;	/* no space section */
-	SHT_REL SectionType =			9;	/* relocation section - no addends */
-	SHT_SHLIB SectionType =		10;	/* reserved - purpose unknown */
-	SHT_DYNSYM SectionType =		11;	/* dynamic symbol table section */
-	SHT_INIT_ARRAY SectionType =		14;	/* Initialization function pointers. */
-	SHT_FINI_ARRAY SectionType =		15;	/* Termination function pointers. */
-	SHT_PREINIT_ARRAY SectionType =	16;	/* Pre-initialization function ptrs. */
-	SHT_GROUP SectionType =		17;	/* Section group. */
-	SHT_SYMTAB_SHNDX SectionType =	18;	/* Section indexes (see SHN_XINDEX). */
-	SHT_LOOS SectionType =	0x60000000;	/* First of OS specific semantics */
-	SHT_HIOS SectionType =	0x6fffffff;	/* Last of OS specific semantics */
-	SHT_LOPROC SectionType =	0x70000000;	/* reserved range for processor */
-	SHT_HIPROC SectionType =	0x7fffffff;	/* specific section header types */
-	SHT_LOUSER SectionType =	0x80000000;	/* reserved range for application */
-	SHT_HIUSER SectionType =	0xffffffff;	/* specific indexes */
+	SHT_NULL		SectionType	= 0;		/* inactive */
+	SHT_PROGBITS		SectionType	= 1;		/* program defined information */
+	SHT_SYMTAB		SectionType	= 2;		/* symbol table section */
+	SHT_STRTAB		SectionType	= 3;		/* string table section */
+	SHT_RELA		SectionType	= 4;		/* relocation section with addends */
+	SHT_HASH		SectionType	= 5;		/* symbol hash table section */
+	SHT_DYNAMIC		SectionType	= 6;		/* dynamic section */
+	SHT_NOTE		SectionType	= 7;		/* note section */
+	SHT_NOBITS		SectionType	= 8;		/* no space section */
+	SHT_REL			SectionType	= 9;		/* relocation section - no addends */
+	SHT_SHLIB		SectionType	= 10;		/* reserved - purpose unknown */
+	SHT_DYNSYM		SectionType	= 11;		/* dynamic symbol table section */
+	SHT_INIT_ARRAY		SectionType	= 14;		/* Initialization function pointers. */
+	SHT_FINI_ARRAY		SectionType	= 15;		/* Termination function pointers. */
+	SHT_PREINIT_ARRAY	SectionType	= 16;		/* Pre-initialization function ptrs. */
+	SHT_GROUP		SectionType	= 17;		/* Section group. */
+	SHT_SYMTAB_SHNDX	SectionType	= 18;		/* Section indexes (see SHN_XINDEX). */
+	SHT_LOOS		SectionType	= 0x60000000;	/* First of OS specific semantics */
+	SHT_HIOS		SectionType	= 0x6fffffff;	/* Last of OS specific semantics */
+	SHT_LOPROC		SectionType	= 0x70000000;	/* reserved range for processor */
+	SHT_HIPROC		SectionType	= 0x7fffffff;	/* specific section header types */
+	SHT_LOUSER		SectionType	= 0x80000000;	/* reserved range for application */
+	SHT_HIUSER		SectionType	= 0xffffffff;	/* specific indexes */
 )
-var shtStrings = []intName {
-	intName{ 0, "SHT_NULL" },
-	intName{ 1, "SHT_PROGBITS" },
-	intName{ 2, "SHT_SYMTAB" },
-	intName{ 3, "SHT_STRTAB" },
-	intName{ 4, "SHT_RELA" },
-	intName{ 5, "SHT_HASH" },
-	intName{ 6, "SHT_DYNAMIC" },
-	intName{ 7, "SHT_NOTE" },
-	intName{ 8, "SHT_NOBITS" },
-	intName{ 9, "SHT_REL" },
-	intName{ 10, "SHT_SHLIB" },
-	intName{ 11, "SHT_DYNSYM" },
-	intName{ 14, "SHT_INIT_ARRAY" },
-	intName{ 15, "SHT_FINI_ARRAY" },
-	intName{ 16, "SHT_PREINIT_ARRAY" },
-	intName{ 17, "SHT_GROUP" },
-	intName{ 18, "SHT_SYMTAB_SHNDX" },
-	intName{ 0x60000000, "SHT_LOOS" },
-	intName{ 0x6fffffff, "SHT_HIOS" },
-	intName{ 0x70000000, "SHT_LOPROC" },
-	intName{ 0x7fffffff, "SHT_HIPROC" },
-	intName{ 0x80000000, "SHT_LOUSER" },
-	intName{ 0xffffffff, "SHT_HIUSER" },
+
+var shtStrings = []intName{
+	intName{0, "SHT_NULL"},
+	intName{1, "SHT_PROGBITS"},
+	intName{2, "SHT_SYMTAB"},
+	intName{3, "SHT_STRTAB"},
+	intName{4, "SHT_RELA"},
+	intName{5, "SHT_HASH"},
+	intName{6, "SHT_DYNAMIC"},
+	intName{7, "SHT_NOTE"},
+	intName{8, "SHT_NOBITS"},
+	intName{9, "SHT_REL"},
+	intName{10, "SHT_SHLIB"},
+	intName{11, "SHT_DYNSYM"},
+	intName{14, "SHT_INIT_ARRAY"},
+	intName{15, "SHT_FINI_ARRAY"},
+	intName{16, "SHT_PREINIT_ARRAY"},
+	intName{17, "SHT_GROUP"},
+	intName{18, "SHT_SYMTAB_SHNDX"},
+	intName{0x60000000, "SHT_LOOS"},
+	intName{0x6fffffff, "SHT_HIOS"},
+	intName{0x70000000, "SHT_LOPROC"},
+	intName{0x7fffffff, "SHT_HIPROC"},
+	intName{0x80000000, "SHT_LOUSER"},
+	intName{0xffffffff, "SHT_HIUSER"},
 }
+
 func (i SectionType) String() string {
-	return stringName(uint32(i), shtStrings, false)
+	return stringName(uint32(i), shtStrings, false);
 }
 func (i SectionType) GoString() string {
-	return stringName(uint32(i), shtStrings, true)
+	return stringName(uint32(i), shtStrings, true);
 }
 
 // Section flags.
 type SectionFlag uint32
+
 const (
-	SHF_WRITE SectionFlag =		0x1;	/* Section contains writable data. */
-	SHF_ALLOC SectionFlag =		0x2;	/* Section occupies memory. */
-	SHF_EXECINSTR SectionFlag =		0x4;	/* Section contains instructions. */
-	SHF_MERGE SectionFlag =		0x10;	/* Section may be merged. */
-	SHF_STRINGS SectionFlag =		0x20;	/* Section contains strings. */
-	SHF_INFO_LINK SectionFlag =		0x40;	/* sh_info holds section index. */
-	SHF_LINK_ORDER SectionFlag =		0x80;	/* Special ordering requirements. */
-	SHF_OS_NONCONFORMING SectionFlag =	0x100;	/* OS-specific processing required. */
-	SHF_GROUP SectionFlag =		0x200;	/* Member of section group. */
-	SHF_TLS SectionFlag =			0x400;	/* Section contains TLS data. */
-	SHF_MASKOS SectionFlag =	0x0ff00000;	/* OS-specific semantics. */
-	SHF_MASKPROC SectionFlag =	0xf0000000;	/* Processor-specific semantics. */
+	SHF_WRITE		SectionFlag	= 0x1;		/* Section contains writable data. */
+	SHF_ALLOC		SectionFlag	= 0x2;		/* Section occupies memory. */
+	SHF_EXECINSTR		SectionFlag	= 0x4;		/* Section contains instructions. */
+	SHF_MERGE		SectionFlag	= 0x10;		/* Section may be merged. */
+	SHF_STRINGS		SectionFlag	= 0x20;		/* Section contains strings. */
+	SHF_INFO_LINK		SectionFlag	= 0x40;		/* sh_info holds section index. */
+	SHF_LINK_ORDER		SectionFlag	= 0x80;		/* Special ordering requirements. */
+	SHF_OS_NONCONFORMING	SectionFlag	= 0x100;	/* OS-specific processing required. */
+	SHF_GROUP		SectionFlag	= 0x200;	/* Member of section group. */
+	SHF_TLS			SectionFlag	= 0x400;	/* Section contains TLS data. */
+	SHF_MASKOS		SectionFlag	= 0x0ff00000;	/* OS-specific semantics. */
+	SHF_MASKPROC		SectionFlag	= 0xf0000000;	/* Processor-specific semantics. */
 )
-var shfStrings = []intName {
-	intName{ 0x1, "SHF_WRITE" },
-	intName{ 0x2, "SHF_ALLOC" },
-	intName{ 0x4, "SHF_EXECINSTR" },
-	intName{ 0x10, "SHF_MERGE" },
-	intName{ 0x20, "SHF_STRINGS" },
-	intName{ 0x40, "SHF_INFO_LINK" },
-	intName{ 0x80, "SHF_LINK_ORDER" },
-	intName{ 0x100, "SHF_OS_NONCONFORMING" },
-	intName{ 0x200, "SHF_GROUP" },
-	intName{ 0x400, "SHF_TLS" },
+
+var shfStrings = []intName{
+	intName{0x1, "SHF_WRITE"},
+	intName{0x2, "SHF_ALLOC"},
+	intName{0x4, "SHF_EXECINSTR"},
+	intName{0x10, "SHF_MERGE"},
+	intName{0x20, "SHF_STRINGS"},
+	intName{0x40, "SHF_INFO_LINK"},
+	intName{0x80, "SHF_LINK_ORDER"},
+	intName{0x100, "SHF_OS_NONCONFORMING"},
+	intName{0x200, "SHF_GROUP"},
+	intName{0x400, "SHF_TLS"},
 }
+
 func (i SectionFlag) String() string {
-	return flagName(uint32(i), shfStrings, false)
+	return flagName(uint32(i), shfStrings, false);
 }
 func (i SectionFlag) GoString() string {
-	return flagName(uint32(i), shfStrings, true)
+	return flagName(uint32(i), shfStrings, true);
 }
 
 // Prog.Type
 type ProgType int
+
 const (
-	PT_NULL ProgType =		0;	/* Unused entry. */
-	PT_LOAD ProgType =		1;	/* Loadable segment. */
-	PT_DYNAMIC ProgType =	2;	/* Dynamic linking information segment. */
-	PT_INTERP ProgType =	3;	/* Pathname of interpreter. */
-	PT_NOTE ProgType =		4;	/* Auxiliary information. */
-	PT_SHLIB ProgType =	5;	/* Reserved (not used). */
-	PT_PHDR ProgType =		6;	/* Location of program header itself. */
-	PT_TLS ProgType =		7;	/* Thread local storage segment */
-	PT_LOOS ProgType =		0x60000000;	/* First OS-specific. */
-	PT_HIOS ProgType =		0x6fffffff;	/* Last OS-specific. */
-	PT_LOPROC ProgType =	0x70000000;	/* First processor-specific type. */
-	PT_HIPROC ProgType =	0x7fffffff;	/* Last processor-specific type. */
+	PT_NULL		ProgType	= 0;		/* Unused entry. */
+	PT_LOAD		ProgType	= 1;		/* Loadable segment. */
+	PT_DYNAMIC	ProgType	= 2;		/* Dynamic linking information segment. */
+	PT_INTERP	ProgType	= 3;		/* Pathname of interpreter. */
+	PT_NOTE		ProgType	= 4;		/* Auxiliary information. */
+	PT_SHLIB	ProgType	= 5;		/* Reserved (not used). */
+	PT_PHDR		ProgType	= 6;		/* Location of program header itself. */
+	PT_TLS		ProgType	= 7;		/* Thread local storage segment */
+	PT_LOOS		ProgType	= 0x60000000;	/* First OS-specific. */
+	PT_HIOS		ProgType	= 0x6fffffff;	/* Last OS-specific. */
+	PT_LOPROC	ProgType	= 0x70000000;	/* First processor-specific type. */
+	PT_HIPROC	ProgType	= 0x7fffffff;	/* Last processor-specific type. */
 )
-var ptStrings = []intName {
-	intName{ 0, "PT_NULL" },
-	intName{ 1, "PT_LOAD" },
-	intName{ 2, "PT_DYNAMIC" },
-	intName{ 3, "PT_INTERP" },
-	intName{ 4, "PT_NOTE" },
-	intName{ 5, "PT_SHLIB" },
-	intName{ 6, "PT_PHDR" },
-	intName{ 7, "PT_TLS" },
-	intName{ 0x60000000, "PT_LOOS" },
-	intName{ 0x6fffffff, "PT_HIOS" },
-	intName{ 0x70000000, "PT_LOPROC" },
-	intName{ 0x7fffffff, "PT_HIPROC" },
+
+var ptStrings = []intName{
+	intName{0, "PT_NULL"},
+	intName{1, "PT_LOAD"},
+	intName{2, "PT_DYNAMIC"},
+	intName{3, "PT_INTERP"},
+	intName{4, "PT_NOTE"},
+	intName{5, "PT_SHLIB"},
+	intName{6, "PT_PHDR"},
+	intName{7, "PT_TLS"},
+	intName{0x60000000, "PT_LOOS"},
+	intName{0x6fffffff, "PT_HIOS"},
+	intName{0x70000000, "PT_LOPROC"},
+	intName{0x7fffffff, "PT_HIPROC"},
 }
+
 func (i ProgType) String() string {
-	return stringName(uint32(i), ptStrings, false)
+	return stringName(uint32(i), ptStrings, false);
 }
 func (i ProgType) GoString() string {
-	return stringName(uint32(i), ptStrings, true)
+	return stringName(uint32(i), ptStrings, true);
 }
 
 // Prog.Flag
 type ProgFlag uint32
+
 const (
-	PF_X ProgFlag =		0x1;		/* Executable. */
-	PF_W ProgFlag =		0x2;		/* Writable. */
-	PF_R ProgFlag =		0x4;		/* Readable. */
-	PF_MASKOS ProgFlag =	0x0ff00000;	/* Operating system-specific. */
-	PF_MASKPROC ProgFlag =	0xf0000000;	/* Processor-specific. */
+	PF_X		ProgFlag	= 0x1;		/* Executable. */
+	PF_W		ProgFlag	= 0x2;		/* Writable. */
+	PF_R		ProgFlag	= 0x4;		/* Readable. */
+	PF_MASKOS	ProgFlag	= 0x0ff00000;	/* Operating system-specific. */
+	PF_MASKPROC	ProgFlag	= 0xf0000000;	/* Processor-specific. */
 )
-var pfStrings = []intName {
-	intName{ 0x1, "PF_X" },
-	intName{ 0x2, "PF_W" },
-	intName{ 0x4, "PF_R" },
+
+var pfStrings = []intName{
+	intName{0x1, "PF_X"},
+	intName{0x2, "PF_W"},
+	intName{0x4, "PF_R"},
 }
+
 func (i ProgFlag) String() string {
-	return flagName(uint32(i), pfStrings, false)
+	return flagName(uint32(i), pfStrings, false);
 }
 func (i ProgFlag) GoString() string {
-	return flagName(uint32(i), pfStrings, true)
+	return flagName(uint32(i), pfStrings, true);
 }
 
 // Dyn.Tag
 type DynTag int
+
 const (
-	DT_NULL DynTag =		0;	/* Terminating entry. */
-	DT_NEEDED DynTag =	1;	/* String table offset of a needed shared library. */
-	DT_PLTRELSZ DynTag =	2;	/* Total size in bytes of PLT relocations. */
-	DT_PLTGOT DynTag =	3;	/* Processor-dependent address. */
-	DT_HASH DynTag =		4;	/* Address of symbol hash table. */
-	DT_STRTAB DynTag =	5;	/* Address of string table. */
-	DT_SYMTAB DynTag =	6;	/* Address of symbol table. */
-	DT_RELA DynTag =		7;	/* Address of ElfNN_Rela relocations. */
-	DT_RELASZ DynTag =	8;	/* Total size of ElfNN_Rela relocations. */
-	DT_RELAENT DynTag =	9;	/* Size of each ElfNN_Rela relocation entry. */
-	DT_STRSZ DynTag =	10;	/* Size of string table. */
-	DT_SYMENT DynTag =	11;	/* Size of each symbol table entry. */
-	DT_INIT DynTag =		12;	/* Address of initialization function. */
-	DT_FINI DynTag =		13;	/* Address of finalization function. */
-	DT_SONAME DynTag =	14;	/* String table offset of shared object name. */
-	DT_RPATH DynTag =	15;	/* String table offset of library path. [sup] */
-	DT_SYMBOLIC DynTag =	16;	/* Indicates "symbolic" linking. [sup] */
-	DT_REL DynTag =		17;	/* Address of ElfNN_Rel relocations. */
-	DT_RELSZ DynTag =	18;	/* Total size of ElfNN_Rel relocations. */
-	DT_RELENT DynTag =	19;	/* Size of each ElfNN_Rel relocation. */
-	DT_PLTREL DynTag =	20;	/* Type of relocation used for PLT. */
-	DT_DEBUG DynTag =	21;	/* Reserved (not used). */
-	DT_TEXTREL DynTag =	22;	/* Indicates there may be relocations in non-writable segments. [sup] */
-	DT_JMPREL DynTag =	23;	/* Address of PLT relocations. */
-	DT_BIND_NOW DynTag =	24;	/* [sup] */
-	DT_INIT_ARRAY DynTag =	25;	/* Address of the array of pointers to initialization functions */
-	DT_FINI_ARRAY DynTag =	26;	/* Address of the array of pointers to termination functions */
-	DT_INIT_ARRAYSZ DynTag =	27;	/* Size in bytes of the array of initialization functions. */
-	DT_FINI_ARRAYSZ DynTag =	28;	/* Size in bytes of the array of terminationfunctions. */
-	DT_RUNPATH DynTag =	29;	/* String table offset of a null-terminated library search path string. */
-	DT_FLAGS DynTag =	30;	/* Object specific flag values. */
-	DT_ENCODING DynTag =	32;	/* Values greater than or equal to DT_ENCODING
-				   and less than DT_LOOS follow the rules for
-				   the interpretation of the d_un union
-				   as follows: even == 'd_ptr', even == 'd_val'
-				   or none */
-	DT_PREINIT_ARRAY DynTag = 32;	/* Address of the array of pointers to pre-initialization functions. */
-	DT_PREINIT_ARRAYSZ DynTag = 33;	/* Size in bytes of the array of pre-initialization functions. */
-	DT_LOOS DynTag =		0x6000000d;	/* First OS-specific */
-	DT_HIOS DynTag =		0x6ffff000;	/* Last OS-specific */
-	DT_LOPROC DynTag =	0x70000000;	/* First processor-specific type. */
-	DT_HIPROC DynTag =	0x7fffffff;	/* Last processor-specific type. */
+	DT_NULL			DynTag	= 0;		/* Terminating entry. */
+	DT_NEEDED		DynTag	= 1;		/* String table offset of a needed shared library. */
+	DT_PLTRELSZ		DynTag	= 2;		/* Total size in bytes of PLT relocations. */
+	DT_PLTGOT		DynTag	= 3;		/* Processor-dependent address. */
+	DT_HASH			DynTag	= 4;		/* Address of symbol hash table. */
+	DT_STRTAB		DynTag	= 5;		/* Address of string table. */
+	DT_SYMTAB		DynTag	= 6;		/* Address of symbol table. */
+	DT_RELA			DynTag	= 7;		/* Address of ElfNN_Rela relocations. */
+	DT_RELASZ		DynTag	= 8;		/* Total size of ElfNN_Rela relocations. */
+	DT_RELAENT		DynTag	= 9;		/* Size of each ElfNN_Rela relocation entry. */
+	DT_STRSZ		DynTag	= 10;		/* Size of string table. */
+	DT_SYMENT		DynTag	= 11;		/* Size of each symbol table entry. */
+	DT_INIT			DynTag	= 12;		/* Address of initialization function. */
+	DT_FINI			DynTag	= 13;		/* Address of finalization function. */
+	DT_SONAME		DynTag	= 14;		/* String table offset of shared object name. */
+	DT_RPATH		DynTag	= 15;		/* String table offset of library path. [sup] */
+	DT_SYMBOLIC		DynTag	= 16;		/* Indicates "symbolic" linking. [sup] */
+	DT_REL			DynTag	= 17;		/* Address of ElfNN_Rel relocations. */
+	DT_RELSZ		DynTag	= 18;		/* Total size of ElfNN_Rel relocations. */
+	DT_RELENT		DynTag	= 19;		/* Size of each ElfNN_Rel relocation. */
+	DT_PLTREL		DynTag	= 20;		/* Type of relocation used for PLT. */
+	DT_DEBUG		DynTag	= 21;		/* Reserved (not used). */
+	DT_TEXTREL		DynTag	= 22;		/* Indicates there may be relocations in non-writable segments. [sup] */
+	DT_JMPREL		DynTag	= 23;		/* Address of PLT relocations. */
+	DT_BIND_NOW		DynTag	= 24;		/* [sup] */
+	DT_INIT_ARRAY		DynTag	= 25;		/* Address of the array of pointers to initialization functions */
+	DT_FINI_ARRAY		DynTag	= 26;		/* Address of the array of pointers to termination functions */
+	DT_INIT_ARRAYSZ		DynTag	= 27;		/* Size in bytes of the array of initialization functions. */
+	DT_FINI_ARRAYSZ		DynTag	= 28;		/* Size in bytes of the array of terminationfunctions. */
+	DT_RUNPATH		DynTag	= 29;		/* String table offset of a null-terminated library search path string. */
+	DT_FLAGS		DynTag	= 30;		/* Object specific flag values. */
+	DT_ENCODING		DynTag	= 32;		/* Values greater than or equal to DT_ENCODING
+								   and less than DT_LOOS follow the rules for
+								   the interpretation of the d_un union
+								   as follows: even == 'd_ptr', even == 'd_val'
+								   or none */
+	DT_PREINIT_ARRAY	DynTag	= 32;		/* Address of the array of pointers to pre-initialization functions. */
+	DT_PREINIT_ARRAYSZ	DynTag	= 33;		/* Size in bytes of the array of pre-initialization functions. */
+	DT_LOOS			DynTag	= 0x6000000d;	/* First OS-specific */
+	DT_HIOS			DynTag	= 0x6ffff000;	/* Last OS-specific */
+	DT_LOPROC		DynTag	= 0x70000000;	/* First processor-specific type. */
+	DT_HIPROC		DynTag	= 0x7fffffff;	/* Last processor-specific type. */
 )
-var dtStrings = []intName {
-	intName{ 0, "DT_NULL" },
-	intName{ 1, "DT_NEEDED" },
-	intName{ 2, "DT_PLTRELSZ" },
-	intName{ 3, "DT_PLTGOT" },
-	intName{ 4, "DT_HASH" },
-	intName{ 5, "DT_STRTAB" },
-	intName{ 6, "DT_SYMTAB" },
-	intName{ 7, "DT_RELA" },
-	intName{ 8, "DT_RELASZ" },
-	intName{ 9, "DT_RELAENT" },
-	intName{ 10, "DT_STRSZ" },
-	intName{ 11, "DT_SYMENT" },
-	intName{ 12, "DT_INIT" },
-	intName{ 13, "DT_FINI" },
-	intName{ 14, "DT_SONAME" },
-	intName{ 15, "DT_RPATH" },
-	intName{ 16, "DT_SYMBOLIC" },
-	intName{ 17, "DT_REL" },
-	intName{ 18, "DT_RELSZ" },
-	intName{ 19, "DT_RELENT" },
-	intName{ 20, "DT_PLTREL" },
-	intName{ 21, "DT_DEBUG" },
-	intName{ 22, "DT_TEXTREL" },
-	intName{ 23, "DT_JMPREL" },
-	intName{ 24, "DT_BIND_NOW" },
-	intName{ 25, "DT_INIT_ARRAY" },
-	intName{ 26, "DT_FINI_ARRAY" },
-	intName{ 27, "DT_INIT_ARRAYSZ" },
-	intName{ 28, "DT_FINI_ARRAYSZ" },
-	intName{ 29, "DT_RUNPATH" },
-	intName{ 30, "DT_FLAGS" },
-	intName{ 32, "DT_ENCODING" },
-	intName{ 32, "DT_PREINIT_ARRAY" },
-	intName{ 33, "DT_PREINIT_ARRAYSZ" },
-	intName{ 0x6000000d, "DT_LOOS" },
-	intName{ 0x6ffff000, "DT_HIOS" },
-	intName{ 0x70000000, "DT_LOPROC" },
-	intName{ 0x7fffffff, "DT_HIPROC" },
+
+var dtStrings = []intName{
+	intName{0, "DT_NULL"},
+	intName{1, "DT_NEEDED"},
+	intName{2, "DT_PLTRELSZ"},
+	intName{3, "DT_PLTGOT"},
+	intName{4, "DT_HASH"},
+	intName{5, "DT_STRTAB"},
+	intName{6, "DT_SYMTAB"},
+	intName{7, "DT_RELA"},
+	intName{8, "DT_RELASZ"},
+	intName{9, "DT_RELAENT"},
+	intName{10, "DT_STRSZ"},
+	intName{11, "DT_SYMENT"},
+	intName{12, "DT_INIT"},
+	intName{13, "DT_FINI"},
+	intName{14, "DT_SONAME"},
+	intName{15, "DT_RPATH"},
+	intName{16, "DT_SYMBOLIC"},
+	intName{17, "DT_REL"},
+	intName{18, "DT_RELSZ"},
+	intName{19, "DT_RELENT"},
+	intName{20, "DT_PLTREL"},
+	intName{21, "DT_DEBUG"},
+	intName{22, "DT_TEXTREL"},
+	intName{23, "DT_JMPREL"},
+	intName{24, "DT_BIND_NOW"},
+	intName{25, "DT_INIT_ARRAY"},
+	intName{26, "DT_FINI_ARRAY"},
+	intName{27, "DT_INIT_ARRAYSZ"},
+	intName{28, "DT_FINI_ARRAYSZ"},
+	intName{29, "DT_RUNPATH"},
+	intName{30, "DT_FLAGS"},
+	intName{32, "DT_ENCODING"},
+	intName{32, "DT_PREINIT_ARRAY"},
+	intName{33, "DT_PREINIT_ARRAYSZ"},
+	intName{0x6000000d, "DT_LOOS"},
+	intName{0x6ffff000, "DT_HIOS"},
+	intName{0x70000000, "DT_LOPROC"},
+	intName{0x7fffffff, "DT_HIPROC"},
 }
+
 func (i DynTag) String() string {
-	return stringName(uint32(i), dtStrings, false)
+	return stringName(uint32(i), dtStrings, false);
 }
 func (i DynTag) GoString() string {
-	return stringName(uint32(i), dtStrings, true)
+	return stringName(uint32(i), dtStrings, true);
 }
 
 // DT_FLAGS values.
 type DynFlag int
+
 const (
-	DF_ORIGIN DynFlag =	0x0001;	/* Indicates that the object being loaded may
-				   make reference to the $ORIGIN substitution
-				   string */
-	DF_SYMBOLIC DynFlag =	0x0002;	/* Indicates "symbolic" linking. */
-	DF_TEXTREL DynFlag =	0x0004;	/* Indicates there may be relocations in
-				   non-writable segments. */
-	DF_BIND_NOW DynFlag =	0x0008;	/* Indicates that the dynamic linker should
-				   process all relocations for the object
-				   containing this entry before transferring
-				   control to the program. */
-	DF_STATIC_TLS DynFlag =	0x0010;	/* Indicates that the shared object or
-				   executable contains code using a static
-				   thread-local storage scheme. */
+	DF_ORIGIN	DynFlag	= 0x0001;	/* Indicates that the object being loaded may
+							   make reference to the $ORIGIN substitution
+							   string */
+	DF_SYMBOLIC	DynFlag	= 0x0002;	/* Indicates "symbolic" linking. */
+	DF_TEXTREL	DynFlag	= 0x0004;	/* Indicates there may be relocations in
+							   non-writable segments. */
+	DF_BIND_NOW	DynFlag	= 0x0008;	/* Indicates that the dynamic linker should
+							   process all relocations for the object
+							   containing this entry before transferring
+							   control to the program. */
+	DF_STATIC_TLS	DynFlag	= 0x0010;	/* Indicates that the shared object or
+						   executable contains code using a static
+						   thread-local storage scheme. */
 )
-var dflagStrings = []intName {
-	intName{ 0x0001, "DF_ORIGIN" },
-	intName{ 0x0002, "DF_SYMBOLIC" },
-	intName{ 0x0004, "DF_TEXTREL" },
-	intName{ 0x0008, "DF_BIND_NOW" },
-	intName{ 0x0010, "DF_STATIC_TLS" },
+
+var dflagStrings = []intName{
+	intName{0x0001, "DF_ORIGIN"},
+	intName{0x0002, "DF_SYMBOLIC"},
+	intName{0x0004, "DF_TEXTREL"},
+	intName{0x0008, "DF_BIND_NOW"},
+	intName{0x0010, "DF_STATIC_TLS"},
 }
+
 func (i DynFlag) String() string {
-	return flagName(uint32(i), dflagStrings, false)
+	return flagName(uint32(i), dflagStrings, false);
 }
 func (i DynFlag) GoString() string {
-	return flagName(uint32(i), dflagStrings, true)
+	return flagName(uint32(i), dflagStrings, true);
 }
 
 // NType values; used in core files.
 type NType int
+
 const (
-	NT_PRSTATUS NType =	1;	/* Process status. */
-	NT_FPREGSET NType =	2;	/* Floating point registers. */
-	NT_PRPSINFO NType =	3;	/* Process state info. */
+	NT_PRSTATUS	NType	= 1;	/* Process status. */
+	NT_FPREGSET	NType	= 2;	/* Floating point registers. */
+	NT_PRPSINFO	NType	= 3;	/* Process state info. */
 )
-var ntypeStrings = []intName {
-	intName{ 1, "NT_PRSTATUS" },
-	intName{ 2, "NT_FPREGSET" },
-	intName{ 3, "NT_PRPSINFO" },
+
+var ntypeStrings = []intName{
+	intName{1, "NT_PRSTATUS"},
+	intName{2, "NT_FPREGSET"},
+	intName{3, "NT_PRPSINFO"},
 }
+
 func (i NType) String() string {
-	return stringName(uint32(i), ntypeStrings, false)
+	return stringName(uint32(i), ntypeStrings, false);
 }
 func (i NType) GoString() string {
-	return stringName(uint32(i), ntypeStrings, true)
+	return stringName(uint32(i), ntypeStrings, true);
 }
 
 /* Symbol Binding - ELFNN_ST_BIND - st_info */
 type SymBind int
+
 const (
-	STB_LOCAL SymBind =	0;	/* Local symbol */
-	STB_GLOBAL SymBind =	1;	/* Global symbol */
-	STB_WEAK SymBind =	2;	/* like global - lower precedence */
-	STB_LOOS SymBind =	10;	/* Reserved range for operating system */
-	STB_HIOS SymBind =	12;	/*   specific semantics. */
-	STB_LOPROC SymBind =	13;	/* reserved range for processor */
-	STB_HIPROC SymBind =	15;	/*   specific semantics. */
+	STB_LOCAL	SymBind	= 0;	/* Local symbol */
+	STB_GLOBAL	SymBind	= 1;	/* Global symbol */
+	STB_WEAK	SymBind	= 2;	/* like global - lower precedence */
+	STB_LOOS	SymBind	= 10;	/* Reserved range for operating system */
+	STB_HIOS	SymBind	= 12;	/*   specific semantics. */
+	STB_LOPROC	SymBind	= 13;	/* reserved range for processor */
+	STB_HIPROC	SymBind	= 15;	/*   specific semantics. */
 )
-var stbStrings = []intName {
-	intName{ 0, "STB_LOCAL" },
-	intName{ 1, "STB_GLOBAL" },
-	intName{ 2, "STB_WEAK" },
-	intName{ 10, "STB_LOOS" },
-	intName{ 12, "STB_HIOS" },
-	intName{ 13, "STB_LOPROC" },
-	intName{ 15, "STB_HIPROC" },
+
+var stbStrings = []intName{
+	intName{0, "STB_LOCAL"},
+	intName{1, "STB_GLOBAL"},
+	intName{2, "STB_WEAK"},
+	intName{10, "STB_LOOS"},
+	intName{12, "STB_HIOS"},
+	intName{13, "STB_LOPROC"},
+	intName{15, "STB_HIPROC"},
 }
+
 func (i SymBind) String() string {
-	return stringName(uint32(i), stbStrings, false)
+	return stringName(uint32(i), stbStrings, false);
 }
 func (i SymBind) GoString() string {
-	return stringName(uint32(i), stbStrings, true)
+	return stringName(uint32(i), stbStrings, true);
 }
 
 /* Symbol type - ELFNN_ST_TYPE - st_info */
 type SymType int
+
 const (
-	STT_NOTYPE SymType =	0;	/* Unspecified type. */
-	STT_OBJECT SymType =	1;	/* Data object. */
-	STT_FUNC SymType =	2;	/* Function. */
-	STT_SECTION SymType =	3;	/* Section. */
-	STT_FILE SymType =	4;	/* Source file. */
-	STT_COMMON SymType =	5;	/* Uninitialized common block. */
-	STT_TLS SymType =		6;	/* TLS object. */
-	STT_LOOS SymType =	10;	/* Reserved range for operating system */
-	STT_HIOS SymType =	12;	/*   specific semantics. */
-	STT_LOPROC SymType =	13;	/* reserved range for processor */
-	STT_HIPROC SymType =	15;	/*   specific semantics. */
+	STT_NOTYPE	SymType	= 0;	/* Unspecified type. */
+	STT_OBJECT	SymType	= 1;	/* Data object. */
+	STT_FUNC	SymType	= 2;	/* Function. */
+	STT_SECTION	SymType	= 3;	/* Section. */
+	STT_FILE	SymType	= 4;	/* Source file. */
+	STT_COMMON	SymType	= 5;	/* Uninitialized common block. */
+	STT_TLS		SymType	= 6;	/* TLS object. */
+	STT_LOOS	SymType	= 10;	/* Reserved range for operating system */
+	STT_HIOS	SymType	= 12;	/*   specific semantics. */
+	STT_LOPROC	SymType	= 13;	/* reserved range for processor */
+	STT_HIPROC	SymType	= 15;	/*   specific semantics. */
 )
-var sttStrings = []intName {
-	intName{ 0, "STT_NOTYPE" },
-	intName{ 1, "STT_OBJECT" },
-	intName{ 2, "STT_FUNC" },
-	intName{ 3, "STT_SECTION" },
-	intName{ 4, "STT_FILE" },
-	intName{ 5, "STT_COMMON" },
-	intName{ 6, "STT_TLS" },
-	intName{ 10, "STT_LOOS" },
-	intName{ 12, "STT_HIOS" },
-	intName{ 13, "STT_LOPROC" },
-	intName{ 15, "STT_HIPROC" },
+
+var sttStrings = []intName{
+	intName{0, "STT_NOTYPE"},
+	intName{1, "STT_OBJECT"},
+	intName{2, "STT_FUNC"},
+	intName{3, "STT_SECTION"},
+	intName{4, "STT_FILE"},
+	intName{5, "STT_COMMON"},
+	intName{6, "STT_TLS"},
+	intName{10, "STT_LOOS"},
+	intName{12, "STT_HIOS"},
+	intName{13, "STT_LOPROC"},
+	intName{15, "STT_HIPROC"},
 }
+
 func (i SymType) String() string {
-	return stringName(uint32(i), sttStrings, false)
+	return stringName(uint32(i), sttStrings, false);
 }
 func (i SymType) GoString() string {
-	return stringName(uint32(i), sttStrings, true)
+	return stringName(uint32(i), sttStrings, true);
 }
 
 /* Symbol visibility - ELFNN_ST_VISIBILITY - st_other */
 type SymVis int
+
 const (
-	STV_DEFAULT SymVis =	0x0;	/* Default visibility (see binding). */
-	STV_INTERNAL SymVis =	0x1;	/* Special meaning in relocatable objects. */
-	STV_HIDDEN SymVis =	0x2;	/* Not visible. */
-	STV_PROTECTED SymVis =	0x3;	/* Visible but not preemptible. */
+	STV_DEFAULT	SymVis	= 0x0;	/* Default visibility (see binding). */
+	STV_INTERNAL	SymVis	= 0x1;	/* Special meaning in relocatable objects. */
+	STV_HIDDEN	SymVis	= 0x2;	/* Not visible. */
+	STV_PROTECTED	SymVis	= 0x3;	/* Visible but not preemptible. */
 )
-var stvStrings = []intName {
-	intName{ 0x0, "STV_DEFAULT" },
-	intName{ 0x1, "STV_INTERNAL" },
-	intName{ 0x2, "STV_HIDDEN" },
-	intName{ 0x3, "STV_PROTECTED" },
+
+var stvStrings = []intName{
+	intName{0x0, "STV_DEFAULT"},
+	intName{0x1, "STV_INTERNAL"},
+	intName{0x2, "STV_HIDDEN"},
+	intName{0x3, "STV_PROTECTED"},
 }
+
 func (i SymVis) String() string {
-	return stringName(uint32(i), stvStrings, false)
+	return stringName(uint32(i), stvStrings, false);
 }
 func (i SymVis) GoString() string {
-	return stringName(uint32(i), stvStrings, true)
+	return stringName(uint32(i), stvStrings, true);
 }
 
 /*
@@ -717,582 +768,598 @@ func (i SymVis) GoString() string {
 
 // Relocation types for x86-64.
 type R_X86_64 int
+
 const (
-	R_X86_64_NONE R_X86_64 =	0;	/* No relocation. */
-	R_X86_64_64 R_X86_64 =	1;	/* Add 64 bit symbol value. */
-	R_X86_64_PC32 R_X86_64 =	2;	/* PC-relative 32 bit signed sym value. */
-	R_X86_64_GOT32 R_X86_64 =	3;	/* PC-relative 32 bit GOT offset. */
-	R_X86_64_PLT32 R_X86_64 =	4;	/* PC-relative 32 bit PLT offset. */
-	R_X86_64_COPY R_X86_64 =	5;	/* Copy data from shared object. */
-	R_X86_64_GLOB_DAT R_X86_64 = 6;	/* Set GOT entry to data address. */
-	R_X86_64_JMP_SLOT R_X86_64 = 7;	/* Set GOT entry to code address. */
-	R_X86_64_RELATIVE R_X86_64 = 8;	/* Add load address of shared object. */
-	R_X86_64_GOTPCREL R_X86_64 = 9;	/* Add 32 bit signed pcrel offset to GOT. */
-	R_X86_64_32 R_X86_64 =	10;	/* Add 32 bit zero extended symbol value */
-	R_X86_64_32S R_X86_64 =	11;	/* Add 32 bit sign extended symbol value */
-	R_X86_64_16 R_X86_64 =	12;	/* Add 16 bit zero extended symbol value */
-	R_X86_64_PC16 R_X86_64 =	13;	/* Add 16 bit signed extended pc relative symbol value */
-	R_X86_64_8 R_X86_64 =	14;	/* Add 8 bit zero extended symbol value */
-	R_X86_64_PC8 R_X86_64 =	15;	/* Add 8 bit signed extended pc relative symbol value */
-	R_X86_64_DTPMOD64 R_X86_64 = 16;	/* ID of module containing symbol */
-	R_X86_64_DTPOFF64 R_X86_64 = 17;	/* Offset in TLS block */
-	R_X86_64_TPOFF64 R_X86_64 = 18;	/* Offset in static TLS block */
-	R_X86_64_TLSGD R_X86_64 =	19;	/* PC relative offset to GD GOT entry */
-	R_X86_64_TLSLD R_X86_64 =	20;	/* PC relative offset to LD GOT entry */
-	R_X86_64_DTPOFF32 R_X86_64 = 21;	/* Offset in TLS block */
-	R_X86_64_GOTTPOFF R_X86_64 = 22;	/* PC relative offset to IE GOT entry */
-	R_X86_64_TPOFF32 R_X86_64 = 23;	/* Offset in static TLS block */
+	R_X86_64_NONE		R_X86_64	= 0;	/* No relocation. */
+	R_X86_64_64		R_X86_64	= 1;	/* Add 64 bit symbol value. */
+	R_X86_64_PC32		R_X86_64	= 2;	/* PC-relative 32 bit signed sym value. */
+	R_X86_64_GOT32		R_X86_64	= 3;	/* PC-relative 32 bit GOT offset. */
+	R_X86_64_PLT32		R_X86_64	= 4;	/* PC-relative 32 bit PLT offset. */
+	R_X86_64_COPY		R_X86_64	= 5;	/* Copy data from shared object. */
+	R_X86_64_GLOB_DAT	R_X86_64	= 6;	/* Set GOT entry to data address. */
+	R_X86_64_JMP_SLOT	R_X86_64	= 7;	/* Set GOT entry to code address. */
+	R_X86_64_RELATIVE	R_X86_64	= 8;	/* Add load address of shared object. */
+	R_X86_64_GOTPCREL	R_X86_64	= 9;	/* Add 32 bit signed pcrel offset to GOT. */
+	R_X86_64_32		R_X86_64	= 10;	/* Add 32 bit zero extended symbol value */
+	R_X86_64_32S		R_X86_64	= 11;	/* Add 32 bit sign extended symbol value */
+	R_X86_64_16		R_X86_64	= 12;	/* Add 16 bit zero extended symbol value */
+	R_X86_64_PC16		R_X86_64	= 13;	/* Add 16 bit signed extended pc relative symbol value */
+	R_X86_64_8		R_X86_64	= 14;	/* Add 8 bit zero extended symbol value */
+	R_X86_64_PC8		R_X86_64	= 15;	/* Add 8 bit signed extended pc relative symbol value */
+	R_X86_64_DTPMOD64	R_X86_64	= 16;	/* ID of module containing symbol */
+	R_X86_64_DTPOFF64	R_X86_64	= 17;	/* Offset in TLS block */
+	R_X86_64_TPOFF64	R_X86_64	= 18;	/* Offset in static TLS block */
+	R_X86_64_TLSGD		R_X86_64	= 19;	/* PC relative offset to GD GOT entry */
+	R_X86_64_TLSLD		R_X86_64	= 20;	/* PC relative offset to LD GOT entry */
+	R_X86_64_DTPOFF32	R_X86_64	= 21;	/* Offset in TLS block */
+	R_X86_64_GOTTPOFF	R_X86_64	= 22;	/* PC relative offset to IE GOT entry */
+	R_X86_64_TPOFF32	R_X86_64	= 23;	/* Offset in static TLS block */
 )
-var rx86_64Strings = []intName {
-	intName{ 0, "R_X86_64_NONE" },
-	intName{ 1, "R_X86_64_64" },
-	intName{ 2, "R_X86_64_PC32" },
-	intName{ 3, "R_X86_64_GOT32" },
-	intName{ 4, "R_X86_64_PLT32" },
-	intName{ 5, "R_X86_64_COPY" },
-	intName{ 6, "R_X86_64_GLOB_DAT" },
-	intName{ 7, "R_X86_64_JMP_SLOT" },
-	intName{ 8, "R_X86_64_RELATIVE" },
-	intName{ 9, "R_X86_64_GOTPCREL" },
-	intName{ 10, "R_X86_64_32" },
-	intName{ 11, "R_X86_64_32S" },
-	intName{ 12, "R_X86_64_16" },
-	intName{ 13, "R_X86_64_PC16" },
-	intName{ 14, "R_X86_64_8" },
-	intName{ 15, "R_X86_64_PC8" },
-	intName{ 16, "R_X86_64_DTPMOD64" },
-	intName{ 17, "R_X86_64_DTPOFF64" },
-	intName{ 18, "R_X86_64_TPOFF64" },
-	intName{ 19, "R_X86_64_TLSGD" },
-	intName{ 20, "R_X86_64_TLSLD" },
-	intName{ 21, "R_X86_64_DTPOFF32" },
-	intName{ 22, "R_X86_64_GOTTPOFF" },
-	intName{ 23, "R_X86_64_TPOFF32" },
+
+var rx86_64Strings = []intName{
+	intName{0, "R_X86_64_NONE"},
+	intName{1, "R_X86_64_64"},
+	intName{2, "R_X86_64_PC32"},
+	intName{3, "R_X86_64_GOT32"},
+	intName{4, "R_X86_64_PLT32"},
+	intName{5, "R_X86_64_COPY"},
+	intName{6, "R_X86_64_GLOB_DAT"},
+	intName{7, "R_X86_64_JMP_SLOT"},
+	intName{8, "R_X86_64_RELATIVE"},
+	intName{9, "R_X86_64_GOTPCREL"},
+	intName{10, "R_X86_64_32"},
+	intName{11, "R_X86_64_32S"},
+	intName{12, "R_X86_64_16"},
+	intName{13, "R_X86_64_PC16"},
+	intName{14, "R_X86_64_8"},
+	intName{15, "R_X86_64_PC8"},
+	intName{16, "R_X86_64_DTPMOD64"},
+	intName{17, "R_X86_64_DTPOFF64"},
+	intName{18, "R_X86_64_TPOFF64"},
+	intName{19, "R_X86_64_TLSGD"},
+	intName{20, "R_X86_64_TLSLD"},
+	intName{21, "R_X86_64_DTPOFF32"},
+	intName{22, "R_X86_64_GOTTPOFF"},
+	intName{23, "R_X86_64_TPOFF32"},
 }
+
 func (i R_X86_64) String() string {
-	return stringName(uint32(i), rx86_64Strings, false)
+	return stringName(uint32(i), rx86_64Strings, false);
 }
 func (i R_X86_64) GoString() string {
-	return stringName(uint32(i), rx86_64Strings, true)
+	return stringName(uint32(i), rx86_64Strings, true);
 }
 
 // Relocation types for Alpha.
 type R_ALPHA int
+
 const (
-	R_ALPHA_NONE R_ALPHA =		0;	/* No reloc */
-	R_ALPHA_REFLONG R_ALPHA =		1;	/* Direct 32 bit */
-	R_ALPHA_REFQUAD R_ALPHA =		2;	/* Direct 64 bit */
-	R_ALPHA_GPREL32 R_ALPHA =		3;	/* GP relative 32 bit */
-	R_ALPHA_LITERAL R_ALPHA =		4;	/* GP relative 16 bit w/optimization */
-	R_ALPHA_LITUSE R_ALPHA =		5;	/* Optimization hint for LITERAL */
-	R_ALPHA_GPDISP R_ALPHA =		6;	/* Add displacement to GP */
-	R_ALPHA_BRADDR R_ALPHA =		7;	/* PC+4 relative 23 bit shifted */
-	R_ALPHA_HINT R_ALPHA =		8;	/* PC+4 relative 16 bit shifted */
-	R_ALPHA_SREL16 R_ALPHA =		9;	/* PC relative 16 bit */
-	R_ALPHA_SREL32 R_ALPHA =		10;	/* PC relative 32 bit */
-	R_ALPHA_SREL64 R_ALPHA =		11;	/* PC relative 64 bit */
-	R_ALPHA_OP_PUSH R_ALPHA =		12;	/* OP stack push */
-	R_ALPHA_OP_STORE R_ALPHA =	13;	/* OP stack pop and store */
-	R_ALPHA_OP_PSUB R_ALPHA =		14;	/* OP stack subtract */
-	R_ALPHA_OP_PRSHIFT R_ALPHA =	15;	/* OP stack right shift */
-	R_ALPHA_GPVALUE R_ALPHA =		16;
-	R_ALPHA_GPRELHIGH R_ALPHA =	17;
-	R_ALPHA_GPRELLOW R_ALPHA =	18;
-	R_ALPHA_IMMED_GP_16 R_ALPHA =	19;
-	R_ALPHA_IMMED_GP_HI32 R_ALPHA =	20;
-	R_ALPHA_IMMED_SCN_HI32 R_ALPHA =	21;
-	R_ALPHA_IMMED_BR_HI32 R_ALPHA =	22;
-	R_ALPHA_IMMED_LO32 R_ALPHA =	23;
-	R_ALPHA_COPY R_ALPHA =		24;	/* Copy symbol at runtime */
-	R_ALPHA_GLOB_DAT R_ALPHA =	25;	/* Create GOT entry */
-	R_ALPHA_JMP_SLOT R_ALPHA =	26;	/* Create PLT entry */
-	R_ALPHA_RELATIVE R_ALPHA =	27;	/* Adjust by program base */
+	R_ALPHA_NONE		R_ALPHA	= 0;	/* No reloc */
+	R_ALPHA_REFLONG		R_ALPHA	= 1;	/* Direct 32 bit */
+	R_ALPHA_REFQUAD		R_ALPHA	= 2;	/* Direct 64 bit */
+	R_ALPHA_GPREL32		R_ALPHA	= 3;	/* GP relative 32 bit */
+	R_ALPHA_LITERAL		R_ALPHA	= 4;	/* GP relative 16 bit w/optimization */
+	R_ALPHA_LITUSE		R_ALPHA	= 5;	/* Optimization hint for LITERAL */
+	R_ALPHA_GPDISP		R_ALPHA	= 6;	/* Add displacement to GP */
+	R_ALPHA_BRADDR		R_ALPHA	= 7;	/* PC+4 relative 23 bit shifted */
+	R_ALPHA_HINT		R_ALPHA	= 8;	/* PC+4 relative 16 bit shifted */
+	R_ALPHA_SREL16		R_ALPHA	= 9;	/* PC relative 16 bit */
+	R_ALPHA_SREL32		R_ALPHA	= 10;	/* PC relative 32 bit */
+	R_ALPHA_SREL64		R_ALPHA	= 11;	/* PC relative 64 bit */
+	R_ALPHA_OP_PUSH		R_ALPHA	= 12;	/* OP stack push */
+	R_ALPHA_OP_STORE	R_ALPHA	= 13;	/* OP stack pop and store */
+	R_ALPHA_OP_PSUB		R_ALPHA	= 14;	/* OP stack subtract */
+	R_ALPHA_OP_PRSHIFT	R_ALPHA	= 15;	/* OP stack right shift */
+	R_ALPHA_GPVALUE		R_ALPHA	= 16;
+	R_ALPHA_GPRELHIGH	R_ALPHA	= 17;
+	R_ALPHA_GPRELLOW	R_ALPHA	= 18;
+	R_ALPHA_IMMED_GP_16	R_ALPHA	= 19;
+	R_ALPHA_IMMED_GP_HI32	R_ALPHA	= 20;
+	R_ALPHA_IMMED_SCN_HI32	R_ALPHA	= 21;
+	R_ALPHA_IMMED_BR_HI32	R_ALPHA	= 22;
+	R_ALPHA_IMMED_LO32	R_ALPHA	= 23;
+	R_ALPHA_COPY		R_ALPHA	= 24;	/* Copy symbol at runtime */
+	R_ALPHA_GLOB_DAT	R_ALPHA	= 25;	/* Create GOT entry */
+	R_ALPHA_JMP_SLOT	R_ALPHA	= 26;	/* Create PLT entry */
+	R_ALPHA_RELATIVE	R_ALPHA	= 27;	/* Adjust by program base */
 )
-var ralphaStrings = []intName {
-	intName{ 0, "R_ALPHA_NONE" },
-	intName{ 1, "R_ALPHA_REFLONG" },
-	intName{ 2, "R_ALPHA_REFQUAD" },
-	intName{ 3, "R_ALPHA_GPREL32" },
-	intName{ 4, "R_ALPHA_LITERAL" },
-	intName{ 5, "R_ALPHA_LITUSE" },
-	intName{ 6, "R_ALPHA_GPDISP" },
-	intName{ 7, "R_ALPHA_BRADDR" },
-	intName{ 8, "R_ALPHA_HINT" },
-	intName{ 9, "R_ALPHA_SREL16" },
-	intName{ 10, "R_ALPHA_SREL32" },
-	intName{ 11, "R_ALPHA_SREL64" },
-	intName{ 12, "R_ALPHA_OP_PUSH" },
-	intName{ 13, "R_ALPHA_OP_STORE" },
-	intName{ 14, "R_ALPHA_OP_PSUB" },
-	intName{ 15, "R_ALPHA_OP_PRSHIFT" },
-	intName{ 16, "R_ALPHA_GPVALUE" },
-	intName{ 17, "R_ALPHA_GPRELHIGH" },
-	intName{ 18, "R_ALPHA_GPRELLOW" },
-	intName{ 19, "R_ALPHA_IMMED_GP_16" },
-	intName{ 20, "R_ALPHA_IMMED_GP_HI32" },
-	intName{ 21, "R_ALPHA_IMMED_SCN_HI32" },
-	intName{ 22, "R_ALPHA_IMMED_BR_HI32" },
-	intName{ 23, "R_ALPHA_IMMED_LO32" },
-	intName{ 24, "R_ALPHA_COPY" },
-	intName{ 25, "R_ALPHA_GLOB_DAT" },
-	intName{ 26, "R_ALPHA_JMP_SLOT" },
-	intName{ 27, "R_ALPHA_RELATIVE" },
+
+var ralphaStrings = []intName{
+	intName{0, "R_ALPHA_NONE"},
+	intName{1, "R_ALPHA_REFLONG"},
+	intName{2, "R_ALPHA_REFQUAD"},
+	intName{3, "R_ALPHA_GPREL32"},
+	intName{4, "R_ALPHA_LITERAL"},
+	intName{5, "R_ALPHA_LITUSE"},
+	intName{6, "R_ALPHA_GPDISP"},
+	intName{7, "R_ALPHA_BRADDR"},
+	intName{8, "R_ALPHA_HINT"},
+	intName{9, "R_ALPHA_SREL16"},
+	intName{10, "R_ALPHA_SREL32"},
+	intName{11, "R_ALPHA_SREL64"},
+	intName{12, "R_ALPHA_OP_PUSH"},
+	intName{13, "R_ALPHA_OP_STORE"},
+	intName{14, "R_ALPHA_OP_PSUB"},
+	intName{15, "R_ALPHA_OP_PRSHIFT"},
+	intName{16, "R_ALPHA_GPVALUE"},
+	intName{17, "R_ALPHA_GPRELHIGH"},
+	intName{18, "R_ALPHA_GPRELLOW"},
+	intName{19, "R_ALPHA_IMMED_GP_16"},
+	intName{20, "R_ALPHA_IMMED_GP_HI32"},
+	intName{21, "R_ALPHA_IMMED_SCN_HI32"},
+	intName{22, "R_ALPHA_IMMED_BR_HI32"},
+	intName{23, "R_ALPHA_IMMED_LO32"},
+	intName{24, "R_ALPHA_COPY"},
+	intName{25, "R_ALPHA_GLOB_DAT"},
+	intName{26, "R_ALPHA_JMP_SLOT"},
+	intName{27, "R_ALPHA_RELATIVE"},
 }
+
 func (i R_ALPHA) String() string {
-	return stringName(uint32(i), ralphaStrings, false)
+	return stringName(uint32(i), ralphaStrings, false);
 }
 func (i R_ALPHA) GoString() string {
-	return stringName(uint32(i), ralphaStrings, true)
+	return stringName(uint32(i), ralphaStrings, true);
 }
 
 // Relocation types for ARM.
 type R_ARM int
+
 const (
-	R_ARM_NONE R_ARM =		0;	/* No relocation. */
-	R_ARM_PC24 R_ARM =		1;
-	R_ARM_ABS32 R_ARM =		2;
-	R_ARM_REL32 R_ARM =		3;
-	R_ARM_PC13 R_ARM =		4;
-	R_ARM_ABS16 R_ARM =		5;
-	R_ARM_ABS12 R_ARM =		6;
-	R_ARM_THM_ABS5 R_ARM =		7;
-	R_ARM_ABS8 R_ARM =		8;
-	R_ARM_SBREL32 R_ARM =		9;
-	R_ARM_THM_PC22 R_ARM =		10;
-	R_ARM_THM_PC8 R_ARM =		11;
-	R_ARM_AMP_VCALL9 R_ARM =	12;
-	R_ARM_SWI24 R_ARM =		13;
-	R_ARM_THM_SWI8 R_ARM =		14;
-	R_ARM_XPC25 R_ARM =		15;
-	R_ARM_THM_XPC22 R_ARM =		16;
-	R_ARM_COPY R_ARM =		20;	/* Copy data from shared object. */
-	R_ARM_GLOB_DAT R_ARM =		21;	/* Set GOT entry to data address. */
-	R_ARM_JUMP_SLOT R_ARM =		22;	/* Set GOT entry to code address. */
-	R_ARM_RELATIVE R_ARM =		23;	/* Add load address of shared object. */
-	R_ARM_GOTOFF R_ARM =		24;	/* Add GOT-relative symbol address. */
-	R_ARM_GOTPC R_ARM =		25;	/* Add PC-relative GOT table address. */
-	R_ARM_GOT32 R_ARM =		26;	/* Add PC-relative GOT offset. */
-	R_ARM_PLT32 R_ARM =		27;	/* Add PC-relative PLT offset. */
-	R_ARM_GNU_VTENTRY R_ARM =	100;
-	R_ARM_GNU_VTINHERIT R_ARM =	101;
-	R_ARM_RSBREL32 R_ARM =		250;
-	R_ARM_THM_RPC22 R_ARM =		251;
-	R_ARM_RREL32 R_ARM =		252;
-	R_ARM_RABS32 R_ARM =		253;
-	R_ARM_RPC24 R_ARM =		254;
-	R_ARM_RBASE R_ARM =		255;
+	R_ARM_NONE		R_ARM	= 0;	/* No relocation. */
+	R_ARM_PC24		R_ARM	= 1;
+	R_ARM_ABS32		R_ARM	= 2;
+	R_ARM_REL32		R_ARM	= 3;
+	R_ARM_PC13		R_ARM	= 4;
+	R_ARM_ABS16		R_ARM	= 5;
+	R_ARM_ABS12		R_ARM	= 6;
+	R_ARM_THM_ABS5		R_ARM	= 7;
+	R_ARM_ABS8		R_ARM	= 8;
+	R_ARM_SBREL32		R_ARM	= 9;
+	R_ARM_THM_PC22		R_ARM	= 10;
+	R_ARM_THM_PC8		R_ARM	= 11;
+	R_ARM_AMP_VCALL9	R_ARM	= 12;
+	R_ARM_SWI24		R_ARM	= 13;
+	R_ARM_THM_SWI8		R_ARM	= 14;
+	R_ARM_XPC25		R_ARM	= 15;
+	R_ARM_THM_XPC22		R_ARM	= 16;
+	R_ARM_COPY		R_ARM	= 20;	/* Copy data from shared object. */
+	R_ARM_GLOB_DAT		R_ARM	= 21;	/* Set GOT entry to data address. */
+	R_ARM_JUMP_SLOT		R_ARM	= 22;	/* Set GOT entry to code address. */
+	R_ARM_RELATIVE		R_ARM	= 23;	/* Add load address of shared object. */
+	R_ARM_GOTOFF		R_ARM	= 24;	/* Add GOT-relative symbol address. */
+	R_ARM_GOTPC		R_ARM	= 25;	/* Add PC-relative GOT table address. */
+	R_ARM_GOT32		R_ARM	= 26;	/* Add PC-relative GOT offset. */
+	R_ARM_PLT32		R_ARM	= 27;	/* Add PC-relative PLT offset. */
+	R_ARM_GNU_VTENTRY	R_ARM	= 100;
+	R_ARM_GNU_VTINHERIT	R_ARM	= 101;
+	R_ARM_RSBREL32		R_ARM	= 250;
+	R_ARM_THM_RPC22		R_ARM	= 251;
+	R_ARM_RREL32		R_ARM	= 252;
+	R_ARM_RABS32		R_ARM	= 253;
+	R_ARM_RPC24		R_ARM	= 254;
+	R_ARM_RBASE		R_ARM	= 255;
 )
-var rarmStrings = []intName {
-	intName{ 0, "R_ARM_NONE" },
-	intName{ 1, "R_ARM_PC24" },
-	intName{ 2, "R_ARM_ABS32" },
-	intName{ 3, "R_ARM_REL32" },
-	intName{ 4, "R_ARM_PC13" },
-	intName{ 5, "R_ARM_ABS16" },
-	intName{ 6, "R_ARM_ABS12" },
-	intName{ 7, "R_ARM_THM_ABS5" },
-	intName{ 8, "R_ARM_ABS8" },
-	intName{ 9, "R_ARM_SBREL32" },
-	intName{ 10, "R_ARM_THM_PC22" },
-	intName{ 11, "R_ARM_THM_PC8" },
-	intName{ 12, "R_ARM_AMP_VCALL9" },
-	intName{ 13, "R_ARM_SWI24" },
-	intName{ 14, "R_ARM_THM_SWI8" },
-	intName{ 15, "R_ARM_XPC25" },
-	intName{ 16, "R_ARM_THM_XPC22" },
-	intName{ 20, "R_ARM_COPY" },
-	intName{ 21, "R_ARM_GLOB_DAT" },
-	intName{ 22, "R_ARM_JUMP_SLOT" },
-	intName{ 23, "R_ARM_RELATIVE" },
-	intName{ 24, "R_ARM_GOTOFF" },
-	intName{ 25, "R_ARM_GOTPC" },
-	intName{ 26, "R_ARM_GOT32" },
-	intName{ 27, "R_ARM_PLT32" },
-	intName{ 100, "R_ARM_GNU_VTENTRY" },
-	intName{ 101, "R_ARM_GNU_VTINHERIT" },
-	intName{ 250, "R_ARM_RSBREL32" },
-	intName{ 251, "R_ARM_THM_RPC22" },
-	intName{ 252, "R_ARM_RREL32" },
-	intName{ 253, "R_ARM_RABS32" },
-	intName{ 254, "R_ARM_RPC24" },
-	intName{ 255, "R_ARM_RBASE" },
+
+var rarmStrings = []intName{
+	intName{0, "R_ARM_NONE"},
+	intName{1, "R_ARM_PC24"},
+	intName{2, "R_ARM_ABS32"},
+	intName{3, "R_ARM_REL32"},
+	intName{4, "R_ARM_PC13"},
+	intName{5, "R_ARM_ABS16"},
+	intName{6, "R_ARM_ABS12"},
+	intName{7, "R_ARM_THM_ABS5"},
+	intName{8, "R_ARM_ABS8"},
+	intName{9, "R_ARM_SBREL32"},
+	intName{10, "R_ARM_THM_PC22"},
+	intName{11, "R_ARM_THM_PC8"},
+	intName{12, "R_ARM_AMP_VCALL9"},
+	intName{13, "R_ARM_SWI24"},
+	intName{14, "R_ARM_THM_SWI8"},
+	intName{15, "R_ARM_XPC25"},
+	intName{16, "R_ARM_THM_XPC22"},
+	intName{20, "R_ARM_COPY"},
+	intName{21, "R_ARM_GLOB_DAT"},
+	intName{22, "R_ARM_JUMP_SLOT"},
+	intName{23, "R_ARM_RELATIVE"},
+	intName{24, "R_ARM_GOTOFF"},
+	intName{25, "R_ARM_GOTPC"},
+	intName{26, "R_ARM_GOT32"},
+	intName{27, "R_ARM_PLT32"},
+	intName{100, "R_ARM_GNU_VTENTRY"},
+	intName{101, "R_ARM_GNU_VTINHERIT"},
+	intName{250, "R_ARM_RSBREL32"},
+	intName{251, "R_ARM_THM_RPC22"},
+	intName{252, "R_ARM_RREL32"},
+	intName{253, "R_ARM_RABS32"},
+	intName{254, "R_ARM_RPC24"},
+	intName{255, "R_ARM_RBASE"},
 }
+
 func (i R_ARM) String() string {
-	return stringName(uint32(i), rarmStrings, false)
+	return stringName(uint32(i), rarmStrings, false);
 }
 func (i R_ARM) GoString() string {
-	return stringName(uint32(i), rarmStrings, true)
+	return stringName(uint32(i), rarmStrings, true);
 }
 
 // Relocation types for 386.
 type R_386 int
+
 const (
-	R_386_NONE R_386 =	0;	/* No relocation. */
-	R_386_32 R_386 =	1;	/* Add symbol value. */
-	R_386_PC32 R_386 =	2;	/* Add PC-relative symbol value. */
-	R_386_GOT32 R_386 =	3;	/* Add PC-relative GOT offset. */
-	R_386_PLT32 R_386 =	4;	/* Add PC-relative PLT offset. */
-	R_386_COPY R_386 =	5;	/* Copy data from shared object. */
-	R_386_GLOB_DAT R_386 =	6;	/* Set GOT entry to data address. */
-	R_386_JMP_SLOT R_386 =	7;	/* Set GOT entry to code address. */
-	R_386_RELATIVE R_386 =	8;	/* Add load address of shared object. */
-	R_386_GOTOFF R_386 =	9;	/* Add GOT-relative symbol address. */
-	R_386_GOTPC R_386 =	10;	/* Add PC-relative GOT table address. */
-	R_386_TLS_TPOFF R_386 =	14;	/* Negative offset in static TLS block */
-	R_386_TLS_IE R_386 =	15;	/* Absolute address of GOT for -ve static TLS */
-	R_386_TLS_GOTIE R_386 =	16;	/* GOT entry for negative static TLS block */
-	R_386_TLS_LE R_386 =	17;	/* Negative offset relative to static TLS */
-	R_386_TLS_GD R_386 =	18;	/* 32 bit offset to GOT (index,off) pair */
-	R_386_TLS_LDM R_386 =	19;	/* 32 bit offset to GOT (index,zero) pair */
-	R_386_TLS_GD_32 R_386 =	24;	/* 32 bit offset to GOT (index,off) pair */
-	R_386_TLS_GD_PUSH R_386 = 25;	/* pushl instruction for Sun ABI GD sequence */
-	R_386_TLS_GD_CALL R_386 = 26;	/* call instruction for Sun ABI GD sequence */
-	R_386_TLS_GD_POP R_386 = 27;	/* popl instruction for Sun ABI GD sequence */
-	R_386_TLS_LDM_32 R_386 = 28;	/* 32 bit offset to GOT (index,zero) pair */
-	R_386_TLS_LDM_PUSH R_386 = 29;	/* pushl instruction for Sun ABI LD sequence */
-	R_386_TLS_LDM_CALL R_386 = 30;	/* call instruction for Sun ABI LD sequence */
-	R_386_TLS_LDM_POP R_386 = 31;	/* popl instruction for Sun ABI LD sequence */
-	R_386_TLS_LDO_32 R_386 = 32;	/* 32 bit offset from start of TLS block */
-	R_386_TLS_IE_32 R_386 =	33;	/* 32 bit offset to GOT static TLS offset entry */
-	R_386_TLS_LE_32 R_386 =	34;	/* 32 bit offset within static TLS block */
-	R_386_TLS_DTPMOD32 R_386 = 35;	/* GOT entry containing TLS index */
-	R_386_TLS_DTPOFF32 R_386 = 36;	/* GOT entry containing TLS offset */
-	R_386_TLS_TPOFF32 R_386 = 37;	/* GOT entry of -ve static TLS offset */
+	R_386_NONE		R_386	= 0;	/* No relocation. */
+	R_386_32		R_386	= 1;	/* Add symbol value. */
+	R_386_PC32		R_386	= 2;	/* Add PC-relative symbol value. */
+	R_386_GOT32		R_386	= 3;	/* Add PC-relative GOT offset. */
+	R_386_PLT32		R_386	= 4;	/* Add PC-relative PLT offset. */
+	R_386_COPY		R_386	= 5;	/* Copy data from shared object. */
+	R_386_GLOB_DAT		R_386	= 6;	/* Set GOT entry to data address. */
+	R_386_JMP_SLOT		R_386	= 7;	/* Set GOT entry to code address. */
+	R_386_RELATIVE		R_386	= 8;	/* Add load address of shared object. */
+	R_386_GOTOFF		R_386	= 9;	/* Add GOT-relative symbol address. */
+	R_386_GOTPC		R_386	= 10;	/* Add PC-relative GOT table address. */
+	R_386_TLS_TPOFF		R_386	= 14;	/* Negative offset in static TLS block */
+	R_386_TLS_IE		R_386	= 15;	/* Absolute address of GOT for -ve static TLS */
+	R_386_TLS_GOTIE		R_386	= 16;	/* GOT entry for negative static TLS block */
+	R_386_TLS_LE		R_386	= 17;	/* Negative offset relative to static TLS */
+	R_386_TLS_GD		R_386	= 18;	/* 32 bit offset to GOT (index,off) pair */
+	R_386_TLS_LDM		R_386	= 19;	/* 32 bit offset to GOT (index,zero) pair */
+	R_386_TLS_GD_32		R_386	= 24;	/* 32 bit offset to GOT (index,off) pair */
+	R_386_TLS_GD_PUSH	R_386	= 25;	/* pushl instruction for Sun ABI GD sequence */
+	R_386_TLS_GD_CALL	R_386	= 26;	/* call instruction for Sun ABI GD sequence */
+	R_386_TLS_GD_POP	R_386	= 27;	/* popl instruction for Sun ABI GD sequence */
+	R_386_TLS_LDM_32	R_386	= 28;	/* 32 bit offset to GOT (index,zero) pair */
+	R_386_TLS_LDM_PUSH	R_386	= 29;	/* pushl instruction for Sun ABI LD sequence */
+	R_386_TLS_LDM_CALL	R_386	= 30;	/* call instruction for Sun ABI LD sequence */
+	R_386_TLS_LDM_POP	R_386	= 31;	/* popl instruction for Sun ABI LD sequence */
+	R_386_TLS_LDO_32	R_386	= 32;	/* 32 bit offset from start of TLS block */
+	R_386_TLS_IE_32		R_386	= 33;	/* 32 bit offset to GOT static TLS offset entry */
+	R_386_TLS_LE_32		R_386	= 34;	/* 32 bit offset within static TLS block */
+	R_386_TLS_DTPMOD32	R_386	= 35;	/* GOT entry containing TLS index */
+	R_386_TLS_DTPOFF32	R_386	= 36;	/* GOT entry containing TLS offset */
+	R_386_TLS_TPOFF32	R_386	= 37;	/* GOT entry of -ve static TLS offset */
 )
-var r386Strings = []intName {
-	intName{ 0, "R_386_NONE" },
-	intName{ 1, "R_386_32" },
-	intName{ 2, "R_386_PC32" },
-	intName{ 3, "R_386_GOT32" },
-	intName{ 4, "R_386_PLT32" },
-	intName{ 5, "R_386_COPY" },
-	intName{ 6, "R_386_GLOB_DAT" },
-	intName{ 7, "R_386_JMP_SLOT" },
-	intName{ 8, "R_386_RELATIVE" },
-	intName{ 9, "R_386_GOTOFF" },
-	intName{ 10, "R_386_GOTPC" },
-	intName{ 14, "R_386_TLS_TPOFF" },
-	intName{ 15, "R_386_TLS_IE" },
-	intName{ 16, "R_386_TLS_GOTIE" },
-	intName{ 17, "R_386_TLS_LE" },
-	intName{ 18, "R_386_TLS_GD" },
-	intName{ 19, "R_386_TLS_LDM" },
-	intName{ 24, "R_386_TLS_GD_32" },
-	intName{ 25, "R_386_TLS_GD_PUSH" },
-	intName{ 26, "R_386_TLS_GD_CALL" },
-	intName{ 27, "R_386_TLS_GD_POP" },
-	intName{ 28, "R_386_TLS_LDM_32" },
-	intName{ 29, "R_386_TLS_LDM_PUSH" },
-	intName{ 30, "R_386_TLS_LDM_CALL" },
-	intName{ 31, "R_386_TLS_LDM_POP" },
-	intName{ 32, "R_386_TLS_LDO_32" },
-	intName{ 33, "R_386_TLS_IE_32" },
-	intName{ 34, "R_386_TLS_LE_32" },
-	intName{ 35, "R_386_TLS_DTPMOD32" },
-	intName{ 36, "R_386_TLS_DTPOFF32" },
-	intName{ 37, "R_386_TLS_TPOFF32" },
+
+var r386Strings = []intName{
+	intName{0, "R_386_NONE"},
+	intName{1, "R_386_32"},
+	intName{2, "R_386_PC32"},
+	intName{3, "R_386_GOT32"},
+	intName{4, "R_386_PLT32"},
+	intName{5, "R_386_COPY"},
+	intName{6, "R_386_GLOB_DAT"},
+	intName{7, "R_386_JMP_SLOT"},
+	intName{8, "R_386_RELATIVE"},
+	intName{9, "R_386_GOTOFF"},
+	intName{10, "R_386_GOTPC"},
+	intName{14, "R_386_TLS_TPOFF"},
+	intName{15, "R_386_TLS_IE"},
+	intName{16, "R_386_TLS_GOTIE"},
+	intName{17, "R_386_TLS_LE"},
+	intName{18, "R_386_TLS_GD"},
+	intName{19, "R_386_TLS_LDM"},
+	intName{24, "R_386_TLS_GD_32"},
+	intName{25, "R_386_TLS_GD_PUSH"},
+	intName{26, "R_386_TLS_GD_CALL"},
+	intName{27, "R_386_TLS_GD_POP"},
+	intName{28, "R_386_TLS_LDM_32"},
+	intName{29, "R_386_TLS_LDM_PUSH"},
+	intName{30, "R_386_TLS_LDM_CALL"},
+	intName{31, "R_386_TLS_LDM_POP"},
+	intName{32, "R_386_TLS_LDO_32"},
+	intName{33, "R_386_TLS_IE_32"},
+	intName{34, "R_386_TLS_LE_32"},
+	intName{35, "R_386_TLS_DTPMOD32"},
+	intName{36, "R_386_TLS_DTPOFF32"},
+	intName{37, "R_386_TLS_TPOFF32"},
 }
+
 func (i R_386) String() string {
-	return stringName(uint32(i), r386Strings, false)
+	return stringName(uint32(i), r386Strings, false);
 }
 func (i R_386) GoString() string {
-	return stringName(uint32(i), r386Strings, true)
+	return stringName(uint32(i), r386Strings, true);
 }
 
 // Relocation types for PowerPC.
 type R_PPC int
-const (
-	R_PPC_NONE R_PPC =		0;	/* No relocation. */
-	R_PPC_ADDR32 R_PPC =		1;
-	R_PPC_ADDR24 R_PPC =		2;
-	R_PPC_ADDR16 R_PPC =		3;
-	R_PPC_ADDR16_LO R_PPC =		4;
-	R_PPC_ADDR16_HI R_PPC =		5;
-	R_PPC_ADDR16_HA R_PPC =		6;
-	R_PPC_ADDR14 R_PPC =		7;
-	R_PPC_ADDR14_BRTAKEN R_PPC =	8;
-	R_PPC_ADDR14_BRNTAKEN R_PPC =	9;
-	R_PPC_REL24 R_PPC =		10;
-	R_PPC_REL14 R_PPC =		11;
-	R_PPC_REL14_BRTAKEN R_PPC =	12;
-	R_PPC_REL14_BRNTAKEN R_PPC =	13;
-	R_PPC_GOT16 R_PPC =		14;
-	R_PPC_GOT16_LO R_PPC =		15;
-	R_PPC_GOT16_HI R_PPC =		16;
-	R_PPC_GOT16_HA R_PPC =		17;
-	R_PPC_PLTREL24 R_PPC =		18;
-	R_PPC_COPY R_PPC =		19;
-	R_PPC_GLOB_DAT R_PPC =		20;
-	R_PPC_JMP_SLOT R_PPC =		21;
-	R_PPC_RELATIVE R_PPC =		22;
-	R_PPC_LOCAL24PC R_PPC =		23;
-	R_PPC_UADDR32 R_PPC =		24;
-	R_PPC_UADDR16 R_PPC =		25;
-	R_PPC_REL32 R_PPC =		26;
-	R_PPC_PLT32 R_PPC =		27;
-	R_PPC_PLTREL32 R_PPC =		28;
-	R_PPC_PLT16_LO R_PPC =		29;
-	R_PPC_PLT16_HI R_PPC =		30;
-	R_PPC_PLT16_HA R_PPC =		31;
-	R_PPC_SDAREL16 R_PPC =		32;
-	R_PPC_SECTOFF R_PPC =		33;
-	R_PPC_SECTOFF_LO R_PPC =	34;
-	R_PPC_SECTOFF_HI R_PPC =	35;
-	R_PPC_SECTOFF_HA R_PPC =	36;
-
-	R_PPC_TLS R_PPC =		67;
-	R_PPC_DTPMOD32 R_PPC =		68;
-	R_PPC_TPREL16 R_PPC =		69;
-	R_PPC_TPREL16_LO R_PPC =	70;
-	R_PPC_TPREL16_HI R_PPC =	71;
-	R_PPC_TPREL16_HA R_PPC =	72;
-	R_PPC_TPREL32 R_PPC =		73;
-	R_PPC_DTPREL16 R_PPC =		74;
-	R_PPC_DTPREL16_LO R_PPC =	75;
-	R_PPC_DTPREL16_HI R_PPC =	76;
-	R_PPC_DTPREL16_HA R_PPC =	77;
-	R_PPC_DTPREL32 R_PPC =		78;
-	R_PPC_GOT_TLSGD16 R_PPC =	79;
-	R_PPC_GOT_TLSGD16_LO R_PPC =	80;
-	R_PPC_GOT_TLSGD16_HI R_PPC =	81;
-	R_PPC_GOT_TLSGD16_HA R_PPC =	82;
-	R_PPC_GOT_TLSLD16 R_PPC =	83;
-	R_PPC_GOT_TLSLD16_LO R_PPC =	84;
-	R_PPC_GOT_TLSLD16_HI R_PPC =	85;
-	R_PPC_GOT_TLSLD16_HA R_PPC =	86;
-	R_PPC_GOT_TPREL16 R_PPC =	87;
-	R_PPC_GOT_TPREL16_LO R_PPC =	88;
-	R_PPC_GOT_TPREL16_HI R_PPC =	89;
-	R_PPC_GOT_TPREL16_HA R_PPC =	90;
 
-	R_PPC_EMB_NADDR32 R_PPC =	101;
-	R_PPC_EMB_NADDR16 R_PPC =	102;
-	R_PPC_EMB_NADDR16_LO R_PPC =	103;
-	R_PPC_EMB_NADDR16_HI R_PPC =	104;
-	R_PPC_EMB_NADDR16_HA R_PPC =	105;
-	R_PPC_EMB_SDAI16 R_PPC =	106;
-	R_PPC_EMB_SDA2I16 R_PPC =	107;
-	R_PPC_EMB_SDA2REL R_PPC =	108;
-	R_PPC_EMB_SDA21 R_PPC =		109;
-	R_PPC_EMB_MRKREF R_PPC =	110;
-	R_PPC_EMB_RELSEC16 R_PPC =	111;
-	R_PPC_EMB_RELST_LO R_PPC =	112;
-	R_PPC_EMB_RELST_HI R_PPC =	113;
-	R_PPC_EMB_RELST_HA R_PPC =	114;
-	R_PPC_EMB_BIT_FLD R_PPC =	115;
-	R_PPC_EMB_RELSDA R_PPC =	116;
+const (
+	R_PPC_NONE		R_PPC	= 0;	/* No relocation. */
+	R_PPC_ADDR32		R_PPC	= 1;
+	R_PPC_ADDR24		R_PPC	= 2;
+	R_PPC_ADDR16		R_PPC	= 3;
+	R_PPC_ADDR16_LO		R_PPC	= 4;
+	R_PPC_ADDR16_HI		R_PPC	= 5;
+	R_PPC_ADDR16_HA		R_PPC	= 6;
+	R_PPC_ADDR14		R_PPC	= 7;
+	R_PPC_ADDR14_BRTAKEN	R_PPC	= 8;
+	R_PPC_ADDR14_BRNTAKEN	R_PPC	= 9;
+	R_PPC_REL24		R_PPC	= 10;
+	R_PPC_REL14		R_PPC	= 11;
+	R_PPC_REL14_BRTAKEN	R_PPC	= 12;
+	R_PPC_REL14_BRNTAKEN	R_PPC	= 13;
+	R_PPC_GOT16		R_PPC	= 14;
+	R_PPC_GOT16_LO		R_PPC	= 15;
+	R_PPC_GOT16_HI		R_PPC	= 16;
+	R_PPC_GOT16_HA		R_PPC	= 17;
+	R_PPC_PLTREL24		R_PPC	= 18;
+	R_PPC_COPY		R_PPC	= 19;
+	R_PPC_GLOB_DAT		R_PPC	= 20;
+	R_PPC_JMP_SLOT		R_PPC	= 21;
+	R_PPC_RELATIVE		R_PPC	= 22;
+	R_PPC_LOCAL24PC		R_PPC	= 23;
+	R_PPC_UADDR32		R_PPC	= 24;
+	R_PPC_UADDR16		R_PPC	= 25;
+	R_PPC_REL32		R_PPC	= 26;
+	R_PPC_PLT32		R_PPC	= 27;
+	R_PPC_PLTREL32		R_PPC	= 28;
+	R_PPC_PLT16_LO		R_PPC	= 29;
+	R_PPC_PLT16_HI		R_PPC	= 30;
+	R_PPC_PLT16_HA		R_PPC	= 31;
+	R_PPC_SDAREL16		R_PPC	= 32;
+	R_PPC_SECTOFF		R_PPC	= 33;
+	R_PPC_SECTOFF_LO	R_PPC	= 34;
+	R_PPC_SECTOFF_HI	R_PPC	= 35;
+	R_PPC_SECTOFF_HA	R_PPC	= 36;
+	R_PPC_TLS		R_PPC	= 67;
+	R_PPC_DTPMOD32		R_PPC	= 68;
+	R_PPC_TPREL16		R_PPC	= 69;
+	R_PPC_TPREL16_LO	R_PPC	= 70;
+	R_PPC_TPREL16_HI	R_PPC	= 71;
+	R_PPC_TPREL16_HA	R_PPC	= 72;
+	R_PPC_TPREL32		R_PPC	= 73;
+	R_PPC_DTPREL16		R_PPC	= 74;
+	R_PPC_DTPREL16_LO	R_PPC	= 75;
+	R_PPC_DTPREL16_HI	R_PPC	= 76;
+	R_PPC_DTPREL16_HA	R_PPC	= 77;
+	R_PPC_DTPREL32		R_PPC	= 78;
+	R_PPC_GOT_TLSGD16	R_PPC	= 79;
+	R_PPC_GOT_TLSGD16_LO	R_PPC	= 80;
+	R_PPC_GOT_TLSGD16_HI	R_PPC	= 81;
+	R_PPC_GOT_TLSGD16_HA	R_PPC	= 82;
+	R_PPC_GOT_TLSLD16	R_PPC	= 83;
+	R_PPC_GOT_TLSLD16_LO	R_PPC	= 84;
+	R_PPC_GOT_TLSLD16_HI	R_PPC	= 85;
+	R_PPC_GOT_TLSLD16_HA	R_PPC	= 86;
+	R_PPC_GOT_TPREL16	R_PPC	= 87;
+	R_PPC_GOT_TPREL16_LO	R_PPC	= 88;
+	R_PPC_GOT_TPREL16_HI	R_PPC	= 89;
+	R_PPC_GOT_TPREL16_HA	R_PPC	= 90;
+	R_PPC_EMB_NADDR32	R_PPC	= 101;
+	R_PPC_EMB_NADDR16	R_PPC	= 102;
+	R_PPC_EMB_NADDR16_LO	R_PPC	= 103;
+	R_PPC_EMB_NADDR16_HI	R_PPC	= 104;
+	R_PPC_EMB_NADDR16_HA	R_PPC	= 105;
+	R_PPC_EMB_SDAI16	R_PPC	= 106;
+	R_PPC_EMB_SDA2I16	R_PPC	= 107;
+	R_PPC_EMB_SDA2REL	R_PPC	= 108;
+	R_PPC_EMB_SDA21		R_PPC	= 109;
+	R_PPC_EMB_MRKREF	R_PPC	= 110;
+	R_PPC_EMB_RELSEC16	R_PPC	= 111;
+	R_PPC_EMB_RELST_LO	R_PPC	= 112;
+	R_PPC_EMB_RELST_HI	R_PPC	= 113;
+	R_PPC_EMB_RELST_HA	R_PPC	= 114;
+	R_PPC_EMB_BIT_FLD	R_PPC	= 115;
+	R_PPC_EMB_RELSDA	R_PPC	= 116;
 )
-var rppcStrings = []intName {
-	intName{ 0, "R_PPC_NONE" },
-	intName{ 1, "R_PPC_ADDR32" },
-	intName{ 2, "R_PPC_ADDR24" },
-	intName{ 3, "R_PPC_ADDR16" },
-	intName{ 4, "R_PPC_ADDR16_LO" },
-	intName{ 5, "R_PPC_ADDR16_HI" },
-	intName{ 6, "R_PPC_ADDR16_HA" },
-	intName{ 7, "R_PPC_ADDR14" },
-	intName{ 8, "R_PPC_ADDR14_BRTAKEN" },
-	intName{ 9, "R_PPC_ADDR14_BRNTAKEN" },
-	intName{ 10, "R_PPC_REL24" },
-	intName{ 11, "R_PPC_REL14" },
-	intName{ 12, "R_PPC_REL14_BRTAKEN" },
-	intName{ 13, "R_PPC_REL14_BRNTAKEN" },
-	intName{ 14, "R_PPC_GOT16" },
-	intName{ 15, "R_PPC_GOT16_LO" },
-	intName{ 16, "R_PPC_GOT16_HI" },
-	intName{ 17, "R_PPC_GOT16_HA" },
-	intName{ 18, "R_PPC_PLTREL24" },
-	intName{ 19, "R_PPC_COPY" },
-	intName{ 20, "R_PPC_GLOB_DAT" },
-	intName{ 21, "R_PPC_JMP_SLOT" },
-	intName{ 22, "R_PPC_RELATIVE" },
-	intName{ 23, "R_PPC_LOCAL24PC" },
-	intName{ 24, "R_PPC_UADDR32" },
-	intName{ 25, "R_PPC_UADDR16" },
-	intName{ 26, "R_PPC_REL32" },
-	intName{ 27, "R_PPC_PLT32" },
-	intName{ 28, "R_PPC_PLTREL32" },
-	intName{ 29, "R_PPC_PLT16_LO" },
-	intName{ 30, "R_PPC_PLT16_HI" },
-	intName{ 31, "R_PPC_PLT16_HA" },
-	intName{ 32, "R_PPC_SDAREL16" },
-	intName{ 33, "R_PPC_SECTOFF" },
-	intName{ 34, "R_PPC_SECTOFF_LO" },
-	intName{ 35, "R_PPC_SECTOFF_HI" },
-	intName{ 36, "R_PPC_SECTOFF_HA" },
 
-	intName{ 67, "R_PPC_TLS" },
-	intName{ 68, "R_PPC_DTPMOD32" },
-	intName{ 69, "R_PPC_TPREL16" },
-	intName{ 70, "R_PPC_TPREL16_LO" },
-	intName{ 71, "R_PPC_TPREL16_HI" },
-	intName{ 72, "R_PPC_TPREL16_HA" },
-	intName{ 73, "R_PPC_TPREL32" },
-	intName{ 74, "R_PPC_DTPREL16" },
-	intName{ 75, "R_PPC_DTPREL16_LO" },
-	intName{ 76, "R_PPC_DTPREL16_HI" },
-	intName{ 77, "R_PPC_DTPREL16_HA" },
-	intName{ 78, "R_PPC_DTPREL32" },
-	intName{ 79, "R_PPC_GOT_TLSGD16" },
-	intName{ 80, "R_PPC_GOT_TLSGD16_LO" },
-	intName{ 81, "R_PPC_GOT_TLSGD16_HI" },
-	intName{ 82, "R_PPC_GOT_TLSGD16_HA" },
-	intName{ 83, "R_PPC_GOT_TLSLD16" },
-	intName{ 84, "R_PPC_GOT_TLSLD16_LO" },
-	intName{ 85, "R_PPC_GOT_TLSLD16_HI" },
-	intName{ 86, "R_PPC_GOT_TLSLD16_HA" },
-	intName{ 87, "R_PPC_GOT_TPREL16" },
-	intName{ 88, "R_PPC_GOT_TPREL16_LO" },
-	intName{ 89, "R_PPC_GOT_TPREL16_HI" },
-	intName{ 90, "R_PPC_GOT_TPREL16_HA" },
+var rppcStrings = []intName{
+	intName{0, "R_PPC_NONE"},
+	intName{1, "R_PPC_ADDR32"},
+	intName{2, "R_PPC_ADDR24"},
+	intName{3, "R_PPC_ADDR16"},
+	intName{4, "R_PPC_ADDR16_LO"},
+	intName{5, "R_PPC_ADDR16_HI"},
+	intName{6, "R_PPC_ADDR16_HA"},
+	intName{7, "R_PPC_ADDR14"},
+	intName{8, "R_PPC_ADDR14_BRTAKEN"},
+	intName{9, "R_PPC_ADDR14_BRNTAKEN"},
+	intName{10, "R_PPC_REL24"},
+	intName{11, "R_PPC_REL14"},
+	intName{12, "R_PPC_REL14_BRTAKEN"},
+	intName{13, "R_PPC_REL14_BRNTAKEN"},
+	intName{14, "R_PPC_GOT16"},
+	intName{15, "R_PPC_GOT16_LO"},
+	intName{16, "R_PPC_GOT16_HI"},
+	intName{17, "R_PPC_GOT16_HA"},
+	intName{18, "R_PPC_PLTREL24"},
+	intName{19, "R_PPC_COPY"},
+	intName{20, "R_PPC_GLOB_DAT"},
+	intName{21, "R_PPC_JMP_SLOT"},
+	intName{22, "R_PPC_RELATIVE"},
+	intName{23, "R_PPC_LOCAL24PC"},
+	intName{24, "R_PPC_UADDR32"},
+	intName{25, "R_PPC_UADDR16"},
+	intName{26, "R_PPC_REL32"},
+	intName{27, "R_PPC_PLT32"},
+	intName{28, "R_PPC_PLTREL32"},
+	intName{29, "R_PPC_PLT16_LO"},
+	intName{30, "R_PPC_PLT16_HI"},
+	intName{31, "R_PPC_PLT16_HA"},
+	intName{32, "R_PPC_SDAREL16"},
+	intName{33, "R_PPC_SECTOFF"},
+	intName{34, "R_PPC_SECTOFF_LO"},
+	intName{35, "R_PPC_SECTOFF_HI"},
+	intName{36, "R_PPC_SECTOFF_HA"},
 
-	intName{ 101, "R_PPC_EMB_NADDR32" },
-	intName{ 102, "R_PPC_EMB_NADDR16" },
-	intName{ 103, "R_PPC_EMB_NADDR16_LO" },
-	intName{ 104, "R_PPC_EMB_NADDR16_HI" },
-	intName{ 105, "R_PPC_EMB_NADDR16_HA" },
-	intName{ 106, "R_PPC_EMB_SDAI16" },
-	intName{ 107, "R_PPC_EMB_SDA2I16" },
-	intName{ 108, "R_PPC_EMB_SDA2REL" },
-	intName{ 109, "R_PPC_EMB_SDA21" },
-	intName{ 110, "R_PPC_EMB_MRKREF" },
-	intName{ 111, "R_PPC_EMB_RELSEC16" },
-	intName{ 112, "R_PPC_EMB_RELST_LO" },
-	intName{ 113, "R_PPC_EMB_RELST_HI" },
-	intName{ 114, "R_PPC_EMB_RELST_HA" },
-	intName{ 115, "R_PPC_EMB_BIT_FLD" },
-	intName{ 116, "R_PPC_EMB_RELSDA" },
+	intName{67, "R_PPC_TLS"},
+	intName{68, "R_PPC_DTPMOD32"},
+	intName{69, "R_PPC_TPREL16"},
+	intName{70, "R_PPC_TPREL16_LO"},
+	intName{71, "R_PPC_TPREL16_HI"},
+	intName{72, "R_PPC_TPREL16_HA"},
+	intName{73, "R_PPC_TPREL32"},
+	intName{74, "R_PPC_DTPREL16"},
+	intName{75, "R_PPC_DTPREL16_LO"},
+	intName{76, "R_PPC_DTPREL16_HI"},
+	intName{77, "R_PPC_DTPREL16_HA"},
+	intName{78, "R_PPC_DTPREL32"},
+	intName{79, "R_PPC_GOT_TLSGD16"},
+	intName{80, "R_PPC_GOT_TLSGD16_LO"},
+	intName{81, "R_PPC_GOT_TLSGD16_HI"},
+	intName{82, "R_PPC_GOT_TLSGD16_HA"},
+	intName{83, "R_PPC_GOT_TLSLD16"},
+	intName{84, "R_PPC_GOT_TLSLD16_LO"},
+	intName{85, "R_PPC_GOT_TLSLD16_HI"},
+	intName{86, "R_PPC_GOT_TLSLD16_HA"},
+	intName{87, "R_PPC_GOT_TPREL16"},
+	intName{88, "R_PPC_GOT_TPREL16_LO"},
+	intName{89, "R_PPC_GOT_TPREL16_HI"},
+	intName{90, "R_PPC_GOT_TPREL16_HA"},
+
+	intName{101, "R_PPC_EMB_NADDR32"},
+	intName{102, "R_PPC_EMB_NADDR16"},
+	intName{103, "R_PPC_EMB_NADDR16_LO"},
+	intName{104, "R_PPC_EMB_NADDR16_HI"},
+	intName{105, "R_PPC_EMB_NADDR16_HA"},
+	intName{106, "R_PPC_EMB_SDAI16"},
+	intName{107, "R_PPC_EMB_SDA2I16"},
+	intName{108, "R_PPC_EMB_SDA2REL"},
+	intName{109, "R_PPC_EMB_SDA21"},
+	intName{110, "R_PPC_EMB_MRKREF"},
+	intName{111, "R_PPC_EMB_RELSEC16"},
+	intName{112, "R_PPC_EMB_RELST_LO"},
+	intName{113, "R_PPC_EMB_RELST_HI"},
+	intName{114, "R_PPC_EMB_RELST_HA"},
+	intName{115, "R_PPC_EMB_BIT_FLD"},
+	intName{116, "R_PPC_EMB_RELSDA"},
 }
+
 func (i R_PPC) String() string {
-	return stringName(uint32(i), rppcStrings, false)
+	return stringName(uint32(i), rppcStrings, false);
 }
 func (i R_PPC) GoString() string {
-	return stringName(uint32(i), rppcStrings, true)
+	return stringName(uint32(i), rppcStrings, true);
 }
 
 // Relocation types for SPARC.
 type R_SPARC int
+
 const (
-	R_SPARC_NONE R_SPARC =		0;
-	R_SPARC_8 R_SPARC =		1;
-	R_SPARC_16 R_SPARC =		2;
-	R_SPARC_32 R_SPARC =		3;
-	R_SPARC_DISP8 R_SPARC =		4;
-	R_SPARC_DISP16 R_SPARC =		5;
-	R_SPARC_DISP32 R_SPARC =		6;
-	R_SPARC_WDISP30 R_SPARC =		7;
-	R_SPARC_WDISP22 R_SPARC =		8;
-	R_SPARC_HI22 R_SPARC =		9;
-	R_SPARC_22 R_SPARC =		10;
-	R_SPARC_13 R_SPARC =		11;
-	R_SPARC_LO10 R_SPARC =		12;
-	R_SPARC_GOT10 R_SPARC =		13;
-	R_SPARC_GOT13 R_SPARC =		14;
-	R_SPARC_GOT22 R_SPARC =		15;
-	R_SPARC_PC10 R_SPARC =		16;
-	R_SPARC_PC22 R_SPARC =		17;
-	R_SPARC_WPLT30 R_SPARC =		18;
-	R_SPARC_COPY R_SPARC =		19;
-	R_SPARC_GLOB_DAT R_SPARC =	20;
-	R_SPARC_JMP_SLOT R_SPARC =	21;
-	R_SPARC_RELATIVE R_SPARC =	22;
-	R_SPARC_UA32 R_SPARC =		23;
-	R_SPARC_PLT32 R_SPARC =		24;
-	R_SPARC_HIPLT22 R_SPARC =		25;
-	R_SPARC_LOPLT10 R_SPARC =		26;
-	R_SPARC_PCPLT32 R_SPARC =		27;
-	R_SPARC_PCPLT22 R_SPARC =		28;
-	R_SPARC_PCPLT10 R_SPARC =		29;
-	R_SPARC_10 R_SPARC =		30;
-	R_SPARC_11 R_SPARC =		31;
-	R_SPARC_64 R_SPARC =		32;
-	R_SPARC_OLO10 R_SPARC =		33;
-	R_SPARC_HH22 R_SPARC =		34;
-	R_SPARC_HM10 R_SPARC =		35;
-	R_SPARC_LM22 R_SPARC =		36;
-	R_SPARC_PC_HH22 R_SPARC =		37;
-	R_SPARC_PC_HM10 R_SPARC =		38;
-	R_SPARC_PC_LM22 R_SPARC =		39;
-	R_SPARC_WDISP16 R_SPARC =		40;
-	R_SPARC_WDISP19 R_SPARC =		41;
-	R_SPARC_GLOB_JMP R_SPARC =	42;
-	R_SPARC_7 R_SPARC =		43;
-	R_SPARC_5 R_SPARC =		44;
-	R_SPARC_6 R_SPARC =		45;
-	R_SPARC_DISP64 R_SPARC =		46;
-	R_SPARC_PLT64 R_SPARC =		47;
-	R_SPARC_HIX22 R_SPARC =		48;
-	R_SPARC_LOX10 R_SPARC =		49;
-	R_SPARC_H44 R_SPARC =		50;
-	R_SPARC_M44 R_SPARC =		51;
-	R_SPARC_L44 R_SPARC =		52;
-	R_SPARC_REGISTER R_SPARC =	53;
-	R_SPARC_UA64 R_SPARC =		54;
-	R_SPARC_UA16 R_SPARC =		55;
+	R_SPARC_NONE		R_SPARC	= 0;
+	R_SPARC_8		R_SPARC	= 1;
+	R_SPARC_16		R_SPARC	= 2;
+	R_SPARC_32		R_SPARC	= 3;
+	R_SPARC_DISP8		R_SPARC	= 4;
+	R_SPARC_DISP16		R_SPARC	= 5;
+	R_SPARC_DISP32		R_SPARC	= 6;
+	R_SPARC_WDISP30		R_SPARC	= 7;
+	R_SPARC_WDISP22		R_SPARC	= 8;
+	R_SPARC_HI22		R_SPARC	= 9;
+	R_SPARC_22		R_SPARC	= 10;
+	R_SPARC_13		R_SPARC	= 11;
+	R_SPARC_LO10		R_SPARC	= 12;
+	R_SPARC_GOT10		R_SPARC	= 13;
+	R_SPARC_GOT13		R_SPARC	= 14;
+	R_SPARC_GOT22		R_SPARC	= 15;
+	R_SPARC_PC10		R_SPARC	= 16;
+	R_SPARC_PC22		R_SPARC	= 17;
+	R_SPARC_WPLT30		R_SPARC	= 18;
+	R_SPARC_COPY		R_SPARC	= 19;
+	R_SPARC_GLOB_DAT	R_SPARC	= 20;
+	R_SPARC_JMP_SLOT	R_SPARC	= 21;
+	R_SPARC_RELATIVE	R_SPARC	= 22;
+	R_SPARC_UA32		R_SPARC	= 23;
+	R_SPARC_PLT32		R_SPARC	= 24;
+	R_SPARC_HIPLT22		R_SPARC	= 25;
+	R_SPARC_LOPLT10		R_SPARC	= 26;
+	R_SPARC_PCPLT32		R_SPARC	= 27;
+	R_SPARC_PCPLT22		R_SPARC	= 28;
+	R_SPARC_PCPLT10		R_SPARC	= 29;
+	R_SPARC_10		R_SPARC	= 30;
+	R_SPARC_11		R_SPARC	= 31;
+	R_SPARC_64		R_SPARC	= 32;
+	R_SPARC_OLO10		R_SPARC	= 33;
+	R_SPARC_HH22		R_SPARC	= 34;
+	R_SPARC_HM10		R_SPARC	= 35;
+	R_SPARC_LM22		R_SPARC	= 36;
+	R_SPARC_PC_HH22		R_SPARC	= 37;
+	R_SPARC_PC_HM10		R_SPARC	= 38;
+	R_SPARC_PC_LM22		R_SPARC	= 39;
+	R_SPARC_WDISP16		R_SPARC	= 40;
+	R_SPARC_WDISP19		R_SPARC	= 41;
+	R_SPARC_GLOB_JMP	R_SPARC	= 42;
+	R_SPARC_7		R_SPARC	= 43;
+	R_SPARC_5		R_SPARC	= 44;
+	R_SPARC_6		R_SPARC	= 45;
+	R_SPARC_DISP64		R_SPARC	= 46;
+	R_SPARC_PLT64		R_SPARC	= 47;
+	R_SPARC_HIX22		R_SPARC	= 48;
+	R_SPARC_LOX10		R_SPARC	= 49;
+	R_SPARC_H44		R_SPARC	= 50;
+	R_SPARC_M44		R_SPARC	= 51;
+	R_SPARC_L44		R_SPARC	= 52;
+	R_SPARC_REGISTER	R_SPARC	= 53;
+	R_SPARC_UA64		R_SPARC	= 54;
+	R_SPARC_UA16		R_SPARC	= 55;
 )
-var rsparcStrings = []intName {
-	intName{ 0, "R_SPARC_NONE" },
-	intName{ 1, "R_SPARC_8" },
-	intName{ 2, "R_SPARC_16" },
-	intName{ 3, "R_SPARC_32" },
-	intName{ 4, "R_SPARC_DISP8" },
-	intName{ 5, "R_SPARC_DISP16" },
-	intName{ 6, "R_SPARC_DISP32" },
-	intName{ 7, "R_SPARC_WDISP30" },
-	intName{ 8, "R_SPARC_WDISP22" },
-	intName{ 9, "R_SPARC_HI22" },
-	intName{ 10, "R_SPARC_22" },
-	intName{ 11, "R_SPARC_13" },
-	intName{ 12, "R_SPARC_LO10" },
-	intName{ 13, "R_SPARC_GOT10" },
-	intName{ 14, "R_SPARC_GOT13" },
-	intName{ 15, "R_SPARC_GOT22" },
-	intName{ 16, "R_SPARC_PC10" },
-	intName{ 17, "R_SPARC_PC22" },
-	intName{ 18, "R_SPARC_WPLT30" },
-	intName{ 19, "R_SPARC_COPY" },
-	intName{ 20, "R_SPARC_GLOB_DAT" },
-	intName{ 21, "R_SPARC_JMP_SLOT" },
-	intName{ 22, "R_SPARC_RELATIVE" },
-	intName{ 23, "R_SPARC_UA32" },
-	intName{ 24, "R_SPARC_PLT32" },
-	intName{ 25, "R_SPARC_HIPLT22" },
-	intName{ 26, "R_SPARC_LOPLT10" },
-	intName{ 27, "R_SPARC_PCPLT32" },
-	intName{ 28, "R_SPARC_PCPLT22" },
-	intName{ 29, "R_SPARC_PCPLT10" },
-	intName{ 30, "R_SPARC_10" },
-	intName{ 31, "R_SPARC_11" },
-	intName{ 32, "R_SPARC_64" },
-	intName{ 33, "R_SPARC_OLO10" },
-	intName{ 34, "R_SPARC_HH22" },
-	intName{ 35, "R_SPARC_HM10" },
-	intName{ 36, "R_SPARC_LM22" },
-	intName{ 37, "R_SPARC_PC_HH22" },
-	intName{ 38, "R_SPARC_PC_HM10" },
-	intName{ 39, "R_SPARC_PC_LM22" },
-	intName{ 40, "R_SPARC_WDISP16" },
-	intName{ 41, "R_SPARC_WDISP19" },
-	intName{ 42, "R_SPARC_GLOB_JMP" },
-	intName{ 43, "R_SPARC_7" },
-	intName{ 44, "R_SPARC_5" },
-	intName{ 45, "R_SPARC_6" },
-	intName{ 46, "R_SPARC_DISP64" },
-	intName{ 47, "R_SPARC_PLT64" },
-	intName{ 48, "R_SPARC_HIX22" },
-	intName{ 49, "R_SPARC_LOX10" },
-	intName{ 50, "R_SPARC_H44" },
-	intName{ 51, "R_SPARC_M44" },
-	intName{ 52, "R_SPARC_L44" },
-	intName{ 53, "R_SPARC_REGISTER" },
-	intName{ 54, "R_SPARC_UA64" },
-	intName{ 55, "R_SPARC_UA16" },
+
+var rsparcStrings = []intName{
+	intName{0, "R_SPARC_NONE"},
+	intName{1, "R_SPARC_8"},
+	intName{2, "R_SPARC_16"},
+	intName{3, "R_SPARC_32"},
+	intName{4, "R_SPARC_DISP8"},
+	intName{5, "R_SPARC_DISP16"},
+	intName{6, "R_SPARC_DISP32"},
+	intName{7, "R_SPARC_WDISP30"},
+	intName{8, "R_SPARC_WDISP22"},
+	intName{9, "R_SPARC_HI22"},
+	intName{10, "R_SPARC_22"},
+	intName{11, "R_SPARC_13"},
+	intName{12, "R_SPARC_LO10"},
+	intName{13, "R_SPARC_GOT10"},
+	intName{14, "R_SPARC_GOT13"},
+	intName{15, "R_SPARC_GOT22"},
+	intName{16, "R_SPARC_PC10"},
+	intName{17, "R_SPARC_PC22"},
+	intName{18, "R_SPARC_WPLT30"},
+	intName{19, "R_SPARC_COPY"},
+	intName{20, "R_SPARC_GLOB_DAT"},
+	intName{21, "R_SPARC_JMP_SLOT"},
+	intName{22, "R_SPARC_RELATIVE"},
+	intName{23, "R_SPARC_UA32"},
+	intName{24, "R_SPARC_PLT32"},
+	intName{25, "R_SPARC_HIPLT22"},
+	intName{26, "R_SPARC_LOPLT10"},
+	intName{27, "R_SPARC_PCPLT32"},
+	intName{28, "R_SPARC_PCPLT22"},
+	intName{29, "R_SPARC_PCPLT10"},
+	intName{30, "R_SPARC_10"},
+	intName{31, "R_SPARC_11"},
+	intName{32, "R_SPARC_64"},
+	intName{33, "R_SPARC_OLO10"},
+	intName{34, "R_SPARC_HH22"},
+	intName{35, "R_SPARC_HM10"},
+	intName{36, "R_SPARC_LM22"},
+	intName{37, "R_SPARC_PC_HH22"},
+	intName{38, "R_SPARC_PC_HM10"},
+	intName{39, "R_SPARC_PC_LM22"},
+	intName{40, "R_SPARC_WDISP16"},
+	intName{41, "R_SPARC_WDISP19"},
+	intName{42, "R_SPARC_GLOB_JMP"},
+	intName{43, "R_SPARC_7"},
+	intName{44, "R_SPARC_5"},
+	intName{45, "R_SPARC_6"},
+	intName{46, "R_SPARC_DISP64"},
+	intName{47, "R_SPARC_PLT64"},
+	intName{48, "R_SPARC_HIX22"},
+	intName{49, "R_SPARC_LOX10"},
+	intName{50, "R_SPARC_H44"},
+	intName{51, "R_SPARC_M44"},
+	intName{52, "R_SPARC_L44"},
+	intName{53, "R_SPARC_REGISTER"},
+	intName{54, "R_SPARC_UA64"},
+	intName{55, "R_SPARC_UA16"},
 }
+
 func (i R_SPARC) String() string {
-	return stringName(uint32(i), rsparcStrings, false)
+	return stringName(uint32(i), rsparcStrings, false);
 }
 func (i R_SPARC) GoString() string {
-	return stringName(uint32(i), rsparcStrings, true)
+	return stringName(uint32(i), rsparcStrings, true);
 }
 
 /*
@@ -1306,44 +1373,44 @@ const ARM_MAGIC_TRAMP_NUMBER = 0x5c000003
  * ELF32 File header.
  */
 type Header32 struct {
-	Ident	[EI_NIDENT]byte;	/* File identification. */
-	Type	uint16;		/* File type. */
-	Machine	uint16;	/* Machine architecture. */
-	Version	uint32;	/* ELF format version. */
-	Entry	uint32;	/* Entry point. */
-	Phoff	uint32;	/* Program header file offset. */
-	Shoff	uint32;	/* Section header file offset. */
-	Flags	uint32;	/* Architecture-specific flags. */
-	Ehsize	uint16;	/* Size of ELF header in bytes. */
-	Phentsize	uint16;	/* Size of program header entry. */
-	Phnum	uint16;	/* Number of program header entries. */
-	Shentsize	uint16;	/* Size of section header entry. */
-	Shnum	uint16;	/* Number of section header entries. */
-	Shstrndx	uint16;	/* Section name strings section. */
+	Ident		[EI_NIDENT]byte;	/* File identification. */
+	Type		uint16;			/* File type. */
+	Machine		uint16;			/* Machine architecture. */
+	Version		uint32;			/* ELF format version. */
+	Entry		uint32;			/* Entry point. */
+	Phoff		uint32;			/* Program header file offset. */
+	Shoff		uint32;			/* Section header file offset. */
+	Flags		uint32;			/* Architecture-specific flags. */
+	Ehsize		uint16;			/* Size of ELF header in bytes. */
+	Phentsize	uint16;			/* Size of program header entry. */
+	Phnum		uint16;			/* Number of program header entries. */
+	Shentsize	uint16;			/* Size of section header entry. */
+	Shnum		uint16;			/* Number of section header entries. */
+	Shstrndx	uint16;			/* Section name strings section. */
 }
 
 /*
  * ELF32 Section header.
  */
 type Section32 struct {
-	Name	uint32;	/* Section name (index into the
-					   section header string table). */
-	Type	uint32;	/* Section type. */
-	Flags	uint32;	/* Section flags. */
-	Addr	uint32;	/* Address in memory image. */
-	Off	uint32;	/* Offset in file. */
-	Size	uint32;	/* Size in bytes. */
-	Link	uint32;	/* Index of a related section. */
-	Info	uint32;	/* Depends on section type. */
+	Name		uint32;	/* Section name (index into the
+							   section header string table). */
+	Type		uint32;	/* Section type. */
+	Flags		uint32;	/* Section flags. */
+	Addr		uint32;	/* Address in memory image. */
+	Off		uint32;	/* Offset in file. */
+	Size		uint32;	/* Size in bytes. */
+	Link		uint32;	/* Index of a related section. */
+	Info		uint32;	/* Depends on section type. */
 	Addralign	uint32;	/* Alignment in bytes. */
-	Entsize	uint32;	/* Size of each entry in section. */
+	Entsize		uint32;	/* Size of each entry in section. */
 }
 
 /*
  * ELF32 Program header.
  */
 type Prog32 struct {
-	Type	uint32;		/* Entry type. */
+	Type	uint32;	/* Entry type. */
 	Off	uint32;	/* File offset of contents. */
 	Vaddr	uint32;	/* Virtual address in memory image. */
 	Paddr	uint32;	/* Physical address (not used). */
@@ -1357,9 +1424,9 @@ type Prog32 struct {
  * ELF32 Dynamic structure.  The ".dynamic" section contains an array of them.
  */
 type Dyn32 struct {
-	Tag	int32;		/* Entry type. */
-	Val	uint32;		/* Integer/Address value. */
-};
+	Tag	int32;	/* Entry type. */
+	Val	uint32;	/* Integer/Address value. */
+}
 
 /*
  * Relocation entries.
@@ -1368,21 +1435,21 @@ type Dyn32 struct {
 // ELF32 Relocations that don't need an addend field.
 type Rel32 struct {
 	Off	uint32;	/* Location to be relocated. */
-	Info	uint32;		/* Relocation type and symbol index. */
+	Info	uint32;	/* Relocation type and symbol index. */
 }
 
 // ELF32 Relocations that need an addend field.
 type Rela32 struct {
 	Off	uint32;	/* Location to be relocated. */
-	Info	uint32;		/* Relocation type and symbol index. */
+	Info	uint32;	/* Relocation type and symbol index. */
 	Addend	int32;	/* Addend. */
 }
 
 func R_SYM32(info uint32) uint32 {
-	return uint32(info>>8)
+	return uint32(info>>8);
 }
 func R_TYPE32(info uint32) uint32 {
-	return uint32(info&0xff)
+	return uint32(info&0xff);
 }
 func R_INFO32(sym, typ uint32) uint32 {
 	return sym<<8 | typ;
@@ -1399,13 +1466,13 @@ type Sym32 struct {
 }
 
 func ST_BIND(info uint8) SymBind {
-	return SymBind(info>>4)
+	return SymBind(info>>4);
 }
 func ST_TYPE(bind SymBind, typ SymType) uint8 {
-	return uint8(bind)<<4 | uint8(typ)&0xf
+	return uint8(bind)<<4 | uint8(typ)&0xf;
 }
 func ST_VISIBILITY(other uint8) SymVis {
-	return SymVis(other & 3)
+	return SymVis(other&3);
 }
 
 /*
@@ -1417,20 +1484,20 @@ func ST_VISIBILITY(other uint8) SymVis {
  */
 
 type Header64 struct {
-	Ident	[EI_NIDENT]byte;	/* File identification. */
-	Type	uint16;		/* File type. */
-	Machine	uint16;	/* Machine architecture. */
-	Version	uint32;	/* ELF format version. */
-	Entry	uint64;	/* Entry point. */
-	Phoff	uint64;	/* Program header file offset. */
-	Shoff	uint64;	/* Section header file offset. */
-	Flags	uint32;	/* Architecture-specific flags. */
-	Ehsize	uint16;	/* Size of ELF header in bytes. */
-	Phentsize	uint16;	/* Size of program header entry. */
-	Phnum	uint16;	/* Number of program header entries. */
-	Shentsize	uint16;	/* Size of section header entry. */
-	Shnum	uint16;	/* Number of section header entries. */
-	Shstrndx	uint16;	/* Section name strings section. */
+	Ident		[EI_NIDENT]byte;	/* File identification. */
+	Type		uint16;			/* File type. */
+	Machine		uint16;			/* Machine architecture. */
+	Version		uint32;			/* ELF format version. */
+	Entry		uint64;			/* Entry point. */
+	Phoff		uint64;			/* Program header file offset. */
+	Shoff		uint64;			/* Section header file offset. */
+	Flags		uint32;			/* Architecture-specific flags. */
+	Ehsize		uint16;			/* Size of ELF header in bytes. */
+	Phentsize	uint16;			/* Size of program header entry. */
+	Phnum		uint16;			/* Number of program header entries. */
+	Shentsize	uint16;			/* Size of section header entry. */
+	Shnum		uint16;			/* Number of section header entries. */
+	Shstrndx	uint16;			/* Section name strings section. */
 }
 
 /*
@@ -1438,17 +1505,17 @@ type Header64 struct {
  */
 
 type Section64 struct {
-	Name	uint32;	/* Section name (index into the
-					   section header string table). */
-	Type	uint32;	/* Section type. */
-	Flags	uint64;	/* Section flags. */
-	Addr	uint64;	/* Address in memory image. */
-	Off	uint64;	/* Offset in file. */
-	Size	uint64;	/* Size in bytes. */
-	Link	uint32;	/* Index of a related section. */
-	Info	uint32;	/* Depends on section type. */
+	Name		uint32;	/* Section name (index into the
+							   section header string table). */
+	Type		uint32;	/* Section type. */
+	Flags		uint64;	/* Section flags. */
+	Addr		uint64;	/* Address in memory image. */
+	Off		uint64;	/* Offset in file. */
+	Size		uint64;	/* Size in bytes. */
+	Link		uint32;	/* Index of a related section. */
+	Info		uint32;	/* Depends on section type. */
 	Addralign	uint64;	/* Alignment in bytes. */
-	Entsize	uint64;	/* Size of each entry in section. */
+	Entsize		uint64;	/* Size of each entry in section. */
 }
 
 /*
@@ -1456,7 +1523,7 @@ type Section64 struct {
  */
 
 type Prog64 struct {
-	Type	uint32;		/* Entry type. */
+	Type	uint32;	/* Entry type. */
 	Flags	uint32;	/* Access permission flags. */
 	Off	uint64;	/* File offset of contents. */
 	Vaddr	uint64;	/* Virtual address in memory image. */
@@ -1471,8 +1538,8 @@ type Prog64 struct {
  */
 
 type Dyn64 struct {
-	Tag	int64;		/* Entry type. */
-	Val	uint64;		/* Integer/address value */
+	Tag	int64;	/* Entry type. */
+	Val	uint64;	/* Integer/address value */
 }
 
 /*
@@ -1482,24 +1549,24 @@ type Dyn64 struct {
 /* ELF64 relocations that don't need an addend field. */
 type Rel64 struct {
 	Off	uint64;	/* Location to be relocated. */
-	Info	uint64;		/* Relocation type and symbol index. */
+	Info	uint64;	/* Relocation type and symbol index. */
 }
 
 /* ELF64 relocations that need an addend field. */
 type Rela64 struct {
 	Off	uint64;	/* Location to be relocated. */
-	Info	uint64;		/* Relocation type and symbol index. */
+	Info	uint64;	/* Relocation type and symbol index. */
 	Addend	int64;	/* Addend. */
 }
 
 func R_SYM64(info uint64) uint32 {
-	return uint32(info>>32)
+	return uint32(info>>32);
 }
 func R_TYPE64(info uint64) uint32 {
-	return uint32(info)
+	return uint32(info);
 }
 func R_INFO(sym, typ uint32) uint64 {
-	return uint64(sym)<<32 | uint64(typ)
+	return uint64(sym)<<32 | uint64(typ);
 }
 
 
@@ -1508,7 +1575,7 @@ func R_INFO(sym, typ uint32) uint64 {
  */
 type Sym64 struct {
 	Name	uint32;	/* String table index of name. */
-	Info		uint8;	/* Type and binding information. */
+	Info	uint8;	/* Type and binding information. */
 	Other	uint8;	/* Reserved (not used). */
 	Shndx	uint16;	/* Section index of symbol. */
 	Value	uint64;	/* Symbol value. */
@@ -1517,34 +1584,34 @@ type Sym64 struct {
 
 
 type intName struct {
-	i uint32;
-	s string;
+	i	uint32;
+	s	string;
 }
 
 func stringName(i uint32, names []intName, goSyntax bool) string {
 	for _, n := range names {
 		if n.i == i {
 			if goSyntax {
-				return "elf." + n.s
+				return "elf." + n.s;
 			}
-			return n.s
+			return n.s;
 		}
 	}
 
 	// second pass - look for smaller to add with.
 	// assume sorted already
-	for j := len(names)-1; j>=0; j-- {
+	for j := len(names)-1; j >= 0; j-- {
 		n := names[j];
 		if n.i < i {
 			s := n.s;
 			if goSyntax {
-				s = "elf." + s;
+				s = "elf."+s;
 			}
 			return s + "+" + strconv.Uitoa64(uint64(i - n.i));
 		}
 	}
 
-	return strconv.Uitoa64(uint64(i))
+	return strconv.Uitoa64(uint64(i));
 }
 
 func flagName(i uint32, names []intName, goSyntax bool) string {
@@ -1562,10 +1629,10 @@ func flagName(i uint32, names []intName, goSyntax bool) string {
 		}
 	}
 	if len(s) == 0 {
-		return "0x" + strconv.Uitob64(uint64(i), 16)
+		return "0x" + strconv.Uitob64(uint64(i), 16);
 	}
 	if i != 0 {
-		s += "+0x" + strconv.Uitob64(uint64(i), 16)
+		s += "+0x" + strconv.Uitob64(uint64(i), 16);
 	}
-	return s
+	return s;
 }
diff --git a/src/pkg/debug/elf/elf_test.go b/src/pkg/debug/elf/elf_test.go
index bafa3d36e1..c6cf7bfe46 100644
--- a/src/pkg/debug/elf/elf_test.go
+++ b/src/pkg/debug/elf/elf_test.go
@@ -10,11 +10,11 @@ import (
 )
 
 type nameTest struct {
-	val interface{};
-	str string
+	val	interface{};
+	str	string;
 }
 
-var nameTests = []nameTest {
+var nameTests = []nameTest{
 	nameTest{ELFOSABI_LINUX, "ELFOSABI_LINUX"},
 	nameTest{ET_EXEC, "ET_EXEC"},
 	nameTest{EM_860, "EM_860"},
diff --git a/src/pkg/debug/elf/file.go b/src/pkg/debug/elf/file.go
index 6bb36bd6fd..f2d6657975 100644
--- a/src/pkg/debug/elf/file.go
+++ b/src/pkg/debug/elf/file.go
@@ -21,37 +21,36 @@ import (
 
 // A FileHeader represents an ELF file header.
 type FileHeader struct {
-	Class Class;
-	Data Data;
-	Version Version;
-	OSABI OSABI;
-	ABIVersion uint8;
-	ByteOrder binary.ByteOrder;
-	Type Type;
-	Machine Machine;
+	Class		Class;
+	Data		Data;
+	Version		Version;
+	OSABI		OSABI;
+	ABIVersion	uint8;
+	ByteOrder	binary.ByteOrder;
+	Type		Type;
+	Machine		Machine;
 }
 
 // A File represents an open ELF file.
 type File struct {
 	FileHeader;
-	Sections []*Section;
-	Progs []*Prog;
-
-	closer io.Closer;
+	Sections	[]*Section;
+	Progs		[]*Prog;
+	closer		io.Closer;
 }
 
 // A SectionHeader represents a single ELF section header.
 type SectionHeader struct {
-	Name string;
-	Type SectionType;
-	Flags SectionFlag;
-	Addr uint64;
-	Offset uint64;
-	Size uint64;
-	Link uint32;
-	Info uint32;
-	Addralign uint64;
-	Entsize uint64;
+	Name		string;
+	Type		SectionType;
+	Flags		SectionFlag;
+	Addr		uint64;
+	Offset		uint64;
+	Size		uint64;
+	Link		uint32;
+	Info		uint32;
+	Addralign	uint64;
+	Entsize		uint64;
 }
 
 // A Section represents a single section in an ELF file.
@@ -65,7 +64,7 @@ type Section struct {
 	// Open() to avoid fighting over the seek offset
 	// with other clients.
 	io.ReaderAt;
-	sr *io.SectionReader;
+	sr	*io.SectionReader;
 }
 
 // Data reads and returns the contents of the ELF section.
@@ -82,13 +81,13 @@ func (s *Section) Open() io.ReadSeeker {
 
 // A ProgHeader represents a single ELF program header.
 type ProgHeader struct {
-	Type ProgType;
-	Flags ProgFlag;
-	Vaddr uint64;
-	Paddr uint64;
-	Filesz uint64;
-	Memsz uint64;
-	Align uint64;
+	Type	ProgType;
+	Flags	ProgFlag;
+	Vaddr	uint64;
+	Paddr	uint64;
+	Filesz	uint64;
+	Memsz	uint64;
+	Align	uint64;
 }
 
 // A Prog represents a single ELF program header in an ELF binary.
@@ -102,7 +101,7 @@ type Prog struct {
 	// Open() to avoid fighting over the seek offset
 	// with other clients.
 	io.ReaderAt;
-	sr *io.SectionReader;
+	sr	*io.SectionReader;
 }
 
 // Open returns a new ReadSeeker reading the ELF program body.
@@ -116,9 +115,9 @@ func (p *Prog) Open() io.ReadSeeker {
  */
 
 type FormatError struct {
-	off int64;
-	msg string;
-	val interface{};
+	off	int64;
+	msg	string;
+	val	interface{};
 }
 
 func (e *FormatError) String() string {
@@ -175,7 +174,7 @@ func NewFile(r io.ReaderAt) (*File, os.Error) {
 	switch f.Class {
 	case ELFCLASS32:
 	case ELFCLASS64:
-		// ok
+	// ok
 	default:
 		return nil, &FormatError{0, "unknown ELF class", f.Class};
 	}
@@ -282,7 +281,6 @@ func NewFile(r io.ReaderAt) (*File, os.Error) {
 				Info: uint32(sh.Info),
 				Addralign: uint64(sh.Addralign),
 				Entsize: uint64(sh.Entsize),
-
 			};
 		}
 		s.sr = io.NewSectionReader(r, int64(s.Offset), int64(s.Size));
diff --git a/src/pkg/debug/elf/file_test.go b/src/pkg/debug/elf/file_test.go
index aceda51fee..140841b6da 100644
--- a/src/pkg/debug/elf/file_test.go
+++ b/src/pkg/debug/elf/file_test.go
@@ -11,12 +11,12 @@ import (
 )
 
 type fileTest struct {
-	file string;
-	hdr FileHeader;
-	sections []SectionHeader;
+	file		string;
+	hdr		FileHeader;
+	sections	[]SectionHeader;
 }
 
-var fileTests = []fileTest {
+var fileTests = []fileTest{
 	fileTest{
 		"testdata/gcc-386-freebsd-exec",
 		FileHeader{ELFCLASS32, ELFDATA2LSB, EV_CURRENT, ELFOSABI_FREEBSD, 0, binary.LittleEndian, ET_EXEC, EM_386},
@@ -27,10 +27,10 @@ var fileTests = []fileTest {
 			SectionHeader{".dynsym", SHT_DYNSYM, SHF_ALLOC, 0x804817c, 0x17c, 0x110, 0x4, 0x1, 0x4, 0x10},
 			SectionHeader{".dynstr", SHT_STRTAB, SHF_ALLOC, 0x804828c, 0x28c, 0xbb, 0x0, 0x0, 0x1, 0x0},
 			SectionHeader{".rel.plt", SHT_REL, SHF_ALLOC, 0x8048348, 0x348, 0x20, 0x3, 0x7, 0x4, 0x8},
-			SectionHeader{".init", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x8048368, 0x368, 0x11, 0x0, 0x0, 0x4, 0x0},
-			SectionHeader{".plt", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x804837c, 0x37c, 0x50, 0x0, 0x0, 0x4, 0x4},
-			SectionHeader{".text", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x80483cc, 0x3cc, 0x180, 0x0, 0x0, 0x4, 0x0},
-			SectionHeader{".fini", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x804854c, 0x54c, 0xc, 0x0, 0x0, 0x4, 0x0},
+			SectionHeader{".init", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x8048368, 0x368, 0x11, 0x0, 0x0, 0x4, 0x0},
+			SectionHeader{".plt", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x804837c, 0x37c, 0x50, 0x0, 0x0, 0x4, 0x4},
+			SectionHeader{".text", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x80483cc, 0x3cc, 0x180, 0x0, 0x0, 0x4, 0x0},
+			SectionHeader{".fini", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x804854c, 0x54c, 0xc, 0x0, 0x0, 0x4, 0x0},
 			SectionHeader{".rodata", SHT_PROGBITS, SHF_ALLOC, 0x8048558, 0x558, 0xa3, 0x0, 0x0, 0x1, 0x0},
 			SectionHeader{".data", SHT_PROGBITS, SHF_WRITE+SHF_ALLOC, 0x80495fc, 0x5fc, 0xc, 0x0, 0x0, 0x4, 0x0},
 			SectionHeader{".eh_frame", SHT_PROGBITS, SHF_ALLOC, 0x8049608, 0x608, 0x4, 0x0, 0x0, 0x4, 0x0},
@@ -51,7 +51,7 @@ var fileTests = []fileTest {
 			SectionHeader{".shstrtab", SHT_STRTAB, 0x0, 0x0, 0xa0d, 0xf8, 0x0, 0x0, 0x1, 0x0},
 			SectionHeader{".symtab", SHT_SYMTAB, 0x0, 0x0, 0xfb8, 0x4b0, 0x1d, 0x38, 0x4, 0x10},
 			SectionHeader{".strtab", SHT_STRTAB, 0x0, 0x0, 0x1468, 0x206, 0x0, 0x0, 0x1, 0x0},
-		}
+		},
 	},
 	fileTest{
 		"testdata/gcc-amd64-linux-exec",
@@ -61,17 +61,17 @@ var fileTests = []fileTest {
 			SectionHeader{".interp", SHT_PROGBITS, SHF_ALLOC, 0x400200, 0x200, 0x1c, 0x0, 0x0, 0x1, 0x0},
 			SectionHeader{".note.ABI-tag", SHT_NOTE, SHF_ALLOC, 0x40021c, 0x21c, 0x20, 0x0, 0x0, 0x4, 0x0},
 			SectionHeader{".hash", SHT_HASH, SHF_ALLOC, 0x400240, 0x240, 0x24, 0x5, 0x0, 0x8, 0x4},
-			SectionHeader{".gnu.hash", SHT_LOOS+268435446, SHF_ALLOC, 0x400268, 0x268, 0x1c, 0x5, 0x0, 0x8, 0x0},
+			SectionHeader{".gnu.hash", SHT_LOOS + 268435446, SHF_ALLOC, 0x400268, 0x268, 0x1c, 0x5, 0x0, 0x8, 0x0},
 			SectionHeader{".dynsym", SHT_DYNSYM, SHF_ALLOC, 0x400288, 0x288, 0x60, 0x6, 0x1, 0x8, 0x18},
 			SectionHeader{".dynstr", SHT_STRTAB, SHF_ALLOC, 0x4002e8, 0x2e8, 0x3d, 0x0, 0x0, 0x1, 0x0},
 			SectionHeader{".gnu.version", SHT_HIOS, SHF_ALLOC, 0x400326, 0x326, 0x8, 0x5, 0x0, 0x2, 0x2},
-			SectionHeader{".gnu.version_r", SHT_LOOS+268435454, SHF_ALLOC, 0x400330, 0x330, 0x20, 0x6, 0x1, 0x8, 0x0},
+			SectionHeader{".gnu.version_r", SHT_LOOS + 268435454, SHF_ALLOC, 0x400330, 0x330, 0x20, 0x6, 0x1, 0x8, 0x0},
 			SectionHeader{".rela.dyn", SHT_RELA, SHF_ALLOC, 0x400350, 0x350, 0x18, 0x5, 0x0, 0x8, 0x18},
 			SectionHeader{".rela.plt", SHT_RELA, SHF_ALLOC, 0x400368, 0x368, 0x30, 0x5, 0xc, 0x8, 0x18},
-			SectionHeader{".init", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x400398, 0x398, 0x18, 0x0, 0x0, 0x4, 0x0},
-			SectionHeader{".plt", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x4003b0, 0x3b0, 0x30, 0x0, 0x0, 0x4, 0x10},
-			SectionHeader{".text", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x4003e0, 0x3e0, 0x1b4, 0x0, 0x0, 0x10, 0x0},
-			SectionHeader{".fini", SHT_PROGBITS, SHF_ALLOC+SHF_EXECINSTR, 0x400594, 0x594, 0xe, 0x0, 0x0, 0x4, 0x0},
+			SectionHeader{".init", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x400398, 0x398, 0x18, 0x0, 0x0, 0x4, 0x0},
+			SectionHeader{".plt", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x4003b0, 0x3b0, 0x30, 0x0, 0x0, 0x4, 0x10},
+			SectionHeader{".text", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x4003e0, 0x3e0, 0x1b4, 0x0, 0x0, 0x10, 0x0},
+			SectionHeader{".fini", SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR, 0x400594, 0x594, 0xe, 0x0, 0x0, 0x4, 0x0},
 			SectionHeader{".rodata", SHT_PROGBITS, SHF_ALLOC, 0x4005a4, 0x5a4, 0x11, 0x0, 0x0, 0x4, 0x0},
 			SectionHeader{".eh_frame_hdr", SHT_PROGBITS, SHF_ALLOC, 0x4005b8, 0x5b8, 0x24, 0x0, 0x0, 0x4, 0x0},
 			SectionHeader{".eh_frame", SHT_PROGBITS, SHF_ALLOC, 0x4005e0, 0x5e0, 0xa4, 0x0, 0x0, 0x8, 0x0},
@@ -94,8 +94,8 @@ var fileTests = []fileTest {
 			SectionHeader{".shstrtab", SHT_STRTAB, 0x0, 0x0, 0xf10, 0x149, 0x0, 0x0, 0x1, 0x0},
 			SectionHeader{".symtab", SHT_SYMTAB, 0x0, 0x0, 0x19a0, 0x6f0, 0x24, 0x39, 0x8, 0x18},
 			SectionHeader{".strtab", SHT_STRTAB, 0x0, 0x0, 0x2090, 0x1fc, 0x0, 0x0, 0x1, 0x0},
-		}
-	}
+		},
+	},
 }
 
 func TestOpen(t *testing.T) {
diff --git a/src/pkg/debug/gosym/pclntab.go b/src/pkg/debug/gosym/pclntab.go
index ee6359f9dc..458b5243d4 100644
--- a/src/pkg/debug/gosym/pclntab.go
+++ b/src/pkg/debug/gosym/pclntab.go
@@ -11,13 +11,13 @@ package gosym
 import "debug/binary"
 
 type LineTable struct {
-	Data []byte;
-	PC uint64;
-	Line int;
+	Data	[]byte;
+	PC	uint64;
+	Line	int;
 }
 
 // TODO(rsc): Need to pull in quantum from architecture definition.
-const quantum = 1;
+const quantum = 1
 
 func (t *LineTable) parse(targetPC uint64, targetLine int) (b []byte, pc uint64, line int) {
 	// The PC/line table can be thought of as a sequence of
@@ -44,9 +44,9 @@ func (t *LineTable) parse(targetPC uint64, targetLine int) (b []byte, pc uint64,
 		case code <= 64:
 			line += int(code);
 		case code <= 128:
-			line -= int(code - 64);
+			line -= int(code-64);
 		default:
-			pc += quantum*uint64(code - 128);
+			pc += quantum * uint64(code-128);
 			continue;
 		}
 		pc += quantum;
@@ -70,7 +70,7 @@ func (t *LineTable) LineToPC(line int, maxpc uint64) uint64 {
 		return 0;
 	}
 	// Subtract quantum from PC to account for post-line increment
-	return pc - quantum;
+	return pc-quantum;
 }
 
 // NewLineTable returns a new PC/line table
diff --git a/src/pkg/debug/gosym/pclntab_test.go b/src/pkg/debug/gosym/pclntab_test.go
index 4345112ccb..6b70ba1638 100644
--- a/src/pkg/debug/gosym/pclntab_test.go
+++ b/src/pkg/debug/gosym/pclntab_test.go
@@ -13,7 +13,7 @@ import (
 
 func dotest() bool {
 	// For now, only works on ELF platforms.
-	return syscall.OS == "linux" && os.Getenv("GOARCH") == "amd64"
+	return syscall.OS == "linux" && os.Getenv("GOARCH") == "amd64";
 }
 
 func getTable(t *testing.T) *Table {
@@ -70,14 +70,14 @@ func TestLineFromAline(t *testing.T) {
 
 	// Walk every absolute line and ensure that we hit every
 	// source line monotonically
-	lastline := make(map[string] int);
+	lastline := make(map[string]int);
 	final := -1;
 	for i := 0; i < 10000; i++ {
 		path, line := pkg.lineFromAline(i);
 		// Check for end of object
 		if path == "" {
 			if final == -1 {
-				final = i - 1;
+				final = i-1;
 			}
 			continue;
 		} else if final != -1 {
@@ -92,8 +92,8 @@ func TestLineFromAline(t *testing.T) {
 		ll, ok := lastline[path];
 		if !ok {
 			t.Errorf("file %s starts on line %d", path, line);
-		} else if line != ll + 1 {
-			t.Errorf("expected next line of file %s to be %d, got %d", path, ll + 1, line);
+		} else if line != ll+1 {
+			t.Errorf("expected next line of file %s to be %d, got %d", path, ll+1, line);
 		}
 		lastline[path] = line;
 	}
@@ -113,7 +113,7 @@ func TestLineAline(t *testing.T) {
 		// A source file can appear multiple times in a
 		// object.  alineFromLine will always return alines in
 		// the first file, so track which lines we've seen.
-		found := make(map[string] int);
+		found := make(map[string]int);
 		for i := 0; i < 1000; i++ {
 			path, line := o.lineFromAline(i);
 			if path == "" {
@@ -121,7 +121,7 @@ func TestLineAline(t *testing.T) {
 			}
 
 			// cgo files are full of 'Z' symbols, which we don't handle
-			if len(path) > 4 && path[len(path)-4:len(path)] == ".cgo" {
+			if len(path) > 4 && path[len(path)-4 : len(path)] == ".cgo" {
 				continue;
 			}
 
@@ -167,7 +167,7 @@ func TestPCLine(t *testing.T) {
 		wantLine += int(textdat[off]);
 		if fn == nil {
 			t.Errorf("failed to get line of PC %#x", pc);
-		} else if len(file) < 12 || file[len(file)-12:len(file)] != "pclinetest.s" || line != wantLine || fn != sym {
+		} else if len(file) < 12 || file[len(file)-12 : len(file)] != "pclinetest.s" || line != wantLine || fn != sym {
 			t.Errorf("expected %s:%d (%s) at PC %#x, got %s:%d (%s)", "pclinetest.s", wantLine, sym.Name, pc, file, line, fn.Name);
 		}
 	}
@@ -177,13 +177,13 @@ func TestPCLine(t *testing.T) {
 	lookupline := -1;
 	wantLine = 0;
 	off := uint64(0);	// TODO(rsc): should not need off; bug in 8g
-	for pc := sym.Value; pc < sym.End; pc += 2 + uint64(textdat[off]) {
+	for pc := sym.Value; pc < sym.End; pc += 2+uint64(textdat[off]) {
 		file, line, fn := tab.PCToLine(pc);
-		off = pc-text.Addr;
+		off = pc - text.Addr;
 		wantLine += int(textdat[off]);
 		if line != wantLine {
 			t.Errorf("expected line %d at PC %#x in pcfromline, got %d", wantLine, pc, line);
-			off = pc+1-text.Addr;
+			off = pc + 1 - text.Addr;
 			continue;
 		}
 		if lookupline == -1 {
@@ -202,6 +202,6 @@ func TestPCLine(t *testing.T) {
 				t.Errorf("expected PC %#x (%s) at line %d, got PC %#x (%s)", pc, fn.Name, line, pc2, fn2.Name);
 			}
 		}
-		off = pc+1-text.Addr;
+		off = pc + 1 - text.Addr;
 	}
 }
diff --git a/src/pkg/debug/macho/file_test.go b/src/pkg/debug/macho/file_test.go
index 69b87575f2..fe0b3ff12c 100644
--- a/src/pkg/debug/macho/file_test.go
+++ b/src/pkg/debug/macho/file_test.go
@@ -10,13 +10,13 @@ import (
 )
 
 type fileTest struct {
-	file string;
-	hdr FileHeader;
-	segments []*SegmentHeader;
-	sections []*SectionHeader;
+	file		string;
+	hdr		FileHeader;
+	segments	[]*SegmentHeader;
+	sections	[]*SectionHeader;
 }
 
-var fileTests = []fileTest {
+var fileTests = []fileTest{
 	fileTest{
 		"testdata/gcc-386-darwin-exec",
 		FileHeader{0xfeedface, Cpu386, 0x3, 0x2, 0xc, 0x3c0, 0x85},
diff --git a/src/pkg/debug/macho/macho.go b/src/pkg/debug/macho/macho.go
index 78f2d7fc3b..4903f13450 100644
--- a/src/pkg/debug/macho/macho.go
+++ b/src/pkg/debug/macho/macho.go
@@ -19,60 +19,67 @@ type FileHeader struct {
 	Cmdsz	uint32;
 	Flags	uint32;
 }
+
 const (
-	fileHeaderSize32 = 7*4;
-	fileHeaderSize64 = 8*4;
+	fileHeaderSize32	= 7*4;
+	fileHeaderSize64	= 8*4;
 )
 
 const (
-	Magic32 uint32 = 0xfeedface;
-	Magic64 uint32 = 0xfeedfacf;
+	Magic32	uint32	= 0xfeedface;
+	Magic64	uint32	= 0xfeedfacf;
 )
 
 // A Type is a Mach-O file type, either an object or an executable.
 type Type uint32
+
 const (
-	TypeObj Type = 1;
-	TypeExec Type = 2;
+	TypeObj		Type	= 1;
+	TypeExec	Type	= 2;
 )
 
 // A Cpu is a Mach-O cpu type.
 type Cpu uint32
+
 const (
-	Cpu386 Cpu = 7;
-	CpuAmd64 Cpu = Cpu386 + 1<<24;
+	Cpu386		Cpu	= 7;
+	CpuAmd64	Cpu	= Cpu386 + 1<<24;
 )
 
-var cpuStrings = []intName {
-	intName{ uint32(Cpu386), "Cpu386" },
-	intName{ uint32(CpuAmd64), "CpuAmd64" },
+var cpuStrings = []intName{
+	intName{uint32(Cpu386), "Cpu386"},
+	intName{uint32(CpuAmd64), "CpuAmd64"},
 }
+
 func (i Cpu) String() string {
-	return stringName(uint32(i), cpuStrings, false)
+	return stringName(uint32(i), cpuStrings, false);
 }
 func (i Cpu) GoString() string {
-	return stringName(uint32(i), cpuStrings, true)
+	return stringName(uint32(i), cpuStrings, true);
 }
 
 // A LoadCmd is a Mach-O load command.
-type LoadCmd uint32;
+type LoadCmd uint32
+
 const (
-	LoadCmdSegment LoadCmd = 1;
-	LoadCmdSegment64 LoadCmd = 25;
-	LoadCmdThread LoadCmd = 4;
-	LoadCmdUnixThread LoadCmd = 5;	// thread+stack
+	LoadCmdSegment		LoadCmd	= 1;
+	LoadCmdSegment64	LoadCmd	= 25;
+	LoadCmdThread		LoadCmd	= 4;
+	LoadCmdUnixThread	LoadCmd	= 5;	// thread+stack
 )
-var cmdStrings = []intName {
-	intName{ uint32(LoadCmdSegment), "LoadCmdSegment" },
-	intName{ uint32(LoadCmdSegment64), "LoadCmdSegment64" },
-	intName{ uint32(LoadCmdThread), "LoadCmdThread" },
-	intName{ uint32(LoadCmdUnixThread), "LoadCmdUnixThread" },
+
+var cmdStrings = []intName{
+	intName{uint32(LoadCmdSegment), "LoadCmdSegment"},
+	intName{uint32(LoadCmdSegment64), "LoadCmdSegment64"},
+	intName{uint32(LoadCmdThread), "LoadCmdThread"},
+	intName{uint32(LoadCmdUnixThread), "LoadCmdUnixThread"},
 }
+
 func (i LoadCmd) String() string {
-	return stringName(uint32(i), cmdStrings, false)
+	return stringName(uint32(i), cmdStrings, false);
 }
 func (i LoadCmd) GoString() string {
-	return stringName(uint32(i), cmdStrings, true)
+	return stringName(uint32(i), cmdStrings, true);
 }
 
 // A Segment64 is a 64-bit Mach-O segment load command.
@@ -107,30 +114,30 @@ type Segment32 struct {
 
 // A Section32 is a 32-bit Mach-O section header.
 type Section32 struct {
-	Name	[16]byte;
+	Name		[16]byte;
 	Seg		[16]byte;
-	Addr	uint32;
-	Size	uint32;
-	Offset	uint32;
-	Align	uint32;
-	Reloff	uint32;
-	Nreloc	uint32;
-	Flags	uint32;
+	Addr		uint32;
+	Size		uint32;
+	Offset		uint32;
+	Align		uint32;
+	Reloff		uint32;
+	Nreloc		uint32;
+	Flags		uint32;
 	Reserve1	uint32;
 	Reserve2	uint32;
 }
 
 // A Section32 is a 64-bit Mach-O section header.
 type Section64 struct {
-	Name	[16]byte;
+	Name		[16]byte;
 	Seg		[16]byte;
-	Addr	uint64;
-	Size	uint64;
-	Offset	uint32;
-	Align	uint32;
-	Reloff	uint32;
-	Nreloc	uint32;
-	Flags	uint32;
+	Addr		uint64;
+	Size		uint64;
+	Offset		uint32;
+	Align		uint32;
+	Reloff		uint32;
+	Nreloc		uint32;
+	Flags		uint32;
 	Reserve1	uint32;
 	Reserve2	uint32;
 	Reserve3	uint32;
@@ -190,20 +197,20 @@ type RegsAMD64 struct {
 }
 
 type intName struct {
-	i uint32;
-	s string;
+	i	uint32;
+	s	string;
 }
 
 func stringName(i uint32, names []intName, goSyntax bool) string {
 	for _, n := range names {
 		if n.i == i {
 			if goSyntax {
-				return "macho." + n.s
+				return "macho." + n.s;
 			}
-			return n.s
+			return n.s;
 		}
 	}
-	return strconv.Uitoa64(uint64(i))
+	return strconv.Uitoa64(uint64(i));
 }
 
 func flagName(i uint32, names []intName, goSyntax bool) string {
@@ -221,10 +228,10 @@ func flagName(i uint32, names []intName, goSyntax bool) string {
 		}
 	}
 	if len(s) == 0 {
-		return "0x" + strconv.Uitob64(uint64(i), 16)
+		return "0x" + strconv.Uitob64(uint64(i), 16);
 	}
 	if i != 0 {
-		s += "+0x" + strconv.Uitob64(uint64(i), 16)
+		s += "+0x" + strconv.Uitob64(uint64(i), 16);
 	}
-	return s
+	return s;
 }
diff --git a/src/pkg/debug/proc/proc.go b/src/pkg/debug/proc/proc.go
index c67e02fea6..fc56914b1c 100644
--- a/src/pkg/debug/proc/proc.go
+++ b/src/pkg/debug/proc/proc.go
@@ -13,15 +13,15 @@ package proc
 // and proc_darwin.go do, because deps.bash only looks at
 // this file.
 import (
-	_ "container/vector";
-	_ "fmt";
-	_ "io";
-	"os";
-	_ "runtime";
-	"strconv";
-	_ "strings";
-	_ "sync";
-	_ "syscall";
+	_	"container/vector";
+	_	"fmt";
+	_	"io";
+		"os";
+	_	"runtime";
+		"strconv";
+	_	"strings";
+	_	"sync";
+	_	"syscall";
 )
 
 type Word uint64
@@ -149,7 +149,7 @@ type Process interface {
 // user request (e.g., from the Stop method or after single stepping),
 // or that are stopped because some other thread caused the program to
 // stop.
-type Stopped struct {}
+type Stopped struct{}
 
 func (c Stopped) String() string {
 	return "stopped";
@@ -157,7 +157,7 @@ func (c Stopped) String() string {
 
 // Breakpoint is a stop cause resulting from a thread reaching a set
 // breakpoint.
-type Breakpoint	Word
+type Breakpoint Word
 
 // PC returns the program counter that the program is stopped at.
 func (c Breakpoint) PC() Word {
@@ -202,8 +202,8 @@ func (c *ThreadCreate) String() string {
 // process threads and its registers and memory will still be
 // accessible.
 type ThreadExit struct {
-	exitStatus int;
-	signal string;
+	exitStatus	int;
+	signal		string;
 }
 
 // Exited returns true if the thread exited normally.
diff --git a/src/pkg/debug/proc/proc_linux.go b/src/pkg/debug/proc/proc_linux.go
index 8fb147ddc2..82291be239 100644
--- a/src/pkg/debug/proc/proc_linux.go
+++ b/src/pkg/debug/proc/proc_linux.go
@@ -35,9 +35,9 @@ import (
 // as well as experimentation and examination of gdb's behavior.
 
 const (
-	trace = false;
-	traceIP = false;
-	traceMem = false;
+	trace		= false;
+	traceIP		= false;
+	traceMem	= false;
 )
 
 /*
@@ -60,20 +60,20 @@ const (
 //
 // Terminal threads no longer exist in the OS and thus you can't do
 // anything with them.
-type threadState string;
+type threadState string
 
 const (
-	running             threadState = "Running";
-	singleStepping      threadState = "SingleStepping";	// Transient
-	stopping            threadState = "Stopping";	// Transient
-	stopped             threadState = "Stopped";
-	stoppedBreakpoint   threadState = "StoppedBreakpoint";
-	stoppedSignal       threadState = "StoppedSignal";
-	stoppedThreadCreate threadState = "StoppedThreadCreate";
-	stoppedExiting      threadState = "StoppedExiting";
-	exiting             threadState = "Exiting";	// Transient (except main thread)
-	exited              threadState = "Exited";
-	detached            threadState = "Detached";
+	running			threadState	= "Running";
+	singleStepping		threadState	= "SingleStepping";	// Transient
+	stopping		threadState	= "Stopping";		// Transient
+	stopped			threadState	= "Stopped";
+	stoppedBreakpoint	threadState	= "StoppedBreakpoint";
+	stoppedSignal		threadState	= "StoppedSignal";
+	stoppedThreadCreate	threadState	= "StoppedThreadCreate";
+	stoppedExiting		threadState	= "StoppedExiting";
+	exiting			threadState	= "Exiting";	// Transient (except main thread)
+	exited			threadState	= "Exited";
+	detached		threadState	= "Detached";
 )
 
 func (ts threadState) isRunning() bool {
@@ -104,8 +104,8 @@ func (ts threadState) String() string {
 // including its program counter, the overwritten text if the
 // breakpoint is installed.
 type breakpoint struct {
-	pc uintptr;
-	olddata []byte;
+	pc	uintptr;
+	olddata	[]byte;
 }
 
 func (bp *breakpoint) String() string {
@@ -116,19 +116,19 @@ func (bp *breakpoint) String() string {
 }
 
 // bpinst386 is the breakpoint instruction used on 386 and amd64.
-var bpinst386 = []byte{0xcc};
+var bpinst386 = []byte{0xcc}
 
 // A debugEvent represents a reason a thread stopped or a wait error.
 type debugEvent struct {
 	*os.Waitmsg;
-	t *thread;
-	err os.Error;
+	t	*thread;
+	err	os.Error;
 }
 
 // A debugReq is a request to execute a closure in the monitor thread.
 type debugReq struct {
-	f func () os.Error;
-	res chan os.Error;
+	f	func() os.Error;
+	res	chan os.Error;
 }
 
 // A transitionHandler specifies a function to be called when a thread
@@ -137,8 +137,8 @@ type debugReq struct {
 // invokes a handler, it removes the handler from the handler queue.
 // The handler should re-add itself if needed.
 type transitionHandler struct {
-	handle func (*thread, threadState, threadState);
-	onErr func (os.Error);
+	handle	func(*thread, threadState, threadState);
+	onErr	func(os.Error);
 }
 
 // A process is a Linux process, which consists of a set of threads.
@@ -146,34 +146,34 @@ type transitionHandler struct {
 // messages from the debugEvents, debugReqs, and stopReq channels and
 // calls transition handlers.
 type process struct {
-	pid int;
-	threads map[int] *thread;
-	breakpoints map[uintptr] *breakpoint;
-	debugEvents chan *debugEvent;
-	debugReqs chan *debugReq;
-	stopReq chan os.Error;
-	transitionHandlers *vector.Vector;
+	pid			int;
+	threads			map[int]*thread;
+	breakpoints		map[uintptr]*breakpoint;
+	debugEvents		chan *debugEvent;
+	debugReqs		chan *debugReq;
+	stopReq			chan os.Error;
+	transitionHandlers	*vector.Vector;
 }
 
 // A thread represents a Linux thread in another process that is being
 // debugged.  Each running thread has an associated goroutine that
 // waits for thread updates and sends them to the process monitor.
 type thread struct {
-	tid int;
-	proc *process;
+	tid	int;
+	proc	*process;
 	// Whether to ignore the next SIGSTOP received by wait.
-	ignoreNextSigstop bool;
+	ignoreNextSigstop	bool;
 
 	// Thread state.  Only modified via setState.
-	state threadState;
+	state	threadState;
 	// If state == StoppedBreakpoint
-	breakpoint *breakpoint;
+	breakpoint	*breakpoint;
 	// If state == StoppedSignal or state == Exited
-	signal int;
+	signal	int;
 	// If state == StoppedThreadCreate
-	newThread *thread;
+	newThread	*thread;
 	// If state == Exited
-	exitStatus int;
+	exitStatus	int;
 }
 
 /*
@@ -181,9 +181,9 @@ type thread struct {
  */
 
 type badState struct {
-	thread *thread;
-	message string;
-	state threadState;
+	thread	*thread;
+	message	string;
+	state	threadState;
 }
 
 func (e *badState) String() string {
@@ -204,8 +204,8 @@ func (e noBreakpointError) String() string {
 
 type newThreadError struct {
 	*os.Waitmsg;
-	wantPid int;
-	wantSig int;
+	wantPid	int;
+	wantSig	int;
 }
 
 func (e *newThreadError) String() string {
@@ -435,9 +435,9 @@ func (t *thread) wait() {
 			if err == nil {
 				continue;
 			}
-			// If we failed to continue, just let
-			// the stop go through so we can
-			// update the thread's state.
+		// If we failed to continue, just let
+		// the stop go through so we can
+		// update the thread's state.
 		}
 		t.proc.debugEvents <- &ev;
 		break;
@@ -515,7 +515,7 @@ func (ev *debugEvent) doTrap() (threadState, os.Error) {
 		return stopped, err;
 	}
 
-	b, ok := t.proc.breakpoints[uintptr(regs.PC())-uintptr(len(bpinst386))];
+	b, ok := t.proc.breakpoints[uintptr(regs.PC()) - uintptr(len(bpinst386))];
 	if !ok {
 		// We must have hit a breakpoint that was actually in
 		// the program.  Leave the IP where it is so we don't
@@ -673,13 +673,13 @@ func (ev *debugEvent) process() os.Error {
 // thread.
 //
 // Must be called from the monitor thread.
-func (t *thread) onStop(handle func (), onErr func (os.Error)) {
+func (t *thread) onStop(handle func(), onErr func(os.Error)) {
 	// TODO(austin) This is rather inefficient for things like
 	// stepping all threads during a continue.  Maybe move
 	// transitionHandlers to the thread, or have both per-thread
 	// and per-process transition handlers.
 	h := &transitionHandler{nil, onErr};
-	h.handle = func (st *thread, old, new threadState) {
+	h.handle = func(st *thread, old, new threadState) {
 		if t == st && old.isRunning() && !new.isRunning() {
 			handle();
 		} else {
@@ -753,7 +753,7 @@ func (p *process) monitor() {
 // respect to thread state changes).  f must not block.
 //
 // Must NOT be called from the monitor thread.
-func (p *process) do(f func () os.Error) os.Error {
+func (p *process) do(f func() os.Error) os.Error {
 	// TODO(austin) If monitor is stopped, return error.
 	req := &debugReq{f, make(chan os.Error)};
 	p.debugReqs <- req;
@@ -764,7 +764,7 @@ func (p *process) do(f func () os.Error) os.Error {
 // is already stopped, does nothing.
 func (p *process) stopMonitor(err os.Error) {
 	_ = p.stopReq <- err;	// do not block
-	// TODO(austin) Wait until monitor has exited?
+// TODO(austin) Wait until monitor has exited?
 }
 
 /*
@@ -774,7 +774,7 @@ func (p *process) stopMonitor(err os.Error) {
 func (t *thread) Regs() (Regs, os.Error) {
 	var regs syscall.PtraceRegs;
 
-	err := t.proc.do(func () os.Error {
+	err := t.proc.do(func() os.Error {
 		if !t.state.isStopped() {
 			return &badState{t, "cannot get registers", t.state};
 		}
@@ -784,8 +784,8 @@ func (t *thread) Regs() (Regs, os.Error) {
 		return nil, err;
 	}
 
-	setter := func (r *syscall.PtraceRegs) os.Error {
-		return t.proc.do(func () os.Error {
+	setter := func(r *syscall.PtraceRegs) os.Error {
+		return t.proc.do(func() os.Error {
 			if !t.state.isStopped() {
 				return &badState{t, "cannot get registers", t.state};
 			}
@@ -798,7 +798,7 @@ func (t *thread) Regs() (Regs, os.Error) {
 func (t *thread) Peek(addr Word, out []byte) (int, os.Error) {
 	var c int;
 
-	err := t.proc.do(func () os.Error {
+	err := t.proc.do(func() os.Error {
 		if !t.state.isStopped() {
 			return &badState{t, "cannot peek text", t.state};
 		}
@@ -814,7 +814,7 @@ func (t *thread) Peek(addr Word, out []byte) (int, os.Error) {
 func (t *thread) Poke(addr Word, out []byte) (int, os.Error) {
 	var c int;
 
-	err := t.proc.do(func () os.Error {
+	err := t.proc.do(func() os.Error {
 		if !t.state.isStopped() {
 			return &badState{t, "cannot poke text", t.state};
 		}
@@ -837,10 +837,10 @@ func (t *thread) stepAsync(ready chan os.Error) os.Error {
 		return err;
 	}
 	t.setState(singleStepping);
-	t.onStop(func () {
-			ready <- nil;
-		},
-		func (err os.Error) {
+	t.onStop(func() {
+		ready <- nil;
+	},
+		func(err os.Error) {
 			ready <- err;
 		});
 	return nil;
@@ -852,7 +852,7 @@ func (t *thread) Step() os.Error {
 
 	ready := make(chan os.Error);
 
-	err := t.proc.do(func () os.Error {
+	err := t.proc.do(func() os.Error {
 		if !t.state.isStopped() {
 			return &badState{t, "cannot single step", t.state};
 		}
@@ -867,14 +867,14 @@ func (t *thread) Step() os.Error {
 }
 
 // TODO(austin) We should probably get this via C's strsignal.
-var sigNames = [...]string {
+var sigNames = [...]string{
 	"SIGEXIT", "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL",
 	"SIGTRAP", "SIGABRT", "SIGBUS", "SIGFPE", "SIGKILL",
 	"SIGUSR1", "SIGSEGV", "SIGUSR2", "SIGPIPE", "SIGALRM",
 	"SIGTERM", "SIGSTKFLT", "SIGCHLD", "SIGCONT", "SIGSTOP",
 	"SIGTSTP", "SIGTTIN", "SIGTTOU", "SIGURG", "SIGXCPU",
 	"SIGXFSZ", "SIGVTALRM", "SIGPROF", "SIGWINCH", "SIGPOLL",
-	"SIGPWR", "SIGSYS"
+	"SIGPWR", "SIGSYS",
 }
 
 // sigName returns the symbolic name for the given signal number.  If
@@ -924,7 +924,7 @@ func (t *thread) Stopped() (Cause, os.Error) {
 func (p *process) Threads() []Thread {
 	var res []Thread;
 
-	p.do(func () os.Error {
+	p.do(func() os.Error {
 		res = make([]Thread, len(p.threads));
 		i := 0;
 		for _, t := range p.threads {
@@ -944,7 +944,7 @@ func (p *process) Threads() []Thread {
 }
 
 func (p *process) AddBreakpoint(pc Word) os.Error {
-	return p.do(func () os.Error {
+	return p.do(func() os.Error {
 		if t := p.someRunningThread(); t != nil {
 			return &badState{t, "cannot add breakpoint", t.state};
 		}
@@ -957,7 +957,7 @@ func (p *process) AddBreakpoint(pc Word) os.Error {
 }
 
 func (p *process) RemoveBreakpoint(pc Word) os.Error {
-	return p.do(func () os.Error {
+	return p.do(func() os.Error {
 		if t := p.someRunningThread(); t != nil {
 			return &badState{t, "cannot remove breakpoint", t.state};
 		}
@@ -975,7 +975,7 @@ func (p *process) Continue() os.Error {
 	var ready chan os.Error;
 	count := 0;
 
-	err := p.do(func () os.Error {
+	err := p.do(func() os.Error {
 		// We make the ready channel big enough to hold all
 		// ready message so we don't jam up the monitor if we
 		// stop listening (e.g., if there's an error).
@@ -1022,7 +1022,7 @@ func (p *process) Continue() os.Error {
 	}
 
 	// Continue all threads
-	err = p.do(func () os.Error {
+	err = p.do(func() os.Error {
 		if err := p.installBreakpoints(); err != nil {
 			return err;
 		}
@@ -1067,7 +1067,7 @@ func (p *process) WaitStop() os.Error {
 	// threads are already stopped.
 	ready := make(chan os.Error, 1);
 
-	err := p.do(func () os.Error {
+	err := p.do(func() os.Error {
 		// Are all of the threads already stopped?
 		if p.someRunningThread() == nil {
 			ready <- nil;
@@ -1076,7 +1076,7 @@ func (p *process) WaitStop() os.Error {
 
 		// Monitor state transitions
 		h := &transitionHandler{};
-		h.handle = func (st *thread, old, new threadState) {
+		h.handle = func(st *thread, old, new threadState) {
 			if !new.isRunning() {
 				if p.someRunningThread() == nil {
 					ready <- nil;
@@ -1085,7 +1085,7 @@ func (p *process) WaitStop() os.Error {
 			}
 			p.transitionHandlers.Push(h);
 		};
-		h.onErr = func (err os.Error) {
+		h.onErr = func(err os.Error) {
 			ready <- err;
 		};
 		p.transitionHandlers.Push(h);
@@ -1099,7 +1099,7 @@ func (p *process) WaitStop() os.Error {
 }
 
 func (p *process) Stop() os.Error {
-	err := p.do(func () os.Error {
+	err := p.do(func() os.Error {
 		return p.stopAsync();
 	});
 	if err != nil {
@@ -1114,7 +1114,7 @@ func (p *process) Detach() os.Error {
 		return err;
 	}
 
-	err := p.do(func () os.Error {
+	err := p.do(func() os.Error {
 		if err := p.uninstallBreakpoints(); err != nil {
 			return err;
 		}
@@ -1171,7 +1171,7 @@ func (p *process) newThread(tid int, signal int, cloned bool) (*thread, os.Error
 func (p *process) attachThread(tid int) (*thread, os.Error) {
 	p.logTrace("attaching to thread %d", tid);
 	var thr *thread;
-	err := p.do(func () os.Error {
+	err := p.do(func() os.Error {
 		errno := syscall.PtraceAttach(tid);
 		if errno != 0 {
 			return os.NewSyscallError("ptrace(ATTACH)", errno);
@@ -1253,12 +1253,12 @@ func (p *process) attachAllThreads() os.Error {
 func newProcess(pid int) *process {
 	p := &process{
 		pid: pid,
-		threads: make(map[int] *thread),
-		breakpoints: make(map[uintptr] *breakpoint),
+		threads: make(map[int]*thread),
+		breakpoints: make(map[uintptr]*breakpoint),
 		debugEvents: make(chan *debugEvent),
 		debugReqs: make(chan *debugReq),
 		stopReq: make(chan os.Error),
-		transitionHandlers: vector.New(0)
+		transitionHandlers: vector.New(0),
 	};
 
 	go p.monitor();
@@ -1285,8 +1285,7 @@ func Attach(pid int) (Process, os.Error) {
 // ForkExec forks the current process and execs argv0, stopping the
 // new process after the exec syscall.  See os.ForkExec for additional
 // details.
-func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*os.File) (Process, os.Error)
-{
+func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*os.File) (Process, os.Error) {
 	p := newProcess(-1);
 
 	// Create array of integer (system) fds.
@@ -1300,7 +1299,7 @@ func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*os.F
 	}
 
 	// Fork from the monitor thread so we get the right tracer pid.
-	err := p.do(func () os.Error {
+	err := p.do(func() os.Error {
 		pid, errno := syscall.PtraceForkExec(argv0, argv, envv, dir, intfd);
 		if errno != 0 {
 			return &os.PathError{"fork/exec", argv0, os.Errno(errno)};
diff --git a/src/pkg/debug/proc/proc_nacl.go b/src/pkg/debug/proc/proc_nacl.go
index c4f6067393..6942209a6b 100644
--- a/src/pkg/debug/proc/proc_nacl.go
+++ b/src/pkg/debug/proc/proc_nacl.go
@@ -12,9 +12,9 @@ import (
 // Process tracing is not supported on Native Client.
 
 func Attach(pid int) (Process, os.Error) {
-	return nil, os.NewSyscallError("ptrace", syscall.ENACL)
+	return nil, os.NewSyscallError("ptrace", syscall.ENACL);
 }
 
 func ForkExec(argv0 string, argv []string, envv []string, dir string, fd []*os.File) (Process, os.Error) {
-	return nil, os.NewSyscallError("fork/exec", syscall.ENACL)
+	return nil, os.NewSyscallError("fork/exec", syscall.ENACL);
 }
diff --git a/src/pkg/debug/proc/regs_darwin_386.go b/src/pkg/debug/proc/regs_darwin_386.go
index e171f72a95..60c9ac719e 100644
--- a/src/pkg/debug/proc/regs_darwin_386.go
+++ b/src/pkg/debug/proc/regs_darwin_386.go
@@ -3,4 +3,3 @@
 // license that can be found in the LICENSE file.
 
 package proc
-
diff --git a/src/pkg/debug/proc/regs_linux_386.go b/src/pkg/debug/proc/regs_linux_386.go
index 725223ccda..496fbc3375 100644
--- a/src/pkg/debug/proc/regs_linux_386.go
+++ b/src/pkg/debug/proc/regs_linux_386.go
@@ -12,10 +12,10 @@ import (
 
 type _386Regs struct {
 	syscall.PtraceRegs;
-	setter func (*syscall.PtraceRegs) os.Error;
+	setter	func(*syscall.PtraceRegs) os.Error;
 }
 
-var names = [...]string {
+var names = [...]string{
 	"eax",
 	"ebx",
 	"ecx",
@@ -67,51 +67,83 @@ func (r *_386Regs) Names() []string {
 
 func (r *_386Regs) Get(i int) Word {
 	switch i {
-	case 0: return Word(uint32(r.Eax));
-	case 1: return Word(uint32(r.Ebx));
-	case 2: return Word(uint32(r.Ecx));
-	case 3: return Word(uint32(r.Edx));
-	case 4: return Word(uint32(r.Esi));
-	case 5: return Word(uint32(r.Edi));
-	case 6: return Word(uint32(r.Ebp));
-	case 7: return Word(uint32(r.Esp));
-	case 8: return Word(uint32(r.Eip));
-	case 9: return Word(uint32(r.Eflags));
-	case 10: return Word(r.Cs);
-	case 11: return Word(r.Ss);
-	case 12: return Word(r.Ds);
-	case 13: return Word(r.Es);
-	case 14: return Word(r.Fs);
-	case 15: return Word(r.Gs);
+	case 0:
+		return Word(uint32(r.Eax));
+	case 1:
+		return Word(uint32(r.Ebx));
+	case 2:
+		return Word(uint32(r.Ecx));
+	case 3:
+		return Word(uint32(r.Edx));
+	case 4:
+		return Word(uint32(r.Esi));
+	case 5:
+		return Word(uint32(r.Edi));
+	case 6:
+		return Word(uint32(r.Ebp));
+	case 7:
+		return Word(uint32(r.Esp));
+	case 8:
+		return Word(uint32(r.Eip));
+	case 9:
+		return Word(uint32(r.Eflags));
+	case 10:
+		return Word(r.Cs);
+	case 11:
+		return Word(r.Ss);
+	case 12:
+		return Word(r.Ds);
+	case 13:
+		return Word(r.Es);
+	case 14:
+		return Word(r.Fs);
+	case 15:
+		return Word(r.Gs);
 	}
 	panic("invalid register index ", strconv.Itoa(i));
 }
 
 func (r *_386Regs) Set(i int, val Word) os.Error {
 	switch i {
-	case 0: r.Eax = int32(val);
-	case 1: r.Ebx = int32(val);
-	case 2: r.Ecx = int32(val);
-	case 3: r.Edx = int32(val);
-	case 4: r.Esi = int32(val);
-	case 5: r.Edi = int32(val);
-	case 6: r.Ebp = int32(val);
-	case 7: r.Esp = int32(val);
-	case 8: r.Eip = int32(val);
-	case 9: r.Eflags = int32(val);
-	case 10: r.Cs = uint16(val);
-	case 11: r.Ss = uint16(val);
-	case 12: r.Ds = uint16(val);
-	case 13: r.Es = uint16(val);
-	case 14: r.Fs = uint16(val);
-	case 15: r.Gs = uint16(val);
+	case 0:
+		r.Eax = int32(val);
+	case 1:
+		r.Ebx = int32(val);
+	case 2:
+		r.Ecx = int32(val);
+	case 3:
+		r.Edx = int32(val);
+	case 4:
+		r.Esi = int32(val);
+	case 5:
+		r.Edi = int32(val);
+	case 6:
+		r.Ebp = int32(val);
+	case 7:
+		r.Esp = int32(val);
+	case 8:
+		r.Eip = int32(val);
+	case 9:
+		r.Eflags = int32(val);
+	case 10:
+		r.Cs = uint16(val);
+	case 11:
+		r.Ss = uint16(val);
+	case 12:
+		r.Ds = uint16(val);
+	case 13:
+		r.Es = uint16(val);
+	case 14:
+		r.Fs = uint16(val);
+	case 15:
+		r.Gs = uint16(val);
 	default:
 		panic("invalid register index ", strconv.Itoa(i));
 	}
 	return r.setter(&r.PtraceRegs);
 }
 
-func newRegs(regs *syscall.PtraceRegs, setter func (*syscall.PtraceRegs) os.Error) Regs {
+func newRegs(regs *syscall.PtraceRegs, setter func(*syscall.PtraceRegs) os.Error) Regs {
 	res := _386Regs{};
 	res.PtraceRegs = *regs;
 	res.setter = setter;
diff --git a/src/pkg/debug/proc/regs_nacl_386.go b/src/pkg/debug/proc/regs_nacl_386.go
index e171f72a95..60c9ac719e 100644
--- a/src/pkg/debug/proc/regs_nacl_386.go
+++ b/src/pkg/debug/proc/regs_nacl_386.go
@@ -3,4 +3,3 @@
 // license that can be found in the LICENSE file.
 
 package proc
-