Debian Codegraph @

internal/engine/wazevo/backend/isa/arm64/machine_test.go

raw
1 package arm64
2
3 import (
4 "testing"
5
6 "github.com/tetratelabs/wazero/internal/engine/wazevo/backend"
7 "github.com/tetratelabs/wazero/internal/engine/wazevo/backend/regalloc"
8 "github.com/tetratelabs/wazero/internal/testing/require"
9 )
10
11 func TestMachine_resolveAddressingMode(t *testing.T) {
12 m := NewBackend().(*machine)
13 t.Run("imm12/arg", func(t *testing.T) {
14 i := &instruction{}
15 amode := m.amodePool.Allocate()
16 *amode = addressMode{
17 kind: addressModeKindArgStackSpace,
18 rn: spVReg,
19 imm: 128,
20 }
21 i.asULoad(x17VReg, amode, 64)
22 m.resolveAddressingMode(1024, 0, i)
23 require.Equal(t, addressModeKindRegUnsignedImm12, i.getAmode().kind)
24 require.Equal(t, int64(128+1024), i.getAmode().imm)
25 })
26 t.Run("imm12/result", func(t *testing.T) {
27 i := &instruction{}
28 amode := m.amodePool.Allocate()
29 *amode = addressMode{
30 kind: addressModeKindResultStackSpace,
31 rn: spVReg,
32 imm: 128,
33 }
34 i.asULoad(x17VReg, amode, 64)
35 m.resolveAddressingMode(0, 256, i)
36 require.Equal(t, addressModeKindRegUnsignedImm12, i.getAmode().kind)
37 require.Equal(t, int64(128+256), i.getAmode().imm)
38 })
39
40 t.Run("tmp reg", func(t *testing.T) {
41 root := &instruction{kind: udf}
42 i := &instruction{prev: root}
43 amode := m.amodePool.Allocate()
44 *amode = addressMode{
45 kind: addressModeKindResultStackSpace,
46 rn: spVReg,
47 }
48 i.asULoad(x17VReg, amode, 64)
49 m.resolveAddressingMode(0, 0x40000001, i)
50
51 m.rootInstr = root
52 require.Equal(t, `
53 udf
54 movz x27, #0x1, lsl 0
55 movk x27, #0x4000, lsl 16
56 ldr x17, [sp, x27]
57 `, m.Format())
58 })
59 }
60
61 func TestMachine_clobberedRegSlotSize(t *testing.T) {
62 m := &machine{clobberedRegs: make([]regalloc.VReg, 10)}
63 require.Equal(t, int64(160), m.clobberedRegSlotSize())
64 }
65
66 func TestMachine_frameSize(t *testing.T) {
67 m := &machine{clobberedRegs: make([]regalloc.VReg, 10), spillSlotSize: 16 * 8}
68 require.Equal(t, int64(16*18), m.frameSize())
69 }
70
71 func TestMachine_requiredStackSize(t *testing.T) {
72 m := &machine{
73 clobberedRegs: make([]regalloc.VReg, 10), spillSlotSize: 16 * 8,
74 maxRequiredStackSizeForCalls: 320,
75 }
76 require.Equal(t, int64(16*18)+int64(320)+32, m.requiredStackSize())
77 }
78
79 func TestMachine_arg0OffsetFromSP(t *testing.T) {
80 m := &machine{clobberedRegs: make([]regalloc.VReg, 10), spillSlotSize: 16 * 8}
81 require.Equal(t, int64(16*18)+32, m.arg0OffsetFromSP())
82 }
83
84 func TestMachine_ret0OffsetFromSP(t *testing.T) {
85 m := &machine{
86 clobberedRegs: make([]regalloc.VReg, 10), spillSlotSize: 16 * 8,
87 currentABI: &backend.FunctionABI{ArgStackSize: 180},
88 }
89 require.Equal(t, int64(16*18)+32+180, m.ret0OffsetFromSP())
90 }
91
92 func TestMachine_getVRegSpillSlotOffsetFromSP(t *testing.T) {
93 m := &machine{spillSlots: make(map[regalloc.VRegID]int64)}
94 id := regalloc.VRegID(1)
95 offset := m.getVRegSpillSlotOffsetFromSP(id, 8)
96 require.Equal(t, int64(16), offset)
97 require.Equal(t, int64(8), m.spillSlotSize)
98 _, ok := m.spillSlots[id]
99 require.True(t, ok)
100
101 id = 100
102 offset = m.getVRegSpillSlotOffsetFromSP(id, 16)
103 require.Equal(t, int64(16+8), offset)
104 require.Equal(t, int64(24), m.spillSlotSize)
105 _, ok = m.spillSlots[id]
106 require.True(t, ok)
107 }
108
109 func TestMachine_insertConditionalJumpTrampoline(t *testing.T) {
110 for _, tc := range []struct {
111 brAtEnd bool
112 expBefore, expAfter string
113 }{
114 {
115 brAtEnd: true,
116 expBefore: `
117 L100:
118 b.eq L12345
119 b L888888888
120 L200:
121 exit_sequence x0
122 `,
123 expAfter: `
124 L100:
125 b.eq L10000000
126 b L888888888
127 L10000000:
128 b L12345
129 L200:
130 exit_sequence x0
131 `,
132 },
133 {
134 brAtEnd: false,
135 expBefore: `
136 L100:
137 b.eq L12345
138 udf
139 L200:
140 exit_sequence x0
141 `,
142 expAfter: `
143 L100:
144 b.eq L10000000
145 udf
146 b L200
147 L10000000:
148 b L12345
149 L200:
150 exit_sequence x0
151 `,
152 },
153 } {
154 var name string
155 if tc.brAtEnd {
156 name = "brAtEnd"
157 } else {
158 name = "brNotAtEnd"
159 }
160
161 t.Run(name, func(t *testing.T) {
162 m := NewBackend().(*machine)
163 m.maxSSABlockID, m.nextLabel = 0, 10000000
164 const (
165 originLabel = 100
166 originLabelNext = 200
167 targetLabel = 12345
168 )
169
170 cbr := m.allocateInstr()
171 cbr.asCondBr(eq.asCond(), targetLabel, false)
172
173 end := m.allocateInstr()
174 if tc.brAtEnd {
175 end.asBr(888888888)
176 } else {
177 end.asUDF()
178 }
179
180 originalEndNext := m.allocateInstr()
181 originalEndNext.asExitSequence(x0VReg)
182
183 originLabelPos := m.labelPositionPool.GetOrAllocate(originLabel)
184 originLabelPos.begin = cbr
185 originLabelPos.end = linkInstr(cbr, end)
186 originNextLabelPos := m.labelPositionPool.GetOrAllocate(originLabelNext)
187 originNextLabelPos.begin = originalEndNext
188 linkInstr(originLabelPos.end, originalEndNext)
189
190 m.rootInstr = cbr
191 require.Equal(t, tc.expBefore, m.Format())
192
193 m.insertConditionalJumpTrampoline(cbr, originLabelPos, originLabelNext)
194
195 require.Equal(t, tc.expAfter, m.Format())
196
197 // The original label position should be updated to the unconditional jump to the original target destination.
198 require.Equal(t, "b L12345", originLabelPos.end.String())
199 })
200 }
201 }