blob: bfe7d2bb436c8999631fdbf364c7c766006118a5 [file] [log] [blame]
 // Copyright 2009 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 ir import ( "go/constant" "math" "cmd/compile/internal/base" "cmd/compile/internal/types" ) func ConstType(n Node) constant.Kind { if n == nil || n.Op() != OLITERAL { return constant.Unknown } 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. // Note: if t is uint64, very large values will be converted to negative int64. func IntVal(t *types.Type, v constant.Value) int64 { if t.IsUnsigned() { if x, ok := constant.Uint64Val(v); ok { return int64(x) } } else { if x, ok := constant.Int64Val(v); ok { return x } } base.Fatalf("%v out of range for %v", v, t) 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) { if !ValidTypeForConst(t, v) { base.Fatalf("%v (%v) does not represent %v (%v)", t, t.Kind(), v, v.Kind()) } } func ValidTypeForConst(t *types.Type, v constant.Value) bool { switch v.Kind() { case constant.Unknown: return OKForConst[t.Kind()] case constant.Bool: return t.IsBoolean() case constant.String: return t.IsString() case constant.Int: return t.IsInteger() case constant.Float: return t.IsFloat() case constant.Complex: return t.IsComplex() } base.Fatalf("unexpected constant kind: %v", v) panic("unreachable") } // NewLiteral returns a new untyped constant with value v. func NewLiteral(v constant.Value) Node { return NewBasicLit(base.Pos, v) } func idealType(ct constant.Kind) *types.Type { switch ct { case constant.String: return types.UntypedString case constant.Bool: return types.UntypedBool case constant.Int: return types.UntypedInt case constant.Float: return types.UntypedFloat case constant.Complex: return types.UntypedComplex } base.Fatalf("unexpected Ctype: %v", ct) return nil } 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. // n must be an integer or rune constant. func Int64Val(n Node) int64 { if !IsConst(n, constant.Int) { base.Fatalf("Int64Val(%v)", n) } x, ok := constant.Int64Val(n.Val()) if !ok { base.Fatalf("Int64Val(%v)", n) } return x } // Uint64Val returns n as an uint64. // n must be an integer or rune constant. func Uint64Val(n Node) uint64 { if !IsConst(n, constant.Int) { base.Fatalf("Uint64Val(%v)", n) } x, ok := constant.Uint64Val(n.Val()) if !ok { base.Fatalf("Uint64Val(%v)", n) } return x } // BoolVal returns n as a bool. // n must be a boolean constant. func BoolVal(n Node) bool { if !IsConst(n, constant.Bool) { base.Fatalf("BoolVal(%v)", n) } return constant.BoolVal(n.Val()) } // StringVal returns the value of a literal string Node as a string. // n must be a string constant. func StringVal(n Node) string { if !IsConst(n, constant.String) { base.Fatalf("StringVal(%v)", n) } return constant.StringVal(n.Val()) }