1case glow::Kinded::Kind::PadNodeKind: {
2 auto *N__ = llvm::cast<PadNode>(node);
3 opProto = graph.add_node();
4 opProto->set_op_type("Glow_Pad");
5 opProto->set_name(glow::legalizeName(N__->getName()));
6 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
7 addTypeAttributes(opProto, N__, PadNode::InputIdx, /* isInput */ true);
8 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
9 addTypeAttributes(opProto, N__, PadNode::ResultIdx, /* isInput */ false);
10 addValueAttribute(opProto, "Mode", N__->getMode());
11 addValueAttribute(opProto, "Pads", N__->getPads());
12 addValueAttribute(opProto, "Value", N__->getValue());
13 if (N__->hasPredicate()) {
14 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
15 }
16 break;
17}
18
19case glow::Kinded::Kind::ConvolutionGradNodeKind: {
20 auto *N__ = llvm::cast<ConvolutionGradNode>(node);
21 opProto = graph.add_node();
22 opProto->set_op_type("Glow_ConvolutionGrad");
23 opProto->set_name(glow::legalizeName(N__->getName()));
24 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
25 addTypeAttributes(opProto, N__, ConvolutionGradNode::InputIdx, /* isInput */ true);
26 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
27 addTypeAttributes(opProto, N__, ConvolutionGradNode::FilterIdx, /* isInput */ true);
28 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
29 addTypeAttributes(opProto, N__, ConvolutionGradNode::BiasIdx, /* isInput */ true);
30 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
31 addTypeAttributes(opProto, N__, ConvolutionGradNode::OriginalOutputForResultIdx, /* isInput */ true);
32 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
33 addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
34 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
35 addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
36 opProto->add_output(N__->getGradOfInputNamedFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
37 addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfInputNamedFilterIdx, /* isInput */ false);
38 opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
39 addTypeAttributes(opProto, N__, ConvolutionGradNode::GradOfInputNamedBiasIdx, /* isInput */ false);
40 addValueAttribute(opProto, "Kernels", N__->getKernels());
41 addValueAttribute(opProto, "Strides", N__->getStrides());
42 addValueAttribute(opProto, "Pads", N__->getPads());
43 addValueAttribute(opProto, "Group", N__->getGroup());
44 addValueAttribute(opProto, "Dilation", N__->getDilation());
45 addValueAttribute(opProto, "Layout", N__->getLayout());
46 addValueAttribute(opProto, "FusedActivation", N__->getFusedActivation());
47 addValueAttribute(opProto, "FusedActivationArgs", N__->getFusedActivationArgs());
48 if (N__->hasPredicate()) {
49 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
50 }
51 break;
52}
53
54case glow::Kinded::Kind::ConvolutionNodeKind: {
55 auto *N__ = llvm::cast<ConvolutionNode>(node);
56 opProto = graph.add_node();
57 opProto->set_op_type("Glow_Convolution");
58 opProto->set_name(glow::legalizeName(N__->getName()));
59 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
60 addTypeAttributes(opProto, N__, ConvolutionNode::InputIdx, /* isInput */ true);
61 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
62 addTypeAttributes(opProto, N__, ConvolutionNode::FilterIdx, /* isInput */ true);
63 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
64 addTypeAttributes(opProto, N__, ConvolutionNode::BiasIdx, /* isInput */ true);
65 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
66 addTypeAttributes(opProto, N__, ConvolutionNode::ResultIdx, /* isInput */ false);
67 addValueAttribute(opProto, "Kernels", N__->getKernels());
68 addValueAttribute(opProto, "Strides", N__->getStrides());
69 addValueAttribute(opProto, "Pads", N__->getPads());
70 addValueAttribute(opProto, "Group", N__->getGroup());
71 addValueAttribute(opProto, "Dilation", N__->getDilation());
72 addValueAttribute(opProto, "Layout", N__->getLayout());
73 addValueAttribute(opProto, "FusedActivation", N__->getFusedActivation());
74 addValueAttribute(opProto, "FusedActivationArgs", N__->getFusedActivationArgs());
75 if (N__->hasPredicate()) {
76 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
77 }
78 break;
79}
80
81case glow::Kinded::Kind::ChannelwiseQuantizedConvolutionNodeKind: {
82 auto *N__ = llvm::cast<ChannelwiseQuantizedConvolutionNode>(node);
83 opProto = graph.add_node();
84 opProto->set_op_type("Glow_ChannelwiseQuantizedConvolution");
85 opProto->set_name(glow::legalizeName(N__->getName()));
86 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
87 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::InputIdx, /* isInput */ true);
88 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
89 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::FilterIdx, /* isInput */ true);
90 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
91 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::BiasIdx, /* isInput */ true);
92 opProto->add_input(N__->getFilterScales().generateNodeOutputName(/* stripResNoFor0thInput */ true));
93 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::FilterScalesIdx, /* isInput */ true);
94 opProto->add_input(N__->getFilterOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
95 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::FilterOffsetsIdx, /* isInput */ true);
96 opProto->add_input(N__->getBiasScales().generateNodeOutputName(/* stripResNoFor0thInput */ true));
97 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::BiasScalesIdx, /* isInput */ true);
98 opProto->add_input(N__->getBiasOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
99 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::BiasOffsetsIdx, /* isInput */ true);
100 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
101 addTypeAttributes(opProto, N__, ChannelwiseQuantizedConvolutionNode::ResultIdx, /* isInput */ false);
102 addValueAttribute(opProto, "Kernels", N__->getKernels());
103 addValueAttribute(opProto, "Strides", N__->getStrides());
104 addValueAttribute(opProto, "Pads", N__->getPads());
105 addValueAttribute(opProto, "Group", N__->getGroup());
106 addValueAttribute(opProto, "Dilation", N__->getDilation());
107 addValueAttribute(opProto, "FusedActivation", N__->getFusedActivation());
108 addValueAttribute(opProto, "FusedActivationArgs", N__->getFusedActivationArgs());
109 if (N__->hasPredicate()) {
110 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
111 }
112 break;
113}
114
115case glow::Kinded::Kind::ConvTransposeNodeKind: {
116 auto *N__ = llvm::cast<ConvTransposeNode>(node);
117 opProto = graph.add_node();
118 opProto->set_op_type("Glow_ConvTranspose");
119 opProto->set_name(glow::legalizeName(N__->getName()));
120 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
121 addTypeAttributes(opProto, N__, ConvTransposeNode::InputIdx, /* isInput */ true);
122 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
123 addTypeAttributes(opProto, N__, ConvTransposeNode::FilterIdx, /* isInput */ true);
124 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
125 addTypeAttributes(opProto, N__, ConvTransposeNode::BiasIdx, /* isInput */ true);
126 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
127 addTypeAttributes(opProto, N__, ConvTransposeNode::ResultIdx, /* isInput */ false);
128 addValueAttribute(opProto, "Kernels", N__->getKernels());
129 addValueAttribute(opProto, "Strides", N__->getStrides());
130 addValueAttribute(opProto, "Pads", N__->getPads());
131 addValueAttribute(opProto, "Group", N__->getGroup());
132 addValueAttribute(opProto, "Dilation", N__->getDilation());
133 if (N__->hasPredicate()) {
134 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
135 }
136 break;
137}
138
139case glow::Kinded::Kind::Convolution3DGradNodeKind: {
140 auto *N__ = llvm::cast<Convolution3DGradNode>(node);
141 opProto = graph.add_node();
142 opProto->set_op_type("Glow_Convolution3DGrad");
143 opProto->set_name(glow::legalizeName(N__->getName()));
144 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
145 addTypeAttributes(opProto, N__, Convolution3DGradNode::InputIdx, /* isInput */ true);
146 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
147 addTypeAttributes(opProto, N__, Convolution3DGradNode::FilterIdx, /* isInput */ true);
148 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
149 addTypeAttributes(opProto, N__, Convolution3DGradNode::BiasIdx, /* isInput */ true);
150 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
151 addTypeAttributes(opProto, N__, Convolution3DGradNode::OriginalOutputForResultIdx, /* isInput */ true);
152 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
153 addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
154 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
155 addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
156 opProto->add_output(N__->getGradOfInputNamedFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
157 addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfInputNamedFilterIdx, /* isInput */ false);
158 opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
159 addTypeAttributes(opProto, N__, Convolution3DGradNode::GradOfInputNamedBiasIdx, /* isInput */ false);
160 addValueAttribute(opProto, "Kernels", N__->getKernels());
161 addValueAttribute(opProto, "Strides", N__->getStrides());
162 addValueAttribute(opProto, "Pads", N__->getPads());
163 addValueAttribute(opProto, "Group", N__->getGroup());
164 if (N__->hasPredicate()) {
165 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
166 }
167 break;
168}
169
170case glow::Kinded::Kind::Convolution3DNodeKind: {
171 auto *N__ = llvm::cast<Convolution3DNode>(node);
172 opProto = graph.add_node();
173 opProto->set_op_type("Glow_Convolution3D");
174 opProto->set_name(glow::legalizeName(N__->getName()));
175 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
176 addTypeAttributes(opProto, N__, Convolution3DNode::InputIdx, /* isInput */ true);
177 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
178 addTypeAttributes(opProto, N__, Convolution3DNode::FilterIdx, /* isInput */ true);
179 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
180 addTypeAttributes(opProto, N__, Convolution3DNode::BiasIdx, /* isInput */ true);
181 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
182 addTypeAttributes(opProto, N__, Convolution3DNode::ResultIdx, /* isInput */ false);
183 addValueAttribute(opProto, "Kernels", N__->getKernels());
184 addValueAttribute(opProto, "Strides", N__->getStrides());
185 addValueAttribute(opProto, "Pads", N__->getPads());
186 addValueAttribute(opProto, "Group", N__->getGroup());
187 if (N__->hasPredicate()) {
188 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
189 }
190 break;
191}
192
193case glow::Kinded::Kind::MaxPoolGradNodeKind: {
194 auto *N__ = llvm::cast<MaxPoolGradNode>(node);
195 opProto = graph.add_node();
196 opProto->set_op_type("Glow_MaxPoolGrad");
197 opProto->set_name(glow::legalizeName(N__->getName()));
198 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
199 addTypeAttributes(opProto, N__, MaxPoolGradNode::InputIdx, /* isInput */ true);
200 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
201 addTypeAttributes(opProto, N__, MaxPoolGradNode::OriginalOutputForResultIdx, /* isInput */ true);
202 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
203 addTypeAttributes(opProto, N__, MaxPoolGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
204 opProto->add_input(N__->getOriginalOutputForArgmax().generateNodeOutputName(/* stripResNoFor0thInput */ true));
205 addTypeAttributes(opProto, N__, MaxPoolGradNode::OriginalOutputForArgmaxIdx, /* isInput */ true);
206 opProto->add_input(N__->getGradOfOriginalOutputNamedArgmax().generateNodeOutputName(/* stripResNoFor0thInput */ true));
207 addTypeAttributes(opProto, N__, MaxPoolGradNode::GradOfOriginalOutputNamedArgmaxIdx, /* isInput */ true);
208 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
209 addTypeAttributes(opProto, N__, MaxPoolGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
210 addValueAttribute(opProto, "Kernels", N__->getKernels());
211 addValueAttribute(opProto, "Strides", N__->getStrides());
212 addValueAttribute(opProto, "Pads", N__->getPads());
213 addValueAttribute(opProto, "Layout", N__->getLayout());
214 if (N__->hasPredicate()) {
215 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
216 }
217 break;
218}
219
220case glow::Kinded::Kind::MaxPoolNodeKind: {
221 auto *N__ = llvm::cast<MaxPoolNode>(node);
222 opProto = graph.add_node();
223 opProto->set_op_type("Glow_MaxPool");
224 opProto->set_name(glow::legalizeName(N__->getName()));
225 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
226 addTypeAttributes(opProto, N__, MaxPoolNode::InputIdx, /* isInput */ true);
227 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
228 addTypeAttributes(opProto, N__, MaxPoolNode::ResultIdx, /* isInput */ false);
229 opProto->add_output(N__->getArgmax().generateNodeOutputName(/* stripResNoFor0thInput */ true));
230 addTypeAttributes(opProto, N__, MaxPoolNode::ArgmaxIdx, /* isInput */ false);
231 addValueAttribute(opProto, "Kernels", N__->getKernels());
232 addValueAttribute(opProto, "Strides", N__->getStrides());
233 addValueAttribute(opProto, "Pads", N__->getPads());
234 addValueAttribute(opProto, "Layout", N__->getLayout());
235 if (N__->hasPredicate()) {
236 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
237 }
238 break;
239}
240
241case glow::Kinded::Kind::ArgMaxNodeKind: {
242 auto *N__ = llvm::cast<ArgMaxNode>(node);
243 opProto = graph.add_node();
244 opProto->set_op_type("Glow_ArgMax");
245 opProto->set_name(glow::legalizeName(N__->getName()));
246 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
247 addTypeAttributes(opProto, N__, ArgMaxNode::InputIdx, /* isInput */ true);
248 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
249 addTypeAttributes(opProto, N__, ArgMaxNode::ResultIdx, /* isInput */ false);
250 addValueAttribute(opProto, "Axis", N__->getAxis());
251 addValueAttribute(opProto, "KeepDims", N__->getKeepDims());
252 if (N__->hasPredicate()) {
253 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
254 }
255 break;
256}
257
258case glow::Kinded::Kind::ArgMinNodeKind: {
259 auto *N__ = llvm::cast<ArgMinNode>(node);
260 opProto = graph.add_node();
261 opProto->set_op_type("Glow_ArgMin");
262 opProto->set_name(glow::legalizeName(N__->getName()));
263 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
264 addTypeAttributes(opProto, N__, ArgMinNode::InputIdx, /* isInput */ true);
265 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
266 addTypeAttributes(opProto, N__, ArgMinNode::ResultIdx, /* isInput */ false);
267 addValueAttribute(opProto, "Axis", N__->getAxis());
268 addValueAttribute(opProto, "KeepDims", N__->getKeepDims());
269 if (N__->hasPredicate()) {
270 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
271 }
272 break;
273}
274
275case glow::Kinded::Kind::AvgPoolGradNodeKind: {
276 auto *N__ = llvm::cast<AvgPoolGradNode>(node);
277 opProto = graph.add_node();
278 opProto->set_op_type("Glow_AvgPoolGrad");
279 opProto->set_name(glow::legalizeName(N__->getName()));
280 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
281 addTypeAttributes(opProto, N__, AvgPoolGradNode::InputIdx, /* isInput */ true);
282 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
283 addTypeAttributes(opProto, N__, AvgPoolGradNode::OriginalOutputForResultIdx, /* isInput */ true);
284 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
285 addTypeAttributes(opProto, N__, AvgPoolGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
286 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
287 addTypeAttributes(opProto, N__, AvgPoolGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
288 addValueAttribute(opProto, "Kernels", N__->getKernels());
289 addValueAttribute(opProto, "Strides", N__->getStrides());
290 addValueAttribute(opProto, "Pads", N__->getPads());
291 addValueAttribute(opProto, "Layout", N__->getLayout());
292 addValueAttribute(opProto, "CountIncludePads", N__->getCountIncludePads());
293 if (N__->hasPredicate()) {
294 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
295 }
296 break;
297}
298
299case glow::Kinded::Kind::AvgPoolNodeKind: {
300 auto *N__ = llvm::cast<AvgPoolNode>(node);
301 opProto = graph.add_node();
302 opProto->set_op_type("Glow_AvgPool");
303 opProto->set_name(glow::legalizeName(N__->getName()));
304 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
305 addTypeAttributes(opProto, N__, AvgPoolNode::InputIdx, /* isInput */ true);
306 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
307 addTypeAttributes(opProto, N__, AvgPoolNode::ResultIdx, /* isInput */ false);
308 addValueAttribute(opProto, "Kernels", N__->getKernels());
309 addValueAttribute(opProto, "Strides", N__->getStrides());
310 addValueAttribute(opProto, "Pads", N__->getPads());
311 addValueAttribute(opProto, "Layout", N__->getLayout());
312 addValueAttribute(opProto, "CountIncludePads", N__->getCountIncludePads());
313 if (N__->hasPredicate()) {
314 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
315 }
316 break;
317}
318
319case glow::Kinded::Kind::AdaptiveAvgPoolGradNodeKind: {
320 auto *N__ = llvm::cast<AdaptiveAvgPoolGradNode>(node);
321 opProto = graph.add_node();
322 opProto->set_op_type("Glow_AdaptiveAvgPoolGrad");
323 opProto->set_name(glow::legalizeName(N__->getName()));
324 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
325 addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::InputIdx, /* isInput */ true);
326 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
327 addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::OriginalOutputForResultIdx, /* isInput */ true);
328 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
329 addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
330 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
331 addTypeAttributes(opProto, N__, AdaptiveAvgPoolGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
332 if (N__->hasPredicate()) {
333 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
334 }
335 break;
336}
337
338case glow::Kinded::Kind::AdaptiveAvgPoolNodeKind: {
339 auto *N__ = llvm::cast<AdaptiveAvgPoolNode>(node);
340 opProto = graph.add_node();
341 opProto->set_op_type("Glow_AdaptiveAvgPool");
342 opProto->set_name(glow::legalizeName(N__->getName()));
343 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
344 addTypeAttributes(opProto, N__, AdaptiveAvgPoolNode::InputIdx, /* isInput */ true);
345 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
346 addTypeAttributes(opProto, N__, AdaptiveAvgPoolNode::ResultIdx, /* isInput */ false);
347 if (N__->hasPredicate()) {
348 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
349 }
350 break;
351}
352
353case glow::Kinded::Kind::GemmNodeKind: {
354 auto *N__ = llvm::cast<GemmNode>(node);
355 opProto = graph.add_node();
356 opProto->set_op_type("Glow_Gemm");
357 opProto->set_name(glow::legalizeName(N__->getName()));
358 opProto->add_input(N__->getA().generateNodeOutputName(/* stripResNoFor0thInput */ true));
359 addTypeAttributes(opProto, N__, GemmNode::AIdx, /* isInput */ true);
360 opProto->add_input(N__->getB().generateNodeOutputName(/* stripResNoFor0thInput */ true));
361 addTypeAttributes(opProto, N__, GemmNode::BIdx, /* isInput */ true);
362 opProto->add_input(N__->getC().generateNodeOutputName(/* stripResNoFor0thInput */ true));
363 addTypeAttributes(opProto, N__, GemmNode::CIdx, /* isInput */ true);
364 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
365 addTypeAttributes(opProto, N__, GemmNode::ResultIdx, /* isInput */ false);
366 addValueAttribute(opProto, "Alpha", N__->getAlpha());
367 addValueAttribute(opProto, "Beta", N__->getBeta());
368 addValueAttribute(opProto, "TransposeA", N__->getTransposeA());
369 addValueAttribute(opProto, "TransposeB", N__->getTransposeB());
370 if (N__->hasPredicate()) {
371 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
372 }
373 break;
374}
375
376case glow::Kinded::Kind::FullyConnectedGradNodeKind: {
377 auto *N__ = llvm::cast<FullyConnectedGradNode>(node);
378 opProto = graph.add_node();
379 opProto->set_op_type("Glow_FullyConnectedGrad");
380 opProto->set_name(glow::legalizeName(N__->getName()));
381 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
382 addTypeAttributes(opProto, N__, FullyConnectedGradNode::InputIdx, /* isInput */ true);
383 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
384 addTypeAttributes(opProto, N__, FullyConnectedGradNode::WeightsIdx, /* isInput */ true);
385 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
386 addTypeAttributes(opProto, N__, FullyConnectedGradNode::BiasIdx, /* isInput */ true);
387 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
388 addTypeAttributes(opProto, N__, FullyConnectedGradNode::OriginalOutputForResultIdx, /* isInput */ true);
389 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
390 addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
391 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
392 addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
393 opProto->add_output(N__->getGradOfInputNamedWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
394 addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfInputNamedWeightsIdx, /* isInput */ false);
395 opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
396 addTypeAttributes(opProto, N__, FullyConnectedGradNode::GradOfInputNamedBiasIdx, /* isInput */ false);
397 if (N__->hasPredicate()) {
398 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
399 }
400 break;
401}
402
403case glow::Kinded::Kind::FullyConnectedNodeKind: {
404 auto *N__ = llvm::cast<FullyConnectedNode>(node);
405 opProto = graph.add_node();
406 opProto->set_op_type("Glow_FullyConnected");
407 opProto->set_name(glow::legalizeName(N__->getName()));
408 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
409 addTypeAttributes(opProto, N__, FullyConnectedNode::InputIdx, /* isInput */ true);
410 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
411 addTypeAttributes(opProto, N__, FullyConnectedNode::WeightsIdx, /* isInput */ true);
412 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
413 addTypeAttributes(opProto, N__, FullyConnectedNode::BiasIdx, /* isInput */ true);
414 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
415 addTypeAttributes(opProto, N__, FullyConnectedNode::ResultIdx, /* isInput */ false);
416 if (N__->hasPredicate()) {
417 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
418 }
419 break;
420}
421
422case glow::Kinded::Kind::RowwiseQuantizedFullyConnectedNodeKind: {
423 auto *N__ = llvm::cast<RowwiseQuantizedFullyConnectedNode>(node);
424 opProto = graph.add_node();
425 opProto->set_op_type("Glow_RowwiseQuantizedFullyConnected");
426 opProto->set_name(glow::legalizeName(N__->getName()));
427 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
428 addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::InputIdx, /* isInput */ true);
429 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
430 addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::WeightsIdx, /* isInput */ true);
431 opProto->add_input(N__->getScales().generateNodeOutputName(/* stripResNoFor0thInput */ true));
432 addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::ScalesIdx, /* isInput */ true);
433 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
434 addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::OffsetsIdx, /* isInput */ true);
435 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
436 addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::BiasIdx, /* isInput */ true);
437 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
438 addTypeAttributes(opProto, N__, RowwiseQuantizedFullyConnectedNode::ResultIdx, /* isInput */ false);
439 if (N__->hasPredicate()) {
440 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
441 }
442 break;
443}
444
445case glow::Kinded::Kind::DynamicQuantizedFullyConnectedNodeKind: {
446 auto *N__ = llvm::cast<DynamicQuantizedFullyConnectedNode>(node);
447 opProto = graph.add_node();
448 opProto->set_op_type("Glow_DynamicQuantizedFullyConnected");
449 opProto->set_name(glow::legalizeName(N__->getName()));
450 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
451 addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::InputIdx, /* isInput */ true);
452 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
453 addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::WeightsIdx, /* isInput */ true);
454 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
455 addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::BiasIdx, /* isInput */ true);
456 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
457 addTypeAttributes(opProto, N__, DynamicQuantizedFullyConnectedNode::ResultIdx, /* isInput */ false);
458 addValueAttribute(opProto, "IsSymmetric", N__->getIsSymmetric());
459 addValueAttribute(opProto, "IsPerBatchElement", N__->getIsPerBatchElement());
460 if (N__->hasPredicate()) {
461 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
462 }
463 break;
464}
465
466case glow::Kinded::Kind::DynamicRowwiseQuantizedFullyConnectedNodeKind: {
467 auto *N__ = llvm::cast<DynamicRowwiseQuantizedFullyConnectedNode>(node);
468 opProto = graph.add_node();
469 opProto->set_op_type("Glow_DynamicRowwiseQuantizedFullyConnected");
470 opProto->set_name(glow::legalizeName(N__->getName()));
471 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
472 addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::InputIdx, /* isInput */ true);
473 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
474 addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::WeightsIdx, /* isInput */ true);
475 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
476 addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::BiasIdx, /* isInput */ true);
477 opProto->add_input(N__->getScales().generateNodeOutputName(/* stripResNoFor0thInput */ true));
478 addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::ScalesIdx, /* isInput */ true);
479 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
480 addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::OffsetsIdx, /* isInput */ true);
481 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
482 addTypeAttributes(opProto, N__, DynamicRowwiseQuantizedFullyConnectedNode::ResultIdx, /* isInput */ false);
483 addValueAttribute(opProto, "IsSymmetric", N__->getIsSymmetric());
484 addValueAttribute(opProto, "IsPerBatchElement", N__->getIsPerBatchElement());
485 if (N__->hasPredicate()) {
486 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
487 }
488 break;
489}
490
491case glow::Kinded::Kind::BatchNormalizationGradNodeKind: {
492 auto *N__ = llvm::cast<BatchNormalizationGradNode>(node);
493 opProto = graph.add_node();
494 opProto->set_op_type("Glow_BatchNormalizationGrad");
495 opProto->set_name(glow::legalizeName(N__->getName()));
496 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
497 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::InputIdx, /* isInput */ true);
498 opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true));
499 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::ScaleIdx, /* isInput */ true);
500 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
501 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::BiasIdx, /* isInput */ true);
502 opProto->add_input(N__->getMean().generateNodeOutputName(/* stripResNoFor0thInput */ true));
503 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::MeanIdx, /* isInput */ true);
504 opProto->add_input(N__->getVar().generateNodeOutputName(/* stripResNoFor0thInput */ true));
505 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::VarIdx, /* isInput */ true);
506 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
507 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::OriginalOutputForResultIdx, /* isInput */ true);
508 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
509 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
510 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
511 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
512 opProto->add_output(N__->getGradOfInputNamedScale().generateNodeOutputName(/* stripResNoFor0thInput */ true));
513 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedScaleIdx, /* isInput */ false);
514 opProto->add_output(N__->getGradOfInputNamedBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
515 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedBiasIdx, /* isInput */ false);
516 opProto->add_output(N__->getGradOfInputNamedMean().generateNodeOutputName(/* stripResNoFor0thInput */ true));
517 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedMeanIdx, /* isInput */ false);
518 opProto->add_output(N__->getGradOfInputNamedVar().generateNodeOutputName(/* stripResNoFor0thInput */ true));
519 addTypeAttributes(opProto, N__, BatchNormalizationGradNode::GradOfInputNamedVarIdx, /* isInput */ false);
520 addValueAttribute(opProto, "ChannelIdx", N__->getChannelIdx());
521 addValueAttribute(opProto, "Epsilon", N__->getEpsilon());
522 addValueAttribute(opProto, "Momentum", N__->getMomentum());
523 if (N__->hasPredicate()) {
524 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
525 }
526 break;
527}
528
529case glow::Kinded::Kind::BatchNormalizationNodeKind: {
530 auto *N__ = llvm::cast<BatchNormalizationNode>(node);
531 opProto = graph.add_node();
532 opProto->set_op_type("Glow_BatchNormalization");
533 opProto->set_name(glow::legalizeName(N__->getName()));
534 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
535 addTypeAttributes(opProto, N__, BatchNormalizationNode::InputIdx, /* isInput */ true);
536 opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true));
537 addTypeAttributes(opProto, N__, BatchNormalizationNode::ScaleIdx, /* isInput */ true);
538 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
539 addTypeAttributes(opProto, N__, BatchNormalizationNode::BiasIdx, /* isInput */ true);
540 opProto->add_input(N__->getMean().generateNodeOutputName(/* stripResNoFor0thInput */ true));
541 addTypeAttributes(opProto, N__, BatchNormalizationNode::MeanIdx, /* isInput */ true);
542 opProto->add_input(N__->getVar().generateNodeOutputName(/* stripResNoFor0thInput */ true));
543 addTypeAttributes(opProto, N__, BatchNormalizationNode::VarIdx, /* isInput */ true);
544 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
545 addTypeAttributes(opProto, N__, BatchNormalizationNode::ResultIdx, /* isInput */ false);
546 addValueAttribute(opProto, "ChannelIdx", N__->getChannelIdx());
547 addValueAttribute(opProto, "Epsilon", N__->getEpsilon());
548 addValueAttribute(opProto, "Momentum", N__->getMomentum());
549 if (N__->hasPredicate()) {
550 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
551 }
552 break;
553}
554
555case glow::Kinded::Kind::InstanceNormalizationNodeKind: {
556 auto *N__ = llvm::cast<InstanceNormalizationNode>(node);
557 opProto = graph.add_node();
558 opProto->set_op_type("Glow_InstanceNormalization");
559 opProto->set_name(glow::legalizeName(N__->getName()));
560 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
561 addTypeAttributes(opProto, N__, InstanceNormalizationNode::InputIdx, /* isInput */ true);
562 opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true));
563 addTypeAttributes(opProto, N__, InstanceNormalizationNode::ScaleIdx, /* isInput */ true);
564 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
565 addTypeAttributes(opProto, N__, InstanceNormalizationNode::BiasIdx, /* isInput */ true);
566 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
567 addTypeAttributes(opProto, N__, InstanceNormalizationNode::ResultIdx, /* isInput */ false);
568 addValueAttribute(opProto, "ChannelIdx", N__->getChannelIdx());
569 addValueAttribute(opProto, "Epsilon", N__->getEpsilon());
570 if (N__->hasPredicate()) {
571 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
572 }
573 break;
574}
575
576case glow::Kinded::Kind::MeanVarNormalizationNodeKind: {
577 auto *N__ = llvm::cast<MeanVarNormalizationNode>(node);
578 opProto = graph.add_node();
579 opProto->set_op_type("Glow_MeanVarNormalization");
580 opProto->set_name(glow::legalizeName(N__->getName()));
581 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
582 addTypeAttributes(opProto, N__, MeanVarNormalizationNode::InputIdx, /* isInput */ true);
583 opProto->add_input(N__->getMean().generateNodeOutputName(/* stripResNoFor0thInput */ true));
584 addTypeAttributes(opProto, N__, MeanVarNormalizationNode::MeanIdx, /* isInput */ true);
585 opProto->add_input(N__->getVar().generateNodeOutputName(/* stripResNoFor0thInput */ true));
586 addTypeAttributes(opProto, N__, MeanVarNormalizationNode::VarIdx, /* isInput */ true);
587 opProto->add_output(N__->getNewMean().generateNodeOutputName(/* stripResNoFor0thInput */ true));
588 addTypeAttributes(opProto, N__, MeanVarNormalizationNode::NewMeanIdx, /* isInput */ false);
589 opProto->add_output(N__->getNewVar().generateNodeOutputName(/* stripResNoFor0thInput */ true));
590 addTypeAttributes(opProto, N__, MeanVarNormalizationNode::NewVarIdx, /* isInput */ false);
591 addValueAttribute(opProto, "ChannelIdx", N__->getChannelIdx());
592 addValueAttribute(opProto, "Momentum", N__->getMomentum());
593 if (N__->hasPredicate()) {
594 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
595 }
596 break;
597}
598
599case glow::Kinded::Kind::LocalResponseNormalizationGradNodeKind: {
600 auto *N__ = llvm::cast<LocalResponseNormalizationGradNode>(node);
601 opProto = graph.add_node();
602 opProto->set_op_type("Glow_LocalResponseNormalizationGrad");
603 opProto->set_name(glow::legalizeName(N__->getName()));
604 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
605 addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::InputIdx, /* isInput */ true);
606 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
607 addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::OriginalOutputForResultIdx, /* isInput */ true);
608 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
609 addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
610 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
611 addTypeAttributes(opProto, N__, LocalResponseNormalizationGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
612 addValueAttribute(opProto, "HalfWindowSize", N__->getHalfWindowSize());
613 addValueAttribute(opProto, "Alpha", N__->getAlpha());
614 addValueAttribute(opProto, "Beta", N__->getBeta());
615 addValueAttribute(opProto, "K", N__->getK());
616 if (N__->hasPredicate()) {
617 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
618 }
619 break;
620}
621
622case glow::Kinded::Kind::LocalResponseNormalizationNodeKind: {
623 auto *N__ = llvm::cast<LocalResponseNormalizationNode>(node);
624 opProto = graph.add_node();
625 opProto->set_op_type("Glow_LocalResponseNormalization");
626 opProto->set_name(glow::legalizeName(N__->getName()));
627 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
628 addTypeAttributes(opProto, N__, LocalResponseNormalizationNode::InputIdx, /* isInput */ true);
629 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
630 addTypeAttributes(opProto, N__, LocalResponseNormalizationNode::ResultIdx, /* isInput */ false);
631 addValueAttribute(opProto, "HalfWindowSize", N__->getHalfWindowSize());
632 addValueAttribute(opProto, "Alpha", N__->getAlpha());
633 addValueAttribute(opProto, "Beta", N__->getBeta());
634 addValueAttribute(opProto, "K", N__->getK());
635 if (N__->hasPredicate()) {
636 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
637 }
638 break;
639}
640
641case glow::Kinded::Kind::LayerNormalizationNodeKind: {
642 auto *N__ = llvm::cast<LayerNormalizationNode>(node);
643 opProto = graph.add_node();
644 opProto->set_op_type("Glow_LayerNormalization");
645 opProto->set_name(glow::legalizeName(N__->getName()));
646 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
647 addTypeAttributes(opProto, N__, LayerNormalizationNode::InputIdx, /* isInput */ true);
648 opProto->add_input(N__->getScale().generateNodeOutputName(/* stripResNoFor0thInput */ true));
649 addTypeAttributes(opProto, N__, LayerNormalizationNode::ScaleIdx, /* isInput */ true);
650 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
651 addTypeAttributes(opProto, N__, LayerNormalizationNode::BiasIdx, /* isInput */ true);
652 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
653 addTypeAttributes(opProto, N__, LayerNormalizationNode::ResultIdx, /* isInput */ false);
654 addValueAttribute(opProto, "Epsilon", N__->getEpsilon());
655 if (N__->hasPredicate()) {
656 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
657 }
658 break;
659}
660
661case glow::Kinded::Kind::BatchBoxCoxNodeKind: {
662 auto *N__ = llvm::cast<BatchBoxCoxNode>(node);
663 opProto = graph.add_node();
664 opProto->set_op_type("Glow_BatchBoxCox");
665 opProto->set_name(glow::legalizeName(N__->getName()));
666 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
667 addTypeAttributes(opProto, N__, BatchBoxCoxNode::InputIdx, /* isInput */ true);
668 opProto->add_input(N__->getLambda1().generateNodeOutputName(/* stripResNoFor0thInput */ true));
669 addTypeAttributes(opProto, N__, BatchBoxCoxNode::Lambda1Idx, /* isInput */ true);
670 opProto->add_input(N__->getLambda2().generateNodeOutputName(/* stripResNoFor0thInput */ true));
671 addTypeAttributes(opProto, N__, BatchBoxCoxNode::Lambda2Idx, /* isInput */ true);
672 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
673 addTypeAttributes(opProto, N__, BatchBoxCoxNode::ResultIdx, /* isInput */ false);
674 addValueAttribute(opProto, "Epsilon", N__->getEpsilon());
675 if (N__->hasPredicate()) {
676 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
677 }
678 break;
679}
680
681case glow::Kinded::Kind::VectorNormNodeKind: {
682 auto *N__ = llvm::cast<VectorNormNode>(node);
683 opProto = graph.add_node();
684 opProto->set_op_type("Glow_VectorNorm");
685 opProto->set_name(glow::legalizeName(N__->getName()));
686 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
687 addTypeAttributes(opProto, N__, VectorNormNode::InputIdx, /* isInput */ true);
688 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
689 addTypeAttributes(opProto, N__, VectorNormNode::ResultIdx, /* isInput */ false);
690 addValueAttribute(opProto, "Axis", N__->getAxis());
691 addValueAttribute(opProto, "P", N__->getP());
692 if (N__->hasPredicate()) {
693 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
694 }
695 break;
696}
697
698case glow::Kinded::Kind::BucketizeNodeKind: {
699 auto *N__ = llvm::cast<BucketizeNode>(node);
700 opProto = graph.add_node();
701 opProto->set_op_type("Glow_Bucketize");
702 opProto->set_name(glow::legalizeName(N__->getName()));
703 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
704 addTypeAttributes(opProto, N__, BucketizeNode::InputIdx, /* isInput */ true);
705 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
706 addTypeAttributes(opProto, N__, BucketizeNode::ResultIdx, /* isInput */ false);
707 addValueAttribute(opProto, "Boundaries", N__->getBoundaries());
708 if (N__->hasPredicate()) {
709 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
710 }
711 break;
712}
713
714case glow::Kinded::Kind::SoftMaxGradNodeKind: {
715 auto *N__ = llvm::cast<SoftMaxGradNode>(node);
716 opProto = graph.add_node();
717 opProto->set_op_type("Glow_SoftMaxGrad");
718 opProto->set_name(glow::legalizeName(N__->getName()));
719 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
720 addTypeAttributes(opProto, N__, SoftMaxGradNode::InputIdx, /* isInput */ true);
721 opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
722 addTypeAttributes(opProto, N__, SoftMaxGradNode::SelectedIdx, /* isInput */ true);
723 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
724 addTypeAttributes(opProto, N__, SoftMaxGradNode::OriginalOutputForResultIdx, /* isInput */ true);
725 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
726 addTypeAttributes(opProto, N__, SoftMaxGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
727 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
728 addTypeAttributes(opProto, N__, SoftMaxGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
729 opProto->add_output(N__->getGradOfInputNamedSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
730 addTypeAttributes(opProto, N__, SoftMaxGradNode::GradOfInputNamedSelectedIdx, /* isInput */ false);
731 if (N__->hasPredicate()) {
732 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
733 }
734 break;
735}
736
737case glow::Kinded::Kind::SoftMaxNodeKind: {
738 auto *N__ = llvm::cast<SoftMaxNode>(node);
739 opProto = graph.add_node();
740 opProto->set_op_type("Glow_SoftMax");
741 opProto->set_name(glow::legalizeName(N__->getName()));
742 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
743 addTypeAttributes(opProto, N__, SoftMaxNode::InputIdx, /* isInput */ true);
744 opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
745 addTypeAttributes(opProto, N__, SoftMaxNode::SelectedIdx, /* isInput */ true);
746 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
747 addTypeAttributes(opProto, N__, SoftMaxNode::ResultIdx, /* isInput */ false);
748 if (N__->hasPredicate()) {
749 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
750 }
751 break;
752}
753
754case glow::Kinded::Kind::LogSoftMaxGradNodeKind: {
755 auto *N__ = llvm::cast<LogSoftMaxGradNode>(node);
756 opProto = graph.add_node();
757 opProto->set_op_type("Glow_LogSoftMaxGrad");
758 opProto->set_name(glow::legalizeName(N__->getName()));
759 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
760 addTypeAttributes(opProto, N__, LogSoftMaxGradNode::InputIdx, /* isInput */ true);
761 opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
762 addTypeAttributes(opProto, N__, LogSoftMaxGradNode::SelectedIdx, /* isInput */ true);
763 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
764 addTypeAttributes(opProto, N__, LogSoftMaxGradNode::OriginalOutputForResultIdx, /* isInput */ true);
765 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
766 addTypeAttributes(opProto, N__, LogSoftMaxGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
767 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
768 addTypeAttributes(opProto, N__, LogSoftMaxGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
769 opProto->add_output(N__->getGradOfInputNamedSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
770 addTypeAttributes(opProto, N__, LogSoftMaxGradNode::GradOfInputNamedSelectedIdx, /* isInput */ false);
771 if (N__->hasPredicate()) {
772 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
773 }
774 break;
775}
776
777case glow::Kinded::Kind::LogSoftMaxNodeKind: {
778 auto *N__ = llvm::cast<LogSoftMaxNode>(node);
779 opProto = graph.add_node();
780 opProto->set_op_type("Glow_LogSoftMax");
781 opProto->set_name(glow::legalizeName(N__->getName()));
782 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
783 addTypeAttributes(opProto, N__, LogSoftMaxNode::InputIdx, /* isInput */ true);
784 opProto->add_input(N__->getSelected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
785 addTypeAttributes(opProto, N__, LogSoftMaxNode::SelectedIdx, /* isInput */ true);
786 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
787 addTypeAttributes(opProto, N__, LogSoftMaxNode::ResultIdx, /* isInput */ false);
788 if (N__->hasPredicate()) {
789 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
790 }
791 break;
792}
793
794case glow::Kinded::Kind::CrossEntropyLossGradNodeKind: {
795 auto *N__ = llvm::cast<CrossEntropyLossGradNode>(node);
796 opProto = graph.add_node();
797 opProto->set_op_type("Glow_CrossEntropyLossGrad");
798 opProto->set_name(glow::legalizeName(N__->getName()));
799 opProto->add_input(N__->getP().generateNodeOutputName(/* stripResNoFor0thInput */ true));
800 addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::PIdx, /* isInput */ true);
801 opProto->add_input(N__->getLabels().generateNodeOutputName(/* stripResNoFor0thInput */ true));
802 addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::LabelsIdx, /* isInput */ true);
803 opProto->add_input(N__->getOriginalOutputForCE().generateNodeOutputName(/* stripResNoFor0thInput */ true));
804 addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::OriginalOutputForCEIdx, /* isInput */ true);
805 opProto->add_input(N__->getGradOfOriginalOutputNamedCE().generateNodeOutputName(/* stripResNoFor0thInput */ true));
806 addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::GradOfOriginalOutputNamedCEIdx, /* isInput */ true);
807 opProto->add_output(N__->getGradOfInputNamedP().generateNodeOutputName(/* stripResNoFor0thInput */ true));
808 addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::GradOfInputNamedPIdx, /* isInput */ false);
809 opProto->add_output(N__->getGradOfInputNamedLabels().generateNodeOutputName(/* stripResNoFor0thInput */ true));
810 addTypeAttributes(opProto, N__, CrossEntropyLossGradNode::GradOfInputNamedLabelsIdx, /* isInput */ false);
811 if (N__->hasPredicate()) {
812 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
813 }
814 break;
815}
816
817case glow::Kinded::Kind::CrossEntropyLossNodeKind: {
818 auto *N__ = llvm::cast<CrossEntropyLossNode>(node);
819 opProto = graph.add_node();
820 opProto->set_op_type("Glow_CrossEntropyLoss");
821 opProto->set_name(glow::legalizeName(N__->getName()));
822 opProto->add_input(N__->getP().generateNodeOutputName(/* stripResNoFor0thInput */ true));
823 addTypeAttributes(opProto, N__, CrossEntropyLossNode::PIdx, /* isInput */ true);
824 opProto->add_input(N__->getLabels().generateNodeOutputName(/* stripResNoFor0thInput */ true));
825 addTypeAttributes(opProto, N__, CrossEntropyLossNode::LabelsIdx, /* isInput */ true);
826 opProto->add_output(N__->getCE().generateNodeOutputName(/* stripResNoFor0thInput */ true));
827 addTypeAttributes(opProto, N__, CrossEntropyLossNode::CEIdx, /* isInput */ false);
828 if (N__->hasPredicate()) {
829 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
830 }
831 break;
832}
833
834case glow::Kinded::Kind::RegressionGradNodeKind: {
835 auto *N__ = llvm::cast<RegressionGradNode>(node);
836 opProto = graph.add_node();
837 opProto->set_op_type("Glow_RegressionGrad");
838 opProto->set_name(glow::legalizeName(N__->getName()));
839 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
840 addTypeAttributes(opProto, N__, RegressionGradNode::InputIdx, /* isInput */ true);
841 opProto->add_input(N__->getExpected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
842 addTypeAttributes(opProto, N__, RegressionGradNode::ExpectedIdx, /* isInput */ true);
843 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
844 addTypeAttributes(opProto, N__, RegressionGradNode::OriginalOutputForResultIdx, /* isInput */ true);
845 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
846 addTypeAttributes(opProto, N__, RegressionGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
847 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
848 addTypeAttributes(opProto, N__, RegressionGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
849 opProto->add_output(N__->getGradOfInputNamedExpected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
850 addTypeAttributes(opProto, N__, RegressionGradNode::GradOfInputNamedExpectedIdx, /* isInput */ false);
851 if (N__->hasPredicate()) {
852 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
853 }
854 break;
855}
856
857case glow::Kinded::Kind::RegressionNodeKind: {
858 auto *N__ = llvm::cast<RegressionNode>(node);
859 opProto = graph.add_node();
860 opProto->set_op_type("Glow_Regression");
861 opProto->set_name(glow::legalizeName(N__->getName()));
862 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
863 addTypeAttributes(opProto, N__, RegressionNode::InputIdx, /* isInput */ true);
864 opProto->add_input(N__->getExpected().generateNodeOutputName(/* stripResNoFor0thInput */ true));
865 addTypeAttributes(opProto, N__, RegressionNode::ExpectedIdx, /* isInput */ true);
866 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
867 addTypeAttributes(opProto, N__, RegressionNode::ResultIdx, /* isInput */ false);
868 if (N__->hasPredicate()) {
869 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
870 }
871 break;
872}
873
874case glow::Kinded::Kind::SigmoidCrossEntropyWithLogitsNodeKind: {
875 auto *N__ = llvm::cast<SigmoidCrossEntropyWithLogitsNode>(node);
876 opProto = graph.add_node();
877 opProto->set_op_type("Glow_SigmoidCrossEntropyWithLogits");
878 opProto->set_name(glow::legalizeName(N__->getName()));
879 opProto->add_input(N__->getLogits().generateNodeOutputName(/* stripResNoFor0thInput */ true));
880 addTypeAttributes(opProto, N__, SigmoidCrossEntropyWithLogitsNode::LogitsIdx, /* isInput */ true);
881 opProto->add_input(N__->getTargets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
882 addTypeAttributes(opProto, N__, SigmoidCrossEntropyWithLogitsNode::TargetsIdx, /* isInput */ true);
883 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
884 addTypeAttributes(opProto, N__, SigmoidCrossEntropyWithLogitsNode::ResultIdx, /* isInput */ false);
885 if (N__->hasPredicate()) {
886 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
887 }
888 break;
889}
890
891case glow::Kinded::Kind::AddGradNodeKind: {
892 auto *N__ = llvm::cast<AddGradNode>(node);
893 opProto = graph.add_node();
894 opProto->set_op_type("Glow_AddGrad");
895 opProto->set_name(glow::legalizeName(N__->getName()));
896 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
897 addTypeAttributes(opProto, N__, AddGradNode::LHSIdx, /* isInput */ true);
898 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
899 addTypeAttributes(opProto, N__, AddGradNode::RHSIdx, /* isInput */ true);
900 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
901 addTypeAttributes(opProto, N__, AddGradNode::OriginalOutputForResultIdx, /* isInput */ true);
902 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
903 addTypeAttributes(opProto, N__, AddGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
904 opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
905 addTypeAttributes(opProto, N__, AddGradNode::GradOfInputNamedLHSIdx, /* isInput */ false);
906 opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
907 addTypeAttributes(opProto, N__, AddGradNode::GradOfInputNamedRHSIdx, /* isInput */ false);
908 if (N__->hasPredicate()) {
909 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
910 }
911 break;
912}
913
914case glow::Kinded::Kind::AddNodeKind: {
915 auto *N__ = llvm::cast<AddNode>(node);
916 opProto = graph.add_node();
917 opProto->set_op_type("Glow_Add");
918 opProto->set_name(glow::legalizeName(N__->getName()));
919 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
920 addTypeAttributes(opProto, N__, AddNode::LHSIdx, /* isInput */ true);
921 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
922 addTypeAttributes(opProto, N__, AddNode::RHSIdx, /* isInput */ true);
923 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
924 addTypeAttributes(opProto, N__, AddNode::ResultIdx, /* isInput */ false);
925 if (N__->hasPredicate()) {
926 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
927 }
928 break;
929}
930
931case glow::Kinded::Kind::MulGradNodeKind: {
932 auto *N__ = llvm::cast<MulGradNode>(node);
933 opProto = graph.add_node();
934 opProto->set_op_type("Glow_MulGrad");
935 opProto->set_name(glow::legalizeName(N__->getName()));
936 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
937 addTypeAttributes(opProto, N__, MulGradNode::LHSIdx, /* isInput */ true);
938 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
939 addTypeAttributes(opProto, N__, MulGradNode::RHSIdx, /* isInput */ true);
940 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
941 addTypeAttributes(opProto, N__, MulGradNode::OriginalOutputForResultIdx, /* isInput */ true);
942 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
943 addTypeAttributes(opProto, N__, MulGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
944 opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
945 addTypeAttributes(opProto, N__, MulGradNode::GradOfInputNamedLHSIdx, /* isInput */ false);
946 opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
947 addTypeAttributes(opProto, N__, MulGradNode::GradOfInputNamedRHSIdx, /* isInput */ false);
948 if (N__->hasPredicate()) {
949 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
950 }
951 break;
952}
953
954case glow::Kinded::Kind::MulNodeKind: {
955 auto *N__ = llvm::cast<MulNode>(node);
956 opProto = graph.add_node();
957 opProto->set_op_type("Glow_Mul");
958 opProto->set_name(glow::legalizeName(N__->getName()));
959 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
960 addTypeAttributes(opProto, N__, MulNode::LHSIdx, /* isInput */ true);
961 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
962 addTypeAttributes(opProto, N__, MulNode::RHSIdx, /* isInput */ true);
963 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
964 addTypeAttributes(opProto, N__, MulNode::ResultIdx, /* isInput */ false);
965 if (N__->hasPredicate()) {
966 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
967 }
968 break;
969}
970
971case glow::Kinded::Kind::SubGradNodeKind: {
972 auto *N__ = llvm::cast<SubGradNode>(node);
973 opProto = graph.add_node();
974 opProto->set_op_type("Glow_SubGrad");
975 opProto->set_name(glow::legalizeName(N__->getName()));
976 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
977 addTypeAttributes(opProto, N__, SubGradNode::LHSIdx, /* isInput */ true);
978 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
979 addTypeAttributes(opProto, N__, SubGradNode::RHSIdx, /* isInput */ true);
980 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
981 addTypeAttributes(opProto, N__, SubGradNode::OriginalOutputForResultIdx, /* isInput */ true);
982 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
983 addTypeAttributes(opProto, N__, SubGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
984 opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
985 addTypeAttributes(opProto, N__, SubGradNode::GradOfInputNamedLHSIdx, /* isInput */ false);
986 opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
987 addTypeAttributes(opProto, N__, SubGradNode::GradOfInputNamedRHSIdx, /* isInput */ false);
988 if (N__->hasPredicate()) {
989 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
990 }
991 break;
992}
993
994case glow::Kinded::Kind::SubNodeKind: {
995 auto *N__ = llvm::cast<SubNode>(node);
996 opProto = graph.add_node();
997 opProto->set_op_type("Glow_Sub");
998 opProto->set_name(glow::legalizeName(N__->getName()));
999 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1000 addTypeAttributes(opProto, N__, SubNode::LHSIdx, /* isInput */ true);
1001 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1002 addTypeAttributes(opProto, N__, SubNode::RHSIdx, /* isInput */ true);
1003 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1004 addTypeAttributes(opProto, N__, SubNode::ResultIdx, /* isInput */ false);
1005 if (N__->hasPredicate()) {
1006 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1007 }
1008 break;
1009}
1010
1011case glow::Kinded::Kind::DivGradNodeKind: {
1012 auto *N__ = llvm::cast<DivGradNode>(node);
1013 opProto = graph.add_node();
1014 opProto->set_op_type("Glow_DivGrad");
1015 opProto->set_name(glow::legalizeName(N__->getName()));
1016 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1017 addTypeAttributes(opProto, N__, DivGradNode::LHSIdx, /* isInput */ true);
1018 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1019 addTypeAttributes(opProto, N__, DivGradNode::RHSIdx, /* isInput */ true);
1020 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1021 addTypeAttributes(opProto, N__, DivGradNode::OriginalOutputForResultIdx, /* isInput */ true);
1022 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1023 addTypeAttributes(opProto, N__, DivGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
1024 opProto->add_output(N__->getGradOfInputNamedLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1025 addTypeAttributes(opProto, N__, DivGradNode::GradOfInputNamedLHSIdx, /* isInput */ false);
1026 opProto->add_output(N__->getGradOfInputNamedRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1027 addTypeAttributes(opProto, N__, DivGradNode::GradOfInputNamedRHSIdx, /* isInput */ false);
1028 if (N__->hasPredicate()) {
1029 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1030 }
1031 break;
1032}
1033
1034case glow::Kinded::Kind::DivNodeKind: {
1035 auto *N__ = llvm::cast<DivNode>(node);
1036 opProto = graph.add_node();
1037 opProto->set_op_type("Glow_Div");
1038 opProto->set_name(glow::legalizeName(N__->getName()));
1039 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1040 addTypeAttributes(opProto, N__, DivNode::LHSIdx, /* isInput */ true);
1041 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1042 addTypeAttributes(opProto, N__, DivNode::RHSIdx, /* isInput */ true);
1043 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1044 addTypeAttributes(opProto, N__, DivNode::ResultIdx, /* isInput */ false);
1045 if (N__->hasPredicate()) {
1046 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1047 }
1048 break;
1049}
1050
1051case glow::Kinded::Kind::FloorDivNodeKind: {
1052 auto *N__ = llvm::cast<FloorDivNode>(node);
1053 opProto = graph.add_node();
1054 opProto->set_op_type("Glow_FloorDiv");
1055 opProto->set_name(glow::legalizeName(N__->getName()));
1056 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1057 addTypeAttributes(opProto, N__, FloorDivNode::LHSIdx, /* isInput */ true);
1058 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1059 addTypeAttributes(opProto, N__, FloorDivNode::RHSIdx, /* isInput */ true);
1060 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1061 addTypeAttributes(opProto, N__, FloorDivNode::ResultIdx, /* isInput */ false);
1062 addValueAttribute(opProto, "Truncate", N__->getTruncate());
1063 if (N__->hasPredicate()) {
1064 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1065 }
1066 break;
1067}
1068
1069case glow::Kinded::Kind::FmodNodeKind: {
1070 auto *N__ = llvm::cast<FmodNode>(node);
1071 opProto = graph.add_node();
1072 opProto->set_op_type("Glow_Fmod");
1073 opProto->set_name(glow::legalizeName(N__->getName()));
1074 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1075 addTypeAttributes(opProto, N__, FmodNode::LHSIdx, /* isInput */ true);
1076 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1077 addTypeAttributes(opProto, N__, FmodNode::RHSIdx, /* isInput */ true);
1078 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1079 addTypeAttributes(opProto, N__, FmodNode::ResultIdx, /* isInput */ false);
1080 if (N__->hasPredicate()) {
1081 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1082 }
1083 break;
1084}
1085
1086case glow::Kinded::Kind::MaxNodeKind: {
1087 auto *N__ = llvm::cast<MaxNode>(node);
1088 opProto = graph.add_node();
1089 opProto->set_op_type("Glow_Max");
1090 opProto->set_name(glow::legalizeName(N__->getName()));
1091 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1092 addTypeAttributes(opProto, N__, MaxNode::LHSIdx, /* isInput */ true);
1093 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1094 addTypeAttributes(opProto, N__, MaxNode::RHSIdx, /* isInput */ true);
1095 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1096 addTypeAttributes(opProto, N__, MaxNode::ResultIdx, /* isInput */ false);
1097 if (N__->hasPredicate()) {
1098 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1099 }
1100 break;
1101}
1102
1103case glow::Kinded::Kind::MinNodeKind: {
1104 auto *N__ = llvm::cast<MinNode>(node);
1105 opProto = graph.add_node();
1106 opProto->set_op_type("Glow_Min");
1107 opProto->set_name(glow::legalizeName(N__->getName()));
1108 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1109 addTypeAttributes(opProto, N__, MinNode::LHSIdx, /* isInput */ true);
1110 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1111 addTypeAttributes(opProto, N__, MinNode::RHSIdx, /* isInput */ true);
1112 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1113 addTypeAttributes(opProto, N__, MinNode::ResultIdx, /* isInput */ false);
1114 if (N__->hasPredicate()) {
1115 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1116 }
1117 break;
1118}
1119
1120case glow::Kinded::Kind::CmpEQNodeKind: {
1121 auto *N__ = llvm::cast<CmpEQNode>(node);
1122 opProto = graph.add_node();
1123 opProto->set_op_type("Glow_CmpEQ");
1124 opProto->set_name(glow::legalizeName(N__->getName()));
1125 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1126 addTypeAttributes(opProto, N__, CmpEQNode::LHSIdx, /* isInput */ true);
1127 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1128 addTypeAttributes(opProto, N__, CmpEQNode::RHSIdx, /* isInput */ true);
1129 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1130 addTypeAttributes(opProto, N__, CmpEQNode::ResultIdx, /* isInput */ false);
1131 if (N__->hasPredicate()) {
1132 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1133 }
1134 break;
1135}
1136
1137case glow::Kinded::Kind::CmpNEQNodeKind: {
1138 auto *N__ = llvm::cast<CmpNEQNode>(node);
1139 opProto = graph.add_node();
1140 opProto->set_op_type("Glow_CmpNEQ");
1141 opProto->set_name(glow::legalizeName(N__->getName()));
1142 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1143 addTypeAttributes(opProto, N__, CmpNEQNode::LHSIdx, /* isInput */ true);
1144 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1145 addTypeAttributes(opProto, N__, CmpNEQNode::RHSIdx, /* isInput */ true);
1146 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1147 addTypeAttributes(opProto, N__, CmpNEQNode::ResultIdx, /* isInput */ false);
1148 if (N__->hasPredicate()) {
1149 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1150 }
1151 break;
1152}
1153
1154case glow::Kinded::Kind::CmpLTNodeKind: {
1155 auto *N__ = llvm::cast<CmpLTNode>(node);
1156 opProto = graph.add_node();
1157 opProto->set_op_type("Glow_CmpLT");
1158 opProto->set_name(glow::legalizeName(N__->getName()));
1159 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1160 addTypeAttributes(opProto, N__, CmpLTNode::LHSIdx, /* isInput */ true);
1161 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1162 addTypeAttributes(opProto, N__, CmpLTNode::RHSIdx, /* isInput */ true);
1163 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1164 addTypeAttributes(opProto, N__, CmpLTNode::ResultIdx, /* isInput */ false);
1165 if (N__->hasPredicate()) {
1166 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1167 }
1168 break;
1169}
1170
1171case glow::Kinded::Kind::CmpLTENodeKind: {
1172 auto *N__ = llvm::cast<CmpLTENode>(node);
1173 opProto = graph.add_node();
1174 opProto->set_op_type("Glow_CmpLTE");
1175 opProto->set_name(glow::legalizeName(N__->getName()));
1176 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1177 addTypeAttributes(opProto, N__, CmpLTENode::LHSIdx, /* isInput */ true);
1178 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1179 addTypeAttributes(opProto, N__, CmpLTENode::RHSIdx, /* isInput */ true);
1180 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1181 addTypeAttributes(opProto, N__, CmpLTENode::ResultIdx, /* isInput */ false);
1182 if (N__->hasPredicate()) {
1183 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1184 }
1185 break;
1186}
1187
1188case glow::Kinded::Kind::PowNodeKind: {
1189 auto *N__ = llvm::cast<PowNode>(node);
1190 opProto = graph.add_node();
1191 opProto->set_op_type("Glow_Pow");
1192 opProto->set_name(glow::legalizeName(N__->getName()));
1193 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1194 addTypeAttributes(opProto, N__, PowNode::LHSIdx, /* isInput */ true);
1195 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1196 addTypeAttributes(opProto, N__, PowNode::RHSIdx, /* isInput */ true);
1197 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1198 addTypeAttributes(opProto, N__, PowNode::ResultIdx, /* isInput */ false);
1199 if (N__->hasPredicate()) {
1200 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1201 }
1202 break;
1203}
1204
1205case glow::Kinded::Kind::AndNodeKind: {
1206 auto *N__ = llvm::cast<AndNode>(node);
1207 opProto = graph.add_node();
1208 opProto->set_op_type("Glow_And");
1209 opProto->set_name(glow::legalizeName(N__->getName()));
1210 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1211 addTypeAttributes(opProto, N__, AndNode::LHSIdx, /* isInput */ true);
1212 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1213 addTypeAttributes(opProto, N__, AndNode::RHSIdx, /* isInput */ true);
1214 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1215 addTypeAttributes(opProto, N__, AndNode::ResultIdx, /* isInput */ false);
1216 if (N__->hasPredicate()) {
1217 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1218 }
1219 break;
1220}
1221
1222case glow::Kinded::Kind::BitwiseAndNodeKind: {
1223 auto *N__ = llvm::cast<BitwiseAndNode>(node);
1224 opProto = graph.add_node();
1225 opProto->set_op_type("Glow_BitwiseAnd");
1226 opProto->set_name(glow::legalizeName(N__->getName()));
1227 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1228 addTypeAttributes(opProto, N__, BitwiseAndNode::LHSIdx, /* isInput */ true);
1229 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1230 addTypeAttributes(opProto, N__, BitwiseAndNode::RHSIdx, /* isInput */ true);
1231 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1232 addTypeAttributes(opProto, N__, BitwiseAndNode::ResultIdx, /* isInput */ false);
1233 if (N__->hasPredicate()) {
1234 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1235 }
1236 break;
1237}
1238
1239case glow::Kinded::Kind::OrNodeKind: {
1240 auto *N__ = llvm::cast<OrNode>(node);
1241 opProto = graph.add_node();
1242 opProto->set_op_type("Glow_Or");
1243 opProto->set_name(glow::legalizeName(N__->getName()));
1244 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1245 addTypeAttributes(opProto, N__, OrNode::LHSIdx, /* isInput */ true);
1246 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1247 addTypeAttributes(opProto, N__, OrNode::RHSIdx, /* isInput */ true);
1248 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1249 addTypeAttributes(opProto, N__, OrNode::ResultIdx, /* isInput */ false);
1250 if (N__->hasPredicate()) {
1251 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1252 }
1253 break;
1254}
1255
1256case glow::Kinded::Kind::BitwiseOrNodeKind: {
1257 auto *N__ = llvm::cast<BitwiseOrNode>(node);
1258 opProto = graph.add_node();
1259 opProto->set_op_type("Glow_BitwiseOr");
1260 opProto->set_name(glow::legalizeName(N__->getName()));
1261 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1262 addTypeAttributes(opProto, N__, BitwiseOrNode::LHSIdx, /* isInput */ true);
1263 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1264 addTypeAttributes(opProto, N__, BitwiseOrNode::RHSIdx, /* isInput */ true);
1265 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1266 addTypeAttributes(opProto, N__, BitwiseOrNode::ResultIdx, /* isInput */ false);
1267 if (N__->hasPredicate()) {
1268 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1269 }
1270 break;
1271}
1272
1273case glow::Kinded::Kind::XorNodeKind: {
1274 auto *N__ = llvm::cast<XorNode>(node);
1275 opProto = graph.add_node();
1276 opProto->set_op_type("Glow_Xor");
1277 opProto->set_name(glow::legalizeName(N__->getName()));
1278 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1279 addTypeAttributes(opProto, N__, XorNode::LHSIdx, /* isInput */ true);
1280 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1281 addTypeAttributes(opProto, N__, XorNode::RHSIdx, /* isInput */ true);
1282 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1283 addTypeAttributes(opProto, N__, XorNode::ResultIdx, /* isInput */ false);
1284 if (N__->hasPredicate()) {
1285 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1286 }
1287 break;
1288}
1289
1290case glow::Kinded::Kind::BitwiseXorNodeKind: {
1291 auto *N__ = llvm::cast<BitwiseXorNode>(node);
1292 opProto = graph.add_node();
1293 opProto->set_op_type("Glow_BitwiseXor");
1294 opProto->set_name(glow::legalizeName(N__->getName()));
1295 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1296 addTypeAttributes(opProto, N__, BitwiseXorNode::LHSIdx, /* isInput */ true);
1297 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1298 addTypeAttributes(opProto, N__, BitwiseXorNode::RHSIdx, /* isInput */ true);
1299 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1300 addTypeAttributes(opProto, N__, BitwiseXorNode::ResultIdx, /* isInput */ false);
1301 if (N__->hasPredicate()) {
1302 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1303 }
1304 break;
1305}
1306
1307case glow::Kinded::Kind::NotNodeKind: {
1308 auto *N__ = llvm::cast<NotNode>(node);
1309 opProto = graph.add_node();
1310 opProto->set_op_type("Glow_Not");
1311 opProto->set_name(glow::legalizeName(N__->getName()));
1312 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1313 addTypeAttributes(opProto, N__, NotNode::InputIdx, /* isInput */ true);
1314 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1315 addTypeAttributes(opProto, N__, NotNode::ResultIdx, /* isInput */ false);
1316 if (N__->hasPredicate()) {
1317 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1318 }
1319 break;
1320}
1321
1322case glow::Kinded::Kind::BitwiseNotNodeKind: {
1323 auto *N__ = llvm::cast<BitwiseNotNode>(node);
1324 opProto = graph.add_node();
1325 opProto->set_op_type("Glow_BitwiseNot");
1326 opProto->set_name(glow::legalizeName(N__->getName()));
1327 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1328 addTypeAttributes(opProto, N__, BitwiseNotNode::InputIdx, /* isInput */ true);
1329 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1330 addTypeAttributes(opProto, N__, BitwiseNotNode::ResultIdx, /* isInput */ false);
1331 if (N__->hasPredicate()) {
1332 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1333 }
1334 break;
1335}
1336
1337case glow::Kinded::Kind::NegNodeKind: {
1338 auto *N__ = llvm::cast<NegNode>(node);
1339 opProto = graph.add_node();
1340 opProto->set_op_type("Glow_Neg");
1341 opProto->set_name(glow::legalizeName(N__->getName()));
1342 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1343 addTypeAttributes(opProto, N__, NegNode::InputIdx, /* isInput */ true);
1344 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1345 addTypeAttributes(opProto, N__, NegNode::ResultIdx, /* isInput */ false);
1346 if (N__->hasPredicate()) {
1347 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1348 }
1349 break;
1350}
1351
1352case glow::Kinded::Kind::AbsNodeKind: {
1353 auto *N__ = llvm::cast<AbsNode>(node);
1354 opProto = graph.add_node();
1355 opProto->set_op_type("Glow_Abs");
1356 opProto->set_name(glow::legalizeName(N__->getName()));
1357 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1358 addTypeAttributes(opProto, N__, AbsNode::InputIdx, /* isInput */ true);
1359 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1360 addTypeAttributes(opProto, N__, AbsNode::ResultIdx, /* isInput */ false);
1361 if (N__->hasPredicate()) {
1362 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1363 }
1364 break;
1365}
1366
1367case glow::Kinded::Kind::FloorNodeKind: {
1368 auto *N__ = llvm::cast<FloorNode>(node);
1369 opProto = graph.add_node();
1370 opProto->set_op_type("Glow_Floor");
1371 opProto->set_name(glow::legalizeName(N__->getName()));
1372 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1373 addTypeAttributes(opProto, N__, FloorNode::InputIdx, /* isInput */ true);
1374 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1375 addTypeAttributes(opProto, N__, FloorNode::ResultIdx, /* isInput */ false);
1376 if (N__->hasPredicate()) {
1377 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1378 }
1379 break;
1380}
1381
1382case glow::Kinded::Kind::SignNodeKind: {
1383 auto *N__ = llvm::cast<SignNode>(node);
1384 opProto = graph.add_node();
1385 opProto->set_op_type("Glow_Sign");
1386 opProto->set_name(glow::legalizeName(N__->getName()));
1387 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1388 addTypeAttributes(opProto, N__, SignNode::InputIdx, /* isInput */ true);
1389 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1390 addTypeAttributes(opProto, N__, SignNode::ResultIdx, /* isInput */ false);
1391 if (N__->hasPredicate()) {
1392 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1393 }
1394 break;
1395}
1396
1397case glow::Kinded::Kind::CeilNodeKind: {
1398 auto *N__ = llvm::cast<CeilNode>(node);
1399 opProto = graph.add_node();
1400 opProto->set_op_type("Glow_Ceil");
1401 opProto->set_name(glow::legalizeName(N__->getName()));
1402 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1403 addTypeAttributes(opProto, N__, CeilNode::InputIdx, /* isInput */ true);
1404 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1405 addTypeAttributes(opProto, N__, CeilNode::ResultIdx, /* isInput */ false);
1406 if (N__->hasPredicate()) {
1407 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1408 }
1409 break;
1410}
1411
1412case glow::Kinded::Kind::RoundNodeKind: {
1413 auto *N__ = llvm::cast<RoundNode>(node);
1414 opProto = graph.add_node();
1415 opProto->set_op_type("Glow_Round");
1416 opProto->set_name(glow::legalizeName(N__->getName()));
1417 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1418 addTypeAttributes(opProto, N__, RoundNode::InputIdx, /* isInput */ true);
1419 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1420 addTypeAttributes(opProto, N__, RoundNode::ResultIdx, /* isInput */ false);
1421 if (N__->hasPredicate()) {
1422 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1423 }
1424 break;
1425}
1426
1427case glow::Kinded::Kind::TruncateNodeKind: {
1428 auto *N__ = llvm::cast<TruncateNode>(node);
1429 opProto = graph.add_node();
1430 opProto->set_op_type("Glow_Truncate");
1431 opProto->set_name(glow::legalizeName(N__->getName()));
1432 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1433 addTypeAttributes(opProto, N__, TruncateNode::InputIdx, /* isInput */ true);
1434 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1435 addTypeAttributes(opProto, N__, TruncateNode::ResultIdx, /* isInput */ false);
1436 if (N__->hasPredicate()) {
1437 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1438 }
1439 break;
1440}
1441
1442case glow::Kinded::Kind::SqrtNodeKind: {
1443 auto *N__ = llvm::cast<SqrtNode>(node);
1444 opProto = graph.add_node();
1445 opProto->set_op_type("Glow_Sqrt");
1446 opProto->set_name(glow::legalizeName(N__->getName()));
1447 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1448 addTypeAttributes(opProto, N__, SqrtNode::InputIdx, /* isInput */ true);
1449 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1450 addTypeAttributes(opProto, N__, SqrtNode::ResultIdx, /* isInput */ false);
1451 if (N__->hasPredicate()) {
1452 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1453 }
1454 break;
1455}
1456
1457case glow::Kinded::Kind::RsqrtNodeKind: {
1458 auto *N__ = llvm::cast<RsqrtNode>(node);
1459 opProto = graph.add_node();
1460 opProto->set_op_type("Glow_Rsqrt");
1461 opProto->set_name(glow::legalizeName(N__->getName()));
1462 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1463 addTypeAttributes(opProto, N__, RsqrtNode::InputIdx, /* isInput */ true);
1464 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1465 addTypeAttributes(opProto, N__, RsqrtNode::ResultIdx, /* isInput */ false);
1466 if (N__->hasPredicate()) {
1467 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1468 }
1469 break;
1470}
1471
1472case glow::Kinded::Kind::ReciprocalNodeKind: {
1473 auto *N__ = llvm::cast<ReciprocalNode>(node);
1474 opProto = graph.add_node();
1475 opProto->set_op_type("Glow_Reciprocal");
1476 opProto->set_name(glow::legalizeName(N__->getName()));
1477 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1478 addTypeAttributes(opProto, N__, ReciprocalNode::InputIdx, /* isInput */ true);
1479 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1480 addTypeAttributes(opProto, N__, ReciprocalNode::ResultIdx, /* isInput */ false);
1481 if (N__->hasPredicate()) {
1482 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1483 }
1484 break;
1485}
1486
1487case glow::Kinded::Kind::SinNodeKind: {
1488 auto *N__ = llvm::cast<SinNode>(node);
1489 opProto = graph.add_node();
1490 opProto->set_op_type("Glow_Sin");
1491 opProto->set_name(glow::legalizeName(N__->getName()));
1492 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1493 addTypeAttributes(opProto, N__, SinNode::InputIdx, /* isInput */ true);
1494 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1495 addTypeAttributes(opProto, N__, SinNode::ResultIdx, /* isInput */ false);
1496 if (N__->hasPredicate()) {
1497 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1498 }
1499 break;
1500}
1501
1502case glow::Kinded::Kind::CosNodeKind: {
1503 auto *N__ = llvm::cast<CosNode>(node);
1504 opProto = graph.add_node();
1505 opProto->set_op_type("Glow_Cos");
1506 opProto->set_name(glow::legalizeName(N__->getName()));
1507 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1508 addTypeAttributes(opProto, N__, CosNode::InputIdx, /* isInput */ true);
1509 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1510 addTypeAttributes(opProto, N__, CosNode::ResultIdx, /* isInput */ false);
1511 if (N__->hasPredicate()) {
1512 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1513 }
1514 break;
1515}
1516
1517case glow::Kinded::Kind::LogNodeKind: {
1518 auto *N__ = llvm::cast<LogNode>(node);
1519 opProto = graph.add_node();
1520 opProto->set_op_type("Glow_Log");
1521 opProto->set_name(glow::legalizeName(N__->getName()));
1522 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1523 addTypeAttributes(opProto, N__, LogNode::InputIdx, /* isInput */ true);
1524 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1525 addTypeAttributes(opProto, N__, LogNode::ResultIdx, /* isInput */ false);
1526 if (N__->hasPredicate()) {
1527 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1528 }
1529 break;
1530}
1531
1532case glow::Kinded::Kind::AcosNodeKind: {
1533 auto *N__ = llvm::cast<AcosNode>(node);
1534 opProto = graph.add_node();
1535 opProto->set_op_type("Glow_Acos");
1536 opProto->set_name(glow::legalizeName(N__->getName()));
1537 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1538 addTypeAttributes(opProto, N__, AcosNode::InputIdx, /* isInput */ true);
1539 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1540 addTypeAttributes(opProto, N__, AcosNode::ResultIdx, /* isInput */ false);
1541 if (N__->hasPredicate()) {
1542 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1543 }
1544 break;
1545}
1546
1547case glow::Kinded::Kind::AsinNodeKind: {
1548 auto *N__ = llvm::cast<AsinNode>(node);
1549 opProto = graph.add_node();
1550 opProto->set_op_type("Glow_Asin");
1551 opProto->set_name(glow::legalizeName(N__->getName()));
1552 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1553 addTypeAttributes(opProto, N__, AsinNode::InputIdx, /* isInput */ true);
1554 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1555 addTypeAttributes(opProto, N__, AsinNode::ResultIdx, /* isInput */ false);
1556 if (N__->hasPredicate()) {
1557 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1558 }
1559 break;
1560}
1561
1562case glow::Kinded::Kind::AtanNodeKind: {
1563 auto *N__ = llvm::cast<AtanNode>(node);
1564 opProto = graph.add_node();
1565 opProto->set_op_type("Glow_Atan");
1566 opProto->set_name(glow::legalizeName(N__->getName()));
1567 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1568 addTypeAttributes(opProto, N__, AtanNode::InputIdx, /* isInput */ true);
1569 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1570 addTypeAttributes(opProto, N__, AtanNode::ResultIdx, /* isInput */ false);
1571 if (N__->hasPredicate()) {
1572 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1573 }
1574 break;
1575}
1576
1577case glow::Kinded::Kind::ErfNodeKind: {
1578 auto *N__ = llvm::cast<ErfNode>(node);
1579 opProto = graph.add_node();
1580 opProto->set_op_type("Glow_Erf");
1581 opProto->set_name(glow::legalizeName(N__->getName()));
1582 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1583 addTypeAttributes(opProto, N__, ErfNode::InputIdx, /* isInput */ true);
1584 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1585 addTypeAttributes(opProto, N__, ErfNode::ResultIdx, /* isInput */ false);
1586 if (N__->hasPredicate()) {
1587 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1588 }
1589 break;
1590}
1591
1592case glow::Kinded::Kind::ExpNodeKind: {
1593 auto *N__ = llvm::cast<ExpNode>(node);
1594 opProto = graph.add_node();
1595 opProto->set_op_type("Glow_Exp");
1596 opProto->set_name(glow::legalizeName(N__->getName()));
1597 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1598 addTypeAttributes(opProto, N__, ExpNode::InputIdx, /* isInput */ true);
1599 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1600 addTypeAttributes(opProto, N__, ExpNode::ResultIdx, /* isInput */ false);
1601 if (N__->hasPredicate()) {
1602 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1603 }
1604 break;
1605}
1606
1607case glow::Kinded::Kind::LogitNodeKind: {
1608 auto *N__ = llvm::cast<LogitNode>(node);
1609 opProto = graph.add_node();
1610 opProto->set_op_type("Glow_Logit");
1611 opProto->set_name(glow::legalizeName(N__->getName()));
1612 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1613 addTypeAttributes(opProto, N__, LogitNode::InputIdx, /* isInput */ true);
1614 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1615 addTypeAttributes(opProto, N__, LogitNode::ResultIdx, /* isInput */ false);
1616 addValueAttribute(opProto, "Epsilon", N__->getEpsilon());
1617 if (N__->hasPredicate()) {
1618 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1619 }
1620 break;
1621}
1622
1623case glow::Kinded::Kind::NonZeroNodeKind: {
1624 auto *N__ = llvm::cast<NonZeroNode>(node);
1625 opProto = graph.add_node();
1626 opProto->set_op_type("Glow_NonZero");
1627 opProto->set_name(glow::legalizeName(N__->getName()));
1628 opProto->add_input(N__->getCond().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1629 addTypeAttributes(opProto, N__, NonZeroNode::CondIdx, /* isInput */ true);
1630 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1631 addTypeAttributes(opProto, N__, NonZeroNode::ResultIdx, /* isInput */ false);
1632 if (N__->hasPredicate()) {
1633 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1634 }
1635 break;
1636}
1637
1638case glow::Kinded::Kind::SelectNodeKind: {
1639 auto *N__ = llvm::cast<SelectNode>(node);
1640 opProto = graph.add_node();
1641 opProto->set_op_type("Glow_Select");
1642 opProto->set_name(glow::legalizeName(N__->getName()));
1643 opProto->add_input(N__->getCond().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1644 addTypeAttributes(opProto, N__, SelectNode::CondIdx, /* isInput */ true);
1645 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1646 addTypeAttributes(opProto, N__, SelectNode::LHSIdx, /* isInput */ true);
1647 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1648 addTypeAttributes(opProto, N__, SelectNode::RHSIdx, /* isInput */ true);
1649 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1650 addTypeAttributes(opProto, N__, SelectNode::ResultIdx, /* isInput */ false);
1651 if (N__->hasPredicate()) {
1652 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1653 }
1654 break;
1655}
1656
1657case glow::Kinded::Kind::BatchedAddNodeKind: {
1658 auto *N__ = llvm::cast<BatchedAddNode>(node);
1659 opProto = graph.add_node();
1660 opProto->set_op_type("Glow_BatchedAdd");
1661 opProto->set_name(glow::legalizeName(N__->getName()));
1662 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1663 addTypeAttributes(opProto, N__, BatchedAddNode::BatchIdx, /* isInput */ true);
1664 opProto->add_input(N__->getSlice().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1665 addTypeAttributes(opProto, N__, BatchedAddNode::SliceIdx, /* isInput */ true);
1666 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1667 addTypeAttributes(opProto, N__, BatchedAddNode::ResultIdx, /* isInput */ false);
1668 if (N__->hasPredicate()) {
1669 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1670 }
1671 break;
1672}
1673
1674case glow::Kinded::Kind::BatchedMulNodeKind: {
1675 auto *N__ = llvm::cast<BatchedMulNode>(node);
1676 opProto = graph.add_node();
1677 opProto->set_op_type("Glow_BatchedMul");
1678 opProto->set_name(glow::legalizeName(N__->getName()));
1679 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1680 addTypeAttributes(opProto, N__, BatchedMulNode::BatchIdx, /* isInput */ true);
1681 opProto->add_input(N__->getSlice().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1682 addTypeAttributes(opProto, N__, BatchedMulNode::SliceIdx, /* isInput */ true);
1683 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1684 addTypeAttributes(opProto, N__, BatchedMulNode::ResultIdx, /* isInput */ false);
1685 if (N__->hasPredicate()) {
1686 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1687 }
1688 break;
1689}
1690
1691case glow::Kinded::Kind::MatMulNodeKind: {
1692 auto *N__ = llvm::cast<MatMulNode>(node);
1693 opProto = graph.add_node();
1694 opProto->set_op_type("Glow_MatMul");
1695 opProto->set_name(glow::legalizeName(N__->getName()));
1696 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1697 addTypeAttributes(opProto, N__, MatMulNode::LHSIdx, /* isInput */ true);
1698 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1699 addTypeAttributes(opProto, N__, MatMulNode::RHSIdx, /* isInput */ true);
1700 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1701 addTypeAttributes(opProto, N__, MatMulNode::ResultIdx, /* isInput */ false);
1702 if (N__->hasPredicate()) {
1703 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1704 }
1705 break;
1706}
1707
1708case glow::Kinded::Kind::BatchMatMulNodeKind: {
1709 auto *N__ = llvm::cast<BatchMatMulNode>(node);
1710 opProto = graph.add_node();
1711 opProto->set_op_type("Glow_BatchMatMul");
1712 opProto->set_name(glow::legalizeName(N__->getName()));
1713 opProto->add_input(N__->getLHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1714 addTypeAttributes(opProto, N__, BatchMatMulNode::LHSIdx, /* isInput */ true);
1715 opProto->add_input(N__->getRHS().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1716 addTypeAttributes(opProto, N__, BatchMatMulNode::RHSIdx, /* isInput */ true);
1717 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1718 addTypeAttributes(opProto, N__, BatchMatMulNode::ResultIdx, /* isInput */ false);
1719 if (N__->hasPredicate()) {
1720 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1721 }
1722 break;
1723}
1724
1725case glow::Kinded::Kind::BatchedReduceAddNodeKind: {
1726 auto *N__ = llvm::cast<BatchedReduceAddNode>(node);
1727 opProto = graph.add_node();
1728 opProto->set_op_type("Glow_BatchedReduceAdd");
1729 opProto->set_name(glow::legalizeName(N__->getName()));
1730 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1731 addTypeAttributes(opProto, N__, BatchedReduceAddNode::BatchIdx, /* isInput */ true);
1732 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1733 addTypeAttributes(opProto, N__, BatchedReduceAddNode::ResultIdx, /* isInput */ false);
1734 addValueAttribute(opProto, "Axis", N__->getAxis());
1735 if (N__->hasPredicate()) {
1736 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1737 }
1738 break;
1739}
1740
1741case glow::Kinded::Kind::BatchedReduceSumSquareNodeKind: {
1742 auto *N__ = llvm::cast<BatchedReduceSumSquareNode>(node);
1743 opProto = graph.add_node();
1744 opProto->set_op_type("Glow_BatchedReduceSumSquare");
1745 opProto->set_name(glow::legalizeName(N__->getName()));
1746 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1747 addTypeAttributes(opProto, N__, BatchedReduceSumSquareNode::BatchIdx, /* isInput */ true);
1748 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1749 addTypeAttributes(opProto, N__, BatchedReduceSumSquareNode::ResultIdx, /* isInput */ false);
1750 addValueAttribute(opProto, "Axis", N__->getAxis());
1751 if (N__->hasPredicate()) {
1752 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1753 }
1754 break;
1755}
1756
1757case glow::Kinded::Kind::BatchedReduceMeanNodeKind: {
1758 auto *N__ = llvm::cast<BatchedReduceMeanNode>(node);
1759 opProto = graph.add_node();
1760 opProto->set_op_type("Glow_BatchedReduceMean");
1761 opProto->set_name(glow::legalizeName(N__->getName()));
1762 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1763 addTypeAttributes(opProto, N__, BatchedReduceMeanNode::BatchIdx, /* isInput */ true);
1764 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1765 addTypeAttributes(opProto, N__, BatchedReduceMeanNode::ResultIdx, /* isInput */ false);
1766 addValueAttribute(opProto, "Axes", N__->getAxes());
1767 if (N__->hasPredicate()) {
1768 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1769 }
1770 break;
1771}
1772
1773case glow::Kinded::Kind::BatchedReduceMinNodeKind: {
1774 auto *N__ = llvm::cast<BatchedReduceMinNode>(node);
1775 opProto = graph.add_node();
1776 opProto->set_op_type("Glow_BatchedReduceMin");
1777 opProto->set_name(glow::legalizeName(N__->getName()));
1778 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1779 addTypeAttributes(opProto, N__, BatchedReduceMinNode::BatchIdx, /* isInput */ true);
1780 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1781 addTypeAttributes(opProto, N__, BatchedReduceMinNode::ResultIdx, /* isInput */ false);
1782 addValueAttribute(opProto, "Axes", N__->getAxes());
1783 if (N__->hasPredicate()) {
1784 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1785 }
1786 break;
1787}
1788
1789case glow::Kinded::Kind::BatchedReduceMaxNodeKind: {
1790 auto *N__ = llvm::cast<BatchedReduceMaxNode>(node);
1791 opProto = graph.add_node();
1792 opProto->set_op_type("Glow_BatchedReduceMax");
1793 opProto->set_name(glow::legalizeName(N__->getName()));
1794 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1795 addTypeAttributes(opProto, N__, BatchedReduceMaxNode::BatchIdx, /* isInput */ true);
1796 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1797 addTypeAttributes(opProto, N__, BatchedReduceMaxNode::ResultIdx, /* isInput */ false);
1798 addValueAttribute(opProto, "Axes", N__->getAxes());
1799 if (N__->hasPredicate()) {
1800 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1801 }
1802 break;
1803}
1804
1805case glow::Kinded::Kind::BatchedReduceProdNodeKind: {
1806 auto *N__ = llvm::cast<BatchedReduceProdNode>(node);
1807 opProto = graph.add_node();
1808 opProto->set_op_type("Glow_BatchedReduceProd");
1809 opProto->set_name(glow::legalizeName(N__->getName()));
1810 opProto->add_input(N__->getBatch().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1811 addTypeAttributes(opProto, N__, BatchedReduceProdNode::BatchIdx, /* isInput */ true);
1812 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1813 addTypeAttributes(opProto, N__, BatchedReduceProdNode::ResultIdx, /* isInput */ false);
1814 addValueAttribute(opProto, "Axis", N__->getAxis());
1815 if (N__->hasPredicate()) {
1816 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1817 }
1818 break;
1819}
1820
1821case glow::Kinded::Kind::ChannelShuffleNodeKind: {
1822 auto *N__ = llvm::cast<ChannelShuffleNode>(node);
1823 opProto = graph.add_node();
1824 opProto->set_op_type("Glow_ChannelShuffle");
1825 opProto->set_name(glow::legalizeName(N__->getName()));
1826 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1827 addTypeAttributes(opProto, N__, ChannelShuffleNode::InputIdx, /* isInput */ true);
1828 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1829 addTypeAttributes(opProto, N__, ChannelShuffleNode::ResultIdx, /* isInput */ false);
1830 addValueAttribute(opProto, "Group", N__->getGroup());
1831 addValueAttribute(opProto, "Kernel", N__->getKernel());
1832 if (N__->hasPredicate()) {
1833 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1834 }
1835 break;
1836}
1837
1838case glow::Kinded::Kind::CumSumNodeKind: {
1839 auto *N__ = llvm::cast<CumSumNode>(node);
1840 opProto = graph.add_node();
1841 opProto->set_op_type("Glow_CumSum");
1842 opProto->set_name(glow::legalizeName(N__->getName()));
1843 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1844 addTypeAttributes(opProto, N__, CumSumNode::InputIdx, /* isInput */ true);
1845 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1846 addTypeAttributes(opProto, N__, CumSumNode::ResultIdx, /* isInput */ false);
1847 addValueAttribute(opProto, "Dim", N__->getDim());
1848 addValueAttribute(opProto, "Exclusive", N__->getExclusive());
1849 addValueAttribute(opProto, "Reverse", N__->getReverse());
1850 if (N__->hasPredicate()) {
1851 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1852 }
1853 break;
1854}
1855
1856case glow::Kinded::Kind::LengthsSumNodeKind: {
1857 auto *N__ = llvm::cast<LengthsSumNode>(node);
1858 opProto = graph.add_node();
1859 opProto->set_op_type("Glow_LengthsSum");
1860 opProto->set_name(glow::legalizeName(N__->getName()));
1861 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1862 addTypeAttributes(opProto, N__, LengthsSumNode::DataIdx, /* isInput */ true);
1863 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1864 addTypeAttributes(opProto, N__, LengthsSumNode::LengthsIdx, /* isInput */ true);
1865 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1866 addTypeAttributes(opProto, N__, LengthsSumNode::ResultIdx, /* isInput */ false);
1867 if (N__->hasPredicate()) {
1868 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1869 }
1870 break;
1871}
1872
1873case glow::Kinded::Kind::SparseLengthsSumGradNodeKind: {
1874 auto *N__ = llvm::cast<SparseLengthsSumGradNode>(node);
1875 opProto = graph.add_node();
1876 opProto->set_op_type("Glow_SparseLengthsSumGrad");
1877 opProto->set_name(glow::legalizeName(N__->getName()));
1878 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1879 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::DataIdx, /* isInput */ true);
1880 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1881 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::IndicesIdx, /* isInput */ true);
1882 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1883 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::LengthsIdx, /* isInput */ true);
1884 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1885 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::OriginalOutputForResultIdx, /* isInput */ true);
1886 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1887 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
1888 opProto->add_output(N__->getGradOfInputNamedData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1889 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfInputNamedDataIdx, /* isInput */ false);
1890 opProto->add_output(N__->getGradOfInputNamedIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1891 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfInputNamedIndicesIdx, /* isInput */ false);
1892 opProto->add_output(N__->getGradOfInputNamedLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1893 addTypeAttributes(opProto, N__, SparseLengthsSumGradNode::GradOfInputNamedLengthsIdx, /* isInput */ false);
1894 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
1895 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
1896 if (N__->hasPredicate()) {
1897 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1898 }
1899 break;
1900}
1901
1902case glow::Kinded::Kind::SparseLengthsSumNodeKind: {
1903 auto *N__ = llvm::cast<SparseLengthsSumNode>(node);
1904 opProto = graph.add_node();
1905 opProto->set_op_type("Glow_SparseLengthsSum");
1906 opProto->set_name(glow::legalizeName(N__->getName()));
1907 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1908 addTypeAttributes(opProto, N__, SparseLengthsSumNode::DataIdx, /* isInput */ true);
1909 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1910 addTypeAttributes(opProto, N__, SparseLengthsSumNode::IndicesIdx, /* isInput */ true);
1911 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1912 addTypeAttributes(opProto, N__, SparseLengthsSumNode::LengthsIdx, /* isInput */ true);
1913 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1914 addTypeAttributes(opProto, N__, SparseLengthsSumNode::ResultIdx, /* isInput */ false);
1915 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
1916 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
1917 if (N__->hasPredicate()) {
1918 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1919 }
1920 break;
1921}
1922
1923case glow::Kinded::Kind::SparseLengthsWeightedSumGradNodeKind: {
1924 auto *N__ = llvm::cast<SparseLengthsWeightedSumGradNode>(node);
1925 opProto = graph.add_node();
1926 opProto->set_op_type("Glow_SparseLengthsWeightedSumGrad");
1927 opProto->set_name(glow::legalizeName(N__->getName()));
1928 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1929 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::DataIdx, /* isInput */ true);
1930 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1931 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::WeightsIdx, /* isInput */ true);
1932 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1933 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::IndicesIdx, /* isInput */ true);
1934 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1935 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::LengthsIdx, /* isInput */ true);
1936 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1937 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::OriginalOutputForResultIdx, /* isInput */ true);
1938 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1939 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
1940 opProto->add_output(N__->getGradOfInputNamedData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1941 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedDataIdx, /* isInput */ false);
1942 opProto->add_output(N__->getGradOfInputNamedWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1943 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedWeightsIdx, /* isInput */ false);
1944 opProto->add_output(N__->getGradOfInputNamedIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1945 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedIndicesIdx, /* isInput */ false);
1946 opProto->add_output(N__->getGradOfInputNamedLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1947 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumGradNode::GradOfInputNamedLengthsIdx, /* isInput */ false);
1948 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
1949 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
1950 if (N__->hasPredicate()) {
1951 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1952 }
1953 break;
1954}
1955
1956case glow::Kinded::Kind::SparseLengthsWeightedSumNodeKind: {
1957 auto *N__ = llvm::cast<SparseLengthsWeightedSumNode>(node);
1958 opProto = graph.add_node();
1959 opProto->set_op_type("Glow_SparseLengthsWeightedSum");
1960 opProto->set_name(glow::legalizeName(N__->getName()));
1961 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1962 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::DataIdx, /* isInput */ true);
1963 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1964 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::WeightsIdx, /* isInput */ true);
1965 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1966 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::IndicesIdx, /* isInput */ true);
1967 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1968 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::LengthsIdx, /* isInput */ true);
1969 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1970 addTypeAttributes(opProto, N__, SparseLengthsWeightedSumNode::ResultIdx, /* isInput */ false);
1971 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
1972 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
1973 if (N__->hasPredicate()) {
1974 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1975 }
1976 break;
1977}
1978
1979case glow::Kinded::Kind::EmbeddingNodeKind: {
1980 auto *N__ = llvm::cast<EmbeddingNode>(node);
1981 opProto = graph.add_node();
1982 opProto->set_op_type("Glow_Embedding");
1983 opProto->set_name(glow::legalizeName(N__->getName()));
1984 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1985 addTypeAttributes(opProto, N__, EmbeddingNode::WeightsIdx, /* isInput */ true);
1986 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1987 addTypeAttributes(opProto, N__, EmbeddingNode::IndicesIdx, /* isInput */ true);
1988 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1989 addTypeAttributes(opProto, N__, EmbeddingNode::ResultIdx, /* isInput */ false);
1990 addValueAttribute(opProto, "PadIdx", N__->getPadIdx());
1991 addValueAttribute(opProto, "Scale", N__->getScale());
1992 addValueAttribute(opProto, "Sparse", N__->getSparse());
1993 if (N__->hasPredicate()) {
1994 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
1995 }
1996 break;
1997}
1998
1999case glow::Kinded::Kind::EmbeddingBagNodeKind: {
2000 auto *N__ = llvm::cast<EmbeddingBagNode>(node);
2001 opProto = graph.add_node();
2002 opProto->set_op_type("Glow_EmbeddingBag");
2003 opProto->set_name(glow::legalizeName(N__->getName()));
2004 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2005 addTypeAttributes(opProto, N__, EmbeddingBagNode::DataIdx, /* isInput */ true);
2006 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2007 addTypeAttributes(opProto, N__, EmbeddingBagNode::WeightsIdx, /* isInput */ true);
2008 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2009 addTypeAttributes(opProto, N__, EmbeddingBagNode::IndicesIdx, /* isInput */ true);
2010 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2011 addTypeAttributes(opProto, N__, EmbeddingBagNode::OffsetsIdx, /* isInput */ true);
2012 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2013 addTypeAttributes(opProto, N__, EmbeddingBagNode::ResultIdx, /* isInput */ false);
2014 addValueAttribute(opProto, "HasEndOffset", N__->getHasEndOffset());
2015 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
2016 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
2017 if (N__->hasPredicate()) {
2018 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2019 }
2020 break;
2021}
2022
2023case glow::Kinded::Kind::EmbeddingBagByteRowwiseOffsetsNodeKind: {
2024 auto *N__ = llvm::cast<EmbeddingBagByteRowwiseOffsetsNode>(node);
2025 opProto = graph.add_node();
2026 opProto->set_op_type("Glow_EmbeddingBagByteRowwiseOffsets");
2027 opProto->set_name(glow::legalizeName(N__->getName()));
2028 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2029 addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::DataIdx, /* isInput */ true);
2030 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2031 addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::WeightsIdx, /* isInput */ true);
2032 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2033 addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::IndicesIdx, /* isInput */ true);
2034 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2035 addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::OffsetsIdx, /* isInput */ true);
2036 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2037 addTypeAttributes(opProto, N__, EmbeddingBagByteRowwiseOffsetsNode::ResultIdx, /* isInput */ false);
2038 addValueAttribute(opProto, "UseFP16Accumulation", N__->getUseFP16Accumulation());
2039 addValueAttribute(opProto, "HasEndOffset", N__->getHasEndOffset());
2040 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
2041 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
2042 if (N__->hasPredicate()) {
2043 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2044 }
2045 break;
2046}
2047
2048case glow::Kinded::Kind::RowwiseQuantizedSparseLengthsWeightedSumNodeKind: {
2049 auto *N__ = llvm::cast<RowwiseQuantizedSparseLengthsWeightedSumNode>(node);
2050 opProto = graph.add_node();
2051 opProto->set_op_type("Glow_RowwiseQuantizedSparseLengthsWeightedSum");
2052 opProto->set_name(glow::legalizeName(N__->getName()));
2053 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2054 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::DataIdx, /* isInput */ true);
2055 opProto->add_input(N__->getScales().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2056 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::ScalesIdx, /* isInput */ true);
2057 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2058 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::OffsetsIdx, /* isInput */ true);
2059 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2060 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::WeightsIdx, /* isInput */ true);
2061 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2062 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::IndicesIdx, /* isInput */ true);
2063 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2064 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::LengthsIdx, /* isInput */ true);
2065 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2066 addTypeAttributes(opProto, N__, RowwiseQuantizedSparseLengthsWeightedSumNode::ResultIdx, /* isInput */ false);
2067 addValueAttribute(opProto, "UseFP16Accumulation", N__->getUseFP16Accumulation());
2068 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
2069 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
2070 if (N__->hasPredicate()) {
2071 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2072 }
2073 break;
2074}
2075
2076case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsWeightedSumNodeKind: {
2077 auto *N__ = llvm::cast<FusedRowwiseQuantizedSparseLengthsWeightedSumNode>(node);
2078 opProto = graph.add_node();
2079 opProto->set_op_type("Glow_FusedRowwiseQuantizedSparseLengthsWeightedSum");
2080 opProto->set_name(glow::legalizeName(N__->getName()));
2081 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2082 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::DataIdx, /* isInput */ true);
2083 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2084 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::WeightsIdx, /* isInput */ true);
2085 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2086 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::IndicesIdx, /* isInput */ true);
2087 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2088 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::LengthsIdx, /* isInput */ true);
2089 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2090 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsWeightedSumNode::ResultIdx, /* isInput */ false);
2091 addValueAttribute(opProto, "UseFP16Accumulation", N__->getUseFP16Accumulation());
2092 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
2093 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
2094 if (N__->hasPredicate()) {
2095 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2096 }
2097 break;
2098}
2099
2100case glow::Kinded::Kind::FusedRowwiseQuantizedSparseLengthsSumNodeKind: {
2101 auto *N__ = llvm::cast<FusedRowwiseQuantizedSparseLengthsSumNode>(node);
2102 opProto = graph.add_node();
2103 opProto->set_op_type("Glow_FusedRowwiseQuantizedSparseLengthsSum");
2104 opProto->set_name(glow::legalizeName(N__->getName()));
2105 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2106 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::DataIdx, /* isInput */ true);
2107 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2108 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::IndicesIdx, /* isInput */ true);
2109 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2110 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::LengthsIdx, /* isInput */ true);
2111 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2112 addTypeAttributes(opProto, N__, FusedRowwiseQuantizedSparseLengthsSumNode::ResultIdx, /* isInput */ false);
2113 addValueAttribute(opProto, "UseFP16Accumulation", N__->getUseFP16Accumulation());
2114 addValueAttribute(opProto, "LengthsMode", N__->getLengthsMode());
2115 addValueAttribute(opProto, "AvgLength", N__->getAvgLength());
2116 if (N__->hasPredicate()) {
2117 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2118 }
2119 break;
2120}
2121
2122case glow::Kinded::Kind::LengthsToRangesNodeKind: {
2123 auto *N__ = llvm::cast<LengthsToRangesNode>(node);
2124 opProto = graph.add_node();
2125 opProto->set_op_type("Glow_LengthsToRanges");
2126 opProto->set_name(glow::legalizeName(N__->getName()));
2127 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2128 addTypeAttributes(opProto, N__, LengthsToRangesNode::LengthsIdx, /* isInput */ true);
2129 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2130 addTypeAttributes(opProto, N__, LengthsToRangesNode::ResultIdx, /* isInput */ false);
2131 if (N__->hasPredicate()) {
2132 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2133 }
2134 break;
2135}
2136
2137case glow::Kinded::Kind::LengthsRangeFillNodeKind: {
2138 auto *N__ = llvm::cast<LengthsRangeFillNode>(node);
2139 opProto = graph.add_node();
2140 opProto->set_op_type("Glow_LengthsRangeFill");
2141 opProto->set_name(glow::legalizeName(N__->getName()));
2142 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2143 addTypeAttributes(opProto, N__, LengthsRangeFillNode::LengthsIdx, /* isInput */ true);
2144 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2145 addTypeAttributes(opProto, N__, LengthsRangeFillNode::ResultIdx, /* isInput */ false);
2146 if (N__->hasPredicate()) {
2147 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2148 }
2149 break;
2150}
2151
2152case glow::Kinded::Kind::BatchSparseToDenseNodeKind: {
2153 auto *N__ = llvm::cast<BatchSparseToDenseNode>(node);
2154 opProto = graph.add_node();
2155 opProto->set_op_type("Glow_BatchSparseToDense");
2156 opProto->set_name(glow::legalizeName(N__->getName()));
2157 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2158 addTypeAttributes(opProto, N__, BatchSparseToDenseNode::LengthsIdx, /* isInput */ true);
2159 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2160 addTypeAttributes(opProto, N__, BatchSparseToDenseNode::IndicesIdx, /* isInput */ true);
2161 opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2162 addTypeAttributes(opProto, N__, BatchSparseToDenseNode::ValuesIdx, /* isInput */ true);
2163 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2164 addTypeAttributes(opProto, N__, BatchSparseToDenseNode::ResultIdx, /* isInput */ false);
2165 addValueAttribute(opProto, "DefaultValue", N__->getDefaultValue());
2166 addValueAttribute(opProto, "DenseLastDim", N__->getDenseLastDim());
2167 if (N__->hasPredicate()) {
2168 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2169 }
2170 break;
2171}
2172
2173case glow::Kinded::Kind::FillExamplesWithIndicatorNodeKind: {
2174 auto *N__ = llvm::cast<FillExamplesWithIndicatorNode>(node);
2175 opProto = graph.add_node();
2176 opProto->set_op_type("Glow_FillExamplesWithIndicator");
2177 opProto->set_name(glow::legalizeName(N__->getName()));
2178 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2179 addTypeAttributes(opProto, N__, FillExamplesWithIndicatorNode::DataIdx, /* isInput */ true);
2180 opProto->add_input(N__->getIndicator().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2181 addTypeAttributes(opProto, N__, FillExamplesWithIndicatorNode::IndicatorIdx, /* isInput */ true);
2182 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2183 addTypeAttributes(opProto, N__, FillExamplesWithIndicatorNode::ResultIdx, /* isInput */ false);
2184 if (N__->hasPredicate()) {
2185 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2186 }
2187 break;
2188}
2189
2190case glow::Kinded::Kind::SparseToDenseMaskNodeKind: {
2191 auto *N__ = llvm::cast<SparseToDenseMaskNode>(node);
2192 opProto = graph.add_node();
2193 opProto->set_op_type("Glow_SparseToDenseMask");
2194 opProto->set_name(glow::legalizeName(N__->getName()));
2195 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2196 addTypeAttributes(opProto, N__, SparseToDenseMaskNode::IndicesIdx, /* isInput */ true);
2197 opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2198 addTypeAttributes(opProto, N__, SparseToDenseMaskNode::ValuesIdx, /* isInput */ true);
2199 opProto->add_input(N__->getDefaultValue().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2200 addTypeAttributes(opProto, N__, SparseToDenseMaskNode::DefaultValueIdx, /* isInput */ true);
2201 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2202 addTypeAttributes(opProto, N__, SparseToDenseMaskNode::LengthsIdx, /* isInput */ true);
2203 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2204 addTypeAttributes(opProto, N__, SparseToDenseMaskNode::ResultIdx, /* isInput */ false);
2205 addValueAttribute(opProto, "Mask", N__->getMask());
2206 if (N__->hasPredicate()) {
2207 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2208 }
2209 break;
2210}
2211
2212case glow::Kinded::Kind::IsNaNNodeKind: {
2213 auto *N__ = llvm::cast<IsNaNNode>(node);
2214 opProto = graph.add_node();
2215 opProto->set_op_type("Glow_IsNaN");
2216 opProto->set_name(glow::legalizeName(N__->getName()));
2217 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2218 addTypeAttributes(opProto, N__, IsNaNNode::InputIdx, /* isInput */ true);
2219 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2220 addTypeAttributes(opProto, N__, IsNaNNode::ResultIdx, /* isInput */ false);
2221 if (N__->hasPredicate()) {
2222 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2223 }
2224 break;
2225}
2226
2227case glow::Kinded::Kind::ReplaceNaNNodeKind: {
2228 auto *N__ = llvm::cast<ReplaceNaNNode>(node);
2229 opProto = graph.add_node();
2230 opProto->set_op_type("Glow_ReplaceNaN");
2231 opProto->set_name(glow::legalizeName(N__->getName()));
2232 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2233 addTypeAttributes(opProto, N__, ReplaceNaNNode::InputIdx, /* isInput */ true);
2234 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2235 addTypeAttributes(opProto, N__, ReplaceNaNNode::ResultIdx, /* isInput */ false);
2236 addValueAttribute(opProto, "Value", N__->getValue());
2237 if (N__->hasPredicate()) {
2238 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2239 }
2240 break;
2241}
2242
2243case glow::Kinded::Kind::ModuloNodeKind: {
2244 auto *N__ = llvm::cast<ModuloNode>(node);
2245 opProto = graph.add_node();
2246 opProto->set_op_type("Glow_Modulo");
2247 opProto->set_name(glow::legalizeName(N__->getName()));
2248 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2249 addTypeAttributes(opProto, N__, ModuloNode::InputIdx, /* isInput */ true);
2250 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2251 addTypeAttributes(opProto, N__, ModuloNode::ResultIdx, /* isInput */ false);
2252 addValueAttribute(opProto, "Divisor", N__->getDivisor());
2253 addValueAttribute(opProto, "SignFollowDivisor", N__->getSignFollowDivisor());
2254 if (N__->hasPredicate()) {
2255 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2256 }
2257 break;
2258}
2259
2260case glow::Kinded::Kind::BatchedPairwiseDotProductNodeKind: {
2261 auto *N__ = llvm::cast<BatchedPairwiseDotProductNode>(node);
2262 opProto = graph.add_node();
2263 opProto->set_op_type("Glow_BatchedPairwiseDotProduct");
2264 opProto->set_name(glow::legalizeName(N__->getName()));
2265 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2266 addTypeAttributes(opProto, N__, BatchedPairwiseDotProductNode::ResultIdx, /* isInput */ false);
2267 addValueAttribute(opProto, "Inputs", N__->getInputs());
2268 for (unsigned i = 0, e = N__->getInputs().size(); i < e; i++) {
2269 addTypeAttributes(opProto, N__->getInputs()[i], i, /* isInput */ true, "Inputs_");
2270 }
2271 if (N__->hasPredicate()) {
2272 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2273 }
2274 break;
2275}
2276
2277case glow::Kinded::Kind::BatchedPairwiseDotProductGradNodeKind: {
2278 auto *N__ = llvm::cast<BatchedPairwiseDotProductGradNode>(node);
2279 opProto = graph.add_node();
2280 opProto->set_op_type("Glow_BatchedPairwiseDotProductGrad");
2281 opProto->set_name(glow::legalizeName(N__->getName()));
2282 opProto->add_input(N__->getOutputGrad().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2283 addTypeAttributes(opProto, N__, BatchedPairwiseDotProductGradNode::OutputGradIdx, /* isInput */ true);
2284 addValueAttribute(opProto, "OriginalInputs", N__->getOriginalInputs());
2285 for (unsigned i = 0, e = N__->getOriginalInputs().size(); i < e; i++) {
2286 addTypeAttributes(opProto, N__->getOriginalInputs()[i], i, /* isInput */ true, "OriginalInputs_");
2287 }
2288 if (N__->hasPredicate()) {
2289 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2290 }
2291 break;
2292}
2293
2294case glow::Kinded::Kind::BatchedUnaryEmbeddingsBagsNodeKind: {
2295 auto *N__ = llvm::cast<BatchedUnaryEmbeddingsBagsNode>(node);
2296 opProto = graph.add_node();
2297 opProto->set_op_type("Glow_BatchedUnaryEmbeddingsBags");
2298 opProto->set_name(glow::legalizeName(N__->getName()));
2299 opProto->add_input(N__->getWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2300 addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::WeightsIdx, /* isInput */ true);
2301 opProto->add_input(N__->getTableOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2302 addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::TableOffsetsIdx, /* isInput */ true);
2303 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2304 addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::OffsetsIdx, /* isInput */ true);
2305 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2306 addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::IndicesIdx, /* isInput */ true);
2307 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2308 addTypeAttributes(opProto, N__, BatchedUnaryEmbeddingsBagsNode::ResultIdx, /* isInput */ false);
2309 if (N__->hasPredicate()) {
2310 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2311 }
2312 break;
2313}
2314
2315case glow::Kinded::Kind::IntNBitSplitEmbeddingBagsNodeKind: {
2316 auto *N__ = llvm::cast<IntNBitSplitEmbeddingBagsNode>(node);
2317 opProto = graph.add_node();
2318 opProto->set_op_type("Glow_IntNBitSplitEmbeddingBags");
2319 opProto->set_name(glow::legalizeName(N__->getName()));
2320 opProto->add_input(N__->getDevWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2321 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::DevWeightsIdx, /* isInput */ true);
2322 opProto->add_input(N__->getUvmWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2323 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::UvmWeightsIdx, /* isInput */ true);
2324 opProto->add_input(N__->getWeightsPlacements().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2325 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::WeightsPlacementsIdx, /* isInput */ true);
2326 opProto->add_input(N__->getWeightsOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2327 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::WeightsOffsetsIdx, /* isInput */ true);
2328 opProto->add_input(N__->getWeightsTys().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2329 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::WeightsTysIdx, /* isInput */ true);
2330 opProto->add_input(N__->getDimOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2331 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::DimOffsetsIdx, /* isInput */ true);
2332 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2333 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::IndicesIdx, /* isInput */ true);
2334 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2335 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::OffsetsIdx, /* isInput */ true);
2336 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2337 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingBagsNode::ResultIdx, /* isInput */ false);
2338 addValueAttribute(opProto, "TotalDims", N__->getTotalDims());
2339 addValueAttribute(opProto, "PoolingMode", N__->getPoolingMode());
2340 addValueAttribute(opProto, "OutputDType", N__->getOutputDType());
2341 if (N__->hasPredicate()) {
2342 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2343 }
2344 break;
2345}
2346
2347case glow::Kinded::Kind::IntNBitSplitEmbeddingWeightedBagsNodeKind: {
2348 auto *N__ = llvm::cast<IntNBitSplitEmbeddingWeightedBagsNode>(node);
2349 opProto = graph.add_node();
2350 opProto->set_op_type("Glow_IntNBitSplitEmbeddingWeightedBags");
2351 opProto->set_name(glow::legalizeName(N__->getName()));
2352 opProto->add_input(N__->getDevWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2353 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::DevWeightsIdx, /* isInput */ true);
2354 opProto->add_input(N__->getUvmWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2355 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::UvmWeightsIdx, /* isInput */ true);
2356 opProto->add_input(N__->getWeightsPlacements().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2357 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::WeightsPlacementsIdx, /* isInput */ true);
2358 opProto->add_input(N__->getWeightsOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2359 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::WeightsOffsetsIdx, /* isInput */ true);
2360 opProto->add_input(N__->getWeightsTys().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2361 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::WeightsTysIdx, /* isInput */ true);
2362 opProto->add_input(N__->getDimOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2363 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::DimOffsetsIdx, /* isInput */ true);
2364 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2365 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::IndicesIdx, /* isInput */ true);
2366 opProto->add_input(N__->getOffsets().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2367 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::OffsetsIdx, /* isInput */ true);
2368 opProto->add_input(N__->getIndiceWeight().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2369 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::IndiceWeightIdx, /* isInput */ true);
2370 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2371 addTypeAttributes(opProto, N__, IntNBitSplitEmbeddingWeightedBagsNode::ResultIdx, /* isInput */ false);
2372 addValueAttribute(opProto, "TotalDims", N__->getTotalDims());
2373 addValueAttribute(opProto, "PoolingMode", N__->getPoolingMode());
2374 addValueAttribute(opProto, "OutputDType", N__->getOutputDType());
2375 if (N__->hasPredicate()) {
2376 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2377 }
2378 break;
2379}
2380
2381case glow::Kinded::Kind::GaussianFillNodeKind: {
2382 auto *N__ = llvm::cast<GaussianFillNode>(node);
2383 opProto = graph.add_node();
2384 opProto->set_op_type("Glow_GaussianFill");
2385 opProto->set_name(glow::legalizeName(N__->getName()));
2386 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2387 addTypeAttributes(opProto, N__, GaussianFillNode::InputIdx, /* isInput */ true);
2388 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2389 addTypeAttributes(opProto, N__, GaussianFillNode::ResultIdx, /* isInput */ false);
2390 addValueAttribute(opProto, "Mean", N__->getMean());
2391 addValueAttribute(opProto, "Scale", N__->getScale());
2392 addValueAttribute(opProto, "Seed", N__->getSeed());
2393 if (N__->hasPredicate()) {
2394 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2395 }
2396 break;
2397}
2398
2399case glow::Kinded::Kind::ReluGradNodeKind: {
2400 auto *N__ = llvm::cast<ReluGradNode>(node);
2401 opProto = graph.add_node();
2402 opProto->set_op_type("Glow_ReluGrad");
2403 opProto->set_name(glow::legalizeName(N__->getName()));
2404 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2405 addTypeAttributes(opProto, N__, ReluGradNode::InputIdx, /* isInput */ true);
2406 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2407 addTypeAttributes(opProto, N__, ReluGradNode::OriginalOutputForResultIdx, /* isInput */ true);
2408 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2409 addTypeAttributes(opProto, N__, ReluGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
2410 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2411 addTypeAttributes(opProto, N__, ReluGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
2412 if (N__->hasPredicate()) {
2413 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2414 }
2415 break;
2416}
2417
2418case glow::Kinded::Kind::ReluNodeKind: {
2419 auto *N__ = llvm::cast<ReluNode>(node);
2420 opProto = graph.add_node();
2421 opProto->set_op_type("Glow_Relu");
2422 opProto->set_name(glow::legalizeName(N__->getName()));
2423 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2424 addTypeAttributes(opProto, N__, ReluNode::InputIdx, /* isInput */ true);
2425 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2426 addTypeAttributes(opProto, N__, ReluNode::ResultIdx, /* isInput */ false);
2427 if (N__->hasPredicate()) {
2428 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2429 }
2430 break;
2431}
2432
2433case glow::Kinded::Kind::HardSwishNodeKind: {
2434 auto *N__ = llvm::cast<HardSwishNode>(node);
2435 opProto = graph.add_node();
2436 opProto->set_op_type("Glow_HardSwish");
2437 opProto->set_name(glow::legalizeName(N__->getName()));
2438 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2439 addTypeAttributes(opProto, N__, HardSwishNode::InputIdx, /* isInput */ true);
2440 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2441 addTypeAttributes(opProto, N__, HardSwishNode::ResultIdx, /* isInput */ false);
2442 if (N__->hasPredicate()) {
2443 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2444 }
2445 break;
2446}
2447
2448case glow::Kinded::Kind::GeluNodeKind: {
2449 auto *N__ = llvm::cast<GeluNode>(node);
2450 opProto = graph.add_node();
2451 opProto->set_op_type("Glow_Gelu");
2452 opProto->set_name(glow::legalizeName(N__->getName()));
2453 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2454 addTypeAttributes(opProto, N__, GeluNode::InputIdx, /* isInput */ true);
2455 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2456 addTypeAttributes(opProto, N__, GeluNode::ResultIdx, /* isInput */ false);
2457 if (N__->hasPredicate()) {
2458 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2459 }
2460 break;
2461}
2462
2463case glow::Kinded::Kind::ClipNodeKind: {
2464 auto *N__ = llvm::cast<ClipNode>(node);
2465 opProto = graph.add_node();
2466 opProto->set_op_type("Glow_Clip");
2467 opProto->set_name(glow::legalizeName(N__->getName()));
2468 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2469 addTypeAttributes(opProto, N__, ClipNode::InputIdx, /* isInput */ true);
2470 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2471 addTypeAttributes(opProto, N__, ClipNode::ResultIdx, /* isInput */ false);
2472 addValueAttribute(opProto, "Min", N__->getMin());
2473 addValueAttribute(opProto, "Max", N__->getMax());
2474 if (N__->hasPredicate()) {
2475 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2476 }
2477 break;
2478}
2479
2480case glow::Kinded::Kind::PReluNodeKind: {
2481 auto *N__ = llvm::cast<PReluNode>(node);
2482 opProto = graph.add_node();
2483 opProto->set_op_type("Glow_PRelu");
2484 opProto->set_name(glow::legalizeName(N__->getName()));
2485 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2486 addTypeAttributes(opProto, N__, PReluNode::InputIdx, /* isInput */ true);
2487 opProto->add_input(N__->getSlope().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2488 addTypeAttributes(opProto, N__, PReluNode::SlopeIdx, /* isInput */ true);
2489 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2490 addTypeAttributes(opProto, N__, PReluNode::ResultIdx, /* isInput */ false);
2491 if (N__->hasPredicate()) {
2492 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2493 }
2494 break;
2495}
2496
2497case glow::Kinded::Kind::SigmoidGradNodeKind: {
2498 auto *N__ = llvm::cast<SigmoidGradNode>(node);
2499 opProto = graph.add_node();
2500 opProto->set_op_type("Glow_SigmoidGrad");
2501 opProto->set_name(glow::legalizeName(N__->getName()));
2502 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2503 addTypeAttributes(opProto, N__, SigmoidGradNode::InputIdx, /* isInput */ true);
2504 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2505 addTypeAttributes(opProto, N__, SigmoidGradNode::OriginalOutputForResultIdx, /* isInput */ true);
2506 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2507 addTypeAttributes(opProto, N__, SigmoidGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
2508 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2509 addTypeAttributes(opProto, N__, SigmoidGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
2510 if (N__->hasPredicate()) {
2511 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2512 }
2513 break;
2514}
2515
2516case glow::Kinded::Kind::SigmoidNodeKind: {
2517 auto *N__ = llvm::cast<SigmoidNode>(node);
2518 opProto = graph.add_node();
2519 opProto->set_op_type("Glow_Sigmoid");
2520 opProto->set_name(glow::legalizeName(N__->getName()));
2521 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2522 addTypeAttributes(opProto, N__, SigmoidNode::InputIdx, /* isInput */ true);
2523 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2524 addTypeAttributes(opProto, N__, SigmoidNode::ResultIdx, /* isInput */ false);
2525 if (N__->hasPredicate()) {
2526 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2527 }
2528 break;
2529}
2530
2531case glow::Kinded::Kind::SwishNodeKind: {
2532 auto *N__ = llvm::cast<SwishNode>(node);
2533 opProto = graph.add_node();
2534 opProto->set_op_type("Glow_Swish");
2535 opProto->set_name(glow::legalizeName(N__->getName()));
2536 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2537 addTypeAttributes(opProto, N__, SwishNode::InputIdx, /* isInput */ true);
2538 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2539 addTypeAttributes(opProto, N__, SwishNode::ResultIdx, /* isInput */ false);
2540 if (N__->hasPredicate()) {
2541 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2542 }
2543 break;
2544}
2545
2546case glow::Kinded::Kind::TanhGradNodeKind: {
2547 auto *N__ = llvm::cast<TanhGradNode>(node);
2548 opProto = graph.add_node();
2549 opProto->set_op_type("Glow_TanhGrad");
2550 opProto->set_name(glow::legalizeName(N__->getName()));
2551 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2552 addTypeAttributes(opProto, N__, TanhGradNode::InputIdx, /* isInput */ true);
2553 opProto->add_input(N__->getOriginalOutputForResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2554 addTypeAttributes(opProto, N__, TanhGradNode::OriginalOutputForResultIdx, /* isInput */ true);
2555 opProto->add_input(N__->getGradOfOriginalOutputNamedResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2556 addTypeAttributes(opProto, N__, TanhGradNode::GradOfOriginalOutputNamedResultIdx, /* isInput */ true);
2557 opProto->add_output(N__->getGradOfInputNamedInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2558 addTypeAttributes(opProto, N__, TanhGradNode::GradOfInputNamedInputIdx, /* isInput */ false);
2559 if (N__->hasPredicate()) {
2560 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2561 }
2562 break;
2563}
2564
2565case glow::Kinded::Kind::TanhNodeKind: {
2566 auto *N__ = llvm::cast<TanhNode>(node);
2567 opProto = graph.add_node();
2568 opProto->set_op_type("Glow_Tanh");
2569 opProto->set_name(glow::legalizeName(N__->getName()));
2570 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2571 addTypeAttributes(opProto, N__, TanhNode::InputIdx, /* isInput */ true);
2572 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2573 addTypeAttributes(opProto, N__, TanhNode::ResultIdx, /* isInput */ false);
2574 if (N__->hasPredicate()) {
2575 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2576 }
2577 break;
2578}
2579
2580case glow::Kinded::Kind::LeakyReluNodeKind: {
2581 auto *N__ = llvm::cast<LeakyReluNode>(node);
2582 opProto = graph.add_node();
2583 opProto->set_op_type("Glow_LeakyRelu");
2584 opProto->set_name(glow::legalizeName(N__->getName()));
2585 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2586 addTypeAttributes(opProto, N__, LeakyReluNode::InputIdx, /* isInput */ true);
2587 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2588 addTypeAttributes(opProto, N__, LeakyReluNode::ResultIdx, /* isInput */ false);
2589 addValueAttribute(opProto, "Alpha", N__->getAlpha());
2590 if (N__->hasPredicate()) {
2591 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2592 }
2593 break;
2594}
2595
2596case glow::Kinded::Kind::SoftPlusNodeKind: {
2597 auto *N__ = llvm::cast<SoftPlusNode>(node);
2598 opProto = graph.add_node();
2599 opProto->set_op_type("Glow_SoftPlus");
2600 opProto->set_name(glow::legalizeName(N__->getName()));
2601 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2602 addTypeAttributes(opProto, N__, SoftPlusNode::InputIdx, /* isInput */ true);
2603 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2604 addTypeAttributes(opProto, N__, SoftPlusNode::ResultIdx, /* isInput */ false);
2605 if (N__->hasPredicate()) {
2606 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2607 }
2608 break;
2609}
2610
2611case glow::Kinded::Kind::ReshapeNodeKind: {
2612 auto *N__ = llvm::cast<ReshapeNode>(node);
2613 opProto = graph.add_node();
2614 opProto->set_op_type("Glow_Reshape");
2615 opProto->set_name(glow::legalizeName(N__->getName()));
2616 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2617 addTypeAttributes(opProto, N__, ReshapeNode::InputIdx, /* isInput */ true);
2618 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2619 addTypeAttributes(opProto, N__, ReshapeNode::ResultIdx, /* isInput */ false);
2620 addValueAttribute(opProto, "Dims", N__->getDims());
2621 addValueAttribute(opProto, "Layout", N__->getLayout());
2622 if (N__->hasPredicate()) {
2623 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2624 }
2625 break;
2626}
2627
2628case glow::Kinded::Kind::TransposeNodeKind: {
2629 auto *N__ = llvm::cast<TransposeNode>(node);
2630 opProto = graph.add_node();
2631 opProto->set_op_type("Glow_Transpose");
2632 opProto->set_name(glow::legalizeName(N__->getName()));
2633 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2634 addTypeAttributes(opProto, N__, TransposeNode::InputIdx, /* isInput */ true);
2635 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2636 addTypeAttributes(opProto, N__, TransposeNode::ResultIdx, /* isInput */ false);
2637 addValueAttribute(opProto, "Shuffle", N__->getShuffle());
2638 addValueAttribute(opProto, "Layout", N__->getLayout());
2639 if (N__->hasPredicate()) {
2640 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2641 }
2642 break;
2643}
2644
2645case glow::Kinded::Kind::ConcatNodeKind: {
2646 auto *N__ = llvm::cast<ConcatNode>(node);
2647 opProto = graph.add_node();
2648 opProto->set_op_type("Glow_Concat");
2649 opProto->set_name(glow::legalizeName(N__->getName()));
2650 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2651 addTypeAttributes(opProto, N__, ConcatNode::ResultIdx, /* isInput */ false);
2652 addValueAttribute(opProto, "Inputs", N__->getInputs());
2653 for (unsigned i = 0, e = N__->getInputs().size(); i < e; i++) {
2654 addTypeAttributes(opProto, N__->getInputs()[i], i, /* isInput */ true, "Inputs_");
2655 }
2656 addValueAttribute(opProto, "Dim", N__->getDim());
2657 if (N__->hasPredicate()) {
2658 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2659 }
2660 break;
2661}
2662
2663case glow::Kinded::Kind::SliceNodeKind: {
2664 auto *N__ = llvm::cast<SliceNode>(node);
2665 opProto = graph.add_node();
2666 opProto->set_op_type("Glow_Slice");
2667 opProto->set_name(glow::legalizeName(N__->getName()));
2668 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2669 addTypeAttributes(opProto, N__, SliceNode::InputIdx, /* isInput */ true);
2670 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2671 addTypeAttributes(opProto, N__, SliceNode::ResultIdx, /* isInput */ false);
2672 addValueAttribute(opProto, "Start", N__->getStart());
2673 if (N__->hasPredicate()) {
2674 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2675 }
2676 break;
2677}
2678
2679case glow::Kinded::Kind::InsertTensorNodeKind: {
2680 auto *N__ = llvm::cast<InsertTensorNode>(node);
2681 opProto = graph.add_node();
2682 opProto->set_op_type("Glow_InsertTensor");
2683 opProto->set_name(glow::legalizeName(N__->getName()));
2684 opProto->add_input(N__->getBig().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2685 addTypeAttributes(opProto, N__, InsertTensorNode::BigIdx, /* isInput */ true);
2686 opProto->add_input(N__->getSmall().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2687 addTypeAttributes(opProto, N__, InsertTensorNode::SmallIdx, /* isInput */ true);
2688 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2689 addTypeAttributes(opProto, N__, InsertTensorNode::ResultIdx, /* isInput */ false);
2690 addValueAttribute(opProto, "Start", N__->getStart());
2691 addValueAttribute(opProto, "Count", N__->getCount());
2692 addValueAttribute(opProto, "Axis", N__->getAxis());
2693 if (N__->hasPredicate()) {
2694 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2695 }
2696 break;
2697}
2698
2699case glow::Kinded::Kind::GatherNodeKind: {
2700 auto *N__ = llvm::cast<GatherNode>(node);
2701 opProto = graph.add_node();
2702 opProto->set_op_type("Glow_Gather");
2703 opProto->set_name(glow::legalizeName(N__->getName()));
2704 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2705 addTypeAttributes(opProto, N__, GatherNode::DataIdx, /* isInput */ true);
2706 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2707 addTypeAttributes(opProto, N__, GatherNode::IndicesIdx, /* isInput */ true);
2708 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2709 addTypeAttributes(opProto, N__, GatherNode::ResultIdx, /* isInput */ false);
2710 addValueAttribute(opProto, "BatchDims", N__->getBatchDims());
2711 if (N__->hasPredicate()) {
2712 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2713 }
2714 break;
2715}
2716
2717case glow::Kinded::Kind::GatherNDNodeKind: {
2718 auto *N__ = llvm::cast<GatherNDNode>(node);
2719 opProto = graph.add_node();
2720 opProto->set_op_type("Glow_GatherND");
2721 opProto->set_name(glow::legalizeName(N__->getName()));
2722 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2723 addTypeAttributes(opProto, N__, GatherNDNode::DataIdx, /* isInput */ true);
2724 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2725 addTypeAttributes(opProto, N__, GatherNDNode::IndicesIdx, /* isInput */ true);
2726 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2727 addTypeAttributes(opProto, N__, GatherNDNode::ResultIdx, /* isInput */ false);
2728 addValueAttribute(opProto, "BatchDims", N__->getBatchDims());
2729 if (N__->hasPredicate()) {
2730 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2731 }
2732 break;
2733}
2734
2735case glow::Kinded::Kind::GatherElementsNodeKind: {
2736 auto *N__ = llvm::cast<GatherElementsNode>(node);
2737 opProto = graph.add_node();
2738 opProto->set_op_type("Glow_GatherElements");
2739 opProto->set_name(glow::legalizeName(N__->getName()));
2740 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2741 addTypeAttributes(opProto, N__, GatherElementsNode::DataIdx, /* isInput */ true);
2742 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2743 addTypeAttributes(opProto, N__, GatherElementsNode::IndicesIdx, /* isInput */ true);
2744 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2745 addTypeAttributes(opProto, N__, GatherElementsNode::ResultIdx, /* isInput */ false);
2746 addValueAttribute(opProto, "Dim", N__->getDim());
2747 if (N__->hasPredicate()) {
2748 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2749 }
2750 break;
2751}
2752
2753case glow::Kinded::Kind::GatherRangesNodeKind: {
2754 auto *N__ = llvm::cast<GatherRangesNode>(node);
2755 opProto = graph.add_node();
2756 opProto->set_op_type("Glow_GatherRanges");
2757 opProto->set_name(glow::legalizeName(N__->getName()));
2758 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2759 addTypeAttributes(opProto, N__, GatherRangesNode::DataIdx, /* isInput */ true);
2760 opProto->add_input(N__->getRanges().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2761 addTypeAttributes(opProto, N__, GatherRangesNode::RangesIdx, /* isInput */ true);
2762 opProto->add_output(N__->getOutput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2763 addTypeAttributes(opProto, N__, GatherRangesNode::OutputIdx, /* isInput */ false);
2764 opProto->add_output(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2765 addTypeAttributes(opProto, N__, GatherRangesNode::LengthsIdx, /* isInput */ false);
2766 if (N__->hasPredicate()) {
2767 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2768 }
2769 break;
2770}
2771
2772case glow::Kinded::Kind::ScatterDataNodeKind: {
2773 auto *N__ = llvm::cast<ScatterDataNode>(node);
2774 opProto = graph.add_node();
2775 opProto->set_op_type("Glow_ScatterData");
2776 opProto->set_name(glow::legalizeName(N__->getName()));
2777 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2778 addTypeAttributes(opProto, N__, ScatterDataNode::DataIdx, /* isInput */ true);
2779 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2780 addTypeAttributes(opProto, N__, ScatterDataNode::IndicesIdx, /* isInput */ true);
2781 opProto->add_input(N__->getSlices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2782 addTypeAttributes(opProto, N__, ScatterDataNode::SlicesIdx, /* isInput */ true);
2783 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2784 addTypeAttributes(opProto, N__, ScatterDataNode::ResultIdx, /* isInput */ false);
2785 addValueAttribute(opProto, "Cumulative", N__->getCumulative());
2786 if (N__->hasPredicate()) {
2787 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2788 }
2789 break;
2790}
2791
2792case glow::Kinded::Kind::TileNodeKind: {
2793 auto *N__ = llvm::cast<TileNode>(node);
2794 opProto = graph.add_node();
2795 opProto->set_op_type("Glow_Tile");
2796 opProto->set_name(glow::legalizeName(N__->getName()));
2797 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2798 addTypeAttributes(opProto, N__, TileNode::InputIdx, /* isInput */ true);
2799 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2800 addTypeAttributes(opProto, N__, TileNode::ResultIdx, /* isInput */ false);
2801 addValueAttribute(opProto, "Count", N__->getCount());
2802 addValueAttribute(opProto, "Axis", N__->getAxis());
2803 if (N__->hasPredicate()) {
2804 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2805 }
2806 break;
2807}
2808
2809case glow::Kinded::Kind::BatchOneHotNodeKind: {
2810 auto *N__ = llvm::cast<BatchOneHotNode>(node);
2811 opProto = graph.add_node();
2812 opProto->set_op_type("Glow_BatchOneHot");
2813 opProto->set_name(glow::legalizeName(N__->getName()));
2814 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2815 addTypeAttributes(opProto, N__, BatchOneHotNode::DataIdx, /* isInput */ true);
2816 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2817 addTypeAttributes(opProto, N__, BatchOneHotNode::LengthsIdx, /* isInput */ true);
2818 opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2819 addTypeAttributes(opProto, N__, BatchOneHotNode::ValuesIdx, /* isInput */ true);
2820 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2821 addTypeAttributes(opProto, N__, BatchOneHotNode::ResultIdx, /* isInput */ false);
2822 if (N__->hasPredicate()) {
2823 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2824 }
2825 break;
2826}
2827
2828case glow::Kinded::Kind::SpaceToDepthNodeKind: {
2829 auto *N__ = llvm::cast<SpaceToDepthNode>(node);
2830 opProto = graph.add_node();
2831 opProto->set_op_type("Glow_SpaceToDepth");
2832 opProto->set_name(glow::legalizeName(N__->getName()));
2833 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2834 addTypeAttributes(opProto, N__, SpaceToDepthNode::InputIdx, /* isInput */ true);
2835 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2836 addTypeAttributes(opProto, N__, SpaceToDepthNode::ResultIdx, /* isInput */ false);
2837 addValueAttribute(opProto, "BlockSize", N__->getBlockSize());
2838 if (N__->hasPredicate()) {
2839 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2840 }
2841 break;
2842}
2843
2844case glow::Kinded::Kind::ResizeNearestNodeKind: {
2845 auto *N__ = llvm::cast<ResizeNearestNode>(node);
2846 opProto = graph.add_node();
2847 opProto->set_op_type("Glow_ResizeNearest");
2848 opProto->set_name(glow::legalizeName(N__->getName()));
2849 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2850 addTypeAttributes(opProto, N__, ResizeNearestNode::InputIdx, /* isInput */ true);
2851 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2852 addTypeAttributes(opProto, N__, ResizeNearestNode::ResultIdx, /* isInput */ false);
2853 addValueAttribute(opProto, "Scale", N__->getScale());
2854 if (N__->hasPredicate()) {
2855 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2856 }
2857 break;
2858}
2859
2860case glow::Kinded::Kind::ResizeBilinearNodeKind: {
2861 auto *N__ = llvm::cast<ResizeBilinearNode>(node);
2862 opProto = graph.add_node();
2863 opProto->set_op_type("Glow_ResizeBilinear");
2864 opProto->set_name(glow::legalizeName(N__->getName()));
2865 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2866 addTypeAttributes(opProto, N__, ResizeBilinearNode::InputIdx, /* isInput */ true);
2867 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2868 addTypeAttributes(opProto, N__, ResizeBilinearNode::ResultIdx, /* isInput */ false);
2869 addValueAttribute(opProto, "Scale", N__->getScale());
2870 if (N__->hasPredicate()) {
2871 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2872 }
2873 break;
2874}
2875
2876case glow::Kinded::Kind::BroadcastNodeKind: {
2877 auto *N__ = llvm::cast<BroadcastNode>(node);
2878 opProto = graph.add_node();
2879 opProto->set_op_type("Glow_Broadcast");
2880 opProto->set_name(glow::legalizeName(N__->getName()));
2881 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2882 addTypeAttributes(opProto, N__, BroadcastNode::InputIdx, /* isInput */ true);
2883 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2884 addTypeAttributes(opProto, N__, BroadcastNode::ResultIdx, /* isInput */ false);
2885 addValueAttribute(opProto, "Axis", N__->getAxis());
2886 addValueAttribute(opProto, "TargetDim", N__->getTargetDim());
2887 if (N__->hasPredicate()) {
2888 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2889 }
2890 break;
2891}
2892
2893case glow::Kinded::Kind::SparseLabelSplitNodeKind: {
2894 auto *N__ = llvm::cast<SparseLabelSplitNode>(node);
2895 opProto = graph.add_node();
2896 opProto->set_op_type("Glow_SparseLabelSplit");
2897 opProto->set_name(glow::legalizeName(N__->getName()));
2898 opProto->add_input(N__->getLengths().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2899 addTypeAttributes(opProto, N__, SparseLabelSplitNode::LengthsIdx, /* isInput */ true);
2900 opProto->add_input(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2901 addTypeAttributes(opProto, N__, SparseLabelSplitNode::IndicesIdx, /* isInput */ true);
2902 opProto->add_input(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2903 addTypeAttributes(opProto, N__, SparseLabelSplitNode::ValuesIdx, /* isInput */ true);
2904 opProto->add_output(N__->getLabelValues().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2905 addTypeAttributes(opProto, N__, SparseLabelSplitNode::LabelValuesIdx, /* isInput */ false);
2906 opProto->add_output(N__->getExampleIds().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2907 addTypeAttributes(opProto, N__, SparseLabelSplitNode::ExampleIdsIdx, /* isInput */ false);
2908 opProto->add_output(N__->getGradientOffsetMap().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2909 addTypeAttributes(opProto, N__, SparseLabelSplitNode::GradientOffsetMapIdx, /* isInput */ false);
2910 addValueAttribute(opProto, "NumLabels", N__->getNumLabels());
2911 if (N__->hasPredicate()) {
2912 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2913 }
2914 break;
2915}
2916
2917case glow::Kinded::Kind::FlipNodeKind: {
2918 auto *N__ = llvm::cast<FlipNode>(node);
2919 opProto = graph.add_node();
2920 opProto->set_op_type("Glow_Flip");
2921 opProto->set_name(glow::legalizeName(N__->getName()));
2922 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2923 addTypeAttributes(opProto, N__, FlipNode::InputIdx, /* isInput */ true);
2924 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2925 addTypeAttributes(opProto, N__, FlipNode::ResultIdx, /* isInput */ false);
2926 addValueAttribute(opProto, "Axis", N__->getAxis());
2927 if (N__->hasPredicate()) {
2928 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2929 }
2930 break;
2931}
2932
2933case glow::Kinded::Kind::SplatNodeKind: {
2934 auto *N__ = llvm::cast<SplatNode>(node);
2935 opProto = graph.add_node();
2936 opProto->set_op_type("Glow_Splat");
2937 opProto->set_name(glow::legalizeName(N__->getName()));
2938 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2939 addTypeAttributes(opProto, N__, SplatNode::ResultIdx, /* isInput */ false);
2940 addValueAttribute(opProto, "Value", N__->getValue());
2941 if (N__->hasPredicate()) {
2942 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2943 }
2944 break;
2945}
2946
2947case glow::Kinded::Kind::TouchNodeKind: {
2948 auto *N__ = llvm::cast<TouchNode>(node);
2949 opProto = graph.add_node();
2950 opProto->set_op_type("Glow_Touch");
2951 opProto->set_name(glow::legalizeName(N__->getName()));
2952 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2953 addTypeAttributes(opProto, N__, TouchNode::ResultIdx, /* isInput */ false);
2954 if (N__->hasPredicate()) {
2955 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2956 }
2957 break;
2958}
2959
2960case glow::Kinded::Kind::SGDNodeKind: {
2961 auto *N__ = llvm::cast<SGDNode>(node);
2962 opProto = graph.add_node();
2963 opProto->set_op_type("Glow_SGD");
2964 opProto->set_name(glow::legalizeName(N__->getName()));
2965 opProto->add_input(N__->getGradient().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2966 addTypeAttributes(opProto, N__, SGDNode::GradientIdx, /* isInput */ true);
2967 opProto->add_input(N__->getWeight().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2968 addTypeAttributes(opProto, N__, SGDNode::WeightIdx, /* isInput */ true);
2969 opProto->add_output(N__->getUpdatedWeight().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2970 addTypeAttributes(opProto, N__, SGDNode::UpdatedWeightIdx, /* isInput */ false);
2971 addValueAttribute(opProto, "L1Decay", N__->getL1Decay());
2972 addValueAttribute(opProto, "L2Decay", N__->getL2Decay());
2973 addValueAttribute(opProto, "LearningRate", N__->getLearningRate());
2974 addValueAttribute(opProto, "Momentum", N__->getMomentum());
2975 addValueAttribute(opProto, "BatchSize", N__->getBatchSize());
2976 if (N__->hasPredicate()) {
2977 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2978 }
2979 break;
2980}
2981
2982case glow::Kinded::Kind::TraceEventNodeKind: {
2983 auto *N__ = llvm::cast<TraceEventNode>(node);
2984 opProto = graph.add_node();
2985 opProto->set_op_type("Glow_TraceEvent");
2986 opProto->set_name(glow::legalizeName(N__->getName()));
2987 opProto->add_input(N__->getData().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2988 addTypeAttributes(opProto, N__, TraceEventNode::DataIdx, /* isInput */ true);
2989 addValueAttribute(opProto, "EventName", N__->getEventName());
2990 addValueAttribute(opProto, "EventType", N__->getEventType());
2991 addValueAttribute(opProto, "Index", N__->getIndex());
2992 if (N__->hasPredicate()) {
2993 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
2994 }
2995 break;
2996}
2997
2998case glow::Kinded::Kind::QuantizationProfileNodeKind: {
2999 auto *N__ = llvm::cast<QuantizationProfileNode>(node);
3000 opProto = graph.add_node();
3001 opProto->set_op_type("Glow_QuantizationProfile");
3002 opProto->set_name(glow::legalizeName(N__->getName()));
3003 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3004 addTypeAttributes(opProto, N__, QuantizationProfileNode::InputIdx, /* isInput */ true);
3005 opProto->add_input(N__->getHistogram().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3006 addTypeAttributes(opProto, N__, QuantizationProfileNode::HistogramIdx, /* isInput */ true);
3007 opProto->add_input(N__->getComputationInfo().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3008 addTypeAttributes(opProto, N__, QuantizationProfileNode::ComputationInfoIdx, /* isInput */ true);
3009 addValueAttribute(opProto, "ProfiledNodeName", N__->getProfiledNodeName());
3010 addValueAttribute(opProto, "ProfiledOutputNumber", N__->getProfiledOutputNumber());
3011 if (N__->hasPredicate()) {
3012 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3013 }
3014 break;
3015}
3016
3017case glow::Kinded::Kind::IntLookupTableNodeKind: {
3018 auto *N__ = llvm::cast<IntLookupTableNode>(node);
3019 opProto = graph.add_node();
3020 opProto->set_op_type("Glow_IntLookupTable");
3021 opProto->set_name(glow::legalizeName(N__->getName()));
3022 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3023 addTypeAttributes(opProto, N__, IntLookupTableNode::InputIdx, /* isInput */ true);
3024 opProto->add_input(N__->getMapping().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3025 addTypeAttributes(opProto, N__, IntLookupTableNode::MappingIdx, /* isInput */ true);
3026 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3027 addTypeAttributes(opProto, N__, IntLookupTableNode::ResultIdx, /* isInput */ false);
3028 if (N__->hasPredicate()) {
3029 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3030 }
3031 break;
3032}
3033
3034case glow::Kinded::Kind::QuantizeNodeKind: {
3035 auto *N__ = llvm::cast<QuantizeNode>(node);
3036 opProto = graph.add_node();
3037 opProto->set_op_type("Glow_Quantize");
3038 opProto->set_name(glow::legalizeName(N__->getName()));
3039 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3040 addTypeAttributes(opProto, N__, QuantizeNode::InputIdx, /* isInput */ true);
3041 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3042 addTypeAttributes(opProto, N__, QuantizeNode::ResultIdx, /* isInput */ false);
3043 if (N__->hasPredicate()) {
3044 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3045 }
3046 break;
3047}
3048
3049case glow::Kinded::Kind::DequantizeNodeKind: {
3050 auto *N__ = llvm::cast<DequantizeNode>(node);
3051 opProto = graph.add_node();
3052 opProto->set_op_type("Glow_Dequantize");
3053 opProto->set_name(glow::legalizeName(N__->getName()));
3054 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3055 addTypeAttributes(opProto, N__, DequantizeNode::InputIdx, /* isInput */ true);
3056 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3057 addTypeAttributes(opProto, N__, DequantizeNode::ResultIdx, /* isInput */ false);
3058 if (N__->hasPredicate()) {
3059 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3060 }
3061 break;
3062}
3063
3064case glow::Kinded::Kind::RescaleQuantizedNodeKind: {
3065 auto *N__ = llvm::cast<RescaleQuantizedNode>(node);
3066 opProto = graph.add_node();
3067 opProto->set_op_type("Glow_RescaleQuantized");
3068 opProto->set_name(glow::legalizeName(N__->getName()));
3069 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3070 addTypeAttributes(opProto, N__, RescaleQuantizedNode::InputIdx, /* isInput */ true);
3071 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3072 addTypeAttributes(opProto, N__, RescaleQuantizedNode::ResultIdx, /* isInput */ false);
3073 if (N__->hasPredicate()) {
3074 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3075 }
3076 break;
3077}
3078
3079case glow::Kinded::Kind::TopKNodeKind: {
3080 auto *N__ = llvm::cast<TopKNode>(node);
3081 opProto = graph.add_node();
3082 opProto->set_op_type("Glow_TopK");
3083 opProto->set_name(glow::legalizeName(N__->getName()));
3084 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3085 addTypeAttributes(opProto, N__, TopKNode::InputIdx, /* isInput */ true);
3086 opProto->add_output(N__->getValues().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3087 addTypeAttributes(opProto, N__, TopKNode::ValuesIdx, /* isInput */ false);
3088 opProto->add_output(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3089 addTypeAttributes(opProto, N__, TopKNode::IndicesIdx, /* isInput */ false);
3090 addValueAttribute(opProto, "K", N__->getK());
3091 if (N__->hasPredicate()) {
3092 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3093 }
3094 break;
3095}
3096
3097case glow::Kinded::Kind::LSTMUnitNodeKind: {
3098 auto *N__ = llvm::cast<LSTMUnitNode>(node);
3099 opProto = graph.add_node();
3100 opProto->set_op_type("Glow_LSTMUnit");
3101 opProto->set_name(glow::legalizeName(N__->getName()));
3102 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3103 addTypeAttributes(opProto, N__, LSTMUnitNode::InputIdx, /* isInput */ true);
3104 opProto->add_input(N__->getC().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3105 addTypeAttributes(opProto, N__, LSTMUnitNode::CIdx, /* isInput */ true);
3106 opProto->add_output(N__->getnewC().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3107 addTypeAttributes(opProto, N__, LSTMUnitNode::newCIdx, /* isInput */ false);
3108 opProto->add_output(N__->getnewH().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3109 addTypeAttributes(opProto, N__, LSTMUnitNode::newHIdx, /* isInput */ false);
3110 if (N__->hasPredicate()) {
3111 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3112 }
3113 break;
3114}
3115
3116case glow::Kinded::Kind::ConvertToNodeKind: {
3117 auto *N__ = llvm::cast<ConvertToNode>(node);
3118 opProto = graph.add_node();
3119 opProto->set_op_type("Glow_ConvertTo");
3120 opProto->set_name(glow::legalizeName(N__->getName()));
3121 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3122 addTypeAttributes(opProto, N__, ConvertToNode::InputIdx, /* isInput */ true);
3123 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3124 addTypeAttributes(opProto, N__, ConvertToNode::ResultIdx, /* isInput */ false);
3125 if (N__->hasPredicate()) {
3126 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3127 }
3128 break;
3129}
3130
3131case glow::Kinded::Kind::AudioSpectrogramNodeKind: {
3132 auto *N__ = llvm::cast<AudioSpectrogramNode>(node);
3133 opProto = graph.add_node();
3134 opProto->set_op_type("Glow_AudioSpectrogram");
3135 opProto->set_name(glow::legalizeName(N__->getName()));
3136 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3137 addTypeAttributes(opProto, N__, AudioSpectrogramNode::InputIdx, /* isInput */ true);
3138 opProto->add_input(N__->getWindow().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3139 addTypeAttributes(opProto, N__, AudioSpectrogramNode::WindowIdx, /* isInput */ true);
3140 opProto->add_input(N__->getTwiddleFactors().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3141 addTypeAttributes(opProto, N__, AudioSpectrogramNode::TwiddleFactorsIdx, /* isInput */ true);
3142 opProto->add_input(N__->getBitReverseIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3143 addTypeAttributes(opProto, N__, AudioSpectrogramNode::BitReverseIndicesIdx, /* isInput */ true);
3144 opProto->add_input(N__->getComplexToRealWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3145 addTypeAttributes(opProto, N__, AudioSpectrogramNode::ComplexToRealWeightsIdx, /* isInput */ true);
3146 opProto->add_output(N__->getSpectrogram().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3147 addTypeAttributes(opProto, N__, AudioSpectrogramNode::SpectrogramIdx, /* isInput */ false);
3148 addValueAttribute(opProto, "WindowSize", N__->getWindowSize());
3149 addValueAttribute(opProto, "WindowStride", N__->getWindowStride());
3150 addValueAttribute(opProto, "MagnitudeSquared", N__->getMagnitudeSquared());
3151 if (N__->hasPredicate()) {
3152 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3153 }
3154 break;
3155}
3156
3157case glow::Kinded::Kind::MFCCNodeKind: {
3158 auto *N__ = llvm::cast<MFCCNode>(node);
3159 opProto = graph.add_node();
3160 opProto->set_op_type("Glow_MFCC");
3161 opProto->set_name(glow::legalizeName(N__->getName()));
3162 opProto->add_input(N__->getSpectrogram().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3163 addTypeAttributes(opProto, N__, MFCCNode::SpectrogramIdx, /* isInput */ true);
3164 opProto->add_input(N__->getMelWeights().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3165 addTypeAttributes(opProto, N__, MFCCNode::MelWeightsIdx, /* isInput */ true);
3166 opProto->add_input(N__->getMelRanges().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3167 addTypeAttributes(opProto, N__, MFCCNode::MelRangesIdx, /* isInput */ true);
3168 opProto->add_input(N__->getDctMat().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3169 addTypeAttributes(opProto, N__, MFCCNode::DctMatIdx, /* isInput */ true);
3170 opProto->add_output(N__->getCoefficients().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3171 addTypeAttributes(opProto, N__, MFCCNode::CoefficientsIdx, /* isInput */ false);
3172 addValueAttribute(opProto, "SampleRate", N__->getSampleRate());
3173 addValueAttribute(opProto, "LowerFrequency", N__->getLowerFrequency());
3174 addValueAttribute(opProto, "UpperFrequency", N__->getUpperFrequency());
3175 addValueAttribute(opProto, "FilterBankCount", N__->getFilterBankCount());
3176 addValueAttribute(opProto, "NumCoefficients", N__->getNumCoefficients());
3177 if (N__->hasPredicate()) {
3178 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3179 }
3180 break;
3181}
3182
3183case glow::Kinded::Kind::NonMaxSuppressionNodeKind: {
3184 auto *N__ = llvm::cast<NonMaxSuppressionNode>(node);
3185 opProto = graph.add_node();
3186 opProto->set_op_type("Glow_NonMaxSuppression");
3187 opProto->set_name(glow::legalizeName(N__->getName()));
3188 opProto->add_input(N__->getBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3189 addTypeAttributes(opProto, N__, NonMaxSuppressionNode::BoxesIdx, /* isInput */ true);
3190 opProto->add_input(N__->getScores().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3191 addTypeAttributes(opProto, N__, NonMaxSuppressionNode::ScoresIdx, /* isInput */ true);
3192 opProto->add_output(N__->getIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3193 addTypeAttributes(opProto, N__, NonMaxSuppressionNode::IndicesIdx, /* isInput */ false);
3194 opProto->add_output(N__->getNumberOfSelectedIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3195 addTypeAttributes(opProto, N__, NonMaxSuppressionNode::NumberOfSelectedIndicesIdx, /* isInput */ false);
3196 addValueAttribute(opProto, "CenterPointBox", N__->getCenterPointBox());
3197 addValueAttribute(opProto, "MaxOutputBoxesPerClass", N__->getMaxOutputBoxesPerClass());
3198 addValueAttribute(opProto, "IouThreshold", N__->getIouThreshold());
3199 addValueAttribute(opProto, "ScoreThreshold", N__->getScoreThreshold());
3200 addValueAttribute(opProto, "IsTFVersion4", N__->getIsTFVersion4());
3201 if (N__->hasPredicate()) {
3202 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3203 }
3204 break;
3205}
3206
3207case glow::Kinded::Kind::TFLiteDetectionPostProcessNodeKind: {
3208 auto *N__ = llvm::cast<TFLiteDetectionPostProcessNode>(node);
3209 opProto = graph.add_node();
3210 opProto->set_op_type("Glow_TFLiteDetectionPostProcess");
3211 opProto->set_name(glow::legalizeName(N__->getName()));
3212 opProto->add_input(N__->getBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3213 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::BoxesIdx, /* isInput */ true);
3214 opProto->add_input(N__->getScores().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3215 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::ScoresIdx, /* isInput */ true);
3216 opProto->add_input(N__->getAnchors().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3217 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::AnchorsIdx, /* isInput */ true);
3218 opProto->add_output(N__->getDetectionBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3219 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::DetectionBoxesIdx, /* isInput */ false);
3220 opProto->add_output(N__->getDetectionClasses().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3221 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::DetectionClassesIdx, /* isInput */ false);
3222 opProto->add_output(N__->getDetectionScores().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3223 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::DetectionScoresIdx, /* isInput */ false);
3224 opProto->add_output(N__->getNumDetections().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3225 addTypeAttributes(opProto, N__, TFLiteDetectionPostProcessNode::NumDetectionsIdx, /* isInput */ false);
3226 addValueAttribute(opProto, "NumClasses", N__->getNumClasses());
3227 addValueAttribute(opProto, "MaxDetections", N__->getMaxDetections());
3228 addValueAttribute(opProto, "MaxClassesPerDetection", N__->getMaxClassesPerDetection());
3229 addValueAttribute(opProto, "MaxDetectionsPerClass", N__->getMaxDetectionsPerClass());
3230 addValueAttribute(opProto, "IouThreshold", N__->getIouThreshold());
3231 addValueAttribute(opProto, "ScoreThreshold", N__->getScoreThreshold());
3232 addValueAttribute(opProto, "XScale", N__->getXScale());
3233 addValueAttribute(opProto, "YScale", N__->getYScale());
3234 addValueAttribute(opProto, "HScale", N__->getHScale());
3235 addValueAttribute(opProto, "WScale", N__->getWScale());
3236 addValueAttribute(opProto, "RegularNMS", N__->getRegularNMS());
3237 if (N__->hasPredicate()) {
3238 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3239 }
3240 break;
3241}
3242
3243case glow::Kinded::Kind::ROIAlignNodeKind: {
3244 auto *N__ = llvm::cast<ROIAlignNode>(node);
3245 opProto = graph.add_node();
3246 opProto->set_op_type("Glow_ROIAlign");
3247 opProto->set_name(glow::legalizeName(N__->getName()));
3248 opProto->add_input(N__->getFeatureMap().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3249 addTypeAttributes(opProto, N__, ROIAlignNode::FeatureMapIdx, /* isInput */ true);
3250 opProto->add_input(N__->getBoxes().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3251 addTypeAttributes(opProto, N__, ROIAlignNode::BoxesIdx, /* isInput */ true);
3252 opProto->add_input(N__->getBatchIndices().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3253 addTypeAttributes(opProto, N__, ROIAlignNode::BatchIndicesIdx, /* isInput */ true);
3254 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3255 addTypeAttributes(opProto, N__, ROIAlignNode::ResultIdx, /* isInput */ false);
3256 addValueAttribute(opProto, "Mode", N__->getMode());
3257 addValueAttribute(opProto, "OutputHeight", N__->getOutputHeight());
3258 addValueAttribute(opProto, "OutputWidth", N__->getOutputWidth());
3259 addValueAttribute(opProto, "SamplingRatio", N__->getSamplingRatio());
3260 addValueAttribute(opProto, "SpatialScale", N__->getSpatialScale());
3261 addValueAttribute(opProto, "Aligned", N__->getAligned());
3262 addValueAttribute(opProto, "Rotated", N__->getRotated());
3263 if (N__->hasPredicate()) {
3264 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3265 }
3266 break;
3267}
3268
3269case glow::Kinded::Kind::BBoxTransformNodeKind: {
3270 auto *N__ = llvm::cast<BBoxTransformNode>(node);
3271 opProto = graph.add_node();
3272 opProto->set_op_type("Glow_BBoxTransform");
3273 opProto->set_name(glow::legalizeName(N__->getName()));
3274 opProto->add_input(N__->getRois().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3275 addTypeAttributes(opProto, N__, BBoxTransformNode::RoisIdx, /* isInput */ true);
3276 opProto->add_input(N__->getDeltas().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3277 addTypeAttributes(opProto, N__, BBoxTransformNode::DeltasIdx, /* isInput */ true);
3278 opProto->add_input(N__->getImInfo().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3279 addTypeAttributes(opProto, N__, BBoxTransformNode::ImInfoIdx, /* isInput */ true);
3280 opProto->add_output(N__->getBoxOut().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3281 addTypeAttributes(opProto, N__, BBoxTransformNode::BoxOutIdx, /* isInput */ false);
3282 opProto->add_output(N__->getRoiBatchSplits().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3283 addTypeAttributes(opProto, N__, BBoxTransformNode::RoiBatchSplitsIdx, /* isInput */ false);
3284 addValueAttribute(opProto, "Weights", N__->getWeights());
3285 addValueAttribute(opProto, "ApplyScale", N__->getApplyScale());
3286 addValueAttribute(opProto, "Rotated", N__->getRotated());
3287 addValueAttribute(opProto, "AngleBoundOn", N__->getAngleBoundOn());
3288 addValueAttribute(opProto, "AngleBoundLo", N__->getAngleBoundLo());
3289 addValueAttribute(opProto, "AngleBoundHi", N__->getAngleBoundHi());
3290 addValueAttribute(opProto, "ClipAngleThresh", N__->getClipAngleThresh());
3291 addValueAttribute(opProto, "LegacyPlusOne", N__->getLegacyPlusOne());
3292 if (N__->hasPredicate()) {
3293 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3294 }
3295 break;
3296}
3297
3298case glow::Kinded::Kind::CollectRpnProposalsNodeKind: {
3299 auto *N__ = llvm::cast<CollectRpnProposalsNode>(node);
3300 opProto = graph.add_node();
3301 opProto->set_op_type("Glow_CollectRpnProposals");
3302 opProto->set_name(glow::legalizeName(N__->getName()));
3303 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3304 addTypeAttributes(opProto, N__, CollectRpnProposalsNode::ResultIdx, /* isInput */ false);
3305 addValueAttribute(opProto, "RoisIn", N__->getRoisIn());
3306 for (unsigned i = 0, e = N__->getRoisIn().size(); i < e; i++) {
3307 addTypeAttributes(opProto, N__->getRoisIn()[i], i, /* isInput */ true, "RoisIn_");
3308 }
3309 addValueAttribute(opProto, "RoisProbsIn", N__->getRoisProbsIn());
3310 for (unsigned i = 0, e = N__->getRoisProbsIn().size(); i < e; i++) {
3311 addTypeAttributes(opProto, N__->getRoisProbsIn()[i], i, /* isInput */ true, "RoisProbsIn_");
3312 }
3313 addValueAttribute(opProto, "RpnMaxLevel", N__->getRpnMaxLevel());
3314 addValueAttribute(opProto, "RpnMinLevel", N__->getRpnMinLevel());
3315 addValueAttribute(opProto, "RpnPostNmsTopN", N__->getRpnPostNmsTopN());
3316 if (N__->hasPredicate()) {
3317 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3318 }
3319 break;
3320}
3321
3322case glow::Kinded::Kind::LookupTableNodeKind: {
3323 auto *N__ = llvm::cast<LookupTableNode>(node);
3324 opProto = graph.add_node();
3325 opProto->set_op_type("Glow_LookupTable");
3326 opProto->set_name(glow::legalizeName(N__->getName()));
3327 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3328 addTypeAttributes(opProto, N__, LookupTableNode::InputIdx, /* isInput */ true);
3329 opProto->add_input(N__->getTable().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3330 addTypeAttributes(opProto, N__, LookupTableNode::TableIdx, /* isInput */ true);
3331 opProto->add_input(N__->getTableIdx().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3332 addTypeAttributes(opProto, N__, LookupTableNode::TableIdxIdx, /* isInput */ true);
3333 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3334 addTypeAttributes(opProto, N__, LookupTableNode::ResultIdx, /* isInput */ false);
3335 addValueAttribute(opProto, "Operator", N__->getOperator());
3336 addValueAttribute(opProto, "OperatorArgs", N__->getOperatorArgs());
3337 if (N__->hasPredicate()) {
3338 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3339 }
3340 break;
3341}
3342
3343case glow::Kinded::Kind::CPUMaxSplatNodeKind: {
3344 auto *N__ = llvm::cast<CPUMaxSplatNode>(node);
3345 opProto = graph.add_node();
3346 opProto->set_op_type("Glow_CPUMaxSplat");
3347 opProto->set_name(glow::legalizeName(N__->getName()));
3348 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3349 addTypeAttributes(opProto, N__, CPUMaxSplatNode::InputIdx, /* isInput */ true);
3350 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3351 addTypeAttributes(opProto, N__, CPUMaxSplatNode::ResultIdx, /* isInput */ false);
3352 addValueAttribute(opProto, "SplatValue", N__->getSplatValue());
3353 if (N__->hasPredicate()) {
3354 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3355 }
3356 break;
3357}
3358
3359case glow::Kinded::Kind::CPUConvDKKC8NodeKind: {
3360 auto *N__ = llvm::cast<CPUConvDKKC8Node>(node);
3361 opProto = graph.add_node();
3362 opProto->set_op_type("Glow_CPUConvDKKC8");
3363 opProto->set_name(glow::legalizeName(N__->getName()));
3364 opProto->add_input(N__->getInput().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3365 addTypeAttributes(opProto, N__, CPUConvDKKC8Node::InputIdx, /* isInput */ true);
3366 opProto->add_input(N__->getFilter().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3367 addTypeAttributes(opProto, N__, CPUConvDKKC8Node::FilterIdx, /* isInput */ true);
3368 opProto->add_input(N__->getBias().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3369 addTypeAttributes(opProto, N__, CPUConvDKKC8Node::BiasIdx, /* isInput */ true);
3370 opProto->add_output(N__->getResult().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3371 addTypeAttributes(opProto, N__, CPUConvDKKC8Node::ResultIdx, /* isInput */ false);
3372 addValueAttribute(opProto, "Kernels", N__->getKernels());
3373 addValueAttribute(opProto, "Strides", N__->getStrides());
3374 addValueAttribute(opProto, "Pads", N__->getPads());
3375 addValueAttribute(opProto, "Group", N__->getGroup());
3376 if (N__->hasPredicate()) {
3377 addValueAttribute(opProto, "Predicate", N__->getPredicate().generateNodeOutputName(/* stripResNoFor0thInput */ true));
3378 }
3379 break;
3380}
3381
3382