runtime,internal: move runtime/internal/math to internal/runtime/math

Cleanup and friction reduction.

Updates #65355.

Change-Id: I6c4fcd409d044c00d16561fe9ed2257877d73f5b
Reviewed-on: https://go-review.googlesource.com/c/go/+/600435
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>

2 files changed, 0 insertions, 134 deletions

diff --git a/src/runtime/internal/math/math.go b/src/runtime/internal/math/math.go
deleted file mode 100644
index b2e5508651..0000000000
--- a/src/runtime/internal/math/math.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package math
-
-import "internal/goarch"
-
-const MaxUintptr = ^uintptr(0)
-
-// MulUintptr returns a * b and whether the multiplication overflowed.
-// On supported platforms this is an intrinsic lowered by the compiler.
-func MulUintptr(a, b uintptr) (uintptr, bool) {
-	if a|b < 1<<(4*goarch.PtrSize) || a == 0 {
-		return a * b, false
-	}
-	overflow := b > MaxUintptr/a
-	return a * b, overflow
-}
-
-// Mul64 returns the 128-bit product of x and y: (hi, lo) = x * y
-// with the product bits' upper half returned in hi and the lower
-// half returned in lo.
-// This is a copy from math/bits.Mul64
-// On supported platforms this is an intrinsic lowered by the compiler.
-func Mul64(x, y uint64) (hi, lo uint64) {
-	const mask32 = 1<<32 - 1
-	x0 := x & mask32
-	x1 := x >> 32
-	y0 := y & mask32
-	y1 := y >> 32
-	w0 := x0 * y0
-	t := x1*y0 + w0>>32
-	w1 := t & mask32
-	w2 := t >> 32
-	w1 += x0 * y1
-	hi = x1*y1 + w2 + w1>>32
-	lo = x * y
-	return
-}
-
-// Add64 returns the sum with carry of x, y and carry: sum = x + y + carry.
-// The carry input must be 0 or 1; otherwise the behavior is undefined.
-// The carryOut output is guaranteed to be 0 or 1.
-//
-// This function's execution time does not depend on the inputs.
-// On supported platforms this is an intrinsic lowered by the compiler.
-func Add64(x, y, carry uint64) (sum, carryOut uint64) {
-	sum = x + y + carry
-	// The sum will overflow if both top bits are set (x & y) or if one of them
-	// is (x | y), and a carry from the lower place happened. If such a carry
-	// happens, the top bit will be 1 + 0 + 1 = 0 (&^ sum).
-	carryOut = ((x & y) | ((x | y) &^ sum)) >> 63
-	return
-}
diff --git a/src/runtime/internal/math/math_test.go b/src/runtime/internal/math/math_test.go
deleted file mode 100644
index 303eb63405..0000000000
--- a/src/runtime/internal/math/math_test.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2018 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package math_test
-
-import (
-	. "runtime/internal/math"
-	"testing"
-)
-
-const (
-	UintptrSize = 32 << (^uintptr(0) >> 63)
-)
-
-type mulUintptrTest struct {
-	a        uintptr
-	b        uintptr
-	overflow bool
-}
-
-var mulUintptrTests = []mulUintptrTest{
-	{0, 0, false},
-	{1000, 1000, false},
-	{MaxUintptr, 0, false},
-	{MaxUintptr, 1, false},
-	{MaxUintptr / 2, 2, false},
-	{MaxUintptr / 2, 3, true},
-	{MaxUintptr, 10, true},
-	{MaxUintptr, 100, true},
-	{MaxUintptr / 100, 100, false},
-	{MaxUintptr / 1000, 1001, true},
-	{1<<(UintptrSize/2) - 1, 1<<(UintptrSize/2) - 1, false},
-	{1 << (UintptrSize / 2), 1 << (UintptrSize / 2), true},
-	{MaxUintptr >> 32, MaxUintptr >> 32, false},
-	{MaxUintptr, MaxUintptr, true},
-}
-
-func TestMulUintptr(t *testing.T) {
-	for _, test := range mulUintptrTests {
-		a, b := test.a, test.b
-		for i := 0; i < 2; i++ {
-			mul, overflow := MulUintptr(a, b)
-			if mul != a*b || overflow != test.overflow {
-				t.Errorf("MulUintptr(%v, %v) = %v, %v want %v, %v",
-					a, b, mul, overflow, a*b, test.overflow)
-			}
-			a, b = b, a
-		}
-	}
-}
-
-var SinkUintptr uintptr
-var SinkBool bool
-
-var x, y uintptr
-
-func BenchmarkMulUintptr(b *testing.B) {
-	x, y = 1, 2
-	b.Run("small", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			var overflow bool
-			SinkUintptr, overflow = MulUintptr(x, y)
-			if overflow {
-				SinkUintptr = 0
-			}
-		}
-	})
-	x, y = MaxUintptr, MaxUintptr-1
-	b.Run("large", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			var overflow bool
-			SinkUintptr, overflow = MulUintptr(x, y)
-			if overflow {
-				SinkUintptr = 0
-			}
-		}
-	})
-}