Skip to content

G
go
Commit d3253876 authored by Matthew Dempsky's avatar Matthew Dempsky Committed by Robert Griesemer
Browse files
Options

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: default avatarRobert Griesemer <gri@golang.org>
parent 5fb6aa3e
Hide whitespace changes
Inline Side-by-side
Showing with 316 additions and 316 deletions
src/cmd/compile/internal/gc/bexport.go
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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/const.go
View file @ d3253876
......@@ -29,7 +29,7 @@ func (n *Node) Int() int64 {
if !Isconst(n, CTINT) {
Fatalf("Int(%v)", n)
}
return Mpgetfix(n.Val().U.(*Mpint))
return n.Val().U.(*Mpint).Int64()
}
// SetInt sets n's value to i.
......@@ -38,7 +38,7 @@ func (n *Node) SetInt(i int64) {
if !Isconst(n, CTINT) {
Fatalf("SetInt(%v)", n)
}
Mpmovecfix(n.Val().U.(*Mpint), i)
n.Val().U.(*Mpint).SetInt64(i)
}
// SetBigInt sets n's value to x.
......@@ -71,18 +71,18 @@ func truncfltlit(oldv *Mpflt, t *Type) *Mpflt {
overflow(v, t)
fv := newMpflt()
mpmovefltflt(fv, oldv)
fv.Set(oldv)
// convert large precision literal floating
// into limited precision (float64 or float32)
switch t.Etype {
case TFLOAT64:
d := mpgetflt(fv)
Mpmovecflt(fv, d)
d := fv.Float64()
fv.SetFloat64(d)
case TFLOAT32:
d := mpgetflt32(fv)
Mpmovecflt(fv, d)
d := fv.Float32()
fv.SetFloat64(d)
}
return fv
......@@ -241,7 +241,7 @@ func convlit1(np **Node, t *Type, explicit bool) {
case TUINTPTR:
if n.Type.Etype == TUNSAFEPTR {
n.SetVal(Val{new(Mpint)})
Mpmovecfix(n.Val().U.(*Mpint), 0)
n.Val().U.(*Mpint).SetInt64(0)
} else {
goto bad
}
......@@ -321,19 +321,19 @@ func copyval(v Val) Val {
switch v.Ctype() {
case CTINT, CTRUNE:
i := new(Mpint)
mpmovefixfix(i, v.U.(*Mpint))
i.Set(v.U.(*Mpint))
i.Rune = v.U.(*Mpint).Rune
v.U = i
case CTFLT:
f := newMpflt()
mpmovefltflt(f, v.U.(*Mpflt))
f.Set(v.U.(*Mpflt))
v.U = f
case CTCPLX:
c := new(Mpcplx)
mpmovefltflt(&c.Real, &v.U.(*Mpcplx).Real)
mpmovefltflt(&c.Imag, &v.U.(*Mpcplx).Imag)
c.Real.Set(&v.U.(*Mpcplx).Real)
c.Imag.Set(&v.U.(*Mpcplx).Imag)
v.U = c
}
......@@ -344,14 +344,14 @@ func tocplx(v Val) Val {
switch v.Ctype() {
case CTINT, CTRUNE:
c := new(Mpcplx)
Mpmovefixflt(&c.Real, v.U.(*Mpint))
Mpmovecflt(&c.Imag, 0.0)
c.Real.SetInt(v.U.(*Mpint))
c.Imag.SetFloat64(0.0)
v.U = c
case CTFLT:
c := new(Mpcplx)
mpmovefltflt(&c.Real, v.U.(*Mpflt))
Mpmovecflt(&c.Imag, 0.0)
c.Real.Set(v.U.(*Mpflt))
c.Imag.SetFloat64(0.0)
v.U = c
}
......@@ -362,13 +362,13 @@ func toflt(v Val) Val {
switch v.Ctype() {
case CTINT, CTRUNE:
f := newMpflt()
Mpmovefixflt(f, v.U.(*Mpint))
f.SetInt(v.U.(*Mpint))
v.U = f
case CTCPLX:
f := newMpflt()
mpmovefltflt(f, &v.U.(*Mpcplx).Real)
if mpcmpfltc(&v.U.(*Mpcplx).Imag, 0) != 0 {
f.Set(&v.U.(*Mpcplx).Real)
if v.U.(*Mpcplx).Imag.CmpFloat64(0) != 0 {
Yyerror("constant %v%vi truncated to real", Fconv(&v.U.(*Mpcplx).Real, FmtSharp), Fconv(&v.U.(*Mpcplx).Imag, FmtSharp|FmtSign))
}
v.U = f
......@@ -381,14 +381,14 @@ func toint(v Val) Val {
switch v.Ctype() {
case CTRUNE:
i := new(Mpint)
mpmovefixfix(i, v.U.(*Mpint))
i.Set(v.U.(*Mpint))
v.U = i
case CTFLT:
i := new(Mpint)
if f := v.U.(*Mpflt); mpmovefltfix(i, f) < 0 {
if f := v.U.(*Mpflt); i.SetFloat(f) < 0 {
msg := "constant %v truncated to integer"
// provide better error message if mpmovefltfix failed because f was too large
// provide better error message if SetFloat failed because f was too large
if f.Val.IsInt() {
msg = "constant %v overflows integer"
}
......@@ -398,10 +398,10 @@ func toint(v Val) Val {
case CTCPLX:
i := new(Mpint)
if mpmovefltfix(i, &v.U.(*Mpcplx).Real) < 0 {
if i.SetFloat(&v.U.(*Mpcplx).Real) < 0 {
Yyerror("constant %v%vi truncated to integer", Fconv(&v.U.(*Mpcplx).Real, FmtSharp), Fconv(&v.U.(*Mpcplx).Imag, FmtSharp|FmtSign))
}
if mpcmpfltc(&v.U.(*Mpcplx).Imag, 0) != 0 {
if v.U.(*Mpcplx).Imag.CmpFloat64(0) != 0 {
Yyerror("constant %v%vi truncated to real", Fconv(&v.U.(*Mpcplx).Real, FmtSharp), Fconv(&v.U.(*Mpcplx).Imag, FmtSharp|FmtSign))
}
v.U = i
......@@ -416,7 +416,7 @@ func doesoverflow(v Val, t *Type) bool {
if !Isint[t.Etype] {
Fatalf("overflow: %v integer constant", t)
}
if Mpcmpfixfix(v.U.(*Mpint), Minintval[t.Etype]) < 0 || Mpcmpfixfix(v.U.(*Mpint), Maxintval[t.Etype]) > 0 {
if v.U.(*Mpint).Cmp(Minintval[t.Etype]) < 0 || v.U.(*Mpint).Cmp(Maxintval[t.Etype]) > 0 {
return true
}
......@@ -424,7 +424,7 @@ func doesoverflow(v Val, t *Type) bool {
if !Isfloat[t.Etype] {
Fatalf("overflow: %v floating-point constant", t)
}
if mpcmpfltflt(v.U.(*Mpflt), minfltval[t.Etype]) <= 0 || mpcmpfltflt(v.U.(*Mpflt), maxfltval[t.Etype]) >= 0 {
if v.U.(*Mpflt).Cmp(minfltval[t.Etype]) <= 0 || v.U.(*Mpflt).Cmp(maxfltval[t.Etype]) >= 0 {
return true
}
......@@ -432,7 +432,7 @@ func doesoverflow(v Val, t *Type) bool {
if !Iscomplex[t.Etype] {
Fatalf("overflow: %v complex constant", t)
}
if mpcmpfltflt(&v.U.(*Mpcplx).Real, minfltval[t.Etype]) <= 0 || mpcmpfltflt(&v.U.(*Mpcplx).Real, maxfltval[t.Etype]) >= 0 || mpcmpfltflt(&v.U.(*Mpcplx).Imag, minfltval[t.Etype]) <= 0 || mpcmpfltflt(&v.U.(*Mpcplx).Imag, maxfltval[t.Etype]) >= 0 {
if v.U.(*Mpcplx).Real.Cmp(minfltval[t.Etype]) <= 0 || v.U.(*Mpcplx).Real.Cmp(maxfltval[t.Etype]) >= 0 || v.U.(*Mpcplx).Imag.Cmp(minfltval[t.Etype]) <= 0 || v.U.(*Mpcplx).Imag.Cmp(maxfltval[t.Etype]) >= 0 {
return true
}
}
......@@ -460,10 +460,10 @@ func overflow(v Val, t *Type) {
func tostr(v Val) Val {
switch v.Ctype() {
case CTINT, CTRUNE:
if Mpcmpfixfix(v.U.(*Mpint), Minintval[TINT]) < 0 || Mpcmpfixfix(v.U.(*Mpint), Maxintval[TINT]) > 0 {
if v.U.(*Mpint).Cmp(Minintval[TINT]) < 0 || v.U.(*Mpint).Cmp(Maxintval[TINT]) > 0 {
Yyerror("overflow in int -> string")
}
r := uint(Mpgetfix(v.U.(*Mpint)))
r := uint(v.U.(*Mpint).Int64())
v = Val{}
v.U = string(r)
......@@ -677,7 +677,7 @@ func evconst(n *Node) {
case OMINUS_ | CTINT_,
OMINUS_ | CTRUNE_:
mpnegfix(v.U.(*Mpint))
v.U.(*Mpint).Neg()
case OCOM_ | CTINT_,
OCOM_ | CTRUNE_:
......@@ -692,7 +692,7 @@ func evconst(n *Node) {
switch et {
// signed guys change sign
default:
Mpmovecfix(&b, -1)
b.SetInt64(-1)
// unsigned guys invert their bits
case TUINT8,
......@@ -701,23 +701,23 @@ func evconst(n *Node) {
TUINT64,
TUINT,
TUINTPTR:
mpmovefixfix(&b, Maxintval[et])
b.Set(Maxintval[et])
}
mpxorfixfix(v.U.(*Mpint), &b)
v.U.(*Mpint).Xor(&b)
case OPLUS_ | CTFLT_:
break
case OMINUS_ | CTFLT_:
mpnegflt(v.U.(*Mpflt))
v.U.(*Mpflt).Neg()
case OPLUS_ | CTCPLX_:
break
case OMINUS_ | CTCPLX_:
mpnegflt(&v.U.(*Mpcplx).Real)
mpnegflt(&v.U.(*Mpcplx).Imag)
v.U.(*Mpcplx).Real.Neg()
v.U.(*Mpcplx).Imag.Neg()
case ONOT_ | CTBOOL_:
if !v.U.(bool) {
......@@ -800,18 +800,18 @@ func evconst(n *Node) {
// Rune and int turns into rune.
if v.Ctype() == CTRUNE && rv.Ctype() == CTINT {
i := new(Mpint)
mpmovefixfix(i, rv.U.(*Mpint))
i.Set(rv.U.(*Mpint))
i.Rune = true
rv.U = i
}
if v.Ctype() == CTINT && rv.Ctype() == CTRUNE {
if n.Op == OLSH || n.Op == ORSH {
i := new(Mpint)
mpmovefixfix(i, rv.U.(*Mpint))
i.Set(rv.U.(*Mpint))
rv.U = i
} else {
i := new(Mpint)
mpmovefixfix(i, v.U.(*Mpint))
i.Set(v.U.(*Mpint))
i.Rune = true
v.U = i
}
......@@ -832,77 +832,77 @@ func evconst(n *Node) {
case OADD_ | CTINT_,
OADD_ | CTRUNE_:
mpaddfixfix(v.U.(*Mpint), rv.U.(*Mpint), 0)
v.U.(*Mpint).Add(rv.U.(*Mpint), 0)
case OSUB_ | CTINT_,
OSUB_ | CTRUNE_:
mpsubfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Sub(rv.U.(*Mpint))
case OMUL_ | CTINT_,
OMUL_ | CTRUNE_:
mpmulfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Mul(rv.U.(*Mpint))
case ODIV_ | CTINT_,
ODIV_ | CTRUNE_:
if mpcmpfixc(rv.U.(*Mpint), 0) == 0 {
if rv.U.(*Mpint).CmpInt64(0) == 0 {
Yyerror("division by zero")
mpsetovf(v.U.(*Mpint))
v.U.(*Mpint).SetOverflow()
break
}
mpdivfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Quo(rv.U.(*Mpint))
case OMOD_ | CTINT_,
OMOD_ | CTRUNE_:
if mpcmpfixc(rv.U.(*Mpint), 0) == 0 {
if rv.U.(*Mpint).CmpInt64(0) == 0 {
Yyerror("division by zero")
mpsetovf(v.U.(*Mpint))
v.U.(*Mpint).SetOverflow()
break
}
mpmodfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Rem(rv.U.(*Mpint))
case OLSH_ | CTINT_,
OLSH_ | CTRUNE_:
mplshfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Lsh(rv.U.(*Mpint))
case ORSH_ | CTINT_,
ORSH_ | CTRUNE_:
mprshfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Rsh(rv.U.(*Mpint))
case OOR_ | CTINT_,
OOR_ | CTRUNE_:
mporfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Or(rv.U.(*Mpint))
case OAND_ | CTINT_,
OAND_ | CTRUNE_:
mpandfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).And(rv.U.(*Mpint))
case OANDNOT_ | CTINT_,
OANDNOT_ | CTRUNE_:
mpandnotfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).AndNot(rv.U.(*Mpint))
case OXOR_ | CTINT_,
OXOR_ | CTRUNE_:
mpxorfixfix(v.U.(*Mpint), rv.U.(*Mpint))
v.U.(*Mpint).Xor(rv.U.(*Mpint))
case OADD_ | CTFLT_:
mpaddfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
v.U.(*Mpflt).Add(rv.U.(*Mpflt))
case OSUB_ | CTFLT_:
mpsubfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
v.U.(*Mpflt).Sub(rv.U.(*Mpflt))
case OMUL_ | CTFLT_:
mpmulfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
v.U.(*Mpflt).Mul(rv.U.(*Mpflt))
case ODIV_ | CTFLT_:
if mpcmpfltc(rv.U.(*Mpflt), 0) == 0 {
if rv.U.(*Mpflt).CmpFloat64(0) == 0 {
Yyerror("division by zero")
Mpmovecflt(v.U.(*Mpflt), 1.0)
v.U.(*Mpflt).SetFloat64(1.0)
break
}
mpdivfltflt(v.U.(*Mpflt), rv.U.(*Mpflt))
v.U.(*Mpflt).Quo(rv.U.(*Mpflt))
// The default case above would print 'ideal % ideal',
// which is not quite an ideal error.
......@@ -915,21 +915,21 @@ func evconst(n *Node) {
return
case OADD_ | CTCPLX_:
mpaddfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real)
mpaddfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag)
v.U.(*Mpcplx).Real.Add(&rv.U.(*Mpcplx).Real)
v.U.(*Mpcplx).Imag.Add(&rv.U.(*Mpcplx).Imag)
case OSUB_ | CTCPLX_:
mpsubfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real)
mpsubfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag)
v.U.(*Mpcplx).Real.Sub(&rv.U.(*Mpcplx).Real)
v.U.(*Mpcplx).Imag.Sub(&rv.U.(*Mpcplx).Imag)
case OMUL_ | CTCPLX_:
cmplxmpy(v.U.(*Mpcplx), rv.U.(*Mpcplx))
case ODIV_ | CTCPLX_:
if mpcmpfltc(&rv.U.(*Mpcplx).Real, 0) == 0 && mpcmpfltc(&rv.U.(*Mpcplx).Imag, 0) == 0 {
if rv.U.(*Mpcplx).Real.CmpFloat64(0) == 0 && rv.U.(*Mpcplx).Imag.CmpFloat64(0) == 0 {
Yyerror("complex division by zero")
Mpmovecflt(&rv.U.(*Mpcplx).Real, 1.0)
Mpmovecflt(&rv.U.(*Mpcplx).Imag, 0.0)
rv.U.(*Mpcplx).Real.SetFloat64(1.0)
rv.U.(*Mpcplx).Imag.SetFloat64(0.0)
break
}
......@@ -943,90 +943,90 @@ func evconst(n *Node) {
case OEQ_ | CTINT_,
OEQ_ | CTRUNE_:
if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) == 0 {
if v.U.(*Mpint).Cmp(rv.U.(*Mpint)) == 0 {
goto settrue
}
goto setfalse
case ONE_ | CTINT_,
ONE_ | CTRUNE_:
if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) != 0 {
if v.U.(*Mpint).Cmp(rv.U.(*Mpint)) != 0 {
goto settrue
}
goto setfalse
case OLT_ | CTINT_,
OLT_ | CTRUNE_:
if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) < 0 {
if v.U.(*Mpint).Cmp(rv.U.(*Mpint)) < 0 {
goto settrue
}
goto setfalse
case OLE_ | CTINT_,
OLE_ | CTRUNE_:
if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) <= 0 {
if v.U.(*Mpint).Cmp(rv.U.(*Mpint)) <= 0 {
goto settrue
}
goto setfalse
case OGE_ | CTINT_,
OGE_ | CTRUNE_:
if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) >= 0 {
if v.U.(*Mpint).Cmp(rv.U.(*Mpint)) >= 0 {
goto settrue
}
goto setfalse
case OGT_ | CTINT_,
OGT_ | CTRUNE_:
if Mpcmpfixfix(v.U.(*Mpint), rv.U.(*Mpint)) > 0 {
if v.U.(*Mpint).Cmp(rv.U.(*Mpint)) > 0 {
goto settrue
}
goto setfalse
case OEQ_ | CTFLT_:
if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) == 0 {
if v.U.(*Mpflt).Cmp(rv.U.(*Mpflt)) == 0 {
goto settrue
}
goto setfalse
case ONE_ | CTFLT_:
if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) != 0 {
if v.U.(*Mpflt).Cmp(rv.U.(*Mpflt)) != 0 {
goto settrue
}
goto setfalse
case OLT_ | CTFLT_:
if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) < 0 {
if v.U.(*Mpflt).Cmp(rv.U.(*Mpflt)) < 0 {
goto settrue
}
goto setfalse
case OLE_ | CTFLT_:
if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) <= 0 {
if v.U.(*Mpflt).Cmp(rv.U.(*Mpflt)) <= 0 {
goto settrue
}
goto setfalse
case OGE_ | CTFLT_:
if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) >= 0 {
if v.U.(*Mpflt).Cmp(rv.U.(*Mpflt)) >= 0 {
goto settrue
}
goto setfalse
case OGT_ | CTFLT_:
if mpcmpfltflt(v.U.(*Mpflt), rv.U.(*Mpflt)) > 0 {
if v.U.(*Mpflt).Cmp(rv.U.(*Mpflt)) > 0 {
goto settrue
}
goto setfalse
case OEQ_ | CTCPLX_:
if mpcmpfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real) == 0 && mpcmpfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag) == 0 {
if v.U.(*Mpcplx).Real.Cmp(&rv.U.(*Mpcplx).Real) == 0 && v.U.(*Mpcplx).Imag.Cmp(&rv.U.(*Mpcplx).Imag) == 0 {
goto settrue
}
goto setfalse
case ONE_ | CTCPLX_:
if mpcmpfltflt(&v.U.(*Mpcplx).Real, &rv.U.(*Mpcplx).Real) != 0 || mpcmpfltflt(&v.U.(*Mpcplx).Imag, &rv.U.(*Mpcplx).Imag) != 0 {
if v.U.(*Mpcplx).Real.Cmp(&rv.U.(*Mpcplx).Real) != 0 || v.U.(*Mpcplx).Imag.Cmp(&rv.U.(*Mpcplx).Imag) != 0 {
goto settrue
}
goto setfalse
......@@ -1175,8 +1175,8 @@ func nodcplxlit(r Val, i Val) *Node {
Fatalf("nodcplxlit ctype %d/%d", r.Ctype(), i.Ctype())
}
mpmovefltflt(&c.Real, r.U.(*Mpflt))
mpmovefltflt(&c.Imag, i.U.(*Mpflt))
c.Real.Set(r.U.(*Mpflt))
c.Imag.Set(i.U.(*Mpflt))
return n
}
......@@ -1416,7 +1416,7 @@ func Smallintconst(n *Node) bool {
return true
case TIDEAL, TINT64, TUINT64, TPTR64:
if Mpcmpfixfix(n.Val().U.(*Mpint), Minintval[TINT32]) < 0 || Mpcmpfixfix(n.Val().U.(*Mpint), Maxintval[TINT32]) > 0 {
if n.Val().U.(*Mpint).Cmp(Minintval[TINT32]) < 0 || n.Val().U.(*Mpint).Cmp(Maxintval[TINT32]) > 0 {
break
}
return true
......@@ -1439,10 +1439,10 @@ func nonnegconst(n *Node) int {
TINT64,
TUINT64,
TIDEAL:
if Mpcmpfixfix(n.Val().U.(*Mpint), Minintval[TUINT32]) < 0 || Mpcmpfixfix(n.Val().U.(*Mpint), Maxintval[TINT32]) > 0 {
if n.Val().U.(*Mpint).Cmp(Minintval[TUINT32]) < 0 || n.Val().U.(*Mpint).Cmp(Maxintval[TINT32]) > 0 {
break
}
return int(Mpgetfix(n.Val().U.(*Mpint)))
return int(n.Val().U.(*Mpint).Int64())
}
}
......@@ -1497,7 +1497,7 @@ func (n *Node) Convconst(con *Node, t *Type) {
Fatalf("convconst ctype=%d %v", n.Val().Ctype(), Tconv(t, FmtLong))
case CTINT, CTRUNE:
i = Mpgetfix(n.Val().U.(*Mpint))
i = n.Val().U.(*Mpint).Int64()
case CTBOOL:
i = int64(obj.Bool2int(n.Val().U.(bool)))
......@@ -1507,7 +1507,7 @@ func (n *Node) Convconst(con *Node, t *Type) {
}
i = iconv(i, tt)
Mpmovecfix(con.Val().U.(*Mpint), i)
con.Val().U.(*Mpint).SetInt64(i)
return
}
......@@ -1542,28 +1542,28 @@ func cmplxmpy(v *Mpcplx, rv *Mpcplx) {
var bc Mpflt
var ad Mpflt
mpmovefltflt(&ac, &v.Real)
mpmulfltflt(&ac, &rv.Real) // ac
ac.Set(&v.Real)
ac.Mul(&rv.Real) // ac
mpmovefltflt(&bd, &v.Imag)
bd.Set(&v.Imag)
mpmulfltflt(&bd, &rv.Imag) // bd
bd.Mul(&rv.Imag) // bd
mpmovefltflt(&bc, &v.Imag)
bc.Set(&v.Imag)
mpmulfltflt(&bc, &rv.Real) // bc
bc.Mul(&rv.Real) // bc
mpmovefltflt(&ad, &v.Real)
ad.Set(&v.Real)
mpmulfltflt(&ad, &rv.Imag) // ad
ad.Mul(&rv.Imag) // ad
mpmovefltflt(&v.Real, &ac)
v.Real.Set(&ac)
mpsubfltflt(&v.Real, &bd) // ac-bd
v.Real.Sub(&bd) // ac-bd
mpmovefltflt(&v.Imag, &bc)
v.Imag.Set(&bc)
mpaddfltflt(&v.Imag, &ad) // bc+ad
v.Imag.Add(&ad) // bc+ad
}
// complex divide v /= rv
......@@ -1575,40 +1575,40 @@ func cmplxdiv(v *Mpcplx, rv *Mpcplx) {
var ad Mpflt
var cc_plus_dd Mpflt
mpmovefltflt(&cc_plus_dd, &rv.Real)
mpmulfltflt(&cc_plus_dd, &rv.Real) // cc
cc_plus_dd.Set(&rv.Real)
cc_plus_dd.Mul(&rv.Real) // cc
mpmovefltflt(&ac, &rv.Imag)
ac.Set(&rv.Imag)
mpmulfltflt(&ac, &rv.Imag) // dd
ac.Mul(&rv.Imag) // dd
mpaddfltflt(&cc_plus_dd, &ac) // cc+dd
cc_plus_dd.Add(&ac) // cc+dd
mpmovefltflt(&ac, &v.Real)
ac.Set(&v.Real)
mpmulfltflt(&ac, &rv.Real) // ac
ac.Mul(&rv.Real) // ac
mpmovefltflt(&bd, &v.Imag)
bd.Set(&v.Imag)
mpmulfltflt(&bd, &rv.Imag) // bd
bd.Mul(&rv.Imag) // bd
mpmovefltflt(&bc, &v.Imag)
bc.Set(&v.Imag)
mpmulfltflt(&bc, &rv.Real) // bc
bc.Mul(&rv.Real) // bc
mpmovefltflt(&ad, &v.Real)
ad.Set(&v.Real)
mpmulfltflt(&ad, &rv.Imag) // ad
ad.Mul(&rv.Imag) // ad
mpmovefltflt(&v.Real, &ac)
v.Real.Set(&ac)
mpaddfltflt(&v.Real, &bd) // ac+bd
mpdivfltflt(&v.Real, &cc_plus_dd) // (ac+bd)/(cc+dd)
v.Real.Add(&bd) // ac+bd
v.Real.Quo(&cc_plus_dd) // (ac+bd)/(cc+dd)
mpmovefltflt(&v.Imag, &bc)
v.Imag.Set(&bc)
mpsubfltflt(&v.Imag, &ad) // bc-ad
mpdivfltflt(&v.Imag, &cc_plus_dd) // (bc+ad)/(cc+dd)
v.Imag.Sub(&ad) // bc-ad
v.Imag.Quo(&cc_plus_dd) // (bc+ad)/(cc+dd)
}
// Is n a Go language constant (as opposed to a compile-time constant)?
......
src/cmd/compile/internal/gc/fmt.go
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
View file @ d3253876
......@@ -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
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7