qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-24 09:30:07 -07:00
Code Releases Activity

cmd/compile/internal/ir: remove un-used code for const

Browse Source 
CL 390474 removed last usages of ConstValue, it can now be removed, and
also Float64Val, since when it's only used by ConstValue.

CanInt64 is un-used for a long time, its original form last usage was
removed in CL 221802.

Change-Id: Id142b0da49c319faca73ef1b2090325f81431321
Reviewed-on: https://go-review.googlesource.com/c/go/+/396078
Trust: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Cuong Manh Le 2022-03-28 21:41:19 +07:00
parent 5fcc6554d9
commit b10164b292
1 changed files with 0 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/cmd/compile/internal/ir/val.go
View File

@ -6,7 +6,6 @@ package ir
import ( import (
"go/constant" "go/constant"
"math"
"cmd/compile/internal/base" "cmd/compile/internal/base"
"cmd/compile/internal/types" "cmd/compile/internal/types"
@ -19,27 +18,6 @@ func ConstType(n Node) constant.Kind {
return n.Val().Kind() return n.Val().Kind()
} }
// ConstValue returns the constant value stored in n as an interface{}.
// It returns int64s for ints and runes, float64s for floats,
// and complex128s for complex values.
func ConstValue(n Node) interface{} {
switch v := n.Val(); v.Kind() {
default:
base.Fatalf("unexpected constant: %v", v)
panic("unreachable")
case constant.Bool:
return constant.BoolVal(v)
case constant.String:
return constant.StringVal(v)
case constant.Int:
return IntVal(n.Type(), v)
case constant.Float:
return Float64Val(v)
case constant.Complex:
return complex(Float64Val(constant.Real(v)), Float64Val(constant.Imag(v)))
}
}
// IntVal returns v converted to int64. // IntVal returns v converted to int64.
// Note: if t is uint64, very large values will be converted to negative int64. // Note: if t is uint64, very large values will be converted to negative int64.
func IntVal(t *types.Type, v constant.Value) int64 { func IntVal(t *types.Type, v constant.Value) int64 {
@ -56,14 +34,6 @@ func IntVal(t *types.Type, v constant.Value) int64 {
panic("unreachable") panic("unreachable")
} }
func Float64Val(v constant.Value) float64 {
if x, _ := constant.Float64Val(v); !math.IsInf(x, 0) {
return x + 0 // avoid -0 (should not be needed, but be conservative)
}
base.Fatalf("bad float64 value: %v", v)
panic("unreachable")
}
func AssertValidTypeForConst(t *types.Type, v constant.Value) { func AssertValidTypeForConst(t *types.Type, v constant.Value) {
if !ValidTypeForConst(t, v) { if !ValidTypeForConst(t, v) {
base.Fatalf("%v (%v) does not represent %v (%v)", t, t.Kind(), v, v.Kind()) base.Fatalf("%v (%v) does not represent %v (%v)", t, t.Kind(), v, v.Kind())
@ -114,18 +84,6 @@ func idealType(ct constant.Kind) *types.Type {
var OKForConst [types.NTYPE]bool var OKForConst [types.NTYPE]bool
// CanInt64 reports whether it is safe to call Int64Val() on n.
func CanInt64(n Node) bool {
if !IsConst(n, constant.Int) {
return false
}
// if the value inside n cannot be represented as an int64, the
// return value of Int64 is undefined
_, ok := constant.Int64Val(n.Val())
return ok
}
// Int64Val returns n as an int64. // Int64Val returns n as an int64.
// n must be an integer or rune constant. // n must be an integer or rune constant.
func Int64Val(n Node) int64 { func Int64Val(n Node) int64 {