podman

1
/*
2
 * Copyright 2021 ByteDance Inc.
3
 *
4
 * Licensed under the Apache License, Version 2.0 (the "License");
5
 * you may not use this file except in compliance with the License.
6
 * You may obtain a copy of the License at
7
 *
8
 *     http://www.apache.org/licenses/LICENSE-2.0
9
 *
10
 * Unless required by applicable law or agreed to in writing, software
11
 * distributed under the License is distributed on an "AS IS" BASIS,
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
 * See the License for the specific language governing permissions and
14
 * limitations under the License.
15
 */
16

17
package jit
18

19
import (
20
    `encoding/binary`
21
    `strconv`
22
    `strings`
23
    `sync`
24

25
    `github.com/bytedance/sonic/loader`
26
    `github.com/bytedance/sonic/internal/rt`
27
    `github.com/twitchyliquid64/golang-asm/obj`
28
    `github.com/twitchyliquid64/golang-asm/obj/x86`
29
)
30

31
const (
32
    _LB_jump_pc = "_jump_pc_"
33
)
34

35
type BaseAssembler struct {
36
    i        int
37
    f        func()
38
    c        []byte
39
    o        sync.Once
40
    pb       *Backend
41
    xrefs    map[string][]*obj.Prog
42
    labels   map[string]*obj.Prog
43
    pendings map[string][]*obj.Prog
44
}
45

46
/** Instruction Encoders **/
47

48
var _NOPS = [][16]byte {
49
    {0x90},                                                     // NOP
50
    {0x66, 0x90},                                               // 66 NOP
51
    {0x0f, 0x1f, 0x00},                                         // NOP DWORD ptr [EAX]
52
    {0x0f, 0x1f, 0x40, 0x00},                                   // NOP DWORD ptr [EAX + 00H]
53
    {0x0f, 0x1f, 0x44, 0x00, 0x00},                             // NOP DWORD ptr [EAX + EAX*1 + 00H]
54
    {0x66, 0x0f, 0x1f, 0x44, 0x00, 0x00},                       // 66 NOP DWORD ptr [EAX + EAX*1 + 00H]
55
    {0x0f, 0x1f, 0x80, 0x00, 0x00, 0x00, 0x00},                 // NOP DWORD ptr [EAX + 00000000H]
56
    {0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},           // NOP DWORD ptr [EAX + EAX*1 + 00000000H]
57
    {0x66, 0x0f, 0x1f, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00},     // 66 NOP DWORD ptr [EAX + EAX*1 + 00000000H]
58
}
59

60
func (self *BaseAssembler) NOP() *obj.Prog {
61
    p := self.pb.New()
62
    p.As = obj.ANOP
63
    self.pb.Append(p)
64
    return p
65
}
66

67
func (self *BaseAssembler) NOPn(n int) {
68
    for i := len(_NOPS); i > 0 && n > 0; i-- {
69
        for ; n >= i; n -= i {
70
            self.Byte(_NOPS[i - 1][:i]...)
71
        }
72
    }
73
}
74

75
func (self *BaseAssembler) Byte(v ...byte) {
76
    for ; len(v) >= 8; v = v[8:] { self.From("QUAD", Imm(rt.Get64(v))) }
77
    for ; len(v) >= 4; v = v[4:] { self.From("LONG", Imm(int64(rt.Get32(v)))) }
78
    for ; len(v) >= 2; v = v[2:] { self.From("WORD", Imm(int64(rt.Get16(v)))) }
79
    for ; len(v) >= 1; v = v[1:] { self.From("BYTE", Imm(int64(v[0]))) }
80
}
81

82
func (self *BaseAssembler) Mark(pc int) {
83
    self.i++
84
    self.Link(_LB_jump_pc + strconv.Itoa(pc))
85
}
86

87
func (self *BaseAssembler) Link(to string) {
88
    var p *obj.Prog
89
    var v []*obj.Prog
90

91
    /* placeholder substitution */
92
    if strings.Contains(to, "{n}") {
93
        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
94
    }
95

96
    /* check for duplications */
97
    if _, ok := self.labels[to]; ok {
98
        panic("label " + to + " has already been linked")
99
    }
100

101
    /* get the pending links */
102
    p = self.NOP()
103
    v = self.pendings[to]
104

105
    /* patch all the pending jumps */
106
    for _, q := range v {
107
        q.To.Val = p
108
    }
109

110
    /* mark the label as resolved */
111
    self.labels[to] = p
112
    delete(self.pendings, to)
113
}
114

115
func (self *BaseAssembler) Xref(pc int, d int64) {
116
    self.Sref(_LB_jump_pc + strconv.Itoa(pc), d)
117
}
118

