cmd/internal/gc, cmd/[56789]g: rename stackcopy to blockcopy

To avoid confusion with the runtime concept of copying stack.

Change-Id: I33442377b71012c2482c2d0ddd561492c71e70d0
Reviewed-on: https://go-review.googlesource.com/8639
Reviewed-by: Dave Cheney <dave@cheney.net>
Reviewed-by: Russ Cox <rsc@golang.org>

diff --git a/src/cmd/5g/cgen.go b/src/cmd/5g/cgen.go
index a79c55fd494673bd0ab641657a1e000c5f4ae119..2e922391cb8271606b4804663b2a2f0bb07539b3 100644 (file)
--- a/src/cmd/5g/cgen.go
+++ b/src/cmd/5g/cgen.go
@@ -75,7 +75,7 @@ func gencmp0(n *gc.Node, t *gc.Type, o int, likely int, to *obj.Prog) {
        gc.Regfree(&n1)
 }
 
-func stackcopy(n, res *gc.Node, osrc, odst, w int64) {
+func blockcopy(n, res *gc.Node, osrc, odst, w int64) {
        // determine alignment.
        // want to avoid unaligned access, so have to use
        // smaller operations for less aligned types.

diff --git a/src/cmd/5g/galign.go b/src/cmd/5g/galign.go
index 51c6e1e45af9ea625fc2e4ffef846da41b0c58c2..3c8ba519ebc120bf709300970a994c6f3efca31b 100644 (file)
--- a/src/cmd/5g/galign.go
+++ b/src/cmd/5g/galign.go
@@ -76,7 +76,7 @@ func main() {
        gc.Thearch.Sameaddr = sameaddr
        gc.Thearch.Smallindir = smallindir
        gc.Thearch.Stackaddr = stackaddr
-       gc.Thearch.Stackcopy = stackcopy
+       gc.Thearch.Blockcopy = blockcopy
        gc.Thearch.Sudoaddable = sudoaddable
        gc.Thearch.Sudoclean = sudoclean
        gc.Thearch.Excludedregs = excludedregs

diff --git a/src/cmd/6g/cgen.go b/src/cmd/6g/cgen.go
index 4ed97fa5894e601a392ef204486ee178e7c47665..23e2d1b57ff7c59ae5a22d0bbd579fbfa1442f16 100644 (file)
--- a/src/cmd/6g/cgen.go
+++ b/src/cmd/6g/cgen.go
@@ -10,7 +10,7 @@ import (
        "cmd/internal/obj/x86"
 )
 
-func stackcopy(n, ns *gc.Node, osrc, odst, w int64) {
+func blockcopy(n, ns *gc.Node, osrc, odst, w int64) {
        var noddi gc.Node
        gc.Nodreg(&noddi, gc.Types[gc.Tptr], x86.REG_DI)
        var nodsi gc.Node

diff --git a/src/cmd/6g/galign.go b/src/cmd/6g/galign.go
index 5b41a670ec2801394912e1f8816f3a80fb4c1423..0ca87537ff82577f61198563140980c17b712385 100644 (file)
--- a/src/cmd/6g/galign.go
+++ b/src/cmd/6g/galign.go
@@ -111,7 +111,7 @@ func main() {
        gc.Thearch.Sameaddr = sameaddr
        gc.Thearch.Smallindir = smallindir
        gc.Thearch.Stackaddr = stackaddr
-       gc.Thearch.Stackcopy = stackcopy
+       gc.Thearch.Blockcopy = blockcopy
        gc.Thearch.Sudoaddable = sudoaddable
        gc.Thearch.Sudoclean = sudoclean
        gc.Thearch.Excludedregs = excludedregs

diff --git a/src/cmd/7g/cgen.go b/src/cmd/7g/cgen.go
index 1d4f391d75f231c52671344aa95c98994350a763..6f268b41856c111b6d4ecb9a1098f3c53ee6c383 100644 (file)
--- a/src/cmd/7g/cgen.go
+++ b/src/cmd/7g/cgen.go
@@ -10,7 +10,7 @@ import (
        "cmd/internal/obj/arm64"
 )
 
-func stackcopy(n, res *gc.Node, osrc, odst, w int64) {
+func blockcopy(n, res *gc.Node, osrc, odst, w int64) {
        // determine alignment.
        // want to avoid unaligned access, so have to use
        // smaller operations for less aligned types.

diff --git a/src/cmd/7g/galign.go b/src/cmd/7g/galign.go
index 3ad786a8fd4bf28c2f8b9c12fb1ee7baebaa77a9..34b4ab6142c34958a453872a42aade5825f146fb 100644 (file)
--- a/src/cmd/7g/galign.go
+++ b/src/cmd/7g/galign.go
@@ -75,7 +75,7 @@ func main() {
        gc.Thearch.Sameaddr = sameaddr
        gc.Thearch.Smallindir = smallindir
        gc.Thearch.Stackaddr = stackaddr
-       gc.Thearch.Stackcopy = stackcopy
+       gc.Thearch.Blockcopy = blockcopy
        gc.Thearch.Sudoaddable = sudoaddable
        gc.Thearch.Sudoclean = sudoclean
        gc.Thearch.Excludedregs = excludedregs

diff --git a/src/cmd/8g/cgen.go b/src/cmd/8g/cgen.go
index 0b93694f2c28f15e8d7955ce8dd0bbf3868f0dad..dfbdafefe3c487551671793cd3411d901e3d26d6 100644 (file)
--- a/src/cmd/8g/cgen.go
+++ b/src/cmd/8g/cgen.go
@@ -48,7 +48,7 @@ func igenindex(n *gc.Node, res *gc.Node, bounded bool) *obj.Prog {
        return gc.Gbranch(x86.AJNE, nil, +1)
 }
 
-func stackcopy(n, res *gc.Node, osrc, odst, w int64) {
+func blockcopy(n, res *gc.Node, osrc, odst, w int64) {
        var dst gc.Node
        gc.Nodreg(&dst, gc.Types[gc.Tptr], x86.REG_DI)
        var src gc.Node

diff --git a/src/cmd/8g/galign.go b/src/cmd/8g/galign.go
index 36328dc0022aa6b9bfa3121686631e2e0f070798..9eb1cf5d0852c3648bcc793f98d574ca3f2863e4 100644 (file)
--- a/src/cmd/8g/galign.go
+++ b/src/cmd/8g/galign.go
@@ -89,7 +89,7 @@ func main() {
        gc.Thearch.Sameaddr = sameaddr
        gc.Thearch.Smallindir = smallindir
        gc.Thearch.Stackaddr = stackaddr
-       gc.Thearch.Stackcopy = stackcopy
+       gc.Thearch.Blockcopy = blockcopy
        gc.Thearch.Sudoaddable = sudoaddable
        gc.Thearch.Sudoclean = sudoclean
        gc.Thearch.Excludedregs = excludedregs

diff --git a/src/cmd/9g/cgen.go b/src/cmd/9g/cgen.go
index feadfeb9a90682fc5fa71908ac27bb9f439dbd55..5d24a6ff67194185ec93fd57423958fd80e06672 100644 (file)
--- a/src/cmd/9g/cgen.go
+++ b/src/cmd/9g/cgen.go
@@ -10,7 +10,7 @@ import (
        "cmd/internal/obj/ppc64"
 )
 
-func stackcopy(n, res *gc.Node, osrc, odst, w int64) {
+func blockcopy(n, res *gc.Node, osrc, odst, w int64) {
        // determine alignment.
        // want to avoid unaligned access, so have to use
        // smaller operations for less aligned types.

diff --git a/src/cmd/9g/galign.go b/src/cmd/9g/galign.go
index 4aa84f8b627baeee06603f00f505f3e7c8fb94a0..a2f4a0ef89cee1b5b6d5113e758e50fca1549630 100644 (file)
--- a/src/cmd/9g/galign.go
+++ b/src/cmd/9g/galign.go
@@ -82,7 +82,7 @@ func main() {
        gc.Thearch.Sameaddr = sameaddr
        gc.Thearch.Smallindir = smallindir
        gc.Thearch.Stackaddr = stackaddr
-       gc.Thearch.Stackcopy = stackcopy
+       gc.Thearch.Blockcopy = blockcopy
        gc.Thearch.Sudoaddable = sudoaddable
        gc.Thearch.Sudoclean = sudoclean
        gc.Thearch.Excludedregs = excludedregs

diff --git a/src/cmd/internal/gc/cgen.go b/src/cmd/internal/gc/cgen.go
index d24db5ff683fbe1d23df7b924af1f344063a6eac..3fea97e0a61b587100f5a529c701de4362d544c9 100644 (file)
--- a/src/cmd/internal/gc/cgen.go
+++ b/src/cmd/internal/gc/cgen.go
@@ -2312,7 +2312,7 @@ func sgen_wb(n *Node, ns *Node, w int64, wb bool) {
                return
        }
 
-       Thearch.Stackcopy(n, ns, osrc, odst, w)
+       Thearch.Blockcopy(n, ns, osrc, odst, w)
 }
 
 /*

diff --git a/src/cmd/internal/gc/go.go b/src/cmd/internal/gc/go.go
index d399ebbd36d510948419187159eed238f0d411b8..2d85f5858045cf7846d3eebb782b1c17ef623c19 100644 (file)
--- a/src/cmd/internal/gc/go.go
+++ b/src/cmd/internal/gc/go.go
@@ -809,7 +809,7 @@ type Arch struct {
        Sameaddr     func(*obj.Addr, *obj.Addr) bool
        Smallindir   func(*obj.Addr, *obj.Addr) bool
        Stackaddr    func(*obj.Addr) bool
-       Stackcopy    func(*Node, *Node, int64, int64, int64)
+       Blockcopy    func(*Node, *Node, int64, int64, int64)
        Sudoaddable  func(int, *Node, *obj.Addr) bool
        Sudoclean    func()
        Excludedregs func() uint64

diff --git a/src/runtime/mkduff.go b/src/runtime/mkduff.go
index c0e46f9f854871635125dfd2d4c2240101f1d84b..dc94cee5c7ff752375f9ad0d0ad68cdd6bbf58c8 100644 (file)
--- a/src/runtime/mkduff.go
+++ b/src/runtime/mkduff.go
@@ -15,7 +15,7 @@
 // the routine to copy chunks of memory.
 // Source and destination must not overlap.
 // Do not change duffcopy without also
-// changing stackcopy in cmd/?g/cgen.go.
+// changing blockcopy in cmd/?g/cgen.go.
 
 // See the zero* and copy* generators below
 // for architecture-specific comments.