cmd/compile: change Mp{int,flt} functions into methods

Also give them more idiomatic Go names. Adding godocs is outside the
scope of this CL. (Besides, the method names almost all directly
parallel an underlying math/big.Int or math/big.Float method.)

CL prepared mechanically with sed (for rewriting mpint.go/mpfloat.go)
and gofmt (for rewriting call sites).

Passes toolstash -cmp.

Change-Id: Id76f4aee476ba740f48db33162463e7978c2083d
Reviewed-on: https://go-review.googlesource.com/20909
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

src/cmd/compile/internal/gc/bexport.go

@@ -721,16 +721,16 @@ func (p *exporter) value(x Val) {
 		p.tag(tag)
 
 	case *Mpint:
-		if Mpcmpfixfix(Minintval[TINT64], x) <= 0 && Mpcmpfixfix(x, Maxintval[TINT64]) <= 0 {
+		if Minintval[TINT64].Cmp(x) <= 0 && x.Cmp(Maxintval[TINT64]) <= 0 {
 			// common case: x fits into an int64 - use compact encoding
 			p.tag(int64Tag)
-			p.int64(Mpgetfix(x))
+			p.int64(x.Int64())
 			return
 		}
 		// uncommon case: large x - use float encoding
 		// (powers of 2 will be encoded efficiently with exponent)
 		f := newMpflt()
-		Mpmovefixflt(f, x)
+		f.SetInt(x)
 		p.tag(floatTag)
 		p.float(f)
 

src/cmd/compile/internal/gc/bimport.go

@@ -484,7 +484,7 @@ func (p *importer) value(typ *Type) (x Val) {
 
 	case int64Tag:
 		u := new(Mpint)
-		Mpmovecfix(u, p.int64())
+		u.SetInt64(p.int64())
 		u.Rune = typ == idealrune
 		x.U = u
 
@@ -494,7 +494,7 @@ func (p *importer) value(typ *Type) (x Val) {
 		if typ == idealint || Isint[typ.Etype] {
 			// uncommon case: large int encoded as float
 			u := new(Mpint)
-			mpmovefltfix(u, f)
+			u.SetFloat(f)
 			x.U = u
 			break
 		}
@@ -530,7 +530,7 @@ func (p *importer) value(typ *Type) (x Val) {
 func (p *importer) float(x *Mpflt) {
 	sign := p.int()
 	if sign == 0 {
-		Mpmovecflt(x, 0)
+		x.SetFloat64(0)
 		return
 	}
 

src/cmd/compile/internal/gc/cgen.go

@@ -1033,7 +1033,7 @@ func Agenr(n *Node, a *Node, res *Node) {
 				if Isconst(nl, CTSTR) {
 					Fatalf("constant string constant index")
 				}
-				v := uint64(Mpgetfix(nr.Val().U.(*Mpint)))
+				v := uint64(nr.Val().U.(*Mpint).Int64())
 				var n2 Node
 				if Isslice(nl.Type) || nl.Type.Etype == TSTRING {
 					if Debug['B'] == 0 && !n.Bounded {
@@ -1185,7 +1185,7 @@ func Agenr(n *Node, a *Node, res *Node) {
 				if Isconst(nl, CTSTR) {
 					Fatalf("constant string constant index") // front end should handle
 				}
-				v := uint64(Mpgetfix(nr.Val().U.(*Mpint)))
+				v := uint64(nr.Val().U.(*Mpint).Int64())
 				if Isslice(nl.Type) || nl.Type.Etype == TSTRING {
 					if Debug['B'] == 0 && !n.Bounded {
 						nlen := n3
@@ -1375,7 +1375,7 @@ func Agenr(n *Node, a *Node, res *Node) {
 			if Isconst(nl, CTSTR) {
 				Fatalf("constant string constant index") // front end should handle
 			}
-			v := uint64(Mpgetfix(nr.Val().U.(*Mpint)))
+			v := uint64(nr.Val().U.(*Mpint).Int64())
 			if Isslice(nl.Type) || nl.Type.Etype == TSTRING {
 				if Debug['B'] == 0 && !n.Bounded {
 					p1 := Thearch.Ginscmp(OGT, Types[Simtype[TUINT]], &nlen, Nodintconst(int64(v)), +1)
@@ -1709,7 +1709,7 @@ func Igen(n *Node, a *Node, res *Node) {
 				// Compute &a[i] as &a + i*width.
 				a.Type = n.Type
 
-				a.Xoffset += Mpgetfix(n.Right.Val().U.(*Mpint)) * n.Type.Width
+				a.Xoffset += n.Right.Val().U.(*Mpint).Int64() * n.Type.Width
 				Fixlargeoffset(a)
 				return
 			}
@@ -2215,7 +2215,7 @@ func stkof(n *Node) int64 {
 			return off
 		}
 		if Isconst(n.Right, CTINT) {
-			return off + t.Type.Width*Mpgetfix(n.Right.Val().U.(*Mpint))
+			return off + t.Type.Width*n.Right.Val().U.(*Mpint).Int64()
 		}
 		return +1000 // on stack but not sure exactly where
 
@@ -2646,7 +2646,7 @@ func cgen_div(op Op, nl *Node, nr *Node, res *Node) {
 	case TUINT64:
 		var m Magic
 		m.W = w
-		m.Ud = uint64(Mpgetfix(nr.Val().U.(*Mpint)))
+		m.Ud = uint64(nr.Val().U.(*Mpint).Int64())
 		Umagic(&m)
 		if m.Bad != 0 {
 			break
@@ -2684,7 +2684,7 @@ func cgen_div(op Op, nl *Node, nr *Node, res *Node) {
 	case TINT64:
 		var m Magic
 		m.W = w
-		m.Sd = Mpgetfix(nr.Val().U.(*Mpint))
+		m.Sd = nr.Val().U.(*Mpint).Int64()
 		Smagic(&m)
 		if m.Bad != 0 {
 			break
@@ -3189,17 +3189,17 @@ func cgen_slice(n, res *Node, wb bool) {
 		bound = int64(len(n.Left.Val().U.(string)))
 	}
 	if Isconst(&i, CTINT) {
-		if mpcmpfixc(i.Val().U.(*Mpint), 0) < 0 || bound >= 0 && mpcmpfixc(i.Val().U.(*Mpint), bound) > 0 {
+		if i.Val().U.(*Mpint).CmpInt64(0) < 0 || bound >= 0 && i.Val().U.(*Mpint).CmpInt64(bound) > 0 {
 			Yyerror("slice index out of bounds")
 		}
 	}
 	if Isconst(&j, CTINT) {
-		if mpcmpfixc(j.Val().U.(*Mpint), 0) < 0 || bound >= 0 && mpcmpfixc(j.Val().U.(*Mpint), bound) > 0 {
+		if j.Val().U.(*Mpint).CmpInt64(0) < 0 || bound >= 0 && j.Val().U.(*Mpint).CmpInt64(bound) > 0 {
 			Yyerror("slice index out of bounds")
 		}
 	}
 	if Isconst(&k, CTINT) {
-		if mpcmpfixc(k.Val().U.(*Mpint), 0) < 0 || bound >= 0 && mpcmpfixc(k.Val().U.(*Mpint), bound) > 0 {
+		if k.Val().U.(*Mpint).CmpInt64(0) < 0 || bound >= 0 && k.Val().U.(*Mpint).CmpInt64(bound) > 0 {
 			Yyerror("slice index out of bounds")
 		}
 	}
@@ -3208,7 +3208,7 @@ func cgen_slice(n, res *Node, wb bool) {
 	same := func(n1, n2 *Node) bool {
 		return n1.Op == OREGISTER && n2.Op == OREGISTER && n1.Reg == n2.Reg ||
 			n1.Op == ONAME && n2.Op == ONAME && n1.Orig == n2.Orig && n1.Type == n2.Type && n1.Xoffset == n2.Xoffset ||
-			n1.Op == OLITERAL && n2.Op == OLITERAL && Mpcmpfixfix(n1.Val().U.(*Mpint), n2.Val().U.(*Mpint)) == 0
+			n1.Op == OLITERAL && n2.Op == OLITERAL && n1.Val().U.(*Mpint).Cmp(n2.Val().U.(*Mpint)) == 0
 	}
 
 	// obvious reports whether n1 <= n2 is obviously true,
@@ -3227,7 +3227,7 @@ func cgen_slice(n, res *Node, wb bool) {
 			return true // len(x) <= cap(x) always true
 		}
 		if Isconst(n1, CTINT) && Isconst(n2, CTINT) {
-			if Mpcmpfixfix(n1.Val().U.(*Mpint), n2.Val().U.(*Mpint)) <= 0 {
+			if n1.Val().U.(*Mpint).Cmp(n2.Val().U.(*Mpint)) <= 0 {
 				return true // n1, n2 constants such that n1 <= n2
 			}
 			Yyerror("slice index out of bounds")
@@ -3240,11 +3240,11 @@ func cgen_slice(n, res *Node, wb bool) {
 		// n1 might be a 64-bit constant, even on 32-bit architectures,
 		// but it will be represented in 32 bits.
 		if Ctxt.Arch.Regsize == 4 && Is64(n1.Type) {
-			if mpcmpfixc(n1.Val().U.(*Mpint), 1<<31) >= 0 {
+			if n1.Val().U.(*Mpint).CmpInt64(1<<31) >= 0 {
 				Fatalf("missed slice out of bounds check")
 			}
 			var tmp Node
-			Nodconst(&tmp, indexRegType, Mpgetfix(n1.Val().U.(*Mpint)))
+			Nodconst(&tmp, indexRegType, n1.Val().U.(*Mpint).Int64())
 			n1 = &tmp
 		}
 		p := Thearch.Ginscmp(OGT, indexRegType, n1, n2, -1)
@@ -3328,9 +3328,9 @@ func cgen_slice(n, res *Node, wb bool) {
 			switch j.Op {
 			case OLITERAL:
 				if Isconst(&i, CTINT) {
-					Nodconst(&j, indexRegType, Mpgetfix(j.Val().U.(*Mpint))-Mpgetfix(i.Val().U.(*Mpint)))
+					Nodconst(&j, indexRegType, j.Val().U.(*Mpint).Int64()-i.Val().U.(*Mpint).Int64())
 					if Debug_slice > 0 {
-						Warn("slice: result len == %d", Mpgetfix(j.Val().U.(*Mpint)))
+						Warn("slice: result len == %d", j.Val().U.(*Mpint).Int64())
 					}
 					break
 				}
@@ -3345,7 +3345,7 @@ func cgen_slice(n, res *Node, wb bool) {
 				fallthrough
 			case OREGISTER:
 				if i.Op == OLITERAL {
-					v := Mpgetfix(i.Val().U.(*Mpint))
+					v := i.Val().U.(*Mpint).Int64()
 					if v != 0 {
 						ginscon(Thearch.Optoas(OSUB, indexRegType), v, &j)
 					}
@@ -3388,9 +3388,9 @@ func cgen_slice(n, res *Node, wb bool) {
 			switch k.Op {
 			case OLITERAL:
 				if Isconst(&i, CTINT) {
-					Nodconst(&k, indexRegType, Mpgetfix(k.Val().U.(*Mpint))-Mpgetfix(i.Val().U.(*Mpint)))
+					Nodconst(&k, indexRegType, k.Val().U.(*Mpint).Int64()-i.Val().U.(*Mpint).Int64())
 					if Debug_slice > 0 {
-						Warn("slice: result cap == %d", Mpgetfix(k.Val().U.(*Mpint)))
+						Warn("slice: result cap == %d", k.Val().U.(*Mpint).Int64())
 					}
 					break
 				}
@@ -3411,7 +3411,7 @@ func cgen_slice(n, res *Node, wb bool) {
 						Warn("slice: result cap == 0")
 					}
 				} else if i.Op == OLITERAL {
-					v := Mpgetfix(i.Val().U.(*Mpint))
+					v := i.Val().U.(*Mpint).Int64()
 					if v != 0 {
 						ginscon(Thearch.Optoas(OSUB, indexRegType), v, &k)
 					}
@@ -3494,7 +3494,7 @@ func cgen_slice(n, res *Node, wb bool) {
 				w = res.Type.Type.Width // res is []T, elem size is T.width
 			}
 			if Isconst(&i, CTINT) {
-				ginscon(Thearch.Optoas(OADD, xbase.Type), Mpgetfix(i.Val().U.(*Mpint))*w, &xbase)
+				ginscon(Thearch.Optoas(OADD, xbase.Type), i.Val().U.(*Mpint).Int64()*w, &xbase)
 			} else if Thearch.AddIndex != nil && Thearch.AddIndex(&i, w, &xbase) {
 				// done by back end
 			} else if w == 1 {

src/cmd/compile/internal/gc/fmt.go

@@ -335,7 +335,7 @@ func Vconv(v Val, flag FmtFlag) string {
 		return Bconv(v.U.(*Mpint), 0)
 
 	case CTRUNE:
-		x := Mpgetfix(v.U.(*Mpint))
+		x := v.U.(*Mpint).Int64()
 		if ' ' <= x && x < 0x80 && x != '\\' && x != '\'' {
 			return fmt.Sprintf("'%c'", int(x))
 		}
@@ -357,13 +357,13 @@ func Vconv(v Val, flag FmtFlag) string {
 		if (flag&FmtSharp != 0) || fmtmode == FExp {
 			return fmt.Sprintf("(%v+%vi)", &v.U.(*Mpcplx).Real, &v.U.(*Mpcplx).Imag)
 		}
-		if mpcmpfltc(&v.U.(*Mpcplx).Real, 0) == 0 {
+		if v.U.(*Mpcplx).Real.CmpFloat64(0) == 0 {
 			return fmt.Sprintf("%vi", Fconv(&v.U.(*Mpcplx).Imag, FmtSharp))
 		}
-		if mpcmpfltc(&v.U.(*Mpcplx).Imag, 0) == 0 {
+		if v.U.(*Mpcplx).Imag.CmpFloat64(0) == 0 {
 			return Fconv(&v.U.(*Mpcplx).Real, FmtSharp)
 		}
-		if mpcmpfltc(&v.U.(*Mpcplx).Imag, 0) < 0 {
+		if v.U.(*Mpcplx).Imag.CmpFloat64(0) < 0 {
 			return fmt.Sprintf("(%v%vi)", Fconv(&v.U.(*Mpcplx).Real, FmtSharp), Fconv(&v.U.(*Mpcplx).Imag, FmtSharp))
 		}
 		return fmt.Sprintf("(%v+%vi)", Fconv(&v.U.(*Mpcplx).Real, FmtSharp), Fconv(&v.U.(*Mpcplx).Imag, FmtSharp))

src/cmd/compile/internal/gc/gen.go

@@ -319,12 +319,12 @@ func Clearslim(n *Node) {
 	switch Simtype[n.Type.Etype] {
 	case TCOMPLEX64, TCOMPLEX128:
 		z.SetVal(Val{new(Mpcplx)})
-		Mpmovecflt(&z.Val().U.(*Mpcplx).Real, 0.0)
-		Mpmovecflt(&z.Val().U.(*Mpcplx).Imag, 0.0)
+		z.Val().U.(*Mpcplx).Real.SetFloat64(0.0)
+		z.Val().U.(*Mpcplx).Imag.SetFloat64(0.0)
 
 	case TFLOAT32, TFLOAT64:
 		var zero Mpflt
-		Mpmovecflt(&zero, 0.0)
+		zero.SetFloat64(0.0)
 		z.SetVal(Val{&zero})
 
 	case TPTR32, TPTR64, TCHAN, TMAP:
@@ -342,7 +342,7 @@ func Clearslim(n *Node) {
 		TUINT32,
 		TUINT64:
 		z.SetVal(Val{new(Mpint)})
-		Mpmovecfix(z.Val().U.(*Mpint), 0)
+		z.Val().U.(*Mpint).SetInt64(0)
 
 	default:
 		Fatalf("clearslim called on type %v", n.Type)

src/cmd/compile/internal/gc/gsubr.go

@@ -433,12 +433,12 @@ func Naddr(a *obj.Addr, n *Node) {
 
 		case CTFLT:
 			a.Type = obj.TYPE_FCONST
-			a.Val = mpgetflt(n.Val().U.(*Mpflt))
+			a.Val = n.Val().U.(*Mpflt).Float64()
 
 		case CTINT, CTRUNE:
 			a.Sym = nil
 			a.Type = obj.TYPE_CONST
-			a.Offset = Mpgetfix(n.Val().U.(*Mpint))
+			a.Offset = n.Val().U.(*Mpint).Int64()
 
 		case CTSTR:
 			datagostring(n.Val().U.(string), a)

src/cmd/compile/internal/gc/lex.go

@@ -687,11 +687,11 @@ func (l *lexer) number(c rune) {
 		if c == 'i' {
 			str = lexbuf.String()
 			x := new(Mpcplx)
-			Mpmovecflt(&x.Real, 0.0)
-			mpatoflt(&x.Imag, str)
+			x.Real.SetFloat64(0.0)
+			x.Imag.SetString(str)
 			if x.Imag.Val.IsInf() {
 				Yyerror("overflow in imaginary constant")
-				Mpmovecflt(&x.Imag, 0.0)
+				x.Imag.SetFloat64(0.0)
 			}
 			l.val.U = x
 
@@ -711,10 +711,10 @@ func (l *lexer) number(c rune) {
 
 		str = lexbuf.String()
 		x := new(Mpint)
-		mpatofix(x, str)
+		x.SetString(str)
 		if x.Ovf {
 			Yyerror("overflow in constant")
-			Mpmovecfix(x, 0)
+			x.SetInt64(0)
 		}
 		l.val.U = x
 
@@ -726,10 +726,10 @@ func (l *lexer) number(c rune) {
 
 		str = lexbuf.String()
 		x := newMpflt()
-		mpatoflt(x, str)
+		x.SetString(str)
 		if x.Val.IsInf() {
 			Yyerror("overflow in float constant")
-			Mpmovecflt(x, 0.0)
+			x.SetFloat64(0.0)
 		}
 		l.val.U = x
 
@@ -820,7 +820,7 @@ func (l *lexer) rune() {
 
 	x := new(Mpint)
 	l.val.U = x
-	Mpmovecfix(x, int64(r))
+	x.SetInt64(int64(r))
 	x.Rune = true
 	if Debug['x'] != 0 {
 		fmt.Printf("lex: codepoint literal\n")

src/cmd/compile/internal/gc/mpfloat.go

@@ -37,7 +37,7 @@ func newMpflt() *Mpflt {
 	return &a
 }
 
-func Mpmovefixflt(a *Mpflt, b *Mpint) {
+func (a *Mpflt) SetInt(b *Mpint) {
 	if b.Ovf {
 		// sign doesn't really matter but copy anyway
 		a.Val.SetInf(b.Val.Sign() < 0)
@@ -46,11 +46,11 @@ func Mpmovefixflt(a *Mpflt, b *Mpint) {
 	a.Val.SetInt(&b.Val)
 }
 
-func mpmovefltflt(a *Mpflt, b *Mpflt) {
+func (a *Mpflt) Set(b *Mpflt) {
 	a.Val.Set(&b.Val)
 }
 
-func mpaddfltflt(a *Mpflt, b *Mpflt) {
+func (a *Mpflt) Add(b *Mpflt) {
 	if Mpdebug {
 		fmt.Printf("\n%v + %v", a, b)
 	}
@@ -62,14 +62,14 @@ func mpaddfltflt(a *Mpflt, b *Mpflt) {
 	}
 }
 
-func mpaddcflt(a *Mpflt, c float64) {
+func (a *Mpflt) AddFloat64(c float64) {
 	var b Mpflt
 
-	Mpmovecflt(&b, c)
-	mpaddfltflt(a, &b)
+	b.SetFloat64(c)
+	a.Add(&b)
 }
 
-func mpsubfltflt(a *Mpflt, b *Mpflt) {
+func (a *Mpflt) Sub(b *Mpflt) {
 	if Mpdebug {
 		fmt.Printf("\n%v - %v", a, b)
 	}
@@ -81,7 +81,7 @@ func mpsubfltflt(a *Mpflt, b *Mpflt) {
 	}
 }
 
-func mpmulfltflt(a *Mpflt, b *Mpflt) {
+func (a *Mpflt) Mul(b *Mpflt) {
 	if Mpdebug {
 		fmt.Printf("%v\n * %v\n", a, b)
 	}
@@ -93,14 +93,14 @@ func mpmulfltflt(a *Mpflt, b *Mpflt) {
 	}
 }
 
-func mpmulcflt(a *Mpflt, c float64) {
+func (a *Mpflt) MulFloat64(c float64) {
 	var b Mpflt
 
-	Mpmovecflt(&b, c)
-	mpmulfltflt(a, &b)
+	b.SetFloat64(c)
+	a.Mul(&b)
 }
 
-func mpdivfltflt(a *Mpflt, b *Mpflt) {
+func (a *Mpflt) Quo(b *Mpflt) {
 	if Mpdebug {
 		fmt.Printf("%v\n / %v\n", a, b)
 	}
@@ -112,18 +112,18 @@ func mpdivfltflt(a *Mpflt, b *Mpflt) {
 	}
 }
 
-func mpcmpfltflt(a *Mpflt, b *Mpflt) int {
+func (a *Mpflt) Cmp(b *Mpflt) int {
 	return a.Val.Cmp(&b.Val)
 }
 
-func mpcmpfltc(b *Mpflt, c float64) int {
+func (b *Mpflt) CmpFloat64(c float64) int {
 	var a Mpflt
 
-	Mpmovecflt(&a, c)
-	return mpcmpfltflt(b, &a)
+	a.SetFloat64(c)
+	return b.Cmp(&a)
 }
 
-func mpgetflt(a *Mpflt) float64 {
+func (a *Mpflt) Float64() float64 {
 	x, _ := a.Val.Float64()
 
 	// check for overflow
@@ -134,7 +134,7 @@ func mpgetflt(a *Mpflt) float64 {
 	return x + 0 // avoid -0 (should not be needed, but be conservative)
 }
 
-func mpgetflt32(a *Mpflt) float64 {
+func (a *Mpflt) Float32() float64 {
 	x32, _ := a.Val.Float32()
 	x := float64(x32)
 
@@ -146,7 +146,7 @@ func mpgetflt32(a *Mpflt) float64 {
 	return x + 0 // avoid -0 (should not be needed, but be conservative)
 }
 
-func Mpmovecflt(a *Mpflt, c float64) {
+func (a *Mpflt) SetFloat64(c float64) {
 	if Mpdebug {
 		fmt.Printf("\nconst %g", c)
 	}
@@ -162,7 +162,7 @@ func Mpmovecflt(a *Mpflt, c float64) {
 	}
 }
 
-func mpnegflt(a *Mpflt) {
+func (a *Mpflt) Neg() {
 	// avoid -0
 	if a.Val.Sign() != 0 {
 		a.Val.Neg(&a.Val)
@@ -173,7 +173,7 @@ func mpnegflt(a *Mpflt) {
 // floating point input
 // required syntax is [+-]d*[.]d*[e[+-]d*] or [+-]0xH*[e[+-]d*]
 //
-func mpatoflt(a *Mpflt, as string) {
+func (a *Mpflt) SetString(as string) {
 	for len(as) > 0 && (as[0] == ' ' || as[0] == '\t') {
 		as = as[1:]
 	}

src/cmd/compile/internal/gc/mpint.go

@@ -18,25 +18,25 @@ type Mpint struct {
 	Rune bool // set if syntax indicates default type rune
 }
 
-func mpsetovf(a *Mpint) {
+func (a *Mpint) SetOverflow() {
 	a.Val.SetUint64(1) // avoid spurious div-zero errors
 	a.Ovf = true
 }
 
-func mptestovf(a *Mpint, extra int) bool {
+func (a *Mpint) checkOverflow(extra int) bool {
 	// We don't need to be precise here, any reasonable upper limit would do.
 	// For now, use existing limit so we pass all the tests unchanged.
 	if a.Val.BitLen()+extra > Mpprec {
-		mpsetovf(a)
+		a.SetOverflow()
 	}
 	return a.Ovf
 }
 
-func mpmovefixfix(a, b *Mpint) {
+func (a *Mpint) Set(b *Mpint) {
 	a.Val.Set(&b.Val)
 }
 
-func mpmovefltfix(a *Mpint, b *Mpflt) int {
+func (a *Mpint) SetFloat(b *Mpflt) int {
 	// avoid converting huge floating-point numbers to integers
 	// (2*Mpprec is large enough to permit all tests to pass)
 	if b.Val.MantExp(nil) > 2*Mpprec {
@@ -68,130 +68,130 @@ func mpmovefltfix(a *Mpint, b *Mpflt) int {
 	return -1
 }
 
-func mpaddfixfix(a, b *Mpint, quiet int) {
+func (a *Mpint) Add(b *Mpint, quiet int) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpaddfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.Add(&a.Val, &b.Val)
 
-	if mptestovf(a, 0) && quiet == 0 {
+	if a.checkOverflow(0) && quiet == 0 {
 		Yyerror("constant addition overflow")
 	}
 }
 
-func mpsubfixfix(a, b *Mpint) {
+func (a *Mpint) Sub(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpsubfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.Sub(&a.Val, &b.Val)
 
-	if mptestovf(a, 0) {
+	if a.checkOverflow(0) {
 		Yyerror("constant subtraction overflow")
 	}
 }
 
-func mpmulfixfix(a, b *Mpint) {
+func (a *Mpint) Mul(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpmulfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.Mul(&a.Val, &b.Val)
 
-	if mptestovf(a, 0) {
+	if a.checkOverflow(0) {
 		Yyerror("constant multiplication overflow")
 	}
 }
 
-func mpdivfixfix(a, b *Mpint) {
+func (a *Mpint) Quo(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpdivfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.Quo(&a.Val, &b.Val)
 
-	if mptestovf(a, 0) {
+	if a.checkOverflow(0) {
 		// can only happen for div-0 which should be checked elsewhere
 		Yyerror("constant division overflow")
 	}
 }
 
-func mpmodfixfix(a, b *Mpint) {
+func (a *Mpint) Rem(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpmodfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.Rem(&a.Val, &b.Val)
 
-	if mptestovf(a, 0) {
+	if a.checkOverflow(0) {
 		// should never happen
 		Yyerror("constant modulo overflow")
 	}
 }
 
-func mporfixfix(a, b *Mpint) {
+func (a *Mpint) Or(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mporfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.Or(&a.Val, &b.Val)
 }
 
-func mpandfixfix(a, b *Mpint) {
+func (a *Mpint) And(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpandfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.And(&a.Val, &b.Val)
 }
 
-func mpandnotfixfix(a, b *Mpint) {
+func (a *Mpint) AndNot(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpandnotfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
 	a.Val.AndNot(&a.Val, &b.Val)
 }
 
-func mpxorfixfix(a, b *Mpint) {
+func (a *Mpint) Xor(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mpxorfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
@@ -199,10 +199,10 @@ func mpxorfixfix(a, b *Mpint) {
 }
 
 // shift left by s (or right by -s)
-func Mpshiftfix(a *Mpint, s int) {
+func (a *Mpint) shift(s int) {
 	switch {
 	case s > 0:
-		if mptestovf(a, s) {
+		if a.checkOverflow(s) {
 			Yyerror("constant shift overflow")
 			return
 		}
@@ -212,65 +212,65 @@ func Mpshiftfix(a *Mpint, s int) {
 	}
 }
 
-func mplshfixfix(a, b *Mpint) {
+func (a *Mpint) Lsh(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mplshfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
-	s := Mpgetfix(b)
+	s := b.Int64()
 	if s < 0 || s >= Mpprec {
 		msg := "shift count too large"
 		if s < 0 {
 			msg = "invalid negative shift count"
 		}
 		Yyerror("%s: %d", msg, s)
-		Mpmovecfix(a, 0)
+		a.SetInt64(0)
 		return
 	}
 
-	Mpshiftfix(a, int(s))
+	a.shift(int(s))
 }
 
-func mprshfixfix(a, b *Mpint) {
+func (a *Mpint) Rsh(b *Mpint) {
 	if a.Ovf || b.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("ovf in mprshfixfix")
 		}
-		mpsetovf(a)
+		a.SetOverflow()
 		return
 	}
 
-	s := Mpgetfix(b)
+	s := b.Int64()
 	if s < 0 {
 		Yyerror("invalid negative shift count: %d", s)
 		if a.Val.Sign() < 0 {
-			Mpmovecfix(a, -1)
+			a.SetInt64(-1)
 		} else {
-			Mpmovecfix(a, 0)
+			a.SetInt64(0)
 		}
 		return
 	}
 
-	Mpshiftfix(a, int(-s))
+	a.shift(int(-s))
 }
 
-func Mpcmpfixfix(a, b *Mpint) int {
+func (a *Mpint) Cmp(b *Mpint) int {
 	return a.Val.Cmp(&b.Val)
 }
 
-func mpcmpfixc(b *Mpint, c int64) int {
+func (b *Mpint) CmpInt64(c int64) int {
 	return b.Val.Cmp(big.NewInt(c))
 }
 
-func mpnegfix(a *Mpint) {
+func (a *Mpint) Neg() {
 	a.Val.Neg(&a.Val)
 }
 
-func Mpgetfix(a *Mpint) int64 {
+func (a *Mpint) Int64() int64 {
 	if a.Ovf {
 		if nsavederrors+nerrors == 0 {
 			Yyerror("constant overflow")
@@ -281,11 +281,11 @@ func Mpgetfix(a *Mpint) int64 {
 	return a.Val.Int64()
 }
 
-func Mpmovecfix(a *Mpint, c int64) {
+func (a *Mpint) SetInt64(c int64) {
 	a.Val.SetInt64(c)
 }
 
-func mpatofix(a *Mpint, as string) {
+func (a *Mpint) SetString(as string) {
 	_, ok := a.Val.SetString(as, 0)
 	if !ok {
 		// required syntax is [+-][0[x]]d*
@@ -299,7 +299,7 @@ func mpatofix(a *Mpint, as string) {
 		a.Val.SetUint64(0)
 		return
 	}
-	if mptestovf(a, 0) {
+	if a.checkOverflow(0) {
 		Yyerror("constant too large: %s", as)
 	}
 }

src/cmd/compile/internal/gc/obj.go

@@ -343,7 +343,7 @@ func gdata(nam *Node, nr *Node, wid int) {
 
 		case CTFLT:
 			s := Linksym(nam.Sym)
-			f := mpgetflt(nr.Val().U.(*Mpflt))
+			f := nr.Val().U.(*Mpflt).Float64()
 			switch nam.Type.Etype {
 			case TFLOAT32:
 				s.WriteFloat32(Ctxt, nam.Xoffset, float32(f))
@@ -375,8 +375,8 @@ func gdata(nam *Node, nr *Node, wid int) {
 
 func gdatacomplex(nam *Node, cval *Mpcplx) {
 	t := Types[cplxsubtype(nam.Type.Etype)]
-	r := mpgetflt(&cval.Real)
-	i := mpgetflt(&cval.Imag)
+	r := cval.Real.Float64()
+	i := cval.Imag.Float64()
 	s := Linksym(nam.Sym)
 
 	switch t.Etype {

src/cmd/compile/internal/gc/parser.go

@@ -3269,14 +3269,14 @@ func (p *parser) hidden_literal() *Node {
 			p.next()
 			switch ss.Val().Ctype() {
 			case CTINT, CTRUNE:
-				mpnegfix(ss.Val().U.(*Mpint))
+				ss.Val().U.(*Mpint).Neg()
 				break
 			case CTFLT:
-				mpnegflt(ss.Val().U.(*Mpflt))
+				ss.Val().U.(*Mpflt).Neg()
 				break
 			case CTCPLX:
-				mpnegflt(&ss.Val().U.(*Mpcplx).Real)
-				mpnegflt(&ss.Val().U.(*Mpcplx).Imag)
+				ss.Val().U.(*Mpcplx).Real.Neg()
+				ss.Val().U.(*Mpcplx).Imag.Neg()
 				break
 			default:
 				Yyerror("bad negated constant")
@@ -3318,11 +3318,11 @@ func (p *parser) hidden_constant() *Node {
 
 		if s2.Val().Ctype() == CTRUNE && s4.Val().Ctype() == CTINT {
 			ss := s2
-			mpaddfixfix(s2.Val().U.(*Mpint), s4.Val().U.(*Mpint), 0)
+			s2.Val().U.(*Mpint).Add(s4.Val().U.(*Mpint), 0)
 			return ss
 		}
 		s4.Val().U.(*Mpcplx).Real = s4.Val().U.(*Mpcplx).Imag
-		Mpmovecflt(&s4.Val().U.(*Mpcplx).Imag, 0.0)
+		s4.Val().U.(*Mpcplx).Imag.SetFloat64(0.0)
 		return nodcplxlit(s2.Val(), s4.Val())
 	}
 }

src/cmd/compile/internal/gc/sinit.go

@@ -436,7 +436,7 @@ func staticassign(l *Node, r *Node, out *[]*Node) bool {
 			ta := typ(TARRAY)
 
 			ta.Type = r.Type.Type
-			ta.Bound = Mpgetfix(r.Right.Val().U.(*Mpint))
+			ta.Bound = r.Right.Val().U.(*Mpint).Int64()
 			a := staticname(ta, 1)
 			inittemps[r] = a
 			n := *l
@@ -691,7 +691,7 @@ func arraylit(ctxt int, pass int, n *Node, var_ *Node, init *Nodes) {
 func slicelit(ctxt int, n *Node, var_ *Node, init *Nodes) {
 	// make an array type
 	t := n.Type.Copy()
-	t.Bound = Mpgetfix(n.Right.Val().U.(*Mpint))
+	t.Bound = n.Right.Val().U.(*Mpint).Int64()
 	t.Width = 0
 	t.Sym = nil
 	t.Haspointers = 0
@@ -1178,7 +1178,7 @@ func oaslit(n *Node, init *Nodes) bool {
 
 func getlit(lit *Node) int {
 	if Smallintconst(lit) {
-		return int(Mpgetfix(lit.Val().U.(*Mpint)))
+		return int(lit.Val().U.(*Mpint).Int64())
 	}
 	return -1
 }
@@ -1241,7 +1241,7 @@ func initplan(n *Node) {
 			if a.Op != OKEY || !Smallintconst(a.Left) {
 				Fatalf("initplan arraylit")
 			}
-			addvalue(p, n.Type.Type.Width*Mpgetfix(a.Left.Val().U.(*Mpint)), a.Right)
+			addvalue(p, n.Type.Type.Width*a.Left.Val().U.(*Mpint).Int64(), a.Right)
 		}
 
 	case OSTRUCTLIT:
@@ -1302,13 +1302,13 @@ func iszero(n *Node) bool {
 			return !n.Val().U.(bool)
 
 		case CTINT, CTRUNE:
-			return mpcmpfixc(n.Val().U.(*Mpint), 0) == 0
+			return n.Val().U.(*Mpint).CmpInt64(0) == 0
 
 		case CTFLT:
-			return mpcmpfltc(n.Val().U.(*Mpflt), 0) == 0
+			return n.Val().U.(*Mpflt).CmpFloat64(0) == 0
 
 		case CTCPLX:
-			return mpcmpfltc(&n.Val().U.(*Mpcplx).Real, 0) == 0 && mpcmpfltc(&n.Val().U.(*Mpcplx).Imag, 0) == 0
+			return n.Val().U.(*Mpcplx).Real.CmpFloat64(0) == 0 && n.Val().U.(*Mpcplx).Imag.CmpFloat64(0) == 0
 		}
 
 	case OARRAYLIT:

src/cmd/compile/internal/gc/ssa.go

@@ -1379,7 +1379,7 @@ func (s *state) expr(n *Node) *ssa.Value {
 	case OLITERAL:
 		switch n.Val().Ctype() {
 		case CTINT:
-			i := Mpgetfix(n.Val().U.(*Mpint))
+			i := n.Val().U.(*Mpint).Int64()
 			switch n.Type.Size() {
 			case 1:
 				return s.constInt8(n.Type, int8(i))
@@ -1421,9 +1421,9 @@ func (s *state) expr(n *Node) *ssa.Value {
 			f := n.Val().U.(*Mpflt)
 			switch n.Type.Size() {
 			case 4:
-				return s.constFloat32(n.Type, mpgetflt32(f))
+				return s.constFloat32(n.Type, f.Float32())
 			case 8:
-				return s.constFloat64(n.Type, mpgetflt(f))
+				return s.constFloat64(n.Type, f.Float64())
 			default:
 				s.Fatalf("bad float size %d", n.Type.Size())
 				return nil
@@ -1437,15 +1437,15 @@ func (s *state) expr(n *Node) *ssa.Value {
 				{
 					pt := Types[TFLOAT32]
 					return s.newValue2(ssa.OpComplexMake, n.Type,
-						s.constFloat32(pt, mpgetflt32(r)),
-						s.constFloat32(pt, mpgetflt32(i)))
+						s.constFloat32(pt, r.Float32()),
+						s.constFloat32(pt, i.Float32()))
 				}
 			case 16:
 				{
 					pt := Types[TFLOAT64]
 					return s.newValue2(ssa.OpComplexMake, n.Type,
-						s.constFloat64(pt, mpgetflt(r)),
-						s.constFloat64(pt, mpgetflt(i)))
+						s.constFloat64(pt, r.Float64()),
+						s.constFloat64(pt, i.Float64()))
 				}
 			default:
 				s.Fatalf("bad float size %d", n.Type.Size())

src/cmd/compile/internal/gc/subr.go

@@ -438,7 +438,7 @@ func Nodintconst(v int64) *Node {
 	c := Nod(OLITERAL, nil, nil)
 	c.Addable = true
 	c.SetVal(Val{new(Mpint)})
-	Mpmovecfix(c.Val().U.(*Mpint), v)
+	c.Val().U.(*Mpint).SetInt64(v)
 	c.Type = Types[TIDEAL]
 	ullmancalc(c)
 	return c
@@ -448,7 +448,7 @@ func nodfltconst(v *Mpflt) *Node {
 	c := Nod(OLITERAL, nil, nil)
 	c.Addable = true
 	c.SetVal(Val{newMpflt()})
-	mpmovefltflt(c.Val().U.(*Mpflt), v)
+	c.Val().U.(*Mpflt).Set(v)
 	c.Type = Types[TIDEAL]
 	ullmancalc(c)
 	return c
@@ -460,7 +460,7 @@ func Nodconst(n *Node, t *Type, v int64) {
 	n.Addable = true
 	ullmancalc(n)
 	n.SetVal(Val{new(Mpint)})
-	Mpmovecfix(n.Val().U.(*Mpint), v)
+	n.Val().U.(*Mpint).SetInt64(v)
 	n.Type = t
 
 	if Isfloat[t.Etype] {
@@ -491,7 +491,7 @@ func aindex(b *Node, t *Type) *Type {
 			Yyerror("array bound must be an integer expression")
 
 		case CTINT, CTRUNE:
-			bound = Mpgetfix(b.Val().U.(*Mpint))
+			bound = b.Val().U.(*Mpint).Int64()
 			if bound < 0 {
 				Yyerror("array bound must be non negative")
 			}
@@ -2198,7 +2198,7 @@ func powtwo(n *Node) int {
 		return -1
 	}
 
-	v := uint64(Mpgetfix(n.Val().U.(*Mpint)))
+	v := uint64(n.Val().U.(*Mpint).Int64())
 	b := uint64(1)
 	for i := 0; i < 64; i++ {
 		if b == v {

src/cmd/compile/internal/gc/swt.go

@@ -795,9 +795,9 @@ func exprcmp(c1, c2 *caseClause) int {
 	// sort by constant value to enable binary search
 	switch ct {
 	case CTFLT:
-		return mpcmpfltflt(n1.Val().U.(*Mpflt), n2.Val().U.(*Mpflt))
+		return n1.Val().U.(*Mpflt).Cmp(n2.Val().U.(*Mpflt))
 	case CTINT, CTRUNE:
-		return Mpcmpfixfix(n1.Val().U.(*Mpint), n2.Val().U.(*Mpint))
+		return n1.Val().U.(*Mpint).Cmp(n2.Val().U.(*Mpint))
 	case CTSTR:
 		// Sort strings by length and then by value.
 		// It is much cheaper to compare lengths than values,

src/cmd/compile/internal/gc/typecheck.go

@@ -367,7 +367,7 @@ OpSwitch:
 				return
 			}
 
-			t.Bound = Mpgetfix(v.U.(*Mpint))
+			t.Bound = v.U.(*Mpint).Int64()
 			if doesoverflow(v, Types[TINT]) {
 				Yyerror("array bound is too large")
 				n.Type = nil
@@ -733,7 +733,7 @@ OpSwitch:
 		}
 
 		if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
-			if mpcmpfixc(r.Val().U.(*Mpint), 0) == 0 {
+			if r.Val().U.(*Mpint).CmpInt64(0) == 0 {
 				Yyerror("division by zero")
 				n.Type = nil
 				return
@@ -1000,14 +1000,14 @@ OpSwitch:
 			}
 
 			if !n.Bounded && Isconst(n.Right, CTINT) {
-				x := Mpgetfix(n.Right.Val().U.(*Mpint))
+				x := n.Right.Val().U.(*Mpint).Int64()
 				if x < 0 {
 					Yyerror("invalid %s index %v (index must be non-negative)", why, n.Right)
 				} else if Isfixedarray(t) && x >= t.Bound {
 					Yyerror("invalid array index %v (out of bounds for %d-element array)", n.Right, t.Bound)
 				} else if Isconst(n.Left, CTSTR) && x >= int64(len(n.Left.Val().U.(string))) {
 					Yyerror("invalid string index %v (out of bounds for %d-byte string)", n.Right, len(n.Left.Val().U.(string)))
-				} else if Mpcmpfixfix(n.Right.Val().U.(*Mpint), Maxintval[TINT]) > 0 {
+				} else if n.Right.Val().U.(*Mpint).Cmp(Maxintval[TINT]) > 0 {
 					Yyerror("invalid %s index %v (index too large)", why, n.Right)
 				}
 			}
@@ -1808,7 +1808,7 @@ OpSwitch:
 				n.Type = nil
 				return
 			}
-			if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && Mpcmpfixfix(l.Val().U.(*Mpint), r.Val().U.(*Mpint)) > 0 {
+			if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && l.Val().U.(*Mpint).Cmp(r.Val().U.(*Mpint)) > 0 {
 				Yyerror("len larger than cap in make(%v)", t)
 				n.Type = nil
 				return
@@ -2204,16 +2204,16 @@ func checksliceindex(l *Node, r *Node, tp *Type) bool {
 	}
 
 	if r.Op == OLITERAL {
-		if Mpgetfix(r.Val().U.(*Mpint)) < 0 {
+		if r.Val().U.(*Mpint).Int64() < 0 {
 			Yyerror("invalid slice index %v (index must be non-negative)", r)
 			return false
-		} else if tp != nil && tp.Bound > 0 && Mpgetfix(r.Val().U.(*Mpint)) > tp.Bound {
+		} else if tp != nil && tp.Bound > 0 && r.Val().U.(*Mpint).Int64() > tp.Bound {
 			Yyerror("invalid slice index %v (out of bounds for %d-element array)", r, tp.Bound)
 			return false
-		} else if Isconst(l, CTSTR) && Mpgetfix(r.Val().U.(*Mpint)) > int64(len(l.Val().U.(string))) {
+		} else if Isconst(l, CTSTR) && r.Val().U.(*Mpint).Int64() > int64(len(l.Val().U.(string))) {
 			Yyerror("invalid slice index %v (out of bounds for %d-byte string)", r, len(l.Val().U.(string)))
 			return false
-		} else if Mpcmpfixfix(r.Val().U.(*Mpint), Maxintval[TINT]) > 0 {
+		} else if r.Val().U.(*Mpint).Cmp(Maxintval[TINT]) > 0 {
 			Yyerror("invalid slice index %v (index too large)", r)
 			return false
 		}
@@ -2223,7 +2223,7 @@ func checksliceindex(l *Node, r *Node, tp *Type) bool {
 }
 
 func checksliceconst(lo *Node, hi *Node) bool {
-	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && Mpcmpfixfix(lo.Val().U.(*Mpint), hi.Val().U.(*Mpint)) > 0 {
+	if lo != nil && hi != nil && lo.Op == OLITERAL && hi.Op == OLITERAL && lo.Val().U.(*Mpint).Cmp(hi.Val().U.(*Mpint)) > 0 {
 		Yyerror("invalid slice index: %v > %v", lo, hi)
 		return false
 	}
@@ -2779,10 +2779,10 @@ func keydup(n *Node, hash map[uint32][]*Node) {
 		h = 23
 
 	case CTINT, CTRUNE:
-		h = uint32(Mpgetfix(n.Val().U.(*Mpint)))
+		h = uint32(n.Val().U.(*Mpint).Int64())
 
 	case CTFLT:
-		d := mpgetflt(n.Val().U.(*Mpflt))
+		d := n.Val().U.(*Mpflt).Float64()
 		x := math.Float64bits(d)
 		for i := 0; i < 8; i++ {
 			h = h*PRIME1 + uint32(x&0xFF)
@@ -2834,7 +2834,7 @@ func indexdup(n *Node, hash map[int64]*Node) {
 		Fatalf("indexdup: not OLITERAL")
 	}
 
-	v := Mpgetfix(n.Val().U.(*Mpint))
+	v := n.Val().U.(*Mpint).Int64()
 	if hash[v] != nil {
 		Yyerror("duplicate index in array literal: %d", v)
 		return
@@ -3794,12 +3794,12 @@ func checkmake(t *Type, arg string, n *Node) bool {
 		switch n.Val().Ctype() {
 		case CTINT, CTRUNE, CTFLT, CTCPLX:
 			n.SetVal(toint(n.Val()))
-			if mpcmpfixc(n.Val().U.(*Mpint), 0) < 0 {
+			if n.Val().U.(*Mpint).CmpInt64(0) < 0 {
 				Yyerror("negative %s argument in make(%v)", arg, t)
 				return false
 			}
 
-			if Mpcmpfixfix(n.Val().U.(*Mpint), Maxintval[TINT]) > 0 {
+			if n.Val().U.(*Mpint).Cmp(Maxintval[TINT]) > 0 {
 				Yyerror("%s argument too large in make(%v)", arg, t)
 				return false
 			}

src/cmd/compile/internal/gc/universe.go

@@ -309,25 +309,25 @@ func typeinit() {
 	iscmp[OEQ] = true
 	iscmp[ONE] = true
 
-	mpatofix(Maxintval[TINT8], "0x7f")
-	mpatofix(Minintval[TINT8], "-0x80")
-	mpatofix(Maxintval[TINT16], "0x7fff")
-	mpatofix(Minintval[TINT16], "-0x8000")
-	mpatofix(Maxintval[TINT32], "0x7fffffff")
-	mpatofix(Minintval[TINT32], "-0x80000000")
-	mpatofix(Maxintval[TINT64], "0x7fffffffffffffff")
-	mpatofix(Minintval[TINT64], "-0x8000000000000000")
-
-	mpatofix(Maxintval[TUINT8], "0xff")
-	mpatofix(Maxintval[TUINT16], "0xffff")
-	mpatofix(Maxintval[TUINT32], "0xffffffff")
-	mpatofix(Maxintval[TUINT64], "0xffffffffffffffff")
+	Maxintval[TINT8].SetString("0x7f")
+	Minintval[TINT8].SetString("-0x80")
+	Maxintval[TINT16].SetString("0x7fff")
+	Minintval[TINT16].SetString("-0x8000")
+	Maxintval[TINT32].SetString("0x7fffffff")
+	Minintval[TINT32].SetString("-0x80000000")
+	Maxintval[TINT64].SetString("0x7fffffffffffffff")
+	Minintval[TINT64].SetString("-0x8000000000000000")
+
+	Maxintval[TUINT8].SetString("0xff")
+	Maxintval[TUINT16].SetString("0xffff")
+	Maxintval[TUINT32].SetString("0xffffffff")
+	Maxintval[TUINT64].SetString("0xffffffffffffffff")
 
 	// f is valid float if min < f < max.  (min and max are not themselves valid.)
-	mpatoflt(maxfltval[TFLOAT32], "33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
-	mpatoflt(minfltval[TFLOAT32], "-33554431p103")
-	mpatoflt(maxfltval[TFLOAT64], "18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
-	mpatoflt(minfltval[TFLOAT64], "-18014398509481983p970")
+	maxfltval[TFLOAT32].SetString("33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
+	minfltval[TFLOAT32].SetString("-33554431p103")
+	maxfltval[TFLOAT64].SetString("18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
+	minfltval[TFLOAT64].SetString("-18014398509481983p970")
 
 	maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
 	minfltval[TCOMPLEX64] = minfltval[TFLOAT32]

src/cmd/compile/internal/gc/unsafe.go

@@ -103,7 +103,7 @@ ret:
 	// any side effects disappear; ignore init
 	var val Val
 	val.U = new(Mpint)
-	Mpmovecfix(val.U.(*Mpint), v)
+	val.U.(*Mpint).SetInt64(v)
 	n := Nod(OLITERAL, nil, nil)
 	n.Orig = nn
 	n.SetVal(val)

src/cmd/compile/internal/gc/walk.go

@@ -366,7 +366,7 @@ func isSmallMakeSlice(n *Node) bool {
 	}
 	t := n.Type
 
-	return Smallintconst(l) && Smallintconst(r) && (t.Type.Width == 0 || Mpgetfix(r.Val().U.(*Mpint)) < (1<<16)/t.Type.Width)
+	return Smallintconst(l) && Smallintconst(r) && (t.Type.Width == 0 || r.Val().U.(*Mpint).Int64() < (1<<16)/t.Type.Width)
 }
 
 // walk the whole tree of the body of an
@@ -1220,7 +1220,7 @@ opswitch:
 					// replace "abc"[1] with 'b'.
 					// delayed until now because "abc"[1] is not
 					// an ideal constant.
-					v := Mpgetfix(n.Right.Val().U.(*Mpint))
+					v := n.Right.Val().U.(*Mpint).Int64()
 
 					Nodconst(n, n.Type, int64(n.Left.Val().U.(string)[v]))
 					n.Typecheck = 1
@@ -1229,7 +1229,7 @@ opswitch:
 		}
 
 		if Isconst(n.Right, CTINT) {
-			if Mpcmpfixfix(n.Right.Val().U.(*Mpint), &mpzero) < 0 || Mpcmpfixfix(n.Right.Val().U.(*Mpint), Maxintval[TINT]) > 0 {
+			if n.Right.Val().U.(*Mpint).Cmp(&mpzero) < 0 || n.Right.Val().U.(*Mpint).Cmp(Maxintval[TINT]) > 0 {
 				Yyerror("index out of bounds")
 			}
 		}
@@ -3304,7 +3304,7 @@ func samecheap(a *Node, b *Node) bool {
 		case OINDEX:
 			ar = a.Right
 			br = b.Right
-			if !Isconst(ar, CTINT) || !Isconst(br, CTINT) || Mpcmpfixfix(ar.Val().U.(*Mpint), br.Val().U.(*Mpint)) != 0 {
+			if !Isconst(ar, CTINT) || !Isconst(br, CTINT) || ar.Val().U.(*Mpint).Cmp(br.Val().U.(*Mpint)) != 0 {
 				return false
 			}
 		}
@@ -3340,9 +3340,9 @@ func walkrotate(np **Node) {
 	w := int(l.Type.Width * 8)
 
 	if Smallintconst(l.Right) && Smallintconst(r.Right) {
-		sl := int(Mpgetfix(l.Right.Val().U.(*Mpint)))
+		sl := int(l.Right.Val().U.(*Mpint).Int64())
 		if sl >= 0 {
-			sr := int(Mpgetfix(r.Right.Val().U.(*Mpint)))
+			sr := int(r.Right.Val().U.(*Mpint).Int64())
 			if sr >= 0 && sl+sr == w {
 				// Rewrite left shift half to left rotate.
 				if l.Op == OLSH {
@@ -3353,7 +3353,7 @@ func walkrotate(np **Node) {
 				n.Op = OLROT
 
 				// Remove rotate 0 and rotate w.
-				s := int(Mpgetfix(n.Right.Val().U.(*Mpint)))
+				s := int(n.Right.Val().U.(*Mpint).Int64())
 
 				if s == 0 || s == w {
 					n = n.Left
@@ -3394,7 +3394,7 @@ func walkmul(np **Node, init *Nodes) {
 	// x*0 is 0 (and side effects of x).
 	var pow int
 	var w int
-	if Mpgetfix(nr.Val().U.(*Mpint)) == 0 {
+	if nr.Val().U.(*Mpint).Int64() == 0 {
 		cheapexpr(nl, init)
 		Nodconst(n, n.Type, 0)
 		goto ret
@@ -3485,10 +3485,10 @@ func walkdiv(np **Node, init *Nodes) {
 		m.W = w
 
 		if Issigned[nl.Type.Etype] {
-			m.Sd = Mpgetfix(nr.Val().U.(*Mpint))
+			m.Sd = nr.Val().U.(*Mpint).Int64()
 			Smagic(&m)
 		} else {
-			m.Ud = uint64(Mpgetfix(nr.Val().U.(*Mpint)))
+			m.Ud = uint64(nr.Val().U.(*Mpint).Int64())
 			Umagic(&m)
 		}
 
@@ -3680,7 +3680,7 @@ func walkdiv(np **Node, init *Nodes) {
 			// n = nl & (nr-1)
 			n.Op = OAND
 
-			Nodconst(nc, nl.Type, Mpgetfix(nr.Val().U.(*Mpint))-1)
+			Nodconst(nc, nl.Type, nr.Val().U.(*Mpint).Int64()-1)
 		} else {
 			// n = nl >> pow
 			n.Op = ORSH
@@ -3710,7 +3710,7 @@ func bounded(n *Node, max int64) bool {
 	bits := int32(8 * n.Type.Width)
 
 	if Smallintconst(n) {
-		v := Mpgetfix(n.Val().U.(*Mpint))
+		v := n.Val().U.(*Mpint).Int64()
 		return 0 <= v && v < max
 	}
 
@@ -3718,9 +3718,9 @@ func bounded(n *Node, max int64) bool {
 	case OAND:
 		v := int64(-1)
 		if Smallintconst(n.Left) {
-			v = Mpgetfix(n.Left.Val().U.(*Mpint))
+			v = n.Left.Val().U.(*Mpint).Int64()
 		} else if Smallintconst(n.Right) {
-			v = Mpgetfix(n.Right.Val().U.(*Mpint))
+			v = n.Right.Val().U.(*Mpint).Int64()
 		}
 
 		if 0 <= v && v < max {
@@ -3729,7 +3729,7 @@ func bounded(n *Node, max int64) bool {
 
 	case OMOD:
 		if !sign && Smallintconst(n.Right) {
-			v := Mpgetfix(n.Right.Val().U.(*Mpint))
+			v := n.Right.Val().U.(*Mpint).Int64()
 			if 0 <= v && v <= max {
 				return true
 			}
@@ -3737,7 +3737,7 @@ func bounded(n *Node, max int64) bool {
 
 	case ODIV:
 		if !sign && Smallintconst(n.Right) {
-			v := Mpgetfix(n.Right.Val().U.(*Mpint))
+			v := n.Right.Val().U.(*Mpint).Int64()
 			for bits > 0 && v >= 2 {
 				bits--
 				v >>= 1
@@ -3746,7 +3746,7 @@ func bounded(n *Node, max int64) bool {
 
 	case ORSH:
 		if !sign && Smallintconst(n.Right) {
-			v := Mpgetfix(n.Right.Val().U.(*Mpint))
+			v := n.Right.Val().U.(*Mpint).Int64()
 			if v > int64(bits) {
 				return true
 			}
@@ -3926,17 +3926,17 @@ func candiscard(n *Node) bool {
 
 		// Discardable as long as we know it's not division by zero.
 	case ODIV, OMOD:
-		if Isconst(n.Right, CTINT) && mpcmpfixc(n.Right.Val().U.(*Mpint), 0) != 0 {
+		if Isconst(n.Right, CTINT) && n.Right.Val().U.(*Mpint).CmpInt64(0) != 0 {
 			break
 		}
-		if Isconst(n.Right, CTFLT) && mpcmpfltc(n.Right.Val().U.(*Mpflt), 0) != 0 {
+		if Isconst(n.Right, CTFLT) && n.Right.Val().U.(*Mpflt).CmpFloat64(0) != 0 {
 			break
 		}
 		return false
 
 		// Discardable as long as we know it won't fail because of a bad size.
 	case OMAKECHAN, OMAKEMAP:
-		if Isconst(n.Left, CTINT) && mpcmpfixc(n.Left.Val().U.(*Mpint), 0) == 0 {
+		if Isconst(n.Left, CTINT) && n.Left.Val().U.(*Mpint).CmpInt64(0) == 0 {
 			break
 		}
 		return false