cmd/internal/obj: unify creation of numeric literal syms

This is a straightforward refactoring,
to reduce the scope of upcoming changes.

The symbol size and AttrLocal=true was not
set universally, but it appears not to matter,
since toolstash -cmp is happy.

Passes toolstash-check -all.

Change-Id: I7f8392f939592d3a1bc6f61dec992f5661f42fca
Reviewed-on: https://go-review.googlesource.com/39791
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/cmd/compile/fmt_test.go b/src/cmd/compile/fmt_test.go
index 1dc4434e25b7e13bbbba62833e5435e0394b4428..e9b78df2fb0a4de63f01b64adb1cd72603902e0f 100644 (file)
--- a/src/cmd/compile/fmt_test.go
+++ b/src/cmd/compile/fmt_test.go
@@ -703,10 +703,8 @@ var knownFormats = map[string]string{
        "uint16 %d":        "",
        "uint16 %v":        "",
        "uint16 %x":        "",
-       "uint32 %08x":      "",
        "uint32 %d":        "",
        "uint32 %x":        "",
-       "uint64 %016x":     "",
        "uint64 %08x":      "",
        "uint64 %d":        "",
        "uint64 %x":        "",

diff --git a/src/cmd/compile/internal/x86/ssa.go b/src/cmd/compile/internal/x86/ssa.go
index 144cfaee2de3d888fab496daab2eff79c014a4e3..e7fcc978554f477541b09b6f353aaf79c57aafa4 100644 (file)
--- a/src/cmd/compile/internal/x86/ssa.go
+++ b/src/cmd/compile/internal/x86/ssa.go
@@ -443,17 +443,15 @@ func ssaGenValue(s *gc.SSAGenState, v *ssa.Value) {
                p.To.Type = obj.TYPE_REG
                p.To.Reg = x
        case ssa.Op386MOVSSconst1, ssa.Op386MOVSDconst1:
-               var literal string
-               if v.Op == ssa.Op386MOVSDconst1 {
-                       literal = fmt.Sprintf("$f64.%016x", uint64(v.AuxInt))
-               } else {
-                       literal = fmt.Sprintf("$f32.%08x", math.Float32bits(float32(math.Float64frombits(uint64(v.AuxInt)))))
-               }
                p := s.Prog(x86.ALEAL)
                p.From.Type = obj.TYPE_MEM
                p.From.Name = obj.NAME_EXTERN
-               p.From.Sym = gc.Ctxt.Lookup(literal, 0)
-               p.From.Sym.Set(obj.AttrLocal, true)
+               f := math.Float64frombits(uint64(v.AuxInt))
+               if v.Op == ssa.Op386MOVSDconst1 {
+                       p.From.Sym = gc.Ctxt.Float64Sym(f)
+               } else {
+                       p.From.Sym = gc.Ctxt.Float32Sym(float32(f))
+               }
                p.To.Type = obj.TYPE_REG
                p.To.Reg = v.Reg()
        case ssa.Op386MOVSSconst2, ssa.Op386MOVSDconst2:

diff --git a/src/cmd/internal/obj/arm/obj5.go b/src/cmd/internal/obj/arm/obj5.go
index 0949088a9753cee03312f87e1a58b7c67857bf32..f14577e2fadae0d3cccecf14cae9a08bf6a27880 100644 (file)
--- a/src/cmd/internal/obj/arm/obj5.go
+++ b/src/cmd/internal/obj/arm/obj5.go
@@ -33,8 +33,6 @@ package arm
 import (
        "cmd/internal/obj"
        "cmd/internal/sys"
-       "fmt"
-       "math"
 )
 
 var progedit_tlsfallback *obj.LSym
@@ -108,22 +106,16 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
        case AMOVF:
                if p.From.Type == obj.TYPE_FCONST && chipfloat5(ctxt, p.From.Val.(float64)) < 0 && (chipzero5(ctxt, p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
                        f32 := float32(p.From.Val.(float64))
-                       i32 := math.Float32bits(f32)
-                       literal := fmt.Sprintf("$f32.%08x", i32)
-                       s := ctxt.Lookup(literal, 0)
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
+                       p.From.Sym = ctxt.Float32Sym(f32)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
 
        case AMOVD:
                if p.From.Type == obj.TYPE_FCONST && chipfloat5(ctxt, p.From.Val.(float64)) < 0 && (chipzero5(ctxt, p.From.Val.(float64)) < 0 || p.Scond&C_SCOND != C_SCOND_NONE) {
-                       i64 := math.Float64bits(p.From.Val.(float64))
-                       literal := fmt.Sprintf("$f64.%016x", i64)
-                       s := ctxt.Lookup(literal, 0)
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
+                       p.From.Sym = ctxt.Float64Sym(p.From.Val.(float64))
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }

diff --git a/src/cmd/internal/obj/arm64/obj7.go b/src/cmd/internal/obj/arm64/obj7.go
index f1fdef236bd54ae2a5d56f1c7a1d03d5b9404f0d..b09454445aad922cd18c1884651a0416a9ddd067 100644 (file)
--- a/src/cmd/internal/obj/arm64/obj7.go
+++ b/src/cmd/internal/obj/arm64/obj7.go
@@ -33,7 +33,6 @@ package arm64
 import (
        "cmd/internal/obj"
        "cmd/internal/sys"
-       "fmt"
        "math"
 )
 
@@ -259,36 +258,27 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
        case AFMOVS:
                if p.From.Type == obj.TYPE_FCONST {
                        f32 := float32(p.From.Val.(float64))
-                       i32 := math.Float32bits(f32)
-                       if i32 == 0 {
+                       if math.Float32bits(f32) == 0 {
                                p.From.Type = obj.TYPE_REG
                                p.From.Reg = REGZERO
                                break
                        }
-                       literal := fmt.Sprintf("$f32.%08x", i32)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 4
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float32Sym(f32)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
 
        case AFMOVD:
                if p.From.Type == obj.TYPE_FCONST {
-                       i64 := math.Float64bits(p.From.Val.(float64))
-                       if i64 == 0 {
+                       f64 := p.From.Val.(float64)
+                       if math.Float64bits(f64) == 0 {
                                p.From.Type = obj.TYPE_REG
                                p.From.Reg = REGZERO
                                break
                        }
-                       literal := fmt.Sprintf("$f64.%016x", i64)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 8
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float64Sym(f64)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }

diff --git a/src/cmd/internal/obj/mips/obj0.go b/src/cmd/internal/obj/mips/obj0.go
index 86e3b920d5f90bbb28090bbf44b76e190cdef215..3724808be11699d585f680279afd68016552a27a 100644 (file)
--- a/src/cmd/internal/obj/mips/obj0.go
+++ b/src/cmd/internal/obj/mips/obj0.go
@@ -58,36 +58,29 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
        case AMOVF:
                if p.From.Type == obj.TYPE_FCONST {
                        f32 := float32(p.From.Val.(float64))
-                       i32 := math.Float32bits(f32)
-                       if i32 == 0 {
+                       if math.Float32bits(f32) == 0 {
                                p.As = AMOVW
                                p.From.Type = obj.TYPE_REG
                                p.From.Reg = REGZERO
                                break
                        }
-                       literal := fmt.Sprintf("$f32.%08x", i32)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 4
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
+                       p.From.Sym = ctxt.Float32Sym(f32)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
 
        case AMOVD:
                if p.From.Type == obj.TYPE_FCONST {
-                       i64 := math.Float64bits(p.From.Val.(float64))
-                       if i64 == 0 && ctxt.Arch.Family == sys.MIPS64 {
+                       f64 := p.From.Val.(float64)
+                       if math.Float64bits(f64) == 0 && ctxt.Arch.Family == sys.MIPS64 {
                                p.As = AMOVV
                                p.From.Type = obj.TYPE_REG
                                p.From.Reg = REGZERO
                                break
                        }
-                       literal := fmt.Sprintf("$f64.%016x", i64)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 8
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
+                       p.From.Sym = ctxt.Float64Sym(f64)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
@@ -95,11 +88,8 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
                // Put >32-bit constants in memory and load them
        case AMOVV:
                if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
-                       literal := fmt.Sprintf("$i64.%016x", uint64(p.From.Offset))
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 8
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
+                       p.From.Sym = ctxt.Int64Sym(p.From.Offset)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }

diff --git a/src/cmd/internal/obj/ppc64/obj9.go b/src/cmd/internal/obj/ppc64/obj9.go
index 96d10caeb2f592f976df28a14cbb597602f90cc0..6e93cc399685d496d86e9234dd5bf0984ed62671 100644 (file)
--- a/src/cmd/internal/obj/ppc64/obj9.go
+++ b/src/cmd/internal/obj/ppc64/obj9.go
@@ -32,8 +32,6 @@ package ppc64
 import (
        "cmd/internal/obj"
        "cmd/internal/sys"
-       "fmt"
-       "math"
 )
 
 func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
@@ -57,26 +55,17 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
        case AFMOVS:
                if p.From.Type == obj.TYPE_FCONST {
                        f32 := float32(p.From.Val.(float64))
-                       i32 := math.Float32bits(f32)
-                       literal := fmt.Sprintf("$f32.%08x", i32)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 4
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float32Sym(f32)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
 
        case AFMOVD:
                if p.From.Type == obj.TYPE_FCONST {
-                       i64 := math.Float64bits(p.From.Val.(float64))
-                       literal := fmt.Sprintf("$f64.%016x", i64)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 8
+                       f64 := p.From.Val.(float64)
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float64Sym(f64)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
@@ -84,12 +73,8 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
                // Put >32-bit constants in memory and load them
        case AMOVD:
                if p.From.Type == obj.TYPE_CONST && p.From.Name == obj.NAME_NONE && p.From.Reg == 0 && int64(int32(p.From.Offset)) != p.From.Offset {
-                       literal := fmt.Sprintf("$i64.%016x", uint64(p.From.Offset))
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 8
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Int64Sym(p.From.Offset)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }

diff --git a/src/cmd/internal/obj/s390x/objz.go b/src/cmd/internal/obj/s390x/objz.go
index 7b82ae4350feb5133b699d064fdff76086467fb0..3815db51fc9eb052ca7958584e955681e2cc7eba 100644 (file)
--- a/src/cmd/internal/obj/s390x/objz.go
+++ b/src/cmd/internal/obj/s390x/objz.go
@@ -32,7 +32,6 @@ package s390x
 import (
        "cmd/internal/obj"
        "cmd/internal/sys"
-       "fmt"
        "math"
 )
 
@@ -57,32 +56,23 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
        case AFMOVS:
                if p.From.Type == obj.TYPE_FCONST {
                        f32 := float32(p.From.Val.(float64))
-                       i32 := math.Float32bits(f32)
-                       if i32 == 0 { // +0
+                       if math.Float32bits(f32) == 0 { // +0
                                break
                        }
-                       literal := fmt.Sprintf("$f32.%08x", i32)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 4
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float32Sym(f32)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
 
        case AFMOVD:
                if p.From.Type == obj.TYPE_FCONST {
-                       i64 := math.Float64bits(p.From.Val.(float64))
-                       if i64 == 0 { // +0
+                       f64 := p.From.Val.(float64)
+                       if math.Float64bits(f64) == 0 { // +0
                                break
                        }
-                       literal := fmt.Sprintf("$f64.%016x", i64)
-                       s := ctxt.Lookup(literal, 0)
-                       s.Size = 8
                        p.From.Type = obj.TYPE_MEM
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float64Sym(f64)
                        p.From.Name = obj.NAME_EXTERN
                        p.From.Offset = 0
                }
@@ -94,12 +84,8 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
                        if int64(int32(val)) != val &&
                                int64(uint32(val)) != val &&
                                int64(uint64(val)&(0xffffffff<<32)) != val {
-                               literal := fmt.Sprintf("$i64.%016x", uint64(p.From.Offset))
-                               s := ctxt.Lookup(literal, 0)
-                               s.Size = 8
                                p.From.Type = obj.TYPE_MEM
-                               p.From.Sym = s
-                               p.From.Sym.Set(obj.AttrLocal, true)
+                               p.From.Sym = ctxt.Int64Sym(p.From.Offset)
                                p.From.Name = obj.NAME_EXTERN
                                p.From.Offset = 0
                        }

diff --git a/src/cmd/internal/obj/sym.go b/src/cmd/internal/obj/sym.go
index f5c1c8005a6b6439344f3a9b21691a71a94708c2..61d65f9e5f4e610e8063cfbd148d72ce7eb24b1a 100644 (file)
--- a/src/cmd/internal/obj/sym.go
+++ b/src/cmd/internal/obj/sym.go
@@ -32,7 +32,9 @@
 package obj
 
 import (
+       "fmt"
        "log"
+       "math"
        "os"
        "path/filepath"
 )
@@ -82,6 +84,32 @@ func (ctxt *Link) Lookup(name string, v int) *LSym {
        return s
 }
 
+func (ctxt *Link) Float32Sym(f float32) *LSym {
+       i := math.Float32bits(f)
+       name := fmt.Sprintf("$f32.%08x", i)
+       s := ctxt.Lookup(name, 0)
+       s.Size = 4
+       s.Set(AttrLocal, true)
+       return s
+}
+
+func (ctxt *Link) Float64Sym(f float64) *LSym {
+       i := math.Float64bits(f)
+       name := fmt.Sprintf("$f64.%016x", i)
+       s := ctxt.Lookup(name, 0)
+       s.Size = 8
+       s.Set(AttrLocal, true)
+       return s
+}
+
+func (ctxt *Link) Int64Sym(i int64) *LSym {
+       name := fmt.Sprintf("$i64.%016x", uint64(i))
+       s := ctxt.Lookup(name, 0)
+       s.Size = 8
+       s.Set(AttrLocal, true)
+       return s
+}
+
 func Linksymfmt(s *LSym) string {
        if s == nil {
                return "<nil>"

diff --git a/src/cmd/internal/obj/x86/obj6.go b/src/cmd/internal/obj/x86/obj6.go
index fb3756ad3108014bfefde92b25082ff7b108b302..29ec849893f7faf6cce2eb4b3d1e7ae7893be917 100644 (file)
--- a/src/cmd/internal/obj/x86/obj6.go
+++ b/src/cmd/internal/obj/x86/obj6.go
@@ -33,7 +33,6 @@ package x86
 import (
        "cmd/internal/obj"
        "cmd/internal/sys"
-       "fmt"
        "math"
        "strings"
 )
@@ -241,13 +240,9 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
                AUCOMISS:
                if p.From.Type == obj.TYPE_FCONST {
                        f32 := float32(p.From.Val.(float64))
-                       i32 := math.Float32bits(f32)
-                       literal := fmt.Sprintf("$f32.%08x", i32)
-                       s := ctxt.Lookup(literal, 0)
                        p.From.Type = obj.TYPE_MEM
                        p.From.Name = obj.NAME_EXTERN
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float32Sym(f32)
                        p.From.Offset = 0
                }
 
@@ -281,13 +276,10 @@ func progedit(ctxt *obj.Link, p *obj.Prog, newprog obj.ProgAlloc) {
                ACOMISD,
                AUCOMISD:
                if p.From.Type == obj.TYPE_FCONST {
-                       i64 := math.Float64bits(p.From.Val.(float64))
-                       literal := fmt.Sprintf("$f64.%016x", i64)
-                       s := ctxt.Lookup(literal, 0)
+                       f64 := p.From.Val.(float64)
                        p.From.Type = obj.TYPE_MEM
                        p.From.Name = obj.NAME_EXTERN
-                       p.From.Sym = s
-                       p.From.Sym.Set(obj.AttrLocal, true)
+                       p.From.Sym = ctxt.Float64Sym(f64)
                        p.From.Offset = 0
                }
        }