1case glow::Kinded::Kind::ConvolutionNodeKind: {
2 auto *CN__ = cast<ConvolutionNode>(N);
3 auto *Src = valueForNode(CN__->getInput());
4 auto *Filter = valueForNode(CN__->getFilter());
5 auto *Bias = valueForNode(CN__->getBias());
6 std::string allocName = std::string(N->getName()) + ".res";
7 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
8 auto *V = builder_.createConvolutionInst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup(), CN__->getDilation(), CN__->getLayout(), CN__->getFusedActivation(), CN__->getFusedActivationArgs());
9 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
10 registerIR(CN__->getResult(), V->getDest());
11 nodeToInstr_[N] = V;
12 break;
13}
14case glow::Kinded::Kind::ChannelwiseQuantizedConvolutionNodeKind: {
15 auto *CN__ = cast<ChannelwiseQuantizedConvolutionNode>(N);
16 auto *Src = valueForNode(CN__->getInput());
17 auto *Filter = valueForNode(CN__->getFilter());
18 auto *Bias = valueForNode(CN__->getBias());
19 auto *FilterScales = valueForNode(CN__->getFilterScales());
20 auto *FilterOffsets = valueForNode(CN__->getFilterOffsets());
21 auto *BiasScales = valueForNode(CN__->getBiasScales());
22 auto *BiasOffsets = valueForNode(CN__->getBiasOffsets());
23 std::string allocName = std::string(N->getName()) + ".res";
24 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
25 auto *V = builder_.createChannelwiseQuantizedConvolutionInst(N->getName(), Dest__, Src, Filter, Bias, FilterScales, FilterOffsets, BiasScales, BiasOffsets, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup(), CN__->getDilation(), CN__->getFusedActivation(), CN__->getFusedActivationArgs());
26 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
27 registerIR(CN__->getResult(), V->getDest());
28 nodeToInstr_[N] = V;
29 break;
30}
31case glow::Kinded::Kind::ConvTransposeNodeKind: {
32 auto *CN__ = cast<ConvTransposeNode>(N);
33 auto *Src = valueForNode(CN__->getInput());
34 auto *Filter = valueForNode(CN__->getFilter());
35 auto *Bias = valueForNode(CN__->getBias());
36 std::string allocName = std::string(N->getName()) + ".res";
37 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
38 auto *V = builder_.createConvTransposeInst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup(), CN__->getDilation());
39 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
40 registerIR(CN__->getResult(), V->getDest());
41 nodeToInstr_[N] = V;
42 break;
43}
44case glow::Kinded::Kind::Convolution3DNodeKind: {
45 auto *CN__ = cast<Convolution3DNode>(N);
46 auto *Src = valueForNode(CN__->getInput());
47 auto *Filter = valueForNode(CN__->getFilter());
48 auto *Bias = valueForNode(CN__->getBias());
49 std::string allocName = std::string(N->getName()) + ".res";
50 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
51 auto *V = builder_.createConvolution3DInst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup());
52 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
53 registerIR(CN__->getResult(), V->getDest());
54 nodeToInstr_[N] = V;
55 break;
56}
57case glow::Kinded::Kind::BatchNormalizationNodeKind: {
58 auto *CN__ = cast<BatchNormalizationNode>(N);
59 auto *Src = valueForNode(CN__->getInput());
60 auto *Scale = valueForNode(CN__->getScale());
61 auto *Bias = valueForNode(CN__->getBias());
62 auto *Mean = valueForNode(CN__->getMean());
63 auto *Var = valueForNode(CN__->getVar());
64 std::string allocName = std::string(N->getName()) + ".res";
65 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
66 auto *V = builder_.createBatchNormalizationInst(N->getName(), Dest__, Src, Scale, Bias, Mean, Var, CN__->getChannelIdx(), CN__->getEpsilon(), CN__->getMomentum());
67 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
68 registerIR(CN__->getResult(), V->getDest());
69 nodeToInstr_[N] = V;
70 break;
71}
72case glow::Kinded::Kind::AvgPoolNodeKind: {
73 auto *CN__ = cast<AvgPoolNode>(N);
74 auto *Src = valueForNode(CN__->getInput());
75 std::string allocName = std::string(N->getName()) + ".res";
76 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
77 auto *V = builder_.createAvgPoolInst(N->getName(), Dest__, Src, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getLayout(), CN__->getCountIncludePads());
78 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
79 registerIR(CN__->getResult(), V->getDest());
80 nodeToInstr_[N] = V;
81 break;
82}
83case glow::Kinded::Kind::ArgMaxNodeKind: {
84 auto *CN__ = cast<ArgMaxNode>(N);
85 auto *Src = valueForNode(CN__->getInput());
86 std::string allocName = std::string(N->getName()) + ".res";
87 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
88 auto *V = builder_.createArgMaxInst(N->getName(), Dest__, Src, CN__->getAxis(), CN__->getKeepDims());
89 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
90 registerIR(CN__->getResult(), V->getDest());
91 nodeToInstr_[N] = V;
92 break;
93}
94case glow::Kinded::Kind::ArgMinNodeKind: {
95 auto *CN__ = cast<ArgMinNode>(N);
96 auto *Src = valueForNode(CN__->getInput());
97 std::string allocName = std::string(N->getName()) + ".res";
98 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
99 auto *V = builder_.createArgMinInst(N->getName(), Dest__, Src, CN__->getAxis(), CN__->getKeepDims());
100 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
101 registerIR(CN__->getResult(), V->getDest());
102 nodeToInstr_[N] = V;
103 break;
104}
105case glow::Kinded::Kind::AdaptiveAvgPoolNodeKind: {
106 auto *CN__ = cast<AdaptiveAvgPoolNode>(N);
107 auto *Src = valueForNode(CN__->getInput());
108 std::string allocName = std::string(N->getName()) + ".res";
109 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
110 auto *V = builder_.createAdaptiveAvgPoolInst(N->getName(), Dest__, Src);
111 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
112 registerIR(CN__->getResult(), V->getDest());
113 nodeToInstr_[N] = V;
114 break;
115}
116case glow::Kinded::Kind::FullyConnectedNodeKind: {
117 auto *CN__ = cast<FullyConnectedNode>(N);
118 auto *Src = valueForNode(CN__->getInput());
119 auto *Weights = valueForNode(CN__->getWeights());
120 auto *Bias = valueForNode(CN__->getBias());
121 std::string allocName = std::string(N->getName()) + ".res";
122 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
123 auto *V = builder_.createFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias);
124 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
125 registerIR(CN__->getResult(), V->getDest());
126 nodeToInstr_[N] = V;
127 break;
128}
129case glow::Kinded::Kind::RowwiseQuantizedFullyConnectedNodeKind: {
130 auto *CN__ = cast<RowwiseQuantizedFullyConnectedNode>(N);
131 auto *Src = valueForNode(CN__->getInput());
132 auto *Weights = valueForNode(CN__->getWeights());
133 auto *Bias = valueForNode(CN__->getBias());
134 auto *Scales = valueForNode(CN__->getScales());
135 auto *Offsets = valueForNode(CN__->getOffsets());
136 std::string allocName = std::string(N->getName()) + ".res";
137 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
138 auto *V = builder_.createRowwiseQuantizedFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias, Scales, Offsets);
139 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
140 registerIR(CN__->getResult(), V->getDest());
141 nodeToInstr_[N] = V;
142 break;
143}
144case glow::Kinded::Kind::DynamicQuantizedFullyConnectedNodeKind: {
145 auto *CN__ = cast<DynamicQuantizedFullyConnectedNode>(N);
146 auto *Src = valueForNode(CN__->getInput());
147 auto *Weights = valueForNode(CN__->getWeights());
148 auto *Bias = valueForNode(CN__->getBias());
149 std::string allocName = std::string(N->getName()) + ".res";
150 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
151 auto *V = builder_.createDynamicQuantizedFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias, CN__->getIsSymmetric(), CN__->getIsPerBatchElement());
152 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
153 registerIR(CN__->getResult(), V->getDest());
154 nodeToInstr_[N] = V;
155 break;
156}
157case glow::Kinded::Kind::DynamicRowwiseQuantizedFullyConnectedNodeKind: {
158 auto *CN__ = cast<DynamicRowwiseQuantizedFullyConnectedNode>(N);
159 auto *Src = valueForNode(CN__->getInput());
160 auto *Weights = valueForNode(CN__->getWeights());
161 auto *Bias = valueForNode(CN__->getBias());
162 auto *Scales = valueForNode(CN__->getScales());
163 auto *Offsets = valueForNode(CN__->getOffsets());
164 std::string allocName = std::string(N->getName()) + ".res";
165 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
166 auto *V = builder_.createDynamicRowwiseQuantizedFullyConnectedInst(N->getName(), Dest__, Src, Weights, Bias, Scales, Offsets, CN__->getIsSymmetric(), CN__->getIsPerBatchElement());
167 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
168 registerIR(CN__->getResult(), V->getDest());
169 nodeToInstr_[N] = V;
170 break;
171}
172case glow::Kinded::Kind::BucketizeNodeKind: {
173 auto *CN__ = cast<BucketizeNode>(N);
174 auto *Src = valueForNode(CN__->getInput());
175 std::string allocName = std::string(N->getName()) + ".res";
176 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
177 auto *V = builder_.createBucketizeInst(N->getName(), Dest__, Src, CN__->getBoundaries());
178 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
179 registerIR(CN__->getResult(), V->getDest());
180 nodeToInstr_[N] = V;
181 break;
182}
183case glow::Kinded::Kind::LayerNormalizationNodeKind: {
184 auto *CN__ = cast<LayerNormalizationNode>(N);
185 auto *Src = valueForNode(CN__->getInput());
186 auto *Scale = valueForNode(CN__->getScale());
187 auto *Bias = valueForNode(CN__->getBias());
188 std::string allocName = std::string(N->getName()) + ".res";
189 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
190 auto *V = builder_.createLayerNormalizationInst(N->getName(), Dest__, Src, Scale, Bias, CN__->getEpsilon());
191 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
192 registerIR(CN__->getResult(), V->getDest());
193 nodeToInstr_[N] = V;
194 break;
195}
196case glow::Kinded::Kind::SoftMaxNodeKind: {
197 auto *CN__ = cast<SoftMaxNode>(N);
198 auto *Src = valueForNode(CN__->getInput());
199 std::string allocName = std::string(N->getName()) + ".res";
200 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
201 auto *V = builder_.createSoftMaxInst(N->getName(), Dest__, Src);
202 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
203 registerIR(CN__->getResult(), V->getDest());
204 nodeToInstr_[N] = V;
205 break;
206}
207case glow::Kinded::Kind::LogSoftMaxNodeKind: {
208 auto *CN__ = cast<LogSoftMaxNode>(N);
209 auto *Src = valueForNode(CN__->getInput());
210 std::string allocName = std::string(N->getName()) + ".res";
211 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
212 auto *V = builder_.createLogSoftMaxInst(N->getName(), Dest__, Src);
213 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
214 registerIR(CN__->getResult(), V->getDest());
215 nodeToInstr_[N] = V;
216 break;
217}
218case glow::Kinded::Kind::MatMulNodeKind: {
219 auto *CN__ = cast<MatMulNode>(N);
220 auto *LHS = valueForNode(CN__->getLHS());
221 auto *RHS = valueForNode(CN__->getRHS());
222 std::string allocName = std::string(N->getName()) + ".res";
223 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
224 auto *V = builder_.createMatMulInst(N->getName(), Dest__, LHS, RHS);
225 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
226 registerIR(CN__->getResult(), V->getDest());
227 nodeToInstr_[N] = V;
228 break;
229}
230case glow::Kinded::Kind::BatchMatMulNodeKind: {
231 auto *CN__ = cast<BatchMatMulNode>(N);
232 auto *LHS = valueForNode(CN__->getLHS());
233 auto *RHS = valueForNode(CN__->getRHS());
234 std::string allocName = std::string(N->getName()) + ".res";
235 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
236 auto *V = builder_.createBatchMatMulInst(N->getName(), Dest__, LHS, RHS);
237 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
238 registerIR(CN__->getResult(), V->getDest());
239 nodeToInstr_[N] = V;
240 break;
241}
242case glow::Kinded::Kind::BatchedReduceAddNodeKind: {
243 auto *CN__ = cast<BatchedReduceAddNode>(N);
244 auto *Batch = valueForNode(CN__->getBatch());
245 std::string allocName = std::string(N->getName()) + ".res";
246 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
247 auto *V = builder_.createBatchedReduceAddInst(N->getName(), Dest__, Batch, CN__->getAxis());
248 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
249 registerIR(CN__->getResult(), V->getDest());
250 nodeToInstr_[N] = V;
251 break;
252}
253case glow::Kinded::Kind::BatchedReduceMinNodeKind: {
254 auto *CN__ = cast<BatchedReduceMinNode>(N);
255 auto *Batch = valueForNode(CN__->getBatch());
256 std::string allocName = std::string(N->getName()) + ".res";
257 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
258 auto *V = builder_.createBatchedReduceMinInst(N->getName(), Dest__, Batch, CN__->getAxes());
259 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
260 registerIR(CN__->getResult(), V->getDest());
261 nodeToInstr_[N] = V;
262 break;
263}
264case glow::Kinded::Kind::BatchedReduceMaxNodeKind: {
265 auto *CN__ = cast<BatchedReduceMaxNode>(N);
266 auto *Batch = valueForNode(CN__->getBatch());
267 std::string allocName = std::string(N->getName()) + ".res";
268 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
269 auto *V = builder_.createBatchedReduceMaxInst(N->getName(), Dest__, Batch, CN__->getAxes());
270 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
271 registerIR(CN__->getResult(), V->getDest());
272 nodeToInstr_[N] = V;
273 break;
274}
275case glow::Kinded::Kind::BatchedReduceProdNodeKind: {
276 auto *CN__ = cast<BatchedReduceProdNode>(N);
277 auto *Batch = valueForNode(CN__->getBatch());
278 std::string allocName = std::string(N->getName()) + ".res";
279 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
280 auto *V = builder_.createBatchedReduceProdInst(N->getName(), Dest__, Batch, CN__->getAxis());
281 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
282 registerIR(CN__->getResult(), V->getDest());
283 nodeToInstr_[N] = V;
284 break;
285}
286case glow::Kinded::Kind::CumSumNodeKind: {
287 auto *CN__ = cast<CumSumNode>(N);
288 auto *Input = valueForNode(CN__->getInput());
289 std::string allocName = std::string(N->getName()) + ".res";
290 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
291 auto *V = builder_.createCumSumInst(N->getName(), Dest__, Input, CN__->getDim(), CN__->getExclusive(), CN__->getReverse());
292 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
293 registerIR(CN__->getResult(), V->getDest());
294 nodeToInstr_[N] = V;
295 break;
296}
297case glow::Kinded::Kind::LengthsSumNodeKind: {
298 auto *CN__ = cast<LengthsSumNode>(N);
299 auto *Data = valueForNode(CN__->getData());
300 auto *Lengths = valueForNode(CN__->getLengths());
301 std::string allocName = std::string(N->getName()) + ".res";
302 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
303 auto *V = builder_.createLengthsSumInst(N->getName(), Dest__, Data, Lengths);
304 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
305 registerIR(CN__->getResult(), V->getDest());
306 nodeToInstr_[N] = V;
307 break;
308}
309case glow::Kinded::Kind::SparseLengthsSumNodeKind: {
310 auto *CN__ = cast<SparseLengthsSumNode>(N);
311 auto *Data = valueForNode(CN__->getData());
312 auto *Indices = valueForNode(CN__->getIndices());
313 auto *Lengths = valueForNode(CN__->getLengths());
314 std::string allocName = std::string(N->getName()) + ".res";
315 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
316 auto *V = builder_.createSparseLengthsSumInst(N->getName(), Dest__, Data, Indices, Lengths, CN__->getLengthsMode(), CN__->getAvgLength());
317 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
318 registerIR(CN__->getResult(), V->getDest());
319 nodeToInstr_[N] = V;
320 break;
321}
322case glow::Kinded::Kind::SparseLengthsWeightedSumNodeKind: {
323 auto *CN__ = cast<SparseLengthsWeightedSumNode>(N);
324 auto *Data = valueForNode(CN__->getData());
325 auto *Weights = valueForNode(CN__->getWeights());
326 auto *Indices = valueForNode(CN__->getIndices());
327 auto *Lengths = valueForNode(CN__->getLengths());
328 std::string allocName = std::string(N->getName()) + ".res";
329 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
330 auto *V = builder_.createSparseLengthsWeightedSumInst(N->getName(), Dest__, Data, Weights, Indices, Lengths, CN__->getLengthsMode(), CN__->getAvgLength());
331 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
332 registerIR(CN__->getResult(), V->getDest());
333 nodeToInstr_[N] = V;
334 break;
335}
336case glow::Kinded::Kind::EmbeddingNodeKind: {
337 auto *CN__ = cast<EmbeddingNode>(N);
338 auto *Weights = valueForNode(CN__->getWeights());
339 auto *Indices = valueForNode(CN__->getIndices());
340 std::string allocName = std::string(N->getName()) + ".res";
341 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
342 auto *V = builder_.createEmbeddingInst(N->getName(), Dest__, Weights, Indices, CN__->getPadIdx(), CN__->getScale(), CN__->getSparse());
343 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
344 registerIR(CN__->getResult(), V->getDest());
345 nodeToInstr_[N] = V;
346 break;
347}
348case glow::Kinded::Kind::EmbeddingBagNodeKind: {
349 auto *CN__ = cast<EmbeddingBagNode>(N);
350 auto *Data = valueForNode(CN__->getData());
351 auto *Weights = valueForNode(CN__->getWeights());
352 auto *Indices = valueForNode(CN__->getIndices());
353 auto *Offsets = valueForNode(CN__->getOffsets());
354 std::string allocName = std::string(N->getName()) + ".res";
355 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
356 auto *V = builder_.createEmbeddingBagInst(N->getName(), Dest__, Data, Weights, Indices, Offsets, CN__->getHasEndOffset(), CN__->getLengthsMode(), CN__->getAvgLength());
357 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
358 registerIR(CN__->getResult(), V->getDest());
359 nodeToInstr_[N] = V;
360 break;
361}
362case glow::Kinded::Kind::RowwiseQuantizedSparseLengthsWeightedSumNodeKind: {
363 auto *CN__ = cast<RowwiseQuantizedSparseLengthsWeightedSumNode>(N);
364 auto *Data = valueForNode(CN__->getData());
365 auto *Scales = valueForNode(CN__->getScales());
366 auto *Offsets = valueForNode(CN__->getOffsets());
367 auto *Weights = valueForNode(CN__->getWeights());
368 auto *Indices = valueForNode(CN__->getIndices());
369 auto *Lengths = valueForNode(CN__->getLengths());
370 std::string allocName = std::string(N->getName()) + ".res";
371 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
372 auto *V = builder_.createRowwiseQuantizedSparseLengthsWeightedSumInst(N->getName(), Dest__, Data, Scales, Offsets, Weights, Indices, Lengths, CN__->getUseFP16Accumulation(), CN__->getLengthsMode(), CN__->getAvgLength());
373 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
374 registerIR(CN__->getResult(), V->getDest());
375 nodeToInstr_[N] = V;
376 break;
377}
378case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsWeightedSumNodeKind: {
379 auto *CN__ = cast<FusedRowwiseQuantizedSparseLengthsWeightedSumNode>(N);
380 auto *Data = valueForNode(CN__->getData());
381 auto *Weights = valueForNode(CN__->getWeights());
382 auto *Indices = valueForNode(CN__->getIndices());
383 auto *Lengths = valueForNode(CN__->getLengths());
384 std::string allocName = std::string(N->getName()) + ".res";
385 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
386 auto *V = builder_.createFusedRowwiseQuantizedSparseLengthsWeightedSumInst(N->getName(), Dest__, Data, Weights, Indices, Lengths, CN__->getUseFP16Accumulation(), CN__->getLengthsMode(), CN__->getAvgLength());
387 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
388 registerIR(CN__->getResult(), V->getDest());
389 nodeToInstr_[N] = V;
390 break;
391}
392case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsSumNodeKind: {
393 auto *CN__ = cast<FusedRowwiseQuantizedSparseLengthsSumNode>(N);
394 auto *Data = valueForNode(CN__->getData());
395 auto *Indices = valueForNode(CN__->getIndices());
396 auto *Lengths = valueForNode(CN__->getLengths());
397 std::string allocName = std::string(N->getName()) + ".res";
398 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
399 auto *V = builder_.createFusedRowwiseQuantizedSparseLengthsSumInst(N->getName(), Dest__, Data, Indices, Lengths, CN__->getUseFP16Accumulation(), CN__->getLengthsMode(), CN__->getAvgLength());
400 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
401 registerIR(CN__->getResult(), V->getDest());
402 nodeToInstr_[N] = V;
403 break;
404}
405case glow::Kinded::Kind::EmbeddingBagByteRowwiseOffsetsNodeKind: {
406 auto *CN__ = cast<EmbeddingBagByteRowwiseOffsetsNode>(N);
407 auto *Data = valueForNode(CN__->getData());
408 auto *Weights = valueForNode(CN__->getWeights());
409 auto *Indices = valueForNode(CN__->getIndices());
410 auto *Offsets = valueForNode(CN__->getOffsets());
411 std::string allocName = std::string(N->getName()) + ".res";
412 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
413 auto *V = builder_.createEmbeddingBagByteRowwiseOffsetsInst(N->getName(), Dest__, Data, Weights, Indices, Offsets, CN__->getUseFP16Accumulation(), CN__->getHasEndOffset(), CN__->getLengthsMode(), CN__->getAvgLength());
414 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
415 registerIR(CN__->getResult(), V->getDest());
416 nodeToInstr_[N] = V;
417 break;
418}
419case glow::Kinded::Kind::LengthsToRangesNodeKind: {
420 auto *CN__ = cast<LengthsToRangesNode>(N);
421 auto *Lengths = valueForNode(CN__->getLengths());
422 std::string allocName = std::string(N->getName()) + ".res";
423 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
424 auto *V = builder_.createLengthsToRangesInst(N->getName(), Dest__, Lengths);
425 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
426 registerIR(CN__->getResult(), V->getDest());
427 nodeToInstr_[N] = V;
428 break;
429}
430case glow::Kinded::Kind::LengthsRangeFillNodeKind: {
431 auto *CN__ = cast<LengthsRangeFillNode>(N);
432 auto *Lengths = valueForNode(CN__->getLengths());
433 std::string allocName = std::string(N->getName()) + ".res";
434 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
435 auto *V = builder_.createLengthsRangeFillInst(N->getName(), Dest__, Lengths);
436 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
437 registerIR(CN__->getResult(), V->getDest());
438 nodeToInstr_[N] = V;
439 break;
440}
441case glow::Kinded::Kind::BatchSparseToDenseNodeKind: {
442 auto *CN__ = cast<BatchSparseToDenseNode>(N);
443 auto *Lengths = valueForNode(CN__->getLengths());
444 auto *Indices = valueForNode(CN__->getIndices());
445 auto *Values = valueForNode(CN__->getValues());
446 std::string allocName = std::string(N->getName()) + ".res";
447 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
448 auto *V = builder_.createBatchSparseToDenseInst(N->getName(), Dest__, Lengths, Indices, Values, CN__->getDefaultValue(), CN__->getDenseLastDim());
449 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
450 registerIR(CN__->getResult(), V->getDest());
451 nodeToInstr_[N] = V;
452 break;
453}
454case glow::Kinded::Kind::FillExamplesWithIndicatorNodeKind: {
455 auto *CN__ = cast<FillExamplesWithIndicatorNode>(N);
456 auto *Data = valueForNode(CN__->getData());
457 auto *Indicator = valueForNode(CN__->getIndicator());
458 std::string allocName = std::string(N->getName()) + ".res";
459 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
460 auto *V = builder_.createFillExamplesWithIndicatorInst(N->getName(), Dest__, Data, Indicator);
461 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
462 registerIR(CN__->getResult(), V->getDest());
463 nodeToInstr_[N] = V;
464 break;
465}
466case glow::Kinded::Kind::SparseToDenseMaskNodeKind: {
467 auto *CN__ = cast<SparseToDenseMaskNode>(N);
468 auto *Indices = valueForNode(CN__->getIndices());
469 auto *Values = valueForNode(CN__->getValues());
470 auto *DefaultValue = valueForNode(CN__->getDefaultValue());
471 auto *Lengths = valueForNode(CN__->getLengths());
472 std::string allocName = std::string(N->getName()) + ".res";
473 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
474 auto *V = builder_.createSparseToDenseMaskInst(N->getName(), Dest__, Indices, Values, DefaultValue, Lengths, CN__->getMask());
475 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
476 registerIR(CN__->getResult(), V->getDest());
477 nodeToInstr_[N] = V;
478 break;
479}
480case glow::Kinded::Kind::BatchedAddNodeKind: {
481 auto *CN__ = cast<BatchedAddNode>(N);
482 auto *Batch = valueForNode(CN__->getBatch());
483 auto *Slice = valueForNode(CN__->getSlice());
484 std::string allocName = std::string(N->getName()) + ".res";
485 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
486 auto *V = builder_.createBatchedAddInst(N->getName(), Dest__, Batch, Slice);
487 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
488 registerIR(CN__->getResult(), V->getDest());
489 nodeToInstr_[N] = V;
490 break;
491}
492case glow::Kinded::Kind::AddNodeKind: {
493 auto *CN__ = cast<AddNode>(N);
494 auto *LHS = valueForNode(CN__->getLHS());
495 auto *RHS = valueForNode(CN__->getRHS());
496 std::string allocName = std::string(N->getName()) + ".res";
497 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
498 auto *V = builder_.createElementAddInst(N->getName(), Dest__, LHS, RHS);
499 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
500 registerIR(CN__->getResult(), V->getDest());
501 nodeToInstr_[N] = V;
502 break;
503}
504case glow::Kinded::Kind::SubNodeKind: {
505 auto *CN__ = cast<SubNode>(N);
506 auto *LHS = valueForNode(CN__->getLHS());
507 auto *RHS = valueForNode(CN__->getRHS());
508 std::string allocName = std::string(N->getName()) + ".res";
509 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
510 auto *V = builder_.createElementSubInst(N->getName(), Dest__, LHS, RHS);
511 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
512 registerIR(CN__->getResult(), V->getDest());
513 nodeToInstr_[N] = V;
514 break;
515}
516case glow::Kinded::Kind::MulNodeKind: {
517 auto *CN__ = cast<MulNode>(N);
518 auto *LHS = valueForNode(CN__->getLHS());
519 auto *RHS = valueForNode(CN__->getRHS());
520 std::string allocName = std::string(N->getName()) + ".res";
521 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
522 auto *V = builder_.createElementMulInst(N->getName(), Dest__, LHS, RHS);
523 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
524 registerIR(CN__->getResult(), V->getDest());
525 nodeToInstr_[N] = V;
526 break;
527}
528case glow::Kinded::Kind::DivNodeKind: {
529 auto *CN__ = cast<DivNode>(N);
530 auto *LHS = valueForNode(CN__->getLHS());
531 auto *RHS = valueForNode(CN__->getRHS());
532 std::string allocName = std::string(N->getName()) + ".res";
533 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
534 auto *V = builder_.createElementDivInst(N->getName(), Dest__, LHS, RHS);
535 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
536 registerIR(CN__->getResult(), V->getDest());
537 nodeToInstr_[N] = V;
538 break;
539}
540case glow::Kinded::Kind::FmodNodeKind: {
541 auto *CN__ = cast<FmodNode>(N);
542 auto *LHS = valueForNode(CN__->getLHS());
543 auto *RHS = valueForNode(CN__->getRHS());
544 std::string allocName = std::string(N->getName()) + ".res";
545 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
546 auto *V = builder_.createElementFmodInst(N->getName(), Dest__, LHS, RHS);
547 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
548 registerIR(CN__->getResult(), V->getDest());
549 nodeToInstr_[N] = V;
550 break;
551}
552case glow::Kinded::Kind::MaxNodeKind: {
553 auto *CN__ = cast<MaxNode>(N);
554 auto *LHS = valueForNode(CN__->getLHS());
555 auto *RHS = valueForNode(CN__->getRHS());
556 std::string allocName = std::string(N->getName()) + ".res";
557 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
558 auto *V = builder_.createElementMaxInst(N->getName(), Dest__, LHS, RHS);
559 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
560 registerIR(CN__->getResult(), V->getDest());
561 nodeToInstr_[N] = V;
562 break;
563}
564case glow::Kinded::Kind::MinNodeKind: {
565 auto *CN__ = cast<MinNode>(N);
566 auto *LHS = valueForNode(CN__->getLHS());
567 auto *RHS = valueForNode(CN__->getRHS());
568 std::string allocName = std::string(N->getName()) + ".res";
569 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
570 auto *V = builder_.createElementMinInst(N->getName(), Dest__, LHS, RHS);
571 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
572 registerIR(CN__->getResult(), V->getDest());
573 nodeToInstr_[N] = V;
574 break;
575}
576case glow::Kinded::Kind::CmpEQNodeKind: {
577 auto *CN__ = cast<CmpEQNode>(N);
578 auto *LHS = valueForNode(CN__->getLHS());
579 auto *RHS = valueForNode(CN__->getRHS());
580 std::string allocName = std::string(N->getName()) + ".res";
581 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
582 auto *V = builder_.createElementCmpEQInst(N->getName(), Dest__, LHS, RHS);
583 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
584 registerIR(CN__->getResult(), V->getDest());
585 nodeToInstr_[N] = V;
586 break;
587}
588case glow::Kinded::Kind::CmpNEQNodeKind: {
589 auto *CN__ = cast<CmpNEQNode>(N);
590 auto *LHS = valueForNode(CN__->getLHS());
591 auto *RHS = valueForNode(CN__->getRHS());
592 std::string allocName = std::string(N->getName()) + ".res";
593 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
594 auto *V = builder_.createElementCmpNEQInst(N->getName(), Dest__, LHS, RHS);
595 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
596 registerIR(CN__->getResult(), V->getDest());
597 nodeToInstr_[N] = V;
598 break;
599}
600case glow::Kinded::Kind::CmpLTNodeKind: {
601 auto *CN__ = cast<CmpLTNode>(N);
602 auto *LHS = valueForNode(CN__->getLHS());
603 auto *RHS = valueForNode(CN__->getRHS());
604 std::string allocName = std::string(N->getName()) + ".res";
605 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
606 auto *V = builder_.createElementCmpLTInst(N->getName(), Dest__, LHS, RHS);
607 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
608 registerIR(CN__->getResult(), V->getDest());
609 nodeToInstr_[N] = V;
610 break;
611}
612case glow::Kinded::Kind::CmpLTENodeKind: {
613 auto *CN__ = cast<CmpLTENode>(N);
614 auto *LHS = valueForNode(CN__->getLHS());
615 auto *RHS = valueForNode(CN__->getRHS());
616 std::string allocName = std::string(N->getName()) + ".res";
617 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
618 auto *V = builder_.createElementCmpLTEInst(N->getName(), Dest__, LHS, RHS);
619 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
620 registerIR(CN__->getResult(), V->getDest());
621 nodeToInstr_[N] = V;
622 break;
623}
624case glow::Kinded::Kind::IsNaNNodeKind: {
625 auto *CN__ = cast<IsNaNNode>(N);
626 auto *Src = valueForNode(CN__->getInput());
627 std::string allocName = std::string(N->getName()) + ".res";
628 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
629 auto *V = builder_.createElementIsNaNInst(N->getName(), Dest__, Src);
630 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
631 registerIR(CN__->getResult(), V->getDest());
632 nodeToInstr_[N] = V;
633 break;
634}
635case glow::Kinded::Kind::PowNodeKind: {
636 auto *CN__ = cast<PowNode>(N);
637 auto *LHS = valueForNode(CN__->getLHS());
638 auto *RHS = valueForNode(CN__->getRHS());
639 std::string allocName = std::string(N->getName()) + ".res";
640 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
641 auto *V = builder_.createElementPowInst(N->getName(), Dest__, LHS, RHS);
642 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
643 registerIR(CN__->getResult(), V->getDest());
644 nodeToInstr_[N] = V;
645 break;
646}
647case glow::Kinded::Kind::AndNodeKind: {
648 auto *CN__ = cast<AndNode>(N);
649 auto *LHS = valueForNode(CN__->getLHS());
650 auto *RHS = valueForNode(CN__->getRHS());
651 std::string allocName = std::string(N->getName()) + ".res";
652 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
653 auto *V = builder_.createElementAndInst(N->getName(), Dest__, LHS, RHS);
654 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
655 registerIR(CN__->getResult(), V->getDest());
656 nodeToInstr_[N] = V;
657 break;
658}
659case glow::Kinded::Kind::BitwiseAndNodeKind: {
660 auto *CN__ = cast<BitwiseAndNode>(N);
661 auto *LHS = valueForNode(CN__->getLHS());
662 auto *RHS = valueForNode(CN__->getRHS());
663 std::string allocName = std::string(N->getName()) + ".res";
664 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
665 auto *V = builder_.createElementBitwiseAndInst(N->getName(), Dest__, LHS, RHS);
666 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
667 registerIR(CN__->getResult(), V->getDest());
668 nodeToInstr_[N] = V;
669 break;
670}
671case glow::Kinded::Kind::OrNodeKind: {
672 auto *CN__ = cast<OrNode>(N);
673 auto *LHS = valueForNode(CN__->getLHS());
674 auto *RHS = valueForNode(CN__->getRHS());
675 std::string allocName = std::string(N->getName()) + ".res";
676 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
677 auto *V = builder_.createElementOrInst(N->getName(), Dest__, LHS, RHS);
678 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
679 registerIR(CN__->getResult(), V->getDest());
680 nodeToInstr_[N] = V;
681 break;
682}
683case glow::Kinded::Kind::BitwiseOrNodeKind: {
684 auto *CN__ = cast<BitwiseOrNode>(N);
685 auto *LHS = valueForNode(CN__->getLHS());
686 auto *RHS = valueForNode(CN__->getRHS());
687 std::string allocName = std::string(N->getName()) + ".res";
688 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
689 auto *V = builder_.createElementBitwiseOrInst(N->getName(), Dest__, LHS, RHS);
690 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
691 registerIR(CN__->getResult(), V->getDest());
692 nodeToInstr_[N] = V;
693 break;
694}
695case glow::Kinded::Kind::XorNodeKind: {
696 auto *CN__ = cast<XorNode>(N);
697 auto *LHS = valueForNode(CN__->getLHS());
698 auto *RHS = valueForNode(CN__->getRHS());
699 std::string allocName = std::string(N->getName()) + ".res";
700 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
701 auto *V = builder_.createElementXorInst(N->getName(), Dest__, LHS, RHS);
702 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
703 registerIR(CN__->getResult(), V->getDest());
704 nodeToInstr_[N] = V;
705 break;
706}
707case glow::Kinded::Kind::BitwiseXorNodeKind: {
708 auto *CN__ = cast<BitwiseXorNode>(N);
709 auto *LHS = valueForNode(CN__->getLHS());
710 auto *RHS = valueForNode(CN__->getRHS());
711 std::string allocName = std::string(N->getName()) + ".res";
712 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
713 auto *V = builder_.createElementBitwiseXorInst(N->getName(), Dest__, LHS, RHS);
714 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
715 registerIR(CN__->getResult(), V->getDest());
716 nodeToInstr_[N] = V;
717 break;
718}
719case glow::Kinded::Kind::NotNodeKind: {
720 auto *CN__ = cast<NotNode>(N);
721 auto *Src = valueForNode(CN__->getInput());
722 std::string allocName = std::string(N->getName()) + ".res";
723 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
724 auto *V = builder_.createElementNotInst(N->getName(), Dest__, Src);
725 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
726 registerIR(CN__->getResult(), V->getDest());
727 nodeToInstr_[N] = V;
728 break;
729}
730case glow::Kinded::Kind::BitwiseNotNodeKind: {
731 auto *CN__ = cast<BitwiseNotNode>(N);
732 auto *Src = valueForNode(CN__->getInput());
733 std::string allocName = std::string(N->getName()) + ".res";
734 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
735 auto *V = builder_.createElementBitwiseNotInst(N->getName(), Dest__, Src);
736 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
737 registerIR(CN__->getResult(), V->getDest());
738 nodeToInstr_[N] = V;
739 break;
740}
741case glow::Kinded::Kind::NegNodeKind: {
742 auto *CN__ = cast<NegNode>(N);
743 auto *Src = valueForNode(CN__->getInput());
744 std::string allocName = std::string(N->getName()) + ".res";
745 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
746 auto *V = builder_.createElementNegInst(N->getName(), Dest__, Src);
747 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
748 registerIR(CN__->getResult(), V->getDest());
749 nodeToInstr_[N] = V;
750 break;
751}
752case glow::Kinded::Kind::AbsNodeKind: {
753 auto *CN__ = cast<AbsNode>(N);
754 auto *Src = valueForNode(CN__->getInput());
755 std::string allocName = std::string(N->getName()) + ".res";
756 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
757 auto *V = builder_.createElementAbsInst(N->getName(), Dest__, Src);
758 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
759 registerIR(CN__->getResult(), V->getDest());
760 nodeToInstr_[N] = V;
761 break;
762}
763case glow::Kinded::Kind::FloorNodeKind: {
764 auto *CN__ = cast<FloorNode>(N);
765 auto *Src = valueForNode(CN__->getInput());
766 std::string allocName = std::string(N->getName()) + ".res";
767 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
768 auto *V = builder_.createElementFloorInst(N->getName(), Dest__, Src);
769 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
770 registerIR(CN__->getResult(), V->getDest());
771 nodeToInstr_[N] = V;
772 break;
773}
774case glow::Kinded::Kind::SignNodeKind: {
775 auto *CN__ = cast<SignNode>(N);
776 auto *Src = valueForNode(CN__->getInput());
777 std::string allocName = std::string(N->getName()) + ".res";
778 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
779 auto *V = builder_.createElementSignInst(N->getName(), Dest__, Src);
780 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
781 registerIR(CN__->getResult(), V->getDest());
782 nodeToInstr_[N] = V;
783 break;
784}
785case glow::Kinded::Kind::CeilNodeKind: {
786 auto *CN__ = cast<CeilNode>(N);
787 auto *Src = valueForNode(CN__->getInput());
788 std::string allocName = std::string(N->getName()) + ".res";
789 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
790 auto *V = builder_.createElementCeilInst(N->getName(), Dest__, Src);
791 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
792 registerIR(CN__->getResult(), V->getDest());
793 nodeToInstr_[N] = V;
794 break;
795}
796case glow::Kinded::Kind::TruncateNodeKind: {
797 auto *CN__ = cast<TruncateNode>(N);
798 auto *Src = valueForNode(CN__->getInput());
799 std::string allocName = std::string(N->getName()) + ".res";
800 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
801 auto *V = builder_.createElementTruncateInst(N->getName(), Dest__, Src);
802 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
803 registerIR(CN__->getResult(), V->getDest());
804 nodeToInstr_[N] = V;
805 break;
806}
807case glow::Kinded::Kind::RoundNodeKind: {
808 auto *CN__ = cast<RoundNode>(N);
809 auto *Src = valueForNode(CN__->getInput());
810 std::string allocName = std::string(N->getName()) + ".res";
811 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
812 auto *V = builder_.createElementRoundInst(N->getName(), Dest__, Src);
813 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
814 registerIR(CN__->getResult(), V->getDest());
815 nodeToInstr_[N] = V;
816 break;
817}
818case glow::Kinded::Kind::SqrtNodeKind: {
819 auto *CN__ = cast<SqrtNode>(N);
820 auto *Src = valueForNode(CN__->getInput());
821 std::string allocName = std::string(N->getName()) + ".res";
822 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
823 auto *V = builder_.createElementSqrtInst(N->getName(), Dest__, Src);
824 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
825 registerIR(CN__->getResult(), V->getDest());
826 nodeToInstr_[N] = V;
827 break;
828}
829case glow::Kinded::Kind::RsqrtNodeKind: {
830 auto *CN__ = cast<RsqrtNode>(N);
831 auto *Src = valueForNode(CN__->getInput());
832 std::string allocName = std::string(N->getName()) + ".res";
833 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
834 auto *V = builder_.createElementRsqrtInst(N->getName(), Dest__, Src);
835 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
836 registerIR(CN__->getResult(), V->getDest());
837 nodeToInstr_[N] = V;
838 break;
839}
840case glow::Kinded::Kind::ReciprocalNodeKind: {
841 auto *CN__ = cast<ReciprocalNode>(N);
842 auto *Src = valueForNode(CN__->getInput());
843 std::string allocName = std::string(N->getName()) + ".res";
844 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
845 auto *V = builder_.createElementReciprocalInst(N->getName(), Dest__, Src);
846 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
847 registerIR(CN__->getResult(), V->getDest());
848 nodeToInstr_[N] = V;
849 break;
850}
851case glow::Kinded::Kind::SinNodeKind: {
852 auto *CN__ = cast<SinNode>(N);
853 auto *Src = valueForNode(CN__->getInput());
854 std::string allocName = std::string(N->getName()) + ".res";
855 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
856 auto *V = builder_.createElementSinInst(N->getName(), Dest__, Src);
857 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
858 registerIR(CN__->getResult(), V->getDest());
859 nodeToInstr_[N] = V;
860 break;
861}
862case glow::Kinded::Kind::CosNodeKind: {
863 auto *CN__ = cast<CosNode>(N);
864 auto *Src = valueForNode(CN__->getInput());
865 std::string allocName = std::string(N->getName()) + ".res";
866 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
867 auto *V = builder_.createElementCosInst(N->getName(), Dest__, Src);
868 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
869 registerIR(CN__->getResult(), V->getDest());
870 nodeToInstr_[N] = V;
871 break;
872}
873case glow::Kinded::Kind::LogNodeKind: {
874 auto *CN__ = cast<LogNode>(N);
875 auto *Src = valueForNode(CN__->getInput());
876 std::string allocName = std::string(N->getName()) + ".res";
877 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
878 auto *V = builder_.createElementLogInst(N->getName(), Dest__, Src);
879 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
880 registerIR(CN__->getResult(), V->getDest());
881 nodeToInstr_[N] = V;
882 break;
883}
884case glow::Kinded::Kind::ExpNodeKind: {
885 auto *CN__ = cast<ExpNode>(N);
886 auto *Src = valueForNode(CN__->getInput());
887 std::string allocName = std::string(N->getName()) + ".res";
888 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
889 auto *V = builder_.createElementExpInst(N->getName(), Dest__, Src);
890 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
891 registerIR(CN__->getResult(), V->getDest());
892 nodeToInstr_[N] = V;
893 break;
894}
895case glow::Kinded::Kind::AcosNodeKind: {
896 auto *CN__ = cast<AcosNode>(N);
897 auto *Src = valueForNode(CN__->getInput());
898 std::string allocName = std::string(N->getName()) + ".res";
899 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
900 auto *V = builder_.createElementAcosInst(N->getName(), Dest__, Src);
901 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
902 registerIR(CN__->getResult(), V->getDest());
903 nodeToInstr_[N] = V;
904 break;
905}
906case glow::Kinded::Kind::AsinNodeKind: {
907 auto *CN__ = cast<AsinNode>(N);
908 auto *Src = valueForNode(CN__->getInput());
909 std::string allocName = std::string(N->getName()) + ".res";
910 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
911 auto *V = builder_.createElementAsinInst(N->getName(), Dest__, Src);
912 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
913 registerIR(CN__->getResult(), V->getDest());
914 nodeToInstr_[N] = V;
915 break;
916}
917case glow::Kinded::Kind::AtanNodeKind: {
918 auto *CN__ = cast<AtanNode>(N);
919 auto *Src = valueForNode(CN__->getInput());
920 std::string allocName = std::string(N->getName()) + ".res";
921 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
922 auto *V = builder_.createElementAtanInst(N->getName(), Dest__, Src);
923 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
924 registerIR(CN__->getResult(), V->getDest());
925 nodeToInstr_[N] = V;
926 break;
927}
928case glow::Kinded::Kind::ErfNodeKind: {
929 auto *CN__ = cast<ErfNode>(N);
930 auto *Src = valueForNode(CN__->getInput());
931 std::string allocName = std::string(N->getName()) + ".res";
932 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
933 auto *V = builder_.createElementErfInst(N->getName(), Dest__, Src);
934 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
935 registerIR(CN__->getResult(), V->getDest());
936 nodeToInstr_[N] = V;
937 break;
938}
939case glow::Kinded::Kind::NonZeroNodeKind: {
940 auto *CN__ = cast<NonZeroNode>(N);
941 auto *Cond = valueForNode(CN__->getCond());
942 std::string allocName = std::string(N->getName()) + ".res";
943 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
944 auto *V = builder_.createNonZeroInst(N->getName(), Dest__, Cond);
945 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
946 registerIR(CN__->getResult(), V->getDest());
947 nodeToInstr_[N] = V;
948 break;
949}
950case glow::Kinded::Kind::SelectNodeKind: {
951 auto *CN__ = cast<SelectNode>(N);
952 auto *Cond = valueForNode(CN__->getCond());
953 auto *LHS = valueForNode(CN__->getLHS());
954 auto *RHS = valueForNode(CN__->getRHS());
955 std::string allocName = std::string(N->getName()) + ".res";
956 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
957 auto *V = builder_.createElementSelectInst(N->getName(), Dest__, Cond, LHS, RHS);
958 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
959 registerIR(CN__->getResult(), V->getDest());
960 nodeToInstr_[N] = V;
961 break;
962}
963case glow::Kinded::Kind::ModuloNodeKind: {
964 auto *CN__ = cast<ModuloNode>(N);
965 auto *Src = valueForNode(CN__->getInput());
966 std::string allocName = std::string(N->getName()) + ".res";
967 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
968 auto *V = builder_.createModuloInst(N->getName(), Dest__, Src, CN__->getDivisor(), CN__->getSignFollowDivisor());
969 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
970 registerIR(CN__->getResult(), V->getDest());
971 nodeToInstr_[N] = V;
972 break;
973}
974case glow::Kinded::Kind::BatchedUnaryEmbeddingsBagsNodeKind: {
975 auto *CN__ = cast<BatchedUnaryEmbeddingsBagsNode>(N);
976 auto *Weights = valueForNode(CN__->getWeights());
977 auto *TableOffsets = valueForNode(CN__->getTableOffsets());
978 auto *Offsets = valueForNode(CN__->getOffsets());
979 auto *Indices = valueForNode(CN__->getIndices());
980 std::string allocName = std::string(N->getName()) + ".res";
981 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
982 auto *V = builder_.createBatchedUnaryEmbeddingsBagsInst(N->getName(), Dest__, Weights, TableOffsets, Offsets, Indices);
983 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
984 registerIR(CN__->getResult(), V->getDest());
985 nodeToInstr_[N] = V;
986 break;
987}
988case glow::Kinded::Kind::IntNBitSplitEmbeddingBagsNodeKind: {
989 auto *CN__ = cast<IntNBitSplitEmbeddingBagsNode>(N);
990 auto *DevWeights = valueForNode(CN__->getDevWeights());
991 auto *UvmWeights = valueForNode(CN__->getUvmWeights());
992 auto *WeightsPlacements = valueForNode(CN__->getWeightsPlacements());
993 auto *WeightsOffsets = valueForNode(CN__->getWeightsOffsets());
994 auto *WeightsTys = valueForNode(CN__->getWeightsTys());
995 auto *DimOffsets = valueForNode(CN__->getDimOffsets());
996 auto *Indices = valueForNode(CN__->getIndices());
997 auto *Offsets = valueForNode(CN__->getOffsets());
998 std::string allocName = std::string(N->getName()) + ".res";
999 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1000 auto *V = builder_.createIntNBitSplitEmbeddingBagsInst(N->getName(), Dest__, DevWeights, UvmWeights, WeightsPlacements, WeightsOffsets, WeightsTys, DimOffsets, Indices, Offsets, CN__->getTotalDims(), CN__->getPoolingMode(), CN__->getOutputDType());
1001 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1002 registerIR(CN__->getResult(), V->getDest());
1003 nodeToInstr_[N] = V;
1004 break;
1005}
1006case glow::Kinded::Kind::IntNBitSplitEmbeddingWeightedBagsNodeKind: {
1007 auto *CN__ = cast<IntNBitSplitEmbeddingWeightedBagsNode>(N);
1008 auto *DevWeights = valueForNode(CN__->getDevWeights());
1009 auto *UvmWeights = valueForNode(CN__->getUvmWeights());
1010 auto *WeightsPlacements = valueForNode(CN__->getWeightsPlacements());
1011 auto *WeightsOffsets = valueForNode(CN__->getWeightsOffsets());
1012 auto *WeightsTys = valueForNode(CN__->getWeightsTys());
1013 auto *DimOffsets = valueForNode(CN__->getDimOffsets());
1014 auto *Indices = valueForNode(CN__->getIndices());
1015 auto *Offsets = valueForNode(CN__->getOffsets());
1016 auto *IndiceWeight = valueForNode(CN__->getIndiceWeight());
1017 std::string allocName = std::string(N->getName()) + ".res";
1018 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1019 auto *V = builder_.createIntNBitSplitEmbeddingWeightedBagsInst(N->getName(), Dest__, DevWeights, UvmWeights, WeightsPlacements, WeightsOffsets, WeightsTys, DimOffsets, Indices, Offsets, IndiceWeight, CN__->getTotalDims(), CN__->getPoolingMode(), CN__->getOutputDType());
1020 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1021 registerIR(CN__->getResult(), V->getDest());
1022 nodeToInstr_[N] = V;
1023 break;
1024}
1025case glow::Kinded::Kind::GaussianFillNodeKind: {
1026 auto *CN__ = cast<GaussianFillNode>(N);
1027 auto *Input = valueForNode(CN__->getInput());
1028 std::string allocName = std::string(N->getName()) + ".res";
1029 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1030 auto *V = builder_.createGaussianFillInst(N->getName(), Dest__, Input, CN__->getMean(), CN__->getScale(), CN__->getSeed());
1031 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1032 registerIR(CN__->getResult(), V->getDest());
1033 nodeToInstr_[N] = V;
1034 break;
1035}
1036case glow::Kinded::Kind::ReluNodeKind: {
1037 auto *CN__ = cast<ReluNode>(N);
1038 auto *Src = valueForNode(CN__->getInput());
1039 std::string allocName = std::string(N->getName()) + ".res";
1040 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1041 auto *V = builder_.createReluInst(N->getName(), Dest__, Src);
1042 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1043 registerIR(CN__->getResult(), V->getDest());
1044 nodeToInstr_[N] = V;
1045 break;
1046}
1047case glow::Kinded::Kind::ClipNodeKind: {
1048 auto *CN__ = cast<ClipNode>(N);
1049 auto *Src = valueForNode(CN__->getInput());
1050 std::string allocName = std::string(N->getName()) + ".res";
1051 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1052 auto *V = builder_.createClipInst(N->getName(), Dest__, Src, CN__->getMin(), CN__->getMax());
1053 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1054 registerIR(CN__->getResult(), V->getDest());
1055 nodeToInstr_[N] = V;
1056 break;
1057}
1058case glow::Kinded::Kind::SigmoidNodeKind: {
1059 auto *CN__ = cast<SigmoidNode>(N);
1060 auto *Src = valueForNode(CN__->getInput());
1061 std::string allocName = std::string(N->getName()) + ".res";
1062 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1063 auto *V = builder_.createSigmoidInst(N->getName(), Dest__, Src);
1064 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1065 registerIR(CN__->getResult(), V->getDest());
1066 nodeToInstr_[N] = V;
1067 break;
1068}
1069case glow::Kinded::Kind::TanhNodeKind: {
1070 auto *CN__ = cast<TanhNode>(N);
1071 auto *Src = valueForNode(CN__->getInput());
1072 std::string allocName = std::string(N->getName()) + ".res";
1073 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1074 auto *V = builder_.createTanhInst(N->getName(), Dest__, Src);
1075 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1076 registerIR(CN__->getResult(), V->getDest());
1077 nodeToInstr_[N] = V;
1078 break;
1079}
1080case glow::Kinded::Kind::LeakyReluNodeKind: {
1081 auto *CN__ = cast<LeakyReluNode>(N);
1082 auto *Src = valueForNode(CN__->getInput());
1083 std::string allocName = std::string(N->getName()) + ".res";
1084 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1085 auto *V = builder_.createLeakyReluInst(N->getName(), Dest__, Src, CN__->getAlpha());
1086 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1087 registerIR(CN__->getResult(), V->getDest());
1088 nodeToInstr_[N] = V;
1089 break;
1090}
1091case glow::Kinded::Kind::SoftPlusNodeKind: {
1092 auto *CN__ = cast<SoftPlusNode>(N);
1093 auto *Src = valueForNode(CN__->getInput());
1094 std::string allocName = std::string(N->getName()) + ".res";
1095 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1096 auto *V = builder_.createSoftPlusInst(N->getName(), Dest__, Src);
1097 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1098 registerIR(CN__->getResult(), V->getDest());
1099 nodeToInstr_[N] = V;
1100 break;
1101}
1102case glow::Kinded::Kind::TransposeNodeKind: {
1103 auto *CN__ = cast<TransposeNode>(N);
1104 auto *Src = valueForNode(CN__->getInput());
1105 std::string allocName = std::string(N->getName()) + ".res";
1106 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1107 auto *V = builder_.createTransposeInst(N->getName(), Dest__, Src, CN__->getShuffle());
1108 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1109 registerIR(CN__->getResult(), V->getDest());
1110 nodeToInstr_[N] = V;
1111 break;
1112}
1113case glow::Kinded::Kind::SplatNodeKind: {
1114 auto *CN__ = cast<SplatNode>(N);
1115 std::string allocName = std::string(N->getName()) + ".res";
1116 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1117 auto *V = builder_.createSplatInst(N->getName(), Dest__, CN__->getValue());
1118 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1119 registerIR(CN__->getResult(), V->getDest());
1120 nodeToInstr_[N] = V;
1121 break;
1122}
1123case glow::Kinded::Kind::TouchNodeKind: {
1124 auto *CN__ = cast<TouchNode>(N);
1125 std::string allocName = std::string(N->getName()) + ".res";
1126 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1127 auto *V = builder_.createTouchInst(N->getName(), Dest__);
1128 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1129 registerIR(CN__->getResult(), V->getDest());
1130 nodeToInstr_[N] = V;
1131 break;
1132}
1133case glow::Kinded::Kind::GatherNodeKind: {
1134 auto *CN__ = cast<GatherNode>(N);
1135 auto *Data = valueForNode(CN__->getData());
1136 auto *Indices = valueForNode(CN__->getIndices());
1137 std::string allocName = std::string(N->getName()) + ".res";
1138 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1139 auto *V = builder_.createGatherInst(N->getName(), Dest__, Data, Indices, CN__->getBatchDims());
1140 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1141 registerIR(CN__->getResult(), V->getDest());
1142 nodeToInstr_[N] = V;
1143 break;
1144}
1145case glow::Kinded::Kind::GatherNDNodeKind: {
1146 auto *CN__ = cast<GatherNDNode>(N);
1147 auto *Data = valueForNode(CN__->getData());
1148 auto *Indices = valueForNode(CN__->getIndices());
1149 std::string allocName = std::string(N->getName()) + ".res";
1150 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1151 auto *V = builder_.createGatherNDInst(N->getName(), Dest__, Data, Indices, CN__->getBatchDims());
1152 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1153 registerIR(CN__->getResult(), V->getDest());
1154 nodeToInstr_[N] = V;
1155 break;
1156}
1157case glow::Kinded::Kind::GatherElementsNodeKind: {
1158 auto *CN__ = cast<GatherElementsNode>(N);
1159 auto *Data = valueForNode(CN__->getData());
1160 auto *Indices = valueForNode(CN__->getIndices());
1161 std::string allocName = std::string(N->getName()) + ".res";
1162 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1163 auto *V = builder_.createGatherElementsInst(N->getName(), Dest__, Data, Indices, CN__->getDim());
1164 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1165 registerIR(CN__->getResult(), V->getDest());
1166 nodeToInstr_[N] = V;
1167 break;
1168}
1169case glow::Kinded::Kind::GatherRangesNodeKind: {
1170 auto *CN__ = cast<GatherRangesNode>(N);
1171 auto *Data = valueForNode(CN__->getData());
1172 auto *Ranges = valueForNode(CN__->getRanges());
1173 std::string allocName = std::string(N->getName()) + ".res";
1174 auto *Output__ = builder_.createAllocActivationInst(allocName,CN__->getOutput().getType());
1175 auto *Lengths__ = builder_.createAllocActivationInst(allocName,CN__->getLengths().getType());
1176 auto *V = builder_.createGatherRangesInst(N->getName(), Output__, Lengths__, Data, Ranges);
1177 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1178 registerIR(CN__->getOutput(), V->getOutput());
1179 registerIR(CN__->getLengths(), V->getLengths());
1180 nodeToInstr_[N] = V;
1181 break;
1182}
1183case glow::Kinded::Kind::BatchOneHotNodeKind: {
1184 auto *CN__ = cast<BatchOneHotNode>(N);
1185 auto *Data = valueForNode(CN__->getData());
1186 auto *Lengths = valueForNode(CN__->getLengths());
1187 auto *Values = valueForNode(CN__->getValues());
1188 std::string allocName = std::string(N->getName()) + ".res";
1189 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1190 auto *V = builder_.createBatchOneHotInst(N->getName(), Dest__, Data, Lengths, Values);
1191 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1192 registerIR(CN__->getResult(), V->getDest());
1193 nodeToInstr_[N] = V;
1194 break;
1195}
1196case glow::Kinded::Kind::SpaceToDepthNodeKind: {
1197 auto *CN__ = cast<SpaceToDepthNode>(N);
1198 auto *Src = valueForNode(CN__->getInput());
1199 std::string allocName = std::string(N->getName()) + ".res";
1200 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1201 auto *V = builder_.createSpaceToDepthInst(N->getName(), Dest__, Src, CN__->getBlockSize());
1202 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1203 registerIR(CN__->getResult(), V->getDest());
1204 nodeToInstr_[N] = V;
1205 break;
1206}
1207case glow::Kinded::Kind::ResizeNearestNodeKind: {
1208 auto *CN__ = cast<ResizeNearestNode>(N);
1209 auto *Src = valueForNode(CN__->getInput());
1210 std::string allocName = std::string(N->getName()) + ".res";
1211 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1212 auto *V = builder_.createResizeNearestInst(N->getName(), Dest__, Src, CN__->getScale());
1213 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1214 registerIR(CN__->getResult(), V->getDest());
1215 nodeToInstr_[N] = V;
1216 break;
1217}
1218case glow::Kinded::Kind::ResizeBilinearNodeKind: {
1219 auto *CN__ = cast<ResizeBilinearNode>(N);
1220 auto *Src = valueForNode(CN__->getInput());
1221 std::string allocName = std::string(N->getName()) + ".res";
1222 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1223 auto *V = builder_.createResizeBilinearInst(N->getName(), Dest__, Src, CN__->getScale());
1224 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1225 registerIR(CN__->getResult(), V->getDest());
1226 nodeToInstr_[N] = V;
1227 break;
1228}
1229case glow::Kinded::Kind::SparseLabelSplitNodeKind: {
1230 auto *CN__ = cast<SparseLabelSplitNode>(N);
1231 auto *Lengths = valueForNode(CN__->getLengths());
1232 auto *Indices = valueForNode(CN__->getIndices());
1233 auto *Values = valueForNode(CN__->getValues());
1234 std::string allocName = std::string(N->getName()) + ".res";
1235 auto *LabelValues__ = builder_.createAllocActivationInst(allocName,CN__->getLabelValues().getType());
1236 auto *ExampleIds__ = builder_.createAllocActivationInst(allocName,CN__->getExampleIds().getType());
1237 auto *GradientOffsetMap__ = builder_.createAllocActivationInst(allocName,CN__->getGradientOffsetMap().getType());
1238 auto *V = builder_.createSparseLabelSplitInst(N->getName(), LabelValues__, ExampleIds__, GradientOffsetMap__, Lengths, Indices, Values, CN__->getNumLabels());
1239 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1240 registerIR(CN__->getLabelValues(), V->getLabelValues());
1241 registerIR(CN__->getExampleIds(), V->getExampleIds());
1242 registerIR(CN__->getGradientOffsetMap(), V->getGradientOffsetMap());
1243 nodeToInstr_[N] = V;
1244 break;
1245}
1246case glow::Kinded::Kind::FlipNodeKind: {
1247 auto *CN__ = cast<FlipNode>(N);
1248 auto *Src = valueForNode(CN__->getInput());
1249 std::string allocName = std::string(N->getName()) + ".res";
1250 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1251 auto *V = builder_.createFlipInst(N->getName(), Dest__, Src, CN__->getAxis());
1252 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1253 registerIR(CN__->getResult(), V->getDest());
1254 nodeToInstr_[N] = V;
1255 break;
1256}
1257case glow::Kinded::Kind::IntLookupTableNodeKind: {
1258 auto *CN__ = cast<IntLookupTableNode>(N);
1259 auto *Src = valueForNode(CN__->getInput());
1260 auto *Mapping = valueForNode(CN__->getMapping());
1261 std::string allocName = std::string(N->getName()) + ".res";
1262 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1263 auto *V = builder_.createIntLookupTableInst(N->getName(), Dest__, Src, Mapping);
1264 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1265 registerIR(CN__->getResult(), V->getDest());
1266 nodeToInstr_[N] = V;
1267 break;
1268}
1269case glow::Kinded::Kind::QuantizeNodeKind: {
1270 auto *CN__ = cast<QuantizeNode>(N);
1271 auto *Src = valueForNode(CN__->getInput());
1272 std::string allocName = std::string(N->getName()) + ".res";
1273 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1274 auto *V = builder_.createQuantizeInst(N->getName(), Dest__, Src);
1275 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1276 registerIR(CN__->getResult(), V->getDest());
1277 nodeToInstr_[N] = V;
1278 break;
1279}
1280case glow::Kinded::Kind::DequantizeNodeKind: {
1281 auto *CN__ = cast<DequantizeNode>(N);
1282 auto *Src = valueForNode(CN__->getInput());
1283 std::string allocName = std::string(N->getName()) + ".res";
1284 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1285 auto *V = builder_.createDequantizeInst(N->getName(), Dest__, Src);
1286 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1287 registerIR(CN__->getResult(), V->getDest());
1288 nodeToInstr_[N] = V;
1289 break;
1290}
1291case glow::Kinded::Kind::RescaleQuantizedNodeKind: {
1292 auto *CN__ = cast<RescaleQuantizedNode>(N);
1293 auto *Src = valueForNode(CN__->getInput());
1294 std::string allocName = std::string(N->getName()) + ".res";
1295 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1296 auto *V = builder_.createRescaleQuantizedInst(N->getName(), Dest__, Src);
1297 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1298 registerIR(CN__->getResult(), V->getDest());
1299 nodeToInstr_[N] = V;
1300 break;
1301}
1302case glow::Kinded::Kind::ConvertToNodeKind: {
1303 auto *CN__ = cast<ConvertToNode>(N);
1304 auto *Input = valueForNode(CN__->getInput());
1305 std::string allocName = std::string(N->getName()) + ".res";
1306 auto *Result__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1307 auto *V = builder_.createConvertToInst(N->getName(), Result__, Input);
1308 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1309 registerIR(CN__->getResult(), V->getResult());
1310 nodeToInstr_[N] = V;
1311 break;
1312}
1313case glow::Kinded::Kind::AudioSpectrogramNodeKind: {
1314 auto *CN__ = cast<AudioSpectrogramNode>(N);
1315 auto *Input = valueForNode(CN__->getInput());
1316 auto *Window = valueForNode(CN__->getWindow());
1317 auto *TwiddleFactors = valueForNode(CN__->getTwiddleFactors());
1318 auto *BitReverseIndices = valueForNode(CN__->getBitReverseIndices());
1319 auto *ComplexToRealWeights = valueForNode(CN__->getComplexToRealWeights());
1320 std::string allocName = std::string(N->getName()) + ".res";
1321 auto *Spectrogram__ = builder_.createAllocActivationInst(allocName,CN__->getSpectrogram().getType());
1322 auto *V = builder_.createAudioSpectrogramInst(N->getName(), Spectrogram__, Input, Window, TwiddleFactors, BitReverseIndices, ComplexToRealWeights, CN__->getWindowSize(), CN__->getWindowStride(), CN__->getMagnitudeSquared());
1323 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1324 registerIR(CN__->getSpectrogram(), V->getSpectrogram());
1325 nodeToInstr_[N] = V;
1326 break;
1327}
1328case glow::Kinded::Kind::MFCCNodeKind: {
1329 auto *CN__ = cast<MFCCNode>(N);
1330 auto *Spectrogram = valueForNode(CN__->getSpectrogram());
1331 auto *MelWeights = valueForNode(CN__->getMelWeights());
1332 auto *MelRanges = valueForNode(CN__->getMelRanges());
1333 auto *DctMat = valueForNode(CN__->getDctMat());
1334 std::string allocName = std::string(N->getName()) + ".res";
1335 auto *Coefficients__ = builder_.createAllocActivationInst(allocName,CN__->getCoefficients().getType());
1336 auto *V = builder_.createMFCCInst(N->getName(), Coefficients__, Spectrogram, MelWeights, MelRanges, DctMat, CN__->getSampleRate(), CN__->getLowerFrequency(), CN__->getUpperFrequency(), CN__->getFilterBankCount(), CN__->getNumCoefficients());
1337 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1338 registerIR(CN__->getCoefficients(), V->getCoefficients());
1339 nodeToInstr_[N] = V;
1340 break;
1341}
1342case glow::Kinded::Kind::NonMaxSuppressionNodeKind: {
1343 auto *CN__ = cast<NonMaxSuppressionNode>(N);
1344 auto *Boxes = valueForNode(CN__->getBoxes());
1345 auto *Scores = valueForNode(CN__->getScores());
1346 std::string allocName = std::string(N->getName()) + ".res";
1347 auto *Indices__ = builder_.createAllocActivationInst(allocName,CN__->getIndices().getType());
1348 auto *NumberOfSelectedIndices__ = builder_.createAllocActivationInst(allocName,CN__->getNumberOfSelectedIndices().getType());
1349 auto *V = builder_.createNonMaxSuppressionInst(N->getName(), Indices__, NumberOfSelectedIndices__, Boxes, Scores, CN__->getCenterPointBox(), CN__->getMaxOutputBoxesPerClass(), CN__->getIouThreshold(), CN__->getScoreThreshold(), CN__->getIsTFVersion4());
1350 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1351 registerIR(CN__->getIndices(), V->getIndices());
1352 registerIR(CN__->getNumberOfSelectedIndices(), V->getNumberOfSelectedIndices());
1353 nodeToInstr_[N] = V;
1354 break;
1355}
1356case glow::Kinded::Kind::TFLiteDetectionPostProcessNodeKind: {
1357 auto *CN__ = cast<TFLiteDetectionPostProcessNode>(N);
1358 auto *Boxes = valueForNode(CN__->getBoxes());
1359 auto *Scores = valueForNode(CN__->getScores());
1360 auto *Anchors = valueForNode(CN__->getAnchors());
1361 std::string allocName = std::string(N->getName()) + ".res";
1362 auto *DetectionBoxes__ = builder_.createAllocActivationInst(allocName,CN__->getDetectionBoxes().getType());
1363 auto *DetectionClasses__ = builder_.createAllocActivationInst(allocName,CN__->getDetectionClasses().getType());
1364 auto *DetectionScores__ = builder_.createAllocActivationInst(allocName,CN__->getDetectionScores().getType());
1365 auto *NumDetections__ = builder_.createAllocActivationInst(allocName,CN__->getNumDetections().getType());
1366 auto *V = builder_.createTFLiteDetectionPostProcessInst(N->getName(), DetectionBoxes__, DetectionClasses__, DetectionScores__, NumDetections__, Boxes, Scores, Anchors, CN__->getNumClasses(), CN__->getMaxDetections(), CN__->getMaxClassesPerDetection(), CN__->getMaxDetectionsPerClass(), CN__->getIouThreshold(), CN__->getScoreThreshold(), CN__->getXScale(), CN__->getYScale(), CN__->getHScale(), CN__->getWScale(), CN__->getRegularNMS());
1367 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1368 registerIR(CN__->getDetectionBoxes(), V->getDetectionBoxes());
1369 registerIR(CN__->getDetectionClasses(), V->getDetectionClasses());
1370 registerIR(CN__->getDetectionScores(), V->getDetectionScores());
1371 registerIR(CN__->getNumDetections(), V->getNumDetections());
1372 nodeToInstr_[N] = V;
1373 break;
1374}
1375case glow::Kinded::Kind::ROIAlignNodeKind: {
1376 auto *CN__ = cast<ROIAlignNode>(N);
1377 auto *FeatureMap = valueForNode(CN__->getFeatureMap());
1378 auto *Boxes = valueForNode(CN__->getBoxes());
1379 auto *BatchIndices = valueForNode(CN__->getBatchIndices());
1380 std::string allocName = std::string(N->getName()) + ".res";
1381 auto *Result__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1382 auto *V = builder_.createROIAlignInst(N->getName(), Result__, FeatureMap, Boxes, BatchIndices, CN__->getMode(), CN__->getOutputHeight(), CN__->getOutputWidth(), CN__->getSamplingRatio(), CN__->getSpatialScale(), CN__->getAligned(), CN__->getRotated());
1383 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1384 registerIR(CN__->getResult(), V->getResult());
1385 nodeToInstr_[N] = V;
1386 break;
1387}
1388case glow::Kinded::Kind::BBoxTransformNodeKind: {
1389 auto *CN__ = cast<BBoxTransformNode>(N);
1390 auto *Rois = valueForNode(CN__->getRois());
1391 auto *Deltas = valueForNode(CN__->getDeltas());
1392 auto *ImInfo = valueForNode(CN__->getImInfo());
1393 std::string allocName = std::string(N->getName()) + ".res";
1394 auto *BoxOut__ = builder_.createAllocActivationInst(allocName,CN__->getBoxOut().getType());
1395 auto *RoiBatchSplits__ = builder_.createAllocActivationInst(allocName,CN__->getRoiBatchSplits().getType());
1396 auto *V = builder_.createBBoxTransformInst(N->getName(), BoxOut__, RoiBatchSplits__, Rois, Deltas, ImInfo, CN__->getWeights(), CN__->getApplyScale(), CN__->getRotated(), CN__->getAngleBoundOn(), CN__->getAngleBoundLo(), CN__->getAngleBoundHi(), CN__->getClipAngleThresh(), CN__->getLegacyPlusOne());
1397 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1398 registerIR(CN__->getBoxOut(), V->getBoxOut());
1399 registerIR(CN__->getRoiBatchSplits(), V->getRoiBatchSplits());
1400 nodeToInstr_[N] = V;
1401 break;
1402}
1403case glow::Kinded::Kind::LookupTableNodeKind: {
1404 auto *CN__ = cast<LookupTableNode>(N);
1405 auto *Src = valueForNode(CN__->getInput());
1406 auto *Table = valueForNode(CN__->getTable());
1407 auto *TableIdx = valueForNode(CN__->getTableIdx());
1408 std::string allocName = std::string(N->getName()) + ".res";
1409 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1410 auto *V = builder_.createLookupTableInst(N->getName(), Dest__, Src, Table, TableIdx, CN__->getOperator(), CN__->getOperatorArgs());
1411 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1412 registerIR(CN__->getResult(), V->getDest());
1413 nodeToInstr_[N] = V;
1414 break;
1415}
1416case glow::Kinded::Kind::CPUMaxSplatNodeKind: {
1417 auto *CN__ = cast<CPUMaxSplatNode>(N);
1418 auto *Src = valueForNode(CN__->getInput());
1419 std::string allocName = std::string(N->getName()) + ".res";
1420 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1421 auto *V = builder_.createCPUMaxSplatInst(N->getName(), Dest__, Src, CN__->getSplatValue());
1422 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1423 registerIR(CN__->getResult(), V->getDest());
1424 nodeToInstr_[N] = V;
1425 break;
1426}
1427case glow::Kinded::Kind::CPUConvDKKC8NodeKind: {
1428 auto *CN__ = cast<CPUConvDKKC8Node>(N);
1429 auto *Src = valueForNode(CN__->getInput());
1430 auto *Filter = valueForNode(CN__->getFilter());
1431 auto *Bias = valueForNode(CN__->getBias());
1432 std::string allocName = std::string(N->getName()) + ".res";
1433 auto *Dest__ = builder_.createAllocActivationInst(allocName,CN__->getResult().getType());
1434 auto *V = builder_.createCPUConvDKKC8Inst(N->getName(), Dest__, Src, Filter, Bias, CN__->getKernels(), CN__->getStrides(), CN__->getPads(), CN__->getGroup());
1435 if (N->hasPredicate()) { V->setPredicate(valueForNode(N->getPredicate())); }
1436 registerIR(CN__->getResult(), V->getDest());
1437 nodeToInstr_[N] = V;
1438 break;
1439}
1440