[dev.cc] cmd/internal/obj: export more symbols, rename Type_ to Type

For new assembler, reconvert using rsc.io/c2go rev f9db76e.
- Removes trailing _ from Go keywords that are exported.
- Export regstr as Register, anames[5689] as Anames.

Also update clients.

Change-Id: I41c8fd2d14490236f548b4aa0ed0b9bd7571d2d7
Reviewed-on: https://go-review.googlesource.com/3151
Reviewed-by: Rob Pike <r@golang.org>

4 files changed, 150 insertions, 150 deletions

diff --git a/src/cmd/internal/obj/arm/anames5.go b/src/cmd/internal/obj/arm/anames5.go
index 4c82a2d2e3..dd7b12aa13 100644
--- a/src/cmd/internal/obj/arm/anames5.go
+++ b/src/cmd/internal/obj/arm/anames5.go
@@ -1,6 +1,6 @@
 package arm
 
-var anames5 = []string{
+var Anames = []string{
 	"XXX",
 	"AND",
 	"EOR",
diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go
index 6a20cc8aae..466e30bc3c 100644
--- a/src/cmd/internal/obj/arm/asm5.go
+++ b/src/cmd/internal/obj/arm/asm5.go
@@ -276,14 +276,14 @@ var zprg = obj.Prog{
 	Scond: C_SCOND_NONE,
 	Reg:   NREG,
 	From: obj.Addr{
-		Name:  D_NONE,
-		Type_: D_NONE,
-		Reg:   NREG,
+		Name: D_NONE,
+		Type: D_NONE,
+		Reg:  NREG,
 	},
 	To: obj.Addr{
-		Name:  D_NONE,
-		Type_: D_NONE,
-		Reg:   NREG,
+		Name: D_NONE,
+		Type: D_NONE,
+		Reg:  NREG,
 	},
 }
 
@@ -362,7 +362,7 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 
 	case AB,
 		ABL:
-		if p.To.Type_ != D_OREG {
+		if p.To.Type != D_OREG {
 			if out != nil {
 				asmout(ctxt, p, o, out)
 			}
@@ -414,7 +414,7 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 		AMOVW,
 		ASTREX,
 		ASTREXD:
-		if p.To.Type_ == D_REG && p.To.Reg == 15 && p.From.Reg == 13 { // MOVW.W x(R13), PC
+		if p.To.Type == D_REG && p.To.Reg == 15 && p.From.Reg == 13 { // MOVW.W x(R13), PC
 			if out != nil {
 				asmout(ctxt, p, o, out)
 			}
@@ -454,11 +454,11 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 			}
 		}
 
-		if p.To.Type_ == D_REG && p.To.Reg == 15 {
+		if p.To.Type == D_REG && p.To.Reg == 15 {
 			ctxt.Diag("unsupported instruction (move to another register and use indirect jump instead): %v", p)
 		}
 
-		if p.To.Type_ == D_OREG && p.To.Reg == 13 && (p.Scond&C_WBIT != 0) && size > 4 {
+		if p.To.Type == D_OREG && p.To.Reg == 13 && (p.Scond&C_WBIT != 0) && size > 4 {
 			// function prolog with very large frame size: MOVW.W R14,-100004(R13)
 			// split it into two instructions:
 			// 	ADD $-100004, R13
@@ -468,7 +468,7 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 			p.Scond &^= C_WBIT
 			*q = *p
 			a = &p.To
-			if p.To.Type_ == D_OREG {
+			if p.To.Type == D_OREG {
 				a2 = &q.To
 			} else {
 
@@ -488,16 +488,16 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 
 			p.From = *a
 			p.From.Reg = NREG
-			p.From.Type_ = D_CONST
+			p.From.Type = D_CONST
 			p.To = zprg.To
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = 13
 
 			// make q into p but load/store from 0(R13)
 			q.Spadj = 0
 
 			*a2 = zprg.From
-			a2.Type_ = D_OREG
+			a2.Type = D_OREG
 			a2.Reg = 13
 			a2.Sym = nil
 			a2.Offset = 0
@@ -505,8 +505,8 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 			break
 		}
 
-		if (p.To.Type_ == D_OREG && p.To.Reg != 13 && p.To.Reg != 9) || (p.From.Type_ == D_OREG && p.From.Reg != 13 && p.From.Reg != 9) { // MOVW Rx, X(Ry), y != 13 && y != 9 // MOVW X(Rx), Ry, x != 13 && x != 9
-			if p.To.Type_ == D_OREG {
+		if (p.To.Type == D_OREG && p.To.Reg != 13 && p.To.Reg != 9) || (p.From.Type == D_OREG && p.From.Reg != 13 && p.From.Reg != 9) { // MOVW Rx, X(Ry), y != 13 && y != 9 // MOVW X(Rx), Ry, x != 13 && x != 9
+			if p.To.Type == D_OREG {
 				a = &p.To
 			} else {
 
@@ -548,7 +548,7 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 				}
 				q = ctxt.Arch.Prg()
 				*q = *p
-				if p.To.Type_ == D_OREG {
+				if p.To.Type == D_OREG {
 					a2 = &q.To
 				} else {
 
@@ -567,15 +567,15 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 				p.As = AMOVW
 
 				p.From = *a
-				p.From.Type_ = D_CONST
+				p.From.Type = D_CONST
 				p.To = zprg.To
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = 11
 
 				// make q into p but load/store from 0(R11)
 				*a2 = zprg.From
 
-				a2.Type_ = D_OREG
+				a2.Type = D_OREG
 				a2.Reg = 11
 				a2.Sym = nil
 				a2.Offset = 0
@@ -589,7 +589,7 @@ func asmoutnacl(ctxt *obj.Link, origPC int32, p *obj.Prog, o *Optab, out []uint3
 	}
 
 	// destination register specific
-	if p.To.Type_ == D_REG {
+	if p.To.Type == D_REG {
 
 		switch p.To.Reg {
 		case 9:
@@ -701,7 +701,7 @@ func span5(ctxt *obj.Link, cursym *obj.LSym) {
 			break
 		}
 
-		if p.As == AMOVW && p.To.Type_ == D_REG && p.To.Reg == REGPC && p.Scond&C_SCOND == C_SCOND_NONE {
+		if p.As == AMOVW && p.To.Type == D_REG && p.To.Reg == REGPC && p.Scond&C_SCOND == C_SCOND_NONE {
 			flushpool(ctxt, p, 0, 0)
 		}
 		c += int32(m)
@@ -896,7 +896,7 @@ func flushpool(ctxt *obj.Link, p *obj.Prog, skip int, force int) int {
 			}
 			q = ctxt.Arch.Prg()
 			q.As = AB
-			q.To.Type_ = D_BRANCH
+			q.To.Type = D_BRANCH
 			q.Pcond = p.Link
 			q.Link = ctxt.Blitrl
 			q.Lineno = p.Lineno
@@ -950,7 +950,7 @@ func addpool(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
 	default:
 		t.To.Offset = a.Offset
 		t.To.Sym = a.Sym
-		t.To.Type_ = a.Type_
+		t.To.Type = a.Type
 		t.To.Name = a.Name
 
 		if ctxt.Flag_shared != 0 && t.To.Sym != nil {
@@ -967,7 +967,7 @@ func addpool(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) {
 		C_SAUTO,
 		C_LAUTO,
 		C_LACON:
-		t.To.Type_ = D_CONST
+		t.To.Type = D_CONST
 		t.To.Offset = ctxt.Instoffset
 		break
 	}
@@ -1064,7 +1064,7 @@ func aclass(ctxt *obj.Link, a *obj.Addr) int {
 	var s *obj.LSym
 	var t int
 
-	switch a.Type_ {
+	switch a.Type {
 	case D_NONE:
 		return C_NONE
 
@@ -1291,7 +1291,7 @@ func oplook(ctxt *obj.Link, p *obj.Prog) *Optab {
 
 	if false { /*debug['O']*/
 		fmt.Printf("oplook %v %v %v %v\n", Aconv(int(p.As)), DRconv(a1), DRconv(a2), DRconv(a3))
-		fmt.Printf("\t\t%d %d\n", p.From.Type_, p.To.Type_)
+		fmt.Printf("\t\t%d %d\n", p.From.Type, p.To.Type)
 	}
 
 	e = oprange[r].stop
@@ -1308,8 +1308,8 @@ func oplook(ctxt *obj.Link, p *obj.Prog) *Optab {
 		}
 	}
 
-	ctxt.Diag("illegal combination %v; %v %v %v, %d %d", p, DRconv(a1), DRconv(a2), DRconv(a3), p.From.Type_, p.To.Type_)
-	ctxt.Diag("from %d %d to %d %d\n", p.From.Type_, p.From.Name, p.To.Type_, p.To.Name)
+	ctxt.Diag("illegal combination %v; %v %v %v, %d %d", p, DRconv(a1), DRconv(a2), DRconv(a3), p.From.Type, p.To.Type)
+	ctxt.Diag("from %d %d to %d %d\n", p.From.Type, p.From.Name, p.To.Type, p.To.Name)
 	prasm(p)
 	if o == nil {
 		o = optab
@@ -1627,7 +1627,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 		rf = int(p.From.Reg)
 		rt = int(p.To.Reg)
 		r = int(p.Reg)
-		if p.To.Type_ == D_NONE {
+		if p.To.Type == D_NONE {
 			rt = 0
 		}
 		if p.As == AMOVB || p.As == AMOVH || p.As == AMOVW || p.As == AMVN {
@@ -1644,7 +1644,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 		o1 |= uint32(immrot(uint32(ctxt.Instoffset)))
 		rt = int(p.To.Reg)
 		r = int(p.Reg)
-		if p.To.Type_ == D_NONE {
+		if p.To.Type == D_NONE {
 			rt = 0
 		}
 		if p.As == AMOVW || p.As == AMVN {
@@ -1680,7 +1680,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 			rel.Sym = p.To.Sym
 			v += int32(p.To.Offset)
 			rel.Add = int64(o1) | (int64(v)>>2)&0xffffff
-			rel.Type_ = obj.R_CALLARM
+			rel.Type = obj.R_CALLARM
 			break
 		}
 
@@ -1708,7 +1708,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 		rel = obj.Addrel(ctxt.Cursym)
 		rel.Off = int32(ctxt.Pc)
 		rel.Siz = 0
-		rel.Type_ = obj.R_CALLIND
+		rel.Type = obj.R_CALLIND
 
 	case 8: /* sll $c,[R],R -> mov (R<<$c),R */
 		aclass(ctxt, &p.From)
@@ -1736,7 +1736,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 	case 10: /* swi [$con] */
 		o1 = oprrr(ctxt, int(p.As), int(p.Scond))
 
-		if p.To.Type_ != D_NONE {
+		if p.To.Type != D_NONE {
 			aclass(ctxt, &p.To)
 			o1 |= uint32(ctxt.Instoffset & 0xffffff)
 		}
@@ -1761,18 +1761,18 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 			// Emit a TLS relocation instead of a standard one.
 			if rel.Sym == ctxt.Tlsg {
 
-				rel.Type_ = obj.R_TLS
+				rel.Type = obj.R_TLS
 				if ctxt.Flag_shared != 0 {
 					rel.Add += ctxt.Pc - p.Pcrel.Pc - 8 - int64(rel.Siz)
 				}
 				rel.Xadd = rel.Add
 				rel.Xsym = rel.Sym
 			} else if ctxt.Flag_shared != 0 {
-				rel.Type_ = obj.R_PCREL
+				rel.Type = obj.R_PCREL
 				rel.Add += ctxt.Pc - p.Pcrel.Pc - 8
 			} else {
 
-				rel.Type_ = obj.R_ADDR
+				rel.Type = obj.R_ADDR
 			}
 			o1 = 0
 		}
@@ -1799,7 +1799,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 			r = int(p.To.Reg)
 		}
 		o2 |= uint32(r) << 16
-		if p.To.Type_ != D_NONE {
+		if p.To.Type != D_NONE {
 			o2 |= uint32(p.To.Reg) << 12
 		}
 
@@ -1926,7 +1926,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 			r = int(o.param)
 		}
 		o2 |= uint32(r) << 16
-		if p.To.Type_ != D_NONE {
+		if p.To.Type != D_NONE {
 			o2 |= uint32(p.To.Reg) << 12
 		}
 
@@ -2088,7 +2088,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 		o1 |= uint32(immrot(0xff))
 		rt = int(p.To.Reg)
 		r = int(p.From.Reg)
-		if p.To.Type_ == D_NONE {
+		if p.To.Type == D_NONE {
 			rt = 0
 		}
 		if r == NREG {
@@ -2157,7 +2157,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 			rel = obj.Addrel(ctxt.Cursym)
 			rel.Off = int32(ctxt.Pc)
 			rel.Siz = 4
-			if p.To.Sym != nil && p.To.Sym.Type_ != 0 {
+			if p.To.Sym != nil && p.To.Sym.Type != 0 {
 				rel.Sym = p.To.Sym
 				rel.Add = p.To.Offset
 			} else {
@@ -2167,11 +2167,11 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
 			}
 
 			if o.flag&LPCREL != 0 {
-				rel.Type_ = obj.R_PCREL
+				rel.Type = obj.R_PCREL
 				rel.Add += ctxt.Pc - p.Pcrel.Pc - 16 + int64(rel.Siz)
 			} else {
 
-				rel.Type_ = obj.R_ADDR
+				rel.Type = obj.R_ADDR
 			}
 			o1 = 0
 		}
@@ -2550,7 +2550,7 @@ func mov(ctxt *obj.Link, p *obj.Prog) uint32 {
 	o1 |= uint32(p.From.Offset)
 	rt = int(p.To.Reg)
 	r = int(p.Reg)
-	if p.To.Type_ == D_NONE {
+	if p.To.Type == D_NONE {
 		rt = 0
 	}
 	if p.As == AMOVW || p.As == AMVN {
diff --git a/src/cmd/internal/obj/arm/list5.go b/src/cmd/internal/obj/arm/list5.go
index 1c817bb134..ee9e53e904 100644
--- a/src/cmd/internal/obj/arm/list5.go
+++ b/src/cmd/internal/obj/arm/list5.go
@@ -84,9 +84,9 @@ func Pconv(p *obj.Prog) string {
 		sc += ".U"
 	}
 	if a == AMOVM {
-		if p.From.Type_ == D_CONST {
+		if p.From.Type == D_CONST {
 			str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v", p.Pc, p.Line(), Aconv(a), sc, RAconv(&p.From), Dconv(p, 0, &p.To))
-		} else if p.To.Type_ == D_CONST {
+		} else if p.To.Type == D_CONST {
 			str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), RAconv(&p.To))
 		} else {
 
@@ -98,7 +98,7 @@ func Pconv(p *obj.Prog) string {
 		str = fmt.Sprintf("%.5d (%v)\t%v\t%v,%d,%v", p.Pc, p.Line(), Aconv(a), Dconv(p, 0, &p.From), p.Reg, Dconv(p, 0, &p.To))
 	} else if p.Reg == NREG {
 		str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), Dconv(p, 0, &p.To))
-	} else if p.From.Type_ != D_FREG {
+	} else if p.From.Type != D_FREG {
 		str = fmt.Sprintf("%.5d (%v)\t%v%s\t%v,R%d,%v", p.Pc, p.Line(), Aconv(a), sc, Dconv(p, 0, &p.From), p.Reg, Dconv(p, 0, &p.To))
 	} else {
 
@@ -115,7 +115,7 @@ func Aconv(a int) string {
 
 	s = "???"
 	if a >= AXXX && a < ALAST {
-		s = anames5[a]
+		s = Anames[a]
 	}
 	fp += s
 	return fp
@@ -128,9 +128,9 @@ func Dconv(p *obj.Prog, flag int, a *obj.Addr) string {
 	var op string
 	var v int
 
-	switch a.Type_ {
+	switch a.Type {
 	default:
-		str = fmt.Sprintf("GOK-type(%d)", a.Type_)
+		str = fmt.Sprintf("GOK-type(%d)", a.Type)
 
 	case D_NONE:
 		str = ""
@@ -220,7 +220,7 @@ func RAconv(a *obj.Addr) string {
 	var v int
 
 	str = fmt.Sprintf("GOK-reglist")
-	switch a.Type_ {
+	switch a.Type {
 	case D_CONST,
 		D_CONST2:
 		if a.Reg != NREG {
diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index 6905376778..e8d4a5fc67 100644
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -43,14 +43,14 @@ var zprg5 = obj.Prog{
 	Scond: C_SCOND_NONE,
 	Reg:   NREG,
 	From: obj.Addr{
-		Name:  D_NONE,
-		Type_: D_NONE,
-		Reg:   NREG,
+		Name: D_NONE,
+		Type: D_NONE,
+		Reg:  NREG,
 	},
 	To: obj.Addr{
-		Name:  D_NONE,
-		Type_: D_NONE,
-		Reg:   NREG,
+		Name: D_NONE,
+		Type: D_NONE,
+		Reg:  NREG,
 	},
 }
 
@@ -93,8 +93,8 @@ func progedit(ctxt *obj.Link, p *obj.Prog) {
 		ABL,
 		ADUFFZERO,
 		ADUFFCOPY:
-		if p.To.Type_ == D_OREG && (p.To.Name == D_EXTERN || p.To.Name == D_STATIC) && p.To.Sym != nil {
-			p.To.Type_ = D_BRANCH
+		if p.To.Type == D_OREG && (p.To.Name == D_EXTERN || p.To.Name == D_STATIC) && p.To.Sym != nil {
+			p.To.Type = D_BRANCH
 		}
 		break
 	}
@@ -123,16 +123,16 @@ func progedit(ctxt *obj.Link, p *obj.Prog) {
 				// MOVW	LR, R11
 				p.As = AMOVW
 
-				p.From.Type_ = D_REG
+				p.From.Type = D_REG
 				p.From.Reg = REGLINK
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = REGTMP
 
 				// BL	runtime.read_tls_fallback(SB)
 				p = obj.Appendp(ctxt, p)
 
 				p.As = ABL
-				p.To.Type_ = D_BRANCH
+				p.To.Type = D_BRANCH
 				p.To.Sym = tlsfallback
 				p.To.Offset = 0
 
@@ -140,9 +140,9 @@ func progedit(ctxt *obj.Link, p *obj.Prog) {
 				p = obj.Appendp(ctxt, p)
 
 				p.As = AMOVW
-				p.From.Type_ = D_REG
+				p.From.Type = D_REG
 				p.From.Reg = REGTMP
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = REGLINK
 				break
 			}
@@ -158,38 +158,38 @@ func progedit(ctxt *obj.Link, p *obj.Prog) {
 	switch p.As {
 
 	case AMOVF:
-		if p.From.Type_ == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
+		if p.From.Type == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
 			var i32 uint32
 			var f32 float32
 			f32 = float32(p.From.U.Dval)
 			i32 = math.Float32bits(f32)
 			literal = fmt.Sprintf("$f32.%08x", i32)
 			s = obj.Linklookup(ctxt, literal, 0)
-			if s.Type_ == 0 {
-				s.Type_ = obj.SRODATA
+			if s.Type == 0 {
+				s.Type = obj.SRODATA
 				obj.Adduint32(ctxt, s, i32)
 				s.Reachable = 0
 			}
 
-			p.From.Type_ = D_OREG
+			p.From.Type = D_OREG
 			p.From.Sym = s
 			p.From.Name = D_EXTERN
 			p.From.Offset = 0
 		}
 
 	case AMOVD:
-		if p.From.Type_ == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
+		if p.From.Type == D_FCONST && chipfloat5(ctxt, p.From.U.Dval) < 0 && (chipzero5(ctxt, p.From.U.Dval) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
 			var i64 uint64
 			i64 = math.Float64bits(p.From.U.Dval)
 			literal = fmt.Sprintf("$f64.%016x", i64)
 			s = obj.Linklookup(ctxt, literal, 0)
-			if s.Type_ == 0 {
-				s.Type_ = obj.SRODATA
+			if s.Type == 0 {
+				s.Type = obj.SRODATA
 				obj.Adduint64(ctxt, s, i64)
 				s.Reachable = 0
 			}
 
-			p.From.Type_ = D_OREG
+			p.From.Type = D_OREG
 			p.From.Sym = s
 			p.From.Name = D_EXTERN
 			p.From.Offset = 0
@@ -209,11 +209,11 @@ func progedit(ctxt *obj.Link, p *obj.Prog) {
 			ctxt.Tlsg = obj.Linklookup(ctxt, "runtime.tlsg", 0)
 		}
 
-		if p.From.Type_ == D_CONST && p.From.Name == D_EXTERN && p.From.Sym == ctxt.Tlsg {
-			p.From.Type_ = D_OREG
+		if p.From.Type == D_CONST && p.From.Name == D_EXTERN && p.From.Sym == ctxt.Tlsg {
+			p.From.Type = D_OREG
 		}
-		if p.To.Type_ == D_CONST && p.To.Name == D_EXTERN && p.To.Sym == ctxt.Tlsg {
-			p.To.Type_ = D_OREG
+		if p.To.Type == D_CONST && p.To.Name == D_EXTERN && p.To.Sym == ctxt.Tlsg {
+			p.To.Type = D_OREG
 		}
 	}
 }
@@ -295,29 +295,29 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 			p = obj.Appendp(ctxt, p)
 
 			p.As = AMOVW
-			p.From.Type_ = D_CONST
+			p.From.Type = D_CONST
 			p.From.Reg = 13
 			p.From.Offset = 4
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = 1
 
 			// MOVW $n(R13), R2
 			p = obj.Appendp(ctxt, p)
 
 			p.As = AMOVW
-			p.From.Type_ = D_CONST
+			p.From.Type = D_CONST
 			p.From.Reg = 13
 			p.From.Offset = 4 + int64(autoffset)
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = 2
 
 			// MOVW $0, R3
 			p = obj.Appendp(ctxt, p)
 
 			p.As = AMOVW
-			p.From.Type_ = D_CONST
+			p.From.Type = D_CONST
 			p.From.Offset = 0
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = 3
 
 			// L:
@@ -328,22 +328,22 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 			p = pl
 
 			p.As = AMOVW
-			p.From.Type_ = D_REG
+			p.From.Type = D_REG
 			p.From.Reg = 3
-			p.To.Type_ = D_OREG
+			p.To.Type = D_OREG
 			p.To.Reg = 1
 			p.To.Offset = 4
 			p.Scond |= C_PBIT
 
 			p = obj.Appendp(ctxt, p)
 			p.As = ACMP
-			p.From.Type_ = D_REG
+			p.From.Type = D_REG
 			p.From.Reg = 1
 			p.Reg = 2
 
 			p = obj.Appendp(ctxt, p)
 			p.As = ABNE
-			p.To.Type_ = D_BRANCH
+			p.To.Type = D_BRANCH
 			p.Pcond = pl
 		}
 	}
@@ -463,9 +463,9 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = AMOVW
 			p.Scond |= C_WBIT
-			p.From.Type_ = D_REG
+			p.From.Type = D_REG
 			p.From.Reg = REGLINK
-			p.To.Type_ = D_OREG
+			p.To.Type = D_OREG
 			p.To.Offset = int64(-autosize)
 			p.To.Reg = REGSP
 			p.Spadj = autosize
@@ -491,63 +491,63 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 				p = obj.Appendp(ctxt, p)
 
 				p.As = AMOVW
-				p.From.Type_ = D_OREG
+				p.From.Type = D_OREG
 				p.From.Reg = REGG
 				p.From.Offset = 4 * int64(ctxt.Arch.Ptrsize) // G.panic
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = 1
 
 				p = obj.Appendp(ctxt, p)
 				p.As = ACMP
-				p.From.Type_ = D_CONST
+				p.From.Type = D_CONST
 				p.From.Offset = 0
 				p.Reg = 1
 
 				p = obj.Appendp(ctxt, p)
 				p.As = ABEQ
-				p.To.Type_ = D_BRANCH
+				p.To.Type = D_BRANCH
 				p1 = p
 
 				p = obj.Appendp(ctxt, p)
 				p.As = AMOVW
-				p.From.Type_ = D_OREG
+				p.From.Type = D_OREG
 				p.From.Reg = 1
 				p.From.Offset = 0 // Panic.argp
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = 2
 
 				p = obj.Appendp(ctxt, p)
 				p.As = AADD
-				p.From.Type_ = D_CONST
+				p.From.Type = D_CONST
 				p.From.Offset = int64(autosize) + 4
 				p.Reg = 13
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = 3
 
 				p = obj.Appendp(ctxt, p)
 				p.As = ACMP
-				p.From.Type_ = D_REG
+				p.From.Type = D_REG
 				p.From.Reg = 2
 				p.Reg = 3
 
 				p = obj.Appendp(ctxt, p)
 				p.As = ABNE
-				p.To.Type_ = D_BRANCH
+				p.To.Type = D_BRANCH
 				p2 = p
 
 				p = obj.Appendp(ctxt, p)
 				p.As = AADD
-				p.From.Type_ = D_CONST
+				p.From.Type = D_CONST
 				p.From.Offset = 4
 				p.Reg = 13
-				p.To.Type_ = D_REG
+				p.To.Type = D_REG
 				p.To.Reg = 4
 
 				p = obj.Appendp(ctxt, p)
 				p.As = AMOVW
-				p.From.Type_ = D_REG
+				p.From.Type = D_REG
 				p.From.Reg = 4
-				p.To.Type_ = D_OREG
+				p.To.Type = D_OREG
 				p.To.Reg = 1
 				p.To.Offset = 0 // Panic.argp
 
@@ -565,10 +565,10 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 					p.As = AB
 					p.From = zprg5.From
 					if p.To.Sym != nil { // retjmp
-						p.To.Type_ = D_BRANCH
+						p.To.Type = D_BRANCH
 					} else {
 
-						p.To.Type_ = D_OREG
+						p.To.Type = D_OREG
 						p.To.Offset = 0
 						p.To.Reg = REGLINK
 					}
@@ -579,10 +579,10 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = AMOVW
 			p.Scond |= C_PBIT
-			p.From.Type_ = D_OREG
+			p.From.Type = D_OREG
 			p.From.Offset = int64(autosize)
 			p.From.Reg = REGSP
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = REGPC
 
 			// If there are instructions following
@@ -592,19 +592,19 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 				p.To.Reg = REGLINK
 				q2 = obj.Appendp(ctxt, p)
 				q2.As = AB
-				q2.To.Type_ = D_BRANCH
+				q2.To.Type = D_BRANCH
 				q2.To.Sym = p.To.Sym
 				p.To.Sym = nil
 				p = q2
 			}
 
 		case AADD:
-			if p.From.Type_ == D_CONST && p.From.Reg == NREG && p.To.Type_ == D_REG && p.To.Reg == REGSP {
+			if p.From.Type == D_CONST && p.From.Reg == NREG && p.To.Type == D_REG && p.To.Reg == REGSP {
 				p.Spadj = int32(-p.From.Offset)
 			}
 
 		case ASUB:
-			if p.From.Type_ == D_CONST && p.From.Reg == NREG && p.To.Type_ == D_REG && p.To.Reg == REGSP {
+			if p.From.Type == D_CONST && p.From.Reg == NREG && p.To.Type == D_REG && p.To.Reg == REGSP {
 				p.Spadj = int32(p.From.Offset)
 			}
 
@@ -615,10 +615,10 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 			if ctxt.Debugdivmod != 0 {
 				break
 			}
-			if p.From.Type_ != D_REG {
+			if p.From.Type != D_REG {
 				break
 			}
-			if p.To.Type_ != D_REG {
+			if p.To.Type != D_REG {
 				break
 			}
 			q1 = p
@@ -628,9 +628,9 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = AMOVW
 			p.Lineno = q1.Lineno
-			p.From.Type_ = D_REG
+			p.From.Type = D_REG
 			p.From.Reg = q1.From.Reg
-			p.To.Type_ = D_OREG
+			p.To.Type = D_OREG
 			p.To.Reg = REGSP
 			p.To.Offset = 4
 
@@ -639,12 +639,12 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = AMOVW
 			p.Lineno = q1.Lineno
-			p.From.Type_ = D_REG
+			p.From.Type = D_REG
 			p.From.Reg = int8(q1.Reg)
 			if q1.Reg == NREG {
 				p.From.Reg = q1.To.Reg
 			}
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = REGTMP
 			p.To.Offset = 0
 
@@ -653,7 +653,7 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = ABL
 			p.Lineno = q1.Lineno
-			p.To.Type_ = D_BRANCH
+			p.To.Type = D_BRANCH
 			switch o {
 			case ADIV:
 				p.To.Sym = ctxt.Sym_div
@@ -674,10 +674,10 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = AMOVW
 			p.Lineno = q1.Lineno
-			p.From.Type_ = D_REG
+			p.From.Type = D_REG
 			p.From.Reg = REGTMP
 			p.From.Offset = 0
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = q1.To.Reg
 
 			/* ADD $8,SP */
@@ -685,11 +685,11 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.As = AADD
 			p.Lineno = q1.Lineno
-			p.From.Type_ = D_CONST
+			p.From.Type = D_CONST
 			p.From.Reg = NREG
 			p.From.Offset = 8
 			p.Reg = NREG
-			p.To.Type_ = D_REG
+			p.To.Type = D_REG
 			p.To.Reg = REGSP
 			p.Spadj = -8
 
@@ -698,34 +698,34 @@ func addstacksplit(ctxt *obj.Link, cursym *obj.LSym) {
 			/* TODO: Remove SP adjustments; see issue 6699. */
 			q1.As = AMOVW
 
-			q1.From.Type_ = D_OREG
+			q1.From.Type = D_OREG
 			q1.From.Reg = REGSP
 			q1.From.Offset = 0
 			q1.Reg = NREG
-			q1.To.Type_ = D_REG
+			q1.To.Type = D_REG
 			q1.To.Reg = REGTMP
 
 			/* SUB $8,SP */
 			q1 = obj.Appendp(ctxt, q1)
 
 			q1.As = AMOVW
-			q1.From.Type_ = D_REG
+			q1.From.Type = D_REG
 			q1.From.Reg = REGTMP
 			q1.Reg = NREG
-			q1.To.Type_ = D_OREG
+			q1.To.Type = D_OREG
 			q1.To.Reg = REGSP
 			q1.To.Offset = -8
 			q1.Scond |= C_WBIT
 			q1.Spadj = 8
 
 		case AMOVW:
-			if (p.Scond&C_WBIT != 0) && p.To.Type_ == D_OREG && p.To.Reg == REGSP {
+			if (p.Scond&C_WBIT != 0) && p.To.Type == D_OREG && p.To.Reg == REGSP {
 				p.Spadj = int32(-p.To.Offset)
 			}
-			if (p.Scond&C_PBIT != 0) && p.From.Type_ == D_OREG && p.From.Reg == REGSP && p.To.Reg != REGPC {
+			if (p.Scond&C_PBIT != 0) && p.From.Type == D_OREG && p.From.Reg == REGSP && p.To.Reg != REGPC {
 				p.Spadj = int32(-p.From.Offset)
 			}
-			if p.From.Type_ == D_CONST && p.From.Reg == REGSP && p.To.Type_ == D_REG && p.To.Reg == REGSP {
+			if p.From.Type == D_CONST && p.From.Reg == REGSP && p.To.Type == D_REG && p.To.Reg == REGSP {
 				p.Spadj = int32(-p.From.Offset)
 			}
 			break
@@ -754,7 +754,7 @@ func softfloat(ctxt *obj.Link, cursym *obj.LSym) {
 	for p = cursym.Text; p != nil; p = p.Link {
 		switch p.As {
 		case AMOVW:
-			if p.To.Type_ == D_FREG || p.From.Type_ == D_FREG {
+			if p.To.Type == D_FREG || p.From.Type == D_FREG {
 				goto soft
 			}
 			goto notsoft
@@ -797,7 +797,7 @@ func softfloat(ctxt *obj.Link, cursym *obj.LSym) {
 
 			p.Link = next
 			p.As = ABL
-			p.To.Type_ = D_BRANCH
+			p.To.Type = D_BRANCH
 			p.To.Sym = symsfloat
 			p.Lineno = next.Lineno
 
@@ -817,13 +817,13 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 	p = obj.Appendp(ctxt, p)
 
 	p.As = AMOVW
-	p.From.Type_ = D_OREG
+	p.From.Type = D_OREG
 	p.From.Reg = REGG
 	p.From.Offset = 2 * int64(ctxt.Arch.Ptrsize) // G.stackguard0
 	if ctxt.Cursym.Cfunc != 0 {
 		p.From.Offset = 3 * int64(ctxt.Arch.Ptrsize) // G.stackguard1
 	}
-	p.To.Type_ = D_REG
+	p.To.Type = D_REG
 	p.To.Reg = 1
 
 	if framesize <= obj.StackSmall {
@@ -832,7 +832,7 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 		p = obj.Appendp(ctxt, p)
 
 		p.As = ACMP
-		p.From.Type_ = D_REG
+		p.From.Type = D_REG
 		p.From.Reg = 1
 		p.Reg = REGSP
 	} else if framesize <= obj.StackBig {
@@ -842,15 +842,15 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 		p = obj.Appendp(ctxt, p)
 
 		p.As = AMOVW
-		p.From.Type_ = D_CONST
+		p.From.Type = D_CONST
 		p.From.Reg = REGSP
 		p.From.Offset = int64(-framesize)
-		p.To.Type_ = D_REG
+		p.To.Type = D_REG
 		p.To.Reg = 2
 
 		p = obj.Appendp(ctxt, p)
 		p.As = ACMP
-		p.From.Type_ = D_REG
+		p.From.Type = D_REG
 		p.From.Reg = 1
 		p.Reg = 2
 	} else {
@@ -868,38 +868,38 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 		p = obj.Appendp(ctxt, p)
 
 		p.As = ACMP
-		p.From.Type_ = D_CONST
+		p.From.Type = D_CONST
 		p.From.Offset = int64(uint32(obj.StackPreempt & (1<<32 - 1)))
 		p.Reg = 1
 
 		p = obj.Appendp(ctxt, p)
 		p.As = AMOVW
-		p.From.Type_ = D_CONST
+		p.From.Type = D_CONST
 		p.From.Reg = REGSP
 		p.From.Offset = obj.StackGuard
-		p.To.Type_ = D_REG
+		p.To.Type = D_REG
 		p.To.Reg = 2
 		p.Scond = C_SCOND_NE
 
 		p = obj.Appendp(ctxt, p)
 		p.As = ASUB
-		p.From.Type_ = D_REG
+		p.From.Type = D_REG
 		p.From.Reg = 1
-		p.To.Type_ = D_REG
+		p.To.Type = D_REG
 		p.To.Reg = 2
 		p.Scond = C_SCOND_NE
 
 		p = obj.Appendp(ctxt, p)
 		p.As = AMOVW
-		p.From.Type_ = D_CONST
+		p.From.Type = D_CONST
 		p.From.Offset = int64(framesize) + (obj.StackGuard - obj.StackSmall)
-		p.To.Type_ = D_REG
+		p.To.Type = D_REG
 		p.To.Reg = 3
 		p.Scond = C_SCOND_NE
 
 		p = obj.Appendp(ctxt, p)
 		p.As = ACMP
-		p.From.Type_ = D_REG
+		p.From.Type = D_REG
 		p.From.Reg = 3
 		p.Reg = 2
 		p.Scond = C_SCOND_NE
@@ -910,9 +910,9 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 
 	p.As = AMOVW
 	p.Scond = C_SCOND_LS
-	p.From.Type_ = D_REG
+	p.From.Type = D_REG
 	p.From.Reg = REGLINK
-	p.To.Type_ = D_REG
+	p.To.Type = D_REG
 	p.To.Reg = 3
 
 	// BL.LS		runtime.morestack(SB) // modifies LR, returns with LO still asserted
@@ -920,7 +920,7 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 
 	p.As = ABL
 	p.Scond = C_SCOND_LS
-	p.To.Type_ = D_BRANCH
+	p.To.Type = D_BRANCH
 	if ctxt.Cursym.Cfunc != 0 {
 		p.To.Sym = obj.Linklookup(ctxt, "runtime.morestackc", 0)
 	} else {
@@ -932,7 +932,7 @@ func stacksplit(ctxt *obj.Link, p *obj.Prog, framesize int32, noctxt int) *obj.P
 	p = obj.Appendp(ctxt, p)
 
 	p.As = ABLS
-	p.To.Type_ = D_BRANCH
+	p.To.Type = D_BRANCH
 	p.Pcond = ctxt.Cursym.Text.Link
 
 	return p
@@ -997,7 +997,7 @@ func relinv(a int) int {
 		return ABGT
 	}
 
-	log.Fatalf("unknown relation: %s", anames5[a])
+	log.Fatalf("unknown relation: %s", Anames[a])
 	return 0
 }
 
@@ -1086,7 +1086,7 @@ loop:
 		q = ctxt.Arch.Prg()
 		q.As = int16(a)
 		q.Lineno = p.Lineno
-		q.To.Type_ = D_BRANCH
+		q.To.Type = D_BRANCH
 		q.To.Offset = p.Pc
 		q.Pcond = p
 		p = q