src/cmd/compile/internal/gc: remove now unnecessary restriction on float exponent...

https://go-review.googlesource.com/#/c/13778/ fixed this issue in math/big.
Remove restriction in compiler.

Fixes #11326.

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

diff --git a/src/cmd/compile/internal/gc/mparith3.go b/src/cmd/compile/internal/gc/mparith3.go
index bf37f2d60786c4affce2dbb22975f09f3d648a89..f91a64b42d82310b70b7a0c99286e3a541f98aa4 100644 (file)
--- a/src/cmd/compile/internal/gc/mparith3.go
+++ b/src/cmd/compile/internal/gc/mparith3.go
@@ -9,7 +9,6 @@ import (
        "cmd/internal/obj"
        "fmt"
        "math"
-       "strings"
 )
 
 /// implements float arihmetic
@@ -154,30 +153,6 @@ func mpatoflt(a *Mpflt, as string) {
                as = as[1:]
        }
 
-       // The spec requires accepting exponents that fit in int32.
-       // Don't accept much more than that.
-       // Count digits in exponent and stop early if there are too many.
-       if i := strings.Index(as, "e"); i >= 0 {
-               i++
-               if i < len(as) && (as[i] == '-' || as[i] == '+') {
-                       i++
-               }
-               for i < len(as) && as[i] == '0' {
-                       i++
-               }
-               // TODO(rsc): This should be > 10, because we're supposed
-               // to accept any signed 32-bit int as an exponent.
-               // But that's not working terribly well, so we deviate from the
-               // spec in order to make sure that what we accept works.
-               // We can remove this restriction once those larger exponents work.
-               // See golang.org/issue/11326 and test/fixedbugs/issue11326*.go.
-               if len(as)-i > 8 {
-                       Yyerror("malformed constant: %s (exponent too large)", as)
-                       a.Val.SetUint64(0)
-                       return
-               }
-       }
-
        f, ok := a.Val.SetString(as)
        if !ok {
                // At the moment we lose precise error cause;

diff --git a/test/fixedbugs/issue11326.go b/test/fixedbugs/issue11326.go
index fd1fab338aefbef61e7e435c1f241d5a92e6128a..bb197962322d66da68422c28b84ac387cebb2d5b 100644 (file)
--- a/test/fixedbugs/issue11326.go
+++ b/test/fixedbugs/issue11326.go
@@ -4,25 +4,20 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main
+// Tests for golang.org/issue/11326.
 
-import "fmt"
+package main
 
 func main() {
-       var g = 1e81391777742999 // ERROR "exponent too large"
-       // The next should only cause a problem when converted to float64
-       // by the assignment, but instead the compiler rejects it outright,
-       // rather than mishandle it. Specifically, when handled, 'var h' prints:
-       //      issue11326.go:N: constant 0.93342e+536870911 overflows float64
-       // The rejection of 'var i' is just insurance. It seems to work correctly.
-       // See golang.org/issue/11326.
-       // var h = 1e2147483647     // should be "1.00000e+2147483647 overflows float64"
-       var h = 1e2147483647 // ERROR "exponent too large"
-       // var i = 1e214748364  // should be "1.00000e\+214748364 overflows float64"
-       var i = 1e214748364 // ERROR "exponent too large"
-       var j = 1e21474836  // ERROR "1.00000e\+21474836 overflows float64"
-       var k = 1e2147483   // ERROR "1.00000e\+2147483 overflows float64"
-       var l = 1e214748    // ERROR "1.00000e\+214748 overflows float64"
-       var m = 1e21474     // ERROR "1.00000e\+21474 overflows float64"
-       fmt.Println(g)
+       var _ = 1e2147483647 // ERROR "constant too large"
+       var _ = 1e646456993  // ERROR "constant too large"
+       var _ = 1e646456992  // ERROR "1.00000e\+646456992 overflows float64"
+       var _ = 1e64645699   // ERROR "1.00000e\+64645699 overflows float64"
+       var _ = 1e6464569    // ERROR "1.00000e\+6464569 overflows float64"
+       var _ = 1e646456     // ERROR "1.00000e\+646456 overflows float64"
+       var _ = 1e64645      // ERROR "1.00000e\+64645 overflows float64"
+       var _ = 1e6464       // ERROR "1.00000e\+6464 overflows float64"
+       var _ = 1e646        // ERROR "1.00000e\+646 overflows float64"
+       var _ = 1e309        // ERROR "1.00000e\+309 overflows float64"
+       var _ = 1e308
 }

diff --git a/test/fixedbugs/issue11326b.go b/test/fixedbugs/issue11326b.go
index 00effbcbb981be2cf4bcd459c703544647ec204d..6a6ae2f4494749b8e63f2caa05b0a6b804e15fa1 100644 (file)
--- a/test/fixedbugs/issue11326b.go
+++ b/test/fixedbugs/issue11326b.go
@@ -6,36 +6,36 @@
 
 package main
 
+// Tests for golang.org/issue/11326.
+
 func main() {
-       /* TODO(rsc): Should work but does not. See golang.org/issue/11326.
        {
-               const n = 1e2147483647
-               const d = 1e2147483646
+               const n = 1e646456992
+               const d = 1e646456991
                x := n / d
                if x != 10.0 {
                        println("incorrect value:", x)
                }
        }
        {
-               const n = 1e214748364
-               const d = 1e214748363
+               const n = 1e64645699
+               const d = 1e64645698
                x := n / d
                if x != 10.0 {
                        println("incorrect value:", x)
                }
        }
-       */
        {
-               const n = 1e21474836
-               const d = 1e21474835
+               const n = 1e6464569
+               const d = 1e6464568
                x := n / d
                if x != 10.0 {
                        println("incorrect value:", x)
                }
        }
        {
-               const n = 1e2147483
-               const d = 1e2147482
+               const n = 1e646456
+               const d = 1e646455
                x := n / d
                if x != 10.0 {
                        println("incorrect value:", x)