1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// 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 types
import (
"cmd/compile/internal/base"
"cmd/internal/src"
)
var basicTypes = [...]struct {
name string
etype Kind
}{
{"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},
}
var typedefs = [...]struct {
name string
etype Kind
sameas32 Kind
sameas64 Kind
}{
{"int", TINT, TINT32, TINT64},
{"uint", TUINT, TUINT32, TUINT64},
{"uintptr", TUINTPTR, TUINT32, TUINT64},
}
func InitTypes(defTypeName func(sym *Sym, typ *Type) Object) {
if PtrSize == 0 {
base.Fatalf("typeinit before betypeinit")
}
SlicePtrOffset = 0
SliceLenOffset = Rnd(SlicePtrOffset+int64(PtrSize), int64(PtrSize))
SliceCapOffset = Rnd(SliceLenOffset+int64(PtrSize), int64(PtrSize))
SliceSize = Rnd(SliceCapOffset+int64(PtrSize), int64(PtrSize))
// string is same as slice wo the cap
StringSize = Rnd(SliceLenOffset+int64(PtrSize), int64(PtrSize))
for et := Kind(0); et < NTYPE; et++ {
SimType[et] = et
}
Types[TANY] = New(TANY)
Types[TINTER] = NewInterface(LocalPkg, nil)
defBasic := func(kind Kind, pkg *Pkg, name string) *Type {
typ := New(kind)
obj := defTypeName(pkg.Lookup(name), typ)
typ.sym = obj.Sym()
typ.nod = obj
if kind != TANY {
CheckSize(typ)
}
return typ
}
for _, s := range &basicTypes {
Types[s.etype] = defBasic(s.etype, BuiltinPkg, s.name)
}
for _, s := range &typedefs {
sameas := s.sameas32
if PtrSize == 8 {
sameas = s.sameas64
}
SimType[s.etype] = sameas
Types[s.etype] = defBasic(s.etype, BuiltinPkg, s.name)
}
// We create separate byte and rune types for better error messages
// rather than just creating type alias *Sym's for the uint8 and
// int32 Hence, (bytetype|runtype).Sym.isAlias() is false.
// TODO(gri) Should we get rid of this special case (at the cost
// of less informative error messages involving bytes and runes)?
// (Alternatively, we could introduce an OTALIAS node representing
// type aliases, albeit at the cost of having to deal with it everywhere).
ByteType = defBasic(TUINT8, BuiltinPkg, "byte")
RuneType = defBasic(TINT32, BuiltinPkg, "rune")
// error type
DeferCheckSize()
ErrorType = defBasic(TFORW, BuiltinPkg, "error")
ErrorType.SetUnderlying(makeErrorInterface())
ResumeCheckSize()
// comparable type (interface)
DeferCheckSize()
ComparableType = defBasic(TFORW, BuiltinPkg, "comparable")
ComparableType.SetUnderlying(makeComparableInterface())
ResumeCheckSize()
Types[TUNSAFEPTR] = defBasic(TUNSAFEPTR, UnsafePkg, "Pointer")
// simple aliases
SimType[TMAP] = TPTR
SimType[TCHAN] = TPTR
SimType[TFUNC] = TPTR
SimType[TUNSAFEPTR] = TPTR
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
}
func makeErrorInterface() *Type {
sig := NewSignature(NoPkg, FakeRecv(), nil, nil, []*Field{
NewField(src.NoXPos, nil, Types[TSTRING]),
})
method := NewField(src.NoXPos, LocalPkg.Lookup("Error"), sig)
return NewInterface(NoPkg, []*Field{method})
}
func makeComparableInterface() *Type {
sig := NewSignature(NoPkg, FakeRecv(), nil, nil, nil)
method := NewField(src.NoXPos, LocalPkg.Lookup("=="), sig)
return NewInterface(NoPkg, []*Field{method})
}
|