119
func (self *BaseAssembler) Sref(to string, d int64) {
120
    p := self.pb.New()
121
    p.As = x86.ALONG
122
    p.From = Imm(-d)
123

124
    /* placeholder substitution */
125
    if strings.Contains(to, "{n}") {
126
        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
127
    }
128

129
    /* record the patch point */
130
    self.pb.Append(p)
131
    self.xrefs[to] = append(self.xrefs[to], p)
132
}
133

134
func (self *BaseAssembler) Xjmp(op string, to int) {
135
    self.Sjmp(op, _LB_jump_pc + strconv.Itoa(to))
136
}
137

138
func (self *BaseAssembler) Sjmp(op string, to string) {
139
    p := self.pb.New()
140
    p.As = As(op)
141

142
    /* placeholder substitution */
143
    if strings.Contains(to, "{n}") {
144
        to = strings.ReplaceAll(to, "{n}", strconv.Itoa(self.i))
145
    }
146

147
    /* check for backward jumps */
148
    if v, ok := self.labels[to]; ok {
149
        p.To.Val = v
150
    } else {
151
        self.pendings[to] = append(self.pendings[to], p)
152
    }
153

154
    /* mark as a branch, and add to instruction buffer */
155
    p.To.Type = obj.TYPE_BRANCH
156
    self.pb.Append(p)
157
}
158

159
func (self *BaseAssembler) Rjmp(op string, to obj.Addr) {
160
    p := self.pb.New()
161
    p.To = to
162
    p.As = As(op)
163
    self.pb.Append(p)
164
}
165

166
func (self *BaseAssembler) From(op string, val obj.Addr) {
167
    p := self.pb.New()
168
    p.As = As(op)
169
    p.From = val
170
    self.pb.Append(p)
171
}
172

173
func (self *BaseAssembler) Emit(op string, args ...obj.Addr) {
174
    p := self.pb.New()
175
    p.As = As(op)
176
    self.assignOperands(p, args)
177
    self.pb.Append(p)
178
}
179

180
func (self *BaseAssembler) assignOperands(p *obj.Prog, args []obj.Addr) {
181
    switch len(args) {
182
        case 0  :
183
        case 1  : p.To                     = args[0]
184
        case 2  : p.To, p.From             = args[1], args[0]
185
        case 3  : p.To, p.From, p.RestArgs = args[2], args[0], args[1:2]
186
        case 4  : p.To, p.From, p.RestArgs = args[2], args[3], args[:2]
187
        default : panic("invalid operands")
188
    }
189
}
190

191
/** Assembler Helpers **/
192

193
func (self *BaseAssembler) Size() int {
194
    self.build()
195
    return len(self.c)
196
}
197

198
func (self *BaseAssembler) Init(f func()) {
199
    self.i = 0
200
    self.f = f
201
    self.c = nil
202
    self.o = sync.Once{}
203
}
204

205
var jitLoader = loader.Loader{
206
    Name: "sonic.jit.",
207
    File: "github.com/bytedance/sonic/jit.go",
208
    Options: loader.Options{
209
        NoPreempt: true,
210
    },
211
}
212

213
func (self *BaseAssembler) Load(name string, frameSize int, argSize int, argStackmap []bool, localStackmap []bool) loader.Function {
214
    self.build()
215
    return jitLoader.LoadOne(self.c, name, frameSize, argSize, argStackmap, localStackmap)
216
}
217

218
/** Assembler Stages **/
219

220
func (self *BaseAssembler) init() {
221
    self.pb       = newBackend("amd64")
222
    self.xrefs    = map[string][]*obj.Prog{}
223
    self.labels   = map[string]*obj.Prog{}
224
    self.pendings = map[string][]*obj.Prog{}
225
}
226

227
func (self *BaseAssembler) build() {
228
    self.o.Do(func() {
229
        self.init()
230
        self.f()
231
        self.validate()
232
        self.assemble()
233
        self.resolve()
234
        self.release()
235
    })
236
}
237

238
func (self *BaseAssembler) release() {
239
    self.pb.Release()
240
    self.pb = nil
241
    self.xrefs = nil
242
    self.labels = nil
243
    self.pendings = nil
244
}
245

246
func (self *BaseAssembler) resolve() {
247
    for s, v := range self.xrefs {
248
        for _, prog := range v {
249
            if prog.As != x86.ALONG {
250
                panic("invalid RIP relative reference")
251
            } else if p, ok := self.labels[s]; !ok {
252
                panic("links are not fully resolved: " + s)
253
            } else {
254
                off := prog.From.Offset + p.Pc - prog.Pc
255
                binary.LittleEndian.PutUint32(self.c[prog.Pc:], uint32(off))
256
            }
257
        }
258
    }
259
}
260

261
func (self *BaseAssembler) validate() {
262
    for key := range self.pendings {
263
        panic("links are not fully resolved: " + key)
264
    }
265
}
266

267
func (self *BaseAssembler) assemble() {
268
    self.c = self.pb.Assemble()
269
}
270