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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
/*
* Copyright (C) 2016 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef AirCustom_h
#define AirCustom_h
#if ENABLE(B3_JIT)
#include "AirInst.h"
#include "AirSpecial.h"
#include "B3Value.h"
namespace JSC { namespace B3 { namespace Air {
// This defines the behavior of custom instructions - i.e. those whose behavior cannot be
// described using AirOpcode.opcodes. If you define an opcode as "custom Foo" in that file, then
// you will need to create a "struct FooCustom" here that implements the custom behavior
// methods.
//
// The customizability granted by the custom instruction mechanism is strictly less than what
// you get using the Patch instruction and implementing a Special. However, that path requires
// allocating a Special object and ensuring that it's the first operand. For many instructions,
// that is not as convenient as using Custom, which makes the instruction look like any other
// instruction. Note that both of those extra powers of the Patch instruction happen because we
// special-case that instruction in many phases and analyses. Non-special-cased behaviors of
// Patch are implemented using the custom instruction mechanism.
//
// Specials are still more flexible if you need to list extra clobbered registers and you'd like
// that to be expressed as a bitvector rather than an arglist. They are also more flexible if
// you need to carry extra state around with the instruction. Also, Specials mean that you
// always have access to Code& even in methods that don't take a GenerationContext.
// Definition of Patch instruction. Patch is used to delegate the behavior of the instruction to the
// Special object, which will be the first argument to the instruction.
struct PatchCustom {
template<typename Functor>
static void forEachArg(Inst& inst, const Functor& functor)
{
// This is basically bogus, but it works for analyses that model Special as an
// immediate.
functor(inst.args[0], Arg::Use, Arg::GP, Arg::pointerWidth());
inst.args[0].special()->forEachArg(inst, scopedLambda<Inst::EachArgCallback>(functor));
}
template<typename... Arguments>
static bool isValidFormStatic(Arguments...)
{
return false;
}
static bool isValidForm(Inst& inst);
static bool admitsStack(Inst& inst, unsigned argIndex)
{
if (!argIndex)
return false;
return inst.args[0].special()->admitsStack(inst, argIndex);
}
static Optional<unsigned> shouldTryAliasingDef(Inst& inst)
{
return inst.args[0].special()->shouldTryAliasingDef(inst);
}
static bool hasNonArgNonControlEffects(Inst& inst)
{
return inst.args[0].special()->hasNonArgNonControlEffects();
}
static CCallHelpers::Jump generate(
Inst& inst, CCallHelpers& jit, GenerationContext& context)
{
return inst.args[0].special()->generate(inst, jit, context);
}
};
// Definition of CCall instruction. CCall is used for hot path C function calls. It's lowered to a
// Patch with an Air CCallSpecial along with code to marshal instructions. The lowering happens
// before register allocation, so that the register allocator sees the clobbers.
struct CCallCustom {
template<typename Functor>
static void forEachArg(Inst& inst, const Functor& functor)
{
Value* value = inst.origin;
unsigned index = 0;
functor(inst.args[index++], Arg::Use, Arg::GP, Arg::pointerWidth()); // callee
if (value->type() != Void) {
functor(
inst.args[index++], Arg::Def,
Arg::typeForB3Type(value->type()),
Arg::widthForB3Type(value->type()));
}
for (unsigned i = 1; i < value->numChildren(); ++i) {
Value* child = value->child(i);
functor(
inst.args[index++], Arg::Use,
Arg::typeForB3Type(child->type()),
Arg::widthForB3Type(child->type()));
}
}
template<typename... Arguments>
static bool isValidFormStatic(Arguments...)
{
return false;
}
static bool isValidForm(Inst&);
static bool admitsStack(Inst&, unsigned)
{
return true;
}
static bool hasNonArgNonControlEffects(Inst&)
{
return true;
}
// This just crashes, since we expect C calls to be lowered before generation.
static CCallHelpers::Jump generate(Inst&, CCallHelpers&, GenerationContext&);
};
struct ColdCCallCustom : CCallCustom {
template<typename Functor>
static void forEachArg(Inst& inst, const Functor& functor)
{
// This is just like a call, but uses become cold.
CCallCustom::forEachArg(
inst,
[&] (Arg& arg, Arg::Role role, Arg::Type type, Arg::Width width) {
functor(arg, Arg::cooled(role), type, width);
});
}
};
struct ShuffleCustom {
template<typename Functor>
static void forEachArg(Inst& inst, const Functor& functor)
{
unsigned limit = inst.args.size() / 3 * 3;
for (unsigned i = 0; i < limit; i += 3) {
Arg& src = inst.args[i + 0];
Arg& dst = inst.args[i + 1];
Arg& widthArg = inst.args[i + 2];
Arg::Width width = widthArg.width();
Arg::Type type = src.isGP() && dst.isGP() ? Arg::GP : Arg::FP;
functor(src, Arg::Use, type, width);
functor(dst, Arg::Def, type, width);
functor(widthArg, Arg::Use, Arg::GP, Arg::Width8);
}
}
template<typename... Arguments>
static bool isValidFormStatic(Arguments...)
{
return false;
}
static bool isValidForm(Inst&);
static bool admitsStack(Inst&, unsigned index)
{
switch (index % 3) {
case 0:
case 1:
return true;
default:
return false;
}
}
static bool hasNonArgNonControlEffects(Inst&)
{
return false;
}
static CCallHelpers::Jump generate(Inst&, CCallHelpers&, GenerationContext&);
};
} } } // namespace JSC::B3::Air
#endif // ENABLE(B3_JIT)
#endif // AirCustom_h
|
