mirror of
https://github.com/golang/go.git
synced 2025-12-08 06:10:04 +00:00
3f2cb493e5
Reuse the same mechanisms for handling universal builtins like len to handle unsafe.Sizeof, etc. Allows us to drop package unsafe's export data, and simplifies some code. Updates #17508. Change-Id: I620e0617c24e57e8a2d7cccd0e2de34608779656 Reviewed-on: https://go-review.googlesource.com/31433 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org>
481 lines
11 KiB
Go
481 lines
11 KiB
Go
// 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 gc
|
|
|
|
// builtinpkg is a fake package that declares the universe block.
|
|
var builtinpkg *Pkg
|
|
|
|
var itable *Type // distinguished *byte
|
|
|
|
var basicTypes = [...]struct {
|
|
name string
|
|
etype EType
|
|
}{
|
|
{"int8", TINT8},
|
|
{"int16", TINT16},
|
|
{"int32", TINT32},
|
|
{"int64", TINT64},
|
|
{"uint8", TUINT8},
|
|
{"uint16", TUINT16},
|
|
{"uint32", TUINT32},
|
|
{"uint64", TUINT64},
|
|
{"float32", TFLOAT32},
|
|
{"float64", TFLOAT64},
|
|
{"complex64", TCOMPLEX64},
|
|
{"complex128", TCOMPLEX128},
|
|
{"bool", TBOOL},
|
|
{"string", TSTRING},
|
|
{"any", TANY},
|
|
}
|
|
|
|
var typedefs = [...]struct {
|
|
name string
|
|
etype EType
|
|
width *int
|
|
sameas32 EType
|
|
sameas64 EType
|
|
}{
|
|
{"int", TINT, &Widthint, TINT32, TINT64},
|
|
{"uint", TUINT, &Widthint, TUINT32, TUINT64},
|
|
{"uintptr", TUINTPTR, &Widthptr, TUINT32, TUINT64},
|
|
}
|
|
|
|
var builtinFuncs = [...]struct {
|
|
name string
|
|
op Op
|
|
}{
|
|
{"append", OAPPEND},
|
|
{"cap", OCAP},
|
|
{"close", OCLOSE},
|
|
{"complex", OCOMPLEX},
|
|
{"copy", OCOPY},
|
|
{"delete", ODELETE},
|
|
{"imag", OIMAG},
|
|
{"len", OLEN},
|
|
{"make", OMAKE},
|
|
{"new", ONEW},
|
|
{"panic", OPANIC},
|
|
{"print", OPRINT},
|
|
{"println", OPRINTN},
|
|
{"real", OREAL},
|
|
{"recover", ORECOVER},
|
|
}
|
|
|
|
var unsafeFuncs = [...]struct {
|
|
name string
|
|
op Op
|
|
}{
|
|
{"Alignof", OALIGNOF},
|
|
{"Offsetof", OOFFSETOF},
|
|
{"Sizeof", OSIZEOF},
|
|
}
|
|
|
|
// initUniverse initializes the universe block.
|
|
func initUniverse() {
|
|
lexinit()
|
|
typeinit()
|
|
lexinit1()
|
|
}
|
|
|
|
// lexinit initializes known symbols and the basic types.
|
|
func lexinit() {
|
|
for _, s := range basicTypes {
|
|
etype := s.etype
|
|
if int(etype) >= len(Types) {
|
|
Fatalf("lexinit: %s bad etype", s.name)
|
|
}
|
|
s2 := Pkglookup(s.name, builtinpkg)
|
|
t := Types[etype]
|
|
if t == nil {
|
|
t = typ(etype)
|
|
t.Sym = s2
|
|
if etype != TANY && etype != TSTRING {
|
|
dowidth(t)
|
|
}
|
|
Types[etype] = t
|
|
}
|
|
s2.Def = typenod(t)
|
|
s2.Def.Name = new(Name)
|
|
}
|
|
|
|
for _, s := range builtinFuncs {
|
|
// TODO(marvin): Fix Node.EType type union.
|
|
s2 := Pkglookup(s.name, builtinpkg)
|
|
s2.Def = nod(ONAME, nil, nil)
|
|
s2.Def.Sym = s2
|
|
s2.Def.Etype = EType(s.op)
|
|
}
|
|
|
|
for _, s := range unsafeFuncs {
|
|
s2 := Pkglookup(s.name, unsafepkg)
|
|
s2.Def = nod(ONAME, nil, nil)
|
|
s2.Def.Sym = s2
|
|
s2.Def.Etype = EType(s.op)
|
|
}
|
|
|
|
idealstring = typ(TSTRING)
|
|
idealbool = typ(TBOOL)
|
|
|
|
s := Pkglookup("true", builtinpkg)
|
|
s.Def = nodbool(true)
|
|
s.Def.Sym = lookup("true")
|
|
s.Def.Name = new(Name)
|
|
s.Def.Type = idealbool
|
|
|
|
s = Pkglookup("false", builtinpkg)
|
|
s.Def = nodbool(false)
|
|
s.Def.Sym = lookup("false")
|
|
s.Def.Name = new(Name)
|
|
s.Def.Type = idealbool
|
|
|
|
s = lookup("_")
|
|
s.Block = -100
|
|
s.Def = nod(ONAME, nil, nil)
|
|
s.Def.Sym = s
|
|
Types[TBLANK] = typ(TBLANK)
|
|
s.Def.Type = Types[TBLANK]
|
|
nblank = s.Def
|
|
|
|
s = Pkglookup("_", builtinpkg)
|
|
s.Block = -100
|
|
s.Def = nod(ONAME, nil, nil)
|
|
s.Def.Sym = s
|
|
Types[TBLANK] = typ(TBLANK)
|
|
s.Def.Type = Types[TBLANK]
|
|
|
|
Types[TNIL] = typ(TNIL)
|
|
s = Pkglookup("nil", builtinpkg)
|
|
var v Val
|
|
v.U = new(NilVal)
|
|
s.Def = nodlit(v)
|
|
s.Def.Sym = s
|
|
s.Def.Name = new(Name)
|
|
|
|
s = Pkglookup("iota", builtinpkg)
|
|
s.Def = nod(OIOTA, nil, nil)
|
|
s.Def.Sym = s
|
|
s.Def.Name = new(Name)
|
|
}
|
|
|
|
func typeinit() {
|
|
if Widthptr == 0 {
|
|
Fatalf("typeinit before betypeinit")
|
|
}
|
|
|
|
for et := EType(0); et < NTYPE; et++ {
|
|
simtype[et] = et
|
|
}
|
|
|
|
Types[TPTR32] = typ(TPTR32)
|
|
dowidth(Types[TPTR32])
|
|
|
|
Types[TPTR64] = typ(TPTR64)
|
|
dowidth(Types[TPTR64])
|
|
|
|
t := typ(TUNSAFEPTR)
|
|
Types[TUNSAFEPTR] = t
|
|
t.Sym = Pkglookup("Pointer", unsafepkg)
|
|
t.Sym.Def = typenod(t)
|
|
t.Sym.Def.Name = new(Name)
|
|
dowidth(Types[TUNSAFEPTR])
|
|
|
|
Tptr = TPTR32
|
|
if Widthptr == 8 {
|
|
Tptr = TPTR64
|
|
}
|
|
|
|
for et := TINT8; et <= TUINT64; et++ {
|
|
isInt[et] = true
|
|
}
|
|
isInt[TINT] = true
|
|
isInt[TUINT] = true
|
|
isInt[TUINTPTR] = true
|
|
|
|
isFloat[TFLOAT32] = true
|
|
isFloat[TFLOAT64] = true
|
|
|
|
isComplex[TCOMPLEX64] = true
|
|
isComplex[TCOMPLEX128] = true
|
|
|
|
isforw[TFORW] = true
|
|
|
|
// initialize okfor
|
|
for et := EType(0); et < NTYPE; et++ {
|
|
if isInt[et] || et == TIDEAL {
|
|
okforeq[et] = true
|
|
okforcmp[et] = true
|
|
okforarith[et] = true
|
|
okforadd[et] = true
|
|
okforand[et] = true
|
|
okforconst[et] = true
|
|
issimple[et] = true
|
|
minintval[et] = new(Mpint)
|
|
maxintval[et] = new(Mpint)
|
|
}
|
|
|
|
if isFloat[et] {
|
|
okforeq[et] = true
|
|
okforcmp[et] = true
|
|
okforadd[et] = true
|
|
okforarith[et] = true
|
|
okforconst[et] = true
|
|
issimple[et] = true
|
|
minfltval[et] = newMpflt()
|
|
maxfltval[et] = newMpflt()
|
|
}
|
|
|
|
if isComplex[et] {
|
|
okforeq[et] = true
|
|
okforadd[et] = true
|
|
okforarith[et] = true
|
|
okforconst[et] = true
|
|
issimple[et] = true
|
|
}
|
|
}
|
|
|
|
issimple[TBOOL] = true
|
|
|
|
okforadd[TSTRING] = true
|
|
|
|
okforbool[TBOOL] = true
|
|
|
|
okforcap[TARRAY] = true
|
|
okforcap[TCHAN] = true
|
|
okforcap[TSLICE] = true
|
|
|
|
okforconst[TBOOL] = true
|
|
okforconst[TSTRING] = true
|
|
|
|
okforlen[TARRAY] = true
|
|
okforlen[TCHAN] = true
|
|
okforlen[TMAP] = true
|
|
okforlen[TSLICE] = true
|
|
okforlen[TSTRING] = true
|
|
|
|
okforeq[TPTR32] = true
|
|
okforeq[TPTR64] = true
|
|
okforeq[TUNSAFEPTR] = true
|
|
okforeq[TINTER] = true
|
|
okforeq[TCHAN] = true
|
|
okforeq[TSTRING] = true
|
|
okforeq[TBOOL] = true
|
|
okforeq[TMAP] = true // nil only; refined in typecheck
|
|
okforeq[TFUNC] = true // nil only; refined in typecheck
|
|
okforeq[TSLICE] = true // nil only; refined in typecheck
|
|
okforeq[TARRAY] = true // only if element type is comparable; refined in typecheck
|
|
okforeq[TSTRUCT] = true // only if all struct fields are comparable; refined in typecheck
|
|
|
|
okforcmp[TSTRING] = true
|
|
|
|
var i int
|
|
for i = 0; i < len(okfor); i++ {
|
|
okfor[i] = okfornone[:]
|
|
}
|
|
|
|
// binary
|
|
okfor[OADD] = okforadd[:]
|
|
|
|
okfor[OAND] = okforand[:]
|
|
okfor[OANDAND] = okforbool[:]
|
|
okfor[OANDNOT] = okforand[:]
|
|
okfor[ODIV] = okforarith[:]
|
|
okfor[OEQ] = okforeq[:]
|
|
okfor[OGE] = okforcmp[:]
|
|
okfor[OGT] = okforcmp[:]
|
|
okfor[OLE] = okforcmp[:]
|
|
okfor[OLT] = okforcmp[:]
|
|
okfor[OMOD] = okforand[:]
|
|
okfor[OHMUL] = okforarith[:]
|
|
okfor[OMUL] = okforarith[:]
|
|
okfor[ONE] = okforeq[:]
|
|
okfor[OOR] = okforand[:]
|
|
okfor[OOROR] = okforbool[:]
|
|
okfor[OSUB] = okforarith[:]
|
|
okfor[OXOR] = okforand[:]
|
|
okfor[OLSH] = okforand[:]
|
|
okfor[ORSH] = okforand[:]
|
|
|
|
// unary
|
|
okfor[OCOM] = okforand[:]
|
|
|
|
okfor[OMINUS] = okforarith[:]
|
|
okfor[ONOT] = okforbool[:]
|
|
okfor[OPLUS] = okforarith[:]
|
|
|
|
// special
|
|
okfor[OCAP] = okforcap[:]
|
|
|
|
okfor[OLEN] = okforlen[:]
|
|
|
|
// comparison
|
|
iscmp[OLT] = true
|
|
|
|
iscmp[OGT] = true
|
|
iscmp[OGE] = true
|
|
iscmp[OLE] = true
|
|
iscmp[OEQ] = true
|
|
iscmp[ONE] = true
|
|
|
|
maxintval[TINT8].SetString("0x7f")
|
|
minintval[TINT8].SetString("-0x80")
|
|
maxintval[TINT16].SetString("0x7fff")
|
|
minintval[TINT16].SetString("-0x8000")
|
|
maxintval[TINT32].SetString("0x7fffffff")
|
|
minintval[TINT32].SetString("-0x80000000")
|
|
maxintval[TINT64].SetString("0x7fffffffffffffff")
|
|
minintval[TINT64].SetString("-0x8000000000000000")
|
|
|
|
maxintval[TUINT8].SetString("0xff")
|
|
maxintval[TUINT16].SetString("0xffff")
|
|
maxintval[TUINT32].SetString("0xffffffff")
|
|
maxintval[TUINT64].SetString("0xffffffffffffffff")
|
|
|
|
// f is valid float if min < f < max. (min and max are not themselves valid.)
|
|
maxfltval[TFLOAT32].SetString("33554431p103") // 2^24-1 p (127-23) + 1/2 ulp
|
|
minfltval[TFLOAT32].SetString("-33554431p103")
|
|
maxfltval[TFLOAT64].SetString("18014398509481983p970") // 2^53-1 p (1023-52) + 1/2 ulp
|
|
minfltval[TFLOAT64].SetString("-18014398509481983p970")
|
|
|
|
maxfltval[TCOMPLEX64] = maxfltval[TFLOAT32]
|
|
minfltval[TCOMPLEX64] = minfltval[TFLOAT32]
|
|
maxfltval[TCOMPLEX128] = maxfltval[TFLOAT64]
|
|
minfltval[TCOMPLEX128] = minfltval[TFLOAT64]
|
|
|
|
// for walk to use in error messages
|
|
Types[TFUNC] = functype(nil, nil, nil)
|
|
|
|
// types used in front end
|
|
// types[TNIL] got set early in lexinit
|
|
Types[TIDEAL] = typ(TIDEAL)
|
|
|
|
Types[TINTER] = typ(TINTER)
|
|
|
|
// simple aliases
|
|
simtype[TMAP] = Tptr
|
|
|
|
simtype[TCHAN] = Tptr
|
|
simtype[TFUNC] = Tptr
|
|
simtype[TUNSAFEPTR] = Tptr
|
|
|
|
array_array = int(Rnd(0, int64(Widthptr)))
|
|
array_nel = int(Rnd(int64(array_array)+int64(Widthptr), int64(Widthint)))
|
|
array_cap = int(Rnd(int64(array_nel)+int64(Widthint), int64(Widthint)))
|
|
sizeof_Array = int(Rnd(int64(array_cap)+int64(Widthint), int64(Widthptr)))
|
|
|
|
// string is same as slice wo the cap
|
|
sizeof_String = int(Rnd(int64(array_nel)+int64(Widthint), int64(Widthptr)))
|
|
|
|
dowidth(Types[TSTRING])
|
|
dowidth(idealstring)
|
|
|
|
itable = typPtr(Types[TUINT8])
|
|
}
|
|
|
|
func makeErrorInterface() *Type {
|
|
rcvr := typ(TSTRUCT)
|
|
rcvr.StructType().Funarg = FunargRcvr
|
|
field := newField()
|
|
field.Type = ptrto(typ(TSTRUCT))
|
|
rcvr.SetFields([]*Field{field})
|
|
|
|
in := typ(TSTRUCT)
|
|
in.StructType().Funarg = FunargParams
|
|
|
|
out := typ(TSTRUCT)
|
|
out.StructType().Funarg = FunargResults
|
|
field = newField()
|
|
field.Type = Types[TSTRING]
|
|
out.SetFields([]*Field{field})
|
|
|
|
f := typ(TFUNC)
|
|
f.FuncType().Receiver = rcvr
|
|
f.FuncType().Results = out
|
|
f.FuncType().Params = in
|
|
|
|
t := typ(TINTER)
|
|
field = newField()
|
|
field.Sym = lookup("Error")
|
|
field.Type = f
|
|
t.SetFields([]*Field{field})
|
|
|
|
return t
|
|
}
|
|
|
|
func lexinit1() {
|
|
// error type
|
|
s := Pkglookup("error", builtinpkg)
|
|
errortype = makeErrorInterface()
|
|
errortype.Sym = s
|
|
// TODO: If we can prove that it's safe to set errortype.Orig here
|
|
// than we don't need the special errortype/errorInterface case in
|
|
// bexport.go. See also issue #15920.
|
|
// errortype.Orig = makeErrorInterface()
|
|
s.Def = typenod(errortype)
|
|
|
|
// byte alias
|
|
s = Pkglookup("byte", builtinpkg)
|
|
bytetype = typ(TUINT8)
|
|
bytetype.Sym = s
|
|
s.Def = typenod(bytetype)
|
|
s.Def.Name = new(Name)
|
|
|
|
// rune alias
|
|
s = Pkglookup("rune", builtinpkg)
|
|
runetype = typ(TINT32)
|
|
runetype.Sym = s
|
|
s.Def = typenod(runetype)
|
|
s.Def.Name = new(Name)
|
|
|
|
// backend-dependent builtin types (e.g. int).
|
|
for _, s := range typedefs {
|
|
s1 := Pkglookup(s.name, builtinpkg)
|
|
|
|
sameas := s.sameas32
|
|
if *s.width == 8 {
|
|
sameas = s.sameas64
|
|
}
|
|
|
|
simtype[s.etype] = sameas
|
|
minfltval[s.etype] = minfltval[sameas]
|
|
maxfltval[s.etype] = maxfltval[sameas]
|
|
minintval[s.etype] = minintval[sameas]
|
|
maxintval[s.etype] = maxintval[sameas]
|
|
|
|
t := typ(s.etype)
|
|
t.Sym = s1
|
|
Types[s.etype] = t
|
|
s1.Def = typenod(t)
|
|
s1.Def.Name = new(Name)
|
|
s1.Origpkg = builtinpkg
|
|
|
|
dowidth(t)
|
|
}
|
|
}
|
|
|
|
// finishUniverse makes the universe block visible within the current package.
|
|
func finishUniverse() {
|
|
// Operationally, this is similar to a dot import of builtinpkg, except
|
|
// that we silently skip symbols that are already declared in the
|
|
// package block rather than emitting a redeclared symbol error.
|
|
|
|
for _, s := range builtinpkg.Syms {
|
|
if s.Def == nil || (s.Name == "any" && Debug['A'] == 0) {
|
|
continue
|
|
}
|
|
s1 := lookup(s.Name)
|
|
if s1.Def != nil {
|
|
continue
|
|
}
|
|
|
|
s1.Def = s.Def
|
|
s1.Block = s.Block
|
|
}
|
|
|
|
nodfp = nod(ONAME, nil, nil)
|
|
nodfp.Type = Types[TINT32]
|
|
nodfp.Xoffset = 0
|
|
nodfp.Class = PPARAM
|
|
nodfp.Sym = lookup(".fp")
|
|
}
|