Coverage Report

Created: 2024-01-17 10:31

/src/build/tools/clang/lib/AST/Opcodes.inc
Line
Count
Source (jump to first uncovered line)
1
#ifdef GET_OPCODE_NAMES
2
OP_AddSint8,
3
OP_AddUint8,
4
OP_AddSint16,
5
OP_AddUint16,
6
OP_AddSint32,
7
OP_AddUint32,
8
OP_AddSint64,
9
OP_AddUint64,
10
OP_AddIntAP,
11
OP_AddIntAPS,
12
OP_AddBool,
13
#endif
14
0
#ifdef GET_INTERP
15
0
case OP_AddSint8: {
16
0
  if (!Add<PT_Sint8>(S, OpPC))
17
0
    return false;
18
0
  continue;
19
0
}
20
0
case OP_AddUint8: {
21
0
  if (!Add<PT_Uint8>(S, OpPC))
22
0
    return false;
23
0
  continue;
24
0
}
25
0
case OP_AddSint16: {
26
0
  if (!Add<PT_Sint16>(S, OpPC))
27
0
    return false;
28
0
  continue;
29
0
}
30
0
case OP_AddUint16: {
31
0
  if (!Add<PT_Uint16>(S, OpPC))
32
0
    return false;
33
0
  continue;
34
0
}
35
0
case OP_AddSint32: {
36
0
  if (!Add<PT_Sint32>(S, OpPC))
37
0
    return false;
38
0
  continue;
39
0
}
40
0
case OP_AddUint32: {
41
0
  if (!Add<PT_Uint32>(S, OpPC))
42
0
    return false;
43
0
  continue;
44
0
}
45
0
case OP_AddSint64: {
46
0
  if (!Add<PT_Sint64>(S, OpPC))
47
0
    return false;
48
0
  continue;
49
0
}
50
0
case OP_AddUint64: {
51
0
  if (!Add<PT_Uint64>(S, OpPC))
52
0
    return false;
53
0
  continue;
54
0
}
55
0
case OP_AddIntAP: {
56
0
  if (!Add<PT_IntAP>(S, OpPC))
57
0
    return false;
58
0
  continue;
59
0
}
60
0
case OP_AddIntAPS: {
61
0
  if (!Add<PT_IntAPS>(S, OpPC))
62
0
    return false;
63
0
  continue;
64
0
}
65
0
case OP_AddBool: {
66
0
  if (!Add<PT_Bool>(S, OpPC))
67
0
    return false;
68
0
  continue;
69
0
}
70
0
#endif
71
#ifdef GET_DISASM
72
case OP_AddSint8:
73
  PrintName("AddSint8");
74
  OS << "\t" << "\n";
75
  continue;
76
case OP_AddUint8:
77
  PrintName("AddUint8");
78
  OS << "\t" << "\n";
79
  continue;
80
case OP_AddSint16:
81
  PrintName("AddSint16");
82
  OS << "\t" << "\n";
83
  continue;
84
case OP_AddUint16:
85
  PrintName("AddUint16");
86
  OS << "\t" << "\n";
87
  continue;
88
case OP_AddSint32:
89
  PrintName("AddSint32");
90
  OS << "\t" << "\n";
91
  continue;
92
case OP_AddUint32:
93
  PrintName("AddUint32");
94
  OS << "\t" << "\n";
95
  continue;
96
case OP_AddSint64:
97
  PrintName("AddSint64");
98
  OS << "\t" << "\n";
99
  continue;
100
case OP_AddUint64:
101
  PrintName("AddUint64");
102
  OS << "\t" << "\n";
103
  continue;
104
case OP_AddIntAP:
105
  PrintName("AddIntAP");
106
  OS << "\t" << "\n";
107
  continue;
108
case OP_AddIntAPS:
109
  PrintName("AddIntAPS");
110
  OS << "\t" << "\n";
111
  continue;
112
case OP_AddBool:
113
  PrintName("AddBool");
114
  OS << "\t" << "\n";
115
  continue;
116
#endif
117
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
118
bool emitAddSint8(const SourceInfo &);
119
bool emitAddUint8(const SourceInfo &);
120
bool emitAddSint16(const SourceInfo &);
121
bool emitAddUint16(const SourceInfo &);
122
bool emitAddSint32(const SourceInfo &);
123
bool emitAddUint32(const SourceInfo &);
124
bool emitAddSint64(const SourceInfo &);
125
bool emitAddUint64(const SourceInfo &);
126
bool emitAddIntAP(const SourceInfo &);
127
bool emitAddIntAPS(const SourceInfo &);
128
bool emitAddBool(const SourceInfo &);
129
#endif
130
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
131
bool emitAdd(PrimType, const SourceInfo &I);
132
#endif
133
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
134
bool
135
#if defined(GET_EVAL_IMPL)
136
EvalEmitter
137
#else
138
ByteCodeEmitter
139
#endif
140
0
::emitAdd(PrimType T0, const SourceInfo &I) {
141
0
  switch (T0) {
142
0
  case PT_Sint8:
143
0
    return emitAddSint8(I);
144
0
  case PT_Uint8:
145
0
    return emitAddUint8(I);
146
0
  case PT_Sint16:
147
0
    return emitAddSint16(I);
148
0
  case PT_Uint16:
149
0
    return emitAddUint16(I);
150
0
  case PT_Sint32:
151
0
    return emitAddSint32(I);
152
0
  case PT_Uint32:
153
0
    return emitAddUint32(I);
154
0
  case PT_Sint64:
155
0
    return emitAddSint64(I);
156
0
  case PT_Uint64:
157
0
    return emitAddUint64(I);
158
0
  case PT_IntAP:
159
0
    return emitAddIntAP(I);
160
0
  case PT_IntAPS:
161
0
    return emitAddIntAPS(I);
162
0
  case PT_Bool:
163
0
    return emitAddBool(I);
164
0
  default: llvm_unreachable("invalid type: emitAdd");
165
0
  }
166
0
  llvm_unreachable("invalid enum value");
167
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitAdd(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitAdd(clang::interp::PrimType, clang::interp::SourceInfo const&)
168
#endif
169
#ifdef GET_LINK_IMPL
170
0
bool ByteCodeEmitter::emitAddSint8(const SourceInfo &L) {
171
0
  return emitOp<>(OP_AddSint8, L);
172
0
}
173
0
bool ByteCodeEmitter::emitAddUint8(const SourceInfo &L) {
174
0
  return emitOp<>(OP_AddUint8, L);
175
0
}
176
0
bool ByteCodeEmitter::emitAddSint16(const SourceInfo &L) {
177
0
  return emitOp<>(OP_AddSint16, L);
178
0
}
179
0
bool ByteCodeEmitter::emitAddUint16(const SourceInfo &L) {
180
0
  return emitOp<>(OP_AddUint16, L);
181
0
}
182
0
bool ByteCodeEmitter::emitAddSint32(const SourceInfo &L) {
183
0
  return emitOp<>(OP_AddSint32, L);
184
0
}
185
0
bool ByteCodeEmitter::emitAddUint32(const SourceInfo &L) {
186
0
  return emitOp<>(OP_AddUint32, L);
187
0
}
188
0
bool ByteCodeEmitter::emitAddSint64(const SourceInfo &L) {
189
0
  return emitOp<>(OP_AddSint64, L);
190
0
}
191
0
bool ByteCodeEmitter::emitAddUint64(const SourceInfo &L) {
192
0
  return emitOp<>(OP_AddUint64, L);
193
0
}
194
0
bool ByteCodeEmitter::emitAddIntAP(const SourceInfo &L) {
195
0
  return emitOp<>(OP_AddIntAP, L);
196
0
}
197
0
bool ByteCodeEmitter::emitAddIntAPS(const SourceInfo &L) {
198
0
  return emitOp<>(OP_AddIntAPS, L);
199
0
}
200
0
bool ByteCodeEmitter::emitAddBool(const SourceInfo &L) {
201
0
  return emitOp<>(OP_AddBool, L);
202
0
}
203
#endif
204
#ifdef GET_EVAL_IMPL
205
0
bool EvalEmitter::emitAddSint8(const SourceInfo &L) {
206
0
  if (!isActive()) return true;
207
0
  CurrentSource = L;
208
0
  return Add<PT_Sint8>(S, OpPC);
209
0
}
210
0
bool EvalEmitter::emitAddUint8(const SourceInfo &L) {
211
0
  if (!isActive()) return true;
212
0
  CurrentSource = L;
213
0
  return Add<PT_Uint8>(S, OpPC);
214
0
}
215
0
bool EvalEmitter::emitAddSint16(const SourceInfo &L) {
216
0
  if (!isActive()) return true;
217
0
  CurrentSource = L;
218
0
  return Add<PT_Sint16>(S, OpPC);
219
0
}
220
0
bool EvalEmitter::emitAddUint16(const SourceInfo &L) {
221
0
  if (!isActive()) return true;
222
0
  CurrentSource = L;
223
0
  return Add<PT_Uint16>(S, OpPC);
224
0
}
225
0
bool EvalEmitter::emitAddSint32(const SourceInfo &L) {
226
0
  if (!isActive()) return true;
227
0
  CurrentSource = L;
228
0
  return Add<PT_Sint32>(S, OpPC);
229
0
}
230
0
bool EvalEmitter::emitAddUint32(const SourceInfo &L) {
231
0
  if (!isActive()) return true;
232
0
  CurrentSource = L;
233
0
  return Add<PT_Uint32>(S, OpPC);
234
0
}
235
0
bool EvalEmitter::emitAddSint64(const SourceInfo &L) {
236
0
  if (!isActive()) return true;
237
0
  CurrentSource = L;
238
0
  return Add<PT_Sint64>(S, OpPC);
239
0
}
240
0
bool EvalEmitter::emitAddUint64(const SourceInfo &L) {
241
0
  if (!isActive()) return true;
242
0
  CurrentSource = L;
243
0
  return Add<PT_Uint64>(S, OpPC);
244
0
}
245
0
bool EvalEmitter::emitAddIntAP(const SourceInfo &L) {
246
0
  if (!isActive()) return true;
247
0
  CurrentSource = L;
248
0
  return Add<PT_IntAP>(S, OpPC);
249
0
}
250
0
bool EvalEmitter::emitAddIntAPS(const SourceInfo &L) {
251
0
  if (!isActive()) return true;
252
0
  CurrentSource = L;
253
0
  return Add<PT_IntAPS>(S, OpPC);
254
0
}
255
0
bool EvalEmitter::emitAddBool(const SourceInfo &L) {
256
0
  if (!isActive()) return true;
257
0
  CurrentSource = L;
258
0
  return Add<PT_Bool>(S, OpPC);
259
0
}
260
#endif
261
#ifdef GET_OPCODE_NAMES
262
OP_AddOffsetSint8,
263
OP_AddOffsetUint8,
264
OP_AddOffsetSint16,
265
OP_AddOffsetUint16,
266
OP_AddOffsetSint32,
267
OP_AddOffsetUint32,
268
OP_AddOffsetSint64,
269
OP_AddOffsetUint64,
270
OP_AddOffsetIntAP,
271
OP_AddOffsetIntAPS,
272
OP_AddOffsetBool,
273
#endif
274
0
#ifdef GET_INTERP
275
0
case OP_AddOffsetSint8: {
276
0
  if (!AddOffset<PT_Sint8>(S, OpPC))
277
0
    return false;
278
0
  continue;
279
0
}
280
0
case OP_AddOffsetUint8: {
281
0
  if (!AddOffset<PT_Uint8>(S, OpPC))
282
0
    return false;
283
0
  continue;
284
0
}
285
0
case OP_AddOffsetSint16: {
286
0
  if (!AddOffset<PT_Sint16>(S, OpPC))
287
0
    return false;
288
0
  continue;
289
0
}
290
0
case OP_AddOffsetUint16: {
291
0
  if (!AddOffset<PT_Uint16>(S, OpPC))
292
0
    return false;
293
0
  continue;
294
0
}
295
0
case OP_AddOffsetSint32: {
296
0
  if (!AddOffset<PT_Sint32>(S, OpPC))
297
0
    return false;
298
0
  continue;
299
0
}
300
0
case OP_AddOffsetUint32: {
301
0
  if (!AddOffset<PT_Uint32>(S, OpPC))
302
0
    return false;
303
0
  continue;
304
0
}
305
0
case OP_AddOffsetSint64: {
306
0
  if (!AddOffset<PT_Sint64>(S, OpPC))
307
0
    return false;
308
0
  continue;
309
0
}
310
0
case OP_AddOffsetUint64: {
311
0
  if (!AddOffset<PT_Uint64>(S, OpPC))
312
0
    return false;
313
0
  continue;
314
0
}
315
0
case OP_AddOffsetIntAP: {
316
0
  if (!AddOffset<PT_IntAP>(S, OpPC))
317
0
    return false;
318
0
  continue;
319
0
}
320
0
case OP_AddOffsetIntAPS: {
321
0
  if (!AddOffset<PT_IntAPS>(S, OpPC))
322
0
    return false;
323
0
  continue;
324
0
}
325
0
case OP_AddOffsetBool: {
326
0
  if (!AddOffset<PT_Bool>(S, OpPC))
327
0
    return false;
328
0
  continue;
329
0
}
330
0
#endif
331
#ifdef GET_DISASM
332
case OP_AddOffsetSint8:
333
  PrintName("AddOffsetSint8");
334
  OS << "\t" << "\n";
335
  continue;
336
case OP_AddOffsetUint8:
337
  PrintName("AddOffsetUint8");
338
  OS << "\t" << "\n";
339
  continue;
340
case OP_AddOffsetSint16:
341
  PrintName("AddOffsetSint16");
342
  OS << "\t" << "\n";
343
  continue;
344
case OP_AddOffsetUint16:
345
  PrintName("AddOffsetUint16");
346
  OS << "\t" << "\n";
347
  continue;
348
case OP_AddOffsetSint32:
349
  PrintName("AddOffsetSint32");
350
  OS << "\t" << "\n";
351
  continue;
352
case OP_AddOffsetUint32:
353
  PrintName("AddOffsetUint32");
354
  OS << "\t" << "\n";
355
  continue;
356
case OP_AddOffsetSint64:
357
  PrintName("AddOffsetSint64");
358
  OS << "\t" << "\n";
359
  continue;
360
case OP_AddOffsetUint64:
361
  PrintName("AddOffsetUint64");
362
  OS << "\t" << "\n";
363
  continue;
364
case OP_AddOffsetIntAP:
365
  PrintName("AddOffsetIntAP");
366
  OS << "\t" << "\n";
367
  continue;
368
case OP_AddOffsetIntAPS:
369
  PrintName("AddOffsetIntAPS");
370
  OS << "\t" << "\n";
371
  continue;
372
case OP_AddOffsetBool:
373
  PrintName("AddOffsetBool");
374
  OS << "\t" << "\n";
375
  continue;
376
#endif
377
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
378
bool emitAddOffsetSint8(const SourceInfo &);
379
bool emitAddOffsetUint8(const SourceInfo &);
380
bool emitAddOffsetSint16(const SourceInfo &);
381
bool emitAddOffsetUint16(const SourceInfo &);
382
bool emitAddOffsetSint32(const SourceInfo &);
383
bool emitAddOffsetUint32(const SourceInfo &);
384
bool emitAddOffsetSint64(const SourceInfo &);
385
bool emitAddOffsetUint64(const SourceInfo &);
386
bool emitAddOffsetIntAP(const SourceInfo &);
387
bool emitAddOffsetIntAPS(const SourceInfo &);
388
bool emitAddOffsetBool(const SourceInfo &);
389
#endif
390
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
391
bool emitAddOffset(PrimType, const SourceInfo &I);
392
#endif
393
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
394
bool
395
#if defined(GET_EVAL_IMPL)
396
EvalEmitter
397
#else
398
ByteCodeEmitter
399
#endif
400
0
::emitAddOffset(PrimType T0, const SourceInfo &I) {
401
0
  switch (T0) {
402
0
  case PT_Sint8:
403
0
    return emitAddOffsetSint8(I);
404
0
  case PT_Uint8:
405
0
    return emitAddOffsetUint8(I);
406
0
  case PT_Sint16:
407
0
    return emitAddOffsetSint16(I);
408
0
  case PT_Uint16:
409
0
    return emitAddOffsetUint16(I);
410
0
  case PT_Sint32:
411
0
    return emitAddOffsetSint32(I);
412
0
  case PT_Uint32:
413
0
    return emitAddOffsetUint32(I);
414
0
  case PT_Sint64:
415
0
    return emitAddOffsetSint64(I);
416
0
  case PT_Uint64:
417
0
    return emitAddOffsetUint64(I);
418
0
  case PT_IntAP:
419
0
    return emitAddOffsetIntAP(I);
420
0
  case PT_IntAPS:
421
0
    return emitAddOffsetIntAPS(I);
422
0
  case PT_Bool:
423
0
    return emitAddOffsetBool(I);
424
0
  default: llvm_unreachable("invalid type: emitAddOffset");
425
0
  }
426
0
  llvm_unreachable("invalid enum value");
427
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitAddOffset(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitAddOffset(clang::interp::PrimType, clang::interp::SourceInfo const&)
428
#endif
429
#ifdef GET_LINK_IMPL
430
0
bool ByteCodeEmitter::emitAddOffsetSint8(const SourceInfo &L) {
431
0
  return emitOp<>(OP_AddOffsetSint8, L);
432
0
}
433
0
bool ByteCodeEmitter::emitAddOffsetUint8(const SourceInfo &L) {
434
0
  return emitOp<>(OP_AddOffsetUint8, L);
435
0
}
436
0
bool ByteCodeEmitter::emitAddOffsetSint16(const SourceInfo &L) {
437
0
  return emitOp<>(OP_AddOffsetSint16, L);
438
0
}
439
0
bool ByteCodeEmitter::emitAddOffsetUint16(const SourceInfo &L) {
440
0
  return emitOp<>(OP_AddOffsetUint16, L);
441
0
}
442
0
bool ByteCodeEmitter::emitAddOffsetSint32(const SourceInfo &L) {
443
0
  return emitOp<>(OP_AddOffsetSint32, L);
444
0
}
445
0
bool ByteCodeEmitter::emitAddOffsetUint32(const SourceInfo &L) {
446
0
  return emitOp<>(OP_AddOffsetUint32, L);
447
0
}
448
0
bool ByteCodeEmitter::emitAddOffsetSint64(const SourceInfo &L) {
449
0
  return emitOp<>(OP_AddOffsetSint64, L);
450
0
}
451
0
bool ByteCodeEmitter::emitAddOffsetUint64(const SourceInfo &L) {
452
0
  return emitOp<>(OP_AddOffsetUint64, L);
453
0
}
454
0
bool ByteCodeEmitter::emitAddOffsetIntAP(const SourceInfo &L) {
455
0
  return emitOp<>(OP_AddOffsetIntAP, L);
456
0
}
457
0
bool ByteCodeEmitter::emitAddOffsetIntAPS(const SourceInfo &L) {
458
0
  return emitOp<>(OP_AddOffsetIntAPS, L);
459
0
}
460
0
bool ByteCodeEmitter::emitAddOffsetBool(const SourceInfo &L) {
461
0
  return emitOp<>(OP_AddOffsetBool, L);
462
0
}
463
#endif
464
#ifdef GET_EVAL_IMPL
465
0
bool EvalEmitter::emitAddOffsetSint8(const SourceInfo &L) {
466
0
  if (!isActive()) return true;
467
0
  CurrentSource = L;
468
0
  return AddOffset<PT_Sint8>(S, OpPC);
469
0
}
470
0
bool EvalEmitter::emitAddOffsetUint8(const SourceInfo &L) {
471
0
  if (!isActive()) return true;
472
0
  CurrentSource = L;
473
0
  return AddOffset<PT_Uint8>(S, OpPC);
474
0
}
475
0
bool EvalEmitter::emitAddOffsetSint16(const SourceInfo &L) {
476
0
  if (!isActive()) return true;
477
0
  CurrentSource = L;
478
0
  return AddOffset<PT_Sint16>(S, OpPC);
479
0
}
480
0
bool EvalEmitter::emitAddOffsetUint16(const SourceInfo &L) {
481
0
  if (!isActive()) return true;
482
0
  CurrentSource = L;
483
0
  return AddOffset<PT_Uint16>(S, OpPC);
484
0
}
485
0
bool EvalEmitter::emitAddOffsetSint32(const SourceInfo &L) {
486
0
  if (!isActive()) return true;
487
0
  CurrentSource = L;
488
0
  return AddOffset<PT_Sint32>(S, OpPC);
489
0
}
490
0
bool EvalEmitter::emitAddOffsetUint32(const SourceInfo &L) {
491
0
  if (!isActive()) return true;
492
0
  CurrentSource = L;
493
0
  return AddOffset<PT_Uint32>(S, OpPC);
494
0
}
495
0
bool EvalEmitter::emitAddOffsetSint64(const SourceInfo &L) {
496
0
  if (!isActive()) return true;
497
0
  CurrentSource = L;
498
0
  return AddOffset<PT_Sint64>(S, OpPC);
499
0
}
500
0
bool EvalEmitter::emitAddOffsetUint64(const SourceInfo &L) {
501
0
  if (!isActive()) return true;
502
0
  CurrentSource = L;
503
0
  return AddOffset<PT_Uint64>(S, OpPC);
504
0
}
505
0
bool EvalEmitter::emitAddOffsetIntAP(const SourceInfo &L) {
506
0
  if (!isActive()) return true;
507
0
  CurrentSource = L;
508
0
  return AddOffset<PT_IntAP>(S, OpPC);
509
0
}
510
0
bool EvalEmitter::emitAddOffsetIntAPS(const SourceInfo &L) {
511
0
  if (!isActive()) return true;
512
0
  CurrentSource = L;
513
0
  return AddOffset<PT_IntAPS>(S, OpPC);
514
0
}
515
0
bool EvalEmitter::emitAddOffsetBool(const SourceInfo &L) {
516
0
  if (!isActive()) return true;
517
0
  CurrentSource = L;
518
0
  return AddOffset<PT_Bool>(S, OpPC);
519
0
}
520
#endif
521
#ifdef GET_OPCODE_NAMES
522
OP_Addf,
523
#endif
524
0
#ifdef GET_INTERP
525
0
case OP_Addf: {
526
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
527
0
  if (!Addf(S, OpPC, V0))
528
0
    return false;
529
0
  continue;
530
0
}
531
0
#endif
532
#ifdef GET_DISASM
533
case OP_Addf:
534
  PrintName("Addf");
535
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
536
  continue;
537
#endif
538
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
539
bool emitAddf(llvm::RoundingMode, const SourceInfo &);
540
#endif
541
#ifdef GET_LINK_IMPL
542
0
bool ByteCodeEmitter::emitAddf(llvm::RoundingMode A0, const SourceInfo &L) {
543
0
  return emitOp<llvm::RoundingMode>(OP_Addf, A0, L);
544
0
}
545
#endif
546
#ifdef GET_EVAL_IMPL
547
0
bool EvalEmitter::emitAddf(llvm::RoundingMode A0, const SourceInfo &L) {
548
0
  if (!isActive()) return true;
549
0
  CurrentSource = L;
550
0
  return Addf(S, OpPC, A0);
551
0
}
552
#endif
553
#ifdef GET_OPCODE_NAMES
554
OP_ArrayDecay,
555
#endif
556
0
#ifdef GET_INTERP
557
0
case OP_ArrayDecay: {
558
0
  if (!ArrayDecay(S, OpPC))
559
0
    return false;
560
0
  continue;
561
0
}
562
0
#endif
563
#ifdef GET_DISASM
564
case OP_ArrayDecay:
565
  PrintName("ArrayDecay");
566
  OS << "\t" << "\n";
567
  continue;
568
#endif
569
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
570
bool emitArrayDecay(const SourceInfo &);
571
#endif
572
#ifdef GET_LINK_IMPL
573
0
bool ByteCodeEmitter::emitArrayDecay(const SourceInfo &L) {
574
0
  return emitOp<>(OP_ArrayDecay, L);
575
0
}
576
#endif
577
#ifdef GET_EVAL_IMPL
578
0
bool EvalEmitter::emitArrayDecay(const SourceInfo &L) {
579
0
  if (!isActive()) return true;
580
0
  CurrentSource = L;
581
0
  return ArrayDecay(S, OpPC);
582
0
}
583
#endif
584
#ifdef GET_OPCODE_NAMES
585
OP_ArrayElemPtrSint8,
586
OP_ArrayElemPtrUint8,
587
OP_ArrayElemPtrSint16,
588
OP_ArrayElemPtrUint16,
589
OP_ArrayElemPtrSint32,
590
OP_ArrayElemPtrUint32,
591
OP_ArrayElemPtrSint64,
592
OP_ArrayElemPtrUint64,
593
OP_ArrayElemPtrIntAP,
594
OP_ArrayElemPtrIntAPS,
595
OP_ArrayElemPtrBool,
596
#endif
597
0
#ifdef GET_INTERP
598
0
case OP_ArrayElemPtrSint8: {
599
0
  if (!ArrayElemPtr<PT_Sint8>(S, OpPC))
600
0
    return false;
601
0
  continue;
602
0
}
603
0
case OP_ArrayElemPtrUint8: {
604
0
  if (!ArrayElemPtr<PT_Uint8>(S, OpPC))
605
0
    return false;
606
0
  continue;
607
0
}
608
0
case OP_ArrayElemPtrSint16: {
609
0
  if (!ArrayElemPtr<PT_Sint16>(S, OpPC))
610
0
    return false;
611
0
  continue;
612
0
}
613
0
case OP_ArrayElemPtrUint16: {
614
0
  if (!ArrayElemPtr<PT_Uint16>(S, OpPC))
615
0
    return false;
616
0
  continue;
617
0
}
618
0
case OP_ArrayElemPtrSint32: {
619
0
  if (!ArrayElemPtr<PT_Sint32>(S, OpPC))
620
0
    return false;
621
0
  continue;
622
0
}
623
0
case OP_ArrayElemPtrUint32: {
624
0
  if (!ArrayElemPtr<PT_Uint32>(S, OpPC))
625
0
    return false;
626
0
  continue;
627
0
}
628
0
case OP_ArrayElemPtrSint64: {
629
0
  if (!ArrayElemPtr<PT_Sint64>(S, OpPC))
630
0
    return false;
631
0
  continue;
632
0
}
633
0
case OP_ArrayElemPtrUint64: {
634
0
  if (!ArrayElemPtr<PT_Uint64>(S, OpPC))
635
0
    return false;
636
0
  continue;
637
0
}
638
0
case OP_ArrayElemPtrIntAP: {
639
0
  if (!ArrayElemPtr<PT_IntAP>(S, OpPC))
640
0
    return false;
641
0
  continue;
642
0
}
643
0
case OP_ArrayElemPtrIntAPS: {
644
0
  if (!ArrayElemPtr<PT_IntAPS>(S, OpPC))
645
0
    return false;
646
0
  continue;
647
0
}
648
0
case OP_ArrayElemPtrBool: {
649
0
  if (!ArrayElemPtr<PT_Bool>(S, OpPC))
650
0
    return false;
651
0
  continue;
652
0
}
653
0
#endif
654
#ifdef GET_DISASM
655
case OP_ArrayElemPtrSint8:
656
  PrintName("ArrayElemPtrSint8");
657
  OS << "\t" << "\n";
658
  continue;
659
case OP_ArrayElemPtrUint8:
660
  PrintName("ArrayElemPtrUint8");
661
  OS << "\t" << "\n";
662
  continue;
663
case OP_ArrayElemPtrSint16:
664
  PrintName("ArrayElemPtrSint16");
665
  OS << "\t" << "\n";
666
  continue;
667
case OP_ArrayElemPtrUint16:
668
  PrintName("ArrayElemPtrUint16");
669
  OS << "\t" << "\n";
670
  continue;
671
case OP_ArrayElemPtrSint32:
672
  PrintName("ArrayElemPtrSint32");
673
  OS << "\t" << "\n";
674
  continue;
675
case OP_ArrayElemPtrUint32:
676
  PrintName("ArrayElemPtrUint32");
677
  OS << "\t" << "\n";
678
  continue;
679
case OP_ArrayElemPtrSint64:
680
  PrintName("ArrayElemPtrSint64");
681
  OS << "\t" << "\n";
682
  continue;
683
case OP_ArrayElemPtrUint64:
684
  PrintName("ArrayElemPtrUint64");
685
  OS << "\t" << "\n";
686
  continue;
687
case OP_ArrayElemPtrIntAP:
688
  PrintName("ArrayElemPtrIntAP");
689
  OS << "\t" << "\n";
690
  continue;
691
case OP_ArrayElemPtrIntAPS:
692
  PrintName("ArrayElemPtrIntAPS");
693
  OS << "\t" << "\n";
694
  continue;
695
case OP_ArrayElemPtrBool:
696
  PrintName("ArrayElemPtrBool");
697
  OS << "\t" << "\n";
698
  continue;
699
#endif
700
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
701
bool emitArrayElemPtrSint8(const SourceInfo &);
702
bool emitArrayElemPtrUint8(const SourceInfo &);
703
bool emitArrayElemPtrSint16(const SourceInfo &);
704
bool emitArrayElemPtrUint16(const SourceInfo &);
705
bool emitArrayElemPtrSint32(const SourceInfo &);
706
bool emitArrayElemPtrUint32(const SourceInfo &);
707
bool emitArrayElemPtrSint64(const SourceInfo &);
708
bool emitArrayElemPtrUint64(const SourceInfo &);
709
bool emitArrayElemPtrIntAP(const SourceInfo &);
710
bool emitArrayElemPtrIntAPS(const SourceInfo &);
711
bool emitArrayElemPtrBool(const SourceInfo &);
712
#endif
713
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
714
bool emitArrayElemPtr(PrimType, const SourceInfo &I);
715
#endif
716
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
717
bool
718
#if defined(GET_EVAL_IMPL)
719
EvalEmitter
720
#else
721
ByteCodeEmitter
722
#endif
723
0
::emitArrayElemPtr(PrimType T0, const SourceInfo &I) {
724
0
  switch (T0) {
725
0
  case PT_Sint8:
726
0
    return emitArrayElemPtrSint8(I);
727
0
  case PT_Uint8:
728
0
    return emitArrayElemPtrUint8(I);
729
0
  case PT_Sint16:
730
0
    return emitArrayElemPtrSint16(I);
731
0
  case PT_Uint16:
732
0
    return emitArrayElemPtrUint16(I);
733
0
  case PT_Sint32:
734
0
    return emitArrayElemPtrSint32(I);
735
0
  case PT_Uint32:
736
0
    return emitArrayElemPtrUint32(I);
737
0
  case PT_Sint64:
738
0
    return emitArrayElemPtrSint64(I);
739
0
  case PT_Uint64:
740
0
    return emitArrayElemPtrUint64(I);
741
0
  case PT_IntAP:
742
0
    return emitArrayElemPtrIntAP(I);
743
0
  case PT_IntAPS:
744
0
    return emitArrayElemPtrIntAPS(I);
745
0
  case PT_Bool:
746
0
    return emitArrayElemPtrBool(I);
747
0
  default: llvm_unreachable("invalid type: emitArrayElemPtr");
748
0
  }
749
0
  llvm_unreachable("invalid enum value");
750
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitArrayElemPtr(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitArrayElemPtr(clang::interp::PrimType, clang::interp::SourceInfo const&)
751
#endif
752
#ifdef GET_LINK_IMPL
753
0
bool ByteCodeEmitter::emitArrayElemPtrSint8(const SourceInfo &L) {
754
0
  return emitOp<>(OP_ArrayElemPtrSint8, L);
755
0
}
756
0
bool ByteCodeEmitter::emitArrayElemPtrUint8(const SourceInfo &L) {
757
0
  return emitOp<>(OP_ArrayElemPtrUint8, L);
758
0
}
759
0
bool ByteCodeEmitter::emitArrayElemPtrSint16(const SourceInfo &L) {
760
0
  return emitOp<>(OP_ArrayElemPtrSint16, L);
761
0
}
762
0
bool ByteCodeEmitter::emitArrayElemPtrUint16(const SourceInfo &L) {
763
0
  return emitOp<>(OP_ArrayElemPtrUint16, L);
764
0
}
765
0
bool ByteCodeEmitter::emitArrayElemPtrSint32(const SourceInfo &L) {
766
0
  return emitOp<>(OP_ArrayElemPtrSint32, L);
767
0
}
768
0
bool ByteCodeEmitter::emitArrayElemPtrUint32(const SourceInfo &L) {
769
0
  return emitOp<>(OP_ArrayElemPtrUint32, L);
770
0
}
771
0
bool ByteCodeEmitter::emitArrayElemPtrSint64(const SourceInfo &L) {
772
0
  return emitOp<>(OP_ArrayElemPtrSint64, L);
773
0
}
774
0
bool ByteCodeEmitter::emitArrayElemPtrUint64(const SourceInfo &L) {
775
0
  return emitOp<>(OP_ArrayElemPtrUint64, L);
776
0
}
777
0
bool ByteCodeEmitter::emitArrayElemPtrIntAP(const SourceInfo &L) {
778
0
  return emitOp<>(OP_ArrayElemPtrIntAP, L);
779
0
}
780
0
bool ByteCodeEmitter::emitArrayElemPtrIntAPS(const SourceInfo &L) {
781
0
  return emitOp<>(OP_ArrayElemPtrIntAPS, L);
782
0
}
783
0
bool ByteCodeEmitter::emitArrayElemPtrBool(const SourceInfo &L) {
784
0
  return emitOp<>(OP_ArrayElemPtrBool, L);
785
0
}
786
#endif
787
#ifdef GET_EVAL_IMPL
788
0
bool EvalEmitter::emitArrayElemPtrSint8(const SourceInfo &L) {
789
0
  if (!isActive()) return true;
790
0
  CurrentSource = L;
791
0
  return ArrayElemPtr<PT_Sint8>(S, OpPC);
792
0
}
793
0
bool EvalEmitter::emitArrayElemPtrUint8(const SourceInfo &L) {
794
0
  if (!isActive()) return true;
795
0
  CurrentSource = L;
796
0
  return ArrayElemPtr<PT_Uint8>(S, OpPC);
797
0
}
798
0
bool EvalEmitter::emitArrayElemPtrSint16(const SourceInfo &L) {
799
0
  if (!isActive()) return true;
800
0
  CurrentSource = L;
801
0
  return ArrayElemPtr<PT_Sint16>(S, OpPC);
802
0
}
803
0
bool EvalEmitter::emitArrayElemPtrUint16(const SourceInfo &L) {
804
0
  if (!isActive()) return true;
805
0
  CurrentSource = L;
806
0
  return ArrayElemPtr<PT_Uint16>(S, OpPC);
807
0
}
808
0
bool EvalEmitter::emitArrayElemPtrSint32(const SourceInfo &L) {
809
0
  if (!isActive()) return true;
810
0
  CurrentSource = L;
811
0
  return ArrayElemPtr<PT_Sint32>(S, OpPC);
812
0
}
813
0
bool EvalEmitter::emitArrayElemPtrUint32(const SourceInfo &L) {
814
0
  if (!isActive()) return true;
815
0
  CurrentSource = L;
816
0
  return ArrayElemPtr<PT_Uint32>(S, OpPC);
817
0
}
818
0
bool EvalEmitter::emitArrayElemPtrSint64(const SourceInfo &L) {
819
0
  if (!isActive()) return true;
820
0
  CurrentSource = L;
821
0
  return ArrayElemPtr<PT_Sint64>(S, OpPC);
822
0
}
823
0
bool EvalEmitter::emitArrayElemPtrUint64(const SourceInfo &L) {
824
0
  if (!isActive()) return true;
825
0
  CurrentSource = L;
826
0
  return ArrayElemPtr<PT_Uint64>(S, OpPC);
827
0
}
828
0
bool EvalEmitter::emitArrayElemPtrIntAP(const SourceInfo &L) {
829
0
  if (!isActive()) return true;
830
0
  CurrentSource = L;
831
0
  return ArrayElemPtr<PT_IntAP>(S, OpPC);
832
0
}
833
0
bool EvalEmitter::emitArrayElemPtrIntAPS(const SourceInfo &L) {
834
0
  if (!isActive()) return true;
835
0
  CurrentSource = L;
836
0
  return ArrayElemPtr<PT_IntAPS>(S, OpPC);
837
0
}
838
0
bool EvalEmitter::emitArrayElemPtrBool(const SourceInfo &L) {
839
0
  if (!isActive()) return true;
840
0
  CurrentSource = L;
841
0
  return ArrayElemPtr<PT_Bool>(S, OpPC);
842
0
}
843
#endif
844
#ifdef GET_OPCODE_NAMES
845
OP_ArrayElemPtrPopSint8,
846
OP_ArrayElemPtrPopUint8,
847
OP_ArrayElemPtrPopSint16,
848
OP_ArrayElemPtrPopUint16,
849
OP_ArrayElemPtrPopSint32,
850
OP_ArrayElemPtrPopUint32,
851
OP_ArrayElemPtrPopSint64,
852
OP_ArrayElemPtrPopUint64,
853
OP_ArrayElemPtrPopIntAP,
854
OP_ArrayElemPtrPopIntAPS,
855
OP_ArrayElemPtrPopBool,
856
#endif
857
0
#ifdef GET_INTERP
858
0
case OP_ArrayElemPtrPopSint8: {
859
0
  if (!ArrayElemPtrPop<PT_Sint8>(S, OpPC))
860
0
    return false;
861
0
  continue;
862
0
}
863
0
case OP_ArrayElemPtrPopUint8: {
864
0
  if (!ArrayElemPtrPop<PT_Uint8>(S, OpPC))
865
0
    return false;
866
0
  continue;
867
0
}
868
0
case OP_ArrayElemPtrPopSint16: {
869
0
  if (!ArrayElemPtrPop<PT_Sint16>(S, OpPC))
870
0
    return false;
871
0
  continue;
872
0
}
873
0
case OP_ArrayElemPtrPopUint16: {
874
0
  if (!ArrayElemPtrPop<PT_Uint16>(S, OpPC))
875
0
    return false;
876
0
  continue;
877
0
}
878
0
case OP_ArrayElemPtrPopSint32: {
879
0
  if (!ArrayElemPtrPop<PT_Sint32>(S, OpPC))
880
0
    return false;
881
0
  continue;
882
0
}
883
0
case OP_ArrayElemPtrPopUint32: {
884
0
  if (!ArrayElemPtrPop<PT_Uint32>(S, OpPC))
885
0
    return false;
886
0
  continue;
887
0
}
888
0
case OP_ArrayElemPtrPopSint64: {
889
0
  if (!ArrayElemPtrPop<PT_Sint64>(S, OpPC))
890
0
    return false;
891
0
  continue;
892
0
}
893
0
case OP_ArrayElemPtrPopUint64: {
894
0
  if (!ArrayElemPtrPop<PT_Uint64>(S, OpPC))
895
0
    return false;
896
0
  continue;
897
0
}
898
0
case OP_ArrayElemPtrPopIntAP: {
899
0
  if (!ArrayElemPtrPop<PT_IntAP>(S, OpPC))
900
0
    return false;
901
0
  continue;
902
0
}
903
0
case OP_ArrayElemPtrPopIntAPS: {
904
0
  if (!ArrayElemPtrPop<PT_IntAPS>(S, OpPC))
905
0
    return false;
906
0
  continue;
907
0
}
908
0
case OP_ArrayElemPtrPopBool: {
909
0
  if (!ArrayElemPtrPop<PT_Bool>(S, OpPC))
910
0
    return false;
911
0
  continue;
912
0
}
913
0
#endif
914
#ifdef GET_DISASM
915
case OP_ArrayElemPtrPopSint8:
916
  PrintName("ArrayElemPtrPopSint8");
917
  OS << "\t" << "\n";
918
  continue;
919
case OP_ArrayElemPtrPopUint8:
920
  PrintName("ArrayElemPtrPopUint8");
921
  OS << "\t" << "\n";
922
  continue;
923
case OP_ArrayElemPtrPopSint16:
924
  PrintName("ArrayElemPtrPopSint16");
925
  OS << "\t" << "\n";
926
  continue;
927
case OP_ArrayElemPtrPopUint16:
928
  PrintName("ArrayElemPtrPopUint16");
929
  OS << "\t" << "\n";
930
  continue;
931
case OP_ArrayElemPtrPopSint32:
932
  PrintName("ArrayElemPtrPopSint32");
933
  OS << "\t" << "\n";
934
  continue;
935
case OP_ArrayElemPtrPopUint32:
936
  PrintName("ArrayElemPtrPopUint32");
937
  OS << "\t" << "\n";
938
  continue;
939
case OP_ArrayElemPtrPopSint64:
940
  PrintName("ArrayElemPtrPopSint64");
941
  OS << "\t" << "\n";
942
  continue;
943
case OP_ArrayElemPtrPopUint64:
944
  PrintName("ArrayElemPtrPopUint64");
945
  OS << "\t" << "\n";
946
  continue;
947
case OP_ArrayElemPtrPopIntAP:
948
  PrintName("ArrayElemPtrPopIntAP");
949
  OS << "\t" << "\n";
950
  continue;
951
case OP_ArrayElemPtrPopIntAPS:
952
  PrintName("ArrayElemPtrPopIntAPS");
953
  OS << "\t" << "\n";
954
  continue;
955
case OP_ArrayElemPtrPopBool:
956
  PrintName("ArrayElemPtrPopBool");
957
  OS << "\t" << "\n";
958
  continue;
959
#endif
960
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
961
bool emitArrayElemPtrPopSint8(const SourceInfo &);
962
bool emitArrayElemPtrPopUint8(const SourceInfo &);
963
bool emitArrayElemPtrPopSint16(const SourceInfo &);
964
bool emitArrayElemPtrPopUint16(const SourceInfo &);
965
bool emitArrayElemPtrPopSint32(const SourceInfo &);
966
bool emitArrayElemPtrPopUint32(const SourceInfo &);
967
bool emitArrayElemPtrPopSint64(const SourceInfo &);
968
bool emitArrayElemPtrPopUint64(const SourceInfo &);
969
bool emitArrayElemPtrPopIntAP(const SourceInfo &);
970
bool emitArrayElemPtrPopIntAPS(const SourceInfo &);
971
bool emitArrayElemPtrPopBool(const SourceInfo &);
972
#endif
973
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
974
bool emitArrayElemPtrPop(PrimType, const SourceInfo &I);
975
#endif
976
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
977
bool
978
#if defined(GET_EVAL_IMPL)
979
EvalEmitter
980
#else
981
ByteCodeEmitter
982
#endif
983
0
::emitArrayElemPtrPop(PrimType T0, const SourceInfo &I) {
984
0
  switch (T0) {
985
0
  case PT_Sint8:
986
0
    return emitArrayElemPtrPopSint8(I);
987
0
  case PT_Uint8:
988
0
    return emitArrayElemPtrPopUint8(I);
989
0
  case PT_Sint16:
990
0
    return emitArrayElemPtrPopSint16(I);
991
0
  case PT_Uint16:
992
0
    return emitArrayElemPtrPopUint16(I);
993
0
  case PT_Sint32:
994
0
    return emitArrayElemPtrPopSint32(I);
995
0
  case PT_Uint32:
996
0
    return emitArrayElemPtrPopUint32(I);
997
0
  case PT_Sint64:
998
0
    return emitArrayElemPtrPopSint64(I);
999
0
  case PT_Uint64:
1000
0
    return emitArrayElemPtrPopUint64(I);
1001
0
  case PT_IntAP:
1002
0
    return emitArrayElemPtrPopIntAP(I);
1003
0
  case PT_IntAPS:
1004
0
    return emitArrayElemPtrPopIntAPS(I);
1005
0
  case PT_Bool:
1006
0
    return emitArrayElemPtrPopBool(I);
1007
0
  default: llvm_unreachable("invalid type: emitArrayElemPtrPop");
1008
0
  }
1009
0
  llvm_unreachable("invalid enum value");
1010
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitArrayElemPtrPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitArrayElemPtrPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
1011
#endif
1012
#ifdef GET_LINK_IMPL
1013
0
bool ByteCodeEmitter::emitArrayElemPtrPopSint8(const SourceInfo &L) {
1014
0
  return emitOp<>(OP_ArrayElemPtrPopSint8, L);
1015
0
}
1016
0
bool ByteCodeEmitter::emitArrayElemPtrPopUint8(const SourceInfo &L) {
1017
0
  return emitOp<>(OP_ArrayElemPtrPopUint8, L);
1018
0
}
1019
0
bool ByteCodeEmitter::emitArrayElemPtrPopSint16(const SourceInfo &L) {
1020
0
  return emitOp<>(OP_ArrayElemPtrPopSint16, L);
1021
0
}
1022
0
bool ByteCodeEmitter::emitArrayElemPtrPopUint16(const SourceInfo &L) {
1023
0
  return emitOp<>(OP_ArrayElemPtrPopUint16, L);
1024
0
}
1025
0
bool ByteCodeEmitter::emitArrayElemPtrPopSint32(const SourceInfo &L) {
1026
0
  return emitOp<>(OP_ArrayElemPtrPopSint32, L);
1027
0
}
1028
0
bool ByteCodeEmitter::emitArrayElemPtrPopUint32(const SourceInfo &L) {
1029
0
  return emitOp<>(OP_ArrayElemPtrPopUint32, L);
1030
0
}
1031
0
bool ByteCodeEmitter::emitArrayElemPtrPopSint64(const SourceInfo &L) {
1032
0
  return emitOp<>(OP_ArrayElemPtrPopSint64, L);
1033
0
}
1034
0
bool ByteCodeEmitter::emitArrayElemPtrPopUint64(const SourceInfo &L) {
1035
0
  return emitOp<>(OP_ArrayElemPtrPopUint64, L);
1036
0
}
1037
0
bool ByteCodeEmitter::emitArrayElemPtrPopIntAP(const SourceInfo &L) {
1038
0
  return emitOp<>(OP_ArrayElemPtrPopIntAP, L);
1039
0
}
1040
0
bool ByteCodeEmitter::emitArrayElemPtrPopIntAPS(const SourceInfo &L) {
1041
0
  return emitOp<>(OP_ArrayElemPtrPopIntAPS, L);
1042
0
}
1043
0
bool ByteCodeEmitter::emitArrayElemPtrPopBool(const SourceInfo &L) {
1044
0
  return emitOp<>(OP_ArrayElemPtrPopBool, L);
1045
0
}
1046
#endif
1047
#ifdef GET_EVAL_IMPL
1048
0
bool EvalEmitter::emitArrayElemPtrPopSint8(const SourceInfo &L) {
1049
0
  if (!isActive()) return true;
1050
0
  CurrentSource = L;
1051
0
  return ArrayElemPtrPop<PT_Sint8>(S, OpPC);
1052
0
}
1053
0
bool EvalEmitter::emitArrayElemPtrPopUint8(const SourceInfo &L) {
1054
0
  if (!isActive()) return true;
1055
0
  CurrentSource = L;
1056
0
  return ArrayElemPtrPop<PT_Uint8>(S, OpPC);
1057
0
}
1058
0
bool EvalEmitter::emitArrayElemPtrPopSint16(const SourceInfo &L) {
1059
0
  if (!isActive()) return true;
1060
0
  CurrentSource = L;
1061
0
  return ArrayElemPtrPop<PT_Sint16>(S, OpPC);
1062
0
}
1063
0
bool EvalEmitter::emitArrayElemPtrPopUint16(const SourceInfo &L) {
1064
0
  if (!isActive()) return true;
1065
0
  CurrentSource = L;
1066
0
  return ArrayElemPtrPop<PT_Uint16>(S, OpPC);
1067
0
}
1068
0
bool EvalEmitter::emitArrayElemPtrPopSint32(const SourceInfo &L) {
1069
0
  if (!isActive()) return true;
1070
0
  CurrentSource = L;
1071
0
  return ArrayElemPtrPop<PT_Sint32>(S, OpPC);
1072
0
}
1073
0
bool EvalEmitter::emitArrayElemPtrPopUint32(const SourceInfo &L) {
1074
0
  if (!isActive()) return true;
1075
0
  CurrentSource = L;
1076
0
  return ArrayElemPtrPop<PT_Uint32>(S, OpPC);
1077
0
}
1078
0
bool EvalEmitter::emitArrayElemPtrPopSint64(const SourceInfo &L) {
1079
0
  if (!isActive()) return true;
1080
0
  CurrentSource = L;
1081
0
  return ArrayElemPtrPop<PT_Sint64>(S, OpPC);
1082
0
}
1083
0
bool EvalEmitter::emitArrayElemPtrPopUint64(const SourceInfo &L) {
1084
0
  if (!isActive()) return true;
1085
0
  CurrentSource = L;
1086
0
  return ArrayElemPtrPop<PT_Uint64>(S, OpPC);
1087
0
}
1088
0
bool EvalEmitter::emitArrayElemPtrPopIntAP(const SourceInfo &L) {
1089
0
  if (!isActive()) return true;
1090
0
  CurrentSource = L;
1091
0
  return ArrayElemPtrPop<PT_IntAP>(S, OpPC);
1092
0
}
1093
0
bool EvalEmitter::emitArrayElemPtrPopIntAPS(const SourceInfo &L) {
1094
0
  if (!isActive()) return true;
1095
0
  CurrentSource = L;
1096
0
  return ArrayElemPtrPop<PT_IntAPS>(S, OpPC);
1097
0
}
1098
0
bool EvalEmitter::emitArrayElemPtrPopBool(const SourceInfo &L) {
1099
0
  if (!isActive()) return true;
1100
0
  CurrentSource = L;
1101
0
  return ArrayElemPtrPop<PT_Bool>(S, OpPC);
1102
0
}
1103
#endif
1104
#ifdef GET_OPCODE_NAMES
1105
OP_BitAndSint8,
1106
OP_BitAndUint8,
1107
OP_BitAndSint16,
1108
OP_BitAndUint16,
1109
OP_BitAndSint32,
1110
OP_BitAndUint32,
1111
OP_BitAndSint64,
1112
OP_BitAndUint64,
1113
OP_BitAndIntAP,
1114
OP_BitAndIntAPS,
1115
#endif
1116
0
#ifdef GET_INTERP
1117
0
case OP_BitAndSint8: {
1118
0
  if (!BitAnd<PT_Sint8>(S, OpPC))
1119
0
    return false;
1120
0
  continue;
1121
0
}
1122
0
case OP_BitAndUint8: {
1123
0
  if (!BitAnd<PT_Uint8>(S, OpPC))
1124
0
    return false;
1125
0
  continue;
1126
0
}
1127
0
case OP_BitAndSint16: {
1128
0
  if (!BitAnd<PT_Sint16>(S, OpPC))
1129
0
    return false;
1130
0
  continue;
1131
0
}
1132
0
case OP_BitAndUint16: {
1133
0
  if (!BitAnd<PT_Uint16>(S, OpPC))
1134
0
    return false;
1135
0
  continue;
1136
0
}
1137
0
case OP_BitAndSint32: {
1138
0
  if (!BitAnd<PT_Sint32>(S, OpPC))
1139
0
    return false;
1140
0
  continue;
1141
0
}
1142
0
case OP_BitAndUint32: {
1143
0
  if (!BitAnd<PT_Uint32>(S, OpPC))
1144
0
    return false;
1145
0
  continue;
1146
0
}
1147
0
case OP_BitAndSint64: {
1148
0
  if (!BitAnd<PT_Sint64>(S, OpPC))
1149
0
    return false;
1150
0
  continue;
1151
0
}
1152
0
case OP_BitAndUint64: {
1153
0
  if (!BitAnd<PT_Uint64>(S, OpPC))
1154
0
    return false;
1155
0
  continue;
1156
0
}
1157
0
case OP_BitAndIntAP: {
1158
0
  if (!BitAnd<PT_IntAP>(S, OpPC))
1159
0
    return false;
1160
0
  continue;
1161
0
}
1162
0
case OP_BitAndIntAPS: {
1163
0
  if (!BitAnd<PT_IntAPS>(S, OpPC))
1164
0
    return false;
1165
0
  continue;
1166
0
}
1167
0
#endif
1168
#ifdef GET_DISASM
1169
case OP_BitAndSint8:
1170
  PrintName("BitAndSint8");
1171
  OS << "\t" << "\n";
1172
  continue;
1173
case OP_BitAndUint8:
1174
  PrintName("BitAndUint8");
1175
  OS << "\t" << "\n";
1176
  continue;
1177
case OP_BitAndSint16:
1178
  PrintName("BitAndSint16");
1179
  OS << "\t" << "\n";
1180
  continue;
1181
case OP_BitAndUint16:
1182
  PrintName("BitAndUint16");
1183
  OS << "\t" << "\n";
1184
  continue;
1185
case OP_BitAndSint32:
1186
  PrintName("BitAndSint32");
1187
  OS << "\t" << "\n";
1188
  continue;
1189
case OP_BitAndUint32:
1190
  PrintName("BitAndUint32");
1191
  OS << "\t" << "\n";
1192
  continue;
1193
case OP_BitAndSint64:
1194
  PrintName("BitAndSint64");
1195
  OS << "\t" << "\n";
1196
  continue;
1197
case OP_BitAndUint64:
1198
  PrintName("BitAndUint64");
1199
  OS << "\t" << "\n";
1200
  continue;
1201
case OP_BitAndIntAP:
1202
  PrintName("BitAndIntAP");
1203
  OS << "\t" << "\n";
1204
  continue;
1205
case OP_BitAndIntAPS:
1206
  PrintName("BitAndIntAPS");
1207
  OS << "\t" << "\n";
1208
  continue;
1209
#endif
1210
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1211
bool emitBitAndSint8(const SourceInfo &);
1212
bool emitBitAndUint8(const SourceInfo &);
1213
bool emitBitAndSint16(const SourceInfo &);
1214
bool emitBitAndUint16(const SourceInfo &);
1215
bool emitBitAndSint32(const SourceInfo &);
1216
bool emitBitAndUint32(const SourceInfo &);
1217
bool emitBitAndSint64(const SourceInfo &);
1218
bool emitBitAndUint64(const SourceInfo &);
1219
bool emitBitAndIntAP(const SourceInfo &);
1220
bool emitBitAndIntAPS(const SourceInfo &);
1221
#endif
1222
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1223
bool emitBitAnd(PrimType, const SourceInfo &I);
1224
#endif
1225
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
1226
bool
1227
#if defined(GET_EVAL_IMPL)
1228
EvalEmitter
1229
#else
1230
ByteCodeEmitter
1231
#endif
1232
0
::emitBitAnd(PrimType T0, const SourceInfo &I) {
1233
0
  switch (T0) {
1234
0
  case PT_Sint8:
1235
0
    return emitBitAndSint8(I);
1236
0
  case PT_Uint8:
1237
0
    return emitBitAndUint8(I);
1238
0
  case PT_Sint16:
1239
0
    return emitBitAndSint16(I);
1240
0
  case PT_Uint16:
1241
0
    return emitBitAndUint16(I);
1242
0
  case PT_Sint32:
1243
0
    return emitBitAndSint32(I);
1244
0
  case PT_Uint32:
1245
0
    return emitBitAndUint32(I);
1246
0
  case PT_Sint64:
1247
0
    return emitBitAndSint64(I);
1248
0
  case PT_Uint64:
1249
0
    return emitBitAndUint64(I);
1250
0
  case PT_IntAP:
1251
0
    return emitBitAndIntAP(I);
1252
0
  case PT_IntAPS:
1253
0
    return emitBitAndIntAPS(I);
1254
0
  default: llvm_unreachable("invalid type: emitBitAnd");
1255
0
  }
1256
0
  llvm_unreachable("invalid enum value");
1257
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitBitAnd(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitBitAnd(clang::interp::PrimType, clang::interp::SourceInfo const&)
1258
#endif
1259
#ifdef GET_LINK_IMPL
1260
0
bool ByteCodeEmitter::emitBitAndSint8(const SourceInfo &L) {
1261
0
  return emitOp<>(OP_BitAndSint8, L);
1262
0
}
1263
0
bool ByteCodeEmitter::emitBitAndUint8(const SourceInfo &L) {
1264
0
  return emitOp<>(OP_BitAndUint8, L);
1265
0
}
1266
0
bool ByteCodeEmitter::emitBitAndSint16(const SourceInfo &L) {
1267
0
  return emitOp<>(OP_BitAndSint16, L);
1268
0
}
1269
0
bool ByteCodeEmitter::emitBitAndUint16(const SourceInfo &L) {
1270
0
  return emitOp<>(OP_BitAndUint16, L);
1271
0
}
1272
0
bool ByteCodeEmitter::emitBitAndSint32(const SourceInfo &L) {
1273
0
  return emitOp<>(OP_BitAndSint32, L);
1274
0
}
1275
0
bool ByteCodeEmitter::emitBitAndUint32(const SourceInfo &L) {
1276
0
  return emitOp<>(OP_BitAndUint32, L);
1277
0
}
1278
0
bool ByteCodeEmitter::emitBitAndSint64(const SourceInfo &L) {
1279
0
  return emitOp<>(OP_BitAndSint64, L);
1280
0
}
1281
0
bool ByteCodeEmitter::emitBitAndUint64(const SourceInfo &L) {
1282
0
  return emitOp<>(OP_BitAndUint64, L);
1283
0
}
1284
0
bool ByteCodeEmitter::emitBitAndIntAP(const SourceInfo &L) {
1285
0
  return emitOp<>(OP_BitAndIntAP, L);
1286
0
}
1287
0
bool ByteCodeEmitter::emitBitAndIntAPS(const SourceInfo &L) {
1288
0
  return emitOp<>(OP_BitAndIntAPS, L);
1289
0
}
1290
#endif
1291
#ifdef GET_EVAL_IMPL
1292
0
bool EvalEmitter::emitBitAndSint8(const SourceInfo &L) {
1293
0
  if (!isActive()) return true;
1294
0
  CurrentSource = L;
1295
0
  return BitAnd<PT_Sint8>(S, OpPC);
1296
0
}
1297
0
bool EvalEmitter::emitBitAndUint8(const SourceInfo &L) {
1298
0
  if (!isActive()) return true;
1299
0
  CurrentSource = L;
1300
0
  return BitAnd<PT_Uint8>(S, OpPC);
1301
0
}
1302
0
bool EvalEmitter::emitBitAndSint16(const SourceInfo &L) {
1303
0
  if (!isActive()) return true;
1304
0
  CurrentSource = L;
1305
0
  return BitAnd<PT_Sint16>(S, OpPC);
1306
0
}
1307
0
bool EvalEmitter::emitBitAndUint16(const SourceInfo &L) {
1308
0
  if (!isActive()) return true;
1309
0
  CurrentSource = L;
1310
0
  return BitAnd<PT_Uint16>(S, OpPC);
1311
0
}
1312
0
bool EvalEmitter::emitBitAndSint32(const SourceInfo &L) {
1313
0
  if (!isActive()) return true;
1314
0
  CurrentSource = L;
1315
0
  return BitAnd<PT_Sint32>(S, OpPC);
1316
0
}
1317
0
bool EvalEmitter::emitBitAndUint32(const SourceInfo &L) {
1318
0
  if (!isActive()) return true;
1319
0
  CurrentSource = L;
1320
0
  return BitAnd<PT_Uint32>(S, OpPC);
1321
0
}
1322
0
bool EvalEmitter::emitBitAndSint64(const SourceInfo &L) {
1323
0
  if (!isActive()) return true;
1324
0
  CurrentSource = L;
1325
0
  return BitAnd<PT_Sint64>(S, OpPC);
1326
0
}
1327
0
bool EvalEmitter::emitBitAndUint64(const SourceInfo &L) {
1328
0
  if (!isActive()) return true;
1329
0
  CurrentSource = L;
1330
0
  return BitAnd<PT_Uint64>(S, OpPC);
1331
0
}
1332
0
bool EvalEmitter::emitBitAndIntAP(const SourceInfo &L) {
1333
0
  if (!isActive()) return true;
1334
0
  CurrentSource = L;
1335
0
  return BitAnd<PT_IntAP>(S, OpPC);
1336
0
}
1337
0
bool EvalEmitter::emitBitAndIntAPS(const SourceInfo &L) {
1338
0
  if (!isActive()) return true;
1339
0
  CurrentSource = L;
1340
0
  return BitAnd<PT_IntAPS>(S, OpPC);
1341
0
}
1342
#endif
1343
#ifdef GET_OPCODE_NAMES
1344
OP_BitOrSint8,
1345
OP_BitOrUint8,
1346
OP_BitOrSint16,
1347
OP_BitOrUint16,
1348
OP_BitOrSint32,
1349
OP_BitOrUint32,
1350
OP_BitOrSint64,
1351
OP_BitOrUint64,
1352
OP_BitOrIntAP,
1353
OP_BitOrIntAPS,
1354
#endif
1355
0
#ifdef GET_INTERP
1356
0
case OP_BitOrSint8: {
1357
0
  if (!BitOr<PT_Sint8>(S, OpPC))
1358
0
    return false;
1359
0
  continue;
1360
0
}
1361
0
case OP_BitOrUint8: {
1362
0
  if (!BitOr<PT_Uint8>(S, OpPC))
1363
0
    return false;
1364
0
  continue;
1365
0
}
1366
0
case OP_BitOrSint16: {
1367
0
  if (!BitOr<PT_Sint16>(S, OpPC))
1368
0
    return false;
1369
0
  continue;
1370
0
}
1371
0
case OP_BitOrUint16: {
1372
0
  if (!BitOr<PT_Uint16>(S, OpPC))
1373
0
    return false;
1374
0
  continue;
1375
0
}
1376
0
case OP_BitOrSint32: {
1377
0
  if (!BitOr<PT_Sint32>(S, OpPC))
1378
0
    return false;
1379
0
  continue;
1380
0
}
1381
0
case OP_BitOrUint32: {
1382
0
  if (!BitOr<PT_Uint32>(S, OpPC))
1383
0
    return false;
1384
0
  continue;
1385
0
}
1386
0
case OP_BitOrSint64: {
1387
0
  if (!BitOr<PT_Sint64>(S, OpPC))
1388
0
    return false;
1389
0
  continue;
1390
0
}
1391
0
case OP_BitOrUint64: {
1392
0
  if (!BitOr<PT_Uint64>(S, OpPC))
1393
0
    return false;
1394
0
  continue;
1395
0
}
1396
0
case OP_BitOrIntAP: {
1397
0
  if (!BitOr<PT_IntAP>(S, OpPC))
1398
0
    return false;
1399
0
  continue;
1400
0
}
1401
0
case OP_BitOrIntAPS: {
1402
0
  if (!BitOr<PT_IntAPS>(S, OpPC))
1403
0
    return false;
1404
0
  continue;
1405
0
}
1406
0
#endif
1407
#ifdef GET_DISASM
1408
case OP_BitOrSint8:
1409
  PrintName("BitOrSint8");
1410
  OS << "\t" << "\n";
1411
  continue;
1412
case OP_BitOrUint8:
1413
  PrintName("BitOrUint8");
1414
  OS << "\t" << "\n";
1415
  continue;
1416
case OP_BitOrSint16:
1417
  PrintName("BitOrSint16");
1418
  OS << "\t" << "\n";
1419
  continue;
1420
case OP_BitOrUint16:
1421
  PrintName("BitOrUint16");
1422
  OS << "\t" << "\n";
1423
  continue;
1424
case OP_BitOrSint32:
1425
  PrintName("BitOrSint32");
1426
  OS << "\t" << "\n";
1427
  continue;
1428
case OP_BitOrUint32:
1429
  PrintName("BitOrUint32");
1430
  OS << "\t" << "\n";
1431
  continue;
1432
case OP_BitOrSint64:
1433
  PrintName("BitOrSint64");
1434
  OS << "\t" << "\n";
1435
  continue;
1436
case OP_BitOrUint64:
1437
  PrintName("BitOrUint64");
1438
  OS << "\t" << "\n";
1439
  continue;
1440
case OP_BitOrIntAP:
1441
  PrintName("BitOrIntAP");
1442
  OS << "\t" << "\n";
1443
  continue;
1444
case OP_BitOrIntAPS:
1445
  PrintName("BitOrIntAPS");
1446
  OS << "\t" << "\n";
1447
  continue;
1448
#endif
1449
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1450
bool emitBitOrSint8(const SourceInfo &);
1451
bool emitBitOrUint8(const SourceInfo &);
1452
bool emitBitOrSint16(const SourceInfo &);
1453
bool emitBitOrUint16(const SourceInfo &);
1454
bool emitBitOrSint32(const SourceInfo &);
1455
bool emitBitOrUint32(const SourceInfo &);
1456
bool emitBitOrSint64(const SourceInfo &);
1457
bool emitBitOrUint64(const SourceInfo &);
1458
bool emitBitOrIntAP(const SourceInfo &);
1459
bool emitBitOrIntAPS(const SourceInfo &);
1460
#endif
1461
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1462
bool emitBitOr(PrimType, const SourceInfo &I);
1463
#endif
1464
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
1465
bool
1466
#if defined(GET_EVAL_IMPL)
1467
EvalEmitter
1468
#else
1469
ByteCodeEmitter
1470
#endif
1471
0
::emitBitOr(PrimType T0, const SourceInfo &I) {
1472
0
  switch (T0) {
1473
0
  case PT_Sint8:
1474
0
    return emitBitOrSint8(I);
1475
0
  case PT_Uint8:
1476
0
    return emitBitOrUint8(I);
1477
0
  case PT_Sint16:
1478
0
    return emitBitOrSint16(I);
1479
0
  case PT_Uint16:
1480
0
    return emitBitOrUint16(I);
1481
0
  case PT_Sint32:
1482
0
    return emitBitOrSint32(I);
1483
0
  case PT_Uint32:
1484
0
    return emitBitOrUint32(I);
1485
0
  case PT_Sint64:
1486
0
    return emitBitOrSint64(I);
1487
0
  case PT_Uint64:
1488
0
    return emitBitOrUint64(I);
1489
0
  case PT_IntAP:
1490
0
    return emitBitOrIntAP(I);
1491
0
  case PT_IntAPS:
1492
0
    return emitBitOrIntAPS(I);
1493
0
  default: llvm_unreachable("invalid type: emitBitOr");
1494
0
  }
1495
0
  llvm_unreachable("invalid enum value");
1496
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitBitOr(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitBitOr(clang::interp::PrimType, clang::interp::SourceInfo const&)
1497
#endif
1498
#ifdef GET_LINK_IMPL
1499
0
bool ByteCodeEmitter::emitBitOrSint8(const SourceInfo &L) {
1500
0
  return emitOp<>(OP_BitOrSint8, L);
1501
0
}
1502
0
bool ByteCodeEmitter::emitBitOrUint8(const SourceInfo &L) {
1503
0
  return emitOp<>(OP_BitOrUint8, L);
1504
0
}
1505
0
bool ByteCodeEmitter::emitBitOrSint16(const SourceInfo &L) {
1506
0
  return emitOp<>(OP_BitOrSint16, L);
1507
0
}
1508
0
bool ByteCodeEmitter::emitBitOrUint16(const SourceInfo &L) {
1509
0
  return emitOp<>(OP_BitOrUint16, L);
1510
0
}
1511
0
bool ByteCodeEmitter::emitBitOrSint32(const SourceInfo &L) {
1512
0
  return emitOp<>(OP_BitOrSint32, L);
1513
0
}
1514
0
bool ByteCodeEmitter::emitBitOrUint32(const SourceInfo &L) {
1515
0
  return emitOp<>(OP_BitOrUint32, L);
1516
0
}
1517
0
bool ByteCodeEmitter::emitBitOrSint64(const SourceInfo &L) {
1518
0
  return emitOp<>(OP_BitOrSint64, L);
1519
0
}
1520
0
bool ByteCodeEmitter::emitBitOrUint64(const SourceInfo &L) {
1521
0
  return emitOp<>(OP_BitOrUint64, L);
1522
0
}
1523
0
bool ByteCodeEmitter::emitBitOrIntAP(const SourceInfo &L) {
1524
0
  return emitOp<>(OP_BitOrIntAP, L);
1525
0
}
1526
0
bool ByteCodeEmitter::emitBitOrIntAPS(const SourceInfo &L) {
1527
0
  return emitOp<>(OP_BitOrIntAPS, L);
1528
0
}
1529
#endif
1530
#ifdef GET_EVAL_IMPL
1531
0
bool EvalEmitter::emitBitOrSint8(const SourceInfo &L) {
1532
0
  if (!isActive()) return true;
1533
0
  CurrentSource = L;
1534
0
  return BitOr<PT_Sint8>(S, OpPC);
1535
0
}
1536
0
bool EvalEmitter::emitBitOrUint8(const SourceInfo &L) {
1537
0
  if (!isActive()) return true;
1538
0
  CurrentSource = L;
1539
0
  return BitOr<PT_Uint8>(S, OpPC);
1540
0
}
1541
0
bool EvalEmitter::emitBitOrSint16(const SourceInfo &L) {
1542
0
  if (!isActive()) return true;
1543
0
  CurrentSource = L;
1544
0
  return BitOr<PT_Sint16>(S, OpPC);
1545
0
}
1546
0
bool EvalEmitter::emitBitOrUint16(const SourceInfo &L) {
1547
0
  if (!isActive()) return true;
1548
0
  CurrentSource = L;
1549
0
  return BitOr<PT_Uint16>(S, OpPC);
1550
0
}
1551
0
bool EvalEmitter::emitBitOrSint32(const SourceInfo &L) {
1552
0
  if (!isActive()) return true;
1553
0
  CurrentSource = L;
1554
0
  return BitOr<PT_Sint32>(S, OpPC);
1555
0
}
1556
0
bool EvalEmitter::emitBitOrUint32(const SourceInfo &L) {
1557
0
  if (!isActive()) return true;
1558
0
  CurrentSource = L;
1559
0
  return BitOr<PT_Uint32>(S, OpPC);
1560
0
}
1561
0
bool EvalEmitter::emitBitOrSint64(const SourceInfo &L) {
1562
0
  if (!isActive()) return true;
1563
0
  CurrentSource = L;
1564
0
  return BitOr<PT_Sint64>(S, OpPC);
1565
0
}
1566
0
bool EvalEmitter::emitBitOrUint64(const SourceInfo &L) {
1567
0
  if (!isActive()) return true;
1568
0
  CurrentSource = L;
1569
0
  return BitOr<PT_Uint64>(S, OpPC);
1570
0
}
1571
0
bool EvalEmitter::emitBitOrIntAP(const SourceInfo &L) {
1572
0
  if (!isActive()) return true;
1573
0
  CurrentSource = L;
1574
0
  return BitOr<PT_IntAP>(S, OpPC);
1575
0
}
1576
0
bool EvalEmitter::emitBitOrIntAPS(const SourceInfo &L) {
1577
0
  if (!isActive()) return true;
1578
0
  CurrentSource = L;
1579
0
  return BitOr<PT_IntAPS>(S, OpPC);
1580
0
}
1581
#endif
1582
#ifdef GET_OPCODE_NAMES
1583
OP_BitXorSint8,
1584
OP_BitXorUint8,
1585
OP_BitXorSint16,
1586
OP_BitXorUint16,
1587
OP_BitXorSint32,
1588
OP_BitXorUint32,
1589
OP_BitXorSint64,
1590
OP_BitXorUint64,
1591
OP_BitXorIntAP,
1592
OP_BitXorIntAPS,
1593
#endif
1594
0
#ifdef GET_INTERP
1595
0
case OP_BitXorSint8: {
1596
0
  if (!BitXor<PT_Sint8>(S, OpPC))
1597
0
    return false;
1598
0
  continue;
1599
0
}
1600
0
case OP_BitXorUint8: {
1601
0
  if (!BitXor<PT_Uint8>(S, OpPC))
1602
0
    return false;
1603
0
  continue;
1604
0
}
1605
0
case OP_BitXorSint16: {
1606
0
  if (!BitXor<PT_Sint16>(S, OpPC))
1607
0
    return false;
1608
0
  continue;
1609
0
}
1610
0
case OP_BitXorUint16: {
1611
0
  if (!BitXor<PT_Uint16>(S, OpPC))
1612
0
    return false;
1613
0
  continue;
1614
0
}
1615
0
case OP_BitXorSint32: {
1616
0
  if (!BitXor<PT_Sint32>(S, OpPC))
1617
0
    return false;
1618
0
  continue;
1619
0
}
1620
0
case OP_BitXorUint32: {
1621
0
  if (!BitXor<PT_Uint32>(S, OpPC))
1622
0
    return false;
1623
0
  continue;
1624
0
}
1625
0
case OP_BitXorSint64: {
1626
0
  if (!BitXor<PT_Sint64>(S, OpPC))
1627
0
    return false;
1628
0
  continue;
1629
0
}
1630
0
case OP_BitXorUint64: {
1631
0
  if (!BitXor<PT_Uint64>(S, OpPC))
1632
0
    return false;
1633
0
  continue;
1634
0
}
1635
0
case OP_BitXorIntAP: {
1636
0
  if (!BitXor<PT_IntAP>(S, OpPC))
1637
0
    return false;
1638
0
  continue;
1639
0
}
1640
0
case OP_BitXorIntAPS: {
1641
0
  if (!BitXor<PT_IntAPS>(S, OpPC))
1642
0
    return false;
1643
0
  continue;
1644
0
}
1645
0
#endif
1646
#ifdef GET_DISASM
1647
case OP_BitXorSint8:
1648
  PrintName("BitXorSint8");
1649
  OS << "\t" << "\n";
1650
  continue;
1651
case OP_BitXorUint8:
1652
  PrintName("BitXorUint8");
1653
  OS << "\t" << "\n";
1654
  continue;
1655
case OP_BitXorSint16:
1656
  PrintName("BitXorSint16");
1657
  OS << "\t" << "\n";
1658
  continue;
1659
case OP_BitXorUint16:
1660
  PrintName("BitXorUint16");
1661
  OS << "\t" << "\n";
1662
  continue;
1663
case OP_BitXorSint32:
1664
  PrintName("BitXorSint32");
1665
  OS << "\t" << "\n";
1666
  continue;
1667
case OP_BitXorUint32:
1668
  PrintName("BitXorUint32");
1669
  OS << "\t" << "\n";
1670
  continue;
1671
case OP_BitXorSint64:
1672
  PrintName("BitXorSint64");
1673
  OS << "\t" << "\n";
1674
  continue;
1675
case OP_BitXorUint64:
1676
  PrintName("BitXorUint64");
1677
  OS << "\t" << "\n";
1678
  continue;
1679
case OP_BitXorIntAP:
1680
  PrintName("BitXorIntAP");
1681
  OS << "\t" << "\n";
1682
  continue;
1683
case OP_BitXorIntAPS:
1684
  PrintName("BitXorIntAPS");
1685
  OS << "\t" << "\n";
1686
  continue;
1687
#endif
1688
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1689
bool emitBitXorSint8(const SourceInfo &);
1690
bool emitBitXorUint8(const SourceInfo &);
1691
bool emitBitXorSint16(const SourceInfo &);
1692
bool emitBitXorUint16(const SourceInfo &);
1693
bool emitBitXorSint32(const SourceInfo &);
1694
bool emitBitXorUint32(const SourceInfo &);
1695
bool emitBitXorSint64(const SourceInfo &);
1696
bool emitBitXorUint64(const SourceInfo &);
1697
bool emitBitXorIntAP(const SourceInfo &);
1698
bool emitBitXorIntAPS(const SourceInfo &);
1699
#endif
1700
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1701
bool emitBitXor(PrimType, const SourceInfo &I);
1702
#endif
1703
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
1704
bool
1705
#if defined(GET_EVAL_IMPL)
1706
EvalEmitter
1707
#else
1708
ByteCodeEmitter
1709
#endif
1710
0
::emitBitXor(PrimType T0, const SourceInfo &I) {
1711
0
  switch (T0) {
1712
0
  case PT_Sint8:
1713
0
    return emitBitXorSint8(I);
1714
0
  case PT_Uint8:
1715
0
    return emitBitXorUint8(I);
1716
0
  case PT_Sint16:
1717
0
    return emitBitXorSint16(I);
1718
0
  case PT_Uint16:
1719
0
    return emitBitXorUint16(I);
1720
0
  case PT_Sint32:
1721
0
    return emitBitXorSint32(I);
1722
0
  case PT_Uint32:
1723
0
    return emitBitXorUint32(I);
1724
0
  case PT_Sint64:
1725
0
    return emitBitXorSint64(I);
1726
0
  case PT_Uint64:
1727
0
    return emitBitXorUint64(I);
1728
0
  case PT_IntAP:
1729
0
    return emitBitXorIntAP(I);
1730
0
  case PT_IntAPS:
1731
0
    return emitBitXorIntAPS(I);
1732
0
  default: llvm_unreachable("invalid type: emitBitXor");
1733
0
  }
1734
0
  llvm_unreachable("invalid enum value");
1735
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitBitXor(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitBitXor(clang::interp::PrimType, clang::interp::SourceInfo const&)
1736
#endif
1737
#ifdef GET_LINK_IMPL
1738
0
bool ByteCodeEmitter::emitBitXorSint8(const SourceInfo &L) {
1739
0
  return emitOp<>(OP_BitXorSint8, L);
1740
0
}
1741
0
bool ByteCodeEmitter::emitBitXorUint8(const SourceInfo &L) {
1742
0
  return emitOp<>(OP_BitXorUint8, L);
1743
0
}
1744
0
bool ByteCodeEmitter::emitBitXorSint16(const SourceInfo &L) {
1745
0
  return emitOp<>(OP_BitXorSint16, L);
1746
0
}
1747
0
bool ByteCodeEmitter::emitBitXorUint16(const SourceInfo &L) {
1748
0
  return emitOp<>(OP_BitXorUint16, L);
1749
0
}
1750
0
bool ByteCodeEmitter::emitBitXorSint32(const SourceInfo &L) {
1751
0
  return emitOp<>(OP_BitXorSint32, L);
1752
0
}
1753
0
bool ByteCodeEmitter::emitBitXorUint32(const SourceInfo &L) {
1754
0
  return emitOp<>(OP_BitXorUint32, L);
1755
0
}
1756
0
bool ByteCodeEmitter::emitBitXorSint64(const SourceInfo &L) {
1757
0
  return emitOp<>(OP_BitXorSint64, L);
1758
0
}
1759
0
bool ByteCodeEmitter::emitBitXorUint64(const SourceInfo &L) {
1760
0
  return emitOp<>(OP_BitXorUint64, L);
1761
0
}
1762
0
bool ByteCodeEmitter::emitBitXorIntAP(const SourceInfo &L) {
1763
0
  return emitOp<>(OP_BitXorIntAP, L);
1764
0
}
1765
0
bool ByteCodeEmitter::emitBitXorIntAPS(const SourceInfo &L) {
1766
0
  return emitOp<>(OP_BitXorIntAPS, L);
1767
0
}
1768
#endif
1769
#ifdef GET_EVAL_IMPL
1770
0
bool EvalEmitter::emitBitXorSint8(const SourceInfo &L) {
1771
0
  if (!isActive()) return true;
1772
0
  CurrentSource = L;
1773
0
  return BitXor<PT_Sint8>(S, OpPC);
1774
0
}
1775
0
bool EvalEmitter::emitBitXorUint8(const SourceInfo &L) {
1776
0
  if (!isActive()) return true;
1777
0
  CurrentSource = L;
1778
0
  return BitXor<PT_Uint8>(S, OpPC);
1779
0
}
1780
0
bool EvalEmitter::emitBitXorSint16(const SourceInfo &L) {
1781
0
  if (!isActive()) return true;
1782
0
  CurrentSource = L;
1783
0
  return BitXor<PT_Sint16>(S, OpPC);
1784
0
}
1785
0
bool EvalEmitter::emitBitXorUint16(const SourceInfo &L) {
1786
0
  if (!isActive()) return true;
1787
0
  CurrentSource = L;
1788
0
  return BitXor<PT_Uint16>(S, OpPC);
1789
0
}
1790
0
bool EvalEmitter::emitBitXorSint32(const SourceInfo &L) {
1791
0
  if (!isActive()) return true;
1792
0
  CurrentSource = L;
1793
0
  return BitXor<PT_Sint32>(S, OpPC);
1794
0
}
1795
0
bool EvalEmitter::emitBitXorUint32(const SourceInfo &L) {
1796
0
  if (!isActive()) return true;
1797
0
  CurrentSource = L;
1798
0
  return BitXor<PT_Uint32>(S, OpPC);
1799
0
}
1800
0
bool EvalEmitter::emitBitXorSint64(const SourceInfo &L) {
1801
0
  if (!isActive()) return true;
1802
0
  CurrentSource = L;
1803
0
  return BitXor<PT_Sint64>(S, OpPC);
1804
0
}
1805
0
bool EvalEmitter::emitBitXorUint64(const SourceInfo &L) {
1806
0
  if (!isActive()) return true;
1807
0
  CurrentSource = L;
1808
0
  return BitXor<PT_Uint64>(S, OpPC);
1809
0
}
1810
0
bool EvalEmitter::emitBitXorIntAP(const SourceInfo &L) {
1811
0
  if (!isActive()) return true;
1812
0
  CurrentSource = L;
1813
0
  return BitXor<PT_IntAP>(S, OpPC);
1814
0
}
1815
0
bool EvalEmitter::emitBitXorIntAPS(const SourceInfo &L) {
1816
0
  if (!isActive()) return true;
1817
0
  CurrentSource = L;
1818
0
  return BitXor<PT_IntAPS>(S, OpPC);
1819
0
}
1820
#endif
1821
#ifdef GET_OPCODE_NAMES
1822
OP_CMP3Sint8,
1823
OP_CMP3Uint8,
1824
OP_CMP3Sint16,
1825
OP_CMP3Uint16,
1826
OP_CMP3Sint32,
1827
OP_CMP3Uint32,
1828
OP_CMP3Sint64,
1829
OP_CMP3Uint64,
1830
OP_CMP3IntAP,
1831
OP_CMP3IntAPS,
1832
OP_CMP3Bool,
1833
OP_CMP3Ptr,
1834
OP_CMP3Float,
1835
OP_CMP3FnPtr,
1836
#endif
1837
0
#ifdef GET_INTERP
1838
0
case OP_CMP3Sint8: {
1839
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1840
0
  if (!CMP3<PT_Sint8>(S, OpPC, V0))
1841
0
    return false;
1842
0
  continue;
1843
0
}
1844
0
case OP_CMP3Uint8: {
1845
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1846
0
  if (!CMP3<PT_Uint8>(S, OpPC, V0))
1847
0
    return false;
1848
0
  continue;
1849
0
}
1850
0
case OP_CMP3Sint16: {
1851
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1852
0
  if (!CMP3<PT_Sint16>(S, OpPC, V0))
1853
0
    return false;
1854
0
  continue;
1855
0
}
1856
0
case OP_CMP3Uint16: {
1857
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1858
0
  if (!CMP3<PT_Uint16>(S, OpPC, V0))
1859
0
    return false;
1860
0
  continue;
1861
0
}
1862
0
case OP_CMP3Sint32: {
1863
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1864
0
  if (!CMP3<PT_Sint32>(S, OpPC, V0))
1865
0
    return false;
1866
0
  continue;
1867
0
}
1868
0
case OP_CMP3Uint32: {
1869
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1870
0
  if (!CMP3<PT_Uint32>(S, OpPC, V0))
1871
0
    return false;
1872
0
  continue;
1873
0
}
1874
0
case OP_CMP3Sint64: {
1875
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1876
0
  if (!CMP3<PT_Sint64>(S, OpPC, V0))
1877
0
    return false;
1878
0
  continue;
1879
0
}
1880
0
case OP_CMP3Uint64: {
1881
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1882
0
  if (!CMP3<PT_Uint64>(S, OpPC, V0))
1883
0
    return false;
1884
0
  continue;
1885
0
}
1886
0
case OP_CMP3IntAP: {
1887
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1888
0
  if (!CMP3<PT_IntAP>(S, OpPC, V0))
1889
0
    return false;
1890
0
  continue;
1891
0
}
1892
0
case OP_CMP3IntAPS: {
1893
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1894
0
  if (!CMP3<PT_IntAPS>(S, OpPC, V0))
1895
0
    return false;
1896
0
  continue;
1897
0
}
1898
0
case OP_CMP3Bool: {
1899
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1900
0
  if (!CMP3<PT_Bool>(S, OpPC, V0))
1901
0
    return false;
1902
0
  continue;
1903
0
}
1904
0
case OP_CMP3Ptr: {
1905
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1906
0
  if (!CMP3<PT_Ptr>(S, OpPC, V0))
1907
0
    return false;
1908
0
  continue;
1909
0
}
1910
0
case OP_CMP3Float: {
1911
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1912
0
  if (!CMP3<PT_Float>(S, OpPC, V0))
1913
0
    return false;
1914
0
  continue;
1915
0
}
1916
0
case OP_CMP3FnPtr: {
1917
0
  auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, PC);
1918
0
  if (!CMP3<PT_FnPtr>(S, OpPC, V0))
1919
0
    return false;
1920
0
  continue;
1921
0
}
1922
0
#endif
1923
#ifdef GET_DISASM
1924
case OP_CMP3Sint8:
1925
  PrintName("CMP3Sint8");
1926
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1927
  continue;
1928
case OP_CMP3Uint8:
1929
  PrintName("CMP3Uint8");
1930
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1931
  continue;
1932
case OP_CMP3Sint16:
1933
  PrintName("CMP3Sint16");
1934
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1935
  continue;
1936
case OP_CMP3Uint16:
1937
  PrintName("CMP3Uint16");
1938
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1939
  continue;
1940
case OP_CMP3Sint32:
1941
  PrintName("CMP3Sint32");
1942
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1943
  continue;
1944
case OP_CMP3Uint32:
1945
  PrintName("CMP3Uint32");
1946
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1947
  continue;
1948
case OP_CMP3Sint64:
1949
  PrintName("CMP3Sint64");
1950
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1951
  continue;
1952
case OP_CMP3Uint64:
1953
  PrintName("CMP3Uint64");
1954
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1955
  continue;
1956
case OP_CMP3IntAP:
1957
  PrintName("CMP3IntAP");
1958
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1959
  continue;
1960
case OP_CMP3IntAPS:
1961
  PrintName("CMP3IntAPS");
1962
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1963
  continue;
1964
case OP_CMP3Bool:
1965
  PrintName("CMP3Bool");
1966
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1967
  continue;
1968
case OP_CMP3Ptr:
1969
  PrintName("CMP3Ptr");
1970
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1971
  continue;
1972
case OP_CMP3Float:
1973
  PrintName("CMP3Float");
1974
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1975
  continue;
1976
case OP_CMP3FnPtr:
1977
  PrintName("CMP3FnPtr");
1978
  OS << "\t" << ReadArg<const ComparisonCategoryInfo *>(P, PC) << " " << "\n";
1979
  continue;
1980
#endif
1981
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1982
bool emitCMP3Sint8(const ComparisonCategoryInfo *, const SourceInfo &);
1983
bool emitCMP3Uint8(const ComparisonCategoryInfo *, const SourceInfo &);
1984
bool emitCMP3Sint16(const ComparisonCategoryInfo *, const SourceInfo &);
1985
bool emitCMP3Uint16(const ComparisonCategoryInfo *, const SourceInfo &);
1986
bool emitCMP3Sint32(const ComparisonCategoryInfo *, const SourceInfo &);
1987
bool emitCMP3Uint32(const ComparisonCategoryInfo *, const SourceInfo &);
1988
bool emitCMP3Sint64(const ComparisonCategoryInfo *, const SourceInfo &);
1989
bool emitCMP3Uint64(const ComparisonCategoryInfo *, const SourceInfo &);
1990
bool emitCMP3IntAP(const ComparisonCategoryInfo *, const SourceInfo &);
1991
bool emitCMP3IntAPS(const ComparisonCategoryInfo *, const SourceInfo &);
1992
bool emitCMP3Bool(const ComparisonCategoryInfo *, const SourceInfo &);
1993
bool emitCMP3Ptr(const ComparisonCategoryInfo *, const SourceInfo &);
1994
bool emitCMP3Float(const ComparisonCategoryInfo *, const SourceInfo &);
1995
bool emitCMP3FnPtr(const ComparisonCategoryInfo *, const SourceInfo &);
1996
#endif
1997
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1998
bool emitCMP3(PrimType, const ComparisonCategoryInfo *, const SourceInfo &I);
1999
#endif
2000
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
2001
bool
2002
#if defined(GET_EVAL_IMPL)
2003
EvalEmitter
2004
#else
2005
ByteCodeEmitter
2006
#endif
2007
0
::emitCMP3(PrimType T0, const ComparisonCategoryInfo * A0, const SourceInfo &I) {
2008
0
  switch (T0) {
2009
0
  case PT_Sint8:
2010
0
    return emitCMP3Sint8(A0, I);
2011
0
  case PT_Uint8:
2012
0
    return emitCMP3Uint8(A0, I);
2013
0
  case PT_Sint16:
2014
0
    return emitCMP3Sint16(A0, I);
2015
0
  case PT_Uint16:
2016
0
    return emitCMP3Uint16(A0, I);
2017
0
  case PT_Sint32:
2018
0
    return emitCMP3Sint32(A0, I);
2019
0
  case PT_Uint32:
2020
0
    return emitCMP3Uint32(A0, I);
2021
0
  case PT_Sint64:
2022
0
    return emitCMP3Sint64(A0, I);
2023
0
  case PT_Uint64:
2024
0
    return emitCMP3Uint64(A0, I);
2025
0
  case PT_IntAP:
2026
0
    return emitCMP3IntAP(A0, I);
2027
0
  case PT_IntAPS:
2028
0
    return emitCMP3IntAPS(A0, I);
2029
0
  case PT_Bool:
2030
0
    return emitCMP3Bool(A0, I);
2031
0
  case PT_Ptr:
2032
0
    return emitCMP3Ptr(A0, I);
2033
0
  case PT_Float:
2034
0
    return emitCMP3Float(A0, I);
2035
0
  case PT_FnPtr:
2036
0
    return emitCMP3FnPtr(A0, I);
2037
0
  }
2038
0
  llvm_unreachable("invalid enum value");
2039
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCMP3(clang::interp::PrimType, clang::ComparisonCategoryInfo const*, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCMP3(clang::interp::PrimType, clang::ComparisonCategoryInfo const*, clang::interp::SourceInfo const&)
2040
#endif
2041
#ifdef GET_LINK_IMPL
2042
0
bool ByteCodeEmitter::emitCMP3Sint8(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2043
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint8, A0, L);
2044
0
}
2045
0
bool ByteCodeEmitter::emitCMP3Uint8(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2046
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint8, A0, L);
2047
0
}
2048
0
bool ByteCodeEmitter::emitCMP3Sint16(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2049
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint16, A0, L);
2050
0
}
2051
0
bool ByteCodeEmitter::emitCMP3Uint16(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2052
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint16, A0, L);
2053
0
}
2054
0
bool ByteCodeEmitter::emitCMP3Sint32(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2055
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint32, A0, L);
2056
0
}
2057
0
bool ByteCodeEmitter::emitCMP3Uint32(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2058
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint32, A0, L);
2059
0
}
2060
0
bool ByteCodeEmitter::emitCMP3Sint64(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2061
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint64, A0, L);
2062
0
}
2063
0
bool ByteCodeEmitter::emitCMP3Uint64(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2064
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint64, A0, L);
2065
0
}
2066
0
bool ByteCodeEmitter::emitCMP3IntAP(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2067
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3IntAP, A0, L);
2068
0
}
2069
0
bool ByteCodeEmitter::emitCMP3IntAPS(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2070
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3IntAPS, A0, L);
2071
0
}
2072
0
bool ByteCodeEmitter::emitCMP3Bool(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2073
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Bool, A0, L);
2074
0
}
2075
0
bool ByteCodeEmitter::emitCMP3Ptr(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2076
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Ptr, A0, L);
2077
0
}
2078
0
bool ByteCodeEmitter::emitCMP3Float(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2079
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Float, A0, L);
2080
0
}
2081
0
bool ByteCodeEmitter::emitCMP3FnPtr(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2082
0
  return emitOp<const ComparisonCategoryInfo *>(OP_CMP3FnPtr, A0, L);
2083
0
}
2084
#endif
2085
#ifdef GET_EVAL_IMPL
2086
0
bool EvalEmitter::emitCMP3Sint8(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2087
0
  if (!isActive()) return true;
2088
0
  CurrentSource = L;
2089
0
  return CMP3<PT_Sint8>(S, OpPC, A0);
2090
0
}
2091
0
bool EvalEmitter::emitCMP3Uint8(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2092
0
  if (!isActive()) return true;
2093
0
  CurrentSource = L;
2094
0
  return CMP3<PT_Uint8>(S, OpPC, A0);
2095
0
}
2096
0
bool EvalEmitter::emitCMP3Sint16(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2097
0
  if (!isActive()) return true;
2098
0
  CurrentSource = L;
2099
0
  return CMP3<PT_Sint16>(S, OpPC, A0);
2100
0
}
2101
0
bool EvalEmitter::emitCMP3Uint16(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2102
0
  if (!isActive()) return true;
2103
0
  CurrentSource = L;
2104
0
  return CMP3<PT_Uint16>(S, OpPC, A0);
2105
0
}
2106
0
bool EvalEmitter::emitCMP3Sint32(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2107
0
  if (!isActive()) return true;
2108
0
  CurrentSource = L;
2109
0
  return CMP3<PT_Sint32>(S, OpPC, A0);
2110
0
}
2111
0
bool EvalEmitter::emitCMP3Uint32(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2112
0
  if (!isActive()) return true;
2113
0
  CurrentSource = L;
2114
0
  return CMP3<PT_Uint32>(S, OpPC, A0);
2115
0
}
2116
0
bool EvalEmitter::emitCMP3Sint64(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2117
0
  if (!isActive()) return true;
2118
0
  CurrentSource = L;
2119
0
  return CMP3<PT_Sint64>(S, OpPC, A0);
2120
0
}
2121
0
bool EvalEmitter::emitCMP3Uint64(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2122
0
  if (!isActive()) return true;
2123
0
  CurrentSource = L;
2124
0
  return CMP3<PT_Uint64>(S, OpPC, A0);
2125
0
}
2126
0
bool EvalEmitter::emitCMP3IntAP(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2127
0
  if (!isActive()) return true;
2128
0
  CurrentSource = L;
2129
0
  return CMP3<PT_IntAP>(S, OpPC, A0);
2130
0
}
2131
0
bool EvalEmitter::emitCMP3IntAPS(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2132
0
  if (!isActive()) return true;
2133
0
  CurrentSource = L;
2134
0
  return CMP3<PT_IntAPS>(S, OpPC, A0);
2135
0
}
2136
0
bool EvalEmitter::emitCMP3Bool(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2137
0
  if (!isActive()) return true;
2138
0
  CurrentSource = L;
2139
0
  return CMP3<PT_Bool>(S, OpPC, A0);
2140
0
}
2141
0
bool EvalEmitter::emitCMP3Ptr(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2142
0
  if (!isActive()) return true;
2143
0
  CurrentSource = L;
2144
0
  return CMP3<PT_Ptr>(S, OpPC, A0);
2145
0
}
2146
0
bool EvalEmitter::emitCMP3Float(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2147
0
  if (!isActive()) return true;
2148
0
  CurrentSource = L;
2149
0
  return CMP3<PT_Float>(S, OpPC, A0);
2150
0
}
2151
0
bool EvalEmitter::emitCMP3FnPtr(const ComparisonCategoryInfo * A0, const SourceInfo &L) {
2152
0
  if (!isActive()) return true;
2153
0
  CurrentSource = L;
2154
0
  return CMP3<PT_FnPtr>(S, OpPC, A0);
2155
0
}
2156
#endif
2157
#ifdef GET_OPCODE_NAMES
2158
OP_Call,
2159
#endif
2160
0
#ifdef GET_INTERP
2161
0
case OP_Call: {
2162
0
  auto V0 = ReadArg<const Function *>(S, PC);
2163
0
  if (!Call(S, OpPC, V0))
2164
0
    return false;
2165
0
  continue;
2166
0
}
2167
0
#endif
2168
#ifdef GET_DISASM
2169
case OP_Call:
2170
  PrintName("Call");
2171
  OS << "\t" << ReadArg<const Function *>(P, PC) << " " << "\n";
2172
  continue;
2173
#endif
2174
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2175
bool emitCall(const Function *, const SourceInfo &);
2176
#endif
2177
#ifdef GET_LINK_IMPL
2178
0
bool ByteCodeEmitter::emitCall(const Function * A0, const SourceInfo &L) {
2179
0
  return emitOp<const Function *>(OP_Call, A0, L);
2180
0
}
2181
#endif
2182
#ifdef GET_EVAL_IMPL
2183
0
bool EvalEmitter::emitCall(const Function * A0, const SourceInfo &L) {
2184
0
  if (!isActive()) return true;
2185
0
  CurrentSource = L;
2186
0
  return Call(S, OpPC, A0);
2187
0
}
2188
#endif
2189
#ifdef GET_OPCODE_NAMES
2190
OP_CallBI,
2191
#endif
2192
0
#ifdef GET_INTERP
2193
0
case OP_CallBI: {
2194
0
  auto V0 = ReadArg<const Function *>(S, PC);
2195
0
  auto V1 = ReadArg<const CallExpr *>(S, PC);
2196
0
  if (!CallBI(S, OpPC, V0, V1))
2197
0
    return false;
2198
0
  continue;
2199
0
}
2200
0
#endif
2201
#ifdef GET_DISASM
2202
case OP_CallBI:
2203
  PrintName("CallBI");
2204
  OS << "\t" << ReadArg<const Function *>(P, PC) << " " << ReadArg<const CallExpr *>(P, PC) << " " << "\n";
2205
  continue;
2206
#endif
2207
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2208
bool emitCallBI(const Function *, const CallExpr *, const SourceInfo &);
2209
#endif
2210
#ifdef GET_LINK_IMPL
2211
0
bool ByteCodeEmitter::emitCallBI(const Function * A0, const CallExpr * A1, const SourceInfo &L) {
2212
0
  return emitOp<const Function *, const CallExpr *>(OP_CallBI, A0, A1, L);
2213
0
}
2214
#endif
2215
#ifdef GET_EVAL_IMPL
2216
0
bool EvalEmitter::emitCallBI(const Function * A0, const CallExpr * A1, const SourceInfo &L) {
2217
0
  if (!isActive()) return true;
2218
0
  CurrentSource = L;
2219
0
  return CallBI(S, OpPC, A0, A1);
2220
0
}
2221
#endif
2222
#ifdef GET_OPCODE_NAMES
2223
OP_CallPtr,
2224
#endif
2225
0
#ifdef GET_INTERP
2226
0
case OP_CallPtr: {
2227
0
  if (!CallPtr(S, OpPC))
2228
0
    return false;
2229
0
  continue;
2230
0
}
2231
0
#endif
2232
#ifdef GET_DISASM
2233
case OP_CallPtr:
2234
  PrintName("CallPtr");
2235
  OS << "\t" << "\n";
2236
  continue;
2237
#endif
2238
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2239
bool emitCallPtr(const SourceInfo &);
2240
#endif
2241
#ifdef GET_LINK_IMPL
2242
0
bool ByteCodeEmitter::emitCallPtr(const SourceInfo &L) {
2243
0
  return emitOp<>(OP_CallPtr, L);
2244
0
}
2245
#endif
2246
#ifdef GET_EVAL_IMPL
2247
0
bool EvalEmitter::emitCallPtr(const SourceInfo &L) {
2248
0
  if (!isActive()) return true;
2249
0
  CurrentSource = L;
2250
0
  return CallPtr(S, OpPC);
2251
0
}
2252
#endif
2253
#ifdef GET_OPCODE_NAMES
2254
OP_CallVirt,
2255
#endif
2256
0
#ifdef GET_INTERP
2257
0
case OP_CallVirt: {
2258
0
  auto V0 = ReadArg<const Function *>(S, PC);
2259
0
  if (!CallVirt(S, OpPC, V0))
2260
0
    return false;
2261
0
  continue;
2262
0
}
2263
0
#endif
2264
#ifdef GET_DISASM
2265
case OP_CallVirt:
2266
  PrintName("CallVirt");
2267
  OS << "\t" << ReadArg<const Function *>(P, PC) << " " << "\n";
2268
  continue;
2269
#endif
2270
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2271
bool emitCallVirt(const Function *, const SourceInfo &);
2272
#endif
2273
#ifdef GET_LINK_IMPL
2274
0
bool ByteCodeEmitter::emitCallVirt(const Function * A0, const SourceInfo &L) {
2275
0
  return emitOp<const Function *>(OP_CallVirt, A0, L);
2276
0
}
2277
#endif
2278
#ifdef GET_EVAL_IMPL
2279
0
bool EvalEmitter::emitCallVirt(const Function * A0, const SourceInfo &L) {
2280
0
  if (!isActive()) return true;
2281
0
  CurrentSource = L;
2282
0
  return CallVirt(S, OpPC, A0);
2283
0
}
2284
#endif
2285
#ifdef GET_OPCODE_NAMES
2286
OP_CastUint8Uint8,
2287
OP_CastUint8Sint8,
2288
OP_CastUint8Uint16,
2289
OP_CastUint8Sint16,
2290
OP_CastUint8Uint32,
2291
OP_CastUint8Sint32,
2292
OP_CastUint8Uint64,
2293
OP_CastUint8Sint64,
2294
OP_CastUint8Bool,
2295
OP_CastSint8Uint8,
2296
OP_CastSint8Sint8,
2297
OP_CastSint8Uint16,
2298
OP_CastSint8Sint16,
2299
OP_CastSint8Uint32,
2300
OP_CastSint8Sint32,
2301
OP_CastSint8Uint64,
2302
OP_CastSint8Sint64,
2303
OP_CastSint8Bool,
2304
OP_CastUint16Uint8,
2305
OP_CastUint16Sint8,
2306
OP_CastUint16Uint16,
2307
OP_CastUint16Sint16,
2308
OP_CastUint16Uint32,
2309
OP_CastUint16Sint32,
2310
OP_CastUint16Uint64,
2311
OP_CastUint16Sint64,
2312
OP_CastUint16Bool,
2313
OP_CastSint16Uint8,
2314
OP_CastSint16Sint8,
2315
OP_CastSint16Uint16,
2316
OP_CastSint16Sint16,
2317
OP_CastSint16Uint32,
2318
OP_CastSint16Sint32,
2319
OP_CastSint16Uint64,
2320
OP_CastSint16Sint64,
2321
OP_CastSint16Bool,
2322
OP_CastUint32Uint8,
2323
OP_CastUint32Sint8,
2324
OP_CastUint32Uint16,
2325
OP_CastUint32Sint16,
2326
OP_CastUint32Uint32,
2327
OP_CastUint32Sint32,
2328
OP_CastUint32Uint64,
2329
OP_CastUint32Sint64,
2330
OP_CastUint32Bool,
2331
OP_CastSint32Uint8,
2332
OP_CastSint32Sint8,
2333
OP_CastSint32Uint16,
2334
OP_CastSint32Sint16,
2335
OP_CastSint32Uint32,
2336
OP_CastSint32Sint32,
2337
OP_CastSint32Uint64,
2338
OP_CastSint32Sint64,
2339
OP_CastSint32Bool,
2340
OP_CastUint64Uint8,
2341
OP_CastUint64Sint8,
2342
OP_CastUint64Uint16,
2343
OP_CastUint64Sint16,
2344
OP_CastUint64Uint32,
2345
OP_CastUint64Sint32,
2346
OP_CastUint64Uint64,
2347
OP_CastUint64Sint64,
2348
OP_CastUint64Bool,
2349
OP_CastSint64Uint8,
2350
OP_CastSint64Sint8,
2351
OP_CastSint64Uint16,
2352
OP_CastSint64Sint16,
2353
OP_CastSint64Uint32,
2354
OP_CastSint64Sint32,
2355
OP_CastSint64Uint64,
2356
OP_CastSint64Sint64,
2357
OP_CastSint64Bool,
2358
OP_CastBoolUint8,
2359
OP_CastBoolSint8,
2360
OP_CastBoolUint16,
2361
OP_CastBoolSint16,
2362
OP_CastBoolUint32,
2363
OP_CastBoolSint32,
2364
OP_CastBoolUint64,
2365
OP_CastBoolSint64,
2366
OP_CastBoolBool,
2367
OP_CastIntAPUint8,
2368
OP_CastIntAPSint8,
2369
OP_CastIntAPUint16,
2370
OP_CastIntAPSint16,
2371
OP_CastIntAPUint32,
2372
OP_CastIntAPSint32,
2373
OP_CastIntAPUint64,
2374
OP_CastIntAPSint64,
2375
OP_CastIntAPBool,
2376
OP_CastIntAPSUint8,
2377
OP_CastIntAPSSint8,
2378
OP_CastIntAPSUint16,
2379
OP_CastIntAPSSint16,
2380
OP_CastIntAPSUint32,
2381
OP_CastIntAPSSint32,
2382
OP_CastIntAPSUint64,
2383
OP_CastIntAPSSint64,
2384
OP_CastIntAPSBool,
2385
#endif
2386
0
#ifdef GET_INTERP
2387
0
case OP_CastUint8Uint8: {
2388
0
  if (!Cast<PT_Uint8, PT_Uint8>(S, OpPC))
2389
0
    return false;
2390
0
  continue;
2391
0
}
2392
0
case OP_CastUint8Sint8: {
2393
0
  if (!Cast<PT_Uint8, PT_Sint8>(S, OpPC))
2394
0
    return false;
2395
0
  continue;
2396
0
}
2397
0
case OP_CastUint8Uint16: {
2398
0
  if (!Cast<PT_Uint8, PT_Uint16>(S, OpPC))
2399
0
    return false;
2400
0
  continue;
2401
0
}
2402
0
case OP_CastUint8Sint16: {
2403
0
  if (!Cast<PT_Uint8, PT_Sint16>(S, OpPC))
2404
0
    return false;
2405
0
  continue;
2406
0
}
2407
0
case OP_CastUint8Uint32: {
2408
0
  if (!Cast<PT_Uint8, PT_Uint32>(S, OpPC))
2409
0
    return false;
2410
0
  continue;
2411
0
}
2412
0
case OP_CastUint8Sint32: {
2413
0
  if (!Cast<PT_Uint8, PT_Sint32>(S, OpPC))
2414
0
    return false;
2415
0
  continue;
2416
0
}
2417
0
case OP_CastUint8Uint64: {
2418
0
  if (!Cast<PT_Uint8, PT_Uint64>(S, OpPC))
2419
0
    return false;
2420
0
  continue;
2421
0
}
2422
0
case OP_CastUint8Sint64: {
2423
0
  if (!Cast<PT_Uint8, PT_Sint64>(S, OpPC))
2424
0
    return false;
2425
0
  continue;
2426
0
}
2427
0
case OP_CastUint8Bool: {
2428
0
  if (!Cast<PT_Uint8, PT_Bool>(S, OpPC))
2429
0
    return false;
2430
0
  continue;
2431
0
}
2432
0
case OP_CastSint8Uint8: {
2433
0
  if (!Cast<PT_Sint8, PT_Uint8>(S, OpPC))
2434
0
    return false;
2435
0
  continue;
2436
0
}
2437
0
case OP_CastSint8Sint8: {
2438
0
  if (!Cast<PT_Sint8, PT_Sint8>(S, OpPC))
2439
0
    return false;
2440
0
  continue;
2441
0
}
2442
0
case OP_CastSint8Uint16: {
2443
0
  if (!Cast<PT_Sint8, PT_Uint16>(S, OpPC))
2444
0
    return false;
2445
0
  continue;
2446
0
}
2447
0
case OP_CastSint8Sint16: {
2448
0
  if (!Cast<PT_Sint8, PT_Sint16>(S, OpPC))
2449
0
    return false;
2450
0
  continue;
2451
0
}
2452
0
case OP_CastSint8Uint32: {
2453
0
  if (!Cast<PT_Sint8, PT_Uint32>(S, OpPC))
2454
0
    return false;
2455
0
  continue;
2456
0
}
2457
0
case OP_CastSint8Sint32: {
2458
0
  if (!Cast<PT_Sint8, PT_Sint32>(S, OpPC))
2459
0
    return false;
2460
0
  continue;
2461
0
}
2462
0
case OP_CastSint8Uint64: {
2463
0
  if (!Cast<PT_Sint8, PT_Uint64>(S, OpPC))
2464
0
    return false;
2465
0
  continue;
2466
0
}
2467
0
case OP_CastSint8Sint64: {
2468
0
  if (!Cast<PT_Sint8, PT_Sint64>(S, OpPC))
2469
0
    return false;
2470
0
  continue;
2471
0
}
2472
0
case OP_CastSint8Bool: {
2473
0
  if (!Cast<PT_Sint8, PT_Bool>(S, OpPC))
2474
0
    return false;
2475
0
  continue;
2476
0
}
2477
0
case OP_CastUint16Uint8: {
2478
0
  if (!Cast<PT_Uint16, PT_Uint8>(S, OpPC))
2479
0
    return false;
2480
0
  continue;
2481
0
}
2482
0
case OP_CastUint16Sint8: {
2483
0
  if (!Cast<PT_Uint16, PT_Sint8>(S, OpPC))
2484
0
    return false;
2485
0
  continue;
2486
0
}
2487
0
case OP_CastUint16Uint16: {
2488
0
  if (!Cast<PT_Uint16, PT_Uint16>(S, OpPC))
2489
0
    return false;
2490
0
  continue;
2491
0
}
2492
0
case OP_CastUint16Sint16: {
2493
0
  if (!Cast<PT_Uint16, PT_Sint16>(S, OpPC))
2494
0
    return false;
2495
0
  continue;
2496
0
}
2497
0
case OP_CastUint16Uint32: {
2498
0
  if (!Cast<PT_Uint16, PT_Uint32>(S, OpPC))
2499
0
    return false;
2500
0
  continue;
2501
0
}
2502
0
case OP_CastUint16Sint32: {
2503
0
  if (!Cast<PT_Uint16, PT_Sint32>(S, OpPC))
2504
0
    return false;
2505
0
  continue;
2506
0
}
2507
0
case OP_CastUint16Uint64: {
2508
0
  if (!Cast<PT_Uint16, PT_Uint64>(S, OpPC))
2509
0
    return false;
2510
0
  continue;
2511
0
}
2512
0
case OP_CastUint16Sint64: {
2513
0
  if (!Cast<PT_Uint16, PT_Sint64>(S, OpPC))
2514
0
    return false;
2515
0
  continue;
2516
0
}
2517
0
case OP_CastUint16Bool: {
2518
0
  if (!Cast<PT_Uint16, PT_Bool>(S, OpPC))
2519
0
    return false;
2520
0
  continue;
2521
0
}
2522
0
case OP_CastSint16Uint8: {
2523
0
  if (!Cast<PT_Sint16, PT_Uint8>(S, OpPC))
2524
0
    return false;
2525
0
  continue;
2526
0
}
2527
0
case OP_CastSint16Sint8: {
2528
0
  if (!Cast<PT_Sint16, PT_Sint8>(S, OpPC))
2529
0
    return false;
2530
0
  continue;
2531
0
}
2532
0
case OP_CastSint16Uint16: {
2533
0
  if (!Cast<PT_Sint16, PT_Uint16>(S, OpPC))
2534
0
    return false;
2535
0
  continue;
2536
0
}
2537
0
case OP_CastSint16Sint16: {
2538
0
  if (!Cast<PT_Sint16, PT_Sint16>(S, OpPC))
2539
0
    return false;
2540
0
  continue;
2541
0
}
2542
0
case OP_CastSint16Uint32: {
2543
0
  if (!Cast<PT_Sint16, PT_Uint32>(S, OpPC))
2544
0
    return false;
2545
0
  continue;
2546
0
}
2547
0
case OP_CastSint16Sint32: {
2548
0
  if (!Cast<PT_Sint16, PT_Sint32>(S, OpPC))
2549
0
    return false;
2550
0
  continue;
2551
0
}
2552
0
case OP_CastSint16Uint64: {
2553
0
  if (!Cast<PT_Sint16, PT_Uint64>(S, OpPC))
2554
0
    return false;
2555
0
  continue;
2556
0
}
2557
0
case OP_CastSint16Sint64: {
2558
0
  if (!Cast<PT_Sint16, PT_Sint64>(S, OpPC))
2559
0
    return false;
2560
0
  continue;
2561
0
}
2562
0
case OP_CastSint16Bool: {
2563
0
  if (!Cast<PT_Sint16, PT_Bool>(S, OpPC))
2564
0
    return false;
2565
0
  continue;
2566
0
}
2567
0
case OP_CastUint32Uint8: {
2568
0
  if (!Cast<PT_Uint32, PT_Uint8>(S, OpPC))
2569
0
    return false;
2570
0
  continue;
2571
0
}
2572
0
case OP_CastUint32Sint8: {
2573
0
  if (!Cast<PT_Uint32, PT_Sint8>(S, OpPC))
2574
0
    return false;
2575
0
  continue;
2576
0
}
2577
0
case OP_CastUint32Uint16: {
2578
0
  if (!Cast<PT_Uint32, PT_Uint16>(S, OpPC))
2579
0
    return false;
2580
0
  continue;
2581
0
}
2582
0
case OP_CastUint32Sint16: {
2583
0
  if (!Cast<PT_Uint32, PT_Sint16>(S, OpPC))
2584
0
    return false;
2585
0
  continue;
2586
0
}
2587
0
case OP_CastUint32Uint32: {
2588
0
  if (!Cast<PT_Uint32, PT_Uint32>(S, OpPC))
2589
0
    return false;
2590
0
  continue;
2591
0
}
2592
0
case OP_CastUint32Sint32: {
2593
0
  if (!Cast<PT_Uint32, PT_Sint32>(S, OpPC))
2594
0
    return false;
2595
0
  continue;
2596
0
}
2597
0
case OP_CastUint32Uint64: {
2598
0
  if (!Cast<PT_Uint32, PT_Uint64>(S, OpPC))
2599
0
    return false;
2600
0
  continue;
2601
0
}
2602
0
case OP_CastUint32Sint64: {
2603
0
  if (!Cast<PT_Uint32, PT_Sint64>(S, OpPC))
2604
0
    return false;
2605
0
  continue;
2606
0
}
2607
0
case OP_CastUint32Bool: {
2608
0
  if (!Cast<PT_Uint32, PT_Bool>(S, OpPC))
2609
0
    return false;
2610
0
  continue;
2611
0
}
2612
0
case OP_CastSint32Uint8: {
2613
0
  if (!Cast<PT_Sint32, PT_Uint8>(S, OpPC))
2614
0
    return false;
2615
0
  continue;
2616
0
}
2617
0
case OP_CastSint32Sint8: {
2618
0
  if (!Cast<PT_Sint32, PT_Sint8>(S, OpPC))
2619
0
    return false;
2620
0
  continue;
2621
0
}
2622
0
case OP_CastSint32Uint16: {
2623
0
  if (!Cast<PT_Sint32, PT_Uint16>(S, OpPC))
2624
0
    return false;
2625
0
  continue;
2626
0
}
2627
0
case OP_CastSint32Sint16: {
2628
0
  if (!Cast<PT_Sint32, PT_Sint16>(S, OpPC))
2629
0
    return false;
2630
0
  continue;
2631
0
}
2632
0
case OP_CastSint32Uint32: {
2633
0
  if (!Cast<PT_Sint32, PT_Uint32>(S, OpPC))
2634
0
    return false;
2635
0
  continue;
2636
0
}
2637
0
case OP_CastSint32Sint32: {
2638
0
  if (!Cast<PT_Sint32, PT_Sint32>(S, OpPC))
2639
0
    return false;
2640
0
  continue;
2641
0
}
2642
0
case OP_CastSint32Uint64: {
2643
0
  if (!Cast<PT_Sint32, PT_Uint64>(S, OpPC))
2644
0
    return false;
2645
0
  continue;
2646
0
}
2647
0
case OP_CastSint32Sint64: {
2648
0
  if (!Cast<PT_Sint32, PT_Sint64>(S, OpPC))
2649
0
    return false;
2650
0
  continue;
2651
0
}
2652
0
case OP_CastSint32Bool: {
2653
0
  if (!Cast<PT_Sint32, PT_Bool>(S, OpPC))
2654
0
    return false;
2655
0
  continue;
2656
0
}
2657
0
case OP_CastUint64Uint8: {
2658
0
  if (!Cast<PT_Uint64, PT_Uint8>(S, OpPC))
2659
0
    return false;
2660
0
  continue;
2661
0
}
2662
0
case OP_CastUint64Sint8: {
2663
0
  if (!Cast<PT_Uint64, PT_Sint8>(S, OpPC))
2664
0
    return false;
2665
0
  continue;
2666
0
}
2667
0
case OP_CastUint64Uint16: {
2668
0
  if (!Cast<PT_Uint64, PT_Uint16>(S, OpPC))
2669
0
    return false;
2670
0
  continue;
2671
0
}
2672
0
case OP_CastUint64Sint16: {
2673
0
  if (!Cast<PT_Uint64, PT_Sint16>(S, OpPC))
2674
0
    return false;
2675
0
  continue;
2676
0
}
2677
0
case OP_CastUint64Uint32: {
2678
0
  if (!Cast<PT_Uint64, PT_Uint32>(S, OpPC))
2679
0
    return false;
2680
0
  continue;
2681
0
}
2682
0
case OP_CastUint64Sint32: {
2683
0
  if (!Cast<PT_Uint64, PT_Sint32>(S, OpPC))
2684
0
    return false;
2685
0
  continue;
2686
0
}
2687
0
case OP_CastUint64Uint64: {
2688
0
  if (!Cast<PT_Uint64, PT_Uint64>(S, OpPC))
2689
0
    return false;
2690
0
  continue;
2691
0
}
2692
0
case OP_CastUint64Sint64: {
2693
0
  if (!Cast<PT_Uint64, PT_Sint64>(S, OpPC))
2694
0
    return false;
2695
0
  continue;
2696
0
}
2697
0
case OP_CastUint64Bool: {
2698
0
  if (!Cast<PT_Uint64, PT_Bool>(S, OpPC))
2699
0
    return false;
2700
0
  continue;
2701
0
}
2702
0
case OP_CastSint64Uint8: {
2703
0
  if (!Cast<PT_Sint64, PT_Uint8>(S, OpPC))
2704
0
    return false;
2705
0
  continue;
2706
0
}
2707
0
case OP_CastSint64Sint8: {
2708
0
  if (!Cast<PT_Sint64, PT_Sint8>(S, OpPC))
2709
0
    return false;
2710
0
  continue;
2711
0
}
2712
0
case OP_CastSint64Uint16: {
2713
0
  if (!Cast<PT_Sint64, PT_Uint16>(S, OpPC))
2714
0
    return false;
2715
0
  continue;
2716
0
}
2717
0
case OP_CastSint64Sint16: {
2718
0
  if (!Cast<PT_Sint64, PT_Sint16>(S, OpPC))
2719
0
    return false;
2720
0
  continue;
2721
0
}
2722
0
case OP_CastSint64Uint32: {
2723
0
  if (!Cast<PT_Sint64, PT_Uint32>(S, OpPC))
2724
0
    return false;
2725
0
  continue;
2726
0
}
2727
0
case OP_CastSint64Sint32: {
2728
0
  if (!Cast<PT_Sint64, PT_Sint32>(S, OpPC))
2729
0
    return false;
2730
0
  continue;
2731
0
}
2732
0
case OP_CastSint64Uint64: {
2733
0
  if (!Cast<PT_Sint64, PT_Uint64>(S, OpPC))
2734
0
    return false;
2735
0
  continue;
2736
0
}
2737
0
case OP_CastSint64Sint64: {
2738
0
  if (!Cast<PT_Sint64, PT_Sint64>(S, OpPC))
2739
0
    return false;
2740
0
  continue;
2741
0
}
2742
0
case OP_CastSint64Bool: {
2743
0
  if (!Cast<PT_Sint64, PT_Bool>(S, OpPC))
2744
0
    return false;
2745
0
  continue;
2746
0
}
2747
0
case OP_CastBoolUint8: {
2748
0
  if (!Cast<PT_Bool, PT_Uint8>(S, OpPC))
2749
0
    return false;
2750
0
  continue;
2751
0
}
2752
0
case OP_CastBoolSint8: {
2753
0
  if (!Cast<PT_Bool, PT_Sint8>(S, OpPC))
2754
0
    return false;
2755
0
  continue;
2756
0
}
2757
0
case OP_CastBoolUint16: {
2758
0
  if (!Cast<PT_Bool, PT_Uint16>(S, OpPC))
2759
0
    return false;
2760
0
  continue;
2761
0
}
2762
0
case OP_CastBoolSint16: {
2763
0
  if (!Cast<PT_Bool, PT_Sint16>(S, OpPC))
2764
0
    return false;
2765
0
  continue;
2766
0
}
2767
0
case OP_CastBoolUint32: {
2768
0
  if (!Cast<PT_Bool, PT_Uint32>(S, OpPC))
2769
0
    return false;
2770
0
  continue;
2771
0
}
2772
0
case OP_CastBoolSint32: {
2773
0
  if (!Cast<PT_Bool, PT_Sint32>(S, OpPC))
2774
0
    return false;
2775
0
  continue;
2776
0
}
2777
0
case OP_CastBoolUint64: {
2778
0
  if (!Cast<PT_Bool, PT_Uint64>(S, OpPC))
2779
0
    return false;
2780
0
  continue;
2781
0
}
2782
0
case OP_CastBoolSint64: {
2783
0
  if (!Cast<PT_Bool, PT_Sint64>(S, OpPC))
2784
0
    return false;
2785
0
  continue;
2786
0
}
2787
0
case OP_CastBoolBool: {
2788
0
  if (!Cast<PT_Bool, PT_Bool>(S, OpPC))
2789
0
    return false;
2790
0
  continue;
2791
0
}
2792
0
case OP_CastIntAPUint8: {
2793
0
  if (!Cast<PT_IntAP, PT_Uint8>(S, OpPC))
2794
0
    return false;
2795
0
  continue;
2796
0
}
2797
0
case OP_CastIntAPSint8: {
2798
0
  if (!Cast<PT_IntAP, PT_Sint8>(S, OpPC))
2799
0
    return false;
2800
0
  continue;
2801
0
}
2802
0
case OP_CastIntAPUint16: {
2803
0
  if (!Cast<PT_IntAP, PT_Uint16>(S, OpPC))
2804
0
    return false;
2805
0
  continue;
2806
0
}
2807
0
case OP_CastIntAPSint16: {
2808
0
  if (!Cast<PT_IntAP, PT_Sint16>(S, OpPC))
2809
0
    return false;
2810
0
  continue;
2811
0
}
2812
0
case OP_CastIntAPUint32: {
2813
0
  if (!Cast<PT_IntAP, PT_Uint32>(S, OpPC))
2814
0
    return false;
2815
0
  continue;
2816
0
}
2817
0
case OP_CastIntAPSint32: {
2818
0
  if (!Cast<PT_IntAP, PT_Sint32>(S, OpPC))
2819
0
    return false;
2820
0
  continue;
2821
0
}
2822
0
case OP_CastIntAPUint64: {
2823
0
  if (!Cast<PT_IntAP, PT_Uint64>(S, OpPC))
2824
0
    return false;
2825
0
  continue;
2826
0
}
2827
0
case OP_CastIntAPSint64: {
2828
0
  if (!Cast<PT_IntAP, PT_Sint64>(S, OpPC))
2829
0
    return false;
2830
0
  continue;
2831
0
}
2832
0
case OP_CastIntAPBool: {
2833
0
  if (!Cast<PT_IntAP, PT_Bool>(S, OpPC))
2834
0
    return false;
2835
0
  continue;
2836
0
}
2837
0
case OP_CastIntAPSUint8: {
2838
0
  if (!Cast<PT_IntAPS, PT_Uint8>(S, OpPC))
2839
0
    return false;
2840
0
  continue;
2841
0
}
2842
0
case OP_CastIntAPSSint8: {
2843
0
  if (!Cast<PT_IntAPS, PT_Sint8>(S, OpPC))
2844
0
    return false;
2845
0
  continue;
2846
0
}
2847
0
case OP_CastIntAPSUint16: {
2848
0
  if (!Cast<PT_IntAPS, PT_Uint16>(S, OpPC))
2849
0
    return false;
2850
0
  continue;
2851
0
}
2852
0
case OP_CastIntAPSSint16: {
2853
0
  if (!Cast<PT_IntAPS, PT_Sint16>(S, OpPC))
2854
0
    return false;
2855
0
  continue;
2856
0
}
2857
0
case OP_CastIntAPSUint32: {
2858
0
  if (!Cast<PT_IntAPS, PT_Uint32>(S, OpPC))
2859
0
    return false;
2860
0
  continue;
2861
0
}
2862
0
case OP_CastIntAPSSint32: {
2863
0
  if (!Cast<PT_IntAPS, PT_Sint32>(S, OpPC))
2864
0
    return false;
2865
0
  continue;
2866
0
}
2867
0
case OP_CastIntAPSUint64: {
2868
0
  if (!Cast<PT_IntAPS, PT_Uint64>(S, OpPC))
2869
0
    return false;
2870
0
  continue;
2871
0
}
2872
0
case OP_CastIntAPSSint64: {
2873
0
  if (!Cast<PT_IntAPS, PT_Sint64>(S, OpPC))
2874
0
    return false;
2875
0
  continue;
2876
0
}
2877
0
case OP_CastIntAPSBool: {
2878
0
  if (!Cast<PT_IntAPS, PT_Bool>(S, OpPC))
2879
0
    return false;
2880
0
  continue;
2881
0
}
2882
0
#endif
2883
#ifdef GET_DISASM
2884
case OP_CastUint8Uint8:
2885
  PrintName("CastUint8Uint8");
2886
  OS << "\t" << "\n";
2887
  continue;
2888
case OP_CastUint8Sint8:
2889
  PrintName("CastUint8Sint8");
2890
  OS << "\t" << "\n";
2891
  continue;
2892
case OP_CastUint8Uint16:
2893
  PrintName("CastUint8Uint16");
2894
  OS << "\t" << "\n";
2895
  continue;
2896
case OP_CastUint8Sint16:
2897
  PrintName("CastUint8Sint16");
2898
  OS << "\t" << "\n";
2899
  continue;
2900
case OP_CastUint8Uint32:
2901
  PrintName("CastUint8Uint32");
2902
  OS << "\t" << "\n";
2903
  continue;
2904
case OP_CastUint8Sint32:
2905
  PrintName("CastUint8Sint32");
2906
  OS << "\t" << "\n";
2907
  continue;
2908
case OP_CastUint8Uint64:
2909
  PrintName("CastUint8Uint64");
2910
  OS << "\t" << "\n";
2911
  continue;
2912
case OP_CastUint8Sint64:
2913
  PrintName("CastUint8Sint64");
2914
  OS << "\t" << "\n";
2915
  continue;
2916
case OP_CastUint8Bool:
2917
  PrintName("CastUint8Bool");
2918
  OS << "\t" << "\n";
2919
  continue;
2920
case OP_CastSint8Uint8:
2921
  PrintName("CastSint8Uint8");
2922
  OS << "\t" << "\n";
2923
  continue;
2924
case OP_CastSint8Sint8:
2925
  PrintName("CastSint8Sint8");
2926
  OS << "\t" << "\n";
2927
  continue;
2928
case OP_CastSint8Uint16:
2929
  PrintName("CastSint8Uint16");
2930
  OS << "\t" << "\n";
2931
  continue;
2932
case OP_CastSint8Sint16:
2933
  PrintName("CastSint8Sint16");
2934
  OS << "\t" << "\n";
2935
  continue;
2936
case OP_CastSint8Uint32:
2937
  PrintName("CastSint8Uint32");
2938
  OS << "\t" << "\n";
2939
  continue;
2940
case OP_CastSint8Sint32:
2941
  PrintName("CastSint8Sint32");
2942
  OS << "\t" << "\n";
2943
  continue;
2944
case OP_CastSint8Uint64:
2945
  PrintName("CastSint8Uint64");
2946
  OS << "\t" << "\n";
2947
  continue;
2948
case OP_CastSint8Sint64:
2949
  PrintName("CastSint8Sint64");
2950
  OS << "\t" << "\n";
2951
  continue;
2952
case OP_CastSint8Bool:
2953
  PrintName("CastSint8Bool");
2954
  OS << "\t" << "\n";
2955
  continue;
2956
case OP_CastUint16Uint8:
2957
  PrintName("CastUint16Uint8");
2958
  OS << "\t" << "\n";
2959
  continue;
2960
case OP_CastUint16Sint8:
2961
  PrintName("CastUint16Sint8");
2962
  OS << "\t" << "\n";
2963
  continue;
2964
case OP_CastUint16Uint16:
2965
  PrintName("CastUint16Uint16");
2966
  OS << "\t" << "\n";
2967
  continue;
2968
case OP_CastUint16Sint16:
2969
  PrintName("CastUint16Sint16");
2970
  OS << "\t" << "\n";
2971
  continue;
2972
case OP_CastUint16Uint32:
2973
  PrintName("CastUint16Uint32");
2974
  OS << "\t" << "\n";
2975
  continue;
2976
case OP_CastUint16Sint32:
2977
  PrintName("CastUint16Sint32");
2978
  OS << "\t" << "\n";
2979
  continue;
2980
case OP_CastUint16Uint64:
2981
  PrintName("CastUint16Uint64");
2982
  OS << "\t" << "\n";
2983
  continue;
2984
case OP_CastUint16Sint64:
2985
  PrintName("CastUint16Sint64");
2986
  OS << "\t" << "\n";
2987
  continue;
2988
case OP_CastUint16Bool:
2989
  PrintName("CastUint16Bool");
2990
  OS << "\t" << "\n";
2991
  continue;
2992
case OP_CastSint16Uint8:
2993
  PrintName("CastSint16Uint8");
2994
  OS << "\t" << "\n";
2995
  continue;
2996
case OP_CastSint16Sint8:
2997
  PrintName("CastSint16Sint8");
2998
  OS << "\t" << "\n";
2999
  continue;
3000
case OP_CastSint16Uint16:
3001
  PrintName("CastSint16Uint16");
3002
  OS << "\t" << "\n";
3003
  continue;
3004
case OP_CastSint16Sint16:
3005
  PrintName("CastSint16Sint16");
3006
  OS << "\t" << "\n";
3007
  continue;
3008
case OP_CastSint16Uint32:
3009
  PrintName("CastSint16Uint32");
3010
  OS << "\t" << "\n";
3011
  continue;
3012
case OP_CastSint16Sint32:
3013
  PrintName("CastSint16Sint32");
3014
  OS << "\t" << "\n";
3015
  continue;
3016
case OP_CastSint16Uint64:
3017
  PrintName("CastSint16Uint64");
3018
  OS << "\t" << "\n";
3019
  continue;
3020
case OP_CastSint16Sint64:
3021
  PrintName("CastSint16Sint64");
3022
  OS << "\t" << "\n";
3023
  continue;
3024
case OP_CastSint16Bool:
3025
  PrintName("CastSint16Bool");
3026
  OS << "\t" << "\n";
3027
  continue;
3028
case OP_CastUint32Uint8:
3029
  PrintName("CastUint32Uint8");
3030
  OS << "\t" << "\n";
3031
  continue;
3032
case OP_CastUint32Sint8:
3033
  PrintName("CastUint32Sint8");
3034
  OS << "\t" << "\n";
3035
  continue;
3036
case OP_CastUint32Uint16:
3037
  PrintName("CastUint32Uint16");
3038
  OS << "\t" << "\n";
3039
  continue;
3040
case OP_CastUint32Sint16:
3041
  PrintName("CastUint32Sint16");
3042
  OS << "\t" << "\n";
3043
  continue;
3044
case OP_CastUint32Uint32:
3045
  PrintName("CastUint32Uint32");
3046
  OS << "\t" << "\n";
3047
  continue;
3048
case OP_CastUint32Sint32:
3049
  PrintName("CastUint32Sint32");
3050
  OS << "\t" << "\n";
3051
  continue;
3052
case OP_CastUint32Uint64:
3053
  PrintName("CastUint32Uint64");
3054
  OS << "\t" << "\n";
3055
  continue;
3056
case OP_CastUint32Sint64:
3057
  PrintName("CastUint32Sint64");
3058
  OS << "\t" << "\n";
3059
  continue;
3060
case OP_CastUint32Bool:
3061
  PrintName("CastUint32Bool");
3062
  OS << "\t" << "\n";
3063
  continue;
3064
case OP_CastSint32Uint8:
3065
  PrintName("CastSint32Uint8");
3066
  OS << "\t" << "\n";
3067
  continue;
3068
case OP_CastSint32Sint8:
3069
  PrintName("CastSint32Sint8");
3070
  OS << "\t" << "\n";
3071
  continue;
3072
case OP_CastSint32Uint16:
3073
  PrintName("CastSint32Uint16");
3074
  OS << "\t" << "\n";
3075
  continue;
3076
case OP_CastSint32Sint16:
3077
  PrintName("CastSint32Sint16");
3078
  OS << "\t" << "\n";
3079
  continue;
3080
case OP_CastSint32Uint32:
3081
  PrintName("CastSint32Uint32");
3082
  OS << "\t" << "\n";
3083
  continue;
3084
case OP_CastSint32Sint32:
3085
  PrintName("CastSint32Sint32");
3086
  OS << "\t" << "\n";
3087
  continue;
3088
case OP_CastSint32Uint64:
3089
  PrintName("CastSint32Uint64");
3090
  OS << "\t" << "\n";
3091
  continue;
3092
case OP_CastSint32Sint64:
3093
  PrintName("CastSint32Sint64");
3094
  OS << "\t" << "\n";
3095
  continue;
3096
case OP_CastSint32Bool:
3097
  PrintName("CastSint32Bool");
3098
  OS << "\t" << "\n";
3099
  continue;
3100
case OP_CastUint64Uint8:
3101
  PrintName("CastUint64Uint8");
3102
  OS << "\t" << "\n";
3103
  continue;
3104
case OP_CastUint64Sint8:
3105
  PrintName("CastUint64Sint8");
3106
  OS << "\t" << "\n";
3107
  continue;
3108
case OP_CastUint64Uint16:
3109
  PrintName("CastUint64Uint16");
3110
  OS << "\t" << "\n";
3111
  continue;
3112
case OP_CastUint64Sint16:
3113
  PrintName("CastUint64Sint16");
3114
  OS << "\t" << "\n";
3115
  continue;
3116
case OP_CastUint64Uint32:
3117
  PrintName("CastUint64Uint32");
3118
  OS << "\t" << "\n";
3119
  continue;
3120
case OP_CastUint64Sint32:
3121
  PrintName("CastUint64Sint32");
3122
  OS << "\t" << "\n";
3123
  continue;
3124
case OP_CastUint64Uint64:
3125
  PrintName("CastUint64Uint64");
3126
  OS << "\t" << "\n";
3127
  continue;
3128
case OP_CastUint64Sint64:
3129
  PrintName("CastUint64Sint64");
3130
  OS << "\t" << "\n";
3131
  continue;
3132
case OP_CastUint64Bool:
3133
  PrintName("CastUint64Bool");
3134
  OS << "\t" << "\n";
3135
  continue;
3136
case OP_CastSint64Uint8:
3137
  PrintName("CastSint64Uint8");
3138
  OS << "\t" << "\n";
3139
  continue;
3140
case OP_CastSint64Sint8:
3141
  PrintName("CastSint64Sint8");
3142
  OS << "\t" << "\n";
3143
  continue;
3144
case OP_CastSint64Uint16:
3145
  PrintName("CastSint64Uint16");
3146
  OS << "\t" << "\n";
3147
  continue;
3148
case OP_CastSint64Sint16:
3149
  PrintName("CastSint64Sint16");
3150
  OS << "\t" << "\n";
3151
  continue;
3152
case OP_CastSint64Uint32:
3153
  PrintName("CastSint64Uint32");
3154
  OS << "\t" << "\n";
3155
  continue;
3156
case OP_CastSint64Sint32:
3157
  PrintName("CastSint64Sint32");
3158
  OS << "\t" << "\n";
3159
  continue;
3160
case OP_CastSint64Uint64:
3161
  PrintName("CastSint64Uint64");
3162
  OS << "\t" << "\n";
3163
  continue;
3164
case OP_CastSint64Sint64:
3165
  PrintName("CastSint64Sint64");
3166
  OS << "\t" << "\n";
3167
  continue;
3168
case OP_CastSint64Bool:
3169
  PrintName("CastSint64Bool");
3170
  OS << "\t" << "\n";
3171
  continue;
3172
case OP_CastBoolUint8:
3173
  PrintName("CastBoolUint8");
3174
  OS << "\t" << "\n";
3175
  continue;
3176
case OP_CastBoolSint8:
3177
  PrintName("CastBoolSint8");
3178
  OS << "\t" << "\n";
3179
  continue;
3180
case OP_CastBoolUint16:
3181
  PrintName("CastBoolUint16");
3182
  OS << "\t" << "\n";
3183
  continue;
3184
case OP_CastBoolSint16:
3185
  PrintName("CastBoolSint16");
3186
  OS << "\t" << "\n";
3187
  continue;
3188
case OP_CastBoolUint32:
3189
  PrintName("CastBoolUint32");
3190
  OS << "\t" << "\n";
3191
  continue;
3192
case OP_CastBoolSint32:
3193
  PrintName("CastBoolSint32");
3194
  OS << "\t" << "\n";
3195
  continue;
3196
case OP_CastBoolUint64:
3197
  PrintName("CastBoolUint64");
3198
  OS << "\t" << "\n";
3199
  continue;
3200
case OP_CastBoolSint64:
3201
  PrintName("CastBoolSint64");
3202
  OS << "\t" << "\n";
3203
  continue;
3204
case OP_CastBoolBool:
3205
  PrintName("CastBoolBool");
3206
  OS << "\t" << "\n";
3207
  continue;
3208
case OP_CastIntAPUint8:
3209
  PrintName("CastIntAPUint8");
3210
  OS << "\t" << "\n";
3211
  continue;
3212
case OP_CastIntAPSint8:
3213
  PrintName("CastIntAPSint8");
3214
  OS << "\t" << "\n";
3215
  continue;
3216
case OP_CastIntAPUint16:
3217
  PrintName("CastIntAPUint16");
3218
  OS << "\t" << "\n";
3219
  continue;
3220
case OP_CastIntAPSint16:
3221
  PrintName("CastIntAPSint16");
3222
  OS << "\t" << "\n";
3223
  continue;
3224
case OP_CastIntAPUint32:
3225
  PrintName("CastIntAPUint32");
3226
  OS << "\t" << "\n";
3227
  continue;
3228
case OP_CastIntAPSint32:
3229
  PrintName("CastIntAPSint32");
3230
  OS << "\t" << "\n";
3231
  continue;
3232
case OP_CastIntAPUint64:
3233
  PrintName("CastIntAPUint64");
3234
  OS << "\t" << "\n";
3235
  continue;
3236
case OP_CastIntAPSint64:
3237
  PrintName("CastIntAPSint64");
3238
  OS << "\t" << "\n";
3239
  continue;
3240
case OP_CastIntAPBool:
3241
  PrintName("CastIntAPBool");
3242
  OS << "\t" << "\n";
3243
  continue;
3244
case OP_CastIntAPSUint8:
3245
  PrintName("CastIntAPSUint8");
3246
  OS << "\t" << "\n";
3247
  continue;
3248
case OP_CastIntAPSSint8:
3249
  PrintName("CastIntAPSSint8");
3250
  OS << "\t" << "\n";
3251
  continue;
3252
case OP_CastIntAPSUint16:
3253
  PrintName("CastIntAPSUint16");
3254
  OS << "\t" << "\n";
3255
  continue;
3256
case OP_CastIntAPSSint16:
3257
  PrintName("CastIntAPSSint16");
3258
  OS << "\t" << "\n";
3259
  continue;
3260
case OP_CastIntAPSUint32:
3261
  PrintName("CastIntAPSUint32");
3262
  OS << "\t" << "\n";
3263
  continue;
3264
case OP_CastIntAPSSint32:
3265
  PrintName("CastIntAPSSint32");
3266
  OS << "\t" << "\n";
3267
  continue;
3268
case OP_CastIntAPSUint64:
3269
  PrintName("CastIntAPSUint64");
3270
  OS << "\t" << "\n";
3271
  continue;
3272
case OP_CastIntAPSSint64:
3273
  PrintName("CastIntAPSSint64");
3274
  OS << "\t" << "\n";
3275
  continue;
3276
case OP_CastIntAPSBool:
3277
  PrintName("CastIntAPSBool");
3278
  OS << "\t" << "\n";
3279
  continue;
3280
#endif
3281
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3282
bool emitCastUint8Uint8(const SourceInfo &);
3283
bool emitCastUint8Sint8(const SourceInfo &);
3284
bool emitCastUint8Uint16(const SourceInfo &);
3285
bool emitCastUint8Sint16(const SourceInfo &);
3286
bool emitCastUint8Uint32(const SourceInfo &);
3287
bool emitCastUint8Sint32(const SourceInfo &);
3288
bool emitCastUint8Uint64(const SourceInfo &);
3289
bool emitCastUint8Sint64(const SourceInfo &);
3290
bool emitCastUint8Bool(const SourceInfo &);
3291
bool emitCastSint8Uint8(const SourceInfo &);
3292
bool emitCastSint8Sint8(const SourceInfo &);
3293
bool emitCastSint8Uint16(const SourceInfo &);
3294
bool emitCastSint8Sint16(const SourceInfo &);
3295
bool emitCastSint8Uint32(const SourceInfo &);
3296
bool emitCastSint8Sint32(const SourceInfo &);
3297
bool emitCastSint8Uint64(const SourceInfo &);
3298
bool emitCastSint8Sint64(const SourceInfo &);
3299
bool emitCastSint8Bool(const SourceInfo &);
3300
bool emitCastUint16Uint8(const SourceInfo &);
3301
bool emitCastUint16Sint8(const SourceInfo &);
3302
bool emitCastUint16Uint16(const SourceInfo &);
3303
bool emitCastUint16Sint16(const SourceInfo &);
3304
bool emitCastUint16Uint32(const SourceInfo &);
3305
bool emitCastUint16Sint32(const SourceInfo &);
3306
bool emitCastUint16Uint64(const SourceInfo &);
3307
bool emitCastUint16Sint64(const SourceInfo &);
3308
bool emitCastUint16Bool(const SourceInfo &);
3309
bool emitCastSint16Uint8(const SourceInfo &);
3310
bool emitCastSint16Sint8(const SourceInfo &);
3311
bool emitCastSint16Uint16(const SourceInfo &);
3312
bool emitCastSint16Sint16(const SourceInfo &);
3313
bool emitCastSint16Uint32(const SourceInfo &);
3314
bool emitCastSint16Sint32(const SourceInfo &);
3315
bool emitCastSint16Uint64(const SourceInfo &);
3316
bool emitCastSint16Sint64(const SourceInfo &);
3317
bool emitCastSint16Bool(const SourceInfo &);
3318
bool emitCastUint32Uint8(const SourceInfo &);
3319
bool emitCastUint32Sint8(const SourceInfo &);
3320
bool emitCastUint32Uint16(const SourceInfo &);
3321
bool emitCastUint32Sint16(const SourceInfo &);
3322
bool emitCastUint32Uint32(const SourceInfo &);
3323
bool emitCastUint32Sint32(const SourceInfo &);
3324
bool emitCastUint32Uint64(const SourceInfo &);
3325
bool emitCastUint32Sint64(const SourceInfo &);
3326
bool emitCastUint32Bool(const SourceInfo &);
3327
bool emitCastSint32Uint8(const SourceInfo &);
3328
bool emitCastSint32Sint8(const SourceInfo &);
3329
bool emitCastSint32Uint16(const SourceInfo &);
3330
bool emitCastSint32Sint16(const SourceInfo &);
3331
bool emitCastSint32Uint32(const SourceInfo &);
3332
bool emitCastSint32Sint32(const SourceInfo &);
3333
bool emitCastSint32Uint64(const SourceInfo &);
3334
bool emitCastSint32Sint64(const SourceInfo &);
3335
bool emitCastSint32Bool(const SourceInfo &);
3336
bool emitCastUint64Uint8(const SourceInfo &);
3337
bool emitCastUint64Sint8(const SourceInfo &);
3338
bool emitCastUint64Uint16(const SourceInfo &);
3339
bool emitCastUint64Sint16(const SourceInfo &);
3340
bool emitCastUint64Uint32(const SourceInfo &);
3341
bool emitCastUint64Sint32(const SourceInfo &);
3342
bool emitCastUint64Uint64(const SourceInfo &);
3343
bool emitCastUint64Sint64(const SourceInfo &);
3344
bool emitCastUint64Bool(const SourceInfo &);
3345
bool emitCastSint64Uint8(const SourceInfo &);
3346
bool emitCastSint64Sint8(const SourceInfo &);
3347
bool emitCastSint64Uint16(const SourceInfo &);
3348
bool emitCastSint64Sint16(const SourceInfo &);
3349
bool emitCastSint64Uint32(const SourceInfo &);
3350
bool emitCastSint64Sint32(const SourceInfo &);
3351
bool emitCastSint64Uint64(const SourceInfo &);
3352
bool emitCastSint64Sint64(const SourceInfo &);
3353
bool emitCastSint64Bool(const SourceInfo &);
3354
bool emitCastBoolUint8(const SourceInfo &);
3355
bool emitCastBoolSint8(const SourceInfo &);
3356
bool emitCastBoolUint16(const SourceInfo &);
3357
bool emitCastBoolSint16(const SourceInfo &);
3358
bool emitCastBoolUint32(const SourceInfo &);
3359
bool emitCastBoolSint32(const SourceInfo &);
3360
bool emitCastBoolUint64(const SourceInfo &);
3361
bool emitCastBoolSint64(const SourceInfo &);
3362
bool emitCastBoolBool(const SourceInfo &);
3363
bool emitCastIntAPUint8(const SourceInfo &);
3364
bool emitCastIntAPSint8(const SourceInfo &);
3365
bool emitCastIntAPUint16(const SourceInfo &);
3366
bool emitCastIntAPSint16(const SourceInfo &);
3367
bool emitCastIntAPUint32(const SourceInfo &);
3368
bool emitCastIntAPSint32(const SourceInfo &);
3369
bool emitCastIntAPUint64(const SourceInfo &);
3370
bool emitCastIntAPSint64(const SourceInfo &);
3371
bool emitCastIntAPBool(const SourceInfo &);
3372
bool emitCastIntAPSUint8(const SourceInfo &);
3373
bool emitCastIntAPSSint8(const SourceInfo &);
3374
bool emitCastIntAPSUint16(const SourceInfo &);
3375
bool emitCastIntAPSSint16(const SourceInfo &);
3376
bool emitCastIntAPSUint32(const SourceInfo &);
3377
bool emitCastIntAPSSint32(const SourceInfo &);
3378
bool emitCastIntAPSUint64(const SourceInfo &);
3379
bool emitCastIntAPSSint64(const SourceInfo &);
3380
bool emitCastIntAPSBool(const SourceInfo &);
3381
#endif
3382
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3383
bool emitCast(PrimType, PrimType, const SourceInfo &I);
3384
#endif
3385
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
3386
bool
3387
#if defined(GET_EVAL_IMPL)
3388
EvalEmitter
3389
#else
3390
ByteCodeEmitter
3391
#endif
3392
0
::emitCast(PrimType T0, PrimType T1, const SourceInfo &I) {
3393
0
  switch (T0) {
3394
0
  case PT_Uint8:
3395
0
  switch (T1) {
3396
0
  case PT_Uint8:
3397
0
    return emitCastUint8Uint8(I);
3398
0
  case PT_Sint8:
3399
0
    return emitCastUint8Sint8(I);
3400
0
  case PT_Uint16:
3401
0
    return emitCastUint8Uint16(I);
3402
0
  case PT_Sint16:
3403
0
    return emitCastUint8Sint16(I);
3404
0
  case PT_Uint32:
3405
0
    return emitCastUint8Uint32(I);
3406
0
  case PT_Sint32:
3407
0
    return emitCastUint8Sint32(I);
3408
0
  case PT_Uint64:
3409
0
    return emitCastUint8Uint64(I);
3410
0
  case PT_Sint64:
3411
0
    return emitCastUint8Sint64(I);
3412
0
  case PT_Bool:
3413
0
    return emitCastUint8Bool(I);
3414
0
  default: llvm_unreachable("invalid type: emitCast");
3415
0
  }
3416
0
  llvm_unreachable("invalid enum value");
3417
0
  case PT_Sint8:
3418
0
  switch (T1) {
3419
0
  case PT_Uint8:
3420
0
    return emitCastSint8Uint8(I);
3421
0
  case PT_Sint8:
3422
0
    return emitCastSint8Sint8(I);
3423
0
  case PT_Uint16:
3424
0
    return emitCastSint8Uint16(I);
3425
0
  case PT_Sint16:
3426
0
    return emitCastSint8Sint16(I);
3427
0
  case PT_Uint32:
3428
0
    return emitCastSint8Uint32(I);
3429
0
  case PT_Sint32:
3430
0
    return emitCastSint8Sint32(I);
3431
0
  case PT_Uint64:
3432
0
    return emitCastSint8Uint64(I);
3433
0
  case PT_Sint64:
3434
0
    return emitCastSint8Sint64(I);
3435
0
  case PT_Bool:
3436
0
    return emitCastSint8Bool(I);
3437
0
  default: llvm_unreachable("invalid type: emitCast");
3438
0
  }
3439
0
  llvm_unreachable("invalid enum value");
3440
0
  case PT_Uint16:
3441
0
  switch (T1) {
3442
0
  case PT_Uint8:
3443
0
    return emitCastUint16Uint8(I);
3444
0
  case PT_Sint8:
3445
0
    return emitCastUint16Sint8(I);
3446
0
  case PT_Uint16:
3447
0
    return emitCastUint16Uint16(I);
3448
0
  case PT_Sint16:
3449
0
    return emitCastUint16Sint16(I);
3450
0
  case PT_Uint32:
3451
0
    return emitCastUint16Uint32(I);
3452
0
  case PT_Sint32:
3453
0
    return emitCastUint16Sint32(I);
3454
0
  case PT_Uint64:
3455
0
    return emitCastUint16Uint64(I);
3456
0
  case PT_Sint64:
3457
0
    return emitCastUint16Sint64(I);
3458
0
  case PT_Bool:
3459
0
    return emitCastUint16Bool(I);
3460
0
  default: llvm_unreachable("invalid type: emitCast");
3461
0
  }
3462
0
  llvm_unreachable("invalid enum value");
3463
0
  case PT_Sint16:
3464
0
  switch (T1) {
3465
0
  case PT_Uint8:
3466
0
    return emitCastSint16Uint8(I);
3467
0
  case PT_Sint8:
3468
0
    return emitCastSint16Sint8(I);
3469
0
  case PT_Uint16:
3470
0
    return emitCastSint16Uint16(I);
3471
0
  case PT_Sint16:
3472
0
    return emitCastSint16Sint16(I);
3473
0
  case PT_Uint32:
3474
0
    return emitCastSint16Uint32(I);
3475
0
  case PT_Sint32:
3476
0
    return emitCastSint16Sint32(I);
3477
0
  case PT_Uint64:
3478
0
    return emitCastSint16Uint64(I);
3479
0
  case PT_Sint64:
3480
0
    return emitCastSint16Sint64(I);
3481
0
  case PT_Bool:
3482
0
    return emitCastSint16Bool(I);
3483
0
  default: llvm_unreachable("invalid type: emitCast");
3484
0
  }
3485
0
  llvm_unreachable("invalid enum value");
3486
0
  case PT_Uint32:
3487
0
  switch (T1) {
3488
0
  case PT_Uint8:
3489
0
    return emitCastUint32Uint8(I);
3490
0
  case PT_Sint8:
3491
0
    return emitCastUint32Sint8(I);
3492
0
  case PT_Uint16:
3493
0
    return emitCastUint32Uint16(I);
3494
0
  case PT_Sint16:
3495
0
    return emitCastUint32Sint16(I);
3496
0
  case PT_Uint32:
3497
0
    return emitCastUint32Uint32(I);
3498
0
  case PT_Sint32:
3499
0
    return emitCastUint32Sint32(I);
3500
0
  case PT_Uint64:
3501
0
    return emitCastUint32Uint64(I);
3502
0
  case PT_Sint64:
3503
0
    return emitCastUint32Sint64(I);
3504
0
  case PT_Bool:
3505
0
    return emitCastUint32Bool(I);
3506
0
  default: llvm_unreachable("invalid type: emitCast");
3507
0
  }
3508
0
  llvm_unreachable("invalid enum value");
3509
0
  case PT_Sint32:
3510
0
  switch (T1) {
3511
0
  case PT_Uint8:
3512
0
    return emitCastSint32Uint8(I);
3513
0
  case PT_Sint8:
3514
0
    return emitCastSint32Sint8(I);
3515
0
  case PT_Uint16:
3516
0
    return emitCastSint32Uint16(I);
3517
0
  case PT_Sint16:
3518
0
    return emitCastSint32Sint16(I);
3519
0
  case PT_Uint32:
3520
0
    return emitCastSint32Uint32(I);
3521
0
  case PT_Sint32:
3522
0
    return emitCastSint32Sint32(I);
3523
0
  case PT_Uint64:
3524
0
    return emitCastSint32Uint64(I);
3525
0
  case PT_Sint64:
3526
0
    return emitCastSint32Sint64(I);
3527
0
  case PT_Bool:
3528
0
    return emitCastSint32Bool(I);
3529
0
  default: llvm_unreachable("invalid type: emitCast");
3530
0
  }
3531
0
  llvm_unreachable("invalid enum value");
3532
0
  case PT_Uint64:
3533
0
  switch (T1) {
3534
0
  case PT_Uint8:
3535
0
    return emitCastUint64Uint8(I);
3536
0
  case PT_Sint8:
3537
0
    return emitCastUint64Sint8(I);
3538
0
  case PT_Uint16:
3539
0
    return emitCastUint64Uint16(I);
3540
0
  case PT_Sint16:
3541
0
    return emitCastUint64Sint16(I);
3542
0
  case PT_Uint32:
3543
0
    return emitCastUint64Uint32(I);
3544
0
  case PT_Sint32:
3545
0
    return emitCastUint64Sint32(I);
3546
0
  case PT_Uint64:
3547
0
    return emitCastUint64Uint64(I);
3548
0
  case PT_Sint64:
3549
0
    return emitCastUint64Sint64(I);
3550
0
  case PT_Bool:
3551
0
    return emitCastUint64Bool(I);
3552
0
  default: llvm_unreachable("invalid type: emitCast");
3553
0
  }
3554
0
  llvm_unreachable("invalid enum value");
3555
0
  case PT_Sint64:
3556
0
  switch (T1) {
3557
0
  case PT_Uint8:
3558
0
    return emitCastSint64Uint8(I);
3559
0
  case PT_Sint8:
3560
0
    return emitCastSint64Sint8(I);
3561
0
  case PT_Uint16:
3562
0
    return emitCastSint64Uint16(I);
3563
0
  case PT_Sint16:
3564
0
    return emitCastSint64Sint16(I);
3565
0
  case PT_Uint32:
3566
0
    return emitCastSint64Uint32(I);
3567
0
  case PT_Sint32:
3568
0
    return emitCastSint64Sint32(I);
3569
0
  case PT_Uint64:
3570
0
    return emitCastSint64Uint64(I);
3571
0
  case PT_Sint64:
3572
0
    return emitCastSint64Sint64(I);
3573
0
  case PT_Bool:
3574
0
    return emitCastSint64Bool(I);
3575
0
  default: llvm_unreachable("invalid type: emitCast");
3576
0
  }
3577
0
  llvm_unreachable("invalid enum value");
3578
0
  case PT_Bool:
3579
0
  switch (T1) {
3580
0
  case PT_Uint8:
3581
0
    return emitCastBoolUint8(I);
3582
0
  case PT_Sint8:
3583
0
    return emitCastBoolSint8(I);
3584
0
  case PT_Uint16:
3585
0
    return emitCastBoolUint16(I);
3586
0
  case PT_Sint16:
3587
0
    return emitCastBoolSint16(I);
3588
0
  case PT_Uint32:
3589
0
    return emitCastBoolUint32(I);
3590
0
  case PT_Sint32:
3591
0
    return emitCastBoolSint32(I);
3592
0
  case PT_Uint64:
3593
0
    return emitCastBoolUint64(I);
3594
0
  case PT_Sint64:
3595
0
    return emitCastBoolSint64(I);
3596
0
  case PT_Bool:
3597
0
    return emitCastBoolBool(I);
3598
0
  default: llvm_unreachable("invalid type: emitCast");
3599
0
  }
3600
0
  llvm_unreachable("invalid enum value");
3601
0
  case PT_IntAP:
3602
0
  switch (T1) {
3603
0
  case PT_Uint8:
3604
0
    return emitCastIntAPUint8(I);
3605
0
  case PT_Sint8:
3606
0
    return emitCastIntAPSint8(I);
3607
0
  case PT_Uint16:
3608
0
    return emitCastIntAPUint16(I);
3609
0
  case PT_Sint16:
3610
0
    return emitCastIntAPSint16(I);
3611
0
  case PT_Uint32:
3612
0
    return emitCastIntAPUint32(I);
3613
0
  case PT_Sint32:
3614
0
    return emitCastIntAPSint32(I);
3615
0
  case PT_Uint64:
3616
0
    return emitCastIntAPUint64(I);
3617
0
  case PT_Sint64:
3618
0
    return emitCastIntAPSint64(I);
3619
0
  case PT_Bool:
3620
0
    return emitCastIntAPBool(I);
3621
0
  default: llvm_unreachable("invalid type: emitCast");
3622
0
  }
3623
0
  llvm_unreachable("invalid enum value");
3624
0
  case PT_IntAPS:
3625
0
  switch (T1) {
3626
0
  case PT_Uint8:
3627
0
    return emitCastIntAPSUint8(I);
3628
0
  case PT_Sint8:
3629
0
    return emitCastIntAPSSint8(I);
3630
0
  case PT_Uint16:
3631
0
    return emitCastIntAPSUint16(I);
3632
0
  case PT_Sint16:
3633
0
    return emitCastIntAPSSint16(I);
3634
0
  case PT_Uint32:
3635
0
    return emitCastIntAPSUint32(I);
3636
0
  case PT_Sint32:
3637
0
    return emitCastIntAPSSint32(I);
3638
0
  case PT_Uint64:
3639
0
    return emitCastIntAPSUint64(I);
3640
0
  case PT_Sint64:
3641
0
    return emitCastIntAPSSint64(I);
3642
0
  case PT_Bool:
3643
0
    return emitCastIntAPSBool(I);
3644
0
  default: llvm_unreachable("invalid type: emitCast");
3645
0
  }
3646
0
  llvm_unreachable("invalid enum value");
3647
0
  default: llvm_unreachable("invalid type: emitCast");
3648
0
  }
3649
0
  llvm_unreachable("invalid enum value");
3650
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCast(clang::interp::PrimType, clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCast(clang::interp::PrimType, clang::interp::PrimType, clang::interp::SourceInfo const&)
3651
#endif
3652
#ifdef GET_LINK_IMPL
3653
0
bool ByteCodeEmitter::emitCastUint8Uint8(const SourceInfo &L) {
3654
0
  return emitOp<>(OP_CastUint8Uint8, L);
3655
0
}
3656
0
bool ByteCodeEmitter::emitCastUint8Sint8(const SourceInfo &L) {
3657
0
  return emitOp<>(OP_CastUint8Sint8, L);
3658
0
}
3659
0
bool ByteCodeEmitter::emitCastUint8Uint16(const SourceInfo &L) {
3660
0
  return emitOp<>(OP_CastUint8Uint16, L);
3661
0
}
3662
0
bool ByteCodeEmitter::emitCastUint8Sint16(const SourceInfo &L) {
3663
0
  return emitOp<>(OP_CastUint8Sint16, L);
3664
0
}
3665
0
bool ByteCodeEmitter::emitCastUint8Uint32(const SourceInfo &L) {
3666
0
  return emitOp<>(OP_CastUint8Uint32, L);
3667
0
}
3668
0
bool ByteCodeEmitter::emitCastUint8Sint32(const SourceInfo &L) {
3669
0
  return emitOp<>(OP_CastUint8Sint32, L);
3670
0
}
3671
0
bool ByteCodeEmitter::emitCastUint8Uint64(const SourceInfo &L) {
3672
0
  return emitOp<>(OP_CastUint8Uint64, L);
3673
0
}
3674
0
bool ByteCodeEmitter::emitCastUint8Sint64(const SourceInfo &L) {
3675
0
  return emitOp<>(OP_CastUint8Sint64, L);
3676
0
}
3677
0
bool ByteCodeEmitter::emitCastUint8Bool(const SourceInfo &L) {
3678
0
  return emitOp<>(OP_CastUint8Bool, L);
3679
0
}
3680
0
bool ByteCodeEmitter::emitCastSint8Uint8(const SourceInfo &L) {
3681
0
  return emitOp<>(OP_CastSint8Uint8, L);
3682
0
}
3683
0
bool ByteCodeEmitter::emitCastSint8Sint8(const SourceInfo &L) {
3684
0
  return emitOp<>(OP_CastSint8Sint8, L);
3685
0
}
3686
0
bool ByteCodeEmitter::emitCastSint8Uint16(const SourceInfo &L) {
3687
0
  return emitOp<>(OP_CastSint8Uint16, L);
3688
0
}
3689
0
bool ByteCodeEmitter::emitCastSint8Sint16(const SourceInfo &L) {
3690
0
  return emitOp<>(OP_CastSint8Sint16, L);
3691
0
}
3692
0
bool ByteCodeEmitter::emitCastSint8Uint32(const SourceInfo &L) {
3693
0
  return emitOp<>(OP_CastSint8Uint32, L);
3694
0
}
3695
0
bool ByteCodeEmitter::emitCastSint8Sint32(const SourceInfo &L) {
3696
0
  return emitOp<>(OP_CastSint8Sint32, L);
3697
0
}
3698
0
bool ByteCodeEmitter::emitCastSint8Uint64(const SourceInfo &L) {
3699
0
  return emitOp<>(OP_CastSint8Uint64, L);
3700
0
}
3701
0
bool ByteCodeEmitter::emitCastSint8Sint64(const SourceInfo &L) {
3702
0
  return emitOp<>(OP_CastSint8Sint64, L);
3703
0
}
3704
0
bool ByteCodeEmitter::emitCastSint8Bool(const SourceInfo &L) {
3705
0
  return emitOp<>(OP_CastSint8Bool, L);
3706
0
}
3707
0
bool ByteCodeEmitter::emitCastUint16Uint8(const SourceInfo &L) {
3708
0
  return emitOp<>(OP_CastUint16Uint8, L);
3709
0
}
3710
0
bool ByteCodeEmitter::emitCastUint16Sint8(const SourceInfo &L) {
3711
0
  return emitOp<>(OP_CastUint16Sint8, L);
3712
0
}
3713
0
bool ByteCodeEmitter::emitCastUint16Uint16(const SourceInfo &L) {
3714
0
  return emitOp<>(OP_CastUint16Uint16, L);
3715
0
}
3716
0
bool ByteCodeEmitter::emitCastUint16Sint16(const SourceInfo &L) {
3717
0
  return emitOp<>(OP_CastUint16Sint16, L);
3718
0
}
3719
0
bool ByteCodeEmitter::emitCastUint16Uint32(const SourceInfo &L) {
3720
0
  return emitOp<>(OP_CastUint16Uint32, L);
3721
0
}
3722
0
bool ByteCodeEmitter::emitCastUint16Sint32(const SourceInfo &L) {
3723
0
  return emitOp<>(OP_CastUint16Sint32, L);
3724
0
}
3725
0
bool ByteCodeEmitter::emitCastUint16Uint64(const SourceInfo &L) {
3726
0
  return emitOp<>(OP_CastUint16Uint64, L);
3727
0
}
3728
0
bool ByteCodeEmitter::emitCastUint16Sint64(const SourceInfo &L) {
3729
0
  return emitOp<>(OP_CastUint16Sint64, L);
3730
0
}
3731
0
bool ByteCodeEmitter::emitCastUint16Bool(const SourceInfo &L) {
3732
0
  return emitOp<>(OP_CastUint16Bool, L);
3733
0
}
3734
0
bool ByteCodeEmitter::emitCastSint16Uint8(const SourceInfo &L) {
3735
0
  return emitOp<>(OP_CastSint16Uint8, L);
3736
0
}
3737
0
bool ByteCodeEmitter::emitCastSint16Sint8(const SourceInfo &L) {
3738
0
  return emitOp<>(OP_CastSint16Sint8, L);
3739
0
}
3740
0
bool ByteCodeEmitter::emitCastSint16Uint16(const SourceInfo &L) {
3741
0
  return emitOp<>(OP_CastSint16Uint16, L);
3742
0
}
3743
0
bool ByteCodeEmitter::emitCastSint16Sint16(const SourceInfo &L) {
3744
0
  return emitOp<>(OP_CastSint16Sint16, L);
3745
0
}
3746
0
bool ByteCodeEmitter::emitCastSint16Uint32(const SourceInfo &L) {
3747
0
  return emitOp<>(OP_CastSint16Uint32, L);
3748
0
}
3749
0
bool ByteCodeEmitter::emitCastSint16Sint32(const SourceInfo &L) {
3750
0
  return emitOp<>(OP_CastSint16Sint32, L);
3751
0
}
3752
0
bool ByteCodeEmitter::emitCastSint16Uint64(const SourceInfo &L) {
3753
0
  return emitOp<>(OP_CastSint16Uint64, L);
3754
0
}
3755
0
bool ByteCodeEmitter::emitCastSint16Sint64(const SourceInfo &L) {
3756
0
  return emitOp<>(OP_CastSint16Sint64, L);
3757
0
}
3758
0
bool ByteCodeEmitter::emitCastSint16Bool(const SourceInfo &L) {
3759
0
  return emitOp<>(OP_CastSint16Bool, L);
3760
0
}
3761
0
bool ByteCodeEmitter::emitCastUint32Uint8(const SourceInfo &L) {
3762
0
  return emitOp<>(OP_CastUint32Uint8, L);
3763
0
}
3764
0
bool ByteCodeEmitter::emitCastUint32Sint8(const SourceInfo &L) {
3765
0
  return emitOp<>(OP_CastUint32Sint8, L);
3766
0
}
3767
0
bool ByteCodeEmitter::emitCastUint32Uint16(const SourceInfo &L) {
3768
0
  return emitOp<>(OP_CastUint32Uint16, L);
3769
0
}
3770
0
bool ByteCodeEmitter::emitCastUint32Sint16(const SourceInfo &L) {
3771
0
  return emitOp<>(OP_CastUint32Sint16, L);
3772
0
}
3773
0
bool ByteCodeEmitter::emitCastUint32Uint32(const SourceInfo &L) {
3774
0
  return emitOp<>(OP_CastUint32Uint32, L);
3775
0
}
3776
0
bool ByteCodeEmitter::emitCastUint32Sint32(const SourceInfo &L) {
3777
0
  return emitOp<>(OP_CastUint32Sint32, L);
3778
0
}
3779
0
bool ByteCodeEmitter::emitCastUint32Uint64(const SourceInfo &L) {
3780
0
  return emitOp<>(OP_CastUint32Uint64, L);
3781
0
}
3782
0
bool ByteCodeEmitter::emitCastUint32Sint64(const SourceInfo &L) {
3783
0
  return emitOp<>(OP_CastUint32Sint64, L);
3784
0
}
3785
0
bool ByteCodeEmitter::emitCastUint32Bool(const SourceInfo &L) {
3786
0
  return emitOp<>(OP_CastUint32Bool, L);
3787
0
}
3788
0
bool ByteCodeEmitter::emitCastSint32Uint8(const SourceInfo &L) {
3789
0
  return emitOp<>(OP_CastSint32Uint8, L);
3790
0
}
3791
0
bool ByteCodeEmitter::emitCastSint32Sint8(const SourceInfo &L) {
3792
0
  return emitOp<>(OP_CastSint32Sint8, L);
3793
0
}
3794
0
bool ByteCodeEmitter::emitCastSint32Uint16(const SourceInfo &L) {
3795
0
  return emitOp<>(OP_CastSint32Uint16, L);
3796
0
}
3797
0
bool ByteCodeEmitter::emitCastSint32Sint16(const SourceInfo &L) {
3798
0
  return emitOp<>(OP_CastSint32Sint16, L);
3799
0
}
3800
0
bool ByteCodeEmitter::emitCastSint32Uint32(const SourceInfo &L) {
3801
0
  return emitOp<>(OP_CastSint32Uint32, L);
3802
0
}
3803
0
bool ByteCodeEmitter::emitCastSint32Sint32(const SourceInfo &L) {
3804
0
  return emitOp<>(OP_CastSint32Sint32, L);
3805
0
}
3806
0
bool ByteCodeEmitter::emitCastSint32Uint64(const SourceInfo &L) {
3807
0
  return emitOp<>(OP_CastSint32Uint64, L);
3808
0
}
3809
0
bool ByteCodeEmitter::emitCastSint32Sint64(const SourceInfo &L) {
3810
0
  return emitOp<>(OP_CastSint32Sint64, L);
3811
0
}
3812
0
bool ByteCodeEmitter::emitCastSint32Bool(const SourceInfo &L) {
3813
0
  return emitOp<>(OP_CastSint32Bool, L);
3814
0
}
3815
0
bool ByteCodeEmitter::emitCastUint64Uint8(const SourceInfo &L) {
3816
0
  return emitOp<>(OP_CastUint64Uint8, L);
3817
0
}
3818
0
bool ByteCodeEmitter::emitCastUint64Sint8(const SourceInfo &L) {
3819
0
  return emitOp<>(OP_CastUint64Sint8, L);
3820
0
}
3821
0
bool ByteCodeEmitter::emitCastUint64Uint16(const SourceInfo &L) {
3822
0
  return emitOp<>(OP_CastUint64Uint16, L);
3823
0
}
3824
0
bool ByteCodeEmitter::emitCastUint64Sint16(const SourceInfo &L) {
3825
0
  return emitOp<>(OP_CastUint64Sint16, L);
3826
0
}
3827
0
bool ByteCodeEmitter::emitCastUint64Uint32(const SourceInfo &L) {
3828
0
  return emitOp<>(OP_CastUint64Uint32, L);
3829
0
}
3830
0
bool ByteCodeEmitter::emitCastUint64Sint32(const SourceInfo &L) {
3831
0
  return emitOp<>(OP_CastUint64Sint32, L);
3832
0
}
3833
0
bool ByteCodeEmitter::emitCastUint64Uint64(const SourceInfo &L) {
3834
0
  return emitOp<>(OP_CastUint64Uint64, L);
3835
0
}
3836
0
bool ByteCodeEmitter::emitCastUint64Sint64(const SourceInfo &L) {
3837
0
  return emitOp<>(OP_CastUint64Sint64, L);
3838
0
}
3839
0
bool ByteCodeEmitter::emitCastUint64Bool(const SourceInfo &L) {
3840
0
  return emitOp<>(OP_CastUint64Bool, L);
3841
0
}
3842
0
bool ByteCodeEmitter::emitCastSint64Uint8(const SourceInfo &L) {
3843
0
  return emitOp<>(OP_CastSint64Uint8, L);
3844
0
}
3845
0
bool ByteCodeEmitter::emitCastSint64Sint8(const SourceInfo &L) {
3846
0
  return emitOp<>(OP_CastSint64Sint8, L);
3847
0
}
3848
0
bool ByteCodeEmitter::emitCastSint64Uint16(const SourceInfo &L) {
3849
0
  return emitOp<>(OP_CastSint64Uint16, L);
3850
0
}
3851
0
bool ByteCodeEmitter::emitCastSint64Sint16(const SourceInfo &L) {
3852
0
  return emitOp<>(OP_CastSint64Sint16, L);
3853
0
}
3854
0
bool ByteCodeEmitter::emitCastSint64Uint32(const SourceInfo &L) {
3855
0
  return emitOp<>(OP_CastSint64Uint32, L);
3856
0
}
3857
0
bool ByteCodeEmitter::emitCastSint64Sint32(const SourceInfo &L) {
3858
0
  return emitOp<>(OP_CastSint64Sint32, L);
3859
0
}
3860
0
bool ByteCodeEmitter::emitCastSint64Uint64(const SourceInfo &L) {
3861
0
  return emitOp<>(OP_CastSint64Uint64, L);
3862
0
}
3863
0
bool ByteCodeEmitter::emitCastSint64Sint64(const SourceInfo &L) {
3864
0
  return emitOp<>(OP_CastSint64Sint64, L);
3865
0
}
3866
0
bool ByteCodeEmitter::emitCastSint64Bool(const SourceInfo &L) {
3867
0
  return emitOp<>(OP_CastSint64Bool, L);
3868
0
}
3869
0
bool ByteCodeEmitter::emitCastBoolUint8(const SourceInfo &L) {
3870
0
  return emitOp<>(OP_CastBoolUint8, L);
3871
0
}
3872
0
bool ByteCodeEmitter::emitCastBoolSint8(const SourceInfo &L) {
3873
0
  return emitOp<>(OP_CastBoolSint8, L);
3874
0
}
3875
0
bool ByteCodeEmitter::emitCastBoolUint16(const SourceInfo &L) {
3876
0
  return emitOp<>(OP_CastBoolUint16, L);
3877
0
}
3878
0
bool ByteCodeEmitter::emitCastBoolSint16(const SourceInfo &L) {
3879
0
  return emitOp<>(OP_CastBoolSint16, L);
3880
0
}
3881
0
bool ByteCodeEmitter::emitCastBoolUint32(const SourceInfo &L) {
3882
0
  return emitOp<>(OP_CastBoolUint32, L);
3883
0
}
3884
0
bool ByteCodeEmitter::emitCastBoolSint32(const SourceInfo &L) {
3885
0
  return emitOp<>(OP_CastBoolSint32, L);
3886
0
}
3887
0
bool ByteCodeEmitter::emitCastBoolUint64(const SourceInfo &L) {
3888
0
  return emitOp<>(OP_CastBoolUint64, L);
3889
0
}
3890
0
bool ByteCodeEmitter::emitCastBoolSint64(const SourceInfo &L) {
3891
0
  return emitOp<>(OP_CastBoolSint64, L);
3892
0
}
3893
0
bool ByteCodeEmitter::emitCastBoolBool(const SourceInfo &L) {
3894
0
  return emitOp<>(OP_CastBoolBool, L);
3895
0
}
3896
0
bool ByteCodeEmitter::emitCastIntAPUint8(const SourceInfo &L) {
3897
0
  return emitOp<>(OP_CastIntAPUint8, L);
3898
0
}
3899
0
bool ByteCodeEmitter::emitCastIntAPSint8(const SourceInfo &L) {
3900
0
  return emitOp<>(OP_CastIntAPSint8, L);
3901
0
}
3902
0
bool ByteCodeEmitter::emitCastIntAPUint16(const SourceInfo &L) {
3903
0
  return emitOp<>(OP_CastIntAPUint16, L);
3904
0
}
3905
0
bool ByteCodeEmitter::emitCastIntAPSint16(const SourceInfo &L) {
3906
0
  return emitOp<>(OP_CastIntAPSint16, L);
3907
0
}
3908
0
bool ByteCodeEmitter::emitCastIntAPUint32(const SourceInfo &L) {
3909
0
  return emitOp<>(OP_CastIntAPUint32, L);
3910
0
}
3911
0
bool ByteCodeEmitter::emitCastIntAPSint32(const SourceInfo &L) {
3912
0
  return emitOp<>(OP_CastIntAPSint32, L);
3913
0
}
3914
0
bool ByteCodeEmitter::emitCastIntAPUint64(const SourceInfo &L) {
3915
0
  return emitOp<>(OP_CastIntAPUint64, L);
3916
0
}
3917
0
bool ByteCodeEmitter::emitCastIntAPSint64(const SourceInfo &L) {
3918
0
  return emitOp<>(OP_CastIntAPSint64, L);
3919
0
}
3920
0
bool ByteCodeEmitter::emitCastIntAPBool(const SourceInfo &L) {
3921
0
  return emitOp<>(OP_CastIntAPBool, L);
3922
0
}
3923
0
bool ByteCodeEmitter::emitCastIntAPSUint8(const SourceInfo &L) {
3924
0
  return emitOp<>(OP_CastIntAPSUint8, L);
3925
0
}
3926
0
bool ByteCodeEmitter::emitCastIntAPSSint8(const SourceInfo &L) {
3927
0
  return emitOp<>(OP_CastIntAPSSint8, L);
3928
0
}
3929
0
bool ByteCodeEmitter::emitCastIntAPSUint16(const SourceInfo &L) {
3930
0
  return emitOp<>(OP_CastIntAPSUint16, L);
3931
0
}
3932
0
bool ByteCodeEmitter::emitCastIntAPSSint16(const SourceInfo &L) {
3933
0
  return emitOp<>(OP_CastIntAPSSint16, L);
3934
0
}
3935
0
bool ByteCodeEmitter::emitCastIntAPSUint32(const SourceInfo &L) {
3936
0
  return emitOp<>(OP_CastIntAPSUint32, L);
3937
0
}
3938
0
bool ByteCodeEmitter::emitCastIntAPSSint32(const SourceInfo &L) {
3939
0
  return emitOp<>(OP_CastIntAPSSint32, L);
3940
0
}
3941
0
bool ByteCodeEmitter::emitCastIntAPSUint64(const SourceInfo &L) {
3942
0
  return emitOp<>(OP_CastIntAPSUint64, L);
3943
0
}
3944
0
bool ByteCodeEmitter::emitCastIntAPSSint64(const SourceInfo &L) {
3945
0
  return emitOp<>(OP_CastIntAPSSint64, L);
3946
0
}
3947
0
bool ByteCodeEmitter::emitCastIntAPSBool(const SourceInfo &L) {
3948
0
  return emitOp<>(OP_CastIntAPSBool, L);
3949
0
}
3950
#endif
3951
#ifdef GET_EVAL_IMPL
3952
0
bool EvalEmitter::emitCastUint8Uint8(const SourceInfo &L) {
3953
0
  if (!isActive()) return true;
3954
0
  CurrentSource = L;
3955
0
  return Cast<PT_Uint8, PT_Uint8>(S, OpPC);
3956
0
}
3957
0
bool EvalEmitter::emitCastUint8Sint8(const SourceInfo &L) {
3958
0
  if (!isActive()) return true;
3959
0
  CurrentSource = L;
3960
0
  return Cast<PT_Uint8, PT_Sint8>(S, OpPC);
3961
0
}
3962
0
bool EvalEmitter::emitCastUint8Uint16(const SourceInfo &L) {
3963
0
  if (!isActive()) return true;
3964
0
  CurrentSource = L;
3965
0
  return Cast<PT_Uint8, PT_Uint16>(S, OpPC);
3966
0
}
3967
0
bool EvalEmitter::emitCastUint8Sint16(const SourceInfo &L) {
3968
0
  if (!isActive()) return true;
3969
0
  CurrentSource = L;
3970
0
  return Cast<PT_Uint8, PT_Sint16>(S, OpPC);
3971
0
}
3972
0
bool EvalEmitter::emitCastUint8Uint32(const SourceInfo &L) {
3973
0
  if (!isActive()) return true;
3974
0
  CurrentSource = L;
3975
0
  return Cast<PT_Uint8, PT_Uint32>(S, OpPC);
3976
0
}
3977
0
bool EvalEmitter::emitCastUint8Sint32(const SourceInfo &L) {
3978
0
  if (!isActive()) return true;
3979
0
  CurrentSource = L;
3980
0
  return Cast<PT_Uint8, PT_Sint32>(S, OpPC);
3981
0
}
3982
0
bool EvalEmitter::emitCastUint8Uint64(const SourceInfo &L) {
3983
0
  if (!isActive()) return true;
3984
0
  CurrentSource = L;
3985
0
  return Cast<PT_Uint8, PT_Uint64>(S, OpPC);
3986
0
}
3987
0
bool EvalEmitter::emitCastUint8Sint64(const SourceInfo &L) {
3988
0
  if (!isActive()) return true;
3989
0
  CurrentSource = L;
3990
0
  return Cast<PT_Uint8, PT_Sint64>(S, OpPC);
3991
0
}
3992
0
bool EvalEmitter::emitCastUint8Bool(const SourceInfo &L) {
3993
0
  if (!isActive()) return true;
3994
0
  CurrentSource = L;
3995
0
  return Cast<PT_Uint8, PT_Bool>(S, OpPC);
3996
0
}
3997
0
bool EvalEmitter::emitCastSint8Uint8(const SourceInfo &L) {
3998
0
  if (!isActive()) return true;
3999
0
  CurrentSource = L;
4000
0
  return Cast<PT_Sint8, PT_Uint8>(S, OpPC);
4001
0
}
4002
0
bool EvalEmitter::emitCastSint8Sint8(const SourceInfo &L) {
4003
0
  if (!isActive()) return true;
4004
0
  CurrentSource = L;
4005
0
  return Cast<PT_Sint8, PT_Sint8>(S, OpPC);
4006
0
}
4007
0
bool EvalEmitter::emitCastSint8Uint16(const SourceInfo &L) {
4008
0
  if (!isActive()) return true;
4009
0
  CurrentSource = L;
4010
0
  return Cast<PT_Sint8, PT_Uint16>(S, OpPC);
4011
0
}
4012
0
bool EvalEmitter::emitCastSint8Sint16(const SourceInfo &L) {
4013
0
  if (!isActive()) return true;
4014
0
  CurrentSource = L;
4015
0
  return Cast<PT_Sint8, PT_Sint16>(S, OpPC);
4016
0
}
4017
0
bool EvalEmitter::emitCastSint8Uint32(const SourceInfo &L) {
4018
0
  if (!isActive()) return true;
4019
0
  CurrentSource = L;
4020
0
  return Cast<PT_Sint8, PT_Uint32>(S, OpPC);
4021
0
}
4022
0
bool EvalEmitter::emitCastSint8Sint32(const SourceInfo &L) {
4023
0
  if (!isActive()) return true;
4024
0
  CurrentSource = L;
4025
0
  return Cast<PT_Sint8, PT_Sint32>(S, OpPC);
4026
0
}
4027
0
bool EvalEmitter::emitCastSint8Uint64(const SourceInfo &L) {
4028
0
  if (!isActive()) return true;
4029
0
  CurrentSource = L;
4030
0
  return Cast<PT_Sint8, PT_Uint64>(S, OpPC);
4031
0
}
4032
0
bool EvalEmitter::emitCastSint8Sint64(const SourceInfo &L) {
4033
0
  if (!isActive()) return true;
4034
0
  CurrentSource = L;
4035
0
  return Cast<PT_Sint8, PT_Sint64>(S, OpPC);
4036
0
}
4037
0
bool EvalEmitter::emitCastSint8Bool(const SourceInfo &L) {
4038
0
  if (!isActive()) return true;
4039
0
  CurrentSource = L;
4040
0
  return Cast<PT_Sint8, PT_Bool>(S, OpPC);
4041
0
}
4042
0
bool EvalEmitter::emitCastUint16Uint8(const SourceInfo &L) {
4043
0
  if (!isActive()) return true;
4044
0
  CurrentSource = L;
4045
0
  return Cast<PT_Uint16, PT_Uint8>(S, OpPC);
4046
0
}
4047
0
bool EvalEmitter::emitCastUint16Sint8(const SourceInfo &L) {
4048
0
  if (!isActive()) return true;
4049
0
  CurrentSource = L;
4050
0
  return Cast<PT_Uint16, PT_Sint8>(S, OpPC);
4051
0
}
4052
0
bool EvalEmitter::emitCastUint16Uint16(const SourceInfo &L) {
4053
0
  if (!isActive()) return true;
4054
0
  CurrentSource = L;
4055
0
  return Cast<PT_Uint16, PT_Uint16>(S, OpPC);
4056
0
}
4057
0
bool EvalEmitter::emitCastUint16Sint16(const SourceInfo &L) {
4058
0
  if (!isActive()) return true;
4059
0
  CurrentSource = L;
4060
0
  return Cast<PT_Uint16, PT_Sint16>(S, OpPC);
4061
0
}
4062
0
bool EvalEmitter::emitCastUint16Uint32(const SourceInfo &L) {
4063
0
  if (!isActive()) return true;
4064
0
  CurrentSource = L;
4065
0
  return Cast<PT_Uint16, PT_Uint32>(S, OpPC);
4066
0
}
4067
0
bool EvalEmitter::emitCastUint16Sint32(const SourceInfo &L) {
4068
0
  if (!isActive()) return true;
4069
0
  CurrentSource = L;
4070
0
  return Cast<PT_Uint16, PT_Sint32>(S, OpPC);
4071
0
}
4072
0
bool EvalEmitter::emitCastUint16Uint64(const SourceInfo &L) {
4073
0
  if (!isActive()) return true;
4074
0
  CurrentSource = L;
4075
0
  return Cast<PT_Uint16, PT_Uint64>(S, OpPC);
4076
0
}
4077
0
bool EvalEmitter::emitCastUint16Sint64(const SourceInfo &L) {
4078
0
  if (!isActive()) return true;
4079
0
  CurrentSource = L;
4080
0
  return Cast<PT_Uint16, PT_Sint64>(S, OpPC);
4081
0
}
4082
0
bool EvalEmitter::emitCastUint16Bool(const SourceInfo &L) {
4083
0
  if (!isActive()) return true;
4084
0
  CurrentSource = L;
4085
0
  return Cast<PT_Uint16, PT_Bool>(S, OpPC);
4086
0
}
4087
0
bool EvalEmitter::emitCastSint16Uint8(const SourceInfo &L) {
4088
0
  if (!isActive()) return true;
4089
0
  CurrentSource = L;
4090
0
  return Cast<PT_Sint16, PT_Uint8>(S, OpPC);
4091
0
}
4092
0
bool EvalEmitter::emitCastSint16Sint8(const SourceInfo &L) {
4093
0
  if (!isActive()) return true;
4094
0
  CurrentSource = L;
4095
0
  return Cast<PT_Sint16, PT_Sint8>(S, OpPC);
4096
0
}
4097
0
bool EvalEmitter::emitCastSint16Uint16(const SourceInfo &L) {
4098
0
  if (!isActive()) return true;
4099
0
  CurrentSource = L;
4100
0
  return Cast<PT_Sint16, PT_Uint16>(S, OpPC);
4101
0
}
4102
0
bool EvalEmitter::emitCastSint16Sint16(const SourceInfo &L) {
4103
0
  if (!isActive()) return true;
4104
0
  CurrentSource = L;
4105
0
  return Cast<PT_Sint16, PT_Sint16>(S, OpPC);
4106
0
}
4107
0
bool EvalEmitter::emitCastSint16Uint32(const SourceInfo &L) {
4108
0
  if (!isActive()) return true;
4109
0
  CurrentSource = L;
4110
0
  return Cast<PT_Sint16, PT_Uint32>(S, OpPC);
4111
0
}
4112
0
bool EvalEmitter::emitCastSint16Sint32(const SourceInfo &L) {
4113
0
  if (!isActive()) return true;
4114
0
  CurrentSource = L;
4115
0
  return Cast<PT_Sint16, PT_Sint32>(S, OpPC);
4116
0
}
4117
0
bool EvalEmitter::emitCastSint16Uint64(const SourceInfo &L) {
4118
0
  if (!isActive()) return true;
4119
0
  CurrentSource = L;
4120
0
  return Cast<PT_Sint16, PT_Uint64>(S, OpPC);
4121
0
}
4122
0
bool EvalEmitter::emitCastSint16Sint64(const SourceInfo &L) {
4123
0
  if (!isActive()) return true;
4124
0
  CurrentSource = L;
4125
0
  return Cast<PT_Sint16, PT_Sint64>(S, OpPC);
4126
0
}
4127
0
bool EvalEmitter::emitCastSint16Bool(const SourceInfo &L) {
4128
0
  if (!isActive()) return true;
4129
0
  CurrentSource = L;
4130
0
  return Cast<PT_Sint16, PT_Bool>(S, OpPC);
4131
0
}
4132
0
bool EvalEmitter::emitCastUint32Uint8(const SourceInfo &L) {
4133
0
  if (!isActive()) return true;
4134
0
  CurrentSource = L;
4135
0
  return Cast<PT_Uint32, PT_Uint8>(S, OpPC);
4136
0
}
4137
0
bool EvalEmitter::emitCastUint32Sint8(const SourceInfo &L) {
4138
0
  if (!isActive()) return true;
4139
0
  CurrentSource = L;
4140
0
  return Cast<PT_Uint32, PT_Sint8>(S, OpPC);
4141
0
}
4142
0
bool EvalEmitter::emitCastUint32Uint16(const SourceInfo &L) {
4143
0
  if (!isActive()) return true;
4144
0
  CurrentSource = L;
4145
0
  return Cast<PT_Uint32, PT_Uint16>(S, OpPC);
4146
0
}
4147
0
bool EvalEmitter::emitCastUint32Sint16(const SourceInfo &L) {
4148
0
  if (!isActive()) return true;
4149
0
  CurrentSource = L;
4150
0
  return Cast<PT_Uint32, PT_Sint16>(S, OpPC);
4151
0
}
4152
0
bool EvalEmitter::emitCastUint32Uint32(const SourceInfo &L) {
4153
0
  if (!isActive()) return true;
4154
0
  CurrentSource = L;
4155
0
  return Cast<PT_Uint32, PT_Uint32>(S, OpPC);
4156
0
}
4157
0
bool EvalEmitter::emitCastUint32Sint32(const SourceInfo &L) {
4158
0
  if (!isActive()) return true;
4159
0
  CurrentSource = L;
4160
0
  return Cast<PT_Uint32, PT_Sint32>(S, OpPC);
4161
0
}
4162
0
bool EvalEmitter::emitCastUint32Uint64(const SourceInfo &L) {
4163
0
  if (!isActive()) return true;
4164
0
  CurrentSource = L;
4165
0
  return Cast<PT_Uint32, PT_Uint64>(S, OpPC);
4166
0
}
4167
0
bool EvalEmitter::emitCastUint32Sint64(const SourceInfo &L) {
4168
0
  if (!isActive()) return true;
4169
0
  CurrentSource = L;
4170
0
  return Cast<PT_Uint32, PT_Sint64>(S, OpPC);
4171
0
}
4172
0
bool EvalEmitter::emitCastUint32Bool(const SourceInfo &L) {
4173
0
  if (!isActive()) return true;
4174
0
  CurrentSource = L;
4175
0
  return Cast<PT_Uint32, PT_Bool>(S, OpPC);
4176
0
}
4177
0
bool EvalEmitter::emitCastSint32Uint8(const SourceInfo &L) {
4178
0
  if (!isActive()) return true;
4179
0
  CurrentSource = L;
4180
0
  return Cast<PT_Sint32, PT_Uint8>(S, OpPC);
4181
0
}
4182
0
bool EvalEmitter::emitCastSint32Sint8(const SourceInfo &L) {
4183
0
  if (!isActive()) return true;
4184
0
  CurrentSource = L;
4185
0
  return Cast<PT_Sint32, PT_Sint8>(S, OpPC);
4186
0
}
4187
0
bool EvalEmitter::emitCastSint32Uint16(const SourceInfo &L) {
4188
0
  if (!isActive()) return true;
4189
0
  CurrentSource = L;
4190
0
  return Cast<PT_Sint32, PT_Uint16>(S, OpPC);
4191
0
}
4192
0
bool EvalEmitter::emitCastSint32Sint16(const SourceInfo &L) {
4193
0
  if (!isActive()) return true;
4194
0
  CurrentSource = L;
4195
0
  return Cast<PT_Sint32, PT_Sint16>(S, OpPC);
4196
0
}
4197
0
bool EvalEmitter::emitCastSint32Uint32(const SourceInfo &L) {
4198
0
  if (!isActive()) return true;
4199
0
  CurrentSource = L;
4200
0
  return Cast<PT_Sint32, PT_Uint32>(S, OpPC);
4201
0
}
4202
0
bool EvalEmitter::emitCastSint32Sint32(const SourceInfo &L) {
4203
0
  if (!isActive()) return true;
4204
0
  CurrentSource = L;
4205
0
  return Cast<PT_Sint32, PT_Sint32>(S, OpPC);
4206
0
}
4207
0
bool EvalEmitter::emitCastSint32Uint64(const SourceInfo &L) {
4208
0
  if (!isActive()) return true;
4209
0
  CurrentSource = L;
4210
0
  return Cast<PT_Sint32, PT_Uint64>(S, OpPC);
4211
0
}
4212
0
bool EvalEmitter::emitCastSint32Sint64(const SourceInfo &L) {
4213
0
  if (!isActive()) return true;
4214
0
  CurrentSource = L;
4215
0
  return Cast<PT_Sint32, PT_Sint64>(S, OpPC);
4216
0
}
4217
0
bool EvalEmitter::emitCastSint32Bool(const SourceInfo &L) {
4218
0
  if (!isActive()) return true;
4219
0
  CurrentSource = L;
4220
0
  return Cast<PT_Sint32, PT_Bool>(S, OpPC);
4221
0
}
4222
0
bool EvalEmitter::emitCastUint64Uint8(const SourceInfo &L) {
4223
0
  if (!isActive()) return true;
4224
0
  CurrentSource = L;
4225
0
  return Cast<PT_Uint64, PT_Uint8>(S, OpPC);
4226
0
}
4227
0
bool EvalEmitter::emitCastUint64Sint8(const SourceInfo &L) {
4228
0
  if (!isActive()) return true;
4229
0
  CurrentSource = L;
4230
0
  return Cast<PT_Uint64, PT_Sint8>(S, OpPC);
4231
0
}
4232
0
bool EvalEmitter::emitCastUint64Uint16(const SourceInfo &L) {
4233
0
  if (!isActive()) return true;
4234
0
  CurrentSource = L;
4235
0
  return Cast<PT_Uint64, PT_Uint16>(S, OpPC);
4236
0
}
4237
0
bool EvalEmitter::emitCastUint64Sint16(const SourceInfo &L) {
4238
0
  if (!isActive()) return true;
4239
0
  CurrentSource = L;
4240
0
  return Cast<PT_Uint64, PT_Sint16>(S, OpPC);
4241
0
}
4242
0
bool EvalEmitter::emitCastUint64Uint32(const SourceInfo &L) {
4243
0
  if (!isActive()) return true;
4244
0
  CurrentSource = L;
4245
0
  return Cast<PT_Uint64, PT_Uint32>(S, OpPC);
4246
0
}
4247
0
bool EvalEmitter::emitCastUint64Sint32(const SourceInfo &L) {
4248
0
  if (!isActive()) return true;
4249
0
  CurrentSource = L;
4250
0
  return Cast<PT_Uint64, PT_Sint32>(S, OpPC);
4251
0
}
4252
0
bool EvalEmitter::emitCastUint64Uint64(const SourceInfo &L) {
4253
0
  if (!isActive()) return true;
4254
0
  CurrentSource = L;
4255
0
  return Cast<PT_Uint64, PT_Uint64>(S, OpPC);
4256
0
}
4257
0
bool EvalEmitter::emitCastUint64Sint64(const SourceInfo &L) {
4258
0
  if (!isActive()) return true;
4259
0
  CurrentSource = L;
4260
0
  return Cast<PT_Uint64, PT_Sint64>(S, OpPC);
4261
0
}
4262
0
bool EvalEmitter::emitCastUint64Bool(const SourceInfo &L) {
4263
0
  if (!isActive()) return true;
4264
0
  CurrentSource = L;
4265
0
  return Cast<PT_Uint64, PT_Bool>(S, OpPC);
4266
0
}
4267
0
bool EvalEmitter::emitCastSint64Uint8(const SourceInfo &L) {
4268
0
  if (!isActive()) return true;
4269
0
  CurrentSource = L;
4270
0
  return Cast<PT_Sint64, PT_Uint8>(S, OpPC);
4271
0
}
4272
0
bool EvalEmitter::emitCastSint64Sint8(const SourceInfo &L) {
4273
0
  if (!isActive()) return true;
4274
0
  CurrentSource = L;
4275
0
  return Cast<PT_Sint64, PT_Sint8>(S, OpPC);
4276
0
}
4277
0
bool EvalEmitter::emitCastSint64Uint16(const SourceInfo &L) {
4278
0
  if (!isActive()) return true;
4279
0
  CurrentSource = L;
4280
0
  return Cast<PT_Sint64, PT_Uint16>(S, OpPC);
4281
0
}
4282
0
bool EvalEmitter::emitCastSint64Sint16(const SourceInfo &L) {
4283
0
  if (!isActive()) return true;
4284
0
  CurrentSource = L;
4285
0
  return Cast<PT_Sint64, PT_Sint16>(S, OpPC);
4286
0
}
4287
0
bool EvalEmitter::emitCastSint64Uint32(const SourceInfo &L) {
4288
0
  if (!isActive()) return true;
4289
0
  CurrentSource = L;
4290
0
  return Cast<PT_Sint64, PT_Uint32>(S, OpPC);
4291
0
}
4292
0
bool EvalEmitter::emitCastSint64Sint32(const SourceInfo &L) {
4293
0
  if (!isActive()) return true;
4294
0
  CurrentSource = L;
4295
0
  return Cast<PT_Sint64, PT_Sint32>(S, OpPC);
4296
0
}
4297
0
bool EvalEmitter::emitCastSint64Uint64(const SourceInfo &L) {
4298
0
  if (!isActive()) return true;
4299
0
  CurrentSource = L;
4300
0
  return Cast<PT_Sint64, PT_Uint64>(S, OpPC);
4301
0
}
4302
0
bool EvalEmitter::emitCastSint64Sint64(const SourceInfo &L) {
4303
0
  if (!isActive()) return true;
4304
0
  CurrentSource = L;
4305
0
  return Cast<PT_Sint64, PT_Sint64>(S, OpPC);
4306
0
}
4307
0
bool EvalEmitter::emitCastSint64Bool(const SourceInfo &L) {
4308
0
  if (!isActive()) return true;
4309
0
  CurrentSource = L;
4310
0
  return Cast<PT_Sint64, PT_Bool>(S, OpPC);
4311
0
}
4312
0
bool EvalEmitter::emitCastBoolUint8(const SourceInfo &L) {
4313
0
  if (!isActive()) return true;
4314
0
  CurrentSource = L;
4315
0
  return Cast<PT_Bool, PT_Uint8>(S, OpPC);
4316
0
}
4317
0
bool EvalEmitter::emitCastBoolSint8(const SourceInfo &L) {
4318
0
  if (!isActive()) return true;
4319
0
  CurrentSource = L;
4320
0
  return Cast<PT_Bool, PT_Sint8>(S, OpPC);
4321
0
}
4322
0
bool EvalEmitter::emitCastBoolUint16(const SourceInfo &L) {
4323
0
  if (!isActive()) return true;
4324
0
  CurrentSource = L;
4325
0
  return Cast<PT_Bool, PT_Uint16>(S, OpPC);
4326
0
}
4327
0
bool EvalEmitter::emitCastBoolSint16(const SourceInfo &L) {
4328
0
  if (!isActive()) return true;
4329
0
  CurrentSource = L;
4330
0
  return Cast<PT_Bool, PT_Sint16>(S, OpPC);
4331
0
}
4332
0
bool EvalEmitter::emitCastBoolUint32(const SourceInfo &L) {
4333
0
  if (!isActive()) return true;
4334
0
  CurrentSource = L;
4335
0
  return Cast<PT_Bool, PT_Uint32>(S, OpPC);
4336
0
}
4337
0
bool EvalEmitter::emitCastBoolSint32(const SourceInfo &L) {
4338
0
  if (!isActive()) return true;
4339
0
  CurrentSource = L;
4340
0
  return Cast<PT_Bool, PT_Sint32>(S, OpPC);
4341
0
}
4342
0
bool EvalEmitter::emitCastBoolUint64(const SourceInfo &L) {
4343
0
  if (!isActive()) return true;
4344
0
  CurrentSource = L;
4345
0
  return Cast<PT_Bool, PT_Uint64>(S, OpPC);
4346
0
}
4347
0
bool EvalEmitter::emitCastBoolSint64(const SourceInfo &L) {
4348
0
  if (!isActive()) return true;
4349
0
  CurrentSource = L;
4350
0
  return Cast<PT_Bool, PT_Sint64>(S, OpPC);
4351
0
}
4352
0
bool EvalEmitter::emitCastBoolBool(const SourceInfo &L) {
4353
0
  if (!isActive()) return true;
4354
0
  CurrentSource = L;
4355
0
  return Cast<PT_Bool, PT_Bool>(S, OpPC);
4356
0
}
4357
0
bool EvalEmitter::emitCastIntAPUint8(const SourceInfo &L) {
4358
0
  if (!isActive()) return true;
4359
0
  CurrentSource = L;
4360
0
  return Cast<PT_IntAP, PT_Uint8>(S, OpPC);
4361
0
}
4362
0
bool EvalEmitter::emitCastIntAPSint8(const SourceInfo &L) {
4363
0
  if (!isActive()) return true;
4364
0
  CurrentSource = L;
4365
0
  return Cast<PT_IntAP, PT_Sint8>(S, OpPC);
4366
0
}
4367
0
bool EvalEmitter::emitCastIntAPUint16(const SourceInfo &L) {
4368
0
  if (!isActive()) return true;
4369
0
  CurrentSource = L;
4370
0
  return Cast<PT_IntAP, PT_Uint16>(S, OpPC);
4371
0
}
4372
0
bool EvalEmitter::emitCastIntAPSint16(const SourceInfo &L) {
4373
0
  if (!isActive()) return true;
4374
0
  CurrentSource = L;
4375
0
  return Cast<PT_IntAP, PT_Sint16>(S, OpPC);
4376
0
}
4377
0
bool EvalEmitter::emitCastIntAPUint32(const SourceInfo &L) {
4378
0
  if (!isActive()) return true;
4379
0
  CurrentSource = L;
4380
0
  return Cast<PT_IntAP, PT_Uint32>(S, OpPC);
4381
0
}
4382
0
bool EvalEmitter::emitCastIntAPSint32(const SourceInfo &L) {
4383
0
  if (!isActive()) return true;
4384
0
  CurrentSource = L;
4385
0
  return Cast<PT_IntAP, PT_Sint32>(S, OpPC);
4386
0
}
4387
0
bool EvalEmitter::emitCastIntAPUint64(const SourceInfo &L) {
4388
0
  if (!isActive()) return true;
4389
0
  CurrentSource = L;
4390
0
  return Cast<PT_IntAP, PT_Uint64>(S, OpPC);
4391
0
}
4392
0
bool EvalEmitter::emitCastIntAPSint64(const SourceInfo &L) {
4393
0
  if (!isActive()) return true;
4394
0
  CurrentSource = L;
4395
0
  return Cast<PT_IntAP, PT_Sint64>(S, OpPC);
4396
0
}
4397
0
bool EvalEmitter::emitCastIntAPBool(const SourceInfo &L) {
4398
0
  if (!isActive()) return true;
4399
0
  CurrentSource = L;
4400
0
  return Cast<PT_IntAP, PT_Bool>(S, OpPC);
4401
0
}
4402
0
bool EvalEmitter::emitCastIntAPSUint8(const SourceInfo &L) {
4403
0
  if (!isActive()) return true;
4404
0
  CurrentSource = L;
4405
0
  return Cast<PT_IntAPS, PT_Uint8>(S, OpPC);
4406
0
}
4407
0
bool EvalEmitter::emitCastIntAPSSint8(const SourceInfo &L) {
4408
0
  if (!isActive()) return true;
4409
0
  CurrentSource = L;
4410
0
  return Cast<PT_IntAPS, PT_Sint8>(S, OpPC);
4411
0
}
4412
0
bool EvalEmitter::emitCastIntAPSUint16(const SourceInfo &L) {
4413
0
  if (!isActive()) return true;
4414
0
  CurrentSource = L;
4415
0
  return Cast<PT_IntAPS, PT_Uint16>(S, OpPC);
4416
0
}
4417
0
bool EvalEmitter::emitCastIntAPSSint16(const SourceInfo &L) {
4418
0
  if (!isActive()) return true;
4419
0
  CurrentSource = L;
4420
0
  return Cast<PT_IntAPS, PT_Sint16>(S, OpPC);
4421
0
}
4422
0
bool EvalEmitter::emitCastIntAPSUint32(const SourceInfo &L) {
4423
0
  if (!isActive()) return true;
4424
0
  CurrentSource = L;
4425
0
  return Cast<PT_IntAPS, PT_Uint32>(S, OpPC);
4426
0
}
4427
0
bool EvalEmitter::emitCastIntAPSSint32(const SourceInfo &L) {
4428
0
  if (!isActive()) return true;
4429
0
  CurrentSource = L;
4430
0
  return Cast<PT_IntAPS, PT_Sint32>(S, OpPC);
4431
0
}
4432
0
bool EvalEmitter::emitCastIntAPSUint64(const SourceInfo &L) {
4433
0
  if (!isActive()) return true;
4434
0
  CurrentSource = L;
4435
0
  return Cast<PT_IntAPS, PT_Uint64>(S, OpPC);
4436
0
}
4437
0
bool EvalEmitter::emitCastIntAPSSint64(const SourceInfo &L) {
4438
0
  if (!isActive()) return true;
4439
0
  CurrentSource = L;
4440
0
  return Cast<PT_IntAPS, PT_Sint64>(S, OpPC);
4441
0
}
4442
0
bool EvalEmitter::emitCastIntAPSBool(const SourceInfo &L) {
4443
0
  if (!isActive()) return true;
4444
0
  CurrentSource = L;
4445
0
  return Cast<PT_IntAPS, PT_Bool>(S, OpPC);
4446
0
}
4447
#endif
4448
#ifdef GET_OPCODE_NAMES
4449
OP_CastAPSint8,
4450
OP_CastAPUint8,
4451
OP_CastAPSint16,
4452
OP_CastAPUint16,
4453
OP_CastAPSint32,
4454
OP_CastAPUint32,
4455
OP_CastAPSint64,
4456
OP_CastAPUint64,
4457
OP_CastAPIntAP,
4458
OP_CastAPIntAPS,
4459
OP_CastAPBool,
4460
#endif
4461
0
#ifdef GET_INTERP
4462
0
case OP_CastAPSint8: {
4463
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4464
0
  if (!CastAP<PT_Sint8>(S, OpPC, V0))
4465
0
    return false;
4466
0
  continue;
4467
0
}
4468
0
case OP_CastAPUint8: {
4469
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4470
0
  if (!CastAP<PT_Uint8>(S, OpPC, V0))
4471
0
    return false;
4472
0
  continue;
4473
0
}
4474
0
case OP_CastAPSint16: {
4475
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4476
0
  if (!CastAP<PT_Sint16>(S, OpPC, V0))
4477
0
    return false;
4478
0
  continue;
4479
0
}
4480
0
case OP_CastAPUint16: {
4481
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4482
0
  if (!CastAP<PT_Uint16>(S, OpPC, V0))
4483
0
    return false;
4484
0
  continue;
4485
0
}
4486
0
case OP_CastAPSint32: {
4487
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4488
0
  if (!CastAP<PT_Sint32>(S, OpPC, V0))
4489
0
    return false;
4490
0
  continue;
4491
0
}
4492
0
case OP_CastAPUint32: {
4493
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4494
0
  if (!CastAP<PT_Uint32>(S, OpPC, V0))
4495
0
    return false;
4496
0
  continue;
4497
0
}
4498
0
case OP_CastAPSint64: {
4499
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4500
0
  if (!CastAP<PT_Sint64>(S, OpPC, V0))
4501
0
    return false;
4502
0
  continue;
4503
0
}
4504
0
case OP_CastAPUint64: {
4505
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4506
0
  if (!CastAP<PT_Uint64>(S, OpPC, V0))
4507
0
    return false;
4508
0
  continue;
4509
0
}
4510
0
case OP_CastAPIntAP: {
4511
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4512
0
  if (!CastAP<PT_IntAP>(S, OpPC, V0))
4513
0
    return false;
4514
0
  continue;
4515
0
}
4516
0
case OP_CastAPIntAPS: {
4517
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4518
0
  if (!CastAP<PT_IntAPS>(S, OpPC, V0))
4519
0
    return false;
4520
0
  continue;
4521
0
}
4522
0
case OP_CastAPBool: {
4523
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4524
0
  if (!CastAP<PT_Bool>(S, OpPC, V0))
4525
0
    return false;
4526
0
  continue;
4527
0
}
4528
0
#endif
4529
#ifdef GET_DISASM
4530
case OP_CastAPSint8:
4531
  PrintName("CastAPSint8");
4532
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4533
  continue;
4534
case OP_CastAPUint8:
4535
  PrintName("CastAPUint8");
4536
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4537
  continue;
4538
case OP_CastAPSint16:
4539
  PrintName("CastAPSint16");
4540
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4541
  continue;
4542
case OP_CastAPUint16:
4543
  PrintName("CastAPUint16");
4544
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4545
  continue;
4546
case OP_CastAPSint32:
4547
  PrintName("CastAPSint32");
4548
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4549
  continue;
4550
case OP_CastAPUint32:
4551
  PrintName("CastAPUint32");
4552
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4553
  continue;
4554
case OP_CastAPSint64:
4555
  PrintName("CastAPSint64");
4556
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4557
  continue;
4558
case OP_CastAPUint64:
4559
  PrintName("CastAPUint64");
4560
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4561
  continue;
4562
case OP_CastAPIntAP:
4563
  PrintName("CastAPIntAP");
4564
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4565
  continue;
4566
case OP_CastAPIntAPS:
4567
  PrintName("CastAPIntAPS");
4568
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4569
  continue;
4570
case OP_CastAPBool:
4571
  PrintName("CastAPBool");
4572
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4573
  continue;
4574
#endif
4575
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4576
bool emitCastAPSint8(uint32_t, const SourceInfo &);
4577
bool emitCastAPUint8(uint32_t, const SourceInfo &);
4578
bool emitCastAPSint16(uint32_t, const SourceInfo &);
4579
bool emitCastAPUint16(uint32_t, const SourceInfo &);
4580
bool emitCastAPSint32(uint32_t, const SourceInfo &);
4581
bool emitCastAPUint32(uint32_t, const SourceInfo &);
4582
bool emitCastAPSint64(uint32_t, const SourceInfo &);
4583
bool emitCastAPUint64(uint32_t, const SourceInfo &);
4584
bool emitCastAPIntAP(uint32_t, const SourceInfo &);
4585
bool emitCastAPIntAPS(uint32_t, const SourceInfo &);
4586
bool emitCastAPBool(uint32_t, const SourceInfo &);
4587
#endif
4588
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4589
bool emitCastAP(PrimType, uint32_t, const SourceInfo &I);
4590
#endif
4591
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
4592
bool
4593
#if defined(GET_EVAL_IMPL)
4594
EvalEmitter
4595
#else
4596
ByteCodeEmitter
4597
#endif
4598
0
::emitCastAP(PrimType T0, uint32_t A0, const SourceInfo &I) {
4599
0
  switch (T0) {
4600
0
  case PT_Sint8:
4601
0
    return emitCastAPSint8(A0, I);
4602
0
  case PT_Uint8:
4603
0
    return emitCastAPUint8(A0, I);
4604
0
  case PT_Sint16:
4605
0
    return emitCastAPSint16(A0, I);
4606
0
  case PT_Uint16:
4607
0
    return emitCastAPUint16(A0, I);
4608
0
  case PT_Sint32:
4609
0
    return emitCastAPSint32(A0, I);
4610
0
  case PT_Uint32:
4611
0
    return emitCastAPUint32(A0, I);
4612
0
  case PT_Sint64:
4613
0
    return emitCastAPSint64(A0, I);
4614
0
  case PT_Uint64:
4615
0
    return emitCastAPUint64(A0, I);
4616
0
  case PT_IntAP:
4617
0
    return emitCastAPIntAP(A0, I);
4618
0
  case PT_IntAPS:
4619
0
    return emitCastAPIntAPS(A0, I);
4620
0
  case PT_Bool:
4621
0
    return emitCastAPBool(A0, I);
4622
0
  default: llvm_unreachable("invalid type: emitCastAP");
4623
0
  }
4624
0
  llvm_unreachable("invalid enum value");
4625
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCastAP(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCastAP(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
4626
#endif
4627
#ifdef GET_LINK_IMPL
4628
0
bool ByteCodeEmitter::emitCastAPSint8(uint32_t A0, const SourceInfo &L) {
4629
0
  return emitOp<uint32_t>(OP_CastAPSint8, A0, L);
4630
0
}
4631
0
bool ByteCodeEmitter::emitCastAPUint8(uint32_t A0, const SourceInfo &L) {
4632
0
  return emitOp<uint32_t>(OP_CastAPUint8, A0, L);
4633
0
}
4634
0
bool ByteCodeEmitter::emitCastAPSint16(uint32_t A0, const SourceInfo &L) {
4635
0
  return emitOp<uint32_t>(OP_CastAPSint16, A0, L);
4636
0
}
4637
0
bool ByteCodeEmitter::emitCastAPUint16(uint32_t A0, const SourceInfo &L) {
4638
0
  return emitOp<uint32_t>(OP_CastAPUint16, A0, L);
4639
0
}
4640
0
bool ByteCodeEmitter::emitCastAPSint32(uint32_t A0, const SourceInfo &L) {
4641
0
  return emitOp<uint32_t>(OP_CastAPSint32, A0, L);
4642
0
}
4643
0
bool ByteCodeEmitter::emitCastAPUint32(uint32_t A0, const SourceInfo &L) {
4644
0
  return emitOp<uint32_t>(OP_CastAPUint32, A0, L);
4645
0
}
4646
0
bool ByteCodeEmitter::emitCastAPSint64(uint32_t A0, const SourceInfo &L) {
4647
0
  return emitOp<uint32_t>(OP_CastAPSint64, A0, L);
4648
0
}
4649
0
bool ByteCodeEmitter::emitCastAPUint64(uint32_t A0, const SourceInfo &L) {
4650
0
  return emitOp<uint32_t>(OP_CastAPUint64, A0, L);
4651
0
}
4652
0
bool ByteCodeEmitter::emitCastAPIntAP(uint32_t A0, const SourceInfo &L) {
4653
0
  return emitOp<uint32_t>(OP_CastAPIntAP, A0, L);
4654
0
}
4655
0
bool ByteCodeEmitter::emitCastAPIntAPS(uint32_t A0, const SourceInfo &L) {
4656
0
  return emitOp<uint32_t>(OP_CastAPIntAPS, A0, L);
4657
0
}
4658
0
bool ByteCodeEmitter::emitCastAPBool(uint32_t A0, const SourceInfo &L) {
4659
0
  return emitOp<uint32_t>(OP_CastAPBool, A0, L);
4660
0
}
4661
#endif
4662
#ifdef GET_EVAL_IMPL
4663
0
bool EvalEmitter::emitCastAPSint8(uint32_t A0, const SourceInfo &L) {
4664
0
  if (!isActive()) return true;
4665
0
  CurrentSource = L;
4666
0
  return CastAP<PT_Sint8>(S, OpPC, A0);
4667
0
}
4668
0
bool EvalEmitter::emitCastAPUint8(uint32_t A0, const SourceInfo &L) {
4669
0
  if (!isActive()) return true;
4670
0
  CurrentSource = L;
4671
0
  return CastAP<PT_Uint8>(S, OpPC, A0);
4672
0
}
4673
0
bool EvalEmitter::emitCastAPSint16(uint32_t A0, const SourceInfo &L) {
4674
0
  if (!isActive()) return true;
4675
0
  CurrentSource = L;
4676
0
  return CastAP<PT_Sint16>(S, OpPC, A0);
4677
0
}
4678
0
bool EvalEmitter::emitCastAPUint16(uint32_t A0, const SourceInfo &L) {
4679
0
  if (!isActive()) return true;
4680
0
  CurrentSource = L;
4681
0
  return CastAP<PT_Uint16>(S, OpPC, A0);
4682
0
}
4683
0
bool EvalEmitter::emitCastAPSint32(uint32_t A0, const SourceInfo &L) {
4684
0
  if (!isActive()) return true;
4685
0
  CurrentSource = L;
4686
0
  return CastAP<PT_Sint32>(S, OpPC, A0);
4687
0
}
4688
0
bool EvalEmitter::emitCastAPUint32(uint32_t A0, const SourceInfo &L) {
4689
0
  if (!isActive()) return true;
4690
0
  CurrentSource = L;
4691
0
  return CastAP<PT_Uint32>(S, OpPC, A0);
4692
0
}
4693
0
bool EvalEmitter::emitCastAPSint64(uint32_t A0, const SourceInfo &L) {
4694
0
  if (!isActive()) return true;
4695
0
  CurrentSource = L;
4696
0
  return CastAP<PT_Sint64>(S, OpPC, A0);
4697
0
}
4698
0
bool EvalEmitter::emitCastAPUint64(uint32_t A0, const SourceInfo &L) {
4699
0
  if (!isActive()) return true;
4700
0
  CurrentSource = L;
4701
0
  return CastAP<PT_Uint64>(S, OpPC, A0);
4702
0
}
4703
0
bool EvalEmitter::emitCastAPIntAP(uint32_t A0, const SourceInfo &L) {
4704
0
  if (!isActive()) return true;
4705
0
  CurrentSource = L;
4706
0
  return CastAP<PT_IntAP>(S, OpPC, A0);
4707
0
}
4708
0
bool EvalEmitter::emitCastAPIntAPS(uint32_t A0, const SourceInfo &L) {
4709
0
  if (!isActive()) return true;
4710
0
  CurrentSource = L;
4711
0
  return CastAP<PT_IntAPS>(S, OpPC, A0);
4712
0
}
4713
0
bool EvalEmitter::emitCastAPBool(uint32_t A0, const SourceInfo &L) {
4714
0
  if (!isActive()) return true;
4715
0
  CurrentSource = L;
4716
0
  return CastAP<PT_Bool>(S, OpPC, A0);
4717
0
}
4718
#endif
4719
#ifdef GET_OPCODE_NAMES
4720
OP_CastAPSSint8,
4721
OP_CastAPSUint8,
4722
OP_CastAPSSint16,
4723
OP_CastAPSUint16,
4724
OP_CastAPSSint32,
4725
OP_CastAPSUint32,
4726
OP_CastAPSSint64,
4727
OP_CastAPSUint64,
4728
OP_CastAPSIntAP,
4729
OP_CastAPSIntAPS,
4730
OP_CastAPSBool,
4731
#endif
4732
0
#ifdef GET_INTERP
4733
0
case OP_CastAPSSint8: {
4734
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4735
0
  if (!CastAPS<PT_Sint8>(S, OpPC, V0))
4736
0
    return false;
4737
0
  continue;
4738
0
}
4739
0
case OP_CastAPSUint8: {
4740
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4741
0
  if (!CastAPS<PT_Uint8>(S, OpPC, V0))
4742
0
    return false;
4743
0
  continue;
4744
0
}
4745
0
case OP_CastAPSSint16: {
4746
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4747
0
  if (!CastAPS<PT_Sint16>(S, OpPC, V0))
4748
0
    return false;
4749
0
  continue;
4750
0
}
4751
0
case OP_CastAPSUint16: {
4752
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4753
0
  if (!CastAPS<PT_Uint16>(S, OpPC, V0))
4754
0
    return false;
4755
0
  continue;
4756
0
}
4757
0
case OP_CastAPSSint32: {
4758
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4759
0
  if (!CastAPS<PT_Sint32>(S, OpPC, V0))
4760
0
    return false;
4761
0
  continue;
4762
0
}
4763
0
case OP_CastAPSUint32: {
4764
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4765
0
  if (!CastAPS<PT_Uint32>(S, OpPC, V0))
4766
0
    return false;
4767
0
  continue;
4768
0
}
4769
0
case OP_CastAPSSint64: {
4770
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4771
0
  if (!CastAPS<PT_Sint64>(S, OpPC, V0))
4772
0
    return false;
4773
0
  continue;
4774
0
}
4775
0
case OP_CastAPSUint64: {
4776
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4777
0
  if (!CastAPS<PT_Uint64>(S, OpPC, V0))
4778
0
    return false;
4779
0
  continue;
4780
0
}
4781
0
case OP_CastAPSIntAP: {
4782
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4783
0
  if (!CastAPS<PT_IntAP>(S, OpPC, V0))
4784
0
    return false;
4785
0
  continue;
4786
0
}
4787
0
case OP_CastAPSIntAPS: {
4788
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4789
0
  if (!CastAPS<PT_IntAPS>(S, OpPC, V0))
4790
0
    return false;
4791
0
  continue;
4792
0
}
4793
0
case OP_CastAPSBool: {
4794
0
  auto V0 = ReadArg<uint32_t>(S, PC);
4795
0
  if (!CastAPS<PT_Bool>(S, OpPC, V0))
4796
0
    return false;
4797
0
  continue;
4798
0
}
4799
0
#endif
4800
#ifdef GET_DISASM
4801
case OP_CastAPSSint8:
4802
  PrintName("CastAPSSint8");
4803
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4804
  continue;
4805
case OP_CastAPSUint8:
4806
  PrintName("CastAPSUint8");
4807
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4808
  continue;
4809
case OP_CastAPSSint16:
4810
  PrintName("CastAPSSint16");
4811
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4812
  continue;
4813
case OP_CastAPSUint16:
4814
  PrintName("CastAPSUint16");
4815
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4816
  continue;
4817
case OP_CastAPSSint32:
4818
  PrintName("CastAPSSint32");
4819
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4820
  continue;
4821
case OP_CastAPSUint32:
4822
  PrintName("CastAPSUint32");
4823
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4824
  continue;
4825
case OP_CastAPSSint64:
4826
  PrintName("CastAPSSint64");
4827
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4828
  continue;
4829
case OP_CastAPSUint64:
4830
  PrintName("CastAPSUint64");
4831
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4832
  continue;
4833
case OP_CastAPSIntAP:
4834
  PrintName("CastAPSIntAP");
4835
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4836
  continue;
4837
case OP_CastAPSIntAPS:
4838
  PrintName("CastAPSIntAPS");
4839
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4840
  continue;
4841
case OP_CastAPSBool:
4842
  PrintName("CastAPSBool");
4843
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
4844
  continue;
4845
#endif
4846
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4847
bool emitCastAPSSint8(uint32_t, const SourceInfo &);
4848
bool emitCastAPSUint8(uint32_t, const SourceInfo &);
4849
bool emitCastAPSSint16(uint32_t, const SourceInfo &);
4850
bool emitCastAPSUint16(uint32_t, const SourceInfo &);
4851
bool emitCastAPSSint32(uint32_t, const SourceInfo &);
4852
bool emitCastAPSUint32(uint32_t, const SourceInfo &);
4853
bool emitCastAPSSint64(uint32_t, const SourceInfo &);
4854
bool emitCastAPSUint64(uint32_t, const SourceInfo &);
4855
bool emitCastAPSIntAP(uint32_t, const SourceInfo &);
4856
bool emitCastAPSIntAPS(uint32_t, const SourceInfo &);
4857
bool emitCastAPSBool(uint32_t, const SourceInfo &);
4858
#endif
4859
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4860
bool emitCastAPS(PrimType, uint32_t, const SourceInfo &I);
4861
#endif
4862
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
4863
bool
4864
#if defined(GET_EVAL_IMPL)
4865
EvalEmitter
4866
#else
4867
ByteCodeEmitter
4868
#endif
4869
0
::emitCastAPS(PrimType T0, uint32_t A0, const SourceInfo &I) {
4870
0
  switch (T0) {
4871
0
  case PT_Sint8:
4872
0
    return emitCastAPSSint8(A0, I);
4873
0
  case PT_Uint8:
4874
0
    return emitCastAPSUint8(A0, I);
4875
0
  case PT_Sint16:
4876
0
    return emitCastAPSSint16(A0, I);
4877
0
  case PT_Uint16:
4878
0
    return emitCastAPSUint16(A0, I);
4879
0
  case PT_Sint32:
4880
0
    return emitCastAPSSint32(A0, I);
4881
0
  case PT_Uint32:
4882
0
    return emitCastAPSUint32(A0, I);
4883
0
  case PT_Sint64:
4884
0
    return emitCastAPSSint64(A0, I);
4885
0
  case PT_Uint64:
4886
0
    return emitCastAPSUint64(A0, I);
4887
0
  case PT_IntAP:
4888
0
    return emitCastAPSIntAP(A0, I);
4889
0
  case PT_IntAPS:
4890
0
    return emitCastAPSIntAPS(A0, I);
4891
0
  case PT_Bool:
4892
0
    return emitCastAPSBool(A0, I);
4893
0
  default: llvm_unreachable("invalid type: emitCastAPS");
4894
0
  }
4895
0
  llvm_unreachable("invalid enum value");
4896
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCastAPS(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCastAPS(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
4897
#endif
4898
#ifdef GET_LINK_IMPL
4899
0
bool ByteCodeEmitter::emitCastAPSSint8(uint32_t A0, const SourceInfo &L) {
4900
0
  return emitOp<uint32_t>(OP_CastAPSSint8, A0, L);
4901
0
}
4902
0
bool ByteCodeEmitter::emitCastAPSUint8(uint32_t A0, const SourceInfo &L) {
4903
0
  return emitOp<uint32_t>(OP_CastAPSUint8, A0, L);
4904
0
}
4905
0
bool ByteCodeEmitter::emitCastAPSSint16(uint32_t A0, const SourceInfo &L) {
4906
0
  return emitOp<uint32_t>(OP_CastAPSSint16, A0, L);
4907
0
}
4908
0
bool ByteCodeEmitter::emitCastAPSUint16(uint32_t A0, const SourceInfo &L) {
4909
0
  return emitOp<uint32_t>(OP_CastAPSUint16, A0, L);
4910
0
}
4911
0
bool ByteCodeEmitter::emitCastAPSSint32(uint32_t A0, const SourceInfo &L) {
4912
0
  return emitOp<uint32_t>(OP_CastAPSSint32, A0, L);
4913
0
}
4914
0
bool ByteCodeEmitter::emitCastAPSUint32(uint32_t A0, const SourceInfo &L) {
4915
0
  return emitOp<uint32_t>(OP_CastAPSUint32, A0, L);
4916
0
}
4917
0
bool ByteCodeEmitter::emitCastAPSSint64(uint32_t A0, const SourceInfo &L) {
4918
0
  return emitOp<uint32_t>(OP_CastAPSSint64, A0, L);
4919
0
}
4920
0
bool ByteCodeEmitter::emitCastAPSUint64(uint32_t A0, const SourceInfo &L) {
4921
0
  return emitOp<uint32_t>(OP_CastAPSUint64, A0, L);
4922
0
}
4923
0
bool ByteCodeEmitter::emitCastAPSIntAP(uint32_t A0, const SourceInfo &L) {
4924
0
  return emitOp<uint32_t>(OP_CastAPSIntAP, A0, L);
4925
0
}
4926
0
bool ByteCodeEmitter::emitCastAPSIntAPS(uint32_t A0, const SourceInfo &L) {
4927
0
  return emitOp<uint32_t>(OP_CastAPSIntAPS, A0, L);
4928
0
}
4929
0
bool ByteCodeEmitter::emitCastAPSBool(uint32_t A0, const SourceInfo &L) {
4930
0
  return emitOp<uint32_t>(OP_CastAPSBool, A0, L);
4931
0
}
4932
#endif
4933
#ifdef GET_EVAL_IMPL
4934
0
bool EvalEmitter::emitCastAPSSint8(uint32_t A0, const SourceInfo &L) {
4935
0
  if (!isActive()) return true;
4936
0
  CurrentSource = L;
4937
0
  return CastAPS<PT_Sint8>(S, OpPC, A0);
4938
0
}
4939
0
bool EvalEmitter::emitCastAPSUint8(uint32_t A0, const SourceInfo &L) {
4940
0
  if (!isActive()) return true;
4941
0
  CurrentSource = L;
4942
0
  return CastAPS<PT_Uint8>(S, OpPC, A0);
4943
0
}
4944
0
bool EvalEmitter::emitCastAPSSint16(uint32_t A0, const SourceInfo &L) {
4945
0
  if (!isActive()) return true;
4946
0
  CurrentSource = L;
4947
0
  return CastAPS<PT_Sint16>(S, OpPC, A0);
4948
0
}
4949
0
bool EvalEmitter::emitCastAPSUint16(uint32_t A0, const SourceInfo &L) {
4950
0
  if (!isActive()) return true;
4951
0
  CurrentSource = L;
4952
0
  return CastAPS<PT_Uint16>(S, OpPC, A0);
4953
0
}
4954
0
bool EvalEmitter::emitCastAPSSint32(uint32_t A0, const SourceInfo &L) {
4955
0
  if (!isActive()) return true;
4956
0
  CurrentSource = L;
4957
0
  return CastAPS<PT_Sint32>(S, OpPC, A0);
4958
0
}
4959
0
bool EvalEmitter::emitCastAPSUint32(uint32_t A0, const SourceInfo &L) {
4960
0
  if (!isActive()) return true;
4961
0
  CurrentSource = L;
4962
0
  return CastAPS<PT_Uint32>(S, OpPC, A0);
4963
0
}
4964
0
bool EvalEmitter::emitCastAPSSint64(uint32_t A0, const SourceInfo &L) {
4965
0
  if (!isActive()) return true;
4966
0
  CurrentSource = L;
4967
0
  return CastAPS<PT_Sint64>(S, OpPC, A0);
4968
0
}
4969
0
bool EvalEmitter::emitCastAPSUint64(uint32_t A0, const SourceInfo &L) {
4970
0
  if (!isActive()) return true;
4971
0
  CurrentSource = L;
4972
0
  return CastAPS<PT_Uint64>(S, OpPC, A0);
4973
0
}
4974
0
bool EvalEmitter::emitCastAPSIntAP(uint32_t A0, const SourceInfo &L) {
4975
0
  if (!isActive()) return true;
4976
0
  CurrentSource = L;
4977
0
  return CastAPS<PT_IntAP>(S, OpPC, A0);
4978
0
}
4979
0
bool EvalEmitter::emitCastAPSIntAPS(uint32_t A0, const SourceInfo &L) {
4980
0
  if (!isActive()) return true;
4981
0
  CurrentSource = L;
4982
0
  return CastAPS<PT_IntAPS>(S, OpPC, A0);
4983
0
}
4984
0
bool EvalEmitter::emitCastAPSBool(uint32_t A0, const SourceInfo &L) {
4985
0
  if (!isActive()) return true;
4986
0
  CurrentSource = L;
4987
0
  return CastAPS<PT_Bool>(S, OpPC, A0);
4988
0
}
4989
#endif
4990
#ifdef GET_OPCODE_NAMES
4991
OP_CastFP,
4992
#endif
4993
0
#ifdef GET_INTERP
4994
0
case OP_CastFP: {
4995
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
4996
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
4997
0
  if (!CastFP(S, OpPC, V0, V1))
4998
0
    return false;
4999
0
  continue;
5000
0
}
5001
0
#endif
5002
#ifdef GET_DISASM
5003
case OP_CastFP:
5004
  PrintName("CastFP");
5005
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5006
  continue;
5007
#endif
5008
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5009
bool emitCastFP(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5010
#endif
5011
#ifdef GET_LINK_IMPL
5012
0
bool ByteCodeEmitter::emitCastFP(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5013
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastFP, A0, A1, L);
5014
0
}
5015
#endif
5016
#ifdef GET_EVAL_IMPL
5017
0
bool EvalEmitter::emitCastFP(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5018
0
  if (!isActive()) return true;
5019
0
  CurrentSource = L;
5020
0
  return CastFP(S, OpPC, A0, A1);
5021
0
}
5022
#endif
5023
#ifdef GET_OPCODE_NAMES
5024
OP_CastFloatingIntegralUint8,
5025
OP_CastFloatingIntegralSint8,
5026
OP_CastFloatingIntegralUint16,
5027
OP_CastFloatingIntegralSint16,
5028
OP_CastFloatingIntegralUint32,
5029
OP_CastFloatingIntegralSint32,
5030
OP_CastFloatingIntegralUint64,
5031
OP_CastFloatingIntegralSint64,
5032
OP_CastFloatingIntegralBool,
5033
#endif
5034
0
#ifdef GET_INTERP
5035
0
case OP_CastFloatingIntegralUint8: {
5036
0
  if (!CastFloatingIntegral<PT_Uint8>(S, OpPC))
5037
0
    return false;
5038
0
  continue;
5039
0
}
5040
0
case OP_CastFloatingIntegralSint8: {
5041
0
  if (!CastFloatingIntegral<PT_Sint8>(S, OpPC))
5042
0
    return false;
5043
0
  continue;
5044
0
}
5045
0
case OP_CastFloatingIntegralUint16: {
5046
0
  if (!CastFloatingIntegral<PT_Uint16>(S, OpPC))
5047
0
    return false;
5048
0
  continue;
5049
0
}
5050
0
case OP_CastFloatingIntegralSint16: {
5051
0
  if (!CastFloatingIntegral<PT_Sint16>(S, OpPC))
5052
0
    return false;
5053
0
  continue;
5054
0
}
5055
0
case OP_CastFloatingIntegralUint32: {
5056
0
  if (!CastFloatingIntegral<PT_Uint32>(S, OpPC))
5057
0
    return false;
5058
0
  continue;
5059
0
}
5060
0
case OP_CastFloatingIntegralSint32: {
5061
0
  if (!CastFloatingIntegral<PT_Sint32>(S, OpPC))
5062
0
    return false;
5063
0
  continue;
5064
0
}
5065
0
case OP_CastFloatingIntegralUint64: {
5066
0
  if (!CastFloatingIntegral<PT_Uint64>(S, OpPC))
5067
0
    return false;
5068
0
  continue;
5069
0
}
5070
0
case OP_CastFloatingIntegralSint64: {
5071
0
  if (!CastFloatingIntegral<PT_Sint64>(S, OpPC))
5072
0
    return false;
5073
0
  continue;
5074
0
}
5075
0
case OP_CastFloatingIntegralBool: {
5076
0
  if (!CastFloatingIntegral<PT_Bool>(S, OpPC))
5077
0
    return false;
5078
0
  continue;
5079
0
}
5080
0
#endif
5081
#ifdef GET_DISASM
5082
case OP_CastFloatingIntegralUint8:
5083
  PrintName("CastFloatingIntegralUint8");
5084
  OS << "\t" << "\n";
5085
  continue;
5086
case OP_CastFloatingIntegralSint8:
5087
  PrintName("CastFloatingIntegralSint8");
5088
  OS << "\t" << "\n";
5089
  continue;
5090
case OP_CastFloatingIntegralUint16:
5091
  PrintName("CastFloatingIntegralUint16");
5092
  OS << "\t" << "\n";
5093
  continue;
5094
case OP_CastFloatingIntegralSint16:
5095
  PrintName("CastFloatingIntegralSint16");
5096
  OS << "\t" << "\n";
5097
  continue;
5098
case OP_CastFloatingIntegralUint32:
5099
  PrintName("CastFloatingIntegralUint32");
5100
  OS << "\t" << "\n";
5101
  continue;
5102
case OP_CastFloatingIntegralSint32:
5103
  PrintName("CastFloatingIntegralSint32");
5104
  OS << "\t" << "\n";
5105
  continue;
5106
case OP_CastFloatingIntegralUint64:
5107
  PrintName("CastFloatingIntegralUint64");
5108
  OS << "\t" << "\n";
5109
  continue;
5110
case OP_CastFloatingIntegralSint64:
5111
  PrintName("CastFloatingIntegralSint64");
5112
  OS << "\t" << "\n";
5113
  continue;
5114
case OP_CastFloatingIntegralBool:
5115
  PrintName("CastFloatingIntegralBool");
5116
  OS << "\t" << "\n";
5117
  continue;
5118
#endif
5119
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5120
bool emitCastFloatingIntegralUint8(const SourceInfo &);
5121
bool emitCastFloatingIntegralSint8(const SourceInfo &);
5122
bool emitCastFloatingIntegralUint16(const SourceInfo &);
5123
bool emitCastFloatingIntegralSint16(const SourceInfo &);
5124
bool emitCastFloatingIntegralUint32(const SourceInfo &);
5125
bool emitCastFloatingIntegralSint32(const SourceInfo &);
5126
bool emitCastFloatingIntegralUint64(const SourceInfo &);
5127
bool emitCastFloatingIntegralSint64(const SourceInfo &);
5128
bool emitCastFloatingIntegralBool(const SourceInfo &);
5129
#endif
5130
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5131
bool emitCastFloatingIntegral(PrimType, const SourceInfo &I);
5132
#endif
5133
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
5134
bool
5135
#if defined(GET_EVAL_IMPL)
5136
EvalEmitter
5137
#else
5138
ByteCodeEmitter
5139
#endif
5140
0
::emitCastFloatingIntegral(PrimType T0, const SourceInfo &I) {
5141
0
  switch (T0) {
5142
0
  case PT_Uint8:
5143
0
    return emitCastFloatingIntegralUint8(I);
5144
0
  case PT_Sint8:
5145
0
    return emitCastFloatingIntegralSint8(I);
5146
0
  case PT_Uint16:
5147
0
    return emitCastFloatingIntegralUint16(I);
5148
0
  case PT_Sint16:
5149
0
    return emitCastFloatingIntegralSint16(I);
5150
0
  case PT_Uint32:
5151
0
    return emitCastFloatingIntegralUint32(I);
5152
0
  case PT_Sint32:
5153
0
    return emitCastFloatingIntegralSint32(I);
5154
0
  case PT_Uint64:
5155
0
    return emitCastFloatingIntegralUint64(I);
5156
0
  case PT_Sint64:
5157
0
    return emitCastFloatingIntegralSint64(I);
5158
0
  case PT_Bool:
5159
0
    return emitCastFloatingIntegralBool(I);
5160
0
  default: llvm_unreachable("invalid type: emitCastFloatingIntegral");
5161
0
  }
5162
0
  llvm_unreachable("invalid enum value");
5163
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCastFloatingIntegral(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCastFloatingIntegral(clang::interp::PrimType, clang::interp::SourceInfo const&)
5164
#endif
5165
#ifdef GET_LINK_IMPL
5166
0
bool ByteCodeEmitter::emitCastFloatingIntegralUint8(const SourceInfo &L) {
5167
0
  return emitOp<>(OP_CastFloatingIntegralUint8, L);
5168
0
}
5169
0
bool ByteCodeEmitter::emitCastFloatingIntegralSint8(const SourceInfo &L) {
5170
0
  return emitOp<>(OP_CastFloatingIntegralSint8, L);
5171
0
}
5172
0
bool ByteCodeEmitter::emitCastFloatingIntegralUint16(const SourceInfo &L) {
5173
0
  return emitOp<>(OP_CastFloatingIntegralUint16, L);
5174
0
}
5175
0
bool ByteCodeEmitter::emitCastFloatingIntegralSint16(const SourceInfo &L) {
5176
0
  return emitOp<>(OP_CastFloatingIntegralSint16, L);
5177
0
}
5178
0
bool ByteCodeEmitter::emitCastFloatingIntegralUint32(const SourceInfo &L) {
5179
0
  return emitOp<>(OP_CastFloatingIntegralUint32, L);
5180
0
}
5181
0
bool ByteCodeEmitter::emitCastFloatingIntegralSint32(const SourceInfo &L) {
5182
0
  return emitOp<>(OP_CastFloatingIntegralSint32, L);
5183
0
}
5184
0
bool ByteCodeEmitter::emitCastFloatingIntegralUint64(const SourceInfo &L) {
5185
0
  return emitOp<>(OP_CastFloatingIntegralUint64, L);
5186
0
}
5187
0
bool ByteCodeEmitter::emitCastFloatingIntegralSint64(const SourceInfo &L) {
5188
0
  return emitOp<>(OP_CastFloatingIntegralSint64, L);
5189
0
}
5190
0
bool ByteCodeEmitter::emitCastFloatingIntegralBool(const SourceInfo &L) {
5191
0
  return emitOp<>(OP_CastFloatingIntegralBool, L);
5192
0
}
5193
#endif
5194
#ifdef GET_EVAL_IMPL
5195
0
bool EvalEmitter::emitCastFloatingIntegralUint8(const SourceInfo &L) {
5196
0
  if (!isActive()) return true;
5197
0
  CurrentSource = L;
5198
0
  return CastFloatingIntegral<PT_Uint8>(S, OpPC);
5199
0
}
5200
0
bool EvalEmitter::emitCastFloatingIntegralSint8(const SourceInfo &L) {
5201
0
  if (!isActive()) return true;
5202
0
  CurrentSource = L;
5203
0
  return CastFloatingIntegral<PT_Sint8>(S, OpPC);
5204
0
}
5205
0
bool EvalEmitter::emitCastFloatingIntegralUint16(const SourceInfo &L) {
5206
0
  if (!isActive()) return true;
5207
0
  CurrentSource = L;
5208
0
  return CastFloatingIntegral<PT_Uint16>(S, OpPC);
5209
0
}
5210
0
bool EvalEmitter::emitCastFloatingIntegralSint16(const SourceInfo &L) {
5211
0
  if (!isActive()) return true;
5212
0
  CurrentSource = L;
5213
0
  return CastFloatingIntegral<PT_Sint16>(S, OpPC);
5214
0
}
5215
0
bool EvalEmitter::emitCastFloatingIntegralUint32(const SourceInfo &L) {
5216
0
  if (!isActive()) return true;
5217
0
  CurrentSource = L;
5218
0
  return CastFloatingIntegral<PT_Uint32>(S, OpPC);
5219
0
}
5220
0
bool EvalEmitter::emitCastFloatingIntegralSint32(const SourceInfo &L) {
5221
0
  if (!isActive()) return true;
5222
0
  CurrentSource = L;
5223
0
  return CastFloatingIntegral<PT_Sint32>(S, OpPC);
5224
0
}
5225
0
bool EvalEmitter::emitCastFloatingIntegralUint64(const SourceInfo &L) {
5226
0
  if (!isActive()) return true;
5227
0
  CurrentSource = L;
5228
0
  return CastFloatingIntegral<PT_Uint64>(S, OpPC);
5229
0
}
5230
0
bool EvalEmitter::emitCastFloatingIntegralSint64(const SourceInfo &L) {
5231
0
  if (!isActive()) return true;
5232
0
  CurrentSource = L;
5233
0
  return CastFloatingIntegral<PT_Sint64>(S, OpPC);
5234
0
}
5235
0
bool EvalEmitter::emitCastFloatingIntegralBool(const SourceInfo &L) {
5236
0
  if (!isActive()) return true;
5237
0
  CurrentSource = L;
5238
0
  return CastFloatingIntegral<PT_Bool>(S, OpPC);
5239
0
}
5240
#endif
5241
#ifdef GET_OPCODE_NAMES
5242
OP_CastFloatingIntegralAP,
5243
#endif
5244
0
#ifdef GET_INTERP
5245
0
case OP_CastFloatingIntegralAP: {
5246
0
  auto V0 = ReadArg<uint32_t>(S, PC);
5247
0
  if (!CastFloatingIntegralAP(S, OpPC, V0))
5248
0
    return false;
5249
0
  continue;
5250
0
}
5251
0
#endif
5252
#ifdef GET_DISASM
5253
case OP_CastFloatingIntegralAP:
5254
  PrintName("CastFloatingIntegralAP");
5255
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
5256
  continue;
5257
#endif
5258
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5259
bool emitCastFloatingIntegralAP(uint32_t, const SourceInfo &);
5260
#endif
5261
#ifdef GET_LINK_IMPL
5262
0
bool ByteCodeEmitter::emitCastFloatingIntegralAP(uint32_t A0, const SourceInfo &L) {
5263
0
  return emitOp<uint32_t>(OP_CastFloatingIntegralAP, A0, L);
5264
0
}
5265
#endif
5266
#ifdef GET_EVAL_IMPL
5267
0
bool EvalEmitter::emitCastFloatingIntegralAP(uint32_t A0, const SourceInfo &L) {
5268
0
  if (!isActive()) return true;
5269
0
  CurrentSource = L;
5270
0
  return CastFloatingIntegralAP(S, OpPC, A0);
5271
0
}
5272
#endif
5273
#ifdef GET_OPCODE_NAMES
5274
OP_CastFloatingIntegralAPS,
5275
#endif
5276
0
#ifdef GET_INTERP
5277
0
case OP_CastFloatingIntegralAPS: {
5278
0
  auto V0 = ReadArg<uint32_t>(S, PC);
5279
0
  if (!CastFloatingIntegralAPS(S, OpPC, V0))
5280
0
    return false;
5281
0
  continue;
5282
0
}
5283
0
#endif
5284
#ifdef GET_DISASM
5285
case OP_CastFloatingIntegralAPS:
5286
  PrintName("CastFloatingIntegralAPS");
5287
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
5288
  continue;
5289
#endif
5290
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5291
bool emitCastFloatingIntegralAPS(uint32_t, const SourceInfo &);
5292
#endif
5293
#ifdef GET_LINK_IMPL
5294
0
bool ByteCodeEmitter::emitCastFloatingIntegralAPS(uint32_t A0, const SourceInfo &L) {
5295
0
  return emitOp<uint32_t>(OP_CastFloatingIntegralAPS, A0, L);
5296
0
}
5297
#endif
5298
#ifdef GET_EVAL_IMPL
5299
0
bool EvalEmitter::emitCastFloatingIntegralAPS(uint32_t A0, const SourceInfo &L) {
5300
0
  if (!isActive()) return true;
5301
0
  CurrentSource = L;
5302
0
  return CastFloatingIntegralAPS(S, OpPC, A0);
5303
0
}
5304
#endif
5305
#ifdef GET_OPCODE_NAMES
5306
OP_CastIntegralFloatingSint8,
5307
OP_CastIntegralFloatingUint8,
5308
OP_CastIntegralFloatingSint16,
5309
OP_CastIntegralFloatingUint16,
5310
OP_CastIntegralFloatingSint32,
5311
OP_CastIntegralFloatingUint32,
5312
OP_CastIntegralFloatingSint64,
5313
OP_CastIntegralFloatingUint64,
5314
OP_CastIntegralFloatingIntAP,
5315
OP_CastIntegralFloatingIntAPS,
5316
OP_CastIntegralFloatingBool,
5317
#endif
5318
0
#ifdef GET_INTERP
5319
0
case OP_CastIntegralFloatingSint8: {
5320
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5321
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5322
0
  if (!CastIntegralFloating<PT_Sint8>(S, OpPC, V0, V1))
5323
0
    return false;
5324
0
  continue;
5325
0
}
5326
0
case OP_CastIntegralFloatingUint8: {
5327
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5328
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5329
0
  if (!CastIntegralFloating<PT_Uint8>(S, OpPC, V0, V1))
5330
0
    return false;
5331
0
  continue;
5332
0
}
5333
0
case OP_CastIntegralFloatingSint16: {
5334
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5335
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5336
0
  if (!CastIntegralFloating<PT_Sint16>(S, OpPC, V0, V1))
5337
0
    return false;
5338
0
  continue;
5339
0
}
5340
0
case OP_CastIntegralFloatingUint16: {
5341
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5342
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5343
0
  if (!CastIntegralFloating<PT_Uint16>(S, OpPC, V0, V1))
5344
0
    return false;
5345
0
  continue;
5346
0
}
5347
0
case OP_CastIntegralFloatingSint32: {
5348
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5349
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5350
0
  if (!CastIntegralFloating<PT_Sint32>(S, OpPC, V0, V1))
5351
0
    return false;
5352
0
  continue;
5353
0
}
5354
0
case OP_CastIntegralFloatingUint32: {
5355
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5356
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5357
0
  if (!CastIntegralFloating<PT_Uint32>(S, OpPC, V0, V1))
5358
0
    return false;
5359
0
  continue;
5360
0
}
5361
0
case OP_CastIntegralFloatingSint64: {
5362
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5363
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5364
0
  if (!CastIntegralFloating<PT_Sint64>(S, OpPC, V0, V1))
5365
0
    return false;
5366
0
  continue;
5367
0
}
5368
0
case OP_CastIntegralFloatingUint64: {
5369
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5370
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5371
0
  if (!CastIntegralFloating<PT_Uint64>(S, OpPC, V0, V1))
5372
0
    return false;
5373
0
  continue;
5374
0
}
5375
0
case OP_CastIntegralFloatingIntAP: {
5376
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5377
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5378
0
  if (!CastIntegralFloating<PT_IntAP>(S, OpPC, V0, V1))
5379
0
    return false;
5380
0
  continue;
5381
0
}
5382
0
case OP_CastIntegralFloatingIntAPS: {
5383
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5384
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5385
0
  if (!CastIntegralFloating<PT_IntAPS>(S, OpPC, V0, V1))
5386
0
    return false;
5387
0
  continue;
5388
0
}
5389
0
case OP_CastIntegralFloatingBool: {
5390
0
  auto V0 = ReadArg<const llvm::fltSemantics *>(S, PC);
5391
0
  auto V1 = ReadArg<llvm::RoundingMode>(S, PC);
5392
0
  if (!CastIntegralFloating<PT_Bool>(S, OpPC, V0, V1))
5393
0
    return false;
5394
0
  continue;
5395
0
}
5396
0
#endif
5397
#ifdef GET_DISASM
5398
case OP_CastIntegralFloatingSint8:
5399
  PrintName("CastIntegralFloatingSint8");
5400
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5401
  continue;
5402
case OP_CastIntegralFloatingUint8:
5403
  PrintName("CastIntegralFloatingUint8");
5404
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5405
  continue;
5406
case OP_CastIntegralFloatingSint16:
5407
  PrintName("CastIntegralFloatingSint16");
5408
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5409
  continue;
5410
case OP_CastIntegralFloatingUint16:
5411
  PrintName("CastIntegralFloatingUint16");
5412
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5413
  continue;
5414
case OP_CastIntegralFloatingSint32:
5415
  PrintName("CastIntegralFloatingSint32");
5416
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5417
  continue;
5418
case OP_CastIntegralFloatingUint32:
5419
  PrintName("CastIntegralFloatingUint32");
5420
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5421
  continue;
5422
case OP_CastIntegralFloatingSint64:
5423
  PrintName("CastIntegralFloatingSint64");
5424
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5425
  continue;
5426
case OP_CastIntegralFloatingUint64:
5427
  PrintName("CastIntegralFloatingUint64");
5428
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5429
  continue;
5430
case OP_CastIntegralFloatingIntAP:
5431
  PrintName("CastIntegralFloatingIntAP");
5432
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5433
  continue;
5434
case OP_CastIntegralFloatingIntAPS:
5435
  PrintName("CastIntegralFloatingIntAPS");
5436
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5437
  continue;
5438
case OP_CastIntegralFloatingBool:
5439
  PrintName("CastIntegralFloatingBool");
5440
  OS << "\t" << ReadArg<const llvm::fltSemantics *>(P, PC) << " " << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
5441
  continue;
5442
#endif
5443
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5444
bool emitCastIntegralFloatingSint8(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5445
bool emitCastIntegralFloatingUint8(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5446
bool emitCastIntegralFloatingSint16(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5447
bool emitCastIntegralFloatingUint16(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5448
bool emitCastIntegralFloatingSint32(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5449
bool emitCastIntegralFloatingUint32(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5450
bool emitCastIntegralFloatingSint64(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5451
bool emitCastIntegralFloatingUint64(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5452
bool emitCastIntegralFloatingIntAP(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5453
bool emitCastIntegralFloatingIntAPS(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5454
bool emitCastIntegralFloatingBool(const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &);
5455
#endif
5456
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5457
bool emitCastIntegralFloating(PrimType, const llvm::fltSemantics *, llvm::RoundingMode, const SourceInfo &I);
5458
#endif
5459
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
5460
bool
5461
#if defined(GET_EVAL_IMPL)
5462
EvalEmitter
5463
#else
5464
ByteCodeEmitter
5465
#endif
5466
0
::emitCastIntegralFloating(PrimType T0, const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &I) {
5467
0
  switch (T0) {
5468
0
  case PT_Sint8:
5469
0
    return emitCastIntegralFloatingSint8(A0, A1, I);
5470
0
  case PT_Uint8:
5471
0
    return emitCastIntegralFloatingUint8(A0, A1, I);
5472
0
  case PT_Sint16:
5473
0
    return emitCastIntegralFloatingSint16(A0, A1, I);
5474
0
  case PT_Uint16:
5475
0
    return emitCastIntegralFloatingUint16(A0, A1, I);
5476
0
  case PT_Sint32:
5477
0
    return emitCastIntegralFloatingSint32(A0, A1, I);
5478
0
  case PT_Uint32:
5479
0
    return emitCastIntegralFloatingUint32(A0, A1, I);
5480
0
  case PT_Sint64:
5481
0
    return emitCastIntegralFloatingSint64(A0, A1, I);
5482
0
  case PT_Uint64:
5483
0
    return emitCastIntegralFloatingUint64(A0, A1, I);
5484
0
  case PT_IntAP:
5485
0
    return emitCastIntegralFloatingIntAP(A0, A1, I);
5486
0
  case PT_IntAPS:
5487
0
    return emitCastIntegralFloatingIntAPS(A0, A1, I);
5488
0
  case PT_Bool:
5489
0
    return emitCastIntegralFloatingBool(A0, A1, I);
5490
0
  default: llvm_unreachable("invalid type: emitCastIntegralFloating");
5491
0
  }
5492
0
  llvm_unreachable("invalid enum value");
5493
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCastIntegralFloating(clang::interp::PrimType, llvm::fltSemantics const*, llvm::RoundingMode, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCastIntegralFloating(clang::interp::PrimType, llvm::fltSemantics const*, llvm::RoundingMode, clang::interp::SourceInfo const&)
5494
#endif
5495
#ifdef GET_LINK_IMPL
5496
0
bool ByteCodeEmitter::emitCastIntegralFloatingSint8(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5497
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingSint8, A0, A1, L);
5498
0
}
5499
0
bool ByteCodeEmitter::emitCastIntegralFloatingUint8(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5500
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingUint8, A0, A1, L);
5501
0
}
5502
0
bool ByteCodeEmitter::emitCastIntegralFloatingSint16(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5503
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingSint16, A0, A1, L);
5504
0
}
5505
0
bool ByteCodeEmitter::emitCastIntegralFloatingUint16(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5506
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingUint16, A0, A1, L);
5507
0
}
5508
0
bool ByteCodeEmitter::emitCastIntegralFloatingSint32(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5509
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingSint32, A0, A1, L);
5510
0
}
5511
0
bool ByteCodeEmitter::emitCastIntegralFloatingUint32(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5512
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingUint32, A0, A1, L);
5513
0
}
5514
0
bool ByteCodeEmitter::emitCastIntegralFloatingSint64(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5515
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingSint64, A0, A1, L);
5516
0
}
5517
0
bool ByteCodeEmitter::emitCastIntegralFloatingUint64(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5518
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingUint64, A0, A1, L);
5519
0
}
5520
0
bool ByteCodeEmitter::emitCastIntegralFloatingIntAP(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5521
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingIntAP, A0, A1, L);
5522
0
}
5523
0
bool ByteCodeEmitter::emitCastIntegralFloatingIntAPS(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5524
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingIntAPS, A0, A1, L);
5525
0
}
5526
0
bool ByteCodeEmitter::emitCastIntegralFloatingBool(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5527
0
  return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastIntegralFloatingBool, A0, A1, L);
5528
0
}
5529
#endif
5530
#ifdef GET_EVAL_IMPL
5531
0
bool EvalEmitter::emitCastIntegralFloatingSint8(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5532
0
  if (!isActive()) return true;
5533
0
  CurrentSource = L;
5534
0
  return CastIntegralFloating<PT_Sint8>(S, OpPC, A0, A1);
5535
0
}
5536
0
bool EvalEmitter::emitCastIntegralFloatingUint8(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5537
0
  if (!isActive()) return true;
5538
0
  CurrentSource = L;
5539
0
  return CastIntegralFloating<PT_Uint8>(S, OpPC, A0, A1);
5540
0
}
5541
0
bool EvalEmitter::emitCastIntegralFloatingSint16(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5542
0
  if (!isActive()) return true;
5543
0
  CurrentSource = L;
5544
0
  return CastIntegralFloating<PT_Sint16>(S, OpPC, A0, A1);
5545
0
}
5546
0
bool EvalEmitter::emitCastIntegralFloatingUint16(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5547
0
  if (!isActive()) return true;
5548
0
  CurrentSource = L;
5549
0
  return CastIntegralFloating<PT_Uint16>(S, OpPC, A0, A1);
5550
0
}
5551
0
bool EvalEmitter::emitCastIntegralFloatingSint32(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5552
0
  if (!isActive()) return true;
5553
0
  CurrentSource = L;
5554
0
  return CastIntegralFloating<PT_Sint32>(S, OpPC, A0, A1);
5555
0
}
5556
0
bool EvalEmitter::emitCastIntegralFloatingUint32(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5557
0
  if (!isActive()) return true;
5558
0
  CurrentSource = L;
5559
0
  return CastIntegralFloating<PT_Uint32>(S, OpPC, A0, A1);
5560
0
}
5561
0
bool EvalEmitter::emitCastIntegralFloatingSint64(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5562
0
  if (!isActive()) return true;
5563
0
  CurrentSource = L;
5564
0
  return CastIntegralFloating<PT_Sint64>(S, OpPC, A0, A1);
5565
0
}
5566
0
bool EvalEmitter::emitCastIntegralFloatingUint64(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5567
0
  if (!isActive()) return true;
5568
0
  CurrentSource = L;
5569
0
  return CastIntegralFloating<PT_Uint64>(S, OpPC, A0, A1);
5570
0
}
5571
0
bool EvalEmitter::emitCastIntegralFloatingIntAP(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5572
0
  if (!isActive()) return true;
5573
0
  CurrentSource = L;
5574
0
  return CastIntegralFloating<PT_IntAP>(S, OpPC, A0, A1);
5575
0
}
5576
0
bool EvalEmitter::emitCastIntegralFloatingIntAPS(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5577
0
  if (!isActive()) return true;
5578
0
  CurrentSource = L;
5579
0
  return CastIntegralFloating<PT_IntAPS>(S, OpPC, A0, A1);
5580
0
}
5581
0
bool EvalEmitter::emitCastIntegralFloatingBool(const llvm::fltSemantics * A0, llvm::RoundingMode A1, const SourceInfo &L) {
5582
0
  if (!isActive()) return true;
5583
0
  CurrentSource = L;
5584
0
  return CastIntegralFloating<PT_Bool>(S, OpPC, A0, A1);
5585
0
}
5586
#endif
5587
#ifdef GET_OPCODE_NAMES
5588
OP_CastPointerIntegralSint8,
5589
OP_CastPointerIntegralUint8,
5590
OP_CastPointerIntegralSint16,
5591
OP_CastPointerIntegralUint16,
5592
OP_CastPointerIntegralSint32,
5593
OP_CastPointerIntegralUint32,
5594
OP_CastPointerIntegralSint64,
5595
OP_CastPointerIntegralUint64,
5596
OP_CastPointerIntegralIntAP,
5597
OP_CastPointerIntegralIntAPS,
5598
OP_CastPointerIntegralBool,
5599
#endif
5600
0
#ifdef GET_INTERP
5601
0
case OP_CastPointerIntegralSint8: {
5602
0
  if (!CastPointerIntegral<PT_Sint8>(S, OpPC))
5603
0
    return false;
5604
0
  continue;
5605
0
}
5606
0
case OP_CastPointerIntegralUint8: {
5607
0
  if (!CastPointerIntegral<PT_Uint8>(S, OpPC))
5608
0
    return false;
5609
0
  continue;
5610
0
}
5611
0
case OP_CastPointerIntegralSint16: {
5612
0
  if (!CastPointerIntegral<PT_Sint16>(S, OpPC))
5613
0
    return false;
5614
0
  continue;
5615
0
}
5616
0
case OP_CastPointerIntegralUint16: {
5617
0
  if (!CastPointerIntegral<PT_Uint16>(S, OpPC))
5618
0
    return false;
5619
0
  continue;
5620
0
}
5621
0
case OP_CastPointerIntegralSint32: {
5622
0
  if (!CastPointerIntegral<PT_Sint32>(S, OpPC))
5623
0
    return false;
5624
0
  continue;
5625
0
}
5626
0
case OP_CastPointerIntegralUint32: {
5627
0
  if (!CastPointerIntegral<PT_Uint32>(S, OpPC))
5628
0
    return false;
5629
0
  continue;
5630
0
}
5631
0
case OP_CastPointerIntegralSint64: {
5632
0
  if (!CastPointerIntegral<PT_Sint64>(S, OpPC))
5633
0
    return false;
5634
0
  continue;
5635
0
}
5636
0
case OP_CastPointerIntegralUint64: {
5637
0
  if (!CastPointerIntegral<PT_Uint64>(S, OpPC))
5638
0
    return false;
5639
0
  continue;
5640
0
}
5641
0
case OP_CastPointerIntegralIntAP: {
5642
0
  if (!CastPointerIntegral<PT_IntAP>(S, OpPC))
5643
0
    return false;
5644
0
  continue;
5645
0
}
5646
0
case OP_CastPointerIntegralIntAPS: {
5647
0
  if (!CastPointerIntegral<PT_IntAPS>(S, OpPC))
5648
0
    return false;
5649
0
  continue;
5650
0
}
5651
0
case OP_CastPointerIntegralBool: {
5652
0
  if (!CastPointerIntegral<PT_Bool>(S, OpPC))
5653
0
    return false;
5654
0
  continue;
5655
0
}
5656
0
#endif
5657
#ifdef GET_DISASM
5658
case OP_CastPointerIntegralSint8:
5659
  PrintName("CastPointerIntegralSint8");
5660
  OS << "\t" << "\n";
5661
  continue;
5662
case OP_CastPointerIntegralUint8:
5663
  PrintName("CastPointerIntegralUint8");
5664
  OS << "\t" << "\n";
5665
  continue;
5666
case OP_CastPointerIntegralSint16:
5667
  PrintName("CastPointerIntegralSint16");
5668
  OS << "\t" << "\n";
5669
  continue;
5670
case OP_CastPointerIntegralUint16:
5671
  PrintName("CastPointerIntegralUint16");
5672
  OS << "\t" << "\n";
5673
  continue;
5674
case OP_CastPointerIntegralSint32:
5675
  PrintName("CastPointerIntegralSint32");
5676
  OS << "\t" << "\n";
5677
  continue;
5678
case OP_CastPointerIntegralUint32:
5679
  PrintName("CastPointerIntegralUint32");
5680
  OS << "\t" << "\n";
5681
  continue;
5682
case OP_CastPointerIntegralSint64:
5683
  PrintName("CastPointerIntegralSint64");
5684
  OS << "\t" << "\n";
5685
  continue;
5686
case OP_CastPointerIntegralUint64:
5687
  PrintName("CastPointerIntegralUint64");
5688
  OS << "\t" << "\n";
5689
  continue;
5690
case OP_CastPointerIntegralIntAP:
5691
  PrintName("CastPointerIntegralIntAP");
5692
  OS << "\t" << "\n";
5693
  continue;
5694
case OP_CastPointerIntegralIntAPS:
5695
  PrintName("CastPointerIntegralIntAPS");
5696
  OS << "\t" << "\n";
5697
  continue;
5698
case OP_CastPointerIntegralBool:
5699
  PrintName("CastPointerIntegralBool");
5700
  OS << "\t" << "\n";
5701
  continue;
5702
#endif
5703
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5704
bool emitCastPointerIntegralSint8(const SourceInfo &);
5705
bool emitCastPointerIntegralUint8(const SourceInfo &);
5706
bool emitCastPointerIntegralSint16(const SourceInfo &);
5707
bool emitCastPointerIntegralUint16(const SourceInfo &);
5708
bool emitCastPointerIntegralSint32(const SourceInfo &);
5709
bool emitCastPointerIntegralUint32(const SourceInfo &);
5710
bool emitCastPointerIntegralSint64(const SourceInfo &);
5711
bool emitCastPointerIntegralUint64(const SourceInfo &);
5712
bool emitCastPointerIntegralIntAP(const SourceInfo &);
5713
bool emitCastPointerIntegralIntAPS(const SourceInfo &);
5714
bool emitCastPointerIntegralBool(const SourceInfo &);
5715
#endif
5716
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5717
bool emitCastPointerIntegral(PrimType, const SourceInfo &I);
5718
#endif
5719
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
5720
bool
5721
#if defined(GET_EVAL_IMPL)
5722
EvalEmitter
5723
#else
5724
ByteCodeEmitter
5725
#endif
5726
0
::emitCastPointerIntegral(PrimType T0, const SourceInfo &I) {
5727
0
  switch (T0) {
5728
0
  case PT_Sint8:
5729
0
    return emitCastPointerIntegralSint8(I);
5730
0
  case PT_Uint8:
5731
0
    return emitCastPointerIntegralUint8(I);
5732
0
  case PT_Sint16:
5733
0
    return emitCastPointerIntegralSint16(I);
5734
0
  case PT_Uint16:
5735
0
    return emitCastPointerIntegralUint16(I);
5736
0
  case PT_Sint32:
5737
0
    return emitCastPointerIntegralSint32(I);
5738
0
  case PT_Uint32:
5739
0
    return emitCastPointerIntegralUint32(I);
5740
0
  case PT_Sint64:
5741
0
    return emitCastPointerIntegralSint64(I);
5742
0
  case PT_Uint64:
5743
0
    return emitCastPointerIntegralUint64(I);
5744
0
  case PT_IntAP:
5745
0
    return emitCastPointerIntegralIntAP(I);
5746
0
  case PT_IntAPS:
5747
0
    return emitCastPointerIntegralIntAPS(I);
5748
0
  case PT_Bool:
5749
0
    return emitCastPointerIntegralBool(I);
5750
0
  default: llvm_unreachable("invalid type: emitCastPointerIntegral");
5751
0
  }
5752
0
  llvm_unreachable("invalid enum value");
5753
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitCastPointerIntegral(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitCastPointerIntegral(clang::interp::PrimType, clang::interp::SourceInfo const&)
5754
#endif
5755
#ifdef GET_LINK_IMPL
5756
0
bool ByteCodeEmitter::emitCastPointerIntegralSint8(const SourceInfo &L) {
5757
0
  return emitOp<>(OP_CastPointerIntegralSint8, L);
5758
0
}
5759
0
bool ByteCodeEmitter::emitCastPointerIntegralUint8(const SourceInfo &L) {
5760
0
  return emitOp<>(OP_CastPointerIntegralUint8, L);
5761
0
}
5762
0
bool ByteCodeEmitter::emitCastPointerIntegralSint16(const SourceInfo &L) {
5763
0
  return emitOp<>(OP_CastPointerIntegralSint16, L);
5764
0
}
5765
0
bool ByteCodeEmitter::emitCastPointerIntegralUint16(const SourceInfo &L) {
5766
0
  return emitOp<>(OP_CastPointerIntegralUint16, L);
5767
0
}
5768
0
bool ByteCodeEmitter::emitCastPointerIntegralSint32(const SourceInfo &L) {
5769
0
  return emitOp<>(OP_CastPointerIntegralSint32, L);
5770
0
}
5771
0
bool ByteCodeEmitter::emitCastPointerIntegralUint32(const SourceInfo &L) {
5772
0
  return emitOp<>(OP_CastPointerIntegralUint32, L);
5773
0
}
5774
0
bool ByteCodeEmitter::emitCastPointerIntegralSint64(const SourceInfo &L) {
5775
0
  return emitOp<>(OP_CastPointerIntegralSint64, L);
5776
0
}
5777
0
bool ByteCodeEmitter::emitCastPointerIntegralUint64(const SourceInfo &L) {
5778
0
  return emitOp<>(OP_CastPointerIntegralUint64, L);
5779
0
}
5780
0
bool ByteCodeEmitter::emitCastPointerIntegralIntAP(const SourceInfo &L) {
5781
0
  return emitOp<>(OP_CastPointerIntegralIntAP, L);
5782
0
}
5783
0
bool ByteCodeEmitter::emitCastPointerIntegralIntAPS(const SourceInfo &L) {
5784
0
  return emitOp<>(OP_CastPointerIntegralIntAPS, L);
5785
0
}
5786
0
bool ByteCodeEmitter::emitCastPointerIntegralBool(const SourceInfo &L) {
5787
0
  return emitOp<>(OP_CastPointerIntegralBool, L);
5788
0
}
5789
#endif
5790
#ifdef GET_EVAL_IMPL
5791
0
bool EvalEmitter::emitCastPointerIntegralSint8(const SourceInfo &L) {
5792
0
  if (!isActive()) return true;
5793
0
  CurrentSource = L;
5794
0
  return CastPointerIntegral<PT_Sint8>(S, OpPC);
5795
0
}
5796
0
bool EvalEmitter::emitCastPointerIntegralUint8(const SourceInfo &L) {
5797
0
  if (!isActive()) return true;
5798
0
  CurrentSource = L;
5799
0
  return CastPointerIntegral<PT_Uint8>(S, OpPC);
5800
0
}
5801
0
bool EvalEmitter::emitCastPointerIntegralSint16(const SourceInfo &L) {
5802
0
  if (!isActive()) return true;
5803
0
  CurrentSource = L;
5804
0
  return CastPointerIntegral<PT_Sint16>(S, OpPC);
5805
0
}
5806
0
bool EvalEmitter::emitCastPointerIntegralUint16(const SourceInfo &L) {
5807
0
  if (!isActive()) return true;
5808
0
  CurrentSource = L;
5809
0
  return CastPointerIntegral<PT_Uint16>(S, OpPC);
5810
0
}
5811
0
bool EvalEmitter::emitCastPointerIntegralSint32(const SourceInfo &L) {
5812
0
  if (!isActive()) return true;
5813
0
  CurrentSource = L;
5814
0
  return CastPointerIntegral<PT_Sint32>(S, OpPC);
5815
0
}
5816
0
bool EvalEmitter::emitCastPointerIntegralUint32(const SourceInfo &L) {
5817
0
  if (!isActive()) return true;
5818
0
  CurrentSource = L;
5819
0
  return CastPointerIntegral<PT_Uint32>(S, OpPC);
5820
0
}
5821
0
bool EvalEmitter::emitCastPointerIntegralSint64(const SourceInfo &L) {
5822
0
  if (!isActive()) return true;
5823
0
  CurrentSource = L;
5824
0
  return CastPointerIntegral<PT_Sint64>(S, OpPC);
5825
0
}
5826
0
bool EvalEmitter::emitCastPointerIntegralUint64(const SourceInfo &L) {
5827
0
  if (!isActive()) return true;
5828
0
  CurrentSource = L;
5829
0
  return CastPointerIntegral<PT_Uint64>(S, OpPC);
5830
0
}
5831
0
bool EvalEmitter::emitCastPointerIntegralIntAP(const SourceInfo &L) {
5832
0
  if (!isActive()) return true;
5833
0
  CurrentSource = L;
5834
0
  return CastPointerIntegral<PT_IntAP>(S, OpPC);
5835
0
}
5836
0
bool EvalEmitter::emitCastPointerIntegralIntAPS(const SourceInfo &L) {
5837
0
  if (!isActive()) return true;
5838
0
  CurrentSource = L;
5839
0
  return CastPointerIntegral<PT_IntAPS>(S, OpPC);
5840
0
}
5841
0
bool EvalEmitter::emitCastPointerIntegralBool(const SourceInfo &L) {
5842
0
  if (!isActive()) return true;
5843
0
  CurrentSource = L;
5844
0
  return CastPointerIntegral<PT_Bool>(S, OpPC);
5845
0
}
5846
#endif
5847
#ifdef GET_OPCODE_NAMES
5848
OP_CheckGlobalCtor,
5849
#endif
5850
0
#ifdef GET_INTERP
5851
0
case OP_CheckGlobalCtor: {
5852
0
  if (!CheckGlobalCtor(S, OpPC))
5853
0
    return false;
5854
0
  continue;
5855
0
}
5856
0
#endif
5857
#ifdef GET_DISASM
5858
case OP_CheckGlobalCtor:
5859
  PrintName("CheckGlobalCtor");
5860
  OS << "\t" << "\n";
5861
  continue;
5862
#endif
5863
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5864
bool emitCheckGlobalCtor(const SourceInfo &);
5865
#endif
5866
#ifdef GET_LINK_IMPL
5867
0
bool ByteCodeEmitter::emitCheckGlobalCtor(const SourceInfo &L) {
5868
0
  return emitOp<>(OP_CheckGlobalCtor, L);
5869
0
}
5870
#endif
5871
#ifdef GET_EVAL_IMPL
5872
0
bool EvalEmitter::emitCheckGlobalCtor(const SourceInfo &L) {
5873
0
  if (!isActive()) return true;
5874
0
  CurrentSource = L;
5875
0
  return CheckGlobalCtor(S, OpPC);
5876
0
}
5877
#endif
5878
#ifdef GET_OPCODE_NAMES
5879
OP_CompSint8,
5880
OP_CompUint8,
5881
OP_CompSint16,
5882
OP_CompUint16,
5883
OP_CompSint32,
5884
OP_CompUint32,
5885
OP_CompSint64,
5886
OP_CompUint64,
5887
OP_CompIntAP,
5888
OP_CompIntAPS,
5889
#endif
5890
0
#ifdef GET_INTERP
5891
0
case OP_CompSint8: {
5892
0
  if (!Comp<PT_Sint8>(S, OpPC))
5893
0
    return false;
5894
0
  continue;
5895
0
}
5896
0
case OP_CompUint8: {
5897
0
  if (!Comp<PT_Uint8>(S, OpPC))
5898
0
    return false;
5899
0
  continue;
5900
0
}
5901
0
case OP_CompSint16: {
5902
0
  if (!Comp<PT_Sint16>(S, OpPC))
5903
0
    return false;
5904
0
  continue;
5905
0
}
5906
0
case OP_CompUint16: {
5907
0
  if (!Comp<PT_Uint16>(S, OpPC))
5908
0
    return false;
5909
0
  continue;
5910
0
}
5911
0
case OP_CompSint32: {
5912
0
  if (!Comp<PT_Sint32>(S, OpPC))
5913
0
    return false;
5914
0
  continue;
5915
0
}
5916
0
case OP_CompUint32: {
5917
0
  if (!Comp<PT_Uint32>(S, OpPC))
5918
0
    return false;
5919
0
  continue;
5920
0
}
5921
0
case OP_CompSint64: {
5922
0
  if (!Comp<PT_Sint64>(S, OpPC))
5923
0
    return false;
5924
0
  continue;
5925
0
}
5926
0
case OP_CompUint64: {
5927
0
  if (!Comp<PT_Uint64>(S, OpPC))
5928
0
    return false;
5929
0
  continue;
5930
0
}
5931
0
case OP_CompIntAP: {
5932
0
  if (!Comp<PT_IntAP>(S, OpPC))
5933
0
    return false;
5934
0
  continue;
5935
0
}
5936
0
case OP_CompIntAPS: {
5937
0
  if (!Comp<PT_IntAPS>(S, OpPC))
5938
0
    return false;
5939
0
  continue;
5940
0
}
5941
0
#endif
5942
#ifdef GET_DISASM
5943
case OP_CompSint8:
5944
  PrintName("CompSint8");
5945
  OS << "\t" << "\n";
5946
  continue;
5947
case OP_CompUint8:
5948
  PrintName("CompUint8");
5949
  OS << "\t" << "\n";
5950
  continue;
5951
case OP_CompSint16:
5952
  PrintName("CompSint16");
5953
  OS << "\t" << "\n";
5954
  continue;
5955
case OP_CompUint16:
5956
  PrintName("CompUint16");
5957
  OS << "\t" << "\n";
5958
  continue;
5959
case OP_CompSint32:
5960
  PrintName("CompSint32");
5961
  OS << "\t" << "\n";
5962
  continue;
5963
case OP_CompUint32:
5964
  PrintName("CompUint32");
5965
  OS << "\t" << "\n";
5966
  continue;
5967
case OP_CompSint64:
5968
  PrintName("CompSint64");
5969
  OS << "\t" << "\n";
5970
  continue;
5971
case OP_CompUint64:
5972
  PrintName("CompUint64");
5973
  OS << "\t" << "\n";
5974
  continue;
5975
case OP_CompIntAP:
5976
  PrintName("CompIntAP");
5977
  OS << "\t" << "\n";
5978
  continue;
5979
case OP_CompIntAPS:
5980
  PrintName("CompIntAPS");
5981
  OS << "\t" << "\n";
5982
  continue;
5983
#endif
5984
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5985
bool emitCompSint8(const SourceInfo &);
5986
bool emitCompUint8(const SourceInfo &);
5987
bool emitCompSint16(const SourceInfo &);
5988
bool emitCompUint16(const SourceInfo &);
5989
bool emitCompSint32(const SourceInfo &);
5990
bool emitCompUint32(const SourceInfo &);
5991
bool emitCompSint64(const SourceInfo &);
5992
bool emitCompUint64(const SourceInfo &);
5993
bool emitCompIntAP(const SourceInfo &);
5994
bool emitCompIntAPS(const SourceInfo &);
5995
#endif
5996
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5997
bool emitComp(PrimType, const SourceInfo &I);
5998
#endif
5999
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
6000
bool
6001
#if defined(GET_EVAL_IMPL)
6002
EvalEmitter
6003
#else
6004
ByteCodeEmitter
6005
#endif
6006
0
::emitComp(PrimType T0, const SourceInfo &I) {
6007
0
  switch (T0) {
6008
0
  case PT_Sint8:
6009
0
    return emitCompSint8(I);
6010
0
  case PT_Uint8:
6011
0
    return emitCompUint8(I);
6012
0
  case PT_Sint16:
6013
0
    return emitCompSint16(I);
6014
0
  case PT_Uint16:
6015
0
    return emitCompUint16(I);
6016
0
  case PT_Sint32:
6017
0
    return emitCompSint32(I);
6018
0
  case PT_Uint32:
6019
0
    return emitCompUint32(I);
6020
0
  case PT_Sint64:
6021
0
    return emitCompSint64(I);
6022
0
  case PT_Uint64:
6023
0
    return emitCompUint64(I);
6024
0
  case PT_IntAP:
6025
0
    return emitCompIntAP(I);
6026
0
  case PT_IntAPS:
6027
0
    return emitCompIntAPS(I);
6028
0
  default: llvm_unreachable("invalid type: emitComp");
6029
0
  }
6030
0
  llvm_unreachable("invalid enum value");
6031
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitComp(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitComp(clang::interp::PrimType, clang::interp::SourceInfo const&)
6032
#endif
6033
#ifdef GET_LINK_IMPL
6034
0
bool ByteCodeEmitter::emitCompSint8(const SourceInfo &L) {
6035
0
  return emitOp<>(OP_CompSint8, L);
6036
0
}
6037
0
bool ByteCodeEmitter::emitCompUint8(const SourceInfo &L) {
6038
0
  return emitOp<>(OP_CompUint8, L);
6039
0
}
6040
0
bool ByteCodeEmitter::emitCompSint16(const SourceInfo &L) {
6041
0
  return emitOp<>(OP_CompSint16, L);
6042
0
}
6043
0
bool ByteCodeEmitter::emitCompUint16(const SourceInfo &L) {
6044
0
  return emitOp<>(OP_CompUint16, L);
6045
0
}
6046
0
bool ByteCodeEmitter::emitCompSint32(const SourceInfo &L) {
6047
0
  return emitOp<>(OP_CompSint32, L);
6048
0
}
6049
0
bool ByteCodeEmitter::emitCompUint32(const SourceInfo &L) {
6050
0
  return emitOp<>(OP_CompUint32, L);
6051
0
}
6052
0
bool ByteCodeEmitter::emitCompSint64(const SourceInfo &L) {
6053
0
  return emitOp<>(OP_CompSint64, L);
6054
0
}
6055
0
bool ByteCodeEmitter::emitCompUint64(const SourceInfo &L) {
6056
0
  return emitOp<>(OP_CompUint64, L);
6057
0
}
6058
0
bool ByteCodeEmitter::emitCompIntAP(const SourceInfo &L) {
6059
0
  return emitOp<>(OP_CompIntAP, L);
6060
0
}
6061
0
bool ByteCodeEmitter::emitCompIntAPS(const SourceInfo &L) {
6062
0
  return emitOp<>(OP_CompIntAPS, L);
6063
0
}
6064
#endif
6065
#ifdef GET_EVAL_IMPL
6066
0
bool EvalEmitter::emitCompSint8(const SourceInfo &L) {
6067
0
  if (!isActive()) return true;
6068
0
  CurrentSource = L;
6069
0
  return Comp<PT_Sint8>(S, OpPC);
6070
0
}
6071
0
bool EvalEmitter::emitCompUint8(const SourceInfo &L) {
6072
0
  if (!isActive()) return true;
6073
0
  CurrentSource = L;
6074
0
  return Comp<PT_Uint8>(S, OpPC);
6075
0
}
6076
0
bool EvalEmitter::emitCompSint16(const SourceInfo &L) {
6077
0
  if (!isActive()) return true;
6078
0
  CurrentSource = L;
6079
0
  return Comp<PT_Sint16>(S, OpPC);
6080
0
}
6081
0
bool EvalEmitter::emitCompUint16(const SourceInfo &L) {
6082
0
  if (!isActive()) return true;
6083
0
  CurrentSource = L;
6084
0
  return Comp<PT_Uint16>(S, OpPC);
6085
0
}
6086
0
bool EvalEmitter::emitCompSint32(const SourceInfo &L) {
6087
0
  if (!isActive()) return true;
6088
0
  CurrentSource = L;
6089
0
  return Comp<PT_Sint32>(S, OpPC);
6090
0
}
6091
0
bool EvalEmitter::emitCompUint32(const SourceInfo &L) {
6092
0
  if (!isActive()) return true;
6093
0
  CurrentSource = L;
6094
0
  return Comp<PT_Uint32>(S, OpPC);
6095
0
}
6096
0
bool EvalEmitter::emitCompSint64(const SourceInfo &L) {
6097
0
  if (!isActive()) return true;
6098
0
  CurrentSource = L;
6099
0
  return Comp<PT_Sint64>(S, OpPC);
6100
0
}
6101
0
bool EvalEmitter::emitCompUint64(const SourceInfo &L) {
6102
0
  if (!isActive()) return true;
6103
0
  CurrentSource = L;
6104
0
  return Comp<PT_Uint64>(S, OpPC);
6105
0
}
6106
0
bool EvalEmitter::emitCompIntAP(const SourceInfo &L) {
6107
0
  if (!isActive()) return true;
6108
0
  CurrentSource = L;
6109
0
  return Comp<PT_IntAP>(S, OpPC);
6110
0
}
6111
0
bool EvalEmitter::emitCompIntAPS(const SourceInfo &L) {
6112
0
  if (!isActive()) return true;
6113
0
  CurrentSource = L;
6114
0
  return Comp<PT_IntAPS>(S, OpPC);
6115
0
}
6116
#endif
6117
#ifdef GET_OPCODE_NAMES
6118
OP_ConstBool,
6119
#endif
6120
0
#ifdef GET_INTERP
6121
0
case OP_ConstBool: {
6122
0
  auto V0 = ReadArg<bool>(S, PC);
6123
0
  if (!Const<PT_Bool>(S, OpPC, V0))
6124
0
    return false;
6125
0
  continue;
6126
0
}
6127
0
#endif
6128
#ifdef GET_DISASM
6129
case OP_ConstBool:
6130
  PrintName("ConstBool");
6131
  OS << "\t" << ReadArg<bool>(P, PC) << " " << "\n";
6132
  continue;
6133
#endif
6134
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6135
bool emitConstBool(bool, const SourceInfo &);
6136
#endif
6137
#ifdef GET_LINK_IMPL
6138
0
bool ByteCodeEmitter::emitConstBool(bool A0, const SourceInfo &L) {
6139
0
  return emitOp<bool>(OP_ConstBool, A0, L);
6140
0
}
6141
#endif
6142
#ifdef GET_EVAL_IMPL
6143
0
bool EvalEmitter::emitConstBool(bool A0, const SourceInfo &L) {
6144
0
  if (!isActive()) return true;
6145
0
  CurrentSource = L;
6146
0
  return Const<PT_Bool>(S, OpPC, A0);
6147
0
}
6148
#endif
6149
#ifdef GET_OPCODE_NAMES
6150
OP_ConstFloat,
6151
#endif
6152
0
#ifdef GET_INTERP
6153
0
case OP_ConstFloat: {
6154
0
  auto V0 = ReadArg<Floating>(S, PC);
6155
0
  if (!Const<PT_Float>(S, OpPC, V0))
6156
0
    return false;
6157
0
  continue;
6158
0
}
6159
0
#endif
6160
#ifdef GET_DISASM
6161
case OP_ConstFloat:
6162
  PrintName("ConstFloat");
6163
  OS << "\t" << ReadArg<Floating>(P, PC) << " " << "\n";
6164
  continue;
6165
#endif
6166
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6167
bool emitConstFloat(Floating, const SourceInfo &);
6168
#endif
6169
#ifdef GET_LINK_IMPL
6170
0
bool ByteCodeEmitter::emitConstFloat(Floating A0, const SourceInfo &L) {
6171
0
  return emitOp<Floating>(OP_ConstFloat, A0, L);
6172
0
}
6173
#endif
6174
#ifdef GET_EVAL_IMPL
6175
0
bool EvalEmitter::emitConstFloat(Floating A0, const SourceInfo &L) {
6176
0
  if (!isActive()) return true;
6177
0
  CurrentSource = L;
6178
0
  return Const<PT_Float>(S, OpPC, A0);
6179
0
}
6180
#endif
6181
#ifdef GET_OPCODE_NAMES
6182
OP_ConstSint8,
6183
#endif
6184
0
#ifdef GET_INTERP
6185
0
case OP_ConstSint8: {
6186
0
  auto V0 = ReadArg<int8_t>(S, PC);
6187
0
  if (!Const<PT_Sint8>(S, OpPC, V0))
6188
0
    return false;
6189
0
  continue;
6190
0
}
6191
0
#endif
6192
#ifdef GET_DISASM
6193
case OP_ConstSint8:
6194
  PrintName("ConstSint8");
6195
  OS << "\t" << ReadArg<int8_t>(P, PC) << " " << "\n";
6196
  continue;
6197
#endif
6198
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6199
bool emitConstSint8(int8_t, const SourceInfo &);
6200
#endif
6201
#ifdef GET_LINK_IMPL
6202
0
bool ByteCodeEmitter::emitConstSint8(int8_t A0, const SourceInfo &L) {
6203
0
  return emitOp<int8_t>(OP_ConstSint8, A0, L);
6204
0
}
6205
#endif
6206
#ifdef GET_EVAL_IMPL
6207
0
bool EvalEmitter::emitConstSint8(int8_t A0, const SourceInfo &L) {
6208
0
  if (!isActive()) return true;
6209
0
  CurrentSource = L;
6210
0
  return Const<PT_Sint8>(S, OpPC, A0);
6211
0
}
6212
#endif
6213
#ifdef GET_OPCODE_NAMES
6214
OP_ConstSint16,
6215
#endif
6216
0
#ifdef GET_INTERP
6217
0
case OP_ConstSint16: {
6218
0
  auto V0 = ReadArg<int16_t>(S, PC);
6219
0
  if (!Const<PT_Sint16>(S, OpPC, V0))
6220
0
    return false;
6221
0
  continue;
6222
0
}
6223
0
#endif
6224
#ifdef GET_DISASM
6225
case OP_ConstSint16:
6226
  PrintName("ConstSint16");
6227
  OS << "\t" << ReadArg<int16_t>(P, PC) << " " << "\n";
6228
  continue;
6229
#endif
6230
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6231
bool emitConstSint16(int16_t, const SourceInfo &);
6232
#endif
6233
#ifdef GET_LINK_IMPL
6234
0
bool ByteCodeEmitter::emitConstSint16(int16_t A0, const SourceInfo &L) {
6235
0
  return emitOp<int16_t>(OP_ConstSint16, A0, L);
6236
0
}
6237
#endif
6238
#ifdef GET_EVAL_IMPL
6239
0
bool EvalEmitter::emitConstSint16(int16_t A0, const SourceInfo &L) {
6240
0
  if (!isActive()) return true;
6241
0
  CurrentSource = L;
6242
0
  return Const<PT_Sint16>(S, OpPC, A0);
6243
0
}
6244
#endif
6245
#ifdef GET_OPCODE_NAMES
6246
OP_ConstSint32,
6247
#endif
6248
0
#ifdef GET_INTERP
6249
0
case OP_ConstSint32: {
6250
0
  auto V0 = ReadArg<int32_t>(S, PC);
6251
0
  if (!Const<PT_Sint32>(S, OpPC, V0))
6252
0
    return false;
6253
0
  continue;
6254
0
}
6255
0
#endif
6256
#ifdef GET_DISASM
6257
case OP_ConstSint32:
6258
  PrintName("ConstSint32");
6259
  OS << "\t" << ReadArg<int32_t>(P, PC) << " " << "\n";
6260
  continue;
6261
#endif
6262
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6263
bool emitConstSint32(int32_t, const SourceInfo &);
6264
#endif
6265
#ifdef GET_LINK_IMPL
6266
0
bool ByteCodeEmitter::emitConstSint32(int32_t A0, const SourceInfo &L) {
6267
0
  return emitOp<int32_t>(OP_ConstSint32, A0, L);
6268
0
}
6269
#endif
6270
#ifdef GET_EVAL_IMPL
6271
0
bool EvalEmitter::emitConstSint32(int32_t A0, const SourceInfo &L) {
6272
0
  if (!isActive()) return true;
6273
0
  CurrentSource = L;
6274
0
  return Const<PT_Sint32>(S, OpPC, A0);
6275
0
}
6276
#endif
6277
#ifdef GET_OPCODE_NAMES
6278
OP_ConstSint64,
6279
#endif
6280
0
#ifdef GET_INTERP
6281
0
case OP_ConstSint64: {
6282
0
  auto V0 = ReadArg<int64_t>(S, PC);
6283
0
  if (!Const<PT_Sint64>(S, OpPC, V0))
6284
0
    return false;
6285
0
  continue;
6286
0
}
6287
0
#endif
6288
#ifdef GET_DISASM
6289
case OP_ConstSint64:
6290
  PrintName("ConstSint64");
6291
  OS << "\t" << ReadArg<int64_t>(P, PC) << " " << "\n";
6292
  continue;
6293
#endif
6294
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6295
bool emitConstSint64(int64_t, const SourceInfo &);
6296
#endif
6297
#ifdef GET_LINK_IMPL
6298
0
bool ByteCodeEmitter::emitConstSint64(int64_t A0, const SourceInfo &L) {
6299
0
  return emitOp<int64_t>(OP_ConstSint64, A0, L);
6300
0
}
6301
#endif
6302
#ifdef GET_EVAL_IMPL
6303
0
bool EvalEmitter::emitConstSint64(int64_t A0, const SourceInfo &L) {
6304
0
  if (!isActive()) return true;
6305
0
  CurrentSource = L;
6306
0
  return Const<PT_Sint64>(S, OpPC, A0);
6307
0
}
6308
#endif
6309
#ifdef GET_OPCODE_NAMES
6310
OP_ConstUint8,
6311
#endif
6312
0
#ifdef GET_INTERP
6313
0
case OP_ConstUint8: {
6314
0
  auto V0 = ReadArg<uint8_t>(S, PC);
6315
0
  if (!Const<PT_Uint8>(S, OpPC, V0))
6316
0
    return false;
6317
0
  continue;
6318
0
}
6319
0
#endif
6320
#ifdef GET_DISASM
6321
case OP_ConstUint8:
6322
  PrintName("ConstUint8");
6323
  OS << "\t" << ReadArg<uint8_t>(P, PC) << " " << "\n";
6324
  continue;
6325
#endif
6326
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6327
bool emitConstUint8(uint8_t, const SourceInfo &);
6328
#endif
6329
#ifdef GET_LINK_IMPL
6330
0
bool ByteCodeEmitter::emitConstUint8(uint8_t A0, const SourceInfo &L) {
6331
0
  return emitOp<uint8_t>(OP_ConstUint8, A0, L);
6332
0
}
6333
#endif
6334
#ifdef GET_EVAL_IMPL
6335
0
bool EvalEmitter::emitConstUint8(uint8_t A0, const SourceInfo &L) {
6336
0
  if (!isActive()) return true;
6337
0
  CurrentSource = L;
6338
0
  return Const<PT_Uint8>(S, OpPC, A0);
6339
0
}
6340
#endif
6341
#ifdef GET_OPCODE_NAMES
6342
OP_ConstUint16,
6343
#endif
6344
0
#ifdef GET_INTERP
6345
0
case OP_ConstUint16: {
6346
0
  auto V0 = ReadArg<uint16_t>(S, PC);
6347
0
  if (!Const<PT_Uint16>(S, OpPC, V0))
6348
0
    return false;
6349
0
  continue;
6350
0
}
6351
0
#endif
6352
#ifdef GET_DISASM
6353
case OP_ConstUint16:
6354
  PrintName("ConstUint16");
6355
  OS << "\t" << ReadArg<uint16_t>(P, PC) << " " << "\n";
6356
  continue;
6357
#endif
6358
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6359
bool emitConstUint16(uint16_t, const SourceInfo &);
6360
#endif
6361
#ifdef GET_LINK_IMPL
6362
0
bool ByteCodeEmitter::emitConstUint16(uint16_t A0, const SourceInfo &L) {
6363
0
  return emitOp<uint16_t>(OP_ConstUint16, A0, L);
6364
0
}
6365
#endif
6366
#ifdef GET_EVAL_IMPL
6367
0
bool EvalEmitter::emitConstUint16(uint16_t A0, const SourceInfo &L) {
6368
0
  if (!isActive()) return true;
6369
0
  CurrentSource = L;
6370
0
  return Const<PT_Uint16>(S, OpPC, A0);
6371
0
}
6372
#endif
6373
#ifdef GET_OPCODE_NAMES
6374
OP_ConstUint32,
6375
#endif
6376
0
#ifdef GET_INTERP
6377
0
case OP_ConstUint32: {
6378
0
  auto V0 = ReadArg<uint32_t>(S, PC);
6379
0
  if (!Const<PT_Uint32>(S, OpPC, V0))
6380
0
    return false;
6381
0
  continue;
6382
0
}
6383
0
#endif
6384
#ifdef GET_DISASM
6385
case OP_ConstUint32:
6386
  PrintName("ConstUint32");
6387
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
6388
  continue;
6389
#endif
6390
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6391
bool emitConstUint32(uint32_t, const SourceInfo &);
6392
#endif
6393
#ifdef GET_LINK_IMPL
6394
0
bool ByteCodeEmitter::emitConstUint32(uint32_t A0, const SourceInfo &L) {
6395
0
  return emitOp<uint32_t>(OP_ConstUint32, A0, L);
6396
0
}
6397
#endif
6398
#ifdef GET_EVAL_IMPL
6399
0
bool EvalEmitter::emitConstUint32(uint32_t A0, const SourceInfo &L) {
6400
0
  if (!isActive()) return true;
6401
0
  CurrentSource = L;
6402
0
  return Const<PT_Uint32>(S, OpPC, A0);
6403
0
}
6404
#endif
6405
#ifdef GET_OPCODE_NAMES
6406
OP_ConstUint64,
6407
#endif
6408
0
#ifdef GET_INTERP
6409
0
case OP_ConstUint64: {
6410
0
  auto V0 = ReadArg<uint64_t>(S, PC);
6411
0
  if (!Const<PT_Uint64>(S, OpPC, V0))
6412
0
    return false;
6413
0
  continue;
6414
0
}
6415
0
#endif
6416
#ifdef GET_DISASM
6417
case OP_ConstUint64:
6418
  PrintName("ConstUint64");
6419
  OS << "\t" << ReadArg<uint64_t>(P, PC) << " " << "\n";
6420
  continue;
6421
#endif
6422
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6423
bool emitConstUint64(uint64_t, const SourceInfo &);
6424
#endif
6425
#ifdef GET_LINK_IMPL
6426
0
bool ByteCodeEmitter::emitConstUint64(uint64_t A0, const SourceInfo &L) {
6427
0
  return emitOp<uint64_t>(OP_ConstUint64, A0, L);
6428
0
}
6429
#endif
6430
#ifdef GET_EVAL_IMPL
6431
0
bool EvalEmitter::emitConstUint64(uint64_t A0, const SourceInfo &L) {
6432
0
  if (!isActive()) return true;
6433
0
  CurrentSource = L;
6434
0
  return Const<PT_Uint64>(S, OpPC, A0);
6435
0
}
6436
#endif
6437
#ifdef GET_OPCODE_NAMES
6438
OP_DecSint8,
6439
OP_DecUint8,
6440
OP_DecSint16,
6441
OP_DecUint16,
6442
OP_DecSint32,
6443
OP_DecUint32,
6444
OP_DecSint64,
6445
OP_DecUint64,
6446
OP_DecIntAP,
6447
OP_DecIntAPS,
6448
#endif
6449
0
#ifdef GET_INTERP
6450
0
case OP_DecSint8: {
6451
0
  if (!Dec<PT_Sint8>(S, OpPC))
6452
0
    return false;
6453
0
  continue;
6454
0
}
6455
0
case OP_DecUint8: {
6456
0
  if (!Dec<PT_Uint8>(S, OpPC))
6457
0
    return false;
6458
0
  continue;
6459
0
}
6460
0
case OP_DecSint16: {
6461
0
  if (!Dec<PT_Sint16>(S, OpPC))
6462
0
    return false;
6463
0
  continue;
6464
0
}
6465
0
case OP_DecUint16: {
6466
0
  if (!Dec<PT_Uint16>(S, OpPC))
6467
0
    return false;
6468
0
  continue;
6469
0
}
6470
0
case OP_DecSint32: {
6471
0
  if (!Dec<PT_Sint32>(S, OpPC))
6472
0
    return false;
6473
0
  continue;
6474
0
}
6475
0
case OP_DecUint32: {
6476
0
  if (!Dec<PT_Uint32>(S, OpPC))
6477
0
    return false;
6478
0
  continue;
6479
0
}
6480
0
case OP_DecSint64: {
6481
0
  if (!Dec<PT_Sint64>(S, OpPC))
6482
0
    return false;
6483
0
  continue;
6484
0
}
6485
0
case OP_DecUint64: {
6486
0
  if (!Dec<PT_Uint64>(S, OpPC))
6487
0
    return false;
6488
0
  continue;
6489
0
}
6490
0
case OP_DecIntAP: {
6491
0
  if (!Dec<PT_IntAP>(S, OpPC))
6492
0
    return false;
6493
0
  continue;
6494
0
}
6495
0
case OP_DecIntAPS: {
6496
0
  if (!Dec<PT_IntAPS>(S, OpPC))
6497
0
    return false;
6498
0
  continue;
6499
0
}
6500
0
#endif
6501
#ifdef GET_DISASM
6502
case OP_DecSint8:
6503
  PrintName("DecSint8");
6504
  OS << "\t" << "\n";
6505
  continue;
6506
case OP_DecUint8:
6507
  PrintName("DecUint8");
6508
  OS << "\t" << "\n";
6509
  continue;
6510
case OP_DecSint16:
6511
  PrintName("DecSint16");
6512
  OS << "\t" << "\n";
6513
  continue;
6514
case OP_DecUint16:
6515
  PrintName("DecUint16");
6516
  OS << "\t" << "\n";
6517
  continue;
6518
case OP_DecSint32:
6519
  PrintName("DecSint32");
6520
  OS << "\t" << "\n";
6521
  continue;
6522
case OP_DecUint32:
6523
  PrintName("DecUint32");
6524
  OS << "\t" << "\n";
6525
  continue;
6526
case OP_DecSint64:
6527
  PrintName("DecSint64");
6528
  OS << "\t" << "\n";
6529
  continue;
6530
case OP_DecUint64:
6531
  PrintName("DecUint64");
6532
  OS << "\t" << "\n";
6533
  continue;
6534
case OP_DecIntAP:
6535
  PrintName("DecIntAP");
6536
  OS << "\t" << "\n";
6537
  continue;
6538
case OP_DecIntAPS:
6539
  PrintName("DecIntAPS");
6540
  OS << "\t" << "\n";
6541
  continue;
6542
#endif
6543
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6544
bool emitDecSint8(const SourceInfo &);
6545
bool emitDecUint8(const SourceInfo &);
6546
bool emitDecSint16(const SourceInfo &);
6547
bool emitDecUint16(const SourceInfo &);
6548
bool emitDecSint32(const SourceInfo &);
6549
bool emitDecUint32(const SourceInfo &);
6550
bool emitDecSint64(const SourceInfo &);
6551
bool emitDecUint64(const SourceInfo &);
6552
bool emitDecIntAP(const SourceInfo &);
6553
bool emitDecIntAPS(const SourceInfo &);
6554
#endif
6555
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6556
bool emitDec(PrimType, const SourceInfo &I);
6557
#endif
6558
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
6559
bool
6560
#if defined(GET_EVAL_IMPL)
6561
EvalEmitter
6562
#else
6563
ByteCodeEmitter
6564
#endif
6565
0
::emitDec(PrimType T0, const SourceInfo &I) {
6566
0
  switch (T0) {
6567
0
  case PT_Sint8:
6568
0
    return emitDecSint8(I);
6569
0
  case PT_Uint8:
6570
0
    return emitDecUint8(I);
6571
0
  case PT_Sint16:
6572
0
    return emitDecSint16(I);
6573
0
  case PT_Uint16:
6574
0
    return emitDecUint16(I);
6575
0
  case PT_Sint32:
6576
0
    return emitDecSint32(I);
6577
0
  case PT_Uint32:
6578
0
    return emitDecUint32(I);
6579
0
  case PT_Sint64:
6580
0
    return emitDecSint64(I);
6581
0
  case PT_Uint64:
6582
0
    return emitDecUint64(I);
6583
0
  case PT_IntAP:
6584
0
    return emitDecIntAP(I);
6585
0
  case PT_IntAPS:
6586
0
    return emitDecIntAPS(I);
6587
0
  default: llvm_unreachable("invalid type: emitDec");
6588
0
  }
6589
0
  llvm_unreachable("invalid enum value");
6590
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitDec(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitDec(clang::interp::PrimType, clang::interp::SourceInfo const&)
6591
#endif
6592
#ifdef GET_LINK_IMPL
6593
0
bool ByteCodeEmitter::emitDecSint8(const SourceInfo &L) {
6594
0
  return emitOp<>(OP_DecSint8, L);
6595
0
}
6596
0
bool ByteCodeEmitter::emitDecUint8(const SourceInfo &L) {
6597
0
  return emitOp<>(OP_DecUint8, L);
6598
0
}
6599
0
bool ByteCodeEmitter::emitDecSint16(const SourceInfo &L) {
6600
0
  return emitOp<>(OP_DecSint16, L);
6601
0
}
6602
0
bool ByteCodeEmitter::emitDecUint16(const SourceInfo &L) {
6603
0
  return emitOp<>(OP_DecUint16, L);
6604
0
}
6605
0
bool ByteCodeEmitter::emitDecSint32(const SourceInfo &L) {
6606
0
  return emitOp<>(OP_DecSint32, L);
6607
0
}
6608
0
bool ByteCodeEmitter::emitDecUint32(const SourceInfo &L) {
6609
0
  return emitOp<>(OP_DecUint32, L);
6610
0
}
6611
0
bool ByteCodeEmitter::emitDecSint64(const SourceInfo &L) {
6612
0
  return emitOp<>(OP_DecSint64, L);
6613
0
}
6614
0
bool ByteCodeEmitter::emitDecUint64(const SourceInfo &L) {
6615
0
  return emitOp<>(OP_DecUint64, L);
6616
0
}
6617
0
bool ByteCodeEmitter::emitDecIntAP(const SourceInfo &L) {
6618
0
  return emitOp<>(OP_DecIntAP, L);
6619
0
}
6620
0
bool ByteCodeEmitter::emitDecIntAPS(const SourceInfo &L) {
6621
0
  return emitOp<>(OP_DecIntAPS, L);
6622
0
}
6623
#endif
6624
#ifdef GET_EVAL_IMPL
6625
0
bool EvalEmitter::emitDecSint8(const SourceInfo &L) {
6626
0
  if (!isActive()) return true;
6627
0
  CurrentSource = L;
6628
0
  return Dec<PT_Sint8>(S, OpPC);
6629
0
}
6630
0
bool EvalEmitter::emitDecUint8(const SourceInfo &L) {
6631
0
  if (!isActive()) return true;
6632
0
  CurrentSource = L;
6633
0
  return Dec<PT_Uint8>(S, OpPC);
6634
0
}
6635
0
bool EvalEmitter::emitDecSint16(const SourceInfo &L) {
6636
0
  if (!isActive()) return true;
6637
0
  CurrentSource = L;
6638
0
  return Dec<PT_Sint16>(S, OpPC);
6639
0
}
6640
0
bool EvalEmitter::emitDecUint16(const SourceInfo &L) {
6641
0
  if (!isActive()) return true;
6642
0
  CurrentSource = L;
6643
0
  return Dec<PT_Uint16>(S, OpPC);
6644
0
}
6645
0
bool EvalEmitter::emitDecSint32(const SourceInfo &L) {
6646
0
  if (!isActive()) return true;
6647
0
  CurrentSource = L;
6648
0
  return Dec<PT_Sint32>(S, OpPC);
6649
0
}
6650
0
bool EvalEmitter::emitDecUint32(const SourceInfo &L) {
6651
0
  if (!isActive()) return true;
6652
0
  CurrentSource = L;
6653
0
  return Dec<PT_Uint32>(S, OpPC);
6654
0
}
6655
0
bool EvalEmitter::emitDecSint64(const SourceInfo &L) {
6656
0
  if (!isActive()) return true;
6657
0
  CurrentSource = L;
6658
0
  return Dec<PT_Sint64>(S, OpPC);
6659
0
}
6660
0
bool EvalEmitter::emitDecUint64(const SourceInfo &L) {
6661
0
  if (!isActive()) return true;
6662
0
  CurrentSource = L;
6663
0
  return Dec<PT_Uint64>(S, OpPC);
6664
0
}
6665
0
bool EvalEmitter::emitDecIntAP(const SourceInfo &L) {
6666
0
  if (!isActive()) return true;
6667
0
  CurrentSource = L;
6668
0
  return Dec<PT_IntAP>(S, OpPC);
6669
0
}
6670
0
bool EvalEmitter::emitDecIntAPS(const SourceInfo &L) {
6671
0
  if (!isActive()) return true;
6672
0
  CurrentSource = L;
6673
0
  return Dec<PT_IntAPS>(S, OpPC);
6674
0
}
6675
#endif
6676
#ifdef GET_OPCODE_NAMES
6677
OP_DecPopSint8,
6678
OP_DecPopUint8,
6679
OP_DecPopSint16,
6680
OP_DecPopUint16,
6681
OP_DecPopSint32,
6682
OP_DecPopUint32,
6683
OP_DecPopSint64,
6684
OP_DecPopUint64,
6685
OP_DecPopIntAP,
6686
OP_DecPopIntAPS,
6687
#endif
6688
0
#ifdef GET_INTERP
6689
0
case OP_DecPopSint8: {
6690
0
  if (!DecPop<PT_Sint8>(S, OpPC))
6691
0
    return false;
6692
0
  continue;
6693
0
}
6694
0
case OP_DecPopUint8: {
6695
0
  if (!DecPop<PT_Uint8>(S, OpPC))
6696
0
    return false;
6697
0
  continue;
6698
0
}
6699
0
case OP_DecPopSint16: {
6700
0
  if (!DecPop<PT_Sint16>(S, OpPC))
6701
0
    return false;
6702
0
  continue;
6703
0
}
6704
0
case OP_DecPopUint16: {
6705
0
  if (!DecPop<PT_Uint16>(S, OpPC))
6706
0
    return false;
6707
0
  continue;
6708
0
}
6709
0
case OP_DecPopSint32: {
6710
0
  if (!DecPop<PT_Sint32>(S, OpPC))
6711
0
    return false;
6712
0
  continue;
6713
0
}
6714
0
case OP_DecPopUint32: {
6715
0
  if (!DecPop<PT_Uint32>(S, OpPC))
6716
0
    return false;
6717
0
  continue;
6718
0
}
6719
0
case OP_DecPopSint64: {
6720
0
  if (!DecPop<PT_Sint64>(S, OpPC))
6721
0
    return false;
6722
0
  continue;
6723
0
}
6724
0
case OP_DecPopUint64: {
6725
0
  if (!DecPop<PT_Uint64>(S, OpPC))
6726
0
    return false;
6727
0
  continue;
6728
0
}
6729
0
case OP_DecPopIntAP: {
6730
0
  if (!DecPop<PT_IntAP>(S, OpPC))
6731
0
    return false;
6732
0
  continue;
6733
0
}
6734
0
case OP_DecPopIntAPS: {
6735
0
  if (!DecPop<PT_IntAPS>(S, OpPC))
6736
0
    return false;
6737
0
  continue;
6738
0
}
6739
0
#endif
6740
#ifdef GET_DISASM
6741
case OP_DecPopSint8:
6742
  PrintName("DecPopSint8");
6743
  OS << "\t" << "\n";
6744
  continue;
6745
case OP_DecPopUint8:
6746
  PrintName("DecPopUint8");
6747
  OS << "\t" << "\n";
6748
  continue;
6749
case OP_DecPopSint16:
6750
  PrintName("DecPopSint16");
6751
  OS << "\t" << "\n";
6752
  continue;
6753
case OP_DecPopUint16:
6754
  PrintName("DecPopUint16");
6755
  OS << "\t" << "\n";
6756
  continue;
6757
case OP_DecPopSint32:
6758
  PrintName("DecPopSint32");
6759
  OS << "\t" << "\n";
6760
  continue;
6761
case OP_DecPopUint32:
6762
  PrintName("DecPopUint32");
6763
  OS << "\t" << "\n";
6764
  continue;
6765
case OP_DecPopSint64:
6766
  PrintName("DecPopSint64");
6767
  OS << "\t" << "\n";
6768
  continue;
6769
case OP_DecPopUint64:
6770
  PrintName("DecPopUint64");
6771
  OS << "\t" << "\n";
6772
  continue;
6773
case OP_DecPopIntAP:
6774
  PrintName("DecPopIntAP");
6775
  OS << "\t" << "\n";
6776
  continue;
6777
case OP_DecPopIntAPS:
6778
  PrintName("DecPopIntAPS");
6779
  OS << "\t" << "\n";
6780
  continue;
6781
#endif
6782
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6783
bool emitDecPopSint8(const SourceInfo &);
6784
bool emitDecPopUint8(const SourceInfo &);
6785
bool emitDecPopSint16(const SourceInfo &);
6786
bool emitDecPopUint16(const SourceInfo &);
6787
bool emitDecPopSint32(const SourceInfo &);
6788
bool emitDecPopUint32(const SourceInfo &);
6789
bool emitDecPopSint64(const SourceInfo &);
6790
bool emitDecPopUint64(const SourceInfo &);
6791
bool emitDecPopIntAP(const SourceInfo &);
6792
bool emitDecPopIntAPS(const SourceInfo &);
6793
#endif
6794
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6795
bool emitDecPop(PrimType, const SourceInfo &I);
6796
#endif
6797
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
6798
bool
6799
#if defined(GET_EVAL_IMPL)
6800
EvalEmitter
6801
#else
6802
ByteCodeEmitter
6803
#endif
6804
0
::emitDecPop(PrimType T0, const SourceInfo &I) {
6805
0
  switch (T0) {
6806
0
  case PT_Sint8:
6807
0
    return emitDecPopSint8(I);
6808
0
  case PT_Uint8:
6809
0
    return emitDecPopUint8(I);
6810
0
  case PT_Sint16:
6811
0
    return emitDecPopSint16(I);
6812
0
  case PT_Uint16:
6813
0
    return emitDecPopUint16(I);
6814
0
  case PT_Sint32:
6815
0
    return emitDecPopSint32(I);
6816
0
  case PT_Uint32:
6817
0
    return emitDecPopUint32(I);
6818
0
  case PT_Sint64:
6819
0
    return emitDecPopSint64(I);
6820
0
  case PT_Uint64:
6821
0
    return emitDecPopUint64(I);
6822
0
  case PT_IntAP:
6823
0
    return emitDecPopIntAP(I);
6824
0
  case PT_IntAPS:
6825
0
    return emitDecPopIntAPS(I);
6826
0
  default: llvm_unreachable("invalid type: emitDecPop");
6827
0
  }
6828
0
  llvm_unreachable("invalid enum value");
6829
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitDecPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitDecPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
6830
#endif
6831
#ifdef GET_LINK_IMPL
6832
0
bool ByteCodeEmitter::emitDecPopSint8(const SourceInfo &L) {
6833
0
  return emitOp<>(OP_DecPopSint8, L);
6834
0
}
6835
0
bool ByteCodeEmitter::emitDecPopUint8(const SourceInfo &L) {
6836
0
  return emitOp<>(OP_DecPopUint8, L);
6837
0
}
6838
0
bool ByteCodeEmitter::emitDecPopSint16(const SourceInfo &L) {
6839
0
  return emitOp<>(OP_DecPopSint16, L);
6840
0
}
6841
0
bool ByteCodeEmitter::emitDecPopUint16(const SourceInfo &L) {
6842
0
  return emitOp<>(OP_DecPopUint16, L);
6843
0
}
6844
0
bool ByteCodeEmitter::emitDecPopSint32(const SourceInfo &L) {
6845
0
  return emitOp<>(OP_DecPopSint32, L);
6846
0
}
6847
0
bool ByteCodeEmitter::emitDecPopUint32(const SourceInfo &L) {
6848
0
  return emitOp<>(OP_DecPopUint32, L);
6849
0
}
6850
0
bool ByteCodeEmitter::emitDecPopSint64(const SourceInfo &L) {
6851
0
  return emitOp<>(OP_DecPopSint64, L);
6852
0
}
6853
0
bool ByteCodeEmitter::emitDecPopUint64(const SourceInfo &L) {
6854
0
  return emitOp<>(OP_DecPopUint64, L);
6855
0
}
6856
0
bool ByteCodeEmitter::emitDecPopIntAP(const SourceInfo &L) {
6857
0
  return emitOp<>(OP_DecPopIntAP, L);
6858
0
}
6859
0
bool ByteCodeEmitter::emitDecPopIntAPS(const SourceInfo &L) {
6860
0
  return emitOp<>(OP_DecPopIntAPS, L);
6861
0
}
6862
#endif
6863
#ifdef GET_EVAL_IMPL
6864
0
bool EvalEmitter::emitDecPopSint8(const SourceInfo &L) {
6865
0
  if (!isActive()) return true;
6866
0
  CurrentSource = L;
6867
0
  return DecPop<PT_Sint8>(S, OpPC);
6868
0
}
6869
0
bool EvalEmitter::emitDecPopUint8(const SourceInfo &L) {
6870
0
  if (!isActive()) return true;
6871
0
  CurrentSource = L;
6872
0
  return DecPop<PT_Uint8>(S, OpPC);
6873
0
}
6874
0
bool EvalEmitter::emitDecPopSint16(const SourceInfo &L) {
6875
0
  if (!isActive()) return true;
6876
0
  CurrentSource = L;
6877
0
  return DecPop<PT_Sint16>(S, OpPC);
6878
0
}
6879
0
bool EvalEmitter::emitDecPopUint16(const SourceInfo &L) {
6880
0
  if (!isActive()) return true;
6881
0
  CurrentSource = L;
6882
0
  return DecPop<PT_Uint16>(S, OpPC);
6883
0
}
6884
0
bool EvalEmitter::emitDecPopSint32(const SourceInfo &L) {
6885
0
  if (!isActive()) return true;
6886
0
  CurrentSource = L;
6887
0
  return DecPop<PT_Sint32>(S, OpPC);
6888
0
}
6889
0
bool EvalEmitter::emitDecPopUint32(const SourceInfo &L) {
6890
0
  if (!isActive()) return true;
6891
0
  CurrentSource = L;
6892
0
  return DecPop<PT_Uint32>(S, OpPC);
6893
0
}
6894
0
bool EvalEmitter::emitDecPopSint64(const SourceInfo &L) {
6895
0
  if (!isActive()) return true;
6896
0
  CurrentSource = L;
6897
0
  return DecPop<PT_Sint64>(S, OpPC);
6898
0
}
6899
0
bool EvalEmitter::emitDecPopUint64(const SourceInfo &L) {
6900
0
  if (!isActive()) return true;
6901
0
  CurrentSource = L;
6902
0
  return DecPop<PT_Uint64>(S, OpPC);
6903
0
}
6904
0
bool EvalEmitter::emitDecPopIntAP(const SourceInfo &L) {
6905
0
  if (!isActive()) return true;
6906
0
  CurrentSource = L;
6907
0
  return DecPop<PT_IntAP>(S, OpPC);
6908
0
}
6909
0
bool EvalEmitter::emitDecPopIntAPS(const SourceInfo &L) {
6910
0
  if (!isActive()) return true;
6911
0
  CurrentSource = L;
6912
0
  return DecPop<PT_IntAPS>(S, OpPC);
6913
0
}
6914
#endif
6915
#ifdef GET_OPCODE_NAMES
6916
OP_DecPtr,
6917
#endif
6918
0
#ifdef GET_INTERP
6919
0
case OP_DecPtr: {
6920
0
  if (!DecPtr(S, OpPC))
6921
0
    return false;
6922
0
  continue;
6923
0
}
6924
0
#endif
6925
#ifdef GET_DISASM
6926
case OP_DecPtr:
6927
  PrintName("DecPtr");
6928
  OS << "\t" << "\n";
6929
  continue;
6930
#endif
6931
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6932
bool emitDecPtr(const SourceInfo &);
6933
#endif
6934
#ifdef GET_LINK_IMPL
6935
0
bool ByteCodeEmitter::emitDecPtr(const SourceInfo &L) {
6936
0
  return emitOp<>(OP_DecPtr, L);
6937
0
}
6938
#endif
6939
#ifdef GET_EVAL_IMPL
6940
0
bool EvalEmitter::emitDecPtr(const SourceInfo &L) {
6941
0
  if (!isActive()) return true;
6942
0
  CurrentSource = L;
6943
0
  return DecPtr(S, OpPC);
6944
0
}
6945
#endif
6946
#ifdef GET_OPCODE_NAMES
6947
OP_Decf,
6948
#endif
6949
0
#ifdef GET_INTERP
6950
0
case OP_Decf: {
6951
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
6952
0
  if (!Decf(S, OpPC, V0))
6953
0
    return false;
6954
0
  continue;
6955
0
}
6956
0
#endif
6957
#ifdef GET_DISASM
6958
case OP_Decf:
6959
  PrintName("Decf");
6960
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
6961
  continue;
6962
#endif
6963
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6964
bool emitDecf(llvm::RoundingMode, const SourceInfo &);
6965
#endif
6966
#ifdef GET_LINK_IMPL
6967
0
bool ByteCodeEmitter::emitDecf(llvm::RoundingMode A0, const SourceInfo &L) {
6968
0
  return emitOp<llvm::RoundingMode>(OP_Decf, A0, L);
6969
0
}
6970
#endif
6971
#ifdef GET_EVAL_IMPL
6972
0
bool EvalEmitter::emitDecf(llvm::RoundingMode A0, const SourceInfo &L) {
6973
0
  if (!isActive()) return true;
6974
0
  CurrentSource = L;
6975
0
  return Decf(S, OpPC, A0);
6976
0
}
6977
#endif
6978
#ifdef GET_OPCODE_NAMES
6979
OP_DecfPop,
6980
#endif
6981
0
#ifdef GET_INTERP
6982
0
case OP_DecfPop: {
6983
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
6984
0
  if (!DecfPop(S, OpPC, V0))
6985
0
    return false;
6986
0
  continue;
6987
0
}
6988
0
#endif
6989
#ifdef GET_DISASM
6990
case OP_DecfPop:
6991
  PrintName("DecfPop");
6992
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
6993
  continue;
6994
#endif
6995
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
6996
bool emitDecfPop(llvm::RoundingMode, const SourceInfo &);
6997
#endif
6998
#ifdef GET_LINK_IMPL
6999
0
bool ByteCodeEmitter::emitDecfPop(llvm::RoundingMode A0, const SourceInfo &L) {
7000
0
  return emitOp<llvm::RoundingMode>(OP_DecfPop, A0, L);
7001
0
}
7002
#endif
7003
#ifdef GET_EVAL_IMPL
7004
0
bool EvalEmitter::emitDecfPop(llvm::RoundingMode A0, const SourceInfo &L) {
7005
0
  if (!isActive()) return true;
7006
0
  CurrentSource = L;
7007
0
  return DecfPop(S, OpPC, A0);
7008
0
}
7009
#endif
7010
#ifdef GET_OPCODE_NAMES
7011
OP_Destroy,
7012
#endif
7013
0
#ifdef GET_INTERP
7014
0
case OP_Destroy: {
7015
0
  auto V0 = ReadArg<uint32_t>(S, PC);
7016
0
  if (!Destroy(S, OpPC, V0))
7017
0
    return false;
7018
0
  continue;
7019
0
}
7020
0
#endif
7021
#ifdef GET_DISASM
7022
case OP_Destroy:
7023
  PrintName("Destroy");
7024
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
7025
  continue;
7026
#endif
7027
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7028
bool emitDestroy(uint32_t, const SourceInfo &);
7029
#endif
7030
#ifdef GET_LINK_IMPL
7031
0
bool ByteCodeEmitter::emitDestroy(uint32_t A0, const SourceInfo &L) {
7032
0
  return emitOp<uint32_t>(OP_Destroy, A0, L);
7033
0
}
7034
#endif
7035
#ifdef GET_OPCODE_NAMES
7036
OP_DivSint8,
7037
OP_DivUint8,
7038
OP_DivSint16,
7039
OP_DivUint16,
7040
OP_DivSint32,
7041
OP_DivUint32,
7042
OP_DivSint64,
7043
OP_DivUint64,
7044
OP_DivIntAP,
7045
OP_DivIntAPS,
7046
#endif
7047
0
#ifdef GET_INTERP
7048
0
case OP_DivSint8: {
7049
0
  if (!Div<PT_Sint8>(S, OpPC))
7050
0
    return false;
7051
0
  continue;
7052
0
}
7053
0
case OP_DivUint8: {
7054
0
  if (!Div<PT_Uint8>(S, OpPC))
7055
0
    return false;
7056
0
  continue;
7057
0
}
7058
0
case OP_DivSint16: {
7059
0
  if (!Div<PT_Sint16>(S, OpPC))
7060
0
    return false;
7061
0
  continue;
7062
0
}
7063
0
case OP_DivUint16: {
7064
0
  if (!Div<PT_Uint16>(S, OpPC))
7065
0
    return false;
7066
0
  continue;
7067
0
}
7068
0
case OP_DivSint32: {
7069
0
  if (!Div<PT_Sint32>(S, OpPC))
7070
0
    return false;
7071
0
  continue;
7072
0
}
7073
0
case OP_DivUint32: {
7074
0
  if (!Div<PT_Uint32>(S, OpPC))
7075
0
    return false;
7076
0
  continue;
7077
0
}
7078
0
case OP_DivSint64: {
7079
0
  if (!Div<PT_Sint64>(S, OpPC))
7080
0
    return false;
7081
0
  continue;
7082
0
}
7083
0
case OP_DivUint64: {
7084
0
  if (!Div<PT_Uint64>(S, OpPC))
7085
0
    return false;
7086
0
  continue;
7087
0
}
7088
0
case OP_DivIntAP: {
7089
0
  if (!Div<PT_IntAP>(S, OpPC))
7090
0
    return false;
7091
0
  continue;
7092
0
}
7093
0
case OP_DivIntAPS: {
7094
0
  if (!Div<PT_IntAPS>(S, OpPC))
7095
0
    return false;
7096
0
  continue;
7097
0
}
7098
0
#endif
7099
#ifdef GET_DISASM
7100
case OP_DivSint8:
7101
  PrintName("DivSint8");
7102
  OS << "\t" << "\n";
7103
  continue;
7104
case OP_DivUint8:
7105
  PrintName("DivUint8");
7106
  OS << "\t" << "\n";
7107
  continue;
7108
case OP_DivSint16:
7109
  PrintName("DivSint16");
7110
  OS << "\t" << "\n";
7111
  continue;
7112
case OP_DivUint16:
7113
  PrintName("DivUint16");
7114
  OS << "\t" << "\n";
7115
  continue;
7116
case OP_DivSint32:
7117
  PrintName("DivSint32");
7118
  OS << "\t" << "\n";
7119
  continue;
7120
case OP_DivUint32:
7121
  PrintName("DivUint32");
7122
  OS << "\t" << "\n";
7123
  continue;
7124
case OP_DivSint64:
7125
  PrintName("DivSint64");
7126
  OS << "\t" << "\n";
7127
  continue;
7128
case OP_DivUint64:
7129
  PrintName("DivUint64");
7130
  OS << "\t" << "\n";
7131
  continue;
7132
case OP_DivIntAP:
7133
  PrintName("DivIntAP");
7134
  OS << "\t" << "\n";
7135
  continue;
7136
case OP_DivIntAPS:
7137
  PrintName("DivIntAPS");
7138
  OS << "\t" << "\n";
7139
  continue;
7140
#endif
7141
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7142
bool emitDivSint8(const SourceInfo &);
7143
bool emitDivUint8(const SourceInfo &);
7144
bool emitDivSint16(const SourceInfo &);
7145
bool emitDivUint16(const SourceInfo &);
7146
bool emitDivSint32(const SourceInfo &);
7147
bool emitDivUint32(const SourceInfo &);
7148
bool emitDivSint64(const SourceInfo &);
7149
bool emitDivUint64(const SourceInfo &);
7150
bool emitDivIntAP(const SourceInfo &);
7151
bool emitDivIntAPS(const SourceInfo &);
7152
#endif
7153
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7154
bool emitDiv(PrimType, const SourceInfo &I);
7155
#endif
7156
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
7157
bool
7158
#if defined(GET_EVAL_IMPL)
7159
EvalEmitter
7160
#else
7161
ByteCodeEmitter
7162
#endif
7163
0
::emitDiv(PrimType T0, const SourceInfo &I) {
7164
0
  switch (T0) {
7165
0
  case PT_Sint8:
7166
0
    return emitDivSint8(I);
7167
0
  case PT_Uint8:
7168
0
    return emitDivUint8(I);
7169
0
  case PT_Sint16:
7170
0
    return emitDivSint16(I);
7171
0
  case PT_Uint16:
7172
0
    return emitDivUint16(I);
7173
0
  case PT_Sint32:
7174
0
    return emitDivSint32(I);
7175
0
  case PT_Uint32:
7176
0
    return emitDivUint32(I);
7177
0
  case PT_Sint64:
7178
0
    return emitDivSint64(I);
7179
0
  case PT_Uint64:
7180
0
    return emitDivUint64(I);
7181
0
  case PT_IntAP:
7182
0
    return emitDivIntAP(I);
7183
0
  case PT_IntAPS:
7184
0
    return emitDivIntAPS(I);
7185
0
  default: llvm_unreachable("invalid type: emitDiv");
7186
0
  }
7187
0
  llvm_unreachable("invalid enum value");
7188
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitDiv(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitDiv(clang::interp::PrimType, clang::interp::SourceInfo const&)
7189
#endif
7190
#ifdef GET_LINK_IMPL
7191
0
bool ByteCodeEmitter::emitDivSint8(const SourceInfo &L) {
7192
0
  return emitOp<>(OP_DivSint8, L);
7193
0
}
7194
0
bool ByteCodeEmitter::emitDivUint8(const SourceInfo &L) {
7195
0
  return emitOp<>(OP_DivUint8, L);
7196
0
}
7197
0
bool ByteCodeEmitter::emitDivSint16(const SourceInfo &L) {
7198
0
  return emitOp<>(OP_DivSint16, L);
7199
0
}
7200
0
bool ByteCodeEmitter::emitDivUint16(const SourceInfo &L) {
7201
0
  return emitOp<>(OP_DivUint16, L);
7202
0
}
7203
0
bool ByteCodeEmitter::emitDivSint32(const SourceInfo &L) {
7204
0
  return emitOp<>(OP_DivSint32, L);
7205
0
}
7206
0
bool ByteCodeEmitter::emitDivUint32(const SourceInfo &L) {
7207
0
  return emitOp<>(OP_DivUint32, L);
7208
0
}
7209
0
bool ByteCodeEmitter::emitDivSint64(const SourceInfo &L) {
7210
0
  return emitOp<>(OP_DivSint64, L);
7211
0
}
7212
0
bool ByteCodeEmitter::emitDivUint64(const SourceInfo &L) {
7213
0
  return emitOp<>(OP_DivUint64, L);
7214
0
}
7215
0
bool ByteCodeEmitter::emitDivIntAP(const SourceInfo &L) {
7216
0
  return emitOp<>(OP_DivIntAP, L);
7217
0
}
7218
0
bool ByteCodeEmitter::emitDivIntAPS(const SourceInfo &L) {
7219
0
  return emitOp<>(OP_DivIntAPS, L);
7220
0
}
7221
#endif
7222
#ifdef GET_EVAL_IMPL
7223
0
bool EvalEmitter::emitDivSint8(const SourceInfo &L) {
7224
0
  if (!isActive()) return true;
7225
0
  CurrentSource = L;
7226
0
  return Div<PT_Sint8>(S, OpPC);
7227
0
}
7228
0
bool EvalEmitter::emitDivUint8(const SourceInfo &L) {
7229
0
  if (!isActive()) return true;
7230
0
  CurrentSource = L;
7231
0
  return Div<PT_Uint8>(S, OpPC);
7232
0
}
7233
0
bool EvalEmitter::emitDivSint16(const SourceInfo &L) {
7234
0
  if (!isActive()) return true;
7235
0
  CurrentSource = L;
7236
0
  return Div<PT_Sint16>(S, OpPC);
7237
0
}
7238
0
bool EvalEmitter::emitDivUint16(const SourceInfo &L) {
7239
0
  if (!isActive()) return true;
7240
0
  CurrentSource = L;
7241
0
  return Div<PT_Uint16>(S, OpPC);
7242
0
}
7243
0
bool EvalEmitter::emitDivSint32(const SourceInfo &L) {
7244
0
  if (!isActive()) return true;
7245
0
  CurrentSource = L;
7246
0
  return Div<PT_Sint32>(S, OpPC);
7247
0
}
7248
0
bool EvalEmitter::emitDivUint32(const SourceInfo &L) {
7249
0
  if (!isActive()) return true;
7250
0
  CurrentSource = L;
7251
0
  return Div<PT_Uint32>(S, OpPC);
7252
0
}
7253
0
bool EvalEmitter::emitDivSint64(const SourceInfo &L) {
7254
0
  if (!isActive()) return true;
7255
0
  CurrentSource = L;
7256
0
  return Div<PT_Sint64>(S, OpPC);
7257
0
}
7258
0
bool EvalEmitter::emitDivUint64(const SourceInfo &L) {
7259
0
  if (!isActive()) return true;
7260
0
  CurrentSource = L;
7261
0
  return Div<PT_Uint64>(S, OpPC);
7262
0
}
7263
0
bool EvalEmitter::emitDivIntAP(const SourceInfo &L) {
7264
0
  if (!isActive()) return true;
7265
0
  CurrentSource = L;
7266
0
  return Div<PT_IntAP>(S, OpPC);
7267
0
}
7268
0
bool EvalEmitter::emitDivIntAPS(const SourceInfo &L) {
7269
0
  if (!isActive()) return true;
7270
0
  CurrentSource = L;
7271
0
  return Div<PT_IntAPS>(S, OpPC);
7272
0
}
7273
#endif
7274
#ifdef GET_OPCODE_NAMES
7275
OP_Divf,
7276
#endif
7277
0
#ifdef GET_INTERP
7278
0
case OP_Divf: {
7279
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
7280
0
  if (!Divf(S, OpPC, V0))
7281
0
    return false;
7282
0
  continue;
7283
0
}
7284
0
#endif
7285
#ifdef GET_DISASM
7286
case OP_Divf:
7287
  PrintName("Divf");
7288
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
7289
  continue;
7290
#endif
7291
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7292
bool emitDivf(llvm::RoundingMode, const SourceInfo &);
7293
#endif
7294
#ifdef GET_LINK_IMPL
7295
0
bool ByteCodeEmitter::emitDivf(llvm::RoundingMode A0, const SourceInfo &L) {
7296
0
  return emitOp<llvm::RoundingMode>(OP_Divf, A0, L);
7297
0
}
7298
#endif
7299
#ifdef GET_EVAL_IMPL
7300
0
bool EvalEmitter::emitDivf(llvm::RoundingMode A0, const SourceInfo &L) {
7301
0
  if (!isActive()) return true;
7302
0
  CurrentSource = L;
7303
0
  return Divf(S, OpPC, A0);
7304
0
}
7305
#endif
7306
#ifdef GET_OPCODE_NAMES
7307
OP_DupSint8,
7308
OP_DupUint8,
7309
OP_DupSint16,
7310
OP_DupUint16,
7311
OP_DupSint32,
7312
OP_DupUint32,
7313
OP_DupSint64,
7314
OP_DupUint64,
7315
OP_DupIntAP,
7316
OP_DupIntAPS,
7317
OP_DupBool,
7318
OP_DupPtr,
7319
OP_DupFnPtr,
7320
OP_DupFloat,
7321
#endif
7322
0
#ifdef GET_INTERP
7323
0
case OP_DupSint8: {
7324
0
  if (!Dup<PT_Sint8>(S, OpPC))
7325
0
    return false;
7326
0
  continue;
7327
0
}
7328
0
case OP_DupUint8: {
7329
0
  if (!Dup<PT_Uint8>(S, OpPC))
7330
0
    return false;
7331
0
  continue;
7332
0
}
7333
0
case OP_DupSint16: {
7334
0
  if (!Dup<PT_Sint16>(S, OpPC))
7335
0
    return false;
7336
0
  continue;
7337
0
}
7338
0
case OP_DupUint16: {
7339
0
  if (!Dup<PT_Uint16>(S, OpPC))
7340
0
    return false;
7341
0
  continue;
7342
0
}
7343
0
case OP_DupSint32: {
7344
0
  if (!Dup<PT_Sint32>(S, OpPC))
7345
0
    return false;
7346
0
  continue;
7347
0
}
7348
0
case OP_DupUint32: {
7349
0
  if (!Dup<PT_Uint32>(S, OpPC))
7350
0
    return false;
7351
0
  continue;
7352
0
}
7353
0
case OP_DupSint64: {
7354
0
  if (!Dup<PT_Sint64>(S, OpPC))
7355
0
    return false;
7356
0
  continue;
7357
0
}
7358
0
case OP_DupUint64: {
7359
0
  if (!Dup<PT_Uint64>(S, OpPC))
7360
0
    return false;
7361
0
  continue;
7362
0
}
7363
0
case OP_DupIntAP: {
7364
0
  if (!Dup<PT_IntAP>(S, OpPC))
7365
0
    return false;
7366
0
  continue;
7367
0
}
7368
0
case OP_DupIntAPS: {
7369
0
  if (!Dup<PT_IntAPS>(S, OpPC))
7370
0
    return false;
7371
0
  continue;
7372
0
}
7373
0
case OP_DupBool: {
7374
0
  if (!Dup<PT_Bool>(S, OpPC))
7375
0
    return false;
7376
0
  continue;
7377
0
}
7378
0
case OP_DupPtr: {
7379
0
  if (!Dup<PT_Ptr>(S, OpPC))
7380
0
    return false;
7381
0
  continue;
7382
0
}
7383
0
case OP_DupFnPtr: {
7384
0
  if (!Dup<PT_FnPtr>(S, OpPC))
7385
0
    return false;
7386
0
  continue;
7387
0
}
7388
0
case OP_DupFloat: {
7389
0
  if (!Dup<PT_Float>(S, OpPC))
7390
0
    return false;
7391
0
  continue;
7392
0
}
7393
0
#endif
7394
#ifdef GET_DISASM
7395
case OP_DupSint8:
7396
  PrintName("DupSint8");
7397
  OS << "\t" << "\n";
7398
  continue;
7399
case OP_DupUint8:
7400
  PrintName("DupUint8");
7401
  OS << "\t" << "\n";
7402
  continue;
7403
case OP_DupSint16:
7404
  PrintName("DupSint16");
7405
  OS << "\t" << "\n";
7406
  continue;
7407
case OP_DupUint16:
7408
  PrintName("DupUint16");
7409
  OS << "\t" << "\n";
7410
  continue;
7411
case OP_DupSint32:
7412
  PrintName("DupSint32");
7413
  OS << "\t" << "\n";
7414
  continue;
7415
case OP_DupUint32:
7416
  PrintName("DupUint32");
7417
  OS << "\t" << "\n";
7418
  continue;
7419
case OP_DupSint64:
7420
  PrintName("DupSint64");
7421
  OS << "\t" << "\n";
7422
  continue;
7423
case OP_DupUint64:
7424
  PrintName("DupUint64");
7425
  OS << "\t" << "\n";
7426
  continue;
7427
case OP_DupIntAP:
7428
  PrintName("DupIntAP");
7429
  OS << "\t" << "\n";
7430
  continue;
7431
case OP_DupIntAPS:
7432
  PrintName("DupIntAPS");
7433
  OS << "\t" << "\n";
7434
  continue;
7435
case OP_DupBool:
7436
  PrintName("DupBool");
7437
  OS << "\t" << "\n";
7438
  continue;
7439
case OP_DupPtr:
7440
  PrintName("DupPtr");
7441
  OS << "\t" << "\n";
7442
  continue;
7443
case OP_DupFnPtr:
7444
  PrintName("DupFnPtr");
7445
  OS << "\t" << "\n";
7446
  continue;
7447
case OP_DupFloat:
7448
  PrintName("DupFloat");
7449
  OS << "\t" << "\n";
7450
  continue;
7451
#endif
7452
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7453
bool emitDupSint8(const SourceInfo &);
7454
bool emitDupUint8(const SourceInfo &);
7455
bool emitDupSint16(const SourceInfo &);
7456
bool emitDupUint16(const SourceInfo &);
7457
bool emitDupSint32(const SourceInfo &);
7458
bool emitDupUint32(const SourceInfo &);
7459
bool emitDupSint64(const SourceInfo &);
7460
bool emitDupUint64(const SourceInfo &);
7461
bool emitDupIntAP(const SourceInfo &);
7462
bool emitDupIntAPS(const SourceInfo &);
7463
bool emitDupBool(const SourceInfo &);
7464
bool emitDupPtr(const SourceInfo &);
7465
bool emitDupFnPtr(const SourceInfo &);
7466
bool emitDupFloat(const SourceInfo &);
7467
#endif
7468
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7469
bool emitDup(PrimType, const SourceInfo &I);
7470
#endif
7471
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
7472
bool
7473
#if defined(GET_EVAL_IMPL)
7474
EvalEmitter
7475
#else
7476
ByteCodeEmitter
7477
#endif
7478
0
::emitDup(PrimType T0, const SourceInfo &I) {
7479
0
  switch (T0) {
7480
0
  case PT_Sint8:
7481
0
    return emitDupSint8(I);
7482
0
  case PT_Uint8:
7483
0
    return emitDupUint8(I);
7484
0
  case PT_Sint16:
7485
0
    return emitDupSint16(I);
7486
0
  case PT_Uint16:
7487
0
    return emitDupUint16(I);
7488
0
  case PT_Sint32:
7489
0
    return emitDupSint32(I);
7490
0
  case PT_Uint32:
7491
0
    return emitDupUint32(I);
7492
0
  case PT_Sint64:
7493
0
    return emitDupSint64(I);
7494
0
  case PT_Uint64:
7495
0
    return emitDupUint64(I);
7496
0
  case PT_IntAP:
7497
0
    return emitDupIntAP(I);
7498
0
  case PT_IntAPS:
7499
0
    return emitDupIntAPS(I);
7500
0
  case PT_Bool:
7501
0
    return emitDupBool(I);
7502
0
  case PT_Ptr:
7503
0
    return emitDupPtr(I);
7504
0
  case PT_FnPtr:
7505
0
    return emitDupFnPtr(I);
7506
0
  case PT_Float:
7507
0
    return emitDupFloat(I);
7508
0
  }
7509
0
  llvm_unreachable("invalid enum value");
7510
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitDup(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitDup(clang::interp::PrimType, clang::interp::SourceInfo const&)
7511
#endif
7512
#ifdef GET_LINK_IMPL
7513
0
bool ByteCodeEmitter::emitDupSint8(const SourceInfo &L) {
7514
0
  return emitOp<>(OP_DupSint8, L);
7515
0
}
7516
0
bool ByteCodeEmitter::emitDupUint8(const SourceInfo &L) {
7517
0
  return emitOp<>(OP_DupUint8, L);
7518
0
}
7519
0
bool ByteCodeEmitter::emitDupSint16(const SourceInfo &L) {
7520
0
  return emitOp<>(OP_DupSint16, L);
7521
0
}
7522
0
bool ByteCodeEmitter::emitDupUint16(const SourceInfo &L) {
7523
0
  return emitOp<>(OP_DupUint16, L);
7524
0
}
7525
0
bool ByteCodeEmitter::emitDupSint32(const SourceInfo &L) {
7526
0
  return emitOp<>(OP_DupSint32, L);
7527
0
}
7528
0
bool ByteCodeEmitter::emitDupUint32(const SourceInfo &L) {
7529
0
  return emitOp<>(OP_DupUint32, L);
7530
0
}
7531
0
bool ByteCodeEmitter::emitDupSint64(const SourceInfo &L) {
7532
0
  return emitOp<>(OP_DupSint64, L);
7533
0
}
7534
0
bool ByteCodeEmitter::emitDupUint64(const SourceInfo &L) {
7535
0
  return emitOp<>(OP_DupUint64, L);
7536
0
}
7537
0
bool ByteCodeEmitter::emitDupIntAP(const SourceInfo &L) {
7538
0
  return emitOp<>(OP_DupIntAP, L);
7539
0
}
7540
0
bool ByteCodeEmitter::emitDupIntAPS(const SourceInfo &L) {
7541
0
  return emitOp<>(OP_DupIntAPS, L);
7542
0
}
7543
0
bool ByteCodeEmitter::emitDupBool(const SourceInfo &L) {
7544
0
  return emitOp<>(OP_DupBool, L);
7545
0
}
7546
0
bool ByteCodeEmitter::emitDupPtr(const SourceInfo &L) {
7547
0
  return emitOp<>(OP_DupPtr, L);
7548
0
}
7549
0
bool ByteCodeEmitter::emitDupFnPtr(const SourceInfo &L) {
7550
0
  return emitOp<>(OP_DupFnPtr, L);
7551
0
}
7552
0
bool ByteCodeEmitter::emitDupFloat(const SourceInfo &L) {
7553
0
  return emitOp<>(OP_DupFloat, L);
7554
0
}
7555
#endif
7556
#ifdef GET_EVAL_IMPL
7557
0
bool EvalEmitter::emitDupSint8(const SourceInfo &L) {
7558
0
  if (!isActive()) return true;
7559
0
  CurrentSource = L;
7560
0
  return Dup<PT_Sint8>(S, OpPC);
7561
0
}
7562
0
bool EvalEmitter::emitDupUint8(const SourceInfo &L) {
7563
0
  if (!isActive()) return true;
7564
0
  CurrentSource = L;
7565
0
  return Dup<PT_Uint8>(S, OpPC);
7566
0
}
7567
0
bool EvalEmitter::emitDupSint16(const SourceInfo &L) {
7568
0
  if (!isActive()) return true;
7569
0
  CurrentSource = L;
7570
0
  return Dup<PT_Sint16>(S, OpPC);
7571
0
}
7572
0
bool EvalEmitter::emitDupUint16(const SourceInfo &L) {
7573
0
  if (!isActive()) return true;
7574
0
  CurrentSource = L;
7575
0
  return Dup<PT_Uint16>(S, OpPC);
7576
0
}
7577
0
bool EvalEmitter::emitDupSint32(const SourceInfo &L) {
7578
0
  if (!isActive()) return true;
7579
0
  CurrentSource = L;
7580
0
  return Dup<PT_Sint32>(S, OpPC);
7581
0
}
7582
0
bool EvalEmitter::emitDupUint32(const SourceInfo &L) {
7583
0
  if (!isActive()) return true;
7584
0
  CurrentSource = L;
7585
0
  return Dup<PT_Uint32>(S, OpPC);
7586
0
}
7587
0
bool EvalEmitter::emitDupSint64(const SourceInfo &L) {
7588
0
  if (!isActive()) return true;
7589
0
  CurrentSource = L;
7590
0
  return Dup<PT_Sint64>(S, OpPC);
7591
0
}
7592
0
bool EvalEmitter::emitDupUint64(const SourceInfo &L) {
7593
0
  if (!isActive()) return true;
7594
0
  CurrentSource = L;
7595
0
  return Dup<PT_Uint64>(S, OpPC);
7596
0
}
7597
0
bool EvalEmitter::emitDupIntAP(const SourceInfo &L) {
7598
0
  if (!isActive()) return true;
7599
0
  CurrentSource = L;
7600
0
  return Dup<PT_IntAP>(S, OpPC);
7601
0
}
7602
0
bool EvalEmitter::emitDupIntAPS(const SourceInfo &L) {
7603
0
  if (!isActive()) return true;
7604
0
  CurrentSource = L;
7605
0
  return Dup<PT_IntAPS>(S, OpPC);
7606
0
}
7607
0
bool EvalEmitter::emitDupBool(const SourceInfo &L) {
7608
0
  if (!isActive()) return true;
7609
0
  CurrentSource = L;
7610
0
  return Dup<PT_Bool>(S, OpPC);
7611
0
}
7612
0
bool EvalEmitter::emitDupPtr(const SourceInfo &L) {
7613
0
  if (!isActive()) return true;
7614
0
  CurrentSource = L;
7615
0
  return Dup<PT_Ptr>(S, OpPC);
7616
0
}
7617
0
bool EvalEmitter::emitDupFnPtr(const SourceInfo &L) {
7618
0
  if (!isActive()) return true;
7619
0
  CurrentSource = L;
7620
0
  return Dup<PT_FnPtr>(S, OpPC);
7621
0
}
7622
0
bool EvalEmitter::emitDupFloat(const SourceInfo &L) {
7623
0
  if (!isActive()) return true;
7624
0
  CurrentSource = L;
7625
0
  return Dup<PT_Float>(S, OpPC);
7626
0
}
7627
#endif
7628
#ifdef GET_OPCODE_NAMES
7629
OP_EQSint8,
7630
OP_EQUint8,
7631
OP_EQSint16,
7632
OP_EQUint16,
7633
OP_EQSint32,
7634
OP_EQUint32,
7635
OP_EQSint64,
7636
OP_EQUint64,
7637
OP_EQIntAP,
7638
OP_EQIntAPS,
7639
OP_EQBool,
7640
OP_EQPtr,
7641
OP_EQFnPtr,
7642
OP_EQFloat,
7643
#endif
7644
0
#ifdef GET_INTERP
7645
0
case OP_EQSint8: {
7646
0
  if (!EQ<PT_Sint8>(S, OpPC))
7647
0
    return false;
7648
0
  continue;
7649
0
}
7650
0
case OP_EQUint8: {
7651
0
  if (!EQ<PT_Uint8>(S, OpPC))
7652
0
    return false;
7653
0
  continue;
7654
0
}
7655
0
case OP_EQSint16: {
7656
0
  if (!EQ<PT_Sint16>(S, OpPC))
7657
0
    return false;
7658
0
  continue;
7659
0
}
7660
0
case OP_EQUint16: {
7661
0
  if (!EQ<PT_Uint16>(S, OpPC))
7662
0
    return false;
7663
0
  continue;
7664
0
}
7665
0
case OP_EQSint32: {
7666
0
  if (!EQ<PT_Sint32>(S, OpPC))
7667
0
    return false;
7668
0
  continue;
7669
0
}
7670
0
case OP_EQUint32: {
7671
0
  if (!EQ<PT_Uint32>(S, OpPC))
7672
0
    return false;
7673
0
  continue;
7674
0
}
7675
0
case OP_EQSint64: {
7676
0
  if (!EQ<PT_Sint64>(S, OpPC))
7677
0
    return false;
7678
0
  continue;
7679
0
}
7680
0
case OP_EQUint64: {
7681
0
  if (!EQ<PT_Uint64>(S, OpPC))
7682
0
    return false;
7683
0
  continue;
7684
0
}
7685
0
case OP_EQIntAP: {
7686
0
  if (!EQ<PT_IntAP>(S, OpPC))
7687
0
    return false;
7688
0
  continue;
7689
0
}
7690
0
case OP_EQIntAPS: {
7691
0
  if (!EQ<PT_IntAPS>(S, OpPC))
7692
0
    return false;
7693
0
  continue;
7694
0
}
7695
0
case OP_EQBool: {
7696
0
  if (!EQ<PT_Bool>(S, OpPC))
7697
0
    return false;
7698
0
  continue;
7699
0
}
7700
0
case OP_EQPtr: {
7701
0
  if (!EQ<PT_Ptr>(S, OpPC))
7702
0
    return false;
7703
0
  continue;
7704
0
}
7705
0
case OP_EQFnPtr: {
7706
0
  if (!EQ<PT_FnPtr>(S, OpPC))
7707
0
    return false;
7708
0
  continue;
7709
0
}
7710
0
case OP_EQFloat: {
7711
0
  if (!EQ<PT_Float>(S, OpPC))
7712
0
    return false;
7713
0
  continue;
7714
0
}
7715
0
#endif
7716
#ifdef GET_DISASM
7717
case OP_EQSint8:
7718
  PrintName("EQSint8");
7719
  OS << "\t" << "\n";
7720
  continue;
7721
case OP_EQUint8:
7722
  PrintName("EQUint8");
7723
  OS << "\t" << "\n";
7724
  continue;
7725
case OP_EQSint16:
7726
  PrintName("EQSint16");
7727
  OS << "\t" << "\n";
7728
  continue;
7729
case OP_EQUint16:
7730
  PrintName("EQUint16");
7731
  OS << "\t" << "\n";
7732
  continue;
7733
case OP_EQSint32:
7734
  PrintName("EQSint32");
7735
  OS << "\t" << "\n";
7736
  continue;
7737
case OP_EQUint32:
7738
  PrintName("EQUint32");
7739
  OS << "\t" << "\n";
7740
  continue;
7741
case OP_EQSint64:
7742
  PrintName("EQSint64");
7743
  OS << "\t" << "\n";
7744
  continue;
7745
case OP_EQUint64:
7746
  PrintName("EQUint64");
7747
  OS << "\t" << "\n";
7748
  continue;
7749
case OP_EQIntAP:
7750
  PrintName("EQIntAP");
7751
  OS << "\t" << "\n";
7752
  continue;
7753
case OP_EQIntAPS:
7754
  PrintName("EQIntAPS");
7755
  OS << "\t" << "\n";
7756
  continue;
7757
case OP_EQBool:
7758
  PrintName("EQBool");
7759
  OS << "\t" << "\n";
7760
  continue;
7761
case OP_EQPtr:
7762
  PrintName("EQPtr");
7763
  OS << "\t" << "\n";
7764
  continue;
7765
case OP_EQFnPtr:
7766
  PrintName("EQFnPtr");
7767
  OS << "\t" << "\n";
7768
  continue;
7769
case OP_EQFloat:
7770
  PrintName("EQFloat");
7771
  OS << "\t" << "\n";
7772
  continue;
7773
#endif
7774
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7775
bool emitEQSint8(const SourceInfo &);
7776
bool emitEQUint8(const SourceInfo &);
7777
bool emitEQSint16(const SourceInfo &);
7778
bool emitEQUint16(const SourceInfo &);
7779
bool emitEQSint32(const SourceInfo &);
7780
bool emitEQUint32(const SourceInfo &);
7781
bool emitEQSint64(const SourceInfo &);
7782
bool emitEQUint64(const SourceInfo &);
7783
bool emitEQIntAP(const SourceInfo &);
7784
bool emitEQIntAPS(const SourceInfo &);
7785
bool emitEQBool(const SourceInfo &);
7786
bool emitEQPtr(const SourceInfo &);
7787
bool emitEQFnPtr(const SourceInfo &);
7788
bool emitEQFloat(const SourceInfo &);
7789
#endif
7790
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7791
bool emitEQ(PrimType, const SourceInfo &I);
7792
#endif
7793
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
7794
bool
7795
#if defined(GET_EVAL_IMPL)
7796
EvalEmitter
7797
#else
7798
ByteCodeEmitter
7799
#endif
7800
0
::emitEQ(PrimType T0, const SourceInfo &I) {
7801
0
  switch (T0) {
7802
0
  case PT_Sint8:
7803
0
    return emitEQSint8(I);
7804
0
  case PT_Uint8:
7805
0
    return emitEQUint8(I);
7806
0
  case PT_Sint16:
7807
0
    return emitEQSint16(I);
7808
0
  case PT_Uint16:
7809
0
    return emitEQUint16(I);
7810
0
  case PT_Sint32:
7811
0
    return emitEQSint32(I);
7812
0
  case PT_Uint32:
7813
0
    return emitEQUint32(I);
7814
0
  case PT_Sint64:
7815
0
    return emitEQSint64(I);
7816
0
  case PT_Uint64:
7817
0
    return emitEQUint64(I);
7818
0
  case PT_IntAP:
7819
0
    return emitEQIntAP(I);
7820
0
  case PT_IntAPS:
7821
0
    return emitEQIntAPS(I);
7822
0
  case PT_Bool:
7823
0
    return emitEQBool(I);
7824
0
  case PT_Ptr:
7825
0
    return emitEQPtr(I);
7826
0
  case PT_FnPtr:
7827
0
    return emitEQFnPtr(I);
7828
0
  case PT_Float:
7829
0
    return emitEQFloat(I);
7830
0
  }
7831
0
  llvm_unreachable("invalid enum value");
7832
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitEQ(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitEQ(clang::interp::PrimType, clang::interp::SourceInfo const&)
7833
#endif
7834
#ifdef GET_LINK_IMPL
7835
0
bool ByteCodeEmitter::emitEQSint8(const SourceInfo &L) {
7836
0
  return emitOp<>(OP_EQSint8, L);
7837
0
}
7838
0
bool ByteCodeEmitter::emitEQUint8(const SourceInfo &L) {
7839
0
  return emitOp<>(OP_EQUint8, L);
7840
0
}
7841
0
bool ByteCodeEmitter::emitEQSint16(const SourceInfo &L) {
7842
0
  return emitOp<>(OP_EQSint16, L);
7843
0
}
7844
0
bool ByteCodeEmitter::emitEQUint16(const SourceInfo &L) {
7845
0
  return emitOp<>(OP_EQUint16, L);
7846
0
}
7847
0
bool ByteCodeEmitter::emitEQSint32(const SourceInfo &L) {
7848
0
  return emitOp<>(OP_EQSint32, L);
7849
0
}
7850
0
bool ByteCodeEmitter::emitEQUint32(const SourceInfo &L) {
7851
0
  return emitOp<>(OP_EQUint32, L);
7852
0
}
7853
0
bool ByteCodeEmitter::emitEQSint64(const SourceInfo &L) {
7854
0
  return emitOp<>(OP_EQSint64, L);
7855
0
}
7856
0
bool ByteCodeEmitter::emitEQUint64(const SourceInfo &L) {
7857
0
  return emitOp<>(OP_EQUint64, L);
7858
0
}
7859
0
bool ByteCodeEmitter::emitEQIntAP(const SourceInfo &L) {
7860
0
  return emitOp<>(OP_EQIntAP, L);
7861
0
}
7862
0
bool ByteCodeEmitter::emitEQIntAPS(const SourceInfo &L) {
7863
0
  return emitOp<>(OP_EQIntAPS, L);
7864
0
}
7865
0
bool ByteCodeEmitter::emitEQBool(const SourceInfo &L) {
7866
0
  return emitOp<>(OP_EQBool, L);
7867
0
}
7868
0
bool ByteCodeEmitter::emitEQPtr(const SourceInfo &L) {
7869
0
  return emitOp<>(OP_EQPtr, L);
7870
0
}
7871
0
bool ByteCodeEmitter::emitEQFnPtr(const SourceInfo &L) {
7872
0
  return emitOp<>(OP_EQFnPtr, L);
7873
0
}
7874
0
bool ByteCodeEmitter::emitEQFloat(const SourceInfo &L) {
7875
0
  return emitOp<>(OP_EQFloat, L);
7876
0
}
7877
#endif
7878
#ifdef GET_EVAL_IMPL
7879
0
bool EvalEmitter::emitEQSint8(const SourceInfo &L) {
7880
0
  if (!isActive()) return true;
7881
0
  CurrentSource = L;
7882
0
  return EQ<PT_Sint8>(S, OpPC);
7883
0
}
7884
0
bool EvalEmitter::emitEQUint8(const SourceInfo &L) {
7885
0
  if (!isActive()) return true;
7886
0
  CurrentSource = L;
7887
0
  return EQ<PT_Uint8>(S, OpPC);
7888
0
}
7889
0
bool EvalEmitter::emitEQSint16(const SourceInfo &L) {
7890
0
  if (!isActive()) return true;
7891
0
  CurrentSource = L;
7892
0
  return EQ<PT_Sint16>(S, OpPC);
7893
0
}
7894
0
bool EvalEmitter::emitEQUint16(const SourceInfo &L) {
7895
0
  if (!isActive()) return true;
7896
0
  CurrentSource = L;
7897
0
  return EQ<PT_Uint16>(S, OpPC);
7898
0
}
7899
0
bool EvalEmitter::emitEQSint32(const SourceInfo &L) {
7900
0
  if (!isActive()) return true;
7901
0
  CurrentSource = L;
7902
0
  return EQ<PT_Sint32>(S, OpPC);
7903
0
}
7904
0
bool EvalEmitter::emitEQUint32(const SourceInfo &L) {
7905
0
  if (!isActive()) return true;
7906
0
  CurrentSource = L;
7907
0
  return EQ<PT_Uint32>(S, OpPC);
7908
0
}
7909
0
bool EvalEmitter::emitEQSint64(const SourceInfo &L) {
7910
0
  if (!isActive()) return true;
7911
0
  CurrentSource = L;
7912
0
  return EQ<PT_Sint64>(S, OpPC);
7913
0
}
7914
0
bool EvalEmitter::emitEQUint64(const SourceInfo &L) {
7915
0
  if (!isActive()) return true;
7916
0
  CurrentSource = L;
7917
0
  return EQ<PT_Uint64>(S, OpPC);
7918
0
}
7919
0
bool EvalEmitter::emitEQIntAP(const SourceInfo &L) {
7920
0
  if (!isActive()) return true;
7921
0
  CurrentSource = L;
7922
0
  return EQ<PT_IntAP>(S, OpPC);
7923
0
}
7924
0
bool EvalEmitter::emitEQIntAPS(const SourceInfo &L) {
7925
0
  if (!isActive()) return true;
7926
0
  CurrentSource = L;
7927
0
  return EQ<PT_IntAPS>(S, OpPC);
7928
0
}
7929
0
bool EvalEmitter::emitEQBool(const SourceInfo &L) {
7930
0
  if (!isActive()) return true;
7931
0
  CurrentSource = L;
7932
0
  return EQ<PT_Bool>(S, OpPC);
7933
0
}
7934
0
bool EvalEmitter::emitEQPtr(const SourceInfo &L) {
7935
0
  if (!isActive()) return true;
7936
0
  CurrentSource = L;
7937
0
  return EQ<PT_Ptr>(S, OpPC);
7938
0
}
7939
0
bool EvalEmitter::emitEQFnPtr(const SourceInfo &L) {
7940
0
  if (!isActive()) return true;
7941
0
  CurrentSource = L;
7942
0
  return EQ<PT_FnPtr>(S, OpPC);
7943
0
}
7944
0
bool EvalEmitter::emitEQFloat(const SourceInfo &L) {
7945
0
  if (!isActive()) return true;
7946
0
  CurrentSource = L;
7947
0
  return EQ<PT_Float>(S, OpPC);
7948
0
}
7949
#endif
7950
#ifdef GET_OPCODE_NAMES
7951
OP_ExpandPtr,
7952
#endif
7953
0
#ifdef GET_INTERP
7954
0
case OP_ExpandPtr: {
7955
0
  if (!ExpandPtr(S, OpPC))
7956
0
    return false;
7957
0
  continue;
7958
0
}
7959
0
#endif
7960
#ifdef GET_DISASM
7961
case OP_ExpandPtr:
7962
  PrintName("ExpandPtr");
7963
  OS << "\t" << "\n";
7964
  continue;
7965
#endif
7966
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7967
bool emitExpandPtr(const SourceInfo &);
7968
#endif
7969
#ifdef GET_LINK_IMPL
7970
0
bool ByteCodeEmitter::emitExpandPtr(const SourceInfo &L) {
7971
0
  return emitOp<>(OP_ExpandPtr, L);
7972
0
}
7973
#endif
7974
#ifdef GET_EVAL_IMPL
7975
0
bool EvalEmitter::emitExpandPtr(const SourceInfo &L) {
7976
0
  if (!isActive()) return true;
7977
0
  CurrentSource = L;
7978
0
  return ExpandPtr(S, OpPC);
7979
0
}
7980
#endif
7981
#ifdef GET_OPCODE_NAMES
7982
OP_GESint8,
7983
OP_GEUint8,
7984
OP_GESint16,
7985
OP_GEUint16,
7986
OP_GESint32,
7987
OP_GEUint32,
7988
OP_GESint64,
7989
OP_GEUint64,
7990
OP_GEIntAP,
7991
OP_GEIntAPS,
7992
OP_GEBool,
7993
OP_GEPtr,
7994
OP_GEFloat,
7995
OP_GEFnPtr,
7996
#endif
7997
0
#ifdef GET_INTERP
7998
0
case OP_GESint8: {
7999
0
  if (!GE<PT_Sint8>(S, OpPC))
8000
0
    return false;
8001
0
  continue;
8002
0
}
8003
0
case OP_GEUint8: {
8004
0
  if (!GE<PT_Uint8>(S, OpPC))
8005
0
    return false;
8006
0
  continue;
8007
0
}
8008
0
case OP_GESint16: {
8009
0
  if (!GE<PT_Sint16>(S, OpPC))
8010
0
    return false;
8011
0
  continue;
8012
0
}
8013
0
case OP_GEUint16: {
8014
0
  if (!GE<PT_Uint16>(S, OpPC))
8015
0
    return false;
8016
0
  continue;
8017
0
}
8018
0
case OP_GESint32: {
8019
0
  if (!GE<PT_Sint32>(S, OpPC))
8020
0
    return false;
8021
0
  continue;
8022
0
}
8023
0
case OP_GEUint32: {
8024
0
  if (!GE<PT_Uint32>(S, OpPC))
8025
0
    return false;
8026
0
  continue;
8027
0
}
8028
0
case OP_GESint64: {
8029
0
  if (!GE<PT_Sint64>(S, OpPC))
8030
0
    return false;
8031
0
  continue;
8032
0
}
8033
0
case OP_GEUint64: {
8034
0
  if (!GE<PT_Uint64>(S, OpPC))
8035
0
    return false;
8036
0
  continue;
8037
0
}
8038
0
case OP_GEIntAP: {
8039
0
  if (!GE<PT_IntAP>(S, OpPC))
8040
0
    return false;
8041
0
  continue;
8042
0
}
8043
0
case OP_GEIntAPS: {
8044
0
  if (!GE<PT_IntAPS>(S, OpPC))
8045
0
    return false;
8046
0
  continue;
8047
0
}
8048
0
case OP_GEBool: {
8049
0
  if (!GE<PT_Bool>(S, OpPC))
8050
0
    return false;
8051
0
  continue;
8052
0
}
8053
0
case OP_GEPtr: {
8054
0
  if (!GE<PT_Ptr>(S, OpPC))
8055
0
    return false;
8056
0
  continue;
8057
0
}
8058
0
case OP_GEFloat: {
8059
0
  if (!GE<PT_Float>(S, OpPC))
8060
0
    return false;
8061
0
  continue;
8062
0
}
8063
0
case OP_GEFnPtr: {
8064
0
  if (!GE<PT_FnPtr>(S, OpPC))
8065
0
    return false;
8066
0
  continue;
8067
0
}
8068
0
#endif
8069
#ifdef GET_DISASM
8070
case OP_GESint8:
8071
  PrintName("GESint8");
8072
  OS << "\t" << "\n";
8073
  continue;
8074
case OP_GEUint8:
8075
  PrintName("GEUint8");
8076
  OS << "\t" << "\n";
8077
  continue;
8078
case OP_GESint16:
8079
  PrintName("GESint16");
8080
  OS << "\t" << "\n";
8081
  continue;
8082
case OP_GEUint16:
8083
  PrintName("GEUint16");
8084
  OS << "\t" << "\n";
8085
  continue;
8086
case OP_GESint32:
8087
  PrintName("GESint32");
8088
  OS << "\t" << "\n";
8089
  continue;
8090
case OP_GEUint32:
8091
  PrintName("GEUint32");
8092
  OS << "\t" << "\n";
8093
  continue;
8094
case OP_GESint64:
8095
  PrintName("GESint64");
8096
  OS << "\t" << "\n";
8097
  continue;
8098
case OP_GEUint64:
8099
  PrintName("GEUint64");
8100
  OS << "\t" << "\n";
8101
  continue;
8102
case OP_GEIntAP:
8103
  PrintName("GEIntAP");
8104
  OS << "\t" << "\n";
8105
  continue;
8106
case OP_GEIntAPS:
8107
  PrintName("GEIntAPS");
8108
  OS << "\t" << "\n";
8109
  continue;
8110
case OP_GEBool:
8111
  PrintName("GEBool");
8112
  OS << "\t" << "\n";
8113
  continue;
8114
case OP_GEPtr:
8115
  PrintName("GEPtr");
8116
  OS << "\t" << "\n";
8117
  continue;
8118
case OP_GEFloat:
8119
  PrintName("GEFloat");
8120
  OS << "\t" << "\n";
8121
  continue;
8122
case OP_GEFnPtr:
8123
  PrintName("GEFnPtr");
8124
  OS << "\t" << "\n";
8125
  continue;
8126
#endif
8127
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8128
bool emitGESint8(const SourceInfo &);
8129
bool emitGEUint8(const SourceInfo &);
8130
bool emitGESint16(const SourceInfo &);
8131
bool emitGEUint16(const SourceInfo &);
8132
bool emitGESint32(const SourceInfo &);
8133
bool emitGEUint32(const SourceInfo &);
8134
bool emitGESint64(const SourceInfo &);
8135
bool emitGEUint64(const SourceInfo &);
8136
bool emitGEIntAP(const SourceInfo &);
8137
bool emitGEIntAPS(const SourceInfo &);
8138
bool emitGEBool(const SourceInfo &);
8139
bool emitGEPtr(const SourceInfo &);
8140
bool emitGEFloat(const SourceInfo &);
8141
bool emitGEFnPtr(const SourceInfo &);
8142
#endif
8143
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8144
bool emitGE(PrimType, const SourceInfo &I);
8145
#endif
8146
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
8147
bool
8148
#if defined(GET_EVAL_IMPL)
8149
EvalEmitter
8150
#else
8151
ByteCodeEmitter
8152
#endif
8153
0
::emitGE(PrimType T0, const SourceInfo &I) {
8154
0
  switch (T0) {
8155
0
  case PT_Sint8:
8156
0
    return emitGESint8(I);
8157
0
  case PT_Uint8:
8158
0
    return emitGEUint8(I);
8159
0
  case PT_Sint16:
8160
0
    return emitGESint16(I);
8161
0
  case PT_Uint16:
8162
0
    return emitGEUint16(I);
8163
0
  case PT_Sint32:
8164
0
    return emitGESint32(I);
8165
0
  case PT_Uint32:
8166
0
    return emitGEUint32(I);
8167
0
  case PT_Sint64:
8168
0
    return emitGESint64(I);
8169
0
  case PT_Uint64:
8170
0
    return emitGEUint64(I);
8171
0
  case PT_IntAP:
8172
0
    return emitGEIntAP(I);
8173
0
  case PT_IntAPS:
8174
0
    return emitGEIntAPS(I);
8175
0
  case PT_Bool:
8176
0
    return emitGEBool(I);
8177
0
  case PT_Ptr:
8178
0
    return emitGEPtr(I);
8179
0
  case PT_Float:
8180
0
    return emitGEFloat(I);
8181
0
  case PT_FnPtr:
8182
0
    return emitGEFnPtr(I);
8183
0
  }
8184
0
  llvm_unreachable("invalid enum value");
8185
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGE(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGE(clang::interp::PrimType, clang::interp::SourceInfo const&)
8186
#endif
8187
#ifdef GET_LINK_IMPL
8188
0
bool ByteCodeEmitter::emitGESint8(const SourceInfo &L) {
8189
0
  return emitOp<>(OP_GESint8, L);
8190
0
}
8191
0
bool ByteCodeEmitter::emitGEUint8(const SourceInfo &L) {
8192
0
  return emitOp<>(OP_GEUint8, L);
8193
0
}
8194
0
bool ByteCodeEmitter::emitGESint16(const SourceInfo &L) {
8195
0
  return emitOp<>(OP_GESint16, L);
8196
0
}
8197
0
bool ByteCodeEmitter::emitGEUint16(const SourceInfo &L) {
8198
0
  return emitOp<>(OP_GEUint16, L);
8199
0
}
8200
0
bool ByteCodeEmitter::emitGESint32(const SourceInfo &L) {
8201
0
  return emitOp<>(OP_GESint32, L);
8202
0
}
8203
0
bool ByteCodeEmitter::emitGEUint32(const SourceInfo &L) {
8204
0
  return emitOp<>(OP_GEUint32, L);
8205
0
}
8206
0
bool ByteCodeEmitter::emitGESint64(const SourceInfo &L) {
8207
0
  return emitOp<>(OP_GESint64, L);
8208
0
}
8209
0
bool ByteCodeEmitter::emitGEUint64(const SourceInfo &L) {
8210
0
  return emitOp<>(OP_GEUint64, L);
8211
0
}
8212
0
bool ByteCodeEmitter::emitGEIntAP(const SourceInfo &L) {
8213
0
  return emitOp<>(OP_GEIntAP, L);
8214
0
}
8215
0
bool ByteCodeEmitter::emitGEIntAPS(const SourceInfo &L) {
8216
0
  return emitOp<>(OP_GEIntAPS, L);
8217
0
}
8218
0
bool ByteCodeEmitter::emitGEBool(const SourceInfo &L) {
8219
0
  return emitOp<>(OP_GEBool, L);
8220
0
}
8221
0
bool ByteCodeEmitter::emitGEPtr(const SourceInfo &L) {
8222
0
  return emitOp<>(OP_GEPtr, L);
8223
0
}
8224
0
bool ByteCodeEmitter::emitGEFloat(const SourceInfo &L) {
8225
0
  return emitOp<>(OP_GEFloat, L);
8226
0
}
8227
0
bool ByteCodeEmitter::emitGEFnPtr(const SourceInfo &L) {
8228
0
  return emitOp<>(OP_GEFnPtr, L);
8229
0
}
8230
#endif
8231
#ifdef GET_EVAL_IMPL
8232
0
bool EvalEmitter::emitGESint8(const SourceInfo &L) {
8233
0
  if (!isActive()) return true;
8234
0
  CurrentSource = L;
8235
0
  return GE<PT_Sint8>(S, OpPC);
8236
0
}
8237
0
bool EvalEmitter::emitGEUint8(const SourceInfo &L) {
8238
0
  if (!isActive()) return true;
8239
0
  CurrentSource = L;
8240
0
  return GE<PT_Uint8>(S, OpPC);
8241
0
}
8242
0
bool EvalEmitter::emitGESint16(const SourceInfo &L) {
8243
0
  if (!isActive()) return true;
8244
0
  CurrentSource = L;
8245
0
  return GE<PT_Sint16>(S, OpPC);
8246
0
}
8247
0
bool EvalEmitter::emitGEUint16(const SourceInfo &L) {
8248
0
  if (!isActive()) return true;
8249
0
  CurrentSource = L;
8250
0
  return GE<PT_Uint16>(S, OpPC);
8251
0
}
8252
0
bool EvalEmitter::emitGESint32(const SourceInfo &L) {
8253
0
  if (!isActive()) return true;
8254
0
  CurrentSource = L;
8255
0
  return GE<PT_Sint32>(S, OpPC);
8256
0
}
8257
0
bool EvalEmitter::emitGEUint32(const SourceInfo &L) {
8258
0
  if (!isActive()) return true;
8259
0
  CurrentSource = L;
8260
0
  return GE<PT_Uint32>(S, OpPC);
8261
0
}
8262
0
bool EvalEmitter::emitGESint64(const SourceInfo &L) {
8263
0
  if (!isActive()) return true;
8264
0
  CurrentSource = L;
8265
0
  return GE<PT_Sint64>(S, OpPC);
8266
0
}
8267
0
bool EvalEmitter::emitGEUint64(const SourceInfo &L) {
8268
0
  if (!isActive()) return true;
8269
0
  CurrentSource = L;
8270
0
  return GE<PT_Uint64>(S, OpPC);
8271
0
}
8272
0
bool EvalEmitter::emitGEIntAP(const SourceInfo &L) {
8273
0
  if (!isActive()) return true;
8274
0
  CurrentSource = L;
8275
0
  return GE<PT_IntAP>(S, OpPC);
8276
0
}
8277
0
bool EvalEmitter::emitGEIntAPS(const SourceInfo &L) {
8278
0
  if (!isActive()) return true;
8279
0
  CurrentSource = L;
8280
0
  return GE<PT_IntAPS>(S, OpPC);
8281
0
}
8282
0
bool EvalEmitter::emitGEBool(const SourceInfo &L) {
8283
0
  if (!isActive()) return true;
8284
0
  CurrentSource = L;
8285
0
  return GE<PT_Bool>(S, OpPC);
8286
0
}
8287
0
bool EvalEmitter::emitGEPtr(const SourceInfo &L) {
8288
0
  if (!isActive()) return true;
8289
0
  CurrentSource = L;
8290
0
  return GE<PT_Ptr>(S, OpPC);
8291
0
}
8292
0
bool EvalEmitter::emitGEFloat(const SourceInfo &L) {
8293
0
  if (!isActive()) return true;
8294
0
  CurrentSource = L;
8295
0
  return GE<PT_Float>(S, OpPC);
8296
0
}
8297
0
bool EvalEmitter::emitGEFnPtr(const SourceInfo &L) {
8298
0
  if (!isActive()) return true;
8299
0
  CurrentSource = L;
8300
0
  return GE<PT_FnPtr>(S, OpPC);
8301
0
}
8302
#endif
8303
#ifdef GET_OPCODE_NAMES
8304
OP_GTSint8,
8305
OP_GTUint8,
8306
OP_GTSint16,
8307
OP_GTUint16,
8308
OP_GTSint32,
8309
OP_GTUint32,
8310
OP_GTSint64,
8311
OP_GTUint64,
8312
OP_GTIntAP,
8313
OP_GTIntAPS,
8314
OP_GTBool,
8315
OP_GTPtr,
8316
OP_GTFloat,
8317
OP_GTFnPtr,
8318
#endif
8319
0
#ifdef GET_INTERP
8320
0
case OP_GTSint8: {
8321
0
  if (!GT<PT_Sint8>(S, OpPC))
8322
0
    return false;
8323
0
  continue;
8324
0
}
8325
0
case OP_GTUint8: {
8326
0
  if (!GT<PT_Uint8>(S, OpPC))
8327
0
    return false;
8328
0
  continue;
8329
0
}
8330
0
case OP_GTSint16: {
8331
0
  if (!GT<PT_Sint16>(S, OpPC))
8332
0
    return false;
8333
0
  continue;
8334
0
}
8335
0
case OP_GTUint16: {
8336
0
  if (!GT<PT_Uint16>(S, OpPC))
8337
0
    return false;
8338
0
  continue;
8339
0
}
8340
0
case OP_GTSint32: {
8341
0
  if (!GT<PT_Sint32>(S, OpPC))
8342
0
    return false;
8343
0
  continue;
8344
0
}
8345
0
case OP_GTUint32: {
8346
0
  if (!GT<PT_Uint32>(S, OpPC))
8347
0
    return false;
8348
0
  continue;
8349
0
}
8350
0
case OP_GTSint64: {
8351
0
  if (!GT<PT_Sint64>(S, OpPC))
8352
0
    return false;
8353
0
  continue;
8354
0
}
8355
0
case OP_GTUint64: {
8356
0
  if (!GT<PT_Uint64>(S, OpPC))
8357
0
    return false;
8358
0
  continue;
8359
0
}
8360
0
case OP_GTIntAP: {
8361
0
  if (!GT<PT_IntAP>(S, OpPC))
8362
0
    return false;
8363
0
  continue;
8364
0
}
8365
0
case OP_GTIntAPS: {
8366
0
  if (!GT<PT_IntAPS>(S, OpPC))
8367
0
    return false;
8368
0
  continue;
8369
0
}
8370
0
case OP_GTBool: {
8371
0
  if (!GT<PT_Bool>(S, OpPC))
8372
0
    return false;
8373
0
  continue;
8374
0
}
8375
0
case OP_GTPtr: {
8376
0
  if (!GT<PT_Ptr>(S, OpPC))
8377
0
    return false;
8378
0
  continue;
8379
0
}
8380
0
case OP_GTFloat: {
8381
0
  if (!GT<PT_Float>(S, OpPC))
8382
0
    return false;
8383
0
  continue;
8384
0
}
8385
0
case OP_GTFnPtr: {
8386
0
  if (!GT<PT_FnPtr>(S, OpPC))
8387
0
    return false;
8388
0
  continue;
8389
0
}
8390
0
#endif
8391
#ifdef GET_DISASM
8392
case OP_GTSint8:
8393
  PrintName("GTSint8");
8394
  OS << "\t" << "\n";
8395
  continue;
8396
case OP_GTUint8:
8397
  PrintName("GTUint8");
8398
  OS << "\t" << "\n";
8399
  continue;
8400
case OP_GTSint16:
8401
  PrintName("GTSint16");
8402
  OS << "\t" << "\n";
8403
  continue;
8404
case OP_GTUint16:
8405
  PrintName("GTUint16");
8406
  OS << "\t" << "\n";
8407
  continue;
8408
case OP_GTSint32:
8409
  PrintName("GTSint32");
8410
  OS << "\t" << "\n";
8411
  continue;
8412
case OP_GTUint32:
8413
  PrintName("GTUint32");
8414
  OS << "\t" << "\n";
8415
  continue;
8416
case OP_GTSint64:
8417
  PrintName("GTSint64");
8418
  OS << "\t" << "\n";
8419
  continue;
8420
case OP_GTUint64:
8421
  PrintName("GTUint64");
8422
  OS << "\t" << "\n";
8423
  continue;
8424
case OP_GTIntAP:
8425
  PrintName("GTIntAP");
8426
  OS << "\t" << "\n";
8427
  continue;
8428
case OP_GTIntAPS:
8429
  PrintName("GTIntAPS");
8430
  OS << "\t" << "\n";
8431
  continue;
8432
case OP_GTBool:
8433
  PrintName("GTBool");
8434
  OS << "\t" << "\n";
8435
  continue;
8436
case OP_GTPtr:
8437
  PrintName("GTPtr");
8438
  OS << "\t" << "\n";
8439
  continue;
8440
case OP_GTFloat:
8441
  PrintName("GTFloat");
8442
  OS << "\t" << "\n";
8443
  continue;
8444
case OP_GTFnPtr:
8445
  PrintName("GTFnPtr");
8446
  OS << "\t" << "\n";
8447
  continue;
8448
#endif
8449
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8450
bool emitGTSint8(const SourceInfo &);
8451
bool emitGTUint8(const SourceInfo &);
8452
bool emitGTSint16(const SourceInfo &);
8453
bool emitGTUint16(const SourceInfo &);
8454
bool emitGTSint32(const SourceInfo &);
8455
bool emitGTUint32(const SourceInfo &);
8456
bool emitGTSint64(const SourceInfo &);
8457
bool emitGTUint64(const SourceInfo &);
8458
bool emitGTIntAP(const SourceInfo &);
8459
bool emitGTIntAPS(const SourceInfo &);
8460
bool emitGTBool(const SourceInfo &);
8461
bool emitGTPtr(const SourceInfo &);
8462
bool emitGTFloat(const SourceInfo &);
8463
bool emitGTFnPtr(const SourceInfo &);
8464
#endif
8465
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8466
bool emitGT(PrimType, const SourceInfo &I);
8467
#endif
8468
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
8469
bool
8470
#if defined(GET_EVAL_IMPL)
8471
EvalEmitter
8472
#else
8473
ByteCodeEmitter
8474
#endif
8475
0
::emitGT(PrimType T0, const SourceInfo &I) {
8476
0
  switch (T0) {
8477
0
  case PT_Sint8:
8478
0
    return emitGTSint8(I);
8479
0
  case PT_Uint8:
8480
0
    return emitGTUint8(I);
8481
0
  case PT_Sint16:
8482
0
    return emitGTSint16(I);
8483
0
  case PT_Uint16:
8484
0
    return emitGTUint16(I);
8485
0
  case PT_Sint32:
8486
0
    return emitGTSint32(I);
8487
0
  case PT_Uint32:
8488
0
    return emitGTUint32(I);
8489
0
  case PT_Sint64:
8490
0
    return emitGTSint64(I);
8491
0
  case PT_Uint64:
8492
0
    return emitGTUint64(I);
8493
0
  case PT_IntAP:
8494
0
    return emitGTIntAP(I);
8495
0
  case PT_IntAPS:
8496
0
    return emitGTIntAPS(I);
8497
0
  case PT_Bool:
8498
0
    return emitGTBool(I);
8499
0
  case PT_Ptr:
8500
0
    return emitGTPtr(I);
8501
0
  case PT_Float:
8502
0
    return emitGTFloat(I);
8503
0
  case PT_FnPtr:
8504
0
    return emitGTFnPtr(I);
8505
0
  }
8506
0
  llvm_unreachable("invalid enum value");
8507
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGT(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGT(clang::interp::PrimType, clang::interp::SourceInfo const&)
8508
#endif
8509
#ifdef GET_LINK_IMPL
8510
0
bool ByteCodeEmitter::emitGTSint8(const SourceInfo &L) {
8511
0
  return emitOp<>(OP_GTSint8, L);
8512
0
}
8513
0
bool ByteCodeEmitter::emitGTUint8(const SourceInfo &L) {
8514
0
  return emitOp<>(OP_GTUint8, L);
8515
0
}
8516
0
bool ByteCodeEmitter::emitGTSint16(const SourceInfo &L) {
8517
0
  return emitOp<>(OP_GTSint16, L);
8518
0
}
8519
0
bool ByteCodeEmitter::emitGTUint16(const SourceInfo &L) {
8520
0
  return emitOp<>(OP_GTUint16, L);
8521
0
}
8522
0
bool ByteCodeEmitter::emitGTSint32(const SourceInfo &L) {
8523
0
  return emitOp<>(OP_GTSint32, L);
8524
0
}
8525
0
bool ByteCodeEmitter::emitGTUint32(const SourceInfo &L) {
8526
0
  return emitOp<>(OP_GTUint32, L);
8527
0
}
8528
0
bool ByteCodeEmitter::emitGTSint64(const SourceInfo &L) {
8529
0
  return emitOp<>(OP_GTSint64, L);
8530
0
}
8531
0
bool ByteCodeEmitter::emitGTUint64(const SourceInfo &L) {
8532
0
  return emitOp<>(OP_GTUint64, L);
8533
0
}
8534
0
bool ByteCodeEmitter::emitGTIntAP(const SourceInfo &L) {
8535
0
  return emitOp<>(OP_GTIntAP, L);
8536
0
}
8537
0
bool ByteCodeEmitter::emitGTIntAPS(const SourceInfo &L) {
8538
0
  return emitOp<>(OP_GTIntAPS, L);
8539
0
}
8540
0
bool ByteCodeEmitter::emitGTBool(const SourceInfo &L) {
8541
0
  return emitOp<>(OP_GTBool, L);
8542
0
}
8543
0
bool ByteCodeEmitter::emitGTPtr(const SourceInfo &L) {
8544
0
  return emitOp<>(OP_GTPtr, L);
8545
0
}
8546
0
bool ByteCodeEmitter::emitGTFloat(const SourceInfo &L) {
8547
0
  return emitOp<>(OP_GTFloat, L);
8548
0
}
8549
0
bool ByteCodeEmitter::emitGTFnPtr(const SourceInfo &L) {
8550
0
  return emitOp<>(OP_GTFnPtr, L);
8551
0
}
8552
#endif
8553
#ifdef GET_EVAL_IMPL
8554
0
bool EvalEmitter::emitGTSint8(const SourceInfo &L) {
8555
0
  if (!isActive()) return true;
8556
0
  CurrentSource = L;
8557
0
  return GT<PT_Sint8>(S, OpPC);
8558
0
}
8559
0
bool EvalEmitter::emitGTUint8(const SourceInfo &L) {
8560
0
  if (!isActive()) return true;
8561
0
  CurrentSource = L;
8562
0
  return GT<PT_Uint8>(S, OpPC);
8563
0
}
8564
0
bool EvalEmitter::emitGTSint16(const SourceInfo &L) {
8565
0
  if (!isActive()) return true;
8566
0
  CurrentSource = L;
8567
0
  return GT<PT_Sint16>(S, OpPC);
8568
0
}
8569
0
bool EvalEmitter::emitGTUint16(const SourceInfo &L) {
8570
0
  if (!isActive()) return true;
8571
0
  CurrentSource = L;
8572
0
  return GT<PT_Uint16>(S, OpPC);
8573
0
}
8574
0
bool EvalEmitter::emitGTSint32(const SourceInfo &L) {
8575
0
  if (!isActive()) return true;
8576
0
  CurrentSource = L;
8577
0
  return GT<PT_Sint32>(S, OpPC);
8578
0
}
8579
0
bool EvalEmitter::emitGTUint32(const SourceInfo &L) {
8580
0
  if (!isActive()) return true;
8581
0
  CurrentSource = L;
8582
0
  return GT<PT_Uint32>(S, OpPC);
8583
0
}
8584
0
bool EvalEmitter::emitGTSint64(const SourceInfo &L) {
8585
0
  if (!isActive()) return true;
8586
0
  CurrentSource = L;
8587
0
  return GT<PT_Sint64>(S, OpPC);
8588
0
}
8589
0
bool EvalEmitter::emitGTUint64(const SourceInfo &L) {
8590
0
  if (!isActive()) return true;
8591
0
  CurrentSource = L;
8592
0
  return GT<PT_Uint64>(S, OpPC);
8593
0
}
8594
0
bool EvalEmitter::emitGTIntAP(const SourceInfo &L) {
8595
0
  if (!isActive()) return true;
8596
0
  CurrentSource = L;
8597
0
  return GT<PT_IntAP>(S, OpPC);
8598
0
}
8599
0
bool EvalEmitter::emitGTIntAPS(const SourceInfo &L) {
8600
0
  if (!isActive()) return true;
8601
0
  CurrentSource = L;
8602
0
  return GT<PT_IntAPS>(S, OpPC);
8603
0
}
8604
0
bool EvalEmitter::emitGTBool(const SourceInfo &L) {
8605
0
  if (!isActive()) return true;
8606
0
  CurrentSource = L;
8607
0
  return GT<PT_Bool>(S, OpPC);
8608
0
}
8609
0
bool EvalEmitter::emitGTPtr(const SourceInfo &L) {
8610
0
  if (!isActive()) return true;
8611
0
  CurrentSource = L;
8612
0
  return GT<PT_Ptr>(S, OpPC);
8613
0
}
8614
0
bool EvalEmitter::emitGTFloat(const SourceInfo &L) {
8615
0
  if (!isActive()) return true;
8616
0
  CurrentSource = L;
8617
0
  return GT<PT_Float>(S, OpPC);
8618
0
}
8619
0
bool EvalEmitter::emitGTFnPtr(const SourceInfo &L) {
8620
0
  if (!isActive()) return true;
8621
0
  CurrentSource = L;
8622
0
  return GT<PT_FnPtr>(S, OpPC);
8623
0
}
8624
#endif
8625
#ifdef GET_OPCODE_NAMES
8626
OP_GetFieldSint8,
8627
OP_GetFieldUint8,
8628
OP_GetFieldSint16,
8629
OP_GetFieldUint16,
8630
OP_GetFieldSint32,
8631
OP_GetFieldUint32,
8632
OP_GetFieldSint64,
8633
OP_GetFieldUint64,
8634
OP_GetFieldIntAP,
8635
OP_GetFieldIntAPS,
8636
OP_GetFieldBool,
8637
OP_GetFieldPtr,
8638
OP_GetFieldFnPtr,
8639
OP_GetFieldFloat,
8640
#endif
8641
0
#ifdef GET_INTERP
8642
0
case OP_GetFieldSint8: {
8643
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8644
0
  if (!GetField<PT_Sint8>(S, OpPC, V0))
8645
0
    return false;
8646
0
  continue;
8647
0
}
8648
0
case OP_GetFieldUint8: {
8649
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8650
0
  if (!GetField<PT_Uint8>(S, OpPC, V0))
8651
0
    return false;
8652
0
  continue;
8653
0
}
8654
0
case OP_GetFieldSint16: {
8655
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8656
0
  if (!GetField<PT_Sint16>(S, OpPC, V0))
8657
0
    return false;
8658
0
  continue;
8659
0
}
8660
0
case OP_GetFieldUint16: {
8661
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8662
0
  if (!GetField<PT_Uint16>(S, OpPC, V0))
8663
0
    return false;
8664
0
  continue;
8665
0
}
8666
0
case OP_GetFieldSint32: {
8667
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8668
0
  if (!GetField<PT_Sint32>(S, OpPC, V0))
8669
0
    return false;
8670
0
  continue;
8671
0
}
8672
0
case OP_GetFieldUint32: {
8673
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8674
0
  if (!GetField<PT_Uint32>(S, OpPC, V0))
8675
0
    return false;
8676
0
  continue;
8677
0
}
8678
0
case OP_GetFieldSint64: {
8679
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8680
0
  if (!GetField<PT_Sint64>(S, OpPC, V0))
8681
0
    return false;
8682
0
  continue;
8683
0
}
8684
0
case OP_GetFieldUint64: {
8685
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8686
0
  if (!GetField<PT_Uint64>(S, OpPC, V0))
8687
0
    return false;
8688
0
  continue;
8689
0
}
8690
0
case OP_GetFieldIntAP: {
8691
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8692
0
  if (!GetField<PT_IntAP>(S, OpPC, V0))
8693
0
    return false;
8694
0
  continue;
8695
0
}
8696
0
case OP_GetFieldIntAPS: {
8697
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8698
0
  if (!GetField<PT_IntAPS>(S, OpPC, V0))
8699
0
    return false;
8700
0
  continue;
8701
0
}
8702
0
case OP_GetFieldBool: {
8703
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8704
0
  if (!GetField<PT_Bool>(S, OpPC, V0))
8705
0
    return false;
8706
0
  continue;
8707
0
}
8708
0
case OP_GetFieldPtr: {
8709
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8710
0
  if (!GetField<PT_Ptr>(S, OpPC, V0))
8711
0
    return false;
8712
0
  continue;
8713
0
}
8714
0
case OP_GetFieldFnPtr: {
8715
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8716
0
  if (!GetField<PT_FnPtr>(S, OpPC, V0))
8717
0
    return false;
8718
0
  continue;
8719
0
}
8720
0
case OP_GetFieldFloat: {
8721
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8722
0
  if (!GetField<PT_Float>(S, OpPC, V0))
8723
0
    return false;
8724
0
  continue;
8725
0
}
8726
0
#endif
8727
#ifdef GET_DISASM
8728
case OP_GetFieldSint8:
8729
  PrintName("GetFieldSint8");
8730
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8731
  continue;
8732
case OP_GetFieldUint8:
8733
  PrintName("GetFieldUint8");
8734
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8735
  continue;
8736
case OP_GetFieldSint16:
8737
  PrintName("GetFieldSint16");
8738
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8739
  continue;
8740
case OP_GetFieldUint16:
8741
  PrintName("GetFieldUint16");
8742
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8743
  continue;
8744
case OP_GetFieldSint32:
8745
  PrintName("GetFieldSint32");
8746
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8747
  continue;
8748
case OP_GetFieldUint32:
8749
  PrintName("GetFieldUint32");
8750
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8751
  continue;
8752
case OP_GetFieldSint64:
8753
  PrintName("GetFieldSint64");
8754
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8755
  continue;
8756
case OP_GetFieldUint64:
8757
  PrintName("GetFieldUint64");
8758
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8759
  continue;
8760
case OP_GetFieldIntAP:
8761
  PrintName("GetFieldIntAP");
8762
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8763
  continue;
8764
case OP_GetFieldIntAPS:
8765
  PrintName("GetFieldIntAPS");
8766
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8767
  continue;
8768
case OP_GetFieldBool:
8769
  PrintName("GetFieldBool");
8770
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8771
  continue;
8772
case OP_GetFieldPtr:
8773
  PrintName("GetFieldPtr");
8774
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8775
  continue;
8776
case OP_GetFieldFnPtr:
8777
  PrintName("GetFieldFnPtr");
8778
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8779
  continue;
8780
case OP_GetFieldFloat:
8781
  PrintName("GetFieldFloat");
8782
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
8783
  continue;
8784
#endif
8785
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8786
bool emitGetFieldSint8(uint32_t, const SourceInfo &);
8787
bool emitGetFieldUint8(uint32_t, const SourceInfo &);
8788
bool emitGetFieldSint16(uint32_t, const SourceInfo &);
8789
bool emitGetFieldUint16(uint32_t, const SourceInfo &);
8790
bool emitGetFieldSint32(uint32_t, const SourceInfo &);
8791
bool emitGetFieldUint32(uint32_t, const SourceInfo &);
8792
bool emitGetFieldSint64(uint32_t, const SourceInfo &);
8793
bool emitGetFieldUint64(uint32_t, const SourceInfo &);
8794
bool emitGetFieldIntAP(uint32_t, const SourceInfo &);
8795
bool emitGetFieldIntAPS(uint32_t, const SourceInfo &);
8796
bool emitGetFieldBool(uint32_t, const SourceInfo &);
8797
bool emitGetFieldPtr(uint32_t, const SourceInfo &);
8798
bool emitGetFieldFnPtr(uint32_t, const SourceInfo &);
8799
bool emitGetFieldFloat(uint32_t, const SourceInfo &);
8800
#endif
8801
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8802
bool emitGetField(PrimType, uint32_t, const SourceInfo &I);
8803
#endif
8804
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
8805
bool
8806
#if defined(GET_EVAL_IMPL)
8807
EvalEmitter
8808
#else
8809
ByteCodeEmitter
8810
#endif
8811
0
::emitGetField(PrimType T0, uint32_t A0, const SourceInfo &I) {
8812
0
  switch (T0) {
8813
0
  case PT_Sint8:
8814
0
    return emitGetFieldSint8(A0, I);
8815
0
  case PT_Uint8:
8816
0
    return emitGetFieldUint8(A0, I);
8817
0
  case PT_Sint16:
8818
0
    return emitGetFieldSint16(A0, I);
8819
0
  case PT_Uint16:
8820
0
    return emitGetFieldUint16(A0, I);
8821
0
  case PT_Sint32:
8822
0
    return emitGetFieldSint32(A0, I);
8823
0
  case PT_Uint32:
8824
0
    return emitGetFieldUint32(A0, I);
8825
0
  case PT_Sint64:
8826
0
    return emitGetFieldSint64(A0, I);
8827
0
  case PT_Uint64:
8828
0
    return emitGetFieldUint64(A0, I);
8829
0
  case PT_IntAP:
8830
0
    return emitGetFieldIntAP(A0, I);
8831
0
  case PT_IntAPS:
8832
0
    return emitGetFieldIntAPS(A0, I);
8833
0
  case PT_Bool:
8834
0
    return emitGetFieldBool(A0, I);
8835
0
  case PT_Ptr:
8836
0
    return emitGetFieldPtr(A0, I);
8837
0
  case PT_FnPtr:
8838
0
    return emitGetFieldFnPtr(A0, I);
8839
0
  case PT_Float:
8840
0
    return emitGetFieldFloat(A0, I);
8841
0
  }
8842
0
  llvm_unreachable("invalid enum value");
8843
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
8844
#endif
8845
#ifdef GET_LINK_IMPL
8846
0
bool ByteCodeEmitter::emitGetFieldSint8(uint32_t A0, const SourceInfo &L) {
8847
0
  return emitOp<uint32_t>(OP_GetFieldSint8, A0, L);
8848
0
}
8849
0
bool ByteCodeEmitter::emitGetFieldUint8(uint32_t A0, const SourceInfo &L) {
8850
0
  return emitOp<uint32_t>(OP_GetFieldUint8, A0, L);
8851
0
}
8852
0
bool ByteCodeEmitter::emitGetFieldSint16(uint32_t A0, const SourceInfo &L) {
8853
0
  return emitOp<uint32_t>(OP_GetFieldSint16, A0, L);
8854
0
}
8855
0
bool ByteCodeEmitter::emitGetFieldUint16(uint32_t A0, const SourceInfo &L) {
8856
0
  return emitOp<uint32_t>(OP_GetFieldUint16, A0, L);
8857
0
}
8858
0
bool ByteCodeEmitter::emitGetFieldSint32(uint32_t A0, const SourceInfo &L) {
8859
0
  return emitOp<uint32_t>(OP_GetFieldSint32, A0, L);
8860
0
}
8861
0
bool ByteCodeEmitter::emitGetFieldUint32(uint32_t A0, const SourceInfo &L) {
8862
0
  return emitOp<uint32_t>(OP_GetFieldUint32, A0, L);
8863
0
}
8864
0
bool ByteCodeEmitter::emitGetFieldSint64(uint32_t A0, const SourceInfo &L) {
8865
0
  return emitOp<uint32_t>(OP_GetFieldSint64, A0, L);
8866
0
}
8867
0
bool ByteCodeEmitter::emitGetFieldUint64(uint32_t A0, const SourceInfo &L) {
8868
0
  return emitOp<uint32_t>(OP_GetFieldUint64, A0, L);
8869
0
}
8870
0
bool ByteCodeEmitter::emitGetFieldIntAP(uint32_t A0, const SourceInfo &L) {
8871
0
  return emitOp<uint32_t>(OP_GetFieldIntAP, A0, L);
8872
0
}
8873
0
bool ByteCodeEmitter::emitGetFieldIntAPS(uint32_t A0, const SourceInfo &L) {
8874
0
  return emitOp<uint32_t>(OP_GetFieldIntAPS, A0, L);
8875
0
}
8876
0
bool ByteCodeEmitter::emitGetFieldBool(uint32_t A0, const SourceInfo &L) {
8877
0
  return emitOp<uint32_t>(OP_GetFieldBool, A0, L);
8878
0
}
8879
0
bool ByteCodeEmitter::emitGetFieldPtr(uint32_t A0, const SourceInfo &L) {
8880
0
  return emitOp<uint32_t>(OP_GetFieldPtr, A0, L);
8881
0
}
8882
0
bool ByteCodeEmitter::emitGetFieldFnPtr(uint32_t A0, const SourceInfo &L) {
8883
0
  return emitOp<uint32_t>(OP_GetFieldFnPtr, A0, L);
8884
0
}
8885
0
bool ByteCodeEmitter::emitGetFieldFloat(uint32_t A0, const SourceInfo &L) {
8886
0
  return emitOp<uint32_t>(OP_GetFieldFloat, A0, L);
8887
0
}
8888
#endif
8889
#ifdef GET_EVAL_IMPL
8890
0
bool EvalEmitter::emitGetFieldSint8(uint32_t A0, const SourceInfo &L) {
8891
0
  if (!isActive()) return true;
8892
0
  CurrentSource = L;
8893
0
  return GetField<PT_Sint8>(S, OpPC, A0);
8894
0
}
8895
0
bool EvalEmitter::emitGetFieldUint8(uint32_t A0, const SourceInfo &L) {
8896
0
  if (!isActive()) return true;
8897
0
  CurrentSource = L;
8898
0
  return GetField<PT_Uint8>(S, OpPC, A0);
8899
0
}
8900
0
bool EvalEmitter::emitGetFieldSint16(uint32_t A0, const SourceInfo &L) {
8901
0
  if (!isActive()) return true;
8902
0
  CurrentSource = L;
8903
0
  return GetField<PT_Sint16>(S, OpPC, A0);
8904
0
}
8905
0
bool EvalEmitter::emitGetFieldUint16(uint32_t A0, const SourceInfo &L) {
8906
0
  if (!isActive()) return true;
8907
0
  CurrentSource = L;
8908
0
  return GetField<PT_Uint16>(S, OpPC, A0);
8909
0
}
8910
0
bool EvalEmitter::emitGetFieldSint32(uint32_t A0, const SourceInfo &L) {
8911
0
  if (!isActive()) return true;
8912
0
  CurrentSource = L;
8913
0
  return GetField<PT_Sint32>(S, OpPC, A0);
8914
0
}
8915
0
bool EvalEmitter::emitGetFieldUint32(uint32_t A0, const SourceInfo &L) {
8916
0
  if (!isActive()) return true;
8917
0
  CurrentSource = L;
8918
0
  return GetField<PT_Uint32>(S, OpPC, A0);
8919
0
}
8920
0
bool EvalEmitter::emitGetFieldSint64(uint32_t A0, const SourceInfo &L) {
8921
0
  if (!isActive()) return true;
8922
0
  CurrentSource = L;
8923
0
  return GetField<PT_Sint64>(S, OpPC, A0);
8924
0
}
8925
0
bool EvalEmitter::emitGetFieldUint64(uint32_t A0, const SourceInfo &L) {
8926
0
  if (!isActive()) return true;
8927
0
  CurrentSource = L;
8928
0
  return GetField<PT_Uint64>(S, OpPC, A0);
8929
0
}
8930
0
bool EvalEmitter::emitGetFieldIntAP(uint32_t A0, const SourceInfo &L) {
8931
0
  if (!isActive()) return true;
8932
0
  CurrentSource = L;
8933
0
  return GetField<PT_IntAP>(S, OpPC, A0);
8934
0
}
8935
0
bool EvalEmitter::emitGetFieldIntAPS(uint32_t A0, const SourceInfo &L) {
8936
0
  if (!isActive()) return true;
8937
0
  CurrentSource = L;
8938
0
  return GetField<PT_IntAPS>(S, OpPC, A0);
8939
0
}
8940
0
bool EvalEmitter::emitGetFieldBool(uint32_t A0, const SourceInfo &L) {
8941
0
  if (!isActive()) return true;
8942
0
  CurrentSource = L;
8943
0
  return GetField<PT_Bool>(S, OpPC, A0);
8944
0
}
8945
0
bool EvalEmitter::emitGetFieldPtr(uint32_t A0, const SourceInfo &L) {
8946
0
  if (!isActive()) return true;
8947
0
  CurrentSource = L;
8948
0
  return GetField<PT_Ptr>(S, OpPC, A0);
8949
0
}
8950
0
bool EvalEmitter::emitGetFieldFnPtr(uint32_t A0, const SourceInfo &L) {
8951
0
  if (!isActive()) return true;
8952
0
  CurrentSource = L;
8953
0
  return GetField<PT_FnPtr>(S, OpPC, A0);
8954
0
}
8955
0
bool EvalEmitter::emitGetFieldFloat(uint32_t A0, const SourceInfo &L) {
8956
0
  if (!isActive()) return true;
8957
0
  CurrentSource = L;
8958
0
  return GetField<PT_Float>(S, OpPC, A0);
8959
0
}
8960
#endif
8961
#ifdef GET_OPCODE_NAMES
8962
OP_GetFieldPopSint8,
8963
OP_GetFieldPopUint8,
8964
OP_GetFieldPopSint16,
8965
OP_GetFieldPopUint16,
8966
OP_GetFieldPopSint32,
8967
OP_GetFieldPopUint32,
8968
OP_GetFieldPopSint64,
8969
OP_GetFieldPopUint64,
8970
OP_GetFieldPopIntAP,
8971
OP_GetFieldPopIntAPS,
8972
OP_GetFieldPopBool,
8973
OP_GetFieldPopPtr,
8974
OP_GetFieldPopFnPtr,
8975
OP_GetFieldPopFloat,
8976
#endif
8977
0
#ifdef GET_INTERP
8978
0
case OP_GetFieldPopSint8: {
8979
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8980
0
  if (!GetFieldPop<PT_Sint8>(S, OpPC, V0))
8981
0
    return false;
8982
0
  continue;
8983
0
}
8984
0
case OP_GetFieldPopUint8: {
8985
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8986
0
  if (!GetFieldPop<PT_Uint8>(S, OpPC, V0))
8987
0
    return false;
8988
0
  continue;
8989
0
}
8990
0
case OP_GetFieldPopSint16: {
8991
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8992
0
  if (!GetFieldPop<PT_Sint16>(S, OpPC, V0))
8993
0
    return false;
8994
0
  continue;
8995
0
}
8996
0
case OP_GetFieldPopUint16: {
8997
0
  auto V0 = ReadArg<uint32_t>(S, PC);
8998
0
  if (!GetFieldPop<PT_Uint16>(S, OpPC, V0))
8999
0
    return false;
9000
0
  continue;
9001
0
}
9002
0
case OP_GetFieldPopSint32: {
9003
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9004
0
  if (!GetFieldPop<PT_Sint32>(S, OpPC, V0))
9005
0
    return false;
9006
0
  continue;
9007
0
}
9008
0
case OP_GetFieldPopUint32: {
9009
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9010
0
  if (!GetFieldPop<PT_Uint32>(S, OpPC, V0))
9011
0
    return false;
9012
0
  continue;
9013
0
}
9014
0
case OP_GetFieldPopSint64: {
9015
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9016
0
  if (!GetFieldPop<PT_Sint64>(S, OpPC, V0))
9017
0
    return false;
9018
0
  continue;
9019
0
}
9020
0
case OP_GetFieldPopUint64: {
9021
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9022
0
  if (!GetFieldPop<PT_Uint64>(S, OpPC, V0))
9023
0
    return false;
9024
0
  continue;
9025
0
}
9026
0
case OP_GetFieldPopIntAP: {
9027
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9028
0
  if (!GetFieldPop<PT_IntAP>(S, OpPC, V0))
9029
0
    return false;
9030
0
  continue;
9031
0
}
9032
0
case OP_GetFieldPopIntAPS: {
9033
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9034
0
  if (!GetFieldPop<PT_IntAPS>(S, OpPC, V0))
9035
0
    return false;
9036
0
  continue;
9037
0
}
9038
0
case OP_GetFieldPopBool: {
9039
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9040
0
  if (!GetFieldPop<PT_Bool>(S, OpPC, V0))
9041
0
    return false;
9042
0
  continue;
9043
0
}
9044
0
case OP_GetFieldPopPtr: {
9045
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9046
0
  if (!GetFieldPop<PT_Ptr>(S, OpPC, V0))
9047
0
    return false;
9048
0
  continue;
9049
0
}
9050
0
case OP_GetFieldPopFnPtr: {
9051
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9052
0
  if (!GetFieldPop<PT_FnPtr>(S, OpPC, V0))
9053
0
    return false;
9054
0
  continue;
9055
0
}
9056
0
case OP_GetFieldPopFloat: {
9057
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9058
0
  if (!GetFieldPop<PT_Float>(S, OpPC, V0))
9059
0
    return false;
9060
0
  continue;
9061
0
}
9062
0
#endif
9063
#ifdef GET_DISASM
9064
case OP_GetFieldPopSint8:
9065
  PrintName("GetFieldPopSint8");
9066
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9067
  continue;
9068
case OP_GetFieldPopUint8:
9069
  PrintName("GetFieldPopUint8");
9070
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9071
  continue;
9072
case OP_GetFieldPopSint16:
9073
  PrintName("GetFieldPopSint16");
9074
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9075
  continue;
9076
case OP_GetFieldPopUint16:
9077
  PrintName("GetFieldPopUint16");
9078
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9079
  continue;
9080
case OP_GetFieldPopSint32:
9081
  PrintName("GetFieldPopSint32");
9082
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9083
  continue;
9084
case OP_GetFieldPopUint32:
9085
  PrintName("GetFieldPopUint32");
9086
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9087
  continue;
9088
case OP_GetFieldPopSint64:
9089
  PrintName("GetFieldPopSint64");
9090
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9091
  continue;
9092
case OP_GetFieldPopUint64:
9093
  PrintName("GetFieldPopUint64");
9094
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9095
  continue;
9096
case OP_GetFieldPopIntAP:
9097
  PrintName("GetFieldPopIntAP");
9098
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9099
  continue;
9100
case OP_GetFieldPopIntAPS:
9101
  PrintName("GetFieldPopIntAPS");
9102
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9103
  continue;
9104
case OP_GetFieldPopBool:
9105
  PrintName("GetFieldPopBool");
9106
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9107
  continue;
9108
case OP_GetFieldPopPtr:
9109
  PrintName("GetFieldPopPtr");
9110
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9111
  continue;
9112
case OP_GetFieldPopFnPtr:
9113
  PrintName("GetFieldPopFnPtr");
9114
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9115
  continue;
9116
case OP_GetFieldPopFloat:
9117
  PrintName("GetFieldPopFloat");
9118
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9119
  continue;
9120
#endif
9121
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9122
bool emitGetFieldPopSint8(uint32_t, const SourceInfo &);
9123
bool emitGetFieldPopUint8(uint32_t, const SourceInfo &);
9124
bool emitGetFieldPopSint16(uint32_t, const SourceInfo &);
9125
bool emitGetFieldPopUint16(uint32_t, const SourceInfo &);
9126
bool emitGetFieldPopSint32(uint32_t, const SourceInfo &);
9127
bool emitGetFieldPopUint32(uint32_t, const SourceInfo &);
9128
bool emitGetFieldPopSint64(uint32_t, const SourceInfo &);
9129
bool emitGetFieldPopUint64(uint32_t, const SourceInfo &);
9130
bool emitGetFieldPopIntAP(uint32_t, const SourceInfo &);
9131
bool emitGetFieldPopIntAPS(uint32_t, const SourceInfo &);
9132
bool emitGetFieldPopBool(uint32_t, const SourceInfo &);
9133
bool emitGetFieldPopPtr(uint32_t, const SourceInfo &);
9134
bool emitGetFieldPopFnPtr(uint32_t, const SourceInfo &);
9135
bool emitGetFieldPopFloat(uint32_t, const SourceInfo &);
9136
#endif
9137
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9138
bool emitGetFieldPop(PrimType, uint32_t, const SourceInfo &I);
9139
#endif
9140
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
9141
bool
9142
#if defined(GET_EVAL_IMPL)
9143
EvalEmitter
9144
#else
9145
ByteCodeEmitter
9146
#endif
9147
0
::emitGetFieldPop(PrimType T0, uint32_t A0, const SourceInfo &I) {
9148
0
  switch (T0) {
9149
0
  case PT_Sint8:
9150
0
    return emitGetFieldPopSint8(A0, I);
9151
0
  case PT_Uint8:
9152
0
    return emitGetFieldPopUint8(A0, I);
9153
0
  case PT_Sint16:
9154
0
    return emitGetFieldPopSint16(A0, I);
9155
0
  case PT_Uint16:
9156
0
    return emitGetFieldPopUint16(A0, I);
9157
0
  case PT_Sint32:
9158
0
    return emitGetFieldPopSint32(A0, I);
9159
0
  case PT_Uint32:
9160
0
    return emitGetFieldPopUint32(A0, I);
9161
0
  case PT_Sint64:
9162
0
    return emitGetFieldPopSint64(A0, I);
9163
0
  case PT_Uint64:
9164
0
    return emitGetFieldPopUint64(A0, I);
9165
0
  case PT_IntAP:
9166
0
    return emitGetFieldPopIntAP(A0, I);
9167
0
  case PT_IntAPS:
9168
0
    return emitGetFieldPopIntAPS(A0, I);
9169
0
  case PT_Bool:
9170
0
    return emitGetFieldPopBool(A0, I);
9171
0
  case PT_Ptr:
9172
0
    return emitGetFieldPopPtr(A0, I);
9173
0
  case PT_FnPtr:
9174
0
    return emitGetFieldPopFnPtr(A0, I);
9175
0
  case PT_Float:
9176
0
    return emitGetFieldPopFloat(A0, I);
9177
0
  }
9178
0
  llvm_unreachable("invalid enum value");
9179
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetFieldPop(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetFieldPop(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
9180
#endif
9181
#ifdef GET_LINK_IMPL
9182
0
bool ByteCodeEmitter::emitGetFieldPopSint8(uint32_t A0, const SourceInfo &L) {
9183
0
  return emitOp<uint32_t>(OP_GetFieldPopSint8, A0, L);
9184
0
}
9185
0
bool ByteCodeEmitter::emitGetFieldPopUint8(uint32_t A0, const SourceInfo &L) {
9186
0
  return emitOp<uint32_t>(OP_GetFieldPopUint8, A0, L);
9187
0
}
9188
0
bool ByteCodeEmitter::emitGetFieldPopSint16(uint32_t A0, const SourceInfo &L) {
9189
0
  return emitOp<uint32_t>(OP_GetFieldPopSint16, A0, L);
9190
0
}
9191
0
bool ByteCodeEmitter::emitGetFieldPopUint16(uint32_t A0, const SourceInfo &L) {
9192
0
  return emitOp<uint32_t>(OP_GetFieldPopUint16, A0, L);
9193
0
}
9194
0
bool ByteCodeEmitter::emitGetFieldPopSint32(uint32_t A0, const SourceInfo &L) {
9195
0
  return emitOp<uint32_t>(OP_GetFieldPopSint32, A0, L);
9196
0
}
9197
0
bool ByteCodeEmitter::emitGetFieldPopUint32(uint32_t A0, const SourceInfo &L) {
9198
0
  return emitOp<uint32_t>(OP_GetFieldPopUint32, A0, L);
9199
0
}
9200
0
bool ByteCodeEmitter::emitGetFieldPopSint64(uint32_t A0, const SourceInfo &L) {
9201
0
  return emitOp<uint32_t>(OP_GetFieldPopSint64, A0, L);
9202
0
}
9203
0
bool ByteCodeEmitter::emitGetFieldPopUint64(uint32_t A0, const SourceInfo &L) {
9204
0
  return emitOp<uint32_t>(OP_GetFieldPopUint64, A0, L);
9205
0
}
9206
0
bool ByteCodeEmitter::emitGetFieldPopIntAP(uint32_t A0, const SourceInfo &L) {
9207
0
  return emitOp<uint32_t>(OP_GetFieldPopIntAP, A0, L);
9208
0
}
9209
0
bool ByteCodeEmitter::emitGetFieldPopIntAPS(uint32_t A0, const SourceInfo &L) {
9210
0
  return emitOp<uint32_t>(OP_GetFieldPopIntAPS, A0, L);
9211
0
}
9212
0
bool ByteCodeEmitter::emitGetFieldPopBool(uint32_t A0, const SourceInfo &L) {
9213
0
  return emitOp<uint32_t>(OP_GetFieldPopBool, A0, L);
9214
0
}
9215
0
bool ByteCodeEmitter::emitGetFieldPopPtr(uint32_t A0, const SourceInfo &L) {
9216
0
  return emitOp<uint32_t>(OP_GetFieldPopPtr, A0, L);
9217
0
}
9218
0
bool ByteCodeEmitter::emitGetFieldPopFnPtr(uint32_t A0, const SourceInfo &L) {
9219
0
  return emitOp<uint32_t>(OP_GetFieldPopFnPtr, A0, L);
9220
0
}
9221
0
bool ByteCodeEmitter::emitGetFieldPopFloat(uint32_t A0, const SourceInfo &L) {
9222
0
  return emitOp<uint32_t>(OP_GetFieldPopFloat, A0, L);
9223
0
}
9224
#endif
9225
#ifdef GET_EVAL_IMPL
9226
0
bool EvalEmitter::emitGetFieldPopSint8(uint32_t A0, const SourceInfo &L) {
9227
0
  if (!isActive()) return true;
9228
0
  CurrentSource = L;
9229
0
  return GetFieldPop<PT_Sint8>(S, OpPC, A0);
9230
0
}
9231
0
bool EvalEmitter::emitGetFieldPopUint8(uint32_t A0, const SourceInfo &L) {
9232
0
  if (!isActive()) return true;
9233
0
  CurrentSource = L;
9234
0
  return GetFieldPop<PT_Uint8>(S, OpPC, A0);
9235
0
}
9236
0
bool EvalEmitter::emitGetFieldPopSint16(uint32_t A0, const SourceInfo &L) {
9237
0
  if (!isActive()) return true;
9238
0
  CurrentSource = L;
9239
0
  return GetFieldPop<PT_Sint16>(S, OpPC, A0);
9240
0
}
9241
0
bool EvalEmitter::emitGetFieldPopUint16(uint32_t A0, const SourceInfo &L) {
9242
0
  if (!isActive()) return true;
9243
0
  CurrentSource = L;
9244
0
  return GetFieldPop<PT_Uint16>(S, OpPC, A0);
9245
0
}
9246
0
bool EvalEmitter::emitGetFieldPopSint32(uint32_t A0, const SourceInfo &L) {
9247
0
  if (!isActive()) return true;
9248
0
  CurrentSource = L;
9249
0
  return GetFieldPop<PT_Sint32>(S, OpPC, A0);
9250
0
}
9251
0
bool EvalEmitter::emitGetFieldPopUint32(uint32_t A0, const SourceInfo &L) {
9252
0
  if (!isActive()) return true;
9253
0
  CurrentSource = L;
9254
0
  return GetFieldPop<PT_Uint32>(S, OpPC, A0);
9255
0
}
9256
0
bool EvalEmitter::emitGetFieldPopSint64(uint32_t A0, const SourceInfo &L) {
9257
0
  if (!isActive()) return true;
9258
0
  CurrentSource = L;
9259
0
  return GetFieldPop<PT_Sint64>(S, OpPC, A0);
9260
0
}
9261
0
bool EvalEmitter::emitGetFieldPopUint64(uint32_t A0, const SourceInfo &L) {
9262
0
  if (!isActive()) return true;
9263
0
  CurrentSource = L;
9264
0
  return GetFieldPop<PT_Uint64>(S, OpPC, A0);
9265
0
}
9266
0
bool EvalEmitter::emitGetFieldPopIntAP(uint32_t A0, const SourceInfo &L) {
9267
0
  if (!isActive()) return true;
9268
0
  CurrentSource = L;
9269
0
  return GetFieldPop<PT_IntAP>(S, OpPC, A0);
9270
0
}
9271
0
bool EvalEmitter::emitGetFieldPopIntAPS(uint32_t A0, const SourceInfo &L) {
9272
0
  if (!isActive()) return true;
9273
0
  CurrentSource = L;
9274
0
  return GetFieldPop<PT_IntAPS>(S, OpPC, A0);
9275
0
}
9276
0
bool EvalEmitter::emitGetFieldPopBool(uint32_t A0, const SourceInfo &L) {
9277
0
  if (!isActive()) return true;
9278
0
  CurrentSource = L;
9279
0
  return GetFieldPop<PT_Bool>(S, OpPC, A0);
9280
0
}
9281
0
bool EvalEmitter::emitGetFieldPopPtr(uint32_t A0, const SourceInfo &L) {
9282
0
  if (!isActive()) return true;
9283
0
  CurrentSource = L;
9284
0
  return GetFieldPop<PT_Ptr>(S, OpPC, A0);
9285
0
}
9286
0
bool EvalEmitter::emitGetFieldPopFnPtr(uint32_t A0, const SourceInfo &L) {
9287
0
  if (!isActive()) return true;
9288
0
  CurrentSource = L;
9289
0
  return GetFieldPop<PT_FnPtr>(S, OpPC, A0);
9290
0
}
9291
0
bool EvalEmitter::emitGetFieldPopFloat(uint32_t A0, const SourceInfo &L) {
9292
0
  if (!isActive()) return true;
9293
0
  CurrentSource = L;
9294
0
  return GetFieldPop<PT_Float>(S, OpPC, A0);
9295
0
}
9296
#endif
9297
#ifdef GET_OPCODE_NAMES
9298
OP_GetFnPtr,
9299
#endif
9300
0
#ifdef GET_INTERP
9301
0
case OP_GetFnPtr: {
9302
0
  auto V0 = ReadArg<const Function *>(S, PC);
9303
0
  if (!GetFnPtr(S, OpPC, V0))
9304
0
    return false;
9305
0
  continue;
9306
0
}
9307
0
#endif
9308
#ifdef GET_DISASM
9309
case OP_GetFnPtr:
9310
  PrintName("GetFnPtr");
9311
  OS << "\t" << ReadArg<const Function *>(P, PC) << " " << "\n";
9312
  continue;
9313
#endif
9314
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9315
bool emitGetFnPtr(const Function *, const SourceInfo &);
9316
#endif
9317
#ifdef GET_LINK_IMPL
9318
0
bool ByteCodeEmitter::emitGetFnPtr(const Function * A0, const SourceInfo &L) {
9319
0
  return emitOp<const Function *>(OP_GetFnPtr, A0, L);
9320
0
}
9321
#endif
9322
#ifdef GET_EVAL_IMPL
9323
0
bool EvalEmitter::emitGetFnPtr(const Function * A0, const SourceInfo &L) {
9324
0
  if (!isActive()) return true;
9325
0
  CurrentSource = L;
9326
0
  return GetFnPtr(S, OpPC, A0);
9327
0
}
9328
#endif
9329
#ifdef GET_OPCODE_NAMES
9330
OP_GetGlobalSint8,
9331
OP_GetGlobalUint8,
9332
OP_GetGlobalSint16,
9333
OP_GetGlobalUint16,
9334
OP_GetGlobalSint32,
9335
OP_GetGlobalUint32,
9336
OP_GetGlobalSint64,
9337
OP_GetGlobalUint64,
9338
OP_GetGlobalIntAP,
9339
OP_GetGlobalIntAPS,
9340
OP_GetGlobalBool,
9341
OP_GetGlobalPtr,
9342
OP_GetGlobalFnPtr,
9343
OP_GetGlobalFloat,
9344
#endif
9345
0
#ifdef GET_INTERP
9346
0
case OP_GetGlobalSint8: {
9347
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9348
0
  if (!GetGlobal<PT_Sint8>(S, OpPC, V0))
9349
0
    return false;
9350
0
  continue;
9351
0
}
9352
0
case OP_GetGlobalUint8: {
9353
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9354
0
  if (!GetGlobal<PT_Uint8>(S, OpPC, V0))
9355
0
    return false;
9356
0
  continue;
9357
0
}
9358
0
case OP_GetGlobalSint16: {
9359
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9360
0
  if (!GetGlobal<PT_Sint16>(S, OpPC, V0))
9361
0
    return false;
9362
0
  continue;
9363
0
}
9364
0
case OP_GetGlobalUint16: {
9365
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9366
0
  if (!GetGlobal<PT_Uint16>(S, OpPC, V0))
9367
0
    return false;
9368
0
  continue;
9369
0
}
9370
0
case OP_GetGlobalSint32: {
9371
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9372
0
  if (!GetGlobal<PT_Sint32>(S, OpPC, V0))
9373
0
    return false;
9374
0
  continue;
9375
0
}
9376
0
case OP_GetGlobalUint32: {
9377
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9378
0
  if (!GetGlobal<PT_Uint32>(S, OpPC, V0))
9379
0
    return false;
9380
0
  continue;
9381
0
}
9382
0
case OP_GetGlobalSint64: {
9383
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9384
0
  if (!GetGlobal<PT_Sint64>(S, OpPC, V0))
9385
0
    return false;
9386
0
  continue;
9387
0
}
9388
0
case OP_GetGlobalUint64: {
9389
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9390
0
  if (!GetGlobal<PT_Uint64>(S, OpPC, V0))
9391
0
    return false;
9392
0
  continue;
9393
0
}
9394
0
case OP_GetGlobalIntAP: {
9395
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9396
0
  if (!GetGlobal<PT_IntAP>(S, OpPC, V0))
9397
0
    return false;
9398
0
  continue;
9399
0
}
9400
0
case OP_GetGlobalIntAPS: {
9401
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9402
0
  if (!GetGlobal<PT_IntAPS>(S, OpPC, V0))
9403
0
    return false;
9404
0
  continue;
9405
0
}
9406
0
case OP_GetGlobalBool: {
9407
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9408
0
  if (!GetGlobal<PT_Bool>(S, OpPC, V0))
9409
0
    return false;
9410
0
  continue;
9411
0
}
9412
0
case OP_GetGlobalPtr: {
9413
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9414
0
  if (!GetGlobal<PT_Ptr>(S, OpPC, V0))
9415
0
    return false;
9416
0
  continue;
9417
0
}
9418
0
case OP_GetGlobalFnPtr: {
9419
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9420
0
  if (!GetGlobal<PT_FnPtr>(S, OpPC, V0))
9421
0
    return false;
9422
0
  continue;
9423
0
}
9424
0
case OP_GetGlobalFloat: {
9425
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9426
0
  if (!GetGlobal<PT_Float>(S, OpPC, V0))
9427
0
    return false;
9428
0
  continue;
9429
0
}
9430
0
#endif
9431
#ifdef GET_DISASM
9432
case OP_GetGlobalSint8:
9433
  PrintName("GetGlobalSint8");
9434
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9435
  continue;
9436
case OP_GetGlobalUint8:
9437
  PrintName("GetGlobalUint8");
9438
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9439
  continue;
9440
case OP_GetGlobalSint16:
9441
  PrintName("GetGlobalSint16");
9442
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9443
  continue;
9444
case OP_GetGlobalUint16:
9445
  PrintName("GetGlobalUint16");
9446
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9447
  continue;
9448
case OP_GetGlobalSint32:
9449
  PrintName("GetGlobalSint32");
9450
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9451
  continue;
9452
case OP_GetGlobalUint32:
9453
  PrintName("GetGlobalUint32");
9454
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9455
  continue;
9456
case OP_GetGlobalSint64:
9457
  PrintName("GetGlobalSint64");
9458
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9459
  continue;
9460
case OP_GetGlobalUint64:
9461
  PrintName("GetGlobalUint64");
9462
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9463
  continue;
9464
case OP_GetGlobalIntAP:
9465
  PrintName("GetGlobalIntAP");
9466
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9467
  continue;
9468
case OP_GetGlobalIntAPS:
9469
  PrintName("GetGlobalIntAPS");
9470
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9471
  continue;
9472
case OP_GetGlobalBool:
9473
  PrintName("GetGlobalBool");
9474
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9475
  continue;
9476
case OP_GetGlobalPtr:
9477
  PrintName("GetGlobalPtr");
9478
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9479
  continue;
9480
case OP_GetGlobalFnPtr:
9481
  PrintName("GetGlobalFnPtr");
9482
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9483
  continue;
9484
case OP_GetGlobalFloat:
9485
  PrintName("GetGlobalFloat");
9486
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9487
  continue;
9488
#endif
9489
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9490
bool emitGetGlobalSint8(uint32_t, const SourceInfo &);
9491
bool emitGetGlobalUint8(uint32_t, const SourceInfo &);
9492
bool emitGetGlobalSint16(uint32_t, const SourceInfo &);
9493
bool emitGetGlobalUint16(uint32_t, const SourceInfo &);
9494
bool emitGetGlobalSint32(uint32_t, const SourceInfo &);
9495
bool emitGetGlobalUint32(uint32_t, const SourceInfo &);
9496
bool emitGetGlobalSint64(uint32_t, const SourceInfo &);
9497
bool emitGetGlobalUint64(uint32_t, const SourceInfo &);
9498
bool emitGetGlobalIntAP(uint32_t, const SourceInfo &);
9499
bool emitGetGlobalIntAPS(uint32_t, const SourceInfo &);
9500
bool emitGetGlobalBool(uint32_t, const SourceInfo &);
9501
bool emitGetGlobalPtr(uint32_t, const SourceInfo &);
9502
bool emitGetGlobalFnPtr(uint32_t, const SourceInfo &);
9503
bool emitGetGlobalFloat(uint32_t, const SourceInfo &);
9504
#endif
9505
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9506
bool emitGetGlobal(PrimType, uint32_t, const SourceInfo &I);
9507
#endif
9508
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
9509
bool
9510
#if defined(GET_EVAL_IMPL)
9511
EvalEmitter
9512
#else
9513
ByteCodeEmitter
9514
#endif
9515
0
::emitGetGlobal(PrimType T0, uint32_t A0, const SourceInfo &I) {
9516
0
  switch (T0) {
9517
0
  case PT_Sint8:
9518
0
    return emitGetGlobalSint8(A0, I);
9519
0
  case PT_Uint8:
9520
0
    return emitGetGlobalUint8(A0, I);
9521
0
  case PT_Sint16:
9522
0
    return emitGetGlobalSint16(A0, I);
9523
0
  case PT_Uint16:
9524
0
    return emitGetGlobalUint16(A0, I);
9525
0
  case PT_Sint32:
9526
0
    return emitGetGlobalSint32(A0, I);
9527
0
  case PT_Uint32:
9528
0
    return emitGetGlobalUint32(A0, I);
9529
0
  case PT_Sint64:
9530
0
    return emitGetGlobalSint64(A0, I);
9531
0
  case PT_Uint64:
9532
0
    return emitGetGlobalUint64(A0, I);
9533
0
  case PT_IntAP:
9534
0
    return emitGetGlobalIntAP(A0, I);
9535
0
  case PT_IntAPS:
9536
0
    return emitGetGlobalIntAPS(A0, I);
9537
0
  case PT_Bool:
9538
0
    return emitGetGlobalBool(A0, I);
9539
0
  case PT_Ptr:
9540
0
    return emitGetGlobalPtr(A0, I);
9541
0
  case PT_FnPtr:
9542
0
    return emitGetGlobalFnPtr(A0, I);
9543
0
  case PT_Float:
9544
0
    return emitGetGlobalFloat(A0, I);
9545
0
  }
9546
0
  llvm_unreachable("invalid enum value");
9547
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetGlobal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetGlobal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
9548
#endif
9549
#ifdef GET_LINK_IMPL
9550
0
bool ByteCodeEmitter::emitGetGlobalSint8(uint32_t A0, const SourceInfo &L) {
9551
0
  return emitOp<uint32_t>(OP_GetGlobalSint8, A0, L);
9552
0
}
9553
0
bool ByteCodeEmitter::emitGetGlobalUint8(uint32_t A0, const SourceInfo &L) {
9554
0
  return emitOp<uint32_t>(OP_GetGlobalUint8, A0, L);
9555
0
}
9556
0
bool ByteCodeEmitter::emitGetGlobalSint16(uint32_t A0, const SourceInfo &L) {
9557
0
  return emitOp<uint32_t>(OP_GetGlobalSint16, A0, L);
9558
0
}
9559
0
bool ByteCodeEmitter::emitGetGlobalUint16(uint32_t A0, const SourceInfo &L) {
9560
0
  return emitOp<uint32_t>(OP_GetGlobalUint16, A0, L);
9561
0
}
9562
0
bool ByteCodeEmitter::emitGetGlobalSint32(uint32_t A0, const SourceInfo &L) {
9563
0
  return emitOp<uint32_t>(OP_GetGlobalSint32, A0, L);
9564
0
}
9565
0
bool ByteCodeEmitter::emitGetGlobalUint32(uint32_t A0, const SourceInfo &L) {
9566
0
  return emitOp<uint32_t>(OP_GetGlobalUint32, A0, L);
9567
0
}
9568
0
bool ByteCodeEmitter::emitGetGlobalSint64(uint32_t A0, const SourceInfo &L) {
9569
0
  return emitOp<uint32_t>(OP_GetGlobalSint64, A0, L);
9570
0
}
9571
0
bool ByteCodeEmitter::emitGetGlobalUint64(uint32_t A0, const SourceInfo &L) {
9572
0
  return emitOp<uint32_t>(OP_GetGlobalUint64, A0, L);
9573
0
}
9574
0
bool ByteCodeEmitter::emitGetGlobalIntAP(uint32_t A0, const SourceInfo &L) {
9575
0
  return emitOp<uint32_t>(OP_GetGlobalIntAP, A0, L);
9576
0
}
9577
0
bool ByteCodeEmitter::emitGetGlobalIntAPS(uint32_t A0, const SourceInfo &L) {
9578
0
  return emitOp<uint32_t>(OP_GetGlobalIntAPS, A0, L);
9579
0
}
9580
0
bool ByteCodeEmitter::emitGetGlobalBool(uint32_t A0, const SourceInfo &L) {
9581
0
  return emitOp<uint32_t>(OP_GetGlobalBool, A0, L);
9582
0
}
9583
0
bool ByteCodeEmitter::emitGetGlobalPtr(uint32_t A0, const SourceInfo &L) {
9584
0
  return emitOp<uint32_t>(OP_GetGlobalPtr, A0, L);
9585
0
}
9586
0
bool ByteCodeEmitter::emitGetGlobalFnPtr(uint32_t A0, const SourceInfo &L) {
9587
0
  return emitOp<uint32_t>(OP_GetGlobalFnPtr, A0, L);
9588
0
}
9589
0
bool ByteCodeEmitter::emitGetGlobalFloat(uint32_t A0, const SourceInfo &L) {
9590
0
  return emitOp<uint32_t>(OP_GetGlobalFloat, A0, L);
9591
0
}
9592
#endif
9593
#ifdef GET_EVAL_IMPL
9594
0
bool EvalEmitter::emitGetGlobalSint8(uint32_t A0, const SourceInfo &L) {
9595
0
  if (!isActive()) return true;
9596
0
  CurrentSource = L;
9597
0
  return GetGlobal<PT_Sint8>(S, OpPC, A0);
9598
0
}
9599
0
bool EvalEmitter::emitGetGlobalUint8(uint32_t A0, const SourceInfo &L) {
9600
0
  if (!isActive()) return true;
9601
0
  CurrentSource = L;
9602
0
  return GetGlobal<PT_Uint8>(S, OpPC, A0);
9603
0
}
9604
0
bool EvalEmitter::emitGetGlobalSint16(uint32_t A0, const SourceInfo &L) {
9605
0
  if (!isActive()) return true;
9606
0
  CurrentSource = L;
9607
0
  return GetGlobal<PT_Sint16>(S, OpPC, A0);
9608
0
}
9609
0
bool EvalEmitter::emitGetGlobalUint16(uint32_t A0, const SourceInfo &L) {
9610
0
  if (!isActive()) return true;
9611
0
  CurrentSource = L;
9612
0
  return GetGlobal<PT_Uint16>(S, OpPC, A0);
9613
0
}
9614
0
bool EvalEmitter::emitGetGlobalSint32(uint32_t A0, const SourceInfo &L) {
9615
0
  if (!isActive()) return true;
9616
0
  CurrentSource = L;
9617
0
  return GetGlobal<PT_Sint32>(S, OpPC, A0);
9618
0
}
9619
0
bool EvalEmitter::emitGetGlobalUint32(uint32_t A0, const SourceInfo &L) {
9620
0
  if (!isActive()) return true;
9621
0
  CurrentSource = L;
9622
0
  return GetGlobal<PT_Uint32>(S, OpPC, A0);
9623
0
}
9624
0
bool EvalEmitter::emitGetGlobalSint64(uint32_t A0, const SourceInfo &L) {
9625
0
  if (!isActive()) return true;
9626
0
  CurrentSource = L;
9627
0
  return GetGlobal<PT_Sint64>(S, OpPC, A0);
9628
0
}
9629
0
bool EvalEmitter::emitGetGlobalUint64(uint32_t A0, const SourceInfo &L) {
9630
0
  if (!isActive()) return true;
9631
0
  CurrentSource = L;
9632
0
  return GetGlobal<PT_Uint64>(S, OpPC, A0);
9633
0
}
9634
0
bool EvalEmitter::emitGetGlobalIntAP(uint32_t A0, const SourceInfo &L) {
9635
0
  if (!isActive()) return true;
9636
0
  CurrentSource = L;
9637
0
  return GetGlobal<PT_IntAP>(S, OpPC, A0);
9638
0
}
9639
0
bool EvalEmitter::emitGetGlobalIntAPS(uint32_t A0, const SourceInfo &L) {
9640
0
  if (!isActive()) return true;
9641
0
  CurrentSource = L;
9642
0
  return GetGlobal<PT_IntAPS>(S, OpPC, A0);
9643
0
}
9644
0
bool EvalEmitter::emitGetGlobalBool(uint32_t A0, const SourceInfo &L) {
9645
0
  if (!isActive()) return true;
9646
0
  CurrentSource = L;
9647
0
  return GetGlobal<PT_Bool>(S, OpPC, A0);
9648
0
}
9649
0
bool EvalEmitter::emitGetGlobalPtr(uint32_t A0, const SourceInfo &L) {
9650
0
  if (!isActive()) return true;
9651
0
  CurrentSource = L;
9652
0
  return GetGlobal<PT_Ptr>(S, OpPC, A0);
9653
0
}
9654
0
bool EvalEmitter::emitGetGlobalFnPtr(uint32_t A0, const SourceInfo &L) {
9655
0
  if (!isActive()) return true;
9656
0
  CurrentSource = L;
9657
0
  return GetGlobal<PT_FnPtr>(S, OpPC, A0);
9658
0
}
9659
0
bool EvalEmitter::emitGetGlobalFloat(uint32_t A0, const SourceInfo &L) {
9660
0
  if (!isActive()) return true;
9661
0
  CurrentSource = L;
9662
0
  return GetGlobal<PT_Float>(S, OpPC, A0);
9663
0
}
9664
#endif
9665
#ifdef GET_OPCODE_NAMES
9666
OP_GetGlobalUncheckedSint8,
9667
OP_GetGlobalUncheckedUint8,
9668
OP_GetGlobalUncheckedSint16,
9669
OP_GetGlobalUncheckedUint16,
9670
OP_GetGlobalUncheckedSint32,
9671
OP_GetGlobalUncheckedUint32,
9672
OP_GetGlobalUncheckedSint64,
9673
OP_GetGlobalUncheckedUint64,
9674
OP_GetGlobalUncheckedIntAP,
9675
OP_GetGlobalUncheckedIntAPS,
9676
OP_GetGlobalUncheckedBool,
9677
OP_GetGlobalUncheckedPtr,
9678
OP_GetGlobalUncheckedFnPtr,
9679
OP_GetGlobalUncheckedFloat,
9680
#endif
9681
0
#ifdef GET_INTERP
9682
0
case OP_GetGlobalUncheckedSint8: {
9683
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9684
0
  if (!GetGlobalUnchecked<PT_Sint8>(S, OpPC, V0))
9685
0
    return false;
9686
0
  continue;
9687
0
}
9688
0
case OP_GetGlobalUncheckedUint8: {
9689
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9690
0
  if (!GetGlobalUnchecked<PT_Uint8>(S, OpPC, V0))
9691
0
    return false;
9692
0
  continue;
9693
0
}
9694
0
case OP_GetGlobalUncheckedSint16: {
9695
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9696
0
  if (!GetGlobalUnchecked<PT_Sint16>(S, OpPC, V0))
9697
0
    return false;
9698
0
  continue;
9699
0
}
9700
0
case OP_GetGlobalUncheckedUint16: {
9701
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9702
0
  if (!GetGlobalUnchecked<PT_Uint16>(S, OpPC, V0))
9703
0
    return false;
9704
0
  continue;
9705
0
}
9706
0
case OP_GetGlobalUncheckedSint32: {
9707
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9708
0
  if (!GetGlobalUnchecked<PT_Sint32>(S, OpPC, V0))
9709
0
    return false;
9710
0
  continue;
9711
0
}
9712
0
case OP_GetGlobalUncheckedUint32: {
9713
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9714
0
  if (!GetGlobalUnchecked<PT_Uint32>(S, OpPC, V0))
9715
0
    return false;
9716
0
  continue;
9717
0
}
9718
0
case OP_GetGlobalUncheckedSint64: {
9719
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9720
0
  if (!GetGlobalUnchecked<PT_Sint64>(S, OpPC, V0))
9721
0
    return false;
9722
0
  continue;
9723
0
}
9724
0
case OP_GetGlobalUncheckedUint64: {
9725
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9726
0
  if (!GetGlobalUnchecked<PT_Uint64>(S, OpPC, V0))
9727
0
    return false;
9728
0
  continue;
9729
0
}
9730
0
case OP_GetGlobalUncheckedIntAP: {
9731
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9732
0
  if (!GetGlobalUnchecked<PT_IntAP>(S, OpPC, V0))
9733
0
    return false;
9734
0
  continue;
9735
0
}
9736
0
case OP_GetGlobalUncheckedIntAPS: {
9737
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9738
0
  if (!GetGlobalUnchecked<PT_IntAPS>(S, OpPC, V0))
9739
0
    return false;
9740
0
  continue;
9741
0
}
9742
0
case OP_GetGlobalUncheckedBool: {
9743
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9744
0
  if (!GetGlobalUnchecked<PT_Bool>(S, OpPC, V0))
9745
0
    return false;
9746
0
  continue;
9747
0
}
9748
0
case OP_GetGlobalUncheckedPtr: {
9749
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9750
0
  if (!GetGlobalUnchecked<PT_Ptr>(S, OpPC, V0))
9751
0
    return false;
9752
0
  continue;
9753
0
}
9754
0
case OP_GetGlobalUncheckedFnPtr: {
9755
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9756
0
  if (!GetGlobalUnchecked<PT_FnPtr>(S, OpPC, V0))
9757
0
    return false;
9758
0
  continue;
9759
0
}
9760
0
case OP_GetGlobalUncheckedFloat: {
9761
0
  auto V0 = ReadArg<uint32_t>(S, PC);
9762
0
  if (!GetGlobalUnchecked<PT_Float>(S, OpPC, V0))
9763
0
    return false;
9764
0
  continue;
9765
0
}
9766
0
#endif
9767
#ifdef GET_DISASM
9768
case OP_GetGlobalUncheckedSint8:
9769
  PrintName("GetGlobalUncheckedSint8");
9770
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9771
  continue;
9772
case OP_GetGlobalUncheckedUint8:
9773
  PrintName("GetGlobalUncheckedUint8");
9774
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9775
  continue;
9776
case OP_GetGlobalUncheckedSint16:
9777
  PrintName("GetGlobalUncheckedSint16");
9778
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9779
  continue;
9780
case OP_GetGlobalUncheckedUint16:
9781
  PrintName("GetGlobalUncheckedUint16");
9782
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9783
  continue;
9784
case OP_GetGlobalUncheckedSint32:
9785
  PrintName("GetGlobalUncheckedSint32");
9786
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9787
  continue;
9788
case OP_GetGlobalUncheckedUint32:
9789
  PrintName("GetGlobalUncheckedUint32");
9790
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9791
  continue;
9792
case OP_GetGlobalUncheckedSint64:
9793
  PrintName("GetGlobalUncheckedSint64");
9794
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9795
  continue;
9796
case OP_GetGlobalUncheckedUint64:
9797
  PrintName("GetGlobalUncheckedUint64");
9798
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9799
  continue;
9800
case OP_GetGlobalUncheckedIntAP:
9801
  PrintName("GetGlobalUncheckedIntAP");
9802
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9803
  continue;
9804
case OP_GetGlobalUncheckedIntAPS:
9805
  PrintName("GetGlobalUncheckedIntAPS");
9806
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9807
  continue;
9808
case OP_GetGlobalUncheckedBool:
9809
  PrintName("GetGlobalUncheckedBool");
9810
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9811
  continue;
9812
case OP_GetGlobalUncheckedPtr:
9813
  PrintName("GetGlobalUncheckedPtr");
9814
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9815
  continue;
9816
case OP_GetGlobalUncheckedFnPtr:
9817
  PrintName("GetGlobalUncheckedFnPtr");
9818
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9819
  continue;
9820
case OP_GetGlobalUncheckedFloat:
9821
  PrintName("GetGlobalUncheckedFloat");
9822
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
9823
  continue;
9824
#endif
9825
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9826
bool emitGetGlobalUncheckedSint8(uint32_t, const SourceInfo &);
9827
bool emitGetGlobalUncheckedUint8(uint32_t, const SourceInfo &);
9828
bool emitGetGlobalUncheckedSint16(uint32_t, const SourceInfo &);
9829
bool emitGetGlobalUncheckedUint16(uint32_t, const SourceInfo &);
9830
bool emitGetGlobalUncheckedSint32(uint32_t, const SourceInfo &);
9831
bool emitGetGlobalUncheckedUint32(uint32_t, const SourceInfo &);
9832
bool emitGetGlobalUncheckedSint64(uint32_t, const SourceInfo &);
9833
bool emitGetGlobalUncheckedUint64(uint32_t, const SourceInfo &);
9834
bool emitGetGlobalUncheckedIntAP(uint32_t, const SourceInfo &);
9835
bool emitGetGlobalUncheckedIntAPS(uint32_t, const SourceInfo &);
9836
bool emitGetGlobalUncheckedBool(uint32_t, const SourceInfo &);
9837
bool emitGetGlobalUncheckedPtr(uint32_t, const SourceInfo &);
9838
bool emitGetGlobalUncheckedFnPtr(uint32_t, const SourceInfo &);
9839
bool emitGetGlobalUncheckedFloat(uint32_t, const SourceInfo &);
9840
#endif
9841
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9842
bool emitGetGlobalUnchecked(PrimType, uint32_t, const SourceInfo &I);
9843
#endif
9844
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
9845
bool
9846
#if defined(GET_EVAL_IMPL)
9847
EvalEmitter
9848
#else
9849
ByteCodeEmitter
9850
#endif
9851
0
::emitGetGlobalUnchecked(PrimType T0, uint32_t A0, const SourceInfo &I) {
9852
0
  switch (T0) {
9853
0
  case PT_Sint8:
9854
0
    return emitGetGlobalUncheckedSint8(A0, I);
9855
0
  case PT_Uint8:
9856
0
    return emitGetGlobalUncheckedUint8(A0, I);
9857
0
  case PT_Sint16:
9858
0
    return emitGetGlobalUncheckedSint16(A0, I);
9859
0
  case PT_Uint16:
9860
0
    return emitGetGlobalUncheckedUint16(A0, I);
9861
0
  case PT_Sint32:
9862
0
    return emitGetGlobalUncheckedSint32(A0, I);
9863
0
  case PT_Uint32:
9864
0
    return emitGetGlobalUncheckedUint32(A0, I);
9865
0
  case PT_Sint64:
9866
0
    return emitGetGlobalUncheckedSint64(A0, I);
9867
0
  case PT_Uint64:
9868
0
    return emitGetGlobalUncheckedUint64(A0, I);
9869
0
  case PT_IntAP:
9870
0
    return emitGetGlobalUncheckedIntAP(A0, I);
9871
0
  case PT_IntAPS:
9872
0
    return emitGetGlobalUncheckedIntAPS(A0, I);
9873
0
  case PT_Bool:
9874
0
    return emitGetGlobalUncheckedBool(A0, I);
9875
0
  case PT_Ptr:
9876
0
    return emitGetGlobalUncheckedPtr(A0, I);
9877
0
  case PT_FnPtr:
9878
0
    return emitGetGlobalUncheckedFnPtr(A0, I);
9879
0
  case PT_Float:
9880
0
    return emitGetGlobalUncheckedFloat(A0, I);
9881
0
  }
9882
0
  llvm_unreachable("invalid enum value");
9883
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetGlobalUnchecked(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetGlobalUnchecked(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
9884
#endif
9885
#ifdef GET_LINK_IMPL
9886
0
bool ByteCodeEmitter::emitGetGlobalUncheckedSint8(uint32_t A0, const SourceInfo &L) {
9887
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedSint8, A0, L);
9888
0
}
9889
0
bool ByteCodeEmitter::emitGetGlobalUncheckedUint8(uint32_t A0, const SourceInfo &L) {
9890
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedUint8, A0, L);
9891
0
}
9892
0
bool ByteCodeEmitter::emitGetGlobalUncheckedSint16(uint32_t A0, const SourceInfo &L) {
9893
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedSint16, A0, L);
9894
0
}
9895
0
bool ByteCodeEmitter::emitGetGlobalUncheckedUint16(uint32_t A0, const SourceInfo &L) {
9896
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedUint16, A0, L);
9897
0
}
9898
0
bool ByteCodeEmitter::emitGetGlobalUncheckedSint32(uint32_t A0, const SourceInfo &L) {
9899
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedSint32, A0, L);
9900
0
}
9901
0
bool ByteCodeEmitter::emitGetGlobalUncheckedUint32(uint32_t A0, const SourceInfo &L) {
9902
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedUint32, A0, L);
9903
0
}
9904
0
bool ByteCodeEmitter::emitGetGlobalUncheckedSint64(uint32_t A0, const SourceInfo &L) {
9905
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedSint64, A0, L);
9906
0
}
9907
0
bool ByteCodeEmitter::emitGetGlobalUncheckedUint64(uint32_t A0, const SourceInfo &L) {
9908
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedUint64, A0, L);
9909
0
}
9910
0
bool ByteCodeEmitter::emitGetGlobalUncheckedIntAP(uint32_t A0, const SourceInfo &L) {
9911
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedIntAP, A0, L);
9912
0
}
9913
0
bool ByteCodeEmitter::emitGetGlobalUncheckedIntAPS(uint32_t A0, const SourceInfo &L) {
9914
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedIntAPS, A0, L);
9915
0
}
9916
0
bool ByteCodeEmitter::emitGetGlobalUncheckedBool(uint32_t A0, const SourceInfo &L) {
9917
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedBool, A0, L);
9918
0
}
9919
0
bool ByteCodeEmitter::emitGetGlobalUncheckedPtr(uint32_t A0, const SourceInfo &L) {
9920
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedPtr, A0, L);
9921
0
}
9922
0
bool ByteCodeEmitter::emitGetGlobalUncheckedFnPtr(uint32_t A0, const SourceInfo &L) {
9923
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedFnPtr, A0, L);
9924
0
}
9925
0
bool ByteCodeEmitter::emitGetGlobalUncheckedFloat(uint32_t A0, const SourceInfo &L) {
9926
0
  return emitOp<uint32_t>(OP_GetGlobalUncheckedFloat, A0, L);
9927
0
}
9928
#endif
9929
#ifdef GET_EVAL_IMPL
9930
0
bool EvalEmitter::emitGetGlobalUncheckedSint8(uint32_t A0, const SourceInfo &L) {
9931
0
  if (!isActive()) return true;
9932
0
  CurrentSource = L;
9933
0
  return GetGlobalUnchecked<PT_Sint8>(S, OpPC, A0);
9934
0
}
9935
0
bool EvalEmitter::emitGetGlobalUncheckedUint8(uint32_t A0, const SourceInfo &L) {
9936
0
  if (!isActive()) return true;
9937
0
  CurrentSource = L;
9938
0
  return GetGlobalUnchecked<PT_Uint8>(S, OpPC, A0);
9939
0
}
9940
0
bool EvalEmitter::emitGetGlobalUncheckedSint16(uint32_t A0, const SourceInfo &L) {
9941
0
  if (!isActive()) return true;
9942
0
  CurrentSource = L;
9943
0
  return GetGlobalUnchecked<PT_Sint16>(S, OpPC, A0);
9944
0
}
9945
0
bool EvalEmitter::emitGetGlobalUncheckedUint16(uint32_t A0, const SourceInfo &L) {
9946
0
  if (!isActive()) return true;
9947
0
  CurrentSource = L;
9948
0
  return GetGlobalUnchecked<PT_Uint16>(S, OpPC, A0);
9949
0
}
9950
0
bool EvalEmitter::emitGetGlobalUncheckedSint32(uint32_t A0, const SourceInfo &L) {
9951
0
  if (!isActive()) return true;
9952
0
  CurrentSource = L;
9953
0
  return GetGlobalUnchecked<PT_Sint32>(S, OpPC, A0);
9954
0
}
9955
0
bool EvalEmitter::emitGetGlobalUncheckedUint32(uint32_t A0, const SourceInfo &L) {
9956
0
  if (!isActive()) return true;
9957
0
  CurrentSource = L;
9958
0
  return GetGlobalUnchecked<PT_Uint32>(S, OpPC, A0);
9959
0
}
9960
0
bool EvalEmitter::emitGetGlobalUncheckedSint64(uint32_t A0, const SourceInfo &L) {
9961
0
  if (!isActive()) return true;
9962
0
  CurrentSource = L;
9963
0
  return GetGlobalUnchecked<PT_Sint64>(S, OpPC, A0);
9964
0
}
9965
0
bool EvalEmitter::emitGetGlobalUncheckedUint64(uint32_t A0, const SourceInfo &L) {
9966
0
  if (!isActive()) return true;
9967
0
  CurrentSource = L;
9968
0
  return GetGlobalUnchecked<PT_Uint64>(S, OpPC, A0);
9969
0
}
9970
0
bool EvalEmitter::emitGetGlobalUncheckedIntAP(uint32_t A0, const SourceInfo &L) {
9971
0
  if (!isActive()) return true;
9972
0
  CurrentSource = L;
9973
0
  return GetGlobalUnchecked<PT_IntAP>(S, OpPC, A0);
9974
0
}
9975
0
bool EvalEmitter::emitGetGlobalUncheckedIntAPS(uint32_t A0, const SourceInfo &L) {
9976
0
  if (!isActive()) return true;
9977
0
  CurrentSource = L;
9978
0
  return GetGlobalUnchecked<PT_IntAPS>(S, OpPC, A0);
9979
0
}
9980
0
bool EvalEmitter::emitGetGlobalUncheckedBool(uint32_t A0, const SourceInfo &L) {
9981
0
  if (!isActive()) return true;
9982
0
  CurrentSource = L;
9983
0
  return GetGlobalUnchecked<PT_Bool>(S, OpPC, A0);
9984
0
}
9985
0
bool EvalEmitter::emitGetGlobalUncheckedPtr(uint32_t A0, const SourceInfo &L) {
9986
0
  if (!isActive()) return true;
9987
0
  CurrentSource = L;
9988
0
  return GetGlobalUnchecked<PT_Ptr>(S, OpPC, A0);
9989
0
}
9990
0
bool EvalEmitter::emitGetGlobalUncheckedFnPtr(uint32_t A0, const SourceInfo &L) {
9991
0
  if (!isActive()) return true;
9992
0
  CurrentSource = L;
9993
0
  return GetGlobalUnchecked<PT_FnPtr>(S, OpPC, A0);
9994
0
}
9995
0
bool EvalEmitter::emitGetGlobalUncheckedFloat(uint32_t A0, const SourceInfo &L) {
9996
0
  if (!isActive()) return true;
9997
0
  CurrentSource = L;
9998
0
  return GetGlobalUnchecked<PT_Float>(S, OpPC, A0);
9999
0
}
10000
#endif
10001
#ifdef GET_OPCODE_NAMES
10002
OP_GetLocalSint8,
10003
OP_GetLocalUint8,
10004
OP_GetLocalSint16,
10005
OP_GetLocalUint16,
10006
OP_GetLocalSint32,
10007
OP_GetLocalUint32,
10008
OP_GetLocalSint64,
10009
OP_GetLocalUint64,
10010
OP_GetLocalIntAP,
10011
OP_GetLocalIntAPS,
10012
OP_GetLocalBool,
10013
OP_GetLocalPtr,
10014
OP_GetLocalFnPtr,
10015
OP_GetLocalFloat,
10016
#endif
10017
0
#ifdef GET_INTERP
10018
0
case OP_GetLocalSint8: {
10019
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10020
0
  if (!GetLocal<PT_Sint8>(S, OpPC, V0))
10021
0
    return false;
10022
0
  continue;
10023
0
}
10024
0
case OP_GetLocalUint8: {
10025
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10026
0
  if (!GetLocal<PT_Uint8>(S, OpPC, V0))
10027
0
    return false;
10028
0
  continue;
10029
0
}
10030
0
case OP_GetLocalSint16: {
10031
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10032
0
  if (!GetLocal<PT_Sint16>(S, OpPC, V0))
10033
0
    return false;
10034
0
  continue;
10035
0
}
10036
0
case OP_GetLocalUint16: {
10037
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10038
0
  if (!GetLocal<PT_Uint16>(S, OpPC, V0))
10039
0
    return false;
10040
0
  continue;
10041
0
}
10042
0
case OP_GetLocalSint32: {
10043
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10044
0
  if (!GetLocal<PT_Sint32>(S, OpPC, V0))
10045
0
    return false;
10046
0
  continue;
10047
0
}
10048
0
case OP_GetLocalUint32: {
10049
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10050
0
  if (!GetLocal<PT_Uint32>(S, OpPC, V0))
10051
0
    return false;
10052
0
  continue;
10053
0
}
10054
0
case OP_GetLocalSint64: {
10055
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10056
0
  if (!GetLocal<PT_Sint64>(S, OpPC, V0))
10057
0
    return false;
10058
0
  continue;
10059
0
}
10060
0
case OP_GetLocalUint64: {
10061
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10062
0
  if (!GetLocal<PT_Uint64>(S, OpPC, V0))
10063
0
    return false;
10064
0
  continue;
10065
0
}
10066
0
case OP_GetLocalIntAP: {
10067
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10068
0
  if (!GetLocal<PT_IntAP>(S, OpPC, V0))
10069
0
    return false;
10070
0
  continue;
10071
0
}
10072
0
case OP_GetLocalIntAPS: {
10073
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10074
0
  if (!GetLocal<PT_IntAPS>(S, OpPC, V0))
10075
0
    return false;
10076
0
  continue;
10077
0
}
10078
0
case OP_GetLocalBool: {
10079
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10080
0
  if (!GetLocal<PT_Bool>(S, OpPC, V0))
10081
0
    return false;
10082
0
  continue;
10083
0
}
10084
0
case OP_GetLocalPtr: {
10085
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10086
0
  if (!GetLocal<PT_Ptr>(S, OpPC, V0))
10087
0
    return false;
10088
0
  continue;
10089
0
}
10090
0
case OP_GetLocalFnPtr: {
10091
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10092
0
  if (!GetLocal<PT_FnPtr>(S, OpPC, V0))
10093
0
    return false;
10094
0
  continue;
10095
0
}
10096
0
case OP_GetLocalFloat: {
10097
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10098
0
  if (!GetLocal<PT_Float>(S, OpPC, V0))
10099
0
    return false;
10100
0
  continue;
10101
0
}
10102
0
#endif
10103
#ifdef GET_DISASM
10104
case OP_GetLocalSint8:
10105
  PrintName("GetLocalSint8");
10106
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10107
  continue;
10108
case OP_GetLocalUint8:
10109
  PrintName("GetLocalUint8");
10110
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10111
  continue;
10112
case OP_GetLocalSint16:
10113
  PrintName("GetLocalSint16");
10114
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10115
  continue;
10116
case OP_GetLocalUint16:
10117
  PrintName("GetLocalUint16");
10118
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10119
  continue;
10120
case OP_GetLocalSint32:
10121
  PrintName("GetLocalSint32");
10122
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10123
  continue;
10124
case OP_GetLocalUint32:
10125
  PrintName("GetLocalUint32");
10126
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10127
  continue;
10128
case OP_GetLocalSint64:
10129
  PrintName("GetLocalSint64");
10130
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10131
  continue;
10132
case OP_GetLocalUint64:
10133
  PrintName("GetLocalUint64");
10134
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10135
  continue;
10136
case OP_GetLocalIntAP:
10137
  PrintName("GetLocalIntAP");
10138
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10139
  continue;
10140
case OP_GetLocalIntAPS:
10141
  PrintName("GetLocalIntAPS");
10142
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10143
  continue;
10144
case OP_GetLocalBool:
10145
  PrintName("GetLocalBool");
10146
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10147
  continue;
10148
case OP_GetLocalPtr:
10149
  PrintName("GetLocalPtr");
10150
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10151
  continue;
10152
case OP_GetLocalFnPtr:
10153
  PrintName("GetLocalFnPtr");
10154
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10155
  continue;
10156
case OP_GetLocalFloat:
10157
  PrintName("GetLocalFloat");
10158
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10159
  continue;
10160
#endif
10161
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10162
bool emitGetLocalSint8(uint32_t, const SourceInfo &);
10163
bool emitGetLocalUint8(uint32_t, const SourceInfo &);
10164
bool emitGetLocalSint16(uint32_t, const SourceInfo &);
10165
bool emitGetLocalUint16(uint32_t, const SourceInfo &);
10166
bool emitGetLocalSint32(uint32_t, const SourceInfo &);
10167
bool emitGetLocalUint32(uint32_t, const SourceInfo &);
10168
bool emitGetLocalSint64(uint32_t, const SourceInfo &);
10169
bool emitGetLocalUint64(uint32_t, const SourceInfo &);
10170
bool emitGetLocalIntAP(uint32_t, const SourceInfo &);
10171
bool emitGetLocalIntAPS(uint32_t, const SourceInfo &);
10172
bool emitGetLocalBool(uint32_t, const SourceInfo &);
10173
bool emitGetLocalPtr(uint32_t, const SourceInfo &);
10174
bool emitGetLocalFnPtr(uint32_t, const SourceInfo &);
10175
bool emitGetLocalFloat(uint32_t, const SourceInfo &);
10176
#if defined(GET_EVAL_PROTO)
10177
template<PrimType>
10178
bool emitGetLocal(uint32_t, const SourceInfo &);
10179
#endif
10180
#endif
10181
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10182
bool emitGetLocal(PrimType, uint32_t, const SourceInfo &I);
10183
#endif
10184
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
10185
bool
10186
#if defined(GET_EVAL_IMPL)
10187
EvalEmitter
10188
#else
10189
ByteCodeEmitter
10190
#endif
10191
0
::emitGetLocal(PrimType T0, uint32_t A0, const SourceInfo &I) {
10192
0
  switch (T0) {
10193
0
  case PT_Sint8:
10194
#ifdef GET_LINK_IMPL
10195
    return emitGetLocalSint8
10196
#else
10197
    return emitGetLocal<PT_Sint8>
10198
#endif
10199
0
      (A0, I);
10200
0
  case PT_Uint8:
10201
#ifdef GET_LINK_IMPL
10202
    return emitGetLocalUint8
10203
#else
10204
    return emitGetLocal<PT_Uint8>
10205
#endif
10206
0
      (A0, I);
10207
0
  case PT_Sint16:
10208
#ifdef GET_LINK_IMPL
10209
    return emitGetLocalSint16
10210
#else
10211
    return emitGetLocal<PT_Sint16>
10212
#endif
10213
0
      (A0, I);
10214
0
  case PT_Uint16:
10215
#ifdef GET_LINK_IMPL
10216
    return emitGetLocalUint16
10217
#else
10218
    return emitGetLocal<PT_Uint16>
10219
#endif
10220
0
      (A0, I);
10221
0
  case PT_Sint32:
10222
#ifdef GET_LINK_IMPL
10223
    return emitGetLocalSint32
10224
#else
10225
    return emitGetLocal<PT_Sint32>
10226
#endif
10227
0
      (A0, I);
10228
0
  case PT_Uint32:
10229
#ifdef GET_LINK_IMPL
10230
    return emitGetLocalUint32
10231
#else
10232
    return emitGetLocal<PT_Uint32>
10233
#endif
10234
0
      (A0, I);
10235
0
  case PT_Sint64:
10236
#ifdef GET_LINK_IMPL
10237
    return emitGetLocalSint64
10238
#else
10239
    return emitGetLocal<PT_Sint64>
10240
#endif
10241
0
      (A0, I);
10242
0
  case PT_Uint64:
10243
#ifdef GET_LINK_IMPL
10244
    return emitGetLocalUint64
10245
#else
10246
    return emitGetLocal<PT_Uint64>
10247
#endif
10248
0
      (A0, I);
10249
0
  case PT_IntAP:
10250
#ifdef GET_LINK_IMPL
10251
    return emitGetLocalIntAP
10252
#else
10253
    return emitGetLocal<PT_IntAP>
10254
#endif
10255
0
      (A0, I);
10256
0
  case PT_IntAPS:
10257
#ifdef GET_LINK_IMPL
10258
    return emitGetLocalIntAPS
10259
#else
10260
    return emitGetLocal<PT_IntAPS>
10261
#endif
10262
0
      (A0, I);
10263
0
  case PT_Bool:
10264
#ifdef GET_LINK_IMPL
10265
    return emitGetLocalBool
10266
#else
10267
    return emitGetLocal<PT_Bool>
10268
#endif
10269
0
      (A0, I);
10270
0
  case PT_Ptr:
10271
#ifdef GET_LINK_IMPL
10272
    return emitGetLocalPtr
10273
#else
10274
    return emitGetLocal<PT_Ptr>
10275
#endif
10276
0
      (A0, I);
10277
0
  case PT_FnPtr:
10278
#ifdef GET_LINK_IMPL
10279
    return emitGetLocalFnPtr
10280
#else
10281
    return emitGetLocal<PT_FnPtr>
10282
#endif
10283
0
      (A0, I);
10284
0
  case PT_Float:
10285
#ifdef GET_LINK_IMPL
10286
    return emitGetLocalFloat
10287
#else
10288
    return emitGetLocal<PT_Float>
10289
#endif
10290
0
      (A0, I);
10291
0
  }
10292
0
  llvm_unreachable("invalid enum value");
10293
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetLocal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetLocal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
10294
#endif
10295
#ifdef GET_LINK_IMPL
10296
0
bool ByteCodeEmitter::emitGetLocalSint8(uint32_t A0, const SourceInfo &L) {
10297
0
  return emitOp<uint32_t>(OP_GetLocalSint8, A0, L);
10298
0
}
10299
0
bool ByteCodeEmitter::emitGetLocalUint8(uint32_t A0, const SourceInfo &L) {
10300
0
  return emitOp<uint32_t>(OP_GetLocalUint8, A0, L);
10301
0
}
10302
0
bool ByteCodeEmitter::emitGetLocalSint16(uint32_t A0, const SourceInfo &L) {
10303
0
  return emitOp<uint32_t>(OP_GetLocalSint16, A0, L);
10304
0
}
10305
0
bool ByteCodeEmitter::emitGetLocalUint16(uint32_t A0, const SourceInfo &L) {
10306
0
  return emitOp<uint32_t>(OP_GetLocalUint16, A0, L);
10307
0
}
10308
0
bool ByteCodeEmitter::emitGetLocalSint32(uint32_t A0, const SourceInfo &L) {
10309
0
  return emitOp<uint32_t>(OP_GetLocalSint32, A0, L);
10310
0
}
10311
0
bool ByteCodeEmitter::emitGetLocalUint32(uint32_t A0, const SourceInfo &L) {
10312
0
  return emitOp<uint32_t>(OP_GetLocalUint32, A0, L);
10313
0
}
10314
0
bool ByteCodeEmitter::emitGetLocalSint64(uint32_t A0, const SourceInfo &L) {
10315
0
  return emitOp<uint32_t>(OP_GetLocalSint64, A0, L);
10316
0
}
10317
0
bool ByteCodeEmitter::emitGetLocalUint64(uint32_t A0, const SourceInfo &L) {
10318
0
  return emitOp<uint32_t>(OP_GetLocalUint64, A0, L);
10319
0
}
10320
0
bool ByteCodeEmitter::emitGetLocalIntAP(uint32_t A0, const SourceInfo &L) {
10321
0
  return emitOp<uint32_t>(OP_GetLocalIntAP, A0, L);
10322
0
}
10323
0
bool ByteCodeEmitter::emitGetLocalIntAPS(uint32_t A0, const SourceInfo &L) {
10324
0
  return emitOp<uint32_t>(OP_GetLocalIntAPS, A0, L);
10325
0
}
10326
0
bool ByteCodeEmitter::emitGetLocalBool(uint32_t A0, const SourceInfo &L) {
10327
0
  return emitOp<uint32_t>(OP_GetLocalBool, A0, L);
10328
0
}
10329
0
bool ByteCodeEmitter::emitGetLocalPtr(uint32_t A0, const SourceInfo &L) {
10330
0
  return emitOp<uint32_t>(OP_GetLocalPtr, A0, L);
10331
0
}
10332
0
bool ByteCodeEmitter::emitGetLocalFnPtr(uint32_t A0, const SourceInfo &L) {
10333
0
  return emitOp<uint32_t>(OP_GetLocalFnPtr, A0, L);
10334
0
}
10335
0
bool ByteCodeEmitter::emitGetLocalFloat(uint32_t A0, const SourceInfo &L) {
10336
0
  return emitOp<uint32_t>(OP_GetLocalFloat, A0, L);
10337
0
}
10338
#endif
10339
#ifdef GET_OPCODE_NAMES
10340
OP_GetParamSint8,
10341
OP_GetParamUint8,
10342
OP_GetParamSint16,
10343
OP_GetParamUint16,
10344
OP_GetParamSint32,
10345
OP_GetParamUint32,
10346
OP_GetParamSint64,
10347
OP_GetParamUint64,
10348
OP_GetParamIntAP,
10349
OP_GetParamIntAPS,
10350
OP_GetParamBool,
10351
OP_GetParamPtr,
10352
OP_GetParamFnPtr,
10353
OP_GetParamFloat,
10354
#endif
10355
0
#ifdef GET_INTERP
10356
0
case OP_GetParamSint8: {
10357
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10358
0
  if (!GetParam<PT_Sint8>(S, OpPC, V0))
10359
0
    return false;
10360
0
  continue;
10361
0
}
10362
0
case OP_GetParamUint8: {
10363
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10364
0
  if (!GetParam<PT_Uint8>(S, OpPC, V0))
10365
0
    return false;
10366
0
  continue;
10367
0
}
10368
0
case OP_GetParamSint16: {
10369
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10370
0
  if (!GetParam<PT_Sint16>(S, OpPC, V0))
10371
0
    return false;
10372
0
  continue;
10373
0
}
10374
0
case OP_GetParamUint16: {
10375
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10376
0
  if (!GetParam<PT_Uint16>(S, OpPC, V0))
10377
0
    return false;
10378
0
  continue;
10379
0
}
10380
0
case OP_GetParamSint32: {
10381
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10382
0
  if (!GetParam<PT_Sint32>(S, OpPC, V0))
10383
0
    return false;
10384
0
  continue;
10385
0
}
10386
0
case OP_GetParamUint32: {
10387
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10388
0
  if (!GetParam<PT_Uint32>(S, OpPC, V0))
10389
0
    return false;
10390
0
  continue;
10391
0
}
10392
0
case OP_GetParamSint64: {
10393
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10394
0
  if (!GetParam<PT_Sint64>(S, OpPC, V0))
10395
0
    return false;
10396
0
  continue;
10397
0
}
10398
0
case OP_GetParamUint64: {
10399
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10400
0
  if (!GetParam<PT_Uint64>(S, OpPC, V0))
10401
0
    return false;
10402
0
  continue;
10403
0
}
10404
0
case OP_GetParamIntAP: {
10405
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10406
0
  if (!GetParam<PT_IntAP>(S, OpPC, V0))
10407
0
    return false;
10408
0
  continue;
10409
0
}
10410
0
case OP_GetParamIntAPS: {
10411
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10412
0
  if (!GetParam<PT_IntAPS>(S, OpPC, V0))
10413
0
    return false;
10414
0
  continue;
10415
0
}
10416
0
case OP_GetParamBool: {
10417
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10418
0
  if (!GetParam<PT_Bool>(S, OpPC, V0))
10419
0
    return false;
10420
0
  continue;
10421
0
}
10422
0
case OP_GetParamPtr: {
10423
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10424
0
  if (!GetParam<PT_Ptr>(S, OpPC, V0))
10425
0
    return false;
10426
0
  continue;
10427
0
}
10428
0
case OP_GetParamFnPtr: {
10429
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10430
0
  if (!GetParam<PT_FnPtr>(S, OpPC, V0))
10431
0
    return false;
10432
0
  continue;
10433
0
}
10434
0
case OP_GetParamFloat: {
10435
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10436
0
  if (!GetParam<PT_Float>(S, OpPC, V0))
10437
0
    return false;
10438
0
  continue;
10439
0
}
10440
0
#endif
10441
#ifdef GET_DISASM
10442
case OP_GetParamSint8:
10443
  PrintName("GetParamSint8");
10444
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10445
  continue;
10446
case OP_GetParamUint8:
10447
  PrintName("GetParamUint8");
10448
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10449
  continue;
10450
case OP_GetParamSint16:
10451
  PrintName("GetParamSint16");
10452
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10453
  continue;
10454
case OP_GetParamUint16:
10455
  PrintName("GetParamUint16");
10456
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10457
  continue;
10458
case OP_GetParamSint32:
10459
  PrintName("GetParamSint32");
10460
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10461
  continue;
10462
case OP_GetParamUint32:
10463
  PrintName("GetParamUint32");
10464
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10465
  continue;
10466
case OP_GetParamSint64:
10467
  PrintName("GetParamSint64");
10468
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10469
  continue;
10470
case OP_GetParamUint64:
10471
  PrintName("GetParamUint64");
10472
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10473
  continue;
10474
case OP_GetParamIntAP:
10475
  PrintName("GetParamIntAP");
10476
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10477
  continue;
10478
case OP_GetParamIntAPS:
10479
  PrintName("GetParamIntAPS");
10480
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10481
  continue;
10482
case OP_GetParamBool:
10483
  PrintName("GetParamBool");
10484
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10485
  continue;
10486
case OP_GetParamPtr:
10487
  PrintName("GetParamPtr");
10488
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10489
  continue;
10490
case OP_GetParamFnPtr:
10491
  PrintName("GetParamFnPtr");
10492
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10493
  continue;
10494
case OP_GetParamFloat:
10495
  PrintName("GetParamFloat");
10496
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10497
  continue;
10498
#endif
10499
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10500
bool emitGetParamSint8(uint32_t, const SourceInfo &);
10501
bool emitGetParamUint8(uint32_t, const SourceInfo &);
10502
bool emitGetParamSint16(uint32_t, const SourceInfo &);
10503
bool emitGetParamUint16(uint32_t, const SourceInfo &);
10504
bool emitGetParamSint32(uint32_t, const SourceInfo &);
10505
bool emitGetParamUint32(uint32_t, const SourceInfo &);
10506
bool emitGetParamSint64(uint32_t, const SourceInfo &);
10507
bool emitGetParamUint64(uint32_t, const SourceInfo &);
10508
bool emitGetParamIntAP(uint32_t, const SourceInfo &);
10509
bool emitGetParamIntAPS(uint32_t, const SourceInfo &);
10510
bool emitGetParamBool(uint32_t, const SourceInfo &);
10511
bool emitGetParamPtr(uint32_t, const SourceInfo &);
10512
bool emitGetParamFnPtr(uint32_t, const SourceInfo &);
10513
bool emitGetParamFloat(uint32_t, const SourceInfo &);
10514
#endif
10515
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10516
bool emitGetParam(PrimType, uint32_t, const SourceInfo &I);
10517
#endif
10518
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
10519
bool
10520
#if defined(GET_EVAL_IMPL)
10521
EvalEmitter
10522
#else
10523
ByteCodeEmitter
10524
#endif
10525
0
::emitGetParam(PrimType T0, uint32_t A0, const SourceInfo &I) {
10526
0
  switch (T0) {
10527
0
  case PT_Sint8:
10528
0
    return emitGetParamSint8(A0, I);
10529
0
  case PT_Uint8:
10530
0
    return emitGetParamUint8(A0, I);
10531
0
  case PT_Sint16:
10532
0
    return emitGetParamSint16(A0, I);
10533
0
  case PT_Uint16:
10534
0
    return emitGetParamUint16(A0, I);
10535
0
  case PT_Sint32:
10536
0
    return emitGetParamSint32(A0, I);
10537
0
  case PT_Uint32:
10538
0
    return emitGetParamUint32(A0, I);
10539
0
  case PT_Sint64:
10540
0
    return emitGetParamSint64(A0, I);
10541
0
  case PT_Uint64:
10542
0
    return emitGetParamUint64(A0, I);
10543
0
  case PT_IntAP:
10544
0
    return emitGetParamIntAP(A0, I);
10545
0
  case PT_IntAPS:
10546
0
    return emitGetParamIntAPS(A0, I);
10547
0
  case PT_Bool:
10548
0
    return emitGetParamBool(A0, I);
10549
0
  case PT_Ptr:
10550
0
    return emitGetParamPtr(A0, I);
10551
0
  case PT_FnPtr:
10552
0
    return emitGetParamFnPtr(A0, I);
10553
0
  case PT_Float:
10554
0
    return emitGetParamFloat(A0, I);
10555
0
  }
10556
0
  llvm_unreachable("invalid enum value");
10557
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetParam(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetParam(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
10558
#endif
10559
#ifdef GET_LINK_IMPL
10560
0
bool ByteCodeEmitter::emitGetParamSint8(uint32_t A0, const SourceInfo &L) {
10561
0
  return emitOp<uint32_t>(OP_GetParamSint8, A0, L);
10562
0
}
10563
0
bool ByteCodeEmitter::emitGetParamUint8(uint32_t A0, const SourceInfo &L) {
10564
0
  return emitOp<uint32_t>(OP_GetParamUint8, A0, L);
10565
0
}
10566
0
bool ByteCodeEmitter::emitGetParamSint16(uint32_t A0, const SourceInfo &L) {
10567
0
  return emitOp<uint32_t>(OP_GetParamSint16, A0, L);
10568
0
}
10569
0
bool ByteCodeEmitter::emitGetParamUint16(uint32_t A0, const SourceInfo &L) {
10570
0
  return emitOp<uint32_t>(OP_GetParamUint16, A0, L);
10571
0
}
10572
0
bool ByteCodeEmitter::emitGetParamSint32(uint32_t A0, const SourceInfo &L) {
10573
0
  return emitOp<uint32_t>(OP_GetParamSint32, A0, L);
10574
0
}
10575
0
bool ByteCodeEmitter::emitGetParamUint32(uint32_t A0, const SourceInfo &L) {
10576
0
  return emitOp<uint32_t>(OP_GetParamUint32, A0, L);
10577
0
}
10578
0
bool ByteCodeEmitter::emitGetParamSint64(uint32_t A0, const SourceInfo &L) {
10579
0
  return emitOp<uint32_t>(OP_GetParamSint64, A0, L);
10580
0
}
10581
0
bool ByteCodeEmitter::emitGetParamUint64(uint32_t A0, const SourceInfo &L) {
10582
0
  return emitOp<uint32_t>(OP_GetParamUint64, A0, L);
10583
0
}
10584
0
bool ByteCodeEmitter::emitGetParamIntAP(uint32_t A0, const SourceInfo &L) {
10585
0
  return emitOp<uint32_t>(OP_GetParamIntAP, A0, L);
10586
0
}
10587
0
bool ByteCodeEmitter::emitGetParamIntAPS(uint32_t A0, const SourceInfo &L) {
10588
0
  return emitOp<uint32_t>(OP_GetParamIntAPS, A0, L);
10589
0
}
10590
0
bool ByteCodeEmitter::emitGetParamBool(uint32_t A0, const SourceInfo &L) {
10591
0
  return emitOp<uint32_t>(OP_GetParamBool, A0, L);
10592
0
}
10593
0
bool ByteCodeEmitter::emitGetParamPtr(uint32_t A0, const SourceInfo &L) {
10594
0
  return emitOp<uint32_t>(OP_GetParamPtr, A0, L);
10595
0
}
10596
0
bool ByteCodeEmitter::emitGetParamFnPtr(uint32_t A0, const SourceInfo &L) {
10597
0
  return emitOp<uint32_t>(OP_GetParamFnPtr, A0, L);
10598
0
}
10599
0
bool ByteCodeEmitter::emitGetParamFloat(uint32_t A0, const SourceInfo &L) {
10600
0
  return emitOp<uint32_t>(OP_GetParamFloat, A0, L);
10601
0
}
10602
#endif
10603
#ifdef GET_EVAL_IMPL
10604
0
bool EvalEmitter::emitGetParamSint8(uint32_t A0, const SourceInfo &L) {
10605
0
  if (!isActive()) return true;
10606
0
  CurrentSource = L;
10607
0
  return GetParam<PT_Sint8>(S, OpPC, A0);
10608
0
}
10609
0
bool EvalEmitter::emitGetParamUint8(uint32_t A0, const SourceInfo &L) {
10610
0
  if (!isActive()) return true;
10611
0
  CurrentSource = L;
10612
0
  return GetParam<PT_Uint8>(S, OpPC, A0);
10613
0
}
10614
0
bool EvalEmitter::emitGetParamSint16(uint32_t A0, const SourceInfo &L) {
10615
0
  if (!isActive()) return true;
10616
0
  CurrentSource = L;
10617
0
  return GetParam<PT_Sint16>(S, OpPC, A0);
10618
0
}
10619
0
bool EvalEmitter::emitGetParamUint16(uint32_t A0, const SourceInfo &L) {
10620
0
  if (!isActive()) return true;
10621
0
  CurrentSource = L;
10622
0
  return GetParam<PT_Uint16>(S, OpPC, A0);
10623
0
}
10624
0
bool EvalEmitter::emitGetParamSint32(uint32_t A0, const SourceInfo &L) {
10625
0
  if (!isActive()) return true;
10626
0
  CurrentSource = L;
10627
0
  return GetParam<PT_Sint32>(S, OpPC, A0);
10628
0
}
10629
0
bool EvalEmitter::emitGetParamUint32(uint32_t A0, const SourceInfo &L) {
10630
0
  if (!isActive()) return true;
10631
0
  CurrentSource = L;
10632
0
  return GetParam<PT_Uint32>(S, OpPC, A0);
10633
0
}
10634
0
bool EvalEmitter::emitGetParamSint64(uint32_t A0, const SourceInfo &L) {
10635
0
  if (!isActive()) return true;
10636
0
  CurrentSource = L;
10637
0
  return GetParam<PT_Sint64>(S, OpPC, A0);
10638
0
}
10639
0
bool EvalEmitter::emitGetParamUint64(uint32_t A0, const SourceInfo &L) {
10640
0
  if (!isActive()) return true;
10641
0
  CurrentSource = L;
10642
0
  return GetParam<PT_Uint64>(S, OpPC, A0);
10643
0
}
10644
0
bool EvalEmitter::emitGetParamIntAP(uint32_t A0, const SourceInfo &L) {
10645
0
  if (!isActive()) return true;
10646
0
  CurrentSource = L;
10647
0
  return GetParam<PT_IntAP>(S, OpPC, A0);
10648
0
}
10649
0
bool EvalEmitter::emitGetParamIntAPS(uint32_t A0, const SourceInfo &L) {
10650
0
  if (!isActive()) return true;
10651
0
  CurrentSource = L;
10652
0
  return GetParam<PT_IntAPS>(S, OpPC, A0);
10653
0
}
10654
0
bool EvalEmitter::emitGetParamBool(uint32_t A0, const SourceInfo &L) {
10655
0
  if (!isActive()) return true;
10656
0
  CurrentSource = L;
10657
0
  return GetParam<PT_Bool>(S, OpPC, A0);
10658
0
}
10659
0
bool EvalEmitter::emitGetParamPtr(uint32_t A0, const SourceInfo &L) {
10660
0
  if (!isActive()) return true;
10661
0
  CurrentSource = L;
10662
0
  return GetParam<PT_Ptr>(S, OpPC, A0);
10663
0
}
10664
0
bool EvalEmitter::emitGetParamFnPtr(uint32_t A0, const SourceInfo &L) {
10665
0
  if (!isActive()) return true;
10666
0
  CurrentSource = L;
10667
0
  return GetParam<PT_FnPtr>(S, OpPC, A0);
10668
0
}
10669
0
bool EvalEmitter::emitGetParamFloat(uint32_t A0, const SourceInfo &L) {
10670
0
  if (!isActive()) return true;
10671
0
  CurrentSource = L;
10672
0
  return GetParam<PT_Float>(S, OpPC, A0);
10673
0
}
10674
#endif
10675
#ifdef GET_OPCODE_NAMES
10676
OP_GetPtrActiveField,
10677
#endif
10678
0
#ifdef GET_INTERP
10679
0
case OP_GetPtrActiveField: {
10680
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10681
0
  if (!GetPtrActiveField(S, OpPC, V0))
10682
0
    return false;
10683
0
  continue;
10684
0
}
10685
0
#endif
10686
#ifdef GET_DISASM
10687
case OP_GetPtrActiveField:
10688
  PrintName("GetPtrActiveField");
10689
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10690
  continue;
10691
#endif
10692
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10693
bool emitGetPtrActiveField(uint32_t, const SourceInfo &);
10694
#endif
10695
#ifdef GET_LINK_IMPL
10696
0
bool ByteCodeEmitter::emitGetPtrActiveField(uint32_t A0, const SourceInfo &L) {
10697
0
  return emitOp<uint32_t>(OP_GetPtrActiveField, A0, L);
10698
0
}
10699
#endif
10700
#ifdef GET_EVAL_IMPL
10701
0
bool EvalEmitter::emitGetPtrActiveField(uint32_t A0, const SourceInfo &L) {
10702
0
  if (!isActive()) return true;
10703
0
  CurrentSource = L;
10704
0
  return GetPtrActiveField(S, OpPC, A0);
10705
0
}
10706
#endif
10707
#ifdef GET_OPCODE_NAMES
10708
OP_GetPtrActiveThisField,
10709
#endif
10710
0
#ifdef GET_INTERP
10711
0
case OP_GetPtrActiveThisField: {
10712
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10713
0
  if (!GetPtrActiveThisField(S, OpPC, V0))
10714
0
    return false;
10715
0
  continue;
10716
0
}
10717
0
#endif
10718
#ifdef GET_DISASM
10719
case OP_GetPtrActiveThisField:
10720
  PrintName("GetPtrActiveThisField");
10721
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10722
  continue;
10723
#endif
10724
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10725
bool emitGetPtrActiveThisField(uint32_t, const SourceInfo &);
10726
#endif
10727
#ifdef GET_LINK_IMPL
10728
0
bool ByteCodeEmitter::emitGetPtrActiveThisField(uint32_t A0, const SourceInfo &L) {
10729
0
  return emitOp<uint32_t>(OP_GetPtrActiveThisField, A0, L);
10730
0
}
10731
#endif
10732
#ifdef GET_EVAL_IMPL
10733
0
bool EvalEmitter::emitGetPtrActiveThisField(uint32_t A0, const SourceInfo &L) {
10734
0
  if (!isActive()) return true;
10735
0
  CurrentSource = L;
10736
0
  return GetPtrActiveThisField(S, OpPC, A0);
10737
0
}
10738
#endif
10739
#ifdef GET_OPCODE_NAMES
10740
OP_GetPtrBase,
10741
#endif
10742
0
#ifdef GET_INTERP
10743
0
case OP_GetPtrBase: {
10744
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10745
0
  if (!GetPtrBase(S, OpPC, V0))
10746
0
    return false;
10747
0
  continue;
10748
0
}
10749
0
#endif
10750
#ifdef GET_DISASM
10751
case OP_GetPtrBase:
10752
  PrintName("GetPtrBase");
10753
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10754
  continue;
10755
#endif
10756
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10757
bool emitGetPtrBase(uint32_t, const SourceInfo &);
10758
#endif
10759
#ifdef GET_LINK_IMPL
10760
0
bool ByteCodeEmitter::emitGetPtrBase(uint32_t A0, const SourceInfo &L) {
10761
0
  return emitOp<uint32_t>(OP_GetPtrBase, A0, L);
10762
0
}
10763
#endif
10764
#ifdef GET_EVAL_IMPL
10765
0
bool EvalEmitter::emitGetPtrBase(uint32_t A0, const SourceInfo &L) {
10766
0
  if (!isActive()) return true;
10767
0
  CurrentSource = L;
10768
0
  return GetPtrBase(S, OpPC, A0);
10769
0
}
10770
#endif
10771
#ifdef GET_OPCODE_NAMES
10772
OP_GetPtrBasePop,
10773
#endif
10774
0
#ifdef GET_INTERP
10775
0
case OP_GetPtrBasePop: {
10776
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10777
0
  if (!GetPtrBasePop(S, OpPC, V0))
10778
0
    return false;
10779
0
  continue;
10780
0
}
10781
0
#endif
10782
#ifdef GET_DISASM
10783
case OP_GetPtrBasePop:
10784
  PrintName("GetPtrBasePop");
10785
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10786
  continue;
10787
#endif
10788
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10789
bool emitGetPtrBasePop(uint32_t, const SourceInfo &);
10790
#endif
10791
#ifdef GET_LINK_IMPL
10792
0
bool ByteCodeEmitter::emitGetPtrBasePop(uint32_t A0, const SourceInfo &L) {
10793
0
  return emitOp<uint32_t>(OP_GetPtrBasePop, A0, L);
10794
0
}
10795
#endif
10796
#ifdef GET_EVAL_IMPL
10797
0
bool EvalEmitter::emitGetPtrBasePop(uint32_t A0, const SourceInfo &L) {
10798
0
  if (!isActive()) return true;
10799
0
  CurrentSource = L;
10800
0
  return GetPtrBasePop(S, OpPC, A0);
10801
0
}
10802
#endif
10803
#ifdef GET_OPCODE_NAMES
10804
OP_GetPtrDerivedPop,
10805
#endif
10806
0
#ifdef GET_INTERP
10807
0
case OP_GetPtrDerivedPop: {
10808
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10809
0
  if (!GetPtrDerivedPop(S, OpPC, V0))
10810
0
    return false;
10811
0
  continue;
10812
0
}
10813
0
#endif
10814
#ifdef GET_DISASM
10815
case OP_GetPtrDerivedPop:
10816
  PrintName("GetPtrDerivedPop");
10817
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10818
  continue;
10819
#endif
10820
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10821
bool emitGetPtrDerivedPop(uint32_t, const SourceInfo &);
10822
#endif
10823
#ifdef GET_LINK_IMPL
10824
0
bool ByteCodeEmitter::emitGetPtrDerivedPop(uint32_t A0, const SourceInfo &L) {
10825
0
  return emitOp<uint32_t>(OP_GetPtrDerivedPop, A0, L);
10826
0
}
10827
#endif
10828
#ifdef GET_EVAL_IMPL
10829
0
bool EvalEmitter::emitGetPtrDerivedPop(uint32_t A0, const SourceInfo &L) {
10830
0
  if (!isActive()) return true;
10831
0
  CurrentSource = L;
10832
0
  return GetPtrDerivedPop(S, OpPC, A0);
10833
0
}
10834
#endif
10835
#ifdef GET_OPCODE_NAMES
10836
OP_GetPtrField,
10837
#endif
10838
0
#ifdef GET_INTERP
10839
0
case OP_GetPtrField: {
10840
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10841
0
  if (!GetPtrField(S, OpPC, V0))
10842
0
    return false;
10843
0
  continue;
10844
0
}
10845
0
#endif
10846
#ifdef GET_DISASM
10847
case OP_GetPtrField:
10848
  PrintName("GetPtrField");
10849
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10850
  continue;
10851
#endif
10852
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10853
bool emitGetPtrField(uint32_t, const SourceInfo &);
10854
#endif
10855
#ifdef GET_LINK_IMPL
10856
0
bool ByteCodeEmitter::emitGetPtrField(uint32_t A0, const SourceInfo &L) {
10857
0
  return emitOp<uint32_t>(OP_GetPtrField, A0, L);
10858
0
}
10859
#endif
10860
#ifdef GET_EVAL_IMPL
10861
0
bool EvalEmitter::emitGetPtrField(uint32_t A0, const SourceInfo &L) {
10862
0
  if (!isActive()) return true;
10863
0
  CurrentSource = L;
10864
0
  return GetPtrField(S, OpPC, A0);
10865
0
}
10866
#endif
10867
#ifdef GET_OPCODE_NAMES
10868
OP_GetPtrGlobal,
10869
#endif
10870
0
#ifdef GET_INTERP
10871
0
case OP_GetPtrGlobal: {
10872
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10873
0
  if (!GetPtrGlobal(S, OpPC, V0))
10874
0
    return false;
10875
0
  continue;
10876
0
}
10877
0
#endif
10878
#ifdef GET_DISASM
10879
case OP_GetPtrGlobal:
10880
  PrintName("GetPtrGlobal");
10881
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10882
  continue;
10883
#endif
10884
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10885
bool emitGetPtrGlobal(uint32_t, const SourceInfo &);
10886
#endif
10887
#ifdef GET_LINK_IMPL
10888
0
bool ByteCodeEmitter::emitGetPtrGlobal(uint32_t A0, const SourceInfo &L) {
10889
0
  return emitOp<uint32_t>(OP_GetPtrGlobal, A0, L);
10890
0
}
10891
#endif
10892
#ifdef GET_EVAL_IMPL
10893
0
bool EvalEmitter::emitGetPtrGlobal(uint32_t A0, const SourceInfo &L) {
10894
0
  if (!isActive()) return true;
10895
0
  CurrentSource = L;
10896
0
  return GetPtrGlobal(S, OpPC, A0);
10897
0
}
10898
#endif
10899
#ifdef GET_OPCODE_NAMES
10900
OP_GetPtrLocal,
10901
#endif
10902
0
#ifdef GET_INTERP
10903
0
case OP_GetPtrLocal: {
10904
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10905
0
  if (!GetPtrLocal(S, OpPC, V0))
10906
0
    return false;
10907
0
  continue;
10908
0
}
10909
0
#endif
10910
#ifdef GET_DISASM
10911
case OP_GetPtrLocal:
10912
  PrintName("GetPtrLocal");
10913
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10914
  continue;
10915
#endif
10916
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10917
bool emitGetPtrLocal(uint32_t, const SourceInfo &);
10918
#endif
10919
#ifdef GET_LINK_IMPL
10920
0
bool ByteCodeEmitter::emitGetPtrLocal(uint32_t A0, const SourceInfo &L) {
10921
0
  return emitOp<uint32_t>(OP_GetPtrLocal, A0, L);
10922
0
}
10923
#endif
10924
#ifdef GET_OPCODE_NAMES
10925
OP_GetPtrParam,
10926
#endif
10927
0
#ifdef GET_INTERP
10928
0
case OP_GetPtrParam: {
10929
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10930
0
  if (!GetPtrParam(S, OpPC, V0))
10931
0
    return false;
10932
0
  continue;
10933
0
}
10934
0
#endif
10935
#ifdef GET_DISASM
10936
case OP_GetPtrParam:
10937
  PrintName("GetPtrParam");
10938
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10939
  continue;
10940
#endif
10941
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10942
bool emitGetPtrParam(uint32_t, const SourceInfo &);
10943
#endif
10944
#ifdef GET_LINK_IMPL
10945
0
bool ByteCodeEmitter::emitGetPtrParam(uint32_t A0, const SourceInfo &L) {
10946
0
  return emitOp<uint32_t>(OP_GetPtrParam, A0, L);
10947
0
}
10948
#endif
10949
#ifdef GET_EVAL_IMPL
10950
0
bool EvalEmitter::emitGetPtrParam(uint32_t A0, const SourceInfo &L) {
10951
0
  if (!isActive()) return true;
10952
0
  CurrentSource = L;
10953
0
  return GetPtrParam(S, OpPC, A0);
10954
0
}
10955
#endif
10956
#ifdef GET_OPCODE_NAMES
10957
OP_GetPtrThisBase,
10958
#endif
10959
0
#ifdef GET_INTERP
10960
0
case OP_GetPtrThisBase: {
10961
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10962
0
  if (!GetPtrThisBase(S, OpPC, V0))
10963
0
    return false;
10964
0
  continue;
10965
0
}
10966
0
#endif
10967
#ifdef GET_DISASM
10968
case OP_GetPtrThisBase:
10969
  PrintName("GetPtrThisBase");
10970
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
10971
  continue;
10972
#endif
10973
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10974
bool emitGetPtrThisBase(uint32_t, const SourceInfo &);
10975
#endif
10976
#ifdef GET_LINK_IMPL
10977
0
bool ByteCodeEmitter::emitGetPtrThisBase(uint32_t A0, const SourceInfo &L) {
10978
0
  return emitOp<uint32_t>(OP_GetPtrThisBase, A0, L);
10979
0
}
10980
#endif
10981
#ifdef GET_EVAL_IMPL
10982
0
bool EvalEmitter::emitGetPtrThisBase(uint32_t A0, const SourceInfo &L) {
10983
0
  if (!isActive()) return true;
10984
0
  CurrentSource = L;
10985
0
  return GetPtrThisBase(S, OpPC, A0);
10986
0
}
10987
#endif
10988
#ifdef GET_OPCODE_NAMES
10989
OP_GetPtrThisField,
10990
#endif
10991
0
#ifdef GET_INTERP
10992
0
case OP_GetPtrThisField: {
10993
0
  auto V0 = ReadArg<uint32_t>(S, PC);
10994
0
  if (!GetPtrThisField(S, OpPC, V0))
10995
0
    return false;
10996
0
  continue;
10997
0
}
10998
0
#endif
10999
#ifdef GET_DISASM
11000
case OP_GetPtrThisField:
11001
  PrintName("GetPtrThisField");
11002
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11003
  continue;
11004
#endif
11005
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11006
bool emitGetPtrThisField(uint32_t, const SourceInfo &);
11007
#endif
11008
#ifdef GET_LINK_IMPL
11009
0
bool ByteCodeEmitter::emitGetPtrThisField(uint32_t A0, const SourceInfo &L) {
11010
0
  return emitOp<uint32_t>(OP_GetPtrThisField, A0, L);
11011
0
}
11012
#endif
11013
#ifdef GET_EVAL_IMPL
11014
0
bool EvalEmitter::emitGetPtrThisField(uint32_t A0, const SourceInfo &L) {
11015
0
  if (!isActive()) return true;
11016
0
  CurrentSource = L;
11017
0
  return GetPtrThisField(S, OpPC, A0);
11018
0
}
11019
#endif
11020
#ifdef GET_OPCODE_NAMES
11021
OP_GetPtrThisVirtBase,
11022
#endif
11023
0
#ifdef GET_INTERP
11024
0
case OP_GetPtrThisVirtBase: {
11025
0
  auto V0 = ReadArg<const RecordDecl *>(S, PC);
11026
0
  if (!GetPtrThisVirtBase(S, OpPC, V0))
11027
0
    return false;
11028
0
  continue;
11029
0
}
11030
0
#endif
11031
#ifdef GET_DISASM
11032
case OP_GetPtrThisVirtBase:
11033
  PrintName("GetPtrThisVirtBase");
11034
  OS << "\t" << ReadArg<const RecordDecl *>(P, PC) << " " << "\n";
11035
  continue;
11036
#endif
11037
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11038
bool emitGetPtrThisVirtBase(const RecordDecl *, const SourceInfo &);
11039
#endif
11040
#ifdef GET_LINK_IMPL
11041
0
bool ByteCodeEmitter::emitGetPtrThisVirtBase(const RecordDecl * A0, const SourceInfo &L) {
11042
0
  return emitOp<const RecordDecl *>(OP_GetPtrThisVirtBase, A0, L);
11043
0
}
11044
#endif
11045
#ifdef GET_EVAL_IMPL
11046
0
bool EvalEmitter::emitGetPtrThisVirtBase(const RecordDecl * A0, const SourceInfo &L) {
11047
0
  if (!isActive()) return true;
11048
0
  CurrentSource = L;
11049
0
  return GetPtrThisVirtBase(S, OpPC, A0);
11050
0
}
11051
#endif
11052
#ifdef GET_OPCODE_NAMES
11053
OP_GetPtrVirtBase,
11054
#endif
11055
0
#ifdef GET_INTERP
11056
0
case OP_GetPtrVirtBase: {
11057
0
  auto V0 = ReadArg<const RecordDecl *>(S, PC);
11058
0
  if (!GetPtrVirtBase(S, OpPC, V0))
11059
0
    return false;
11060
0
  continue;
11061
0
}
11062
0
#endif
11063
#ifdef GET_DISASM
11064
case OP_GetPtrVirtBase:
11065
  PrintName("GetPtrVirtBase");
11066
  OS << "\t" << ReadArg<const RecordDecl *>(P, PC) << " " << "\n";
11067
  continue;
11068
#endif
11069
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11070
bool emitGetPtrVirtBase(const RecordDecl *, const SourceInfo &);
11071
#endif
11072
#ifdef GET_LINK_IMPL
11073
0
bool ByteCodeEmitter::emitGetPtrVirtBase(const RecordDecl * A0, const SourceInfo &L) {
11074
0
  return emitOp<const RecordDecl *>(OP_GetPtrVirtBase, A0, L);
11075
0
}
11076
#endif
11077
#ifdef GET_EVAL_IMPL
11078
0
bool EvalEmitter::emitGetPtrVirtBase(const RecordDecl * A0, const SourceInfo &L) {
11079
0
  if (!isActive()) return true;
11080
0
  CurrentSource = L;
11081
0
  return GetPtrVirtBase(S, OpPC, A0);
11082
0
}
11083
#endif
11084
#ifdef GET_OPCODE_NAMES
11085
OP_GetThisFieldSint8,
11086
OP_GetThisFieldUint8,
11087
OP_GetThisFieldSint16,
11088
OP_GetThisFieldUint16,
11089
OP_GetThisFieldSint32,
11090
OP_GetThisFieldUint32,
11091
OP_GetThisFieldSint64,
11092
OP_GetThisFieldUint64,
11093
OP_GetThisFieldIntAP,
11094
OP_GetThisFieldIntAPS,
11095
OP_GetThisFieldBool,
11096
OP_GetThisFieldPtr,
11097
OP_GetThisFieldFnPtr,
11098
OP_GetThisFieldFloat,
11099
#endif
11100
0
#ifdef GET_INTERP
11101
0
case OP_GetThisFieldSint8: {
11102
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11103
0
  if (!GetThisField<PT_Sint8>(S, OpPC, V0))
11104
0
    return false;
11105
0
  continue;
11106
0
}
11107
0
case OP_GetThisFieldUint8: {
11108
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11109
0
  if (!GetThisField<PT_Uint8>(S, OpPC, V0))
11110
0
    return false;
11111
0
  continue;
11112
0
}
11113
0
case OP_GetThisFieldSint16: {
11114
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11115
0
  if (!GetThisField<PT_Sint16>(S, OpPC, V0))
11116
0
    return false;
11117
0
  continue;
11118
0
}
11119
0
case OP_GetThisFieldUint16: {
11120
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11121
0
  if (!GetThisField<PT_Uint16>(S, OpPC, V0))
11122
0
    return false;
11123
0
  continue;
11124
0
}
11125
0
case OP_GetThisFieldSint32: {
11126
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11127
0
  if (!GetThisField<PT_Sint32>(S, OpPC, V0))
11128
0
    return false;
11129
0
  continue;
11130
0
}
11131
0
case OP_GetThisFieldUint32: {
11132
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11133
0
  if (!GetThisField<PT_Uint32>(S, OpPC, V0))
11134
0
    return false;
11135
0
  continue;
11136
0
}
11137
0
case OP_GetThisFieldSint64: {
11138
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11139
0
  if (!GetThisField<PT_Sint64>(S, OpPC, V0))
11140
0
    return false;
11141
0
  continue;
11142
0
}
11143
0
case OP_GetThisFieldUint64: {
11144
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11145
0
  if (!GetThisField<PT_Uint64>(S, OpPC, V0))
11146
0
    return false;
11147
0
  continue;
11148
0
}
11149
0
case OP_GetThisFieldIntAP: {
11150
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11151
0
  if (!GetThisField<PT_IntAP>(S, OpPC, V0))
11152
0
    return false;
11153
0
  continue;
11154
0
}
11155
0
case OP_GetThisFieldIntAPS: {
11156
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11157
0
  if (!GetThisField<PT_IntAPS>(S, OpPC, V0))
11158
0
    return false;
11159
0
  continue;
11160
0
}
11161
0
case OP_GetThisFieldBool: {
11162
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11163
0
  if (!GetThisField<PT_Bool>(S, OpPC, V0))
11164
0
    return false;
11165
0
  continue;
11166
0
}
11167
0
case OP_GetThisFieldPtr: {
11168
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11169
0
  if (!GetThisField<PT_Ptr>(S, OpPC, V0))
11170
0
    return false;
11171
0
  continue;
11172
0
}
11173
0
case OP_GetThisFieldFnPtr: {
11174
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11175
0
  if (!GetThisField<PT_FnPtr>(S, OpPC, V0))
11176
0
    return false;
11177
0
  continue;
11178
0
}
11179
0
case OP_GetThisFieldFloat: {
11180
0
  auto V0 = ReadArg<uint32_t>(S, PC);
11181
0
  if (!GetThisField<PT_Float>(S, OpPC, V0))
11182
0
    return false;
11183
0
  continue;
11184
0
}
11185
0
#endif
11186
#ifdef GET_DISASM
11187
case OP_GetThisFieldSint8:
11188
  PrintName("GetThisFieldSint8");
11189
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11190
  continue;
11191
case OP_GetThisFieldUint8:
11192
  PrintName("GetThisFieldUint8");
11193
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11194
  continue;
11195
case OP_GetThisFieldSint16:
11196
  PrintName("GetThisFieldSint16");
11197
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11198
  continue;
11199
case OP_GetThisFieldUint16:
11200
  PrintName("GetThisFieldUint16");
11201
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11202
  continue;
11203
case OP_GetThisFieldSint32:
11204
  PrintName("GetThisFieldSint32");
11205
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11206
  continue;
11207
case OP_GetThisFieldUint32:
11208
  PrintName("GetThisFieldUint32");
11209
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11210
  continue;
11211
case OP_GetThisFieldSint64:
11212
  PrintName("GetThisFieldSint64");
11213
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11214
  continue;
11215
case OP_GetThisFieldUint64:
11216
  PrintName("GetThisFieldUint64");
11217
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11218
  continue;
11219
case OP_GetThisFieldIntAP:
11220
  PrintName("GetThisFieldIntAP");
11221
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11222
  continue;
11223
case OP_GetThisFieldIntAPS:
11224
  PrintName("GetThisFieldIntAPS");
11225
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11226
  continue;
11227
case OP_GetThisFieldBool:
11228
  PrintName("GetThisFieldBool");
11229
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11230
  continue;
11231
case OP_GetThisFieldPtr:
11232
  PrintName("GetThisFieldPtr");
11233
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11234
  continue;
11235
case OP_GetThisFieldFnPtr:
11236
  PrintName("GetThisFieldFnPtr");
11237
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11238
  continue;
11239
case OP_GetThisFieldFloat:
11240
  PrintName("GetThisFieldFloat");
11241
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
11242
  continue;
11243
#endif
11244
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11245
bool emitGetThisFieldSint8(uint32_t, const SourceInfo &);
11246
bool emitGetThisFieldUint8(uint32_t, const SourceInfo &);
11247
bool emitGetThisFieldSint16(uint32_t, const SourceInfo &);
11248
bool emitGetThisFieldUint16(uint32_t, const SourceInfo &);
11249
bool emitGetThisFieldSint32(uint32_t, const SourceInfo &);
11250
bool emitGetThisFieldUint32(uint32_t, const SourceInfo &);
11251
bool emitGetThisFieldSint64(uint32_t, const SourceInfo &);
11252
bool emitGetThisFieldUint64(uint32_t, const SourceInfo &);
11253
bool emitGetThisFieldIntAP(uint32_t, const SourceInfo &);
11254
bool emitGetThisFieldIntAPS(uint32_t, const SourceInfo &);
11255
bool emitGetThisFieldBool(uint32_t, const SourceInfo &);
11256
bool emitGetThisFieldPtr(uint32_t, const SourceInfo &);
11257
bool emitGetThisFieldFnPtr(uint32_t, const SourceInfo &);
11258
bool emitGetThisFieldFloat(uint32_t, const SourceInfo &);
11259
#endif
11260
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11261
bool emitGetThisField(PrimType, uint32_t, const SourceInfo &I);
11262
#endif
11263
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
11264
bool
11265
#if defined(GET_EVAL_IMPL)
11266
EvalEmitter
11267
#else
11268
ByteCodeEmitter
11269
#endif
11270
0
::emitGetThisField(PrimType T0, uint32_t A0, const SourceInfo &I) {
11271
0
  switch (T0) {
11272
0
  case PT_Sint8:
11273
0
    return emitGetThisFieldSint8(A0, I);
11274
0
  case PT_Uint8:
11275
0
    return emitGetThisFieldUint8(A0, I);
11276
0
  case PT_Sint16:
11277
0
    return emitGetThisFieldSint16(A0, I);
11278
0
  case PT_Uint16:
11279
0
    return emitGetThisFieldUint16(A0, I);
11280
0
  case PT_Sint32:
11281
0
    return emitGetThisFieldSint32(A0, I);
11282
0
  case PT_Uint32:
11283
0
    return emitGetThisFieldUint32(A0, I);
11284
0
  case PT_Sint64:
11285
0
    return emitGetThisFieldSint64(A0, I);
11286
0
  case PT_Uint64:
11287
0
    return emitGetThisFieldUint64(A0, I);
11288
0
  case PT_IntAP:
11289
0
    return emitGetThisFieldIntAP(A0, I);
11290
0
  case PT_IntAPS:
11291
0
    return emitGetThisFieldIntAPS(A0, I);
11292
0
  case PT_Bool:
11293
0
    return emitGetThisFieldBool(A0, I);
11294
0
  case PT_Ptr:
11295
0
    return emitGetThisFieldPtr(A0, I);
11296
0
  case PT_FnPtr:
11297
0
    return emitGetThisFieldFnPtr(A0, I);
11298
0
  case PT_Float:
11299
0
    return emitGetThisFieldFloat(A0, I);
11300
0
  }
11301
0
  llvm_unreachable("invalid enum value");
11302
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitGetThisField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitGetThisField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
11303
#endif
11304
#ifdef GET_LINK_IMPL
11305
0
bool ByteCodeEmitter::emitGetThisFieldSint8(uint32_t A0, const SourceInfo &L) {
11306
0
  return emitOp<uint32_t>(OP_GetThisFieldSint8, A0, L);
11307
0
}
11308
0
bool ByteCodeEmitter::emitGetThisFieldUint8(uint32_t A0, const SourceInfo &L) {
11309
0
  return emitOp<uint32_t>(OP_GetThisFieldUint8, A0, L);
11310
0
}
11311
0
bool ByteCodeEmitter::emitGetThisFieldSint16(uint32_t A0, const SourceInfo &L) {
11312
0
  return emitOp<uint32_t>(OP_GetThisFieldSint16, A0, L);
11313
0
}
11314
0
bool ByteCodeEmitter::emitGetThisFieldUint16(uint32_t A0, const SourceInfo &L) {
11315
0
  return emitOp<uint32_t>(OP_GetThisFieldUint16, A0, L);
11316
0
}
11317
0
bool ByteCodeEmitter::emitGetThisFieldSint32(uint32_t A0, const SourceInfo &L) {
11318
0
  return emitOp<uint32_t>(OP_GetThisFieldSint32, A0, L);
11319
0
}
11320
0
bool ByteCodeEmitter::emitGetThisFieldUint32(uint32_t A0, const SourceInfo &L) {
11321
0
  return emitOp<uint32_t>(OP_GetThisFieldUint32, A0, L);
11322
0
}
11323
0
bool ByteCodeEmitter::emitGetThisFieldSint64(uint32_t A0, const SourceInfo &L) {
11324
0
  return emitOp<uint32_t>(OP_GetThisFieldSint64, A0, L);
11325
0
}
11326
0
bool ByteCodeEmitter::emitGetThisFieldUint64(uint32_t A0, const SourceInfo &L) {
11327
0
  return emitOp<uint32_t>(OP_GetThisFieldUint64, A0, L);
11328
0
}
11329
0
bool ByteCodeEmitter::emitGetThisFieldIntAP(uint32_t A0, const SourceInfo &L) {
11330
0
  return emitOp<uint32_t>(OP_GetThisFieldIntAP, A0, L);
11331
0
}
11332
0
bool ByteCodeEmitter::emitGetThisFieldIntAPS(uint32_t A0, const SourceInfo &L) {
11333
0
  return emitOp<uint32_t>(OP_GetThisFieldIntAPS, A0, L);
11334
0
}
11335
0
bool ByteCodeEmitter::emitGetThisFieldBool(uint32_t A0, const SourceInfo &L) {
11336
0
  return emitOp<uint32_t>(OP_GetThisFieldBool, A0, L);
11337
0
}
11338
0
bool ByteCodeEmitter::emitGetThisFieldPtr(uint32_t A0, const SourceInfo &L) {
11339
0
  return emitOp<uint32_t>(OP_GetThisFieldPtr, A0, L);
11340
0
}
11341
0
bool ByteCodeEmitter::emitGetThisFieldFnPtr(uint32_t A0, const SourceInfo &L) {
11342
0
  return emitOp<uint32_t>(OP_GetThisFieldFnPtr, A0, L);
11343
0
}
11344
0
bool ByteCodeEmitter::emitGetThisFieldFloat(uint32_t A0, const SourceInfo &L) {
11345
0
  return emitOp<uint32_t>(OP_GetThisFieldFloat, A0, L);
11346
0
}
11347
#endif
11348
#ifdef GET_EVAL_IMPL
11349
0
bool EvalEmitter::emitGetThisFieldSint8(uint32_t A0, const SourceInfo &L) {
11350
0
  if (!isActive()) return true;
11351
0
  CurrentSource = L;
11352
0
  return GetThisField<PT_Sint8>(S, OpPC, A0);
11353
0
}
11354
0
bool EvalEmitter::emitGetThisFieldUint8(uint32_t A0, const SourceInfo &L) {
11355
0
  if (!isActive()) return true;
11356
0
  CurrentSource = L;
11357
0
  return GetThisField<PT_Uint8>(S, OpPC, A0);
11358
0
}
11359
0
bool EvalEmitter::emitGetThisFieldSint16(uint32_t A0, const SourceInfo &L) {
11360
0
  if (!isActive()) return true;
11361
0
  CurrentSource = L;
11362
0
  return GetThisField<PT_Sint16>(S, OpPC, A0);
11363
0
}
11364
0
bool EvalEmitter::emitGetThisFieldUint16(uint32_t A0, const SourceInfo &L) {
11365
0
  if (!isActive()) return true;
11366
0
  CurrentSource = L;
11367
0
  return GetThisField<PT_Uint16>(S, OpPC, A0);
11368
0
}
11369
0
bool EvalEmitter::emitGetThisFieldSint32(uint32_t A0, const SourceInfo &L) {
11370
0
  if (!isActive()) return true;
11371
0
  CurrentSource = L;
11372
0
  return GetThisField<PT_Sint32>(S, OpPC, A0);
11373
0
}
11374
0
bool EvalEmitter::emitGetThisFieldUint32(uint32_t A0, const SourceInfo &L) {
11375
0
  if (!isActive()) return true;
11376
0
  CurrentSource = L;
11377
0
  return GetThisField<PT_Uint32>(S, OpPC, A0);
11378
0
}
11379
0
bool EvalEmitter::emitGetThisFieldSint64(uint32_t A0, const SourceInfo &L) {
11380
0
  if (!isActive()) return true;
11381
0
  CurrentSource = L;
11382
0
  return GetThisField<PT_Sint64>(S, OpPC, A0);
11383
0
}
11384
0
bool EvalEmitter::emitGetThisFieldUint64(uint32_t A0, const SourceInfo &L) {
11385
0
  if (!isActive()) return true;
11386
0
  CurrentSource = L;
11387
0
  return GetThisField<PT_Uint64>(S, OpPC, A0);
11388
0
}
11389
0
bool EvalEmitter::emitGetThisFieldIntAP(uint32_t A0, const SourceInfo &L) {
11390
0
  if (!isActive()) return true;
11391
0
  CurrentSource = L;
11392
0
  return GetThisField<PT_IntAP>(S, OpPC, A0);
11393
0
}
11394
0
bool EvalEmitter::emitGetThisFieldIntAPS(uint32_t A0, const SourceInfo &L) {
11395
0
  if (!isActive()) return true;
11396
0
  CurrentSource = L;
11397
0
  return GetThisField<PT_IntAPS>(S, OpPC, A0);
11398
0
}
11399
0
bool EvalEmitter::emitGetThisFieldBool(uint32_t A0, const SourceInfo &L) {
11400
0
  if (!isActive()) return true;
11401
0
  CurrentSource = L;
11402
0
  return GetThisField<PT_Bool>(S, OpPC, A0);
11403
0
}
11404
0
bool EvalEmitter::emitGetThisFieldPtr(uint32_t A0, const SourceInfo &L) {
11405
0
  if (!isActive()) return true;
11406
0
  CurrentSource = L;
11407
0
  return GetThisField<PT_Ptr>(S, OpPC, A0);
11408
0
}
11409
0
bool EvalEmitter::emitGetThisFieldFnPtr(uint32_t A0, const SourceInfo &L) {
11410
0
  if (!isActive()) return true;
11411
0
  CurrentSource = L;
11412
0
  return GetThisField<PT_FnPtr>(S, OpPC, A0);
11413
0
}
11414
0
bool EvalEmitter::emitGetThisFieldFloat(uint32_t A0, const SourceInfo &L) {
11415
0
  if (!isActive()) return true;
11416
0
  CurrentSource = L;
11417
0
  return GetThisField<PT_Float>(S, OpPC, A0);
11418
0
}
11419
#endif
11420
#ifdef GET_OPCODE_NAMES
11421
OP_IncSint8,
11422
OP_IncUint8,
11423
OP_IncSint16,
11424
OP_IncUint16,
11425
OP_IncSint32,
11426
OP_IncUint32,
11427
OP_IncSint64,
11428
OP_IncUint64,
11429
OP_IncIntAP,
11430
OP_IncIntAPS,
11431
#endif
11432
0
#ifdef GET_INTERP
11433
0
case OP_IncSint8: {
11434
0
  if (!Inc<PT_Sint8>(S, OpPC))
11435
0
    return false;
11436
0
  continue;
11437
0
}
11438
0
case OP_IncUint8: {
11439
0
  if (!Inc<PT_Uint8>(S, OpPC))
11440
0
    return false;
11441
0
  continue;
11442
0
}
11443
0
case OP_IncSint16: {
11444
0
  if (!Inc<PT_Sint16>(S, OpPC))
11445
0
    return false;
11446
0
  continue;
11447
0
}
11448
0
case OP_IncUint16: {
11449
0
  if (!Inc<PT_Uint16>(S, OpPC))
11450
0
    return false;
11451
0
  continue;
11452
0
}
11453
0
case OP_IncSint32: {
11454
0
  if (!Inc<PT_Sint32>(S, OpPC))
11455
0
    return false;
11456
0
  continue;
11457
0
}
11458
0
case OP_IncUint32: {
11459
0
  if (!Inc<PT_Uint32>(S, OpPC))
11460
0
    return false;
11461
0
  continue;
11462
0
}
11463
0
case OP_IncSint64: {
11464
0
  if (!Inc<PT_Sint64>(S, OpPC))
11465
0
    return false;
11466
0
  continue;
11467
0
}
11468
0
case OP_IncUint64: {
11469
0
  if (!Inc<PT_Uint64>(S, OpPC))
11470
0
    return false;
11471
0
  continue;
11472
0
}
11473
0
case OP_IncIntAP: {
11474
0
  if (!Inc<PT_IntAP>(S, OpPC))
11475
0
    return false;
11476
0
  continue;
11477
0
}
11478
0
case OP_IncIntAPS: {
11479
0
  if (!Inc<PT_IntAPS>(S, OpPC))
11480
0
    return false;
11481
0
  continue;
11482
0
}
11483
0
#endif
11484
#ifdef GET_DISASM
11485
case OP_IncSint8:
11486
  PrintName("IncSint8");
11487
  OS << "\t" << "\n";
11488
  continue;
11489
case OP_IncUint8:
11490
  PrintName("IncUint8");
11491
  OS << "\t" << "\n";
11492
  continue;
11493
case OP_IncSint16:
11494
  PrintName("IncSint16");
11495
  OS << "\t" << "\n";
11496
  continue;
11497
case OP_IncUint16:
11498
  PrintName("IncUint16");
11499
  OS << "\t" << "\n";
11500
  continue;
11501
case OP_IncSint32:
11502
  PrintName("IncSint32");
11503
  OS << "\t" << "\n";
11504
  continue;
11505
case OP_IncUint32:
11506
  PrintName("IncUint32");
11507
  OS << "\t" << "\n";
11508
  continue;
11509
case OP_IncSint64:
11510
  PrintName("IncSint64");
11511
  OS << "\t" << "\n";
11512
  continue;
11513
case OP_IncUint64:
11514
  PrintName("IncUint64");
11515
  OS << "\t" << "\n";
11516
  continue;
11517
case OP_IncIntAP:
11518
  PrintName("IncIntAP");
11519
  OS << "\t" << "\n";
11520
  continue;
11521
case OP_IncIntAPS:
11522
  PrintName("IncIntAPS");
11523
  OS << "\t" << "\n";
11524
  continue;
11525
#endif
11526
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11527
bool emitIncSint8(const SourceInfo &);
11528
bool emitIncUint8(const SourceInfo &);
11529
bool emitIncSint16(const SourceInfo &);
11530
bool emitIncUint16(const SourceInfo &);
11531
bool emitIncSint32(const SourceInfo &);
11532
bool emitIncUint32(const SourceInfo &);
11533
bool emitIncSint64(const SourceInfo &);
11534
bool emitIncUint64(const SourceInfo &);
11535
bool emitIncIntAP(const SourceInfo &);
11536
bool emitIncIntAPS(const SourceInfo &);
11537
#endif
11538
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11539
bool emitInc(PrimType, const SourceInfo &I);
11540
#endif
11541
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
11542
bool
11543
#if defined(GET_EVAL_IMPL)
11544
EvalEmitter
11545
#else
11546
ByteCodeEmitter
11547
#endif
11548
0
::emitInc(PrimType T0, const SourceInfo &I) {
11549
0
  switch (T0) {
11550
0
  case PT_Sint8:
11551
0
    return emitIncSint8(I);
11552
0
  case PT_Uint8:
11553
0
    return emitIncUint8(I);
11554
0
  case PT_Sint16:
11555
0
    return emitIncSint16(I);
11556
0
  case PT_Uint16:
11557
0
    return emitIncUint16(I);
11558
0
  case PT_Sint32:
11559
0
    return emitIncSint32(I);
11560
0
  case PT_Uint32:
11561
0
    return emitIncUint32(I);
11562
0
  case PT_Sint64:
11563
0
    return emitIncSint64(I);
11564
0
  case PT_Uint64:
11565
0
    return emitIncUint64(I);
11566
0
  case PT_IntAP:
11567
0
    return emitIncIntAP(I);
11568
0
  case PT_IntAPS:
11569
0
    return emitIncIntAPS(I);
11570
0
  default: llvm_unreachable("invalid type: emitInc");
11571
0
  }
11572
0
  llvm_unreachable("invalid enum value");
11573
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInc(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInc(clang::interp::PrimType, clang::interp::SourceInfo const&)
11574
#endif
11575
#ifdef GET_LINK_IMPL
11576
0
bool ByteCodeEmitter::emitIncSint8(const SourceInfo &L) {
11577
0
  return emitOp<>(OP_IncSint8, L);
11578
0
}
11579
0
bool ByteCodeEmitter::emitIncUint8(const SourceInfo &L) {
11580
0
  return emitOp<>(OP_IncUint8, L);
11581
0
}
11582
0
bool ByteCodeEmitter::emitIncSint16(const SourceInfo &L) {
11583
0
  return emitOp<>(OP_IncSint16, L);
11584
0
}
11585
0
bool ByteCodeEmitter::emitIncUint16(const SourceInfo &L) {
11586
0
  return emitOp<>(OP_IncUint16, L);
11587
0
}
11588
0
bool ByteCodeEmitter::emitIncSint32(const SourceInfo &L) {
11589
0
  return emitOp<>(OP_IncSint32, L);
11590
0
}
11591
0
bool ByteCodeEmitter::emitIncUint32(const SourceInfo &L) {
11592
0
  return emitOp<>(OP_IncUint32, L);
11593
0
}
11594
0
bool ByteCodeEmitter::emitIncSint64(const SourceInfo &L) {
11595
0
  return emitOp<>(OP_IncSint64, L);
11596
0
}
11597
0
bool ByteCodeEmitter::emitIncUint64(const SourceInfo &L) {
11598
0
  return emitOp<>(OP_IncUint64, L);
11599
0
}
11600
0
bool ByteCodeEmitter::emitIncIntAP(const SourceInfo &L) {
11601
0
  return emitOp<>(OP_IncIntAP, L);
11602
0
}
11603
0
bool ByteCodeEmitter::emitIncIntAPS(const SourceInfo &L) {
11604
0
  return emitOp<>(OP_IncIntAPS, L);
11605
0
}
11606
#endif
11607
#ifdef GET_EVAL_IMPL
11608
0
bool EvalEmitter::emitIncSint8(const SourceInfo &L) {
11609
0
  if (!isActive()) return true;
11610
0
  CurrentSource = L;
11611
0
  return Inc<PT_Sint8>(S, OpPC);
11612
0
}
11613
0
bool EvalEmitter::emitIncUint8(const SourceInfo &L) {
11614
0
  if (!isActive()) return true;
11615
0
  CurrentSource = L;
11616
0
  return Inc<PT_Uint8>(S, OpPC);
11617
0
}
11618
0
bool EvalEmitter::emitIncSint16(const SourceInfo &L) {
11619
0
  if (!isActive()) return true;
11620
0
  CurrentSource = L;
11621
0
  return Inc<PT_Sint16>(S, OpPC);
11622
0
}
11623
0
bool EvalEmitter::emitIncUint16(const SourceInfo &L) {
11624
0
  if (!isActive()) return true;
11625
0
  CurrentSource = L;
11626
0
  return Inc<PT_Uint16>(S, OpPC);
11627
0
}
11628
0
bool EvalEmitter::emitIncSint32(const SourceInfo &L) {
11629
0
  if (!isActive()) return true;
11630
0
  CurrentSource = L;
11631
0
  return Inc<PT_Sint32>(S, OpPC);
11632
0
}
11633
0
bool EvalEmitter::emitIncUint32(const SourceInfo &L) {
11634
0
  if (!isActive()) return true;
11635
0
  CurrentSource = L;
11636
0
  return Inc<PT_Uint32>(S, OpPC);
11637
0
}
11638
0
bool EvalEmitter::emitIncSint64(const SourceInfo &L) {
11639
0
  if (!isActive()) return true;
11640
0
  CurrentSource = L;
11641
0
  return Inc<PT_Sint64>(S, OpPC);
11642
0
}
11643
0
bool EvalEmitter::emitIncUint64(const SourceInfo &L) {
11644
0
  if (!isActive()) return true;
11645
0
  CurrentSource = L;
11646
0
  return Inc<PT_Uint64>(S, OpPC);
11647
0
}
11648
0
bool EvalEmitter::emitIncIntAP(const SourceInfo &L) {
11649
0
  if (!isActive()) return true;
11650
0
  CurrentSource = L;
11651
0
  return Inc<PT_IntAP>(S, OpPC);
11652
0
}
11653
0
bool EvalEmitter::emitIncIntAPS(const SourceInfo &L) {
11654
0
  if (!isActive()) return true;
11655
0
  CurrentSource = L;
11656
0
  return Inc<PT_IntAPS>(S, OpPC);
11657
0
}
11658
#endif
11659
#ifdef GET_OPCODE_NAMES
11660
OP_IncPopSint8,
11661
OP_IncPopUint8,
11662
OP_IncPopSint16,
11663
OP_IncPopUint16,
11664
OP_IncPopSint32,
11665
OP_IncPopUint32,
11666
OP_IncPopSint64,
11667
OP_IncPopUint64,
11668
OP_IncPopIntAP,
11669
OP_IncPopIntAPS,
11670
#endif
11671
0
#ifdef GET_INTERP
11672
0
case OP_IncPopSint8: {
11673
0
  if (!IncPop<PT_Sint8>(S, OpPC))
11674
0
    return false;
11675
0
  continue;
11676
0
}
11677
0
case OP_IncPopUint8: {
11678
0
  if (!IncPop<PT_Uint8>(S, OpPC))
11679
0
    return false;
11680
0
  continue;
11681
0
}
11682
0
case OP_IncPopSint16: {
11683
0
  if (!IncPop<PT_Sint16>(S, OpPC))
11684
0
    return false;
11685
0
  continue;
11686
0
}
11687
0
case OP_IncPopUint16: {
11688
0
  if (!IncPop<PT_Uint16>(S, OpPC))
11689
0
    return false;
11690
0
  continue;
11691
0
}
11692
0
case OP_IncPopSint32: {
11693
0
  if (!IncPop<PT_Sint32>(S, OpPC))
11694
0
    return false;
11695
0
  continue;
11696
0
}
11697
0
case OP_IncPopUint32: {
11698
0
  if (!IncPop<PT_Uint32>(S, OpPC))
11699
0
    return false;
11700
0
  continue;
11701
0
}
11702
0
case OP_IncPopSint64: {
11703
0
  if (!IncPop<PT_Sint64>(S, OpPC))
11704
0
    return false;
11705
0
  continue;
11706
0
}
11707
0
case OP_IncPopUint64: {
11708
0
  if (!IncPop<PT_Uint64>(S, OpPC))
11709
0
    return false;
11710
0
  continue;
11711
0
}
11712
0
case OP_IncPopIntAP: {
11713
0
  if (!IncPop<PT_IntAP>(S, OpPC))
11714
0
    return false;
11715
0
  continue;
11716
0
}
11717
0
case OP_IncPopIntAPS: {
11718
0
  if (!IncPop<PT_IntAPS>(S, OpPC))
11719
0
    return false;
11720
0
  continue;
11721
0
}
11722
0
#endif
11723
#ifdef GET_DISASM
11724
case OP_IncPopSint8:
11725
  PrintName("IncPopSint8");
11726
  OS << "\t" << "\n";
11727
  continue;
11728
case OP_IncPopUint8:
11729
  PrintName("IncPopUint8");
11730
  OS << "\t" << "\n";
11731
  continue;
11732
case OP_IncPopSint16:
11733
  PrintName("IncPopSint16");
11734
  OS << "\t" << "\n";
11735
  continue;
11736
case OP_IncPopUint16:
11737
  PrintName("IncPopUint16");
11738
  OS << "\t" << "\n";
11739
  continue;
11740
case OP_IncPopSint32:
11741
  PrintName("IncPopSint32");
11742
  OS << "\t" << "\n";
11743
  continue;
11744
case OP_IncPopUint32:
11745
  PrintName("IncPopUint32");
11746
  OS << "\t" << "\n";
11747
  continue;
11748
case OP_IncPopSint64:
11749
  PrintName("IncPopSint64");
11750
  OS << "\t" << "\n";
11751
  continue;
11752
case OP_IncPopUint64:
11753
  PrintName("IncPopUint64");
11754
  OS << "\t" << "\n";
11755
  continue;
11756
case OP_IncPopIntAP:
11757
  PrintName("IncPopIntAP");
11758
  OS << "\t" << "\n";
11759
  continue;
11760
case OP_IncPopIntAPS:
11761
  PrintName("IncPopIntAPS");
11762
  OS << "\t" << "\n";
11763
  continue;
11764
#endif
11765
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11766
bool emitIncPopSint8(const SourceInfo &);
11767
bool emitIncPopUint8(const SourceInfo &);
11768
bool emitIncPopSint16(const SourceInfo &);
11769
bool emitIncPopUint16(const SourceInfo &);
11770
bool emitIncPopSint32(const SourceInfo &);
11771
bool emitIncPopUint32(const SourceInfo &);
11772
bool emitIncPopSint64(const SourceInfo &);
11773
bool emitIncPopUint64(const SourceInfo &);
11774
bool emitIncPopIntAP(const SourceInfo &);
11775
bool emitIncPopIntAPS(const SourceInfo &);
11776
#endif
11777
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11778
bool emitIncPop(PrimType, const SourceInfo &I);
11779
#endif
11780
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
11781
bool
11782
#if defined(GET_EVAL_IMPL)
11783
EvalEmitter
11784
#else
11785
ByteCodeEmitter
11786
#endif
11787
0
::emitIncPop(PrimType T0, const SourceInfo &I) {
11788
0
  switch (T0) {
11789
0
  case PT_Sint8:
11790
0
    return emitIncPopSint8(I);
11791
0
  case PT_Uint8:
11792
0
    return emitIncPopUint8(I);
11793
0
  case PT_Sint16:
11794
0
    return emitIncPopSint16(I);
11795
0
  case PT_Uint16:
11796
0
    return emitIncPopUint16(I);
11797
0
  case PT_Sint32:
11798
0
    return emitIncPopSint32(I);
11799
0
  case PT_Uint32:
11800
0
    return emitIncPopUint32(I);
11801
0
  case PT_Sint64:
11802
0
    return emitIncPopSint64(I);
11803
0
  case PT_Uint64:
11804
0
    return emitIncPopUint64(I);
11805
0
  case PT_IntAP:
11806
0
    return emitIncPopIntAP(I);
11807
0
  case PT_IntAPS:
11808
0
    return emitIncPopIntAPS(I);
11809
0
  default: llvm_unreachable("invalid type: emitIncPop");
11810
0
  }
11811
0
  llvm_unreachable("invalid enum value");
11812
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitIncPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitIncPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
11813
#endif
11814
#ifdef GET_LINK_IMPL
11815
0
bool ByteCodeEmitter::emitIncPopSint8(const SourceInfo &L) {
11816
0
  return emitOp<>(OP_IncPopSint8, L);
11817
0
}
11818
0
bool ByteCodeEmitter::emitIncPopUint8(const SourceInfo &L) {
11819
0
  return emitOp<>(OP_IncPopUint8, L);
11820
0
}
11821
0
bool ByteCodeEmitter::emitIncPopSint16(const SourceInfo &L) {
11822
0
  return emitOp<>(OP_IncPopSint16, L);
11823
0
}
11824
0
bool ByteCodeEmitter::emitIncPopUint16(const SourceInfo &L) {
11825
0
  return emitOp<>(OP_IncPopUint16, L);
11826
0
}
11827
0
bool ByteCodeEmitter::emitIncPopSint32(const SourceInfo &L) {
11828
0
  return emitOp<>(OP_IncPopSint32, L);
11829
0
}
11830
0
bool ByteCodeEmitter::emitIncPopUint32(const SourceInfo &L) {
11831
0
  return emitOp<>(OP_IncPopUint32, L);
11832
0
}
11833
0
bool ByteCodeEmitter::emitIncPopSint64(const SourceInfo &L) {
11834
0
  return emitOp<>(OP_IncPopSint64, L);
11835
0
}
11836
0
bool ByteCodeEmitter::emitIncPopUint64(const SourceInfo &L) {
11837
0
  return emitOp<>(OP_IncPopUint64, L);
11838
0
}
11839
0
bool ByteCodeEmitter::emitIncPopIntAP(const SourceInfo &L) {
11840
0
  return emitOp<>(OP_IncPopIntAP, L);
11841
0
}
11842
0
bool ByteCodeEmitter::emitIncPopIntAPS(const SourceInfo &L) {
11843
0
  return emitOp<>(OP_IncPopIntAPS, L);
11844
0
}
11845
#endif
11846
#ifdef GET_EVAL_IMPL
11847
0
bool EvalEmitter::emitIncPopSint8(const SourceInfo &L) {
11848
0
  if (!isActive()) return true;
11849
0
  CurrentSource = L;
11850
0
  return IncPop<PT_Sint8>(S, OpPC);
11851
0
}
11852
0
bool EvalEmitter::emitIncPopUint8(const SourceInfo &L) {
11853
0
  if (!isActive()) return true;
11854
0
  CurrentSource = L;
11855
0
  return IncPop<PT_Uint8>(S, OpPC);
11856
0
}
11857
0
bool EvalEmitter::emitIncPopSint16(const SourceInfo &L) {
11858
0
  if (!isActive()) return true;
11859
0
  CurrentSource = L;
11860
0
  return IncPop<PT_Sint16>(S, OpPC);
11861
0
}
11862
0
bool EvalEmitter::emitIncPopUint16(const SourceInfo &L) {
11863
0
  if (!isActive()) return true;
11864
0
  CurrentSource = L;
11865
0
  return IncPop<PT_Uint16>(S, OpPC);
11866
0
}
11867
0
bool EvalEmitter::emitIncPopSint32(const SourceInfo &L) {
11868
0
  if (!isActive()) return true;
11869
0
  CurrentSource = L;
11870
0
  return IncPop<PT_Sint32>(S, OpPC);
11871
0
}
11872
0
bool EvalEmitter::emitIncPopUint32(const SourceInfo &L) {
11873
0
  if (!isActive()) return true;
11874
0
  CurrentSource = L;
11875
0
  return IncPop<PT_Uint32>(S, OpPC);
11876
0
}
11877
0
bool EvalEmitter::emitIncPopSint64(const SourceInfo &L) {
11878
0
  if (!isActive()) return true;
11879
0
  CurrentSource = L;
11880
0
  return IncPop<PT_Sint64>(S, OpPC);
11881
0
}
11882
0
bool EvalEmitter::emitIncPopUint64(const SourceInfo &L) {
11883
0
  if (!isActive()) return true;
11884
0
  CurrentSource = L;
11885
0
  return IncPop<PT_Uint64>(S, OpPC);
11886
0
}
11887
0
bool EvalEmitter::emitIncPopIntAP(const SourceInfo &L) {
11888
0
  if (!isActive()) return true;
11889
0
  CurrentSource = L;
11890
0
  return IncPop<PT_IntAP>(S, OpPC);
11891
0
}
11892
0
bool EvalEmitter::emitIncPopIntAPS(const SourceInfo &L) {
11893
0
  if (!isActive()) return true;
11894
0
  CurrentSource = L;
11895
0
  return IncPop<PT_IntAPS>(S, OpPC);
11896
0
}
11897
#endif
11898
#ifdef GET_OPCODE_NAMES
11899
OP_IncPtr,
11900
#endif
11901
0
#ifdef GET_INTERP
11902
0
case OP_IncPtr: {
11903
0
  if (!IncPtr(S, OpPC))
11904
0
    return false;
11905
0
  continue;
11906
0
}
11907
0
#endif
11908
#ifdef GET_DISASM
11909
case OP_IncPtr:
11910
  PrintName("IncPtr");
11911
  OS << "\t" << "\n";
11912
  continue;
11913
#endif
11914
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11915
bool emitIncPtr(const SourceInfo &);
11916
#endif
11917
#ifdef GET_LINK_IMPL
11918
0
bool ByteCodeEmitter::emitIncPtr(const SourceInfo &L) {
11919
0
  return emitOp<>(OP_IncPtr, L);
11920
0
}
11921
#endif
11922
#ifdef GET_EVAL_IMPL
11923
0
bool EvalEmitter::emitIncPtr(const SourceInfo &L) {
11924
0
  if (!isActive()) return true;
11925
0
  CurrentSource = L;
11926
0
  return IncPtr(S, OpPC);
11927
0
}
11928
#endif
11929
#ifdef GET_OPCODE_NAMES
11930
OP_Incf,
11931
#endif
11932
0
#ifdef GET_INTERP
11933
0
case OP_Incf: {
11934
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
11935
0
  if (!Incf(S, OpPC, V0))
11936
0
    return false;
11937
0
  continue;
11938
0
}
11939
0
#endif
11940
#ifdef GET_DISASM
11941
case OP_Incf:
11942
  PrintName("Incf");
11943
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
11944
  continue;
11945
#endif
11946
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11947
bool emitIncf(llvm::RoundingMode, const SourceInfo &);
11948
#endif
11949
#ifdef GET_LINK_IMPL
11950
0
bool ByteCodeEmitter::emitIncf(llvm::RoundingMode A0, const SourceInfo &L) {
11951
0
  return emitOp<llvm::RoundingMode>(OP_Incf, A0, L);
11952
0
}
11953
#endif
11954
#ifdef GET_EVAL_IMPL
11955
0
bool EvalEmitter::emitIncf(llvm::RoundingMode A0, const SourceInfo &L) {
11956
0
  if (!isActive()) return true;
11957
0
  CurrentSource = L;
11958
0
  return Incf(S, OpPC, A0);
11959
0
}
11960
#endif
11961
#ifdef GET_OPCODE_NAMES
11962
OP_IncfPop,
11963
#endif
11964
0
#ifdef GET_INTERP
11965
0
case OP_IncfPop: {
11966
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
11967
0
  if (!IncfPop(S, OpPC, V0))
11968
0
    return false;
11969
0
  continue;
11970
0
}
11971
0
#endif
11972
#ifdef GET_DISASM
11973
case OP_IncfPop:
11974
  PrintName("IncfPop");
11975
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
11976
  continue;
11977
#endif
11978
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11979
bool emitIncfPop(llvm::RoundingMode, const SourceInfo &);
11980
#endif
11981
#ifdef GET_LINK_IMPL
11982
0
bool ByteCodeEmitter::emitIncfPop(llvm::RoundingMode A0, const SourceInfo &L) {
11983
0
  return emitOp<llvm::RoundingMode>(OP_IncfPop, A0, L);
11984
0
}
11985
#endif
11986
#ifdef GET_EVAL_IMPL
11987
0
bool EvalEmitter::emitIncfPop(llvm::RoundingMode A0, const SourceInfo &L) {
11988
0
  if (!isActive()) return true;
11989
0
  CurrentSource = L;
11990
0
  return IncfPop(S, OpPC, A0);
11991
0
}
11992
#endif
11993
#ifdef GET_OPCODE_NAMES
11994
OP_InitBitFieldSint8,
11995
OP_InitBitFieldUint8,
11996
OP_InitBitFieldSint16,
11997
OP_InitBitFieldUint16,
11998
OP_InitBitFieldSint32,
11999
OP_InitBitFieldUint32,
12000
OP_InitBitFieldSint64,
12001
OP_InitBitFieldUint64,
12002
OP_InitBitFieldIntAP,
12003
OP_InitBitFieldIntAPS,
12004
OP_InitBitFieldBool,
12005
#endif
12006
0
#ifdef GET_INTERP
12007
0
case OP_InitBitFieldSint8: {
12008
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12009
0
  if (!InitBitField<PT_Sint8>(S, OpPC, V0))
12010
0
    return false;
12011
0
  continue;
12012
0
}
12013
0
case OP_InitBitFieldUint8: {
12014
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12015
0
  if (!InitBitField<PT_Uint8>(S, OpPC, V0))
12016
0
    return false;
12017
0
  continue;
12018
0
}
12019
0
case OP_InitBitFieldSint16: {
12020
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12021
0
  if (!InitBitField<PT_Sint16>(S, OpPC, V0))
12022
0
    return false;
12023
0
  continue;
12024
0
}
12025
0
case OP_InitBitFieldUint16: {
12026
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12027
0
  if (!InitBitField<PT_Uint16>(S, OpPC, V0))
12028
0
    return false;
12029
0
  continue;
12030
0
}
12031
0
case OP_InitBitFieldSint32: {
12032
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12033
0
  if (!InitBitField<PT_Sint32>(S, OpPC, V0))
12034
0
    return false;
12035
0
  continue;
12036
0
}
12037
0
case OP_InitBitFieldUint32: {
12038
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12039
0
  if (!InitBitField<PT_Uint32>(S, OpPC, V0))
12040
0
    return false;
12041
0
  continue;
12042
0
}
12043
0
case OP_InitBitFieldSint64: {
12044
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12045
0
  if (!InitBitField<PT_Sint64>(S, OpPC, V0))
12046
0
    return false;
12047
0
  continue;
12048
0
}
12049
0
case OP_InitBitFieldUint64: {
12050
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12051
0
  if (!InitBitField<PT_Uint64>(S, OpPC, V0))
12052
0
    return false;
12053
0
  continue;
12054
0
}
12055
0
case OP_InitBitFieldIntAP: {
12056
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12057
0
  if (!InitBitField<PT_IntAP>(S, OpPC, V0))
12058
0
    return false;
12059
0
  continue;
12060
0
}
12061
0
case OP_InitBitFieldIntAPS: {
12062
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12063
0
  if (!InitBitField<PT_IntAPS>(S, OpPC, V0))
12064
0
    return false;
12065
0
  continue;
12066
0
}
12067
0
case OP_InitBitFieldBool: {
12068
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
12069
0
  if (!InitBitField<PT_Bool>(S, OpPC, V0))
12070
0
    return false;
12071
0
  continue;
12072
0
}
12073
0
#endif
12074
#ifdef GET_DISASM
12075
case OP_InitBitFieldSint8:
12076
  PrintName("InitBitFieldSint8");
12077
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12078
  continue;
12079
case OP_InitBitFieldUint8:
12080
  PrintName("InitBitFieldUint8");
12081
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12082
  continue;
12083
case OP_InitBitFieldSint16:
12084
  PrintName("InitBitFieldSint16");
12085
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12086
  continue;
12087
case OP_InitBitFieldUint16:
12088
  PrintName("InitBitFieldUint16");
12089
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12090
  continue;
12091
case OP_InitBitFieldSint32:
12092
  PrintName("InitBitFieldSint32");
12093
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12094
  continue;
12095
case OP_InitBitFieldUint32:
12096
  PrintName("InitBitFieldUint32");
12097
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12098
  continue;
12099
case OP_InitBitFieldSint64:
12100
  PrintName("InitBitFieldSint64");
12101
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12102
  continue;
12103
case OP_InitBitFieldUint64:
12104
  PrintName("InitBitFieldUint64");
12105
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12106
  continue;
12107
case OP_InitBitFieldIntAP:
12108
  PrintName("InitBitFieldIntAP");
12109
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12110
  continue;
12111
case OP_InitBitFieldIntAPS:
12112
  PrintName("InitBitFieldIntAPS");
12113
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12114
  continue;
12115
case OP_InitBitFieldBool:
12116
  PrintName("InitBitFieldBool");
12117
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
12118
  continue;
12119
#endif
12120
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12121
bool emitInitBitFieldSint8(const Record::Field *, const SourceInfo &);
12122
bool emitInitBitFieldUint8(const Record::Field *, const SourceInfo &);
12123
bool emitInitBitFieldSint16(const Record::Field *, const SourceInfo &);
12124
bool emitInitBitFieldUint16(const Record::Field *, const SourceInfo &);
12125
bool emitInitBitFieldSint32(const Record::Field *, const SourceInfo &);
12126
bool emitInitBitFieldUint32(const Record::Field *, const SourceInfo &);
12127
bool emitInitBitFieldSint64(const Record::Field *, const SourceInfo &);
12128
bool emitInitBitFieldUint64(const Record::Field *, const SourceInfo &);
12129
bool emitInitBitFieldIntAP(const Record::Field *, const SourceInfo &);
12130
bool emitInitBitFieldIntAPS(const Record::Field *, const SourceInfo &);
12131
bool emitInitBitFieldBool(const Record::Field *, const SourceInfo &);
12132
#endif
12133
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12134
bool emitInitBitField(PrimType, const Record::Field *, const SourceInfo &I);
12135
#endif
12136
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
12137
bool
12138
#if defined(GET_EVAL_IMPL)
12139
EvalEmitter
12140
#else
12141
ByteCodeEmitter
12142
#endif
12143
0
::emitInitBitField(PrimType T0, const Record::Field * A0, const SourceInfo &I) {
12144
0
  switch (T0) {
12145
0
  case PT_Sint8:
12146
0
    return emitInitBitFieldSint8(A0, I);
12147
0
  case PT_Uint8:
12148
0
    return emitInitBitFieldUint8(A0, I);
12149
0
  case PT_Sint16:
12150
0
    return emitInitBitFieldSint16(A0, I);
12151
0
  case PT_Uint16:
12152
0
    return emitInitBitFieldUint16(A0, I);
12153
0
  case PT_Sint32:
12154
0
    return emitInitBitFieldSint32(A0, I);
12155
0
  case PT_Uint32:
12156
0
    return emitInitBitFieldUint32(A0, I);
12157
0
  case PT_Sint64:
12158
0
    return emitInitBitFieldSint64(A0, I);
12159
0
  case PT_Uint64:
12160
0
    return emitInitBitFieldUint64(A0, I);
12161
0
  case PT_IntAP:
12162
0
    return emitInitBitFieldIntAP(A0, I);
12163
0
  case PT_IntAPS:
12164
0
    return emitInitBitFieldIntAPS(A0, I);
12165
0
  case PT_Bool:
12166
0
    return emitInitBitFieldBool(A0, I);
12167
0
  default: llvm_unreachable("invalid type: emitInitBitField");
12168
0
  }
12169
0
  llvm_unreachable("invalid enum value");
12170
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitBitField(clang::interp::PrimType, clang::interp::Record::Field const*, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitBitField(clang::interp::PrimType, clang::interp::Record::Field const*, clang::interp::SourceInfo const&)
12171
#endif
12172
#ifdef GET_LINK_IMPL
12173
0
bool ByteCodeEmitter::emitInitBitFieldSint8(const Record::Field * A0, const SourceInfo &L) {
12174
0
  return emitOp<const Record::Field *>(OP_InitBitFieldSint8, A0, L);
12175
0
}
12176
0
bool ByteCodeEmitter::emitInitBitFieldUint8(const Record::Field * A0, const SourceInfo &L) {
12177
0
  return emitOp<const Record::Field *>(OP_InitBitFieldUint8, A0, L);
12178
0
}
12179
0
bool ByteCodeEmitter::emitInitBitFieldSint16(const Record::Field * A0, const SourceInfo &L) {
12180
0
  return emitOp<const Record::Field *>(OP_InitBitFieldSint16, A0, L);
12181
0
}
12182
0
bool ByteCodeEmitter::emitInitBitFieldUint16(const Record::Field * A0, const SourceInfo &L) {
12183
0
  return emitOp<const Record::Field *>(OP_InitBitFieldUint16, A0, L);
12184
0
}
12185
0
bool ByteCodeEmitter::emitInitBitFieldSint32(const Record::Field * A0, const SourceInfo &L) {
12186
0
  return emitOp<const Record::Field *>(OP_InitBitFieldSint32, A0, L);
12187
0
}
12188
0
bool ByteCodeEmitter::emitInitBitFieldUint32(const Record::Field * A0, const SourceInfo &L) {
12189
0
  return emitOp<const Record::Field *>(OP_InitBitFieldUint32, A0, L);
12190
0
}
12191
0
bool ByteCodeEmitter::emitInitBitFieldSint64(const Record::Field * A0, const SourceInfo &L) {
12192
0
  return emitOp<const Record::Field *>(OP_InitBitFieldSint64, A0, L);
12193
0
}
12194
0
bool ByteCodeEmitter::emitInitBitFieldUint64(const Record::Field * A0, const SourceInfo &L) {
12195
0
  return emitOp<const Record::Field *>(OP_InitBitFieldUint64, A0, L);
12196
0
}
12197
0
bool ByteCodeEmitter::emitInitBitFieldIntAP(const Record::Field * A0, const SourceInfo &L) {
12198
0
  return emitOp<const Record::Field *>(OP_InitBitFieldIntAP, A0, L);
12199
0
}
12200
0
bool ByteCodeEmitter::emitInitBitFieldIntAPS(const Record::Field * A0, const SourceInfo &L) {
12201
0
  return emitOp<const Record::Field *>(OP_InitBitFieldIntAPS, A0, L);
12202
0
}
12203
0
bool ByteCodeEmitter::emitInitBitFieldBool(const Record::Field * A0, const SourceInfo &L) {
12204
0
  return emitOp<const Record::Field *>(OP_InitBitFieldBool, A0, L);
12205
0
}
12206
#endif
12207
#ifdef GET_EVAL_IMPL
12208
0
bool EvalEmitter::emitInitBitFieldSint8(const Record::Field * A0, const SourceInfo &L) {
12209
0
  if (!isActive()) return true;
12210
0
  CurrentSource = L;
12211
0
  return InitBitField<PT_Sint8>(S, OpPC, A0);
12212
0
}
12213
0
bool EvalEmitter::emitInitBitFieldUint8(const Record::Field * A0, const SourceInfo &L) {
12214
0
  if (!isActive()) return true;
12215
0
  CurrentSource = L;
12216
0
  return InitBitField<PT_Uint8>(S, OpPC, A0);
12217
0
}
12218
0
bool EvalEmitter::emitInitBitFieldSint16(const Record::Field * A0, const SourceInfo &L) {
12219
0
  if (!isActive()) return true;
12220
0
  CurrentSource = L;
12221
0
  return InitBitField<PT_Sint16>(S, OpPC, A0);
12222
0
}
12223
0
bool EvalEmitter::emitInitBitFieldUint16(const Record::Field * A0, const SourceInfo &L) {
12224
0
  if (!isActive()) return true;
12225
0
  CurrentSource = L;
12226
0
  return InitBitField<PT_Uint16>(S, OpPC, A0);
12227
0
}
12228
0
bool EvalEmitter::emitInitBitFieldSint32(const Record::Field * A0, const SourceInfo &L) {
12229
0
  if (!isActive()) return true;
12230
0
  CurrentSource = L;
12231
0
  return InitBitField<PT_Sint32>(S, OpPC, A0);
12232
0
}
12233
0
bool EvalEmitter::emitInitBitFieldUint32(const Record::Field * A0, const SourceInfo &L) {
12234
0
  if (!isActive()) return true;
12235
0
  CurrentSource = L;
12236
0
  return InitBitField<PT_Uint32>(S, OpPC, A0);
12237
0
}
12238
0
bool EvalEmitter::emitInitBitFieldSint64(const Record::Field * A0, const SourceInfo &L) {
12239
0
  if (!isActive()) return true;
12240
0
  CurrentSource = L;
12241
0
  return InitBitField<PT_Sint64>(S, OpPC, A0);
12242
0
}
12243
0
bool EvalEmitter::emitInitBitFieldUint64(const Record::Field * A0, const SourceInfo &L) {
12244
0
  if (!isActive()) return true;
12245
0
  CurrentSource = L;
12246
0
  return InitBitField<PT_Uint64>(S, OpPC, A0);
12247
0
}
12248
0
bool EvalEmitter::emitInitBitFieldIntAP(const Record::Field * A0, const SourceInfo &L) {
12249
0
  if (!isActive()) return true;
12250
0
  CurrentSource = L;
12251
0
  return InitBitField<PT_IntAP>(S, OpPC, A0);
12252
0
}
12253
0
bool EvalEmitter::emitInitBitFieldIntAPS(const Record::Field * A0, const SourceInfo &L) {
12254
0
  if (!isActive()) return true;
12255
0
  CurrentSource = L;
12256
0
  return InitBitField<PT_IntAPS>(S, OpPC, A0);
12257
0
}
12258
0
bool EvalEmitter::emitInitBitFieldBool(const Record::Field * A0, const SourceInfo &L) {
12259
0
  if (!isActive()) return true;
12260
0
  CurrentSource = L;
12261
0
  return InitBitField<PT_Bool>(S, OpPC, A0);
12262
0
}
12263
#endif
12264
#ifdef GET_OPCODE_NAMES
12265
OP_InitElemSint8,
12266
OP_InitElemUint8,
12267
OP_InitElemSint16,
12268
OP_InitElemUint16,
12269
OP_InitElemSint32,
12270
OP_InitElemUint32,
12271
OP_InitElemSint64,
12272
OP_InitElemUint64,
12273
OP_InitElemIntAP,
12274
OP_InitElemIntAPS,
12275
OP_InitElemBool,
12276
OP_InitElemPtr,
12277
OP_InitElemFnPtr,
12278
OP_InitElemFloat,
12279
#endif
12280
0
#ifdef GET_INTERP
12281
0
case OP_InitElemSint8: {
12282
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12283
0
  if (!InitElem<PT_Sint8>(S, OpPC, V0))
12284
0
    return false;
12285
0
  continue;
12286
0
}
12287
0
case OP_InitElemUint8: {
12288
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12289
0
  if (!InitElem<PT_Uint8>(S, OpPC, V0))
12290
0
    return false;
12291
0
  continue;
12292
0
}
12293
0
case OP_InitElemSint16: {
12294
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12295
0
  if (!InitElem<PT_Sint16>(S, OpPC, V0))
12296
0
    return false;
12297
0
  continue;
12298
0
}
12299
0
case OP_InitElemUint16: {
12300
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12301
0
  if (!InitElem<PT_Uint16>(S, OpPC, V0))
12302
0
    return false;
12303
0
  continue;
12304
0
}
12305
0
case OP_InitElemSint32: {
12306
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12307
0
  if (!InitElem<PT_Sint32>(S, OpPC, V0))
12308
0
    return false;
12309
0
  continue;
12310
0
}
12311
0
case OP_InitElemUint32: {
12312
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12313
0
  if (!InitElem<PT_Uint32>(S, OpPC, V0))
12314
0
    return false;
12315
0
  continue;
12316
0
}
12317
0
case OP_InitElemSint64: {
12318
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12319
0
  if (!InitElem<PT_Sint64>(S, OpPC, V0))
12320
0
    return false;
12321
0
  continue;
12322
0
}
12323
0
case OP_InitElemUint64: {
12324
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12325
0
  if (!InitElem<PT_Uint64>(S, OpPC, V0))
12326
0
    return false;
12327
0
  continue;
12328
0
}
12329
0
case OP_InitElemIntAP: {
12330
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12331
0
  if (!InitElem<PT_IntAP>(S, OpPC, V0))
12332
0
    return false;
12333
0
  continue;
12334
0
}
12335
0
case OP_InitElemIntAPS: {
12336
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12337
0
  if (!InitElem<PT_IntAPS>(S, OpPC, V0))
12338
0
    return false;
12339
0
  continue;
12340
0
}
12341
0
case OP_InitElemBool: {
12342
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12343
0
  if (!InitElem<PT_Bool>(S, OpPC, V0))
12344
0
    return false;
12345
0
  continue;
12346
0
}
12347
0
case OP_InitElemPtr: {
12348
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12349
0
  if (!InitElem<PT_Ptr>(S, OpPC, V0))
12350
0
    return false;
12351
0
  continue;
12352
0
}
12353
0
case OP_InitElemFnPtr: {
12354
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12355
0
  if (!InitElem<PT_FnPtr>(S, OpPC, V0))
12356
0
    return false;
12357
0
  continue;
12358
0
}
12359
0
case OP_InitElemFloat: {
12360
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12361
0
  if (!InitElem<PT_Float>(S, OpPC, V0))
12362
0
    return false;
12363
0
  continue;
12364
0
}
12365
0
#endif
12366
#ifdef GET_DISASM
12367
case OP_InitElemSint8:
12368
  PrintName("InitElemSint8");
12369
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12370
  continue;
12371
case OP_InitElemUint8:
12372
  PrintName("InitElemUint8");
12373
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12374
  continue;
12375
case OP_InitElemSint16:
12376
  PrintName("InitElemSint16");
12377
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12378
  continue;
12379
case OP_InitElemUint16:
12380
  PrintName("InitElemUint16");
12381
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12382
  continue;
12383
case OP_InitElemSint32:
12384
  PrintName("InitElemSint32");
12385
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12386
  continue;
12387
case OP_InitElemUint32:
12388
  PrintName("InitElemUint32");
12389
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12390
  continue;
12391
case OP_InitElemSint64:
12392
  PrintName("InitElemSint64");
12393
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12394
  continue;
12395
case OP_InitElemUint64:
12396
  PrintName("InitElemUint64");
12397
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12398
  continue;
12399
case OP_InitElemIntAP:
12400
  PrintName("InitElemIntAP");
12401
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12402
  continue;
12403
case OP_InitElemIntAPS:
12404
  PrintName("InitElemIntAPS");
12405
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12406
  continue;
12407
case OP_InitElemBool:
12408
  PrintName("InitElemBool");
12409
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12410
  continue;
12411
case OP_InitElemPtr:
12412
  PrintName("InitElemPtr");
12413
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12414
  continue;
12415
case OP_InitElemFnPtr:
12416
  PrintName("InitElemFnPtr");
12417
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12418
  continue;
12419
case OP_InitElemFloat:
12420
  PrintName("InitElemFloat");
12421
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12422
  continue;
12423
#endif
12424
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12425
bool emitInitElemSint8(uint32_t, const SourceInfo &);
12426
bool emitInitElemUint8(uint32_t, const SourceInfo &);
12427
bool emitInitElemSint16(uint32_t, const SourceInfo &);
12428
bool emitInitElemUint16(uint32_t, const SourceInfo &);
12429
bool emitInitElemSint32(uint32_t, const SourceInfo &);
12430
bool emitInitElemUint32(uint32_t, const SourceInfo &);
12431
bool emitInitElemSint64(uint32_t, const SourceInfo &);
12432
bool emitInitElemUint64(uint32_t, const SourceInfo &);
12433
bool emitInitElemIntAP(uint32_t, const SourceInfo &);
12434
bool emitInitElemIntAPS(uint32_t, const SourceInfo &);
12435
bool emitInitElemBool(uint32_t, const SourceInfo &);
12436
bool emitInitElemPtr(uint32_t, const SourceInfo &);
12437
bool emitInitElemFnPtr(uint32_t, const SourceInfo &);
12438
bool emitInitElemFloat(uint32_t, const SourceInfo &);
12439
#endif
12440
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12441
bool emitInitElem(PrimType, uint32_t, const SourceInfo &I);
12442
#endif
12443
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
12444
bool
12445
#if defined(GET_EVAL_IMPL)
12446
EvalEmitter
12447
#else
12448
ByteCodeEmitter
12449
#endif
12450
0
::emitInitElem(PrimType T0, uint32_t A0, const SourceInfo &I) {
12451
0
  switch (T0) {
12452
0
  case PT_Sint8:
12453
0
    return emitInitElemSint8(A0, I);
12454
0
  case PT_Uint8:
12455
0
    return emitInitElemUint8(A0, I);
12456
0
  case PT_Sint16:
12457
0
    return emitInitElemSint16(A0, I);
12458
0
  case PT_Uint16:
12459
0
    return emitInitElemUint16(A0, I);
12460
0
  case PT_Sint32:
12461
0
    return emitInitElemSint32(A0, I);
12462
0
  case PT_Uint32:
12463
0
    return emitInitElemUint32(A0, I);
12464
0
  case PT_Sint64:
12465
0
    return emitInitElemSint64(A0, I);
12466
0
  case PT_Uint64:
12467
0
    return emitInitElemUint64(A0, I);
12468
0
  case PT_IntAP:
12469
0
    return emitInitElemIntAP(A0, I);
12470
0
  case PT_IntAPS:
12471
0
    return emitInitElemIntAPS(A0, I);
12472
0
  case PT_Bool:
12473
0
    return emitInitElemBool(A0, I);
12474
0
  case PT_Ptr:
12475
0
    return emitInitElemPtr(A0, I);
12476
0
  case PT_FnPtr:
12477
0
    return emitInitElemFnPtr(A0, I);
12478
0
  case PT_Float:
12479
0
    return emitInitElemFloat(A0, I);
12480
0
  }
12481
0
  llvm_unreachable("invalid enum value");
12482
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitElem(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitElem(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
12483
#endif
12484
#ifdef GET_LINK_IMPL
12485
0
bool ByteCodeEmitter::emitInitElemSint8(uint32_t A0, const SourceInfo &L) {
12486
0
  return emitOp<uint32_t>(OP_InitElemSint8, A0, L);
12487
0
}
12488
0
bool ByteCodeEmitter::emitInitElemUint8(uint32_t A0, const SourceInfo &L) {
12489
0
  return emitOp<uint32_t>(OP_InitElemUint8, A0, L);
12490
0
}
12491
0
bool ByteCodeEmitter::emitInitElemSint16(uint32_t A0, const SourceInfo &L) {
12492
0
  return emitOp<uint32_t>(OP_InitElemSint16, A0, L);
12493
0
}
12494
0
bool ByteCodeEmitter::emitInitElemUint16(uint32_t A0, const SourceInfo &L) {
12495
0
  return emitOp<uint32_t>(OP_InitElemUint16, A0, L);
12496
0
}
12497
0
bool ByteCodeEmitter::emitInitElemSint32(uint32_t A0, const SourceInfo &L) {
12498
0
  return emitOp<uint32_t>(OP_InitElemSint32, A0, L);
12499
0
}
12500
0
bool ByteCodeEmitter::emitInitElemUint32(uint32_t A0, const SourceInfo &L) {
12501
0
  return emitOp<uint32_t>(OP_InitElemUint32, A0, L);
12502
0
}
12503
0
bool ByteCodeEmitter::emitInitElemSint64(uint32_t A0, const SourceInfo &L) {
12504
0
  return emitOp<uint32_t>(OP_InitElemSint64, A0, L);
12505
0
}
12506
0
bool ByteCodeEmitter::emitInitElemUint64(uint32_t A0, const SourceInfo &L) {
12507
0
  return emitOp<uint32_t>(OP_InitElemUint64, A0, L);
12508
0
}
12509
0
bool ByteCodeEmitter::emitInitElemIntAP(uint32_t A0, const SourceInfo &L) {
12510
0
  return emitOp<uint32_t>(OP_InitElemIntAP, A0, L);
12511
0
}
12512
0
bool ByteCodeEmitter::emitInitElemIntAPS(uint32_t A0, const SourceInfo &L) {
12513
0
  return emitOp<uint32_t>(OP_InitElemIntAPS, A0, L);
12514
0
}
12515
0
bool ByteCodeEmitter::emitInitElemBool(uint32_t A0, const SourceInfo &L) {
12516
0
  return emitOp<uint32_t>(OP_InitElemBool, A0, L);
12517
0
}
12518
0
bool ByteCodeEmitter::emitInitElemPtr(uint32_t A0, const SourceInfo &L) {
12519
0
  return emitOp<uint32_t>(OP_InitElemPtr, A0, L);
12520
0
}
12521
0
bool ByteCodeEmitter::emitInitElemFnPtr(uint32_t A0, const SourceInfo &L) {
12522
0
  return emitOp<uint32_t>(OP_InitElemFnPtr, A0, L);
12523
0
}
12524
0
bool ByteCodeEmitter::emitInitElemFloat(uint32_t A0, const SourceInfo &L) {
12525
0
  return emitOp<uint32_t>(OP_InitElemFloat, A0, L);
12526
0
}
12527
#endif
12528
#ifdef GET_EVAL_IMPL
12529
0
bool EvalEmitter::emitInitElemSint8(uint32_t A0, const SourceInfo &L) {
12530
0
  if (!isActive()) return true;
12531
0
  CurrentSource = L;
12532
0
  return InitElem<PT_Sint8>(S, OpPC, A0);
12533
0
}
12534
0
bool EvalEmitter::emitInitElemUint8(uint32_t A0, const SourceInfo &L) {
12535
0
  if (!isActive()) return true;
12536
0
  CurrentSource = L;
12537
0
  return InitElem<PT_Uint8>(S, OpPC, A0);
12538
0
}
12539
0
bool EvalEmitter::emitInitElemSint16(uint32_t A0, const SourceInfo &L) {
12540
0
  if (!isActive()) return true;
12541
0
  CurrentSource = L;
12542
0
  return InitElem<PT_Sint16>(S, OpPC, A0);
12543
0
}
12544
0
bool EvalEmitter::emitInitElemUint16(uint32_t A0, const SourceInfo &L) {
12545
0
  if (!isActive()) return true;
12546
0
  CurrentSource = L;
12547
0
  return InitElem<PT_Uint16>(S, OpPC, A0);
12548
0
}
12549
0
bool EvalEmitter::emitInitElemSint32(uint32_t A0, const SourceInfo &L) {
12550
0
  if (!isActive()) return true;
12551
0
  CurrentSource = L;
12552
0
  return InitElem<PT_Sint32>(S, OpPC, A0);
12553
0
}
12554
0
bool EvalEmitter::emitInitElemUint32(uint32_t A0, const SourceInfo &L) {
12555
0
  if (!isActive()) return true;
12556
0
  CurrentSource = L;
12557
0
  return InitElem<PT_Uint32>(S, OpPC, A0);
12558
0
}
12559
0
bool EvalEmitter::emitInitElemSint64(uint32_t A0, const SourceInfo &L) {
12560
0
  if (!isActive()) return true;
12561
0
  CurrentSource = L;
12562
0
  return InitElem<PT_Sint64>(S, OpPC, A0);
12563
0
}
12564
0
bool EvalEmitter::emitInitElemUint64(uint32_t A0, const SourceInfo &L) {
12565
0
  if (!isActive()) return true;
12566
0
  CurrentSource = L;
12567
0
  return InitElem<PT_Uint64>(S, OpPC, A0);
12568
0
}
12569
0
bool EvalEmitter::emitInitElemIntAP(uint32_t A0, const SourceInfo &L) {
12570
0
  if (!isActive()) return true;
12571
0
  CurrentSource = L;
12572
0
  return InitElem<PT_IntAP>(S, OpPC, A0);
12573
0
}
12574
0
bool EvalEmitter::emitInitElemIntAPS(uint32_t A0, const SourceInfo &L) {
12575
0
  if (!isActive()) return true;
12576
0
  CurrentSource = L;
12577
0
  return InitElem<PT_IntAPS>(S, OpPC, A0);
12578
0
}
12579
0
bool EvalEmitter::emitInitElemBool(uint32_t A0, const SourceInfo &L) {
12580
0
  if (!isActive()) return true;
12581
0
  CurrentSource = L;
12582
0
  return InitElem<PT_Bool>(S, OpPC, A0);
12583
0
}
12584
0
bool EvalEmitter::emitInitElemPtr(uint32_t A0, const SourceInfo &L) {
12585
0
  if (!isActive()) return true;
12586
0
  CurrentSource = L;
12587
0
  return InitElem<PT_Ptr>(S, OpPC, A0);
12588
0
}
12589
0
bool EvalEmitter::emitInitElemFnPtr(uint32_t A0, const SourceInfo &L) {
12590
0
  if (!isActive()) return true;
12591
0
  CurrentSource = L;
12592
0
  return InitElem<PT_FnPtr>(S, OpPC, A0);
12593
0
}
12594
0
bool EvalEmitter::emitInitElemFloat(uint32_t A0, const SourceInfo &L) {
12595
0
  if (!isActive()) return true;
12596
0
  CurrentSource = L;
12597
0
  return InitElem<PT_Float>(S, OpPC, A0);
12598
0
}
12599
#endif
12600
#ifdef GET_OPCODE_NAMES
12601
OP_InitElemPopSint8,
12602
OP_InitElemPopUint8,
12603
OP_InitElemPopSint16,
12604
OP_InitElemPopUint16,
12605
OP_InitElemPopSint32,
12606
OP_InitElemPopUint32,
12607
OP_InitElemPopSint64,
12608
OP_InitElemPopUint64,
12609
OP_InitElemPopIntAP,
12610
OP_InitElemPopIntAPS,
12611
OP_InitElemPopBool,
12612
OP_InitElemPopPtr,
12613
OP_InitElemPopFnPtr,
12614
OP_InitElemPopFloat,
12615
#endif
12616
0
#ifdef GET_INTERP
12617
0
case OP_InitElemPopSint8: {
12618
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12619
0
  if (!InitElemPop<PT_Sint8>(S, OpPC, V0))
12620
0
    return false;
12621
0
  continue;
12622
0
}
12623
0
case OP_InitElemPopUint8: {
12624
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12625
0
  if (!InitElemPop<PT_Uint8>(S, OpPC, V0))
12626
0
    return false;
12627
0
  continue;
12628
0
}
12629
0
case OP_InitElemPopSint16: {
12630
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12631
0
  if (!InitElemPop<PT_Sint16>(S, OpPC, V0))
12632
0
    return false;
12633
0
  continue;
12634
0
}
12635
0
case OP_InitElemPopUint16: {
12636
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12637
0
  if (!InitElemPop<PT_Uint16>(S, OpPC, V0))
12638
0
    return false;
12639
0
  continue;
12640
0
}
12641
0
case OP_InitElemPopSint32: {
12642
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12643
0
  if (!InitElemPop<PT_Sint32>(S, OpPC, V0))
12644
0
    return false;
12645
0
  continue;
12646
0
}
12647
0
case OP_InitElemPopUint32: {
12648
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12649
0
  if (!InitElemPop<PT_Uint32>(S, OpPC, V0))
12650
0
    return false;
12651
0
  continue;
12652
0
}
12653
0
case OP_InitElemPopSint64: {
12654
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12655
0
  if (!InitElemPop<PT_Sint64>(S, OpPC, V0))
12656
0
    return false;
12657
0
  continue;
12658
0
}
12659
0
case OP_InitElemPopUint64: {
12660
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12661
0
  if (!InitElemPop<PT_Uint64>(S, OpPC, V0))
12662
0
    return false;
12663
0
  continue;
12664
0
}
12665
0
case OP_InitElemPopIntAP: {
12666
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12667
0
  if (!InitElemPop<PT_IntAP>(S, OpPC, V0))
12668
0
    return false;
12669
0
  continue;
12670
0
}
12671
0
case OP_InitElemPopIntAPS: {
12672
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12673
0
  if (!InitElemPop<PT_IntAPS>(S, OpPC, V0))
12674
0
    return false;
12675
0
  continue;
12676
0
}
12677
0
case OP_InitElemPopBool: {
12678
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12679
0
  if (!InitElemPop<PT_Bool>(S, OpPC, V0))
12680
0
    return false;
12681
0
  continue;
12682
0
}
12683
0
case OP_InitElemPopPtr: {
12684
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12685
0
  if (!InitElemPop<PT_Ptr>(S, OpPC, V0))
12686
0
    return false;
12687
0
  continue;
12688
0
}
12689
0
case OP_InitElemPopFnPtr: {
12690
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12691
0
  if (!InitElemPop<PT_FnPtr>(S, OpPC, V0))
12692
0
    return false;
12693
0
  continue;
12694
0
}
12695
0
case OP_InitElemPopFloat: {
12696
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12697
0
  if (!InitElemPop<PT_Float>(S, OpPC, V0))
12698
0
    return false;
12699
0
  continue;
12700
0
}
12701
0
#endif
12702
#ifdef GET_DISASM
12703
case OP_InitElemPopSint8:
12704
  PrintName("InitElemPopSint8");
12705
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12706
  continue;
12707
case OP_InitElemPopUint8:
12708
  PrintName("InitElemPopUint8");
12709
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12710
  continue;
12711
case OP_InitElemPopSint16:
12712
  PrintName("InitElemPopSint16");
12713
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12714
  continue;
12715
case OP_InitElemPopUint16:
12716
  PrintName("InitElemPopUint16");
12717
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12718
  continue;
12719
case OP_InitElemPopSint32:
12720
  PrintName("InitElemPopSint32");
12721
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12722
  continue;
12723
case OP_InitElemPopUint32:
12724
  PrintName("InitElemPopUint32");
12725
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12726
  continue;
12727
case OP_InitElemPopSint64:
12728
  PrintName("InitElemPopSint64");
12729
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12730
  continue;
12731
case OP_InitElemPopUint64:
12732
  PrintName("InitElemPopUint64");
12733
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12734
  continue;
12735
case OP_InitElemPopIntAP:
12736
  PrintName("InitElemPopIntAP");
12737
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12738
  continue;
12739
case OP_InitElemPopIntAPS:
12740
  PrintName("InitElemPopIntAPS");
12741
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12742
  continue;
12743
case OP_InitElemPopBool:
12744
  PrintName("InitElemPopBool");
12745
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12746
  continue;
12747
case OP_InitElemPopPtr:
12748
  PrintName("InitElemPopPtr");
12749
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12750
  continue;
12751
case OP_InitElemPopFnPtr:
12752
  PrintName("InitElemPopFnPtr");
12753
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12754
  continue;
12755
case OP_InitElemPopFloat:
12756
  PrintName("InitElemPopFloat");
12757
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
12758
  continue;
12759
#endif
12760
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12761
bool emitInitElemPopSint8(uint32_t, const SourceInfo &);
12762
bool emitInitElemPopUint8(uint32_t, const SourceInfo &);
12763
bool emitInitElemPopSint16(uint32_t, const SourceInfo &);
12764
bool emitInitElemPopUint16(uint32_t, const SourceInfo &);
12765
bool emitInitElemPopSint32(uint32_t, const SourceInfo &);
12766
bool emitInitElemPopUint32(uint32_t, const SourceInfo &);
12767
bool emitInitElemPopSint64(uint32_t, const SourceInfo &);
12768
bool emitInitElemPopUint64(uint32_t, const SourceInfo &);
12769
bool emitInitElemPopIntAP(uint32_t, const SourceInfo &);
12770
bool emitInitElemPopIntAPS(uint32_t, const SourceInfo &);
12771
bool emitInitElemPopBool(uint32_t, const SourceInfo &);
12772
bool emitInitElemPopPtr(uint32_t, const SourceInfo &);
12773
bool emitInitElemPopFnPtr(uint32_t, const SourceInfo &);
12774
bool emitInitElemPopFloat(uint32_t, const SourceInfo &);
12775
#endif
12776
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12777
bool emitInitElemPop(PrimType, uint32_t, const SourceInfo &I);
12778
#endif
12779
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
12780
bool
12781
#if defined(GET_EVAL_IMPL)
12782
EvalEmitter
12783
#else
12784
ByteCodeEmitter
12785
#endif
12786
0
::emitInitElemPop(PrimType T0, uint32_t A0, const SourceInfo &I) {
12787
0
  switch (T0) {
12788
0
  case PT_Sint8:
12789
0
    return emitInitElemPopSint8(A0, I);
12790
0
  case PT_Uint8:
12791
0
    return emitInitElemPopUint8(A0, I);
12792
0
  case PT_Sint16:
12793
0
    return emitInitElemPopSint16(A0, I);
12794
0
  case PT_Uint16:
12795
0
    return emitInitElemPopUint16(A0, I);
12796
0
  case PT_Sint32:
12797
0
    return emitInitElemPopSint32(A0, I);
12798
0
  case PT_Uint32:
12799
0
    return emitInitElemPopUint32(A0, I);
12800
0
  case PT_Sint64:
12801
0
    return emitInitElemPopSint64(A0, I);
12802
0
  case PT_Uint64:
12803
0
    return emitInitElemPopUint64(A0, I);
12804
0
  case PT_IntAP:
12805
0
    return emitInitElemPopIntAP(A0, I);
12806
0
  case PT_IntAPS:
12807
0
    return emitInitElemPopIntAPS(A0, I);
12808
0
  case PT_Bool:
12809
0
    return emitInitElemPopBool(A0, I);
12810
0
  case PT_Ptr:
12811
0
    return emitInitElemPopPtr(A0, I);
12812
0
  case PT_FnPtr:
12813
0
    return emitInitElemPopFnPtr(A0, I);
12814
0
  case PT_Float:
12815
0
    return emitInitElemPopFloat(A0, I);
12816
0
  }
12817
0
  llvm_unreachable("invalid enum value");
12818
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitElemPop(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitElemPop(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
12819
#endif
12820
#ifdef GET_LINK_IMPL
12821
0
bool ByteCodeEmitter::emitInitElemPopSint8(uint32_t A0, const SourceInfo &L) {
12822
0
  return emitOp<uint32_t>(OP_InitElemPopSint8, A0, L);
12823
0
}
12824
0
bool ByteCodeEmitter::emitInitElemPopUint8(uint32_t A0, const SourceInfo &L) {
12825
0
  return emitOp<uint32_t>(OP_InitElemPopUint8, A0, L);
12826
0
}
12827
0
bool ByteCodeEmitter::emitInitElemPopSint16(uint32_t A0, const SourceInfo &L) {
12828
0
  return emitOp<uint32_t>(OP_InitElemPopSint16, A0, L);
12829
0
}
12830
0
bool ByteCodeEmitter::emitInitElemPopUint16(uint32_t A0, const SourceInfo &L) {
12831
0
  return emitOp<uint32_t>(OP_InitElemPopUint16, A0, L);
12832
0
}
12833
0
bool ByteCodeEmitter::emitInitElemPopSint32(uint32_t A0, const SourceInfo &L) {
12834
0
  return emitOp<uint32_t>(OP_InitElemPopSint32, A0, L);
12835
0
}
12836
0
bool ByteCodeEmitter::emitInitElemPopUint32(uint32_t A0, const SourceInfo &L) {
12837
0
  return emitOp<uint32_t>(OP_InitElemPopUint32, A0, L);
12838
0
}
12839
0
bool ByteCodeEmitter::emitInitElemPopSint64(uint32_t A0, const SourceInfo &L) {
12840
0
  return emitOp<uint32_t>(OP_InitElemPopSint64, A0, L);
12841
0
}
12842
0
bool ByteCodeEmitter::emitInitElemPopUint64(uint32_t A0, const SourceInfo &L) {
12843
0
  return emitOp<uint32_t>(OP_InitElemPopUint64, A0, L);
12844
0
}
12845
0
bool ByteCodeEmitter::emitInitElemPopIntAP(uint32_t A0, const SourceInfo &L) {
12846
0
  return emitOp<uint32_t>(OP_InitElemPopIntAP, A0, L);
12847
0
}
12848
0
bool ByteCodeEmitter::emitInitElemPopIntAPS(uint32_t A0, const SourceInfo &L) {
12849
0
  return emitOp<uint32_t>(OP_InitElemPopIntAPS, A0, L);
12850
0
}
12851
0
bool ByteCodeEmitter::emitInitElemPopBool(uint32_t A0, const SourceInfo &L) {
12852
0
  return emitOp<uint32_t>(OP_InitElemPopBool, A0, L);
12853
0
}
12854
0
bool ByteCodeEmitter::emitInitElemPopPtr(uint32_t A0, const SourceInfo &L) {
12855
0
  return emitOp<uint32_t>(OP_InitElemPopPtr, A0, L);
12856
0
}
12857
0
bool ByteCodeEmitter::emitInitElemPopFnPtr(uint32_t A0, const SourceInfo &L) {
12858
0
  return emitOp<uint32_t>(OP_InitElemPopFnPtr, A0, L);
12859
0
}
12860
0
bool ByteCodeEmitter::emitInitElemPopFloat(uint32_t A0, const SourceInfo &L) {
12861
0
  return emitOp<uint32_t>(OP_InitElemPopFloat, A0, L);
12862
0
}
12863
#endif
12864
#ifdef GET_EVAL_IMPL
12865
0
bool EvalEmitter::emitInitElemPopSint8(uint32_t A0, const SourceInfo &L) {
12866
0
  if (!isActive()) return true;
12867
0
  CurrentSource = L;
12868
0
  return InitElemPop<PT_Sint8>(S, OpPC, A0);
12869
0
}
12870
0
bool EvalEmitter::emitInitElemPopUint8(uint32_t A0, const SourceInfo &L) {
12871
0
  if (!isActive()) return true;
12872
0
  CurrentSource = L;
12873
0
  return InitElemPop<PT_Uint8>(S, OpPC, A0);
12874
0
}
12875
0
bool EvalEmitter::emitInitElemPopSint16(uint32_t A0, const SourceInfo &L) {
12876
0
  if (!isActive()) return true;
12877
0
  CurrentSource = L;
12878
0
  return InitElemPop<PT_Sint16>(S, OpPC, A0);
12879
0
}
12880
0
bool EvalEmitter::emitInitElemPopUint16(uint32_t A0, const SourceInfo &L) {
12881
0
  if (!isActive()) return true;
12882
0
  CurrentSource = L;
12883
0
  return InitElemPop<PT_Uint16>(S, OpPC, A0);
12884
0
}
12885
0
bool EvalEmitter::emitInitElemPopSint32(uint32_t A0, const SourceInfo &L) {
12886
0
  if (!isActive()) return true;
12887
0
  CurrentSource = L;
12888
0
  return InitElemPop<PT_Sint32>(S, OpPC, A0);
12889
0
}
12890
0
bool EvalEmitter::emitInitElemPopUint32(uint32_t A0, const SourceInfo &L) {
12891
0
  if (!isActive()) return true;
12892
0
  CurrentSource = L;
12893
0
  return InitElemPop<PT_Uint32>(S, OpPC, A0);
12894
0
}
12895
0
bool EvalEmitter::emitInitElemPopSint64(uint32_t A0, const SourceInfo &L) {
12896
0
  if (!isActive()) return true;
12897
0
  CurrentSource = L;
12898
0
  return InitElemPop<PT_Sint64>(S, OpPC, A0);
12899
0
}
12900
0
bool EvalEmitter::emitInitElemPopUint64(uint32_t A0, const SourceInfo &L) {
12901
0
  if (!isActive()) return true;
12902
0
  CurrentSource = L;
12903
0
  return InitElemPop<PT_Uint64>(S, OpPC, A0);
12904
0
}
12905
0
bool EvalEmitter::emitInitElemPopIntAP(uint32_t A0, const SourceInfo &L) {
12906
0
  if (!isActive()) return true;
12907
0
  CurrentSource = L;
12908
0
  return InitElemPop<PT_IntAP>(S, OpPC, A0);
12909
0
}
12910
0
bool EvalEmitter::emitInitElemPopIntAPS(uint32_t A0, const SourceInfo &L) {
12911
0
  if (!isActive()) return true;
12912
0
  CurrentSource = L;
12913
0
  return InitElemPop<PT_IntAPS>(S, OpPC, A0);
12914
0
}
12915
0
bool EvalEmitter::emitInitElemPopBool(uint32_t A0, const SourceInfo &L) {
12916
0
  if (!isActive()) return true;
12917
0
  CurrentSource = L;
12918
0
  return InitElemPop<PT_Bool>(S, OpPC, A0);
12919
0
}
12920
0
bool EvalEmitter::emitInitElemPopPtr(uint32_t A0, const SourceInfo &L) {
12921
0
  if (!isActive()) return true;
12922
0
  CurrentSource = L;
12923
0
  return InitElemPop<PT_Ptr>(S, OpPC, A0);
12924
0
}
12925
0
bool EvalEmitter::emitInitElemPopFnPtr(uint32_t A0, const SourceInfo &L) {
12926
0
  if (!isActive()) return true;
12927
0
  CurrentSource = L;
12928
0
  return InitElemPop<PT_FnPtr>(S, OpPC, A0);
12929
0
}
12930
0
bool EvalEmitter::emitInitElemPopFloat(uint32_t A0, const SourceInfo &L) {
12931
0
  if (!isActive()) return true;
12932
0
  CurrentSource = L;
12933
0
  return InitElemPop<PT_Float>(S, OpPC, A0);
12934
0
}
12935
#endif
12936
#ifdef GET_OPCODE_NAMES
12937
OP_InitFieldSint8,
12938
OP_InitFieldUint8,
12939
OP_InitFieldSint16,
12940
OP_InitFieldUint16,
12941
OP_InitFieldSint32,
12942
OP_InitFieldUint32,
12943
OP_InitFieldSint64,
12944
OP_InitFieldUint64,
12945
OP_InitFieldIntAP,
12946
OP_InitFieldIntAPS,
12947
OP_InitFieldBool,
12948
OP_InitFieldPtr,
12949
OP_InitFieldFnPtr,
12950
OP_InitFieldFloat,
12951
#endif
12952
0
#ifdef GET_INTERP
12953
0
case OP_InitFieldSint8: {
12954
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12955
0
  if (!InitField<PT_Sint8>(S, OpPC, V0))
12956
0
    return false;
12957
0
  continue;
12958
0
}
12959
0
case OP_InitFieldUint8: {
12960
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12961
0
  if (!InitField<PT_Uint8>(S, OpPC, V0))
12962
0
    return false;
12963
0
  continue;
12964
0
}
12965
0
case OP_InitFieldSint16: {
12966
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12967
0
  if (!InitField<PT_Sint16>(S, OpPC, V0))
12968
0
    return false;
12969
0
  continue;
12970
0
}
12971
0
case OP_InitFieldUint16: {
12972
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12973
0
  if (!InitField<PT_Uint16>(S, OpPC, V0))
12974
0
    return false;
12975
0
  continue;
12976
0
}
12977
0
case OP_InitFieldSint32: {
12978
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12979
0
  if (!InitField<PT_Sint32>(S, OpPC, V0))
12980
0
    return false;
12981
0
  continue;
12982
0
}
12983
0
case OP_InitFieldUint32: {
12984
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12985
0
  if (!InitField<PT_Uint32>(S, OpPC, V0))
12986
0
    return false;
12987
0
  continue;
12988
0
}
12989
0
case OP_InitFieldSint64: {
12990
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12991
0
  if (!InitField<PT_Sint64>(S, OpPC, V0))
12992
0
    return false;
12993
0
  continue;
12994
0
}
12995
0
case OP_InitFieldUint64: {
12996
0
  auto V0 = ReadArg<uint32_t>(S, PC);
12997
0
  if (!InitField<PT_Uint64>(S, OpPC, V0))
12998
0
    return false;
12999
0
  continue;
13000
0
}
13001
0
case OP_InitFieldIntAP: {
13002
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13003
0
  if (!InitField<PT_IntAP>(S, OpPC, V0))
13004
0
    return false;
13005
0
  continue;
13006
0
}
13007
0
case OP_InitFieldIntAPS: {
13008
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13009
0
  if (!InitField<PT_IntAPS>(S, OpPC, V0))
13010
0
    return false;
13011
0
  continue;
13012
0
}
13013
0
case OP_InitFieldBool: {
13014
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13015
0
  if (!InitField<PT_Bool>(S, OpPC, V0))
13016
0
    return false;
13017
0
  continue;
13018
0
}
13019
0
case OP_InitFieldPtr: {
13020
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13021
0
  if (!InitField<PT_Ptr>(S, OpPC, V0))
13022
0
    return false;
13023
0
  continue;
13024
0
}
13025
0
case OP_InitFieldFnPtr: {
13026
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13027
0
  if (!InitField<PT_FnPtr>(S, OpPC, V0))
13028
0
    return false;
13029
0
  continue;
13030
0
}
13031
0
case OP_InitFieldFloat: {
13032
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13033
0
  if (!InitField<PT_Float>(S, OpPC, V0))
13034
0
    return false;
13035
0
  continue;
13036
0
}
13037
0
#endif
13038
#ifdef GET_DISASM
13039
case OP_InitFieldSint8:
13040
  PrintName("InitFieldSint8");
13041
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13042
  continue;
13043
case OP_InitFieldUint8:
13044
  PrintName("InitFieldUint8");
13045
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13046
  continue;
13047
case OP_InitFieldSint16:
13048
  PrintName("InitFieldSint16");
13049
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13050
  continue;
13051
case OP_InitFieldUint16:
13052
  PrintName("InitFieldUint16");
13053
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13054
  continue;
13055
case OP_InitFieldSint32:
13056
  PrintName("InitFieldSint32");
13057
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13058
  continue;
13059
case OP_InitFieldUint32:
13060
  PrintName("InitFieldUint32");
13061
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13062
  continue;
13063
case OP_InitFieldSint64:
13064
  PrintName("InitFieldSint64");
13065
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13066
  continue;
13067
case OP_InitFieldUint64:
13068
  PrintName("InitFieldUint64");
13069
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13070
  continue;
13071
case OP_InitFieldIntAP:
13072
  PrintName("InitFieldIntAP");
13073
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13074
  continue;
13075
case OP_InitFieldIntAPS:
13076
  PrintName("InitFieldIntAPS");
13077
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13078
  continue;
13079
case OP_InitFieldBool:
13080
  PrintName("InitFieldBool");
13081
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13082
  continue;
13083
case OP_InitFieldPtr:
13084
  PrintName("InitFieldPtr");
13085
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13086
  continue;
13087
case OP_InitFieldFnPtr:
13088
  PrintName("InitFieldFnPtr");
13089
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13090
  continue;
13091
case OP_InitFieldFloat:
13092
  PrintName("InitFieldFloat");
13093
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13094
  continue;
13095
#endif
13096
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13097
bool emitInitFieldSint8(uint32_t, const SourceInfo &);
13098
bool emitInitFieldUint8(uint32_t, const SourceInfo &);
13099
bool emitInitFieldSint16(uint32_t, const SourceInfo &);
13100
bool emitInitFieldUint16(uint32_t, const SourceInfo &);
13101
bool emitInitFieldSint32(uint32_t, const SourceInfo &);
13102
bool emitInitFieldUint32(uint32_t, const SourceInfo &);
13103
bool emitInitFieldSint64(uint32_t, const SourceInfo &);
13104
bool emitInitFieldUint64(uint32_t, const SourceInfo &);
13105
bool emitInitFieldIntAP(uint32_t, const SourceInfo &);
13106
bool emitInitFieldIntAPS(uint32_t, const SourceInfo &);
13107
bool emitInitFieldBool(uint32_t, const SourceInfo &);
13108
bool emitInitFieldPtr(uint32_t, const SourceInfo &);
13109
bool emitInitFieldFnPtr(uint32_t, const SourceInfo &);
13110
bool emitInitFieldFloat(uint32_t, const SourceInfo &);
13111
#endif
13112
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13113
bool emitInitField(PrimType, uint32_t, const SourceInfo &I);
13114
#endif
13115
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
13116
bool
13117
#if defined(GET_EVAL_IMPL)
13118
EvalEmitter
13119
#else
13120
ByteCodeEmitter
13121
#endif
13122
0
::emitInitField(PrimType T0, uint32_t A0, const SourceInfo &I) {
13123
0
  switch (T0) {
13124
0
  case PT_Sint8:
13125
0
    return emitInitFieldSint8(A0, I);
13126
0
  case PT_Uint8:
13127
0
    return emitInitFieldUint8(A0, I);
13128
0
  case PT_Sint16:
13129
0
    return emitInitFieldSint16(A0, I);
13130
0
  case PT_Uint16:
13131
0
    return emitInitFieldUint16(A0, I);
13132
0
  case PT_Sint32:
13133
0
    return emitInitFieldSint32(A0, I);
13134
0
  case PT_Uint32:
13135
0
    return emitInitFieldUint32(A0, I);
13136
0
  case PT_Sint64:
13137
0
    return emitInitFieldSint64(A0, I);
13138
0
  case PT_Uint64:
13139
0
    return emitInitFieldUint64(A0, I);
13140
0
  case PT_IntAP:
13141
0
    return emitInitFieldIntAP(A0, I);
13142
0
  case PT_IntAPS:
13143
0
    return emitInitFieldIntAPS(A0, I);
13144
0
  case PT_Bool:
13145
0
    return emitInitFieldBool(A0, I);
13146
0
  case PT_Ptr:
13147
0
    return emitInitFieldPtr(A0, I);
13148
0
  case PT_FnPtr:
13149
0
    return emitInitFieldFnPtr(A0, I);
13150
0
  case PT_Float:
13151
0
    return emitInitFieldFloat(A0, I);
13152
0
  }
13153
0
  llvm_unreachable("invalid enum value");
13154
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
13155
#endif
13156
#ifdef GET_LINK_IMPL
13157
0
bool ByteCodeEmitter::emitInitFieldSint8(uint32_t A0, const SourceInfo &L) {
13158
0
  return emitOp<uint32_t>(OP_InitFieldSint8, A0, L);
13159
0
}
13160
0
bool ByteCodeEmitter::emitInitFieldUint8(uint32_t A0, const SourceInfo &L) {
13161
0
  return emitOp<uint32_t>(OP_InitFieldUint8, A0, L);
13162
0
}
13163
0
bool ByteCodeEmitter::emitInitFieldSint16(uint32_t A0, const SourceInfo &L) {
13164
0
  return emitOp<uint32_t>(OP_InitFieldSint16, A0, L);
13165
0
}
13166
0
bool ByteCodeEmitter::emitInitFieldUint16(uint32_t A0, const SourceInfo &L) {
13167
0
  return emitOp<uint32_t>(OP_InitFieldUint16, A0, L);
13168
0
}
13169
0
bool ByteCodeEmitter::emitInitFieldSint32(uint32_t A0, const SourceInfo &L) {
13170
0
  return emitOp<uint32_t>(OP_InitFieldSint32, A0, L);
13171
0
}
13172
0
bool ByteCodeEmitter::emitInitFieldUint32(uint32_t A0, const SourceInfo &L) {
13173
0
  return emitOp<uint32_t>(OP_InitFieldUint32, A0, L);
13174
0
}
13175
0
bool ByteCodeEmitter::emitInitFieldSint64(uint32_t A0, const SourceInfo &L) {
13176
0
  return emitOp<uint32_t>(OP_InitFieldSint64, A0, L);
13177
0
}
13178
0
bool ByteCodeEmitter::emitInitFieldUint64(uint32_t A0, const SourceInfo &L) {
13179
0
  return emitOp<uint32_t>(OP_InitFieldUint64, A0, L);
13180
0
}
13181
0
bool ByteCodeEmitter::emitInitFieldIntAP(uint32_t A0, const SourceInfo &L) {
13182
0
  return emitOp<uint32_t>(OP_InitFieldIntAP, A0, L);
13183
0
}
13184
0
bool ByteCodeEmitter::emitInitFieldIntAPS(uint32_t A0, const SourceInfo &L) {
13185
0
  return emitOp<uint32_t>(OP_InitFieldIntAPS, A0, L);
13186
0
}
13187
0
bool ByteCodeEmitter::emitInitFieldBool(uint32_t A0, const SourceInfo &L) {
13188
0
  return emitOp<uint32_t>(OP_InitFieldBool, A0, L);
13189
0
}
13190
0
bool ByteCodeEmitter::emitInitFieldPtr(uint32_t A0, const SourceInfo &L) {
13191
0
  return emitOp<uint32_t>(OP_InitFieldPtr, A0, L);
13192
0
}
13193
0
bool ByteCodeEmitter::emitInitFieldFnPtr(uint32_t A0, const SourceInfo &L) {
13194
0
  return emitOp<uint32_t>(OP_InitFieldFnPtr, A0, L);
13195
0
}
13196
0
bool ByteCodeEmitter::emitInitFieldFloat(uint32_t A0, const SourceInfo &L) {
13197
0
  return emitOp<uint32_t>(OP_InitFieldFloat, A0, L);
13198
0
}
13199
#endif
13200
#ifdef GET_EVAL_IMPL
13201
0
bool EvalEmitter::emitInitFieldSint8(uint32_t A0, const SourceInfo &L) {
13202
0
  if (!isActive()) return true;
13203
0
  CurrentSource = L;
13204
0
  return InitField<PT_Sint8>(S, OpPC, A0);
13205
0
}
13206
0
bool EvalEmitter::emitInitFieldUint8(uint32_t A0, const SourceInfo &L) {
13207
0
  if (!isActive()) return true;
13208
0
  CurrentSource = L;
13209
0
  return InitField<PT_Uint8>(S, OpPC, A0);
13210
0
}
13211
0
bool EvalEmitter::emitInitFieldSint16(uint32_t A0, const SourceInfo &L) {
13212
0
  if (!isActive()) return true;
13213
0
  CurrentSource = L;
13214
0
  return InitField<PT_Sint16>(S, OpPC, A0);
13215
0
}
13216
0
bool EvalEmitter::emitInitFieldUint16(uint32_t A0, const SourceInfo &L) {
13217
0
  if (!isActive()) return true;
13218
0
  CurrentSource = L;
13219
0
  return InitField<PT_Uint16>(S, OpPC, A0);
13220
0
}
13221
0
bool EvalEmitter::emitInitFieldSint32(uint32_t A0, const SourceInfo &L) {
13222
0
  if (!isActive()) return true;
13223
0
  CurrentSource = L;
13224
0
  return InitField<PT_Sint32>(S, OpPC, A0);
13225
0
}
13226
0
bool EvalEmitter::emitInitFieldUint32(uint32_t A0, const SourceInfo &L) {
13227
0
  if (!isActive()) return true;
13228
0
  CurrentSource = L;
13229
0
  return InitField<PT_Uint32>(S, OpPC, A0);
13230
0
}
13231
0
bool EvalEmitter::emitInitFieldSint64(uint32_t A0, const SourceInfo &L) {
13232
0
  if (!isActive()) return true;
13233
0
  CurrentSource = L;
13234
0
  return InitField<PT_Sint64>(S, OpPC, A0);
13235
0
}
13236
0
bool EvalEmitter::emitInitFieldUint64(uint32_t A0, const SourceInfo &L) {
13237
0
  if (!isActive()) return true;
13238
0
  CurrentSource = L;
13239
0
  return InitField<PT_Uint64>(S, OpPC, A0);
13240
0
}
13241
0
bool EvalEmitter::emitInitFieldIntAP(uint32_t A0, const SourceInfo &L) {
13242
0
  if (!isActive()) return true;
13243
0
  CurrentSource = L;
13244
0
  return InitField<PT_IntAP>(S, OpPC, A0);
13245
0
}
13246
0
bool EvalEmitter::emitInitFieldIntAPS(uint32_t A0, const SourceInfo &L) {
13247
0
  if (!isActive()) return true;
13248
0
  CurrentSource = L;
13249
0
  return InitField<PT_IntAPS>(S, OpPC, A0);
13250
0
}
13251
0
bool EvalEmitter::emitInitFieldBool(uint32_t A0, const SourceInfo &L) {
13252
0
  if (!isActive()) return true;
13253
0
  CurrentSource = L;
13254
0
  return InitField<PT_Bool>(S, OpPC, A0);
13255
0
}
13256
0
bool EvalEmitter::emitInitFieldPtr(uint32_t A0, const SourceInfo &L) {
13257
0
  if (!isActive()) return true;
13258
0
  CurrentSource = L;
13259
0
  return InitField<PT_Ptr>(S, OpPC, A0);
13260
0
}
13261
0
bool EvalEmitter::emitInitFieldFnPtr(uint32_t A0, const SourceInfo &L) {
13262
0
  if (!isActive()) return true;
13263
0
  CurrentSource = L;
13264
0
  return InitField<PT_FnPtr>(S, OpPC, A0);
13265
0
}
13266
0
bool EvalEmitter::emitInitFieldFloat(uint32_t A0, const SourceInfo &L) {
13267
0
  if (!isActive()) return true;
13268
0
  CurrentSource = L;
13269
0
  return InitField<PT_Float>(S, OpPC, A0);
13270
0
}
13271
#endif
13272
#ifdef GET_OPCODE_NAMES
13273
OP_InitFieldActiveSint8,
13274
OP_InitFieldActiveUint8,
13275
OP_InitFieldActiveSint16,
13276
OP_InitFieldActiveUint16,
13277
OP_InitFieldActiveSint32,
13278
OP_InitFieldActiveUint32,
13279
OP_InitFieldActiveSint64,
13280
OP_InitFieldActiveUint64,
13281
OP_InitFieldActiveIntAP,
13282
OP_InitFieldActiveIntAPS,
13283
OP_InitFieldActiveBool,
13284
OP_InitFieldActivePtr,
13285
OP_InitFieldActiveFnPtr,
13286
OP_InitFieldActiveFloat,
13287
#endif
13288
0
#ifdef GET_INTERP
13289
0
case OP_InitFieldActiveSint8: {
13290
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13291
0
  if (!InitFieldActive<PT_Sint8>(S, OpPC, V0))
13292
0
    return false;
13293
0
  continue;
13294
0
}
13295
0
case OP_InitFieldActiveUint8: {
13296
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13297
0
  if (!InitFieldActive<PT_Uint8>(S, OpPC, V0))
13298
0
    return false;
13299
0
  continue;
13300
0
}
13301
0
case OP_InitFieldActiveSint16: {
13302
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13303
0
  if (!InitFieldActive<PT_Sint16>(S, OpPC, V0))
13304
0
    return false;
13305
0
  continue;
13306
0
}
13307
0
case OP_InitFieldActiveUint16: {
13308
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13309
0
  if (!InitFieldActive<PT_Uint16>(S, OpPC, V0))
13310
0
    return false;
13311
0
  continue;
13312
0
}
13313
0
case OP_InitFieldActiveSint32: {
13314
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13315
0
  if (!InitFieldActive<PT_Sint32>(S, OpPC, V0))
13316
0
    return false;
13317
0
  continue;
13318
0
}
13319
0
case OP_InitFieldActiveUint32: {
13320
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13321
0
  if (!InitFieldActive<PT_Uint32>(S, OpPC, V0))
13322
0
    return false;
13323
0
  continue;
13324
0
}
13325
0
case OP_InitFieldActiveSint64: {
13326
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13327
0
  if (!InitFieldActive<PT_Sint64>(S, OpPC, V0))
13328
0
    return false;
13329
0
  continue;
13330
0
}
13331
0
case OP_InitFieldActiveUint64: {
13332
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13333
0
  if (!InitFieldActive<PT_Uint64>(S, OpPC, V0))
13334
0
    return false;
13335
0
  continue;
13336
0
}
13337
0
case OP_InitFieldActiveIntAP: {
13338
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13339
0
  if (!InitFieldActive<PT_IntAP>(S, OpPC, V0))
13340
0
    return false;
13341
0
  continue;
13342
0
}
13343
0
case OP_InitFieldActiveIntAPS: {
13344
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13345
0
  if (!InitFieldActive<PT_IntAPS>(S, OpPC, V0))
13346
0
    return false;
13347
0
  continue;
13348
0
}
13349
0
case OP_InitFieldActiveBool: {
13350
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13351
0
  if (!InitFieldActive<PT_Bool>(S, OpPC, V0))
13352
0
    return false;
13353
0
  continue;
13354
0
}
13355
0
case OP_InitFieldActivePtr: {
13356
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13357
0
  if (!InitFieldActive<PT_Ptr>(S, OpPC, V0))
13358
0
    return false;
13359
0
  continue;
13360
0
}
13361
0
case OP_InitFieldActiveFnPtr: {
13362
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13363
0
  if (!InitFieldActive<PT_FnPtr>(S, OpPC, V0))
13364
0
    return false;
13365
0
  continue;
13366
0
}
13367
0
case OP_InitFieldActiveFloat: {
13368
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13369
0
  if (!InitFieldActive<PT_Float>(S, OpPC, V0))
13370
0
    return false;
13371
0
  continue;
13372
0
}
13373
0
#endif
13374
#ifdef GET_DISASM
13375
case OP_InitFieldActiveSint8:
13376
  PrintName("InitFieldActiveSint8");
13377
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13378
  continue;
13379
case OP_InitFieldActiveUint8:
13380
  PrintName("InitFieldActiveUint8");
13381
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13382
  continue;
13383
case OP_InitFieldActiveSint16:
13384
  PrintName("InitFieldActiveSint16");
13385
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13386
  continue;
13387
case OP_InitFieldActiveUint16:
13388
  PrintName("InitFieldActiveUint16");
13389
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13390
  continue;
13391
case OP_InitFieldActiveSint32:
13392
  PrintName("InitFieldActiveSint32");
13393
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13394
  continue;
13395
case OP_InitFieldActiveUint32:
13396
  PrintName("InitFieldActiveUint32");
13397
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13398
  continue;
13399
case OP_InitFieldActiveSint64:
13400
  PrintName("InitFieldActiveSint64");
13401
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13402
  continue;
13403
case OP_InitFieldActiveUint64:
13404
  PrintName("InitFieldActiveUint64");
13405
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13406
  continue;
13407
case OP_InitFieldActiveIntAP:
13408
  PrintName("InitFieldActiveIntAP");
13409
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13410
  continue;
13411
case OP_InitFieldActiveIntAPS:
13412
  PrintName("InitFieldActiveIntAPS");
13413
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13414
  continue;
13415
case OP_InitFieldActiveBool:
13416
  PrintName("InitFieldActiveBool");
13417
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13418
  continue;
13419
case OP_InitFieldActivePtr:
13420
  PrintName("InitFieldActivePtr");
13421
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13422
  continue;
13423
case OP_InitFieldActiveFnPtr:
13424
  PrintName("InitFieldActiveFnPtr");
13425
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13426
  continue;
13427
case OP_InitFieldActiveFloat:
13428
  PrintName("InitFieldActiveFloat");
13429
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13430
  continue;
13431
#endif
13432
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13433
bool emitInitFieldActiveSint8(uint32_t, const SourceInfo &);
13434
bool emitInitFieldActiveUint8(uint32_t, const SourceInfo &);
13435
bool emitInitFieldActiveSint16(uint32_t, const SourceInfo &);
13436
bool emitInitFieldActiveUint16(uint32_t, const SourceInfo &);
13437
bool emitInitFieldActiveSint32(uint32_t, const SourceInfo &);
13438
bool emitInitFieldActiveUint32(uint32_t, const SourceInfo &);
13439
bool emitInitFieldActiveSint64(uint32_t, const SourceInfo &);
13440
bool emitInitFieldActiveUint64(uint32_t, const SourceInfo &);
13441
bool emitInitFieldActiveIntAP(uint32_t, const SourceInfo &);
13442
bool emitInitFieldActiveIntAPS(uint32_t, const SourceInfo &);
13443
bool emitInitFieldActiveBool(uint32_t, const SourceInfo &);
13444
bool emitInitFieldActivePtr(uint32_t, const SourceInfo &);
13445
bool emitInitFieldActiveFnPtr(uint32_t, const SourceInfo &);
13446
bool emitInitFieldActiveFloat(uint32_t, const SourceInfo &);
13447
#endif
13448
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13449
bool emitInitFieldActive(PrimType, uint32_t, const SourceInfo &I);
13450
#endif
13451
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
13452
bool
13453
#if defined(GET_EVAL_IMPL)
13454
EvalEmitter
13455
#else
13456
ByteCodeEmitter
13457
#endif
13458
0
::emitInitFieldActive(PrimType T0, uint32_t A0, const SourceInfo &I) {
13459
0
  switch (T0) {
13460
0
  case PT_Sint8:
13461
0
    return emitInitFieldActiveSint8(A0, I);
13462
0
  case PT_Uint8:
13463
0
    return emitInitFieldActiveUint8(A0, I);
13464
0
  case PT_Sint16:
13465
0
    return emitInitFieldActiveSint16(A0, I);
13466
0
  case PT_Uint16:
13467
0
    return emitInitFieldActiveUint16(A0, I);
13468
0
  case PT_Sint32:
13469
0
    return emitInitFieldActiveSint32(A0, I);
13470
0
  case PT_Uint32:
13471
0
    return emitInitFieldActiveUint32(A0, I);
13472
0
  case PT_Sint64:
13473
0
    return emitInitFieldActiveSint64(A0, I);
13474
0
  case PT_Uint64:
13475
0
    return emitInitFieldActiveUint64(A0, I);
13476
0
  case PT_IntAP:
13477
0
    return emitInitFieldActiveIntAP(A0, I);
13478
0
  case PT_IntAPS:
13479
0
    return emitInitFieldActiveIntAPS(A0, I);
13480
0
  case PT_Bool:
13481
0
    return emitInitFieldActiveBool(A0, I);
13482
0
  case PT_Ptr:
13483
0
    return emitInitFieldActivePtr(A0, I);
13484
0
  case PT_FnPtr:
13485
0
    return emitInitFieldActiveFnPtr(A0, I);
13486
0
  case PT_Float:
13487
0
    return emitInitFieldActiveFloat(A0, I);
13488
0
  }
13489
0
  llvm_unreachable("invalid enum value");
13490
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitFieldActive(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitFieldActive(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
13491
#endif
13492
#ifdef GET_LINK_IMPL
13493
0
bool ByteCodeEmitter::emitInitFieldActiveSint8(uint32_t A0, const SourceInfo &L) {
13494
0
  return emitOp<uint32_t>(OP_InitFieldActiveSint8, A0, L);
13495
0
}
13496
0
bool ByteCodeEmitter::emitInitFieldActiveUint8(uint32_t A0, const SourceInfo &L) {
13497
0
  return emitOp<uint32_t>(OP_InitFieldActiveUint8, A0, L);
13498
0
}
13499
0
bool ByteCodeEmitter::emitInitFieldActiveSint16(uint32_t A0, const SourceInfo &L) {
13500
0
  return emitOp<uint32_t>(OP_InitFieldActiveSint16, A0, L);
13501
0
}
13502
0
bool ByteCodeEmitter::emitInitFieldActiveUint16(uint32_t A0, const SourceInfo &L) {
13503
0
  return emitOp<uint32_t>(OP_InitFieldActiveUint16, A0, L);
13504
0
}
13505
0
bool ByteCodeEmitter::emitInitFieldActiveSint32(uint32_t A0, const SourceInfo &L) {
13506
0
  return emitOp<uint32_t>(OP_InitFieldActiveSint32, A0, L);
13507
0
}
13508
0
bool ByteCodeEmitter::emitInitFieldActiveUint32(uint32_t A0, const SourceInfo &L) {
13509
0
  return emitOp<uint32_t>(OP_InitFieldActiveUint32, A0, L);
13510
0
}
13511
0
bool ByteCodeEmitter::emitInitFieldActiveSint64(uint32_t A0, const SourceInfo &L) {
13512
0
  return emitOp<uint32_t>(OP_InitFieldActiveSint64, A0, L);
13513
0
}
13514
0
bool ByteCodeEmitter::emitInitFieldActiveUint64(uint32_t A0, const SourceInfo &L) {
13515
0
  return emitOp<uint32_t>(OP_InitFieldActiveUint64, A0, L);
13516
0
}
13517
0
bool ByteCodeEmitter::emitInitFieldActiveIntAP(uint32_t A0, const SourceInfo &L) {
13518
0
  return emitOp<uint32_t>(OP_InitFieldActiveIntAP, A0, L);
13519
0
}
13520
0
bool ByteCodeEmitter::emitInitFieldActiveIntAPS(uint32_t A0, const SourceInfo &L) {
13521
0
  return emitOp<uint32_t>(OP_InitFieldActiveIntAPS, A0, L);
13522
0
}
13523
0
bool ByteCodeEmitter::emitInitFieldActiveBool(uint32_t A0, const SourceInfo &L) {
13524
0
  return emitOp<uint32_t>(OP_InitFieldActiveBool, A0, L);
13525
0
}
13526
0
bool ByteCodeEmitter::emitInitFieldActivePtr(uint32_t A0, const SourceInfo &L) {
13527
0
  return emitOp<uint32_t>(OP_InitFieldActivePtr, A0, L);
13528
0
}
13529
0
bool ByteCodeEmitter::emitInitFieldActiveFnPtr(uint32_t A0, const SourceInfo &L) {
13530
0
  return emitOp<uint32_t>(OP_InitFieldActiveFnPtr, A0, L);
13531
0
}
13532
0
bool ByteCodeEmitter::emitInitFieldActiveFloat(uint32_t A0, const SourceInfo &L) {
13533
0
  return emitOp<uint32_t>(OP_InitFieldActiveFloat, A0, L);
13534
0
}
13535
#endif
13536
#ifdef GET_EVAL_IMPL
13537
0
bool EvalEmitter::emitInitFieldActiveSint8(uint32_t A0, const SourceInfo &L) {
13538
0
  if (!isActive()) return true;
13539
0
  CurrentSource = L;
13540
0
  return InitFieldActive<PT_Sint8>(S, OpPC, A0);
13541
0
}
13542
0
bool EvalEmitter::emitInitFieldActiveUint8(uint32_t A0, const SourceInfo &L) {
13543
0
  if (!isActive()) return true;
13544
0
  CurrentSource = L;
13545
0
  return InitFieldActive<PT_Uint8>(S, OpPC, A0);
13546
0
}
13547
0
bool EvalEmitter::emitInitFieldActiveSint16(uint32_t A0, const SourceInfo &L) {
13548
0
  if (!isActive()) return true;
13549
0
  CurrentSource = L;
13550
0
  return InitFieldActive<PT_Sint16>(S, OpPC, A0);
13551
0
}
13552
0
bool EvalEmitter::emitInitFieldActiveUint16(uint32_t A0, const SourceInfo &L) {
13553
0
  if (!isActive()) return true;
13554
0
  CurrentSource = L;
13555
0
  return InitFieldActive<PT_Uint16>(S, OpPC, A0);
13556
0
}
13557
0
bool EvalEmitter::emitInitFieldActiveSint32(uint32_t A0, const SourceInfo &L) {
13558
0
  if (!isActive()) return true;
13559
0
  CurrentSource = L;
13560
0
  return InitFieldActive<PT_Sint32>(S, OpPC, A0);
13561
0
}
13562
0
bool EvalEmitter::emitInitFieldActiveUint32(uint32_t A0, const SourceInfo &L) {
13563
0
  if (!isActive()) return true;
13564
0
  CurrentSource = L;
13565
0
  return InitFieldActive<PT_Uint32>(S, OpPC, A0);
13566
0
}
13567
0
bool EvalEmitter::emitInitFieldActiveSint64(uint32_t A0, const SourceInfo &L) {
13568
0
  if (!isActive()) return true;
13569
0
  CurrentSource = L;
13570
0
  return InitFieldActive<PT_Sint64>(S, OpPC, A0);
13571
0
}
13572
0
bool EvalEmitter::emitInitFieldActiveUint64(uint32_t A0, const SourceInfo &L) {
13573
0
  if (!isActive()) return true;
13574
0
  CurrentSource = L;
13575
0
  return InitFieldActive<PT_Uint64>(S, OpPC, A0);
13576
0
}
13577
0
bool EvalEmitter::emitInitFieldActiveIntAP(uint32_t A0, const SourceInfo &L) {
13578
0
  if (!isActive()) return true;
13579
0
  CurrentSource = L;
13580
0
  return InitFieldActive<PT_IntAP>(S, OpPC, A0);
13581
0
}
13582
0
bool EvalEmitter::emitInitFieldActiveIntAPS(uint32_t A0, const SourceInfo &L) {
13583
0
  if (!isActive()) return true;
13584
0
  CurrentSource = L;
13585
0
  return InitFieldActive<PT_IntAPS>(S, OpPC, A0);
13586
0
}
13587
0
bool EvalEmitter::emitInitFieldActiveBool(uint32_t A0, const SourceInfo &L) {
13588
0
  if (!isActive()) return true;
13589
0
  CurrentSource = L;
13590
0
  return InitFieldActive<PT_Bool>(S, OpPC, A0);
13591
0
}
13592
0
bool EvalEmitter::emitInitFieldActivePtr(uint32_t A0, const SourceInfo &L) {
13593
0
  if (!isActive()) return true;
13594
0
  CurrentSource = L;
13595
0
  return InitFieldActive<PT_Ptr>(S, OpPC, A0);
13596
0
}
13597
0
bool EvalEmitter::emitInitFieldActiveFnPtr(uint32_t A0, const SourceInfo &L) {
13598
0
  if (!isActive()) return true;
13599
0
  CurrentSource = L;
13600
0
  return InitFieldActive<PT_FnPtr>(S, OpPC, A0);
13601
0
}
13602
0
bool EvalEmitter::emitInitFieldActiveFloat(uint32_t A0, const SourceInfo &L) {
13603
0
  if (!isActive()) return true;
13604
0
  CurrentSource = L;
13605
0
  return InitFieldActive<PT_Float>(S, OpPC, A0);
13606
0
}
13607
#endif
13608
#ifdef GET_OPCODE_NAMES
13609
OP_InitGlobalSint8,
13610
OP_InitGlobalUint8,
13611
OP_InitGlobalSint16,
13612
OP_InitGlobalUint16,
13613
OP_InitGlobalSint32,
13614
OP_InitGlobalUint32,
13615
OP_InitGlobalSint64,
13616
OP_InitGlobalUint64,
13617
OP_InitGlobalIntAP,
13618
OP_InitGlobalIntAPS,
13619
OP_InitGlobalBool,
13620
OP_InitGlobalPtr,
13621
OP_InitGlobalFnPtr,
13622
OP_InitGlobalFloat,
13623
#endif
13624
0
#ifdef GET_INTERP
13625
0
case OP_InitGlobalSint8: {
13626
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13627
0
  if (!InitGlobal<PT_Sint8>(S, OpPC, V0))
13628
0
    return false;
13629
0
  continue;
13630
0
}
13631
0
case OP_InitGlobalUint8: {
13632
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13633
0
  if (!InitGlobal<PT_Uint8>(S, OpPC, V0))
13634
0
    return false;
13635
0
  continue;
13636
0
}
13637
0
case OP_InitGlobalSint16: {
13638
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13639
0
  if (!InitGlobal<PT_Sint16>(S, OpPC, V0))
13640
0
    return false;
13641
0
  continue;
13642
0
}
13643
0
case OP_InitGlobalUint16: {
13644
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13645
0
  if (!InitGlobal<PT_Uint16>(S, OpPC, V0))
13646
0
    return false;
13647
0
  continue;
13648
0
}
13649
0
case OP_InitGlobalSint32: {
13650
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13651
0
  if (!InitGlobal<PT_Sint32>(S, OpPC, V0))
13652
0
    return false;
13653
0
  continue;
13654
0
}
13655
0
case OP_InitGlobalUint32: {
13656
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13657
0
  if (!InitGlobal<PT_Uint32>(S, OpPC, V0))
13658
0
    return false;
13659
0
  continue;
13660
0
}
13661
0
case OP_InitGlobalSint64: {
13662
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13663
0
  if (!InitGlobal<PT_Sint64>(S, OpPC, V0))
13664
0
    return false;
13665
0
  continue;
13666
0
}
13667
0
case OP_InitGlobalUint64: {
13668
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13669
0
  if (!InitGlobal<PT_Uint64>(S, OpPC, V0))
13670
0
    return false;
13671
0
  continue;
13672
0
}
13673
0
case OP_InitGlobalIntAP: {
13674
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13675
0
  if (!InitGlobal<PT_IntAP>(S, OpPC, V0))
13676
0
    return false;
13677
0
  continue;
13678
0
}
13679
0
case OP_InitGlobalIntAPS: {
13680
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13681
0
  if (!InitGlobal<PT_IntAPS>(S, OpPC, V0))
13682
0
    return false;
13683
0
  continue;
13684
0
}
13685
0
case OP_InitGlobalBool: {
13686
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13687
0
  if (!InitGlobal<PT_Bool>(S, OpPC, V0))
13688
0
    return false;
13689
0
  continue;
13690
0
}
13691
0
case OP_InitGlobalPtr: {
13692
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13693
0
  if (!InitGlobal<PT_Ptr>(S, OpPC, V0))
13694
0
    return false;
13695
0
  continue;
13696
0
}
13697
0
case OP_InitGlobalFnPtr: {
13698
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13699
0
  if (!InitGlobal<PT_FnPtr>(S, OpPC, V0))
13700
0
    return false;
13701
0
  continue;
13702
0
}
13703
0
case OP_InitGlobalFloat: {
13704
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13705
0
  if (!InitGlobal<PT_Float>(S, OpPC, V0))
13706
0
    return false;
13707
0
  continue;
13708
0
}
13709
0
#endif
13710
#ifdef GET_DISASM
13711
case OP_InitGlobalSint8:
13712
  PrintName("InitGlobalSint8");
13713
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13714
  continue;
13715
case OP_InitGlobalUint8:
13716
  PrintName("InitGlobalUint8");
13717
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13718
  continue;
13719
case OP_InitGlobalSint16:
13720
  PrintName("InitGlobalSint16");
13721
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13722
  continue;
13723
case OP_InitGlobalUint16:
13724
  PrintName("InitGlobalUint16");
13725
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13726
  continue;
13727
case OP_InitGlobalSint32:
13728
  PrintName("InitGlobalSint32");
13729
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13730
  continue;
13731
case OP_InitGlobalUint32:
13732
  PrintName("InitGlobalUint32");
13733
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13734
  continue;
13735
case OP_InitGlobalSint64:
13736
  PrintName("InitGlobalSint64");
13737
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13738
  continue;
13739
case OP_InitGlobalUint64:
13740
  PrintName("InitGlobalUint64");
13741
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13742
  continue;
13743
case OP_InitGlobalIntAP:
13744
  PrintName("InitGlobalIntAP");
13745
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13746
  continue;
13747
case OP_InitGlobalIntAPS:
13748
  PrintName("InitGlobalIntAPS");
13749
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13750
  continue;
13751
case OP_InitGlobalBool:
13752
  PrintName("InitGlobalBool");
13753
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13754
  continue;
13755
case OP_InitGlobalPtr:
13756
  PrintName("InitGlobalPtr");
13757
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13758
  continue;
13759
case OP_InitGlobalFnPtr:
13760
  PrintName("InitGlobalFnPtr");
13761
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13762
  continue;
13763
case OP_InitGlobalFloat:
13764
  PrintName("InitGlobalFloat");
13765
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
13766
  continue;
13767
#endif
13768
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13769
bool emitInitGlobalSint8(uint32_t, const SourceInfo &);
13770
bool emitInitGlobalUint8(uint32_t, const SourceInfo &);
13771
bool emitInitGlobalSint16(uint32_t, const SourceInfo &);
13772
bool emitInitGlobalUint16(uint32_t, const SourceInfo &);
13773
bool emitInitGlobalSint32(uint32_t, const SourceInfo &);
13774
bool emitInitGlobalUint32(uint32_t, const SourceInfo &);
13775
bool emitInitGlobalSint64(uint32_t, const SourceInfo &);
13776
bool emitInitGlobalUint64(uint32_t, const SourceInfo &);
13777
bool emitInitGlobalIntAP(uint32_t, const SourceInfo &);
13778
bool emitInitGlobalIntAPS(uint32_t, const SourceInfo &);
13779
bool emitInitGlobalBool(uint32_t, const SourceInfo &);
13780
bool emitInitGlobalPtr(uint32_t, const SourceInfo &);
13781
bool emitInitGlobalFnPtr(uint32_t, const SourceInfo &);
13782
bool emitInitGlobalFloat(uint32_t, const SourceInfo &);
13783
#endif
13784
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13785
bool emitInitGlobal(PrimType, uint32_t, const SourceInfo &I);
13786
#endif
13787
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
13788
bool
13789
#if defined(GET_EVAL_IMPL)
13790
EvalEmitter
13791
#else
13792
ByteCodeEmitter
13793
#endif
13794
0
::emitInitGlobal(PrimType T0, uint32_t A0, const SourceInfo &I) {
13795
0
  switch (T0) {
13796
0
  case PT_Sint8:
13797
0
    return emitInitGlobalSint8(A0, I);
13798
0
  case PT_Uint8:
13799
0
    return emitInitGlobalUint8(A0, I);
13800
0
  case PT_Sint16:
13801
0
    return emitInitGlobalSint16(A0, I);
13802
0
  case PT_Uint16:
13803
0
    return emitInitGlobalUint16(A0, I);
13804
0
  case PT_Sint32:
13805
0
    return emitInitGlobalSint32(A0, I);
13806
0
  case PT_Uint32:
13807
0
    return emitInitGlobalUint32(A0, I);
13808
0
  case PT_Sint64:
13809
0
    return emitInitGlobalSint64(A0, I);
13810
0
  case PT_Uint64:
13811
0
    return emitInitGlobalUint64(A0, I);
13812
0
  case PT_IntAP:
13813
0
    return emitInitGlobalIntAP(A0, I);
13814
0
  case PT_IntAPS:
13815
0
    return emitInitGlobalIntAPS(A0, I);
13816
0
  case PT_Bool:
13817
0
    return emitInitGlobalBool(A0, I);
13818
0
  case PT_Ptr:
13819
0
    return emitInitGlobalPtr(A0, I);
13820
0
  case PT_FnPtr:
13821
0
    return emitInitGlobalFnPtr(A0, I);
13822
0
  case PT_Float:
13823
0
    return emitInitGlobalFloat(A0, I);
13824
0
  }
13825
0
  llvm_unreachable("invalid enum value");
13826
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitGlobal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitGlobal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
13827
#endif
13828
#ifdef GET_LINK_IMPL
13829
0
bool ByteCodeEmitter::emitInitGlobalSint8(uint32_t A0, const SourceInfo &L) {
13830
0
  return emitOp<uint32_t>(OP_InitGlobalSint8, A0, L);
13831
0
}
13832
0
bool ByteCodeEmitter::emitInitGlobalUint8(uint32_t A0, const SourceInfo &L) {
13833
0
  return emitOp<uint32_t>(OP_InitGlobalUint8, A0, L);
13834
0
}
13835
0
bool ByteCodeEmitter::emitInitGlobalSint16(uint32_t A0, const SourceInfo &L) {
13836
0
  return emitOp<uint32_t>(OP_InitGlobalSint16, A0, L);
13837
0
}
13838
0
bool ByteCodeEmitter::emitInitGlobalUint16(uint32_t A0, const SourceInfo &L) {
13839
0
  return emitOp<uint32_t>(OP_InitGlobalUint16, A0, L);
13840
0
}
13841
0
bool ByteCodeEmitter::emitInitGlobalSint32(uint32_t A0, const SourceInfo &L) {
13842
0
  return emitOp<uint32_t>(OP_InitGlobalSint32, A0, L);
13843
0
}
13844
0
bool ByteCodeEmitter::emitInitGlobalUint32(uint32_t A0, const SourceInfo &L) {
13845
0
  return emitOp<uint32_t>(OP_InitGlobalUint32, A0, L);
13846
0
}
13847
0
bool ByteCodeEmitter::emitInitGlobalSint64(uint32_t A0, const SourceInfo &L) {
13848
0
  return emitOp<uint32_t>(OP_InitGlobalSint64, A0, L);
13849
0
}
13850
0
bool ByteCodeEmitter::emitInitGlobalUint64(uint32_t A0, const SourceInfo &L) {
13851
0
  return emitOp<uint32_t>(OP_InitGlobalUint64, A0, L);
13852
0
}
13853
0
bool ByteCodeEmitter::emitInitGlobalIntAP(uint32_t A0, const SourceInfo &L) {
13854
0
  return emitOp<uint32_t>(OP_InitGlobalIntAP, A0, L);
13855
0
}
13856
0
bool ByteCodeEmitter::emitInitGlobalIntAPS(uint32_t A0, const SourceInfo &L) {
13857
0
  return emitOp<uint32_t>(OP_InitGlobalIntAPS, A0, L);
13858
0
}
13859
0
bool ByteCodeEmitter::emitInitGlobalBool(uint32_t A0, const SourceInfo &L) {
13860
0
  return emitOp<uint32_t>(OP_InitGlobalBool, A0, L);
13861
0
}
13862
0
bool ByteCodeEmitter::emitInitGlobalPtr(uint32_t A0, const SourceInfo &L) {
13863
0
  return emitOp<uint32_t>(OP_InitGlobalPtr, A0, L);
13864
0
}
13865
0
bool ByteCodeEmitter::emitInitGlobalFnPtr(uint32_t A0, const SourceInfo &L) {
13866
0
  return emitOp<uint32_t>(OP_InitGlobalFnPtr, A0, L);
13867
0
}
13868
0
bool ByteCodeEmitter::emitInitGlobalFloat(uint32_t A0, const SourceInfo &L) {
13869
0
  return emitOp<uint32_t>(OP_InitGlobalFloat, A0, L);
13870
0
}
13871
#endif
13872
#ifdef GET_EVAL_IMPL
13873
0
bool EvalEmitter::emitInitGlobalSint8(uint32_t A0, const SourceInfo &L) {
13874
0
  if (!isActive()) return true;
13875
0
  CurrentSource = L;
13876
0
  return InitGlobal<PT_Sint8>(S, OpPC, A0);
13877
0
}
13878
0
bool EvalEmitter::emitInitGlobalUint8(uint32_t A0, const SourceInfo &L) {
13879
0
  if (!isActive()) return true;
13880
0
  CurrentSource = L;
13881
0
  return InitGlobal<PT_Uint8>(S, OpPC, A0);
13882
0
}
13883
0
bool EvalEmitter::emitInitGlobalSint16(uint32_t A0, const SourceInfo &L) {
13884
0
  if (!isActive()) return true;
13885
0
  CurrentSource = L;
13886
0
  return InitGlobal<PT_Sint16>(S, OpPC, A0);
13887
0
}
13888
0
bool EvalEmitter::emitInitGlobalUint16(uint32_t A0, const SourceInfo &L) {
13889
0
  if (!isActive()) return true;
13890
0
  CurrentSource = L;
13891
0
  return InitGlobal<PT_Uint16>(S, OpPC, A0);
13892
0
}
13893
0
bool EvalEmitter::emitInitGlobalSint32(uint32_t A0, const SourceInfo &L) {
13894
0
  if (!isActive()) return true;
13895
0
  CurrentSource = L;
13896
0
  return InitGlobal<PT_Sint32>(S, OpPC, A0);
13897
0
}
13898
0
bool EvalEmitter::emitInitGlobalUint32(uint32_t A0, const SourceInfo &L) {
13899
0
  if (!isActive()) return true;
13900
0
  CurrentSource = L;
13901
0
  return InitGlobal<PT_Uint32>(S, OpPC, A0);
13902
0
}
13903
0
bool EvalEmitter::emitInitGlobalSint64(uint32_t A0, const SourceInfo &L) {
13904
0
  if (!isActive()) return true;
13905
0
  CurrentSource = L;
13906
0
  return InitGlobal<PT_Sint64>(S, OpPC, A0);
13907
0
}
13908
0
bool EvalEmitter::emitInitGlobalUint64(uint32_t A0, const SourceInfo &L) {
13909
0
  if (!isActive()) return true;
13910
0
  CurrentSource = L;
13911
0
  return InitGlobal<PT_Uint64>(S, OpPC, A0);
13912
0
}
13913
0
bool EvalEmitter::emitInitGlobalIntAP(uint32_t A0, const SourceInfo &L) {
13914
0
  if (!isActive()) return true;
13915
0
  CurrentSource = L;
13916
0
  return InitGlobal<PT_IntAP>(S, OpPC, A0);
13917
0
}
13918
0
bool EvalEmitter::emitInitGlobalIntAPS(uint32_t A0, const SourceInfo &L) {
13919
0
  if (!isActive()) return true;
13920
0
  CurrentSource = L;
13921
0
  return InitGlobal<PT_IntAPS>(S, OpPC, A0);
13922
0
}
13923
0
bool EvalEmitter::emitInitGlobalBool(uint32_t A0, const SourceInfo &L) {
13924
0
  if (!isActive()) return true;
13925
0
  CurrentSource = L;
13926
0
  return InitGlobal<PT_Bool>(S, OpPC, A0);
13927
0
}
13928
0
bool EvalEmitter::emitInitGlobalPtr(uint32_t A0, const SourceInfo &L) {
13929
0
  if (!isActive()) return true;
13930
0
  CurrentSource = L;
13931
0
  return InitGlobal<PT_Ptr>(S, OpPC, A0);
13932
0
}
13933
0
bool EvalEmitter::emitInitGlobalFnPtr(uint32_t A0, const SourceInfo &L) {
13934
0
  if (!isActive()) return true;
13935
0
  CurrentSource = L;
13936
0
  return InitGlobal<PT_FnPtr>(S, OpPC, A0);
13937
0
}
13938
0
bool EvalEmitter::emitInitGlobalFloat(uint32_t A0, const SourceInfo &L) {
13939
0
  if (!isActive()) return true;
13940
0
  CurrentSource = L;
13941
0
  return InitGlobal<PT_Float>(S, OpPC, A0);
13942
0
}
13943
#endif
13944
#ifdef GET_OPCODE_NAMES
13945
OP_InitGlobalTempSint8,
13946
OP_InitGlobalTempUint8,
13947
OP_InitGlobalTempSint16,
13948
OP_InitGlobalTempUint16,
13949
OP_InitGlobalTempSint32,
13950
OP_InitGlobalTempUint32,
13951
OP_InitGlobalTempSint64,
13952
OP_InitGlobalTempUint64,
13953
OP_InitGlobalTempIntAP,
13954
OP_InitGlobalTempIntAPS,
13955
OP_InitGlobalTempBool,
13956
OP_InitGlobalTempPtr,
13957
OP_InitGlobalTempFnPtr,
13958
OP_InitGlobalTempFloat,
13959
#endif
13960
0
#ifdef GET_INTERP
13961
0
case OP_InitGlobalTempSint8: {
13962
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13963
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
13964
0
  if (!InitGlobalTemp<PT_Sint8>(S, OpPC, V0, V1))
13965
0
    return false;
13966
0
  continue;
13967
0
}
13968
0
case OP_InitGlobalTempUint8: {
13969
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13970
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
13971
0
  if (!InitGlobalTemp<PT_Uint8>(S, OpPC, V0, V1))
13972
0
    return false;
13973
0
  continue;
13974
0
}
13975
0
case OP_InitGlobalTempSint16: {
13976
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13977
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
13978
0
  if (!InitGlobalTemp<PT_Sint16>(S, OpPC, V0, V1))
13979
0
    return false;
13980
0
  continue;
13981
0
}
13982
0
case OP_InitGlobalTempUint16: {
13983
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13984
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
13985
0
  if (!InitGlobalTemp<PT_Uint16>(S, OpPC, V0, V1))
13986
0
    return false;
13987
0
  continue;
13988
0
}
13989
0
case OP_InitGlobalTempSint32: {
13990
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13991
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
13992
0
  if (!InitGlobalTemp<PT_Sint32>(S, OpPC, V0, V1))
13993
0
    return false;
13994
0
  continue;
13995
0
}
13996
0
case OP_InitGlobalTempUint32: {
13997
0
  auto V0 = ReadArg<uint32_t>(S, PC);
13998
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
13999
0
  if (!InitGlobalTemp<PT_Uint32>(S, OpPC, V0, V1))
14000
0
    return false;
14001
0
  continue;
14002
0
}
14003
0
case OP_InitGlobalTempSint64: {
14004
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14005
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14006
0
  if (!InitGlobalTemp<PT_Sint64>(S, OpPC, V0, V1))
14007
0
    return false;
14008
0
  continue;
14009
0
}
14010
0
case OP_InitGlobalTempUint64: {
14011
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14012
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14013
0
  if (!InitGlobalTemp<PT_Uint64>(S, OpPC, V0, V1))
14014
0
    return false;
14015
0
  continue;
14016
0
}
14017
0
case OP_InitGlobalTempIntAP: {
14018
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14019
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14020
0
  if (!InitGlobalTemp<PT_IntAP>(S, OpPC, V0, V1))
14021
0
    return false;
14022
0
  continue;
14023
0
}
14024
0
case OP_InitGlobalTempIntAPS: {
14025
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14026
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14027
0
  if (!InitGlobalTemp<PT_IntAPS>(S, OpPC, V0, V1))
14028
0
    return false;
14029
0
  continue;
14030
0
}
14031
0
case OP_InitGlobalTempBool: {
14032
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14033
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14034
0
  if (!InitGlobalTemp<PT_Bool>(S, OpPC, V0, V1))
14035
0
    return false;
14036
0
  continue;
14037
0
}
14038
0
case OP_InitGlobalTempPtr: {
14039
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14040
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14041
0
  if (!InitGlobalTemp<PT_Ptr>(S, OpPC, V0, V1))
14042
0
    return false;
14043
0
  continue;
14044
0
}
14045
0
case OP_InitGlobalTempFnPtr: {
14046
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14047
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14048
0
  if (!InitGlobalTemp<PT_FnPtr>(S, OpPC, V0, V1))
14049
0
    return false;
14050
0
  continue;
14051
0
}
14052
0
case OP_InitGlobalTempFloat: {
14053
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14054
0
  auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14055
0
  if (!InitGlobalTemp<PT_Float>(S, OpPC, V0, V1))
14056
0
    return false;
14057
0
  continue;
14058
0
}
14059
0
#endif
14060
#ifdef GET_DISASM
14061
case OP_InitGlobalTempSint8:
14062
  PrintName("InitGlobalTempSint8");
14063
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14064
  continue;
14065
case OP_InitGlobalTempUint8:
14066
  PrintName("InitGlobalTempUint8");
14067
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14068
  continue;
14069
case OP_InitGlobalTempSint16:
14070
  PrintName("InitGlobalTempSint16");
14071
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14072
  continue;
14073
case OP_InitGlobalTempUint16:
14074
  PrintName("InitGlobalTempUint16");
14075
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14076
  continue;
14077
case OP_InitGlobalTempSint32:
14078
  PrintName("InitGlobalTempSint32");
14079
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14080
  continue;
14081
case OP_InitGlobalTempUint32:
14082
  PrintName("InitGlobalTempUint32");
14083
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14084
  continue;
14085
case OP_InitGlobalTempSint64:
14086
  PrintName("InitGlobalTempSint64");
14087
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14088
  continue;
14089
case OP_InitGlobalTempUint64:
14090
  PrintName("InitGlobalTempUint64");
14091
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14092
  continue;
14093
case OP_InitGlobalTempIntAP:
14094
  PrintName("InitGlobalTempIntAP");
14095
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14096
  continue;
14097
case OP_InitGlobalTempIntAPS:
14098
  PrintName("InitGlobalTempIntAPS");
14099
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14100
  continue;
14101
case OP_InitGlobalTempBool:
14102
  PrintName("InitGlobalTempBool");
14103
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14104
  continue;
14105
case OP_InitGlobalTempPtr:
14106
  PrintName("InitGlobalTempPtr");
14107
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14108
  continue;
14109
case OP_InitGlobalTempFnPtr:
14110
  PrintName("InitGlobalTempFnPtr");
14111
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14112
  continue;
14113
case OP_InitGlobalTempFloat:
14114
  PrintName("InitGlobalTempFloat");
14115
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14116
  continue;
14117
#endif
14118
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14119
bool emitInitGlobalTempSint8(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14120
bool emitInitGlobalTempUint8(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14121
bool emitInitGlobalTempSint16(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14122
bool emitInitGlobalTempUint16(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14123
bool emitInitGlobalTempSint32(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14124
bool emitInitGlobalTempUint32(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14125
bool emitInitGlobalTempSint64(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14126
bool emitInitGlobalTempUint64(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14127
bool emitInitGlobalTempIntAP(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14128
bool emitInitGlobalTempIntAPS(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14129
bool emitInitGlobalTempBool(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14130
bool emitInitGlobalTempPtr(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14131
bool emitInitGlobalTempFnPtr(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14132
bool emitInitGlobalTempFloat(uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14133
#endif
14134
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14135
bool emitInitGlobalTemp(PrimType, uint32_t, const LifetimeExtendedTemporaryDecl *, const SourceInfo &I);
14136
#endif
14137
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
14138
bool
14139
#if defined(GET_EVAL_IMPL)
14140
EvalEmitter
14141
#else
14142
ByteCodeEmitter
14143
#endif
14144
0
::emitInitGlobalTemp(PrimType T0, uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &I) {
14145
0
  switch (T0) {
14146
0
  case PT_Sint8:
14147
0
    return emitInitGlobalTempSint8(A0, A1, I);
14148
0
  case PT_Uint8:
14149
0
    return emitInitGlobalTempUint8(A0, A1, I);
14150
0
  case PT_Sint16:
14151
0
    return emitInitGlobalTempSint16(A0, A1, I);
14152
0
  case PT_Uint16:
14153
0
    return emitInitGlobalTempUint16(A0, A1, I);
14154
0
  case PT_Sint32:
14155
0
    return emitInitGlobalTempSint32(A0, A1, I);
14156
0
  case PT_Uint32:
14157
0
    return emitInitGlobalTempUint32(A0, A1, I);
14158
0
  case PT_Sint64:
14159
0
    return emitInitGlobalTempSint64(A0, A1, I);
14160
0
  case PT_Uint64:
14161
0
    return emitInitGlobalTempUint64(A0, A1, I);
14162
0
  case PT_IntAP:
14163
0
    return emitInitGlobalTempIntAP(A0, A1, I);
14164
0
  case PT_IntAPS:
14165
0
    return emitInitGlobalTempIntAPS(A0, A1, I);
14166
0
  case PT_Bool:
14167
0
    return emitInitGlobalTempBool(A0, A1, I);
14168
0
  case PT_Ptr:
14169
0
    return emitInitGlobalTempPtr(A0, A1, I);
14170
0
  case PT_FnPtr:
14171
0
    return emitInitGlobalTempFnPtr(A0, A1, I);
14172
0
  case PT_Float:
14173
0
    return emitInitGlobalTempFloat(A0, A1, I);
14174
0
  }
14175
0
  llvm_unreachable("invalid enum value");
14176
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitGlobalTemp(clang::interp::PrimType, unsigned int, clang::LifetimeExtendedTemporaryDecl const*, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitGlobalTemp(clang::interp::PrimType, unsigned int, clang::LifetimeExtendedTemporaryDecl const*, clang::interp::SourceInfo const&)
14177
#endif
14178
#ifdef GET_LINK_IMPL
14179
0
bool ByteCodeEmitter::emitInitGlobalTempSint8(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14180
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint8, A0, A1, L);
14181
0
}
14182
0
bool ByteCodeEmitter::emitInitGlobalTempUint8(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14183
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint8, A0, A1, L);
14184
0
}
14185
0
bool ByteCodeEmitter::emitInitGlobalTempSint16(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14186
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint16, A0, A1, L);
14187
0
}
14188
0
bool ByteCodeEmitter::emitInitGlobalTempUint16(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14189
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint16, A0, A1, L);
14190
0
}
14191
0
bool ByteCodeEmitter::emitInitGlobalTempSint32(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14192
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint32, A0, A1, L);
14193
0
}
14194
0
bool ByteCodeEmitter::emitInitGlobalTempUint32(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14195
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint32, A0, A1, L);
14196
0
}
14197
0
bool ByteCodeEmitter::emitInitGlobalTempSint64(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14198
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint64, A0, A1, L);
14199
0
}
14200
0
bool ByteCodeEmitter::emitInitGlobalTempUint64(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14201
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint64, A0, A1, L);
14202
0
}
14203
0
bool ByteCodeEmitter::emitInitGlobalTempIntAP(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14204
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempIntAP, A0, A1, L);
14205
0
}
14206
0
bool ByteCodeEmitter::emitInitGlobalTempIntAPS(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14207
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempIntAPS, A0, A1, L);
14208
0
}
14209
0
bool ByteCodeEmitter::emitInitGlobalTempBool(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14210
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempBool, A0, A1, L);
14211
0
}
14212
0
bool ByteCodeEmitter::emitInitGlobalTempPtr(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14213
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempPtr, A0, A1, L);
14214
0
}
14215
0
bool ByteCodeEmitter::emitInitGlobalTempFnPtr(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14216
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempFnPtr, A0, A1, L);
14217
0
}
14218
0
bool ByteCodeEmitter::emitInitGlobalTempFloat(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14219
0
  return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempFloat, A0, A1, L);
14220
0
}
14221
#endif
14222
#ifdef GET_EVAL_IMPL
14223
0
bool EvalEmitter::emitInitGlobalTempSint8(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14224
0
  if (!isActive()) return true;
14225
0
  CurrentSource = L;
14226
0
  return InitGlobalTemp<PT_Sint8>(S, OpPC, A0, A1);
14227
0
}
14228
0
bool EvalEmitter::emitInitGlobalTempUint8(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14229
0
  if (!isActive()) return true;
14230
0
  CurrentSource = L;
14231
0
  return InitGlobalTemp<PT_Uint8>(S, OpPC, A0, A1);
14232
0
}
14233
0
bool EvalEmitter::emitInitGlobalTempSint16(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14234
0
  if (!isActive()) return true;
14235
0
  CurrentSource = L;
14236
0
  return InitGlobalTemp<PT_Sint16>(S, OpPC, A0, A1);
14237
0
}
14238
0
bool EvalEmitter::emitInitGlobalTempUint16(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14239
0
  if (!isActive()) return true;
14240
0
  CurrentSource = L;
14241
0
  return InitGlobalTemp<PT_Uint16>(S, OpPC, A0, A1);
14242
0
}
14243
0
bool EvalEmitter::emitInitGlobalTempSint32(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14244
0
  if (!isActive()) return true;
14245
0
  CurrentSource = L;
14246
0
  return InitGlobalTemp<PT_Sint32>(S, OpPC, A0, A1);
14247
0
}
14248
0
bool EvalEmitter::emitInitGlobalTempUint32(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14249
0
  if (!isActive()) return true;
14250
0
  CurrentSource = L;
14251
0
  return InitGlobalTemp<PT_Uint32>(S, OpPC, A0, A1);
14252
0
}
14253
0
bool EvalEmitter::emitInitGlobalTempSint64(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14254
0
  if (!isActive()) return true;
14255
0
  CurrentSource = L;
14256
0
  return InitGlobalTemp<PT_Sint64>(S, OpPC, A0, A1);
14257
0
}
14258
0
bool EvalEmitter::emitInitGlobalTempUint64(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14259
0
  if (!isActive()) return true;
14260
0
  CurrentSource = L;
14261
0
  return InitGlobalTemp<PT_Uint64>(S, OpPC, A0, A1);
14262
0
}
14263
0
bool EvalEmitter::emitInitGlobalTempIntAP(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14264
0
  if (!isActive()) return true;
14265
0
  CurrentSource = L;
14266
0
  return InitGlobalTemp<PT_IntAP>(S, OpPC, A0, A1);
14267
0
}
14268
0
bool EvalEmitter::emitInitGlobalTempIntAPS(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14269
0
  if (!isActive()) return true;
14270
0
  CurrentSource = L;
14271
0
  return InitGlobalTemp<PT_IntAPS>(S, OpPC, A0, A1);
14272
0
}
14273
0
bool EvalEmitter::emitInitGlobalTempBool(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14274
0
  if (!isActive()) return true;
14275
0
  CurrentSource = L;
14276
0
  return InitGlobalTemp<PT_Bool>(S, OpPC, A0, A1);
14277
0
}
14278
0
bool EvalEmitter::emitInitGlobalTempPtr(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14279
0
  if (!isActive()) return true;
14280
0
  CurrentSource = L;
14281
0
  return InitGlobalTemp<PT_Ptr>(S, OpPC, A0, A1);
14282
0
}
14283
0
bool EvalEmitter::emitInitGlobalTempFnPtr(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14284
0
  if (!isActive()) return true;
14285
0
  CurrentSource = L;
14286
0
  return InitGlobalTemp<PT_FnPtr>(S, OpPC, A0, A1);
14287
0
}
14288
0
bool EvalEmitter::emitInitGlobalTempFloat(uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, const SourceInfo &L) {
14289
0
  if (!isActive()) return true;
14290
0
  CurrentSource = L;
14291
0
  return InitGlobalTemp<PT_Float>(S, OpPC, A0, A1);
14292
0
}
14293
#endif
14294
#ifdef GET_OPCODE_NAMES
14295
OP_InitGlobalTempComp,
14296
#endif
14297
0
#ifdef GET_INTERP
14298
0
case OP_InitGlobalTempComp: {
14299
0
  auto V0 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, PC);
14300
0
  if (!InitGlobalTempComp(S, OpPC, V0))
14301
0
    return false;
14302
0
  continue;
14303
0
}
14304
0
#endif
14305
#ifdef GET_DISASM
14306
case OP_InitGlobalTempComp:
14307
  PrintName("InitGlobalTempComp");
14308
  OS << "\t" << ReadArg<const LifetimeExtendedTemporaryDecl *>(P, PC) << " " << "\n";
14309
  continue;
14310
#endif
14311
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14312
bool emitInitGlobalTempComp(const LifetimeExtendedTemporaryDecl *, const SourceInfo &);
14313
#endif
14314
#ifdef GET_LINK_IMPL
14315
0
bool ByteCodeEmitter::emitInitGlobalTempComp(const LifetimeExtendedTemporaryDecl * A0, const SourceInfo &L) {
14316
0
  return emitOp<const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempComp, A0, L);
14317
0
}
14318
#endif
14319
#ifdef GET_EVAL_IMPL
14320
0
bool EvalEmitter::emitInitGlobalTempComp(const LifetimeExtendedTemporaryDecl * A0, const SourceInfo &L) {
14321
0
  if (!isActive()) return true;
14322
0
  CurrentSource = L;
14323
0
  return InitGlobalTempComp(S, OpPC, A0);
14324
0
}
14325
#endif
14326
#ifdef GET_OPCODE_NAMES
14327
OP_InitPopSint8,
14328
OP_InitPopUint8,
14329
OP_InitPopSint16,
14330
OP_InitPopUint16,
14331
OP_InitPopSint32,
14332
OP_InitPopUint32,
14333
OP_InitPopSint64,
14334
OP_InitPopUint64,
14335
OP_InitPopIntAP,
14336
OP_InitPopIntAPS,
14337
OP_InitPopBool,
14338
OP_InitPopPtr,
14339
OP_InitPopFnPtr,
14340
OP_InitPopFloat,
14341
#endif
14342
0
#ifdef GET_INTERP
14343
0
case OP_InitPopSint8: {
14344
0
  if (!InitPop<PT_Sint8>(S, OpPC))
14345
0
    return false;
14346
0
  continue;
14347
0
}
14348
0
case OP_InitPopUint8: {
14349
0
  if (!InitPop<PT_Uint8>(S, OpPC))
14350
0
    return false;
14351
0
  continue;
14352
0
}
14353
0
case OP_InitPopSint16: {
14354
0
  if (!InitPop<PT_Sint16>(S, OpPC))
14355
0
    return false;
14356
0
  continue;
14357
0
}
14358
0
case OP_InitPopUint16: {
14359
0
  if (!InitPop<PT_Uint16>(S, OpPC))
14360
0
    return false;
14361
0
  continue;
14362
0
}
14363
0
case OP_InitPopSint32: {
14364
0
  if (!InitPop<PT_Sint32>(S, OpPC))
14365
0
    return false;
14366
0
  continue;
14367
0
}
14368
0
case OP_InitPopUint32: {
14369
0
  if (!InitPop<PT_Uint32>(S, OpPC))
14370
0
    return false;
14371
0
  continue;
14372
0
}
14373
0
case OP_InitPopSint64: {
14374
0
  if (!InitPop<PT_Sint64>(S, OpPC))
14375
0
    return false;
14376
0
  continue;
14377
0
}
14378
0
case OP_InitPopUint64: {
14379
0
  if (!InitPop<PT_Uint64>(S, OpPC))
14380
0
    return false;
14381
0
  continue;
14382
0
}
14383
0
case OP_InitPopIntAP: {
14384
0
  if (!InitPop<PT_IntAP>(S, OpPC))
14385
0
    return false;
14386
0
  continue;
14387
0
}
14388
0
case OP_InitPopIntAPS: {
14389
0
  if (!InitPop<PT_IntAPS>(S, OpPC))
14390
0
    return false;
14391
0
  continue;
14392
0
}
14393
0
case OP_InitPopBool: {
14394
0
  if (!InitPop<PT_Bool>(S, OpPC))
14395
0
    return false;
14396
0
  continue;
14397
0
}
14398
0
case OP_InitPopPtr: {
14399
0
  if (!InitPop<PT_Ptr>(S, OpPC))
14400
0
    return false;
14401
0
  continue;
14402
0
}
14403
0
case OP_InitPopFnPtr: {
14404
0
  if (!InitPop<PT_FnPtr>(S, OpPC))
14405
0
    return false;
14406
0
  continue;
14407
0
}
14408
0
case OP_InitPopFloat: {
14409
0
  if (!InitPop<PT_Float>(S, OpPC))
14410
0
    return false;
14411
0
  continue;
14412
0
}
14413
0
#endif
14414
#ifdef GET_DISASM
14415
case OP_InitPopSint8:
14416
  PrintName("InitPopSint8");
14417
  OS << "\t" << "\n";
14418
  continue;
14419
case OP_InitPopUint8:
14420
  PrintName("InitPopUint8");
14421
  OS << "\t" << "\n";
14422
  continue;
14423
case OP_InitPopSint16:
14424
  PrintName("InitPopSint16");
14425
  OS << "\t" << "\n";
14426
  continue;
14427
case OP_InitPopUint16:
14428
  PrintName("InitPopUint16");
14429
  OS << "\t" << "\n";
14430
  continue;
14431
case OP_InitPopSint32:
14432
  PrintName("InitPopSint32");
14433
  OS << "\t" << "\n";
14434
  continue;
14435
case OP_InitPopUint32:
14436
  PrintName("InitPopUint32");
14437
  OS << "\t" << "\n";
14438
  continue;
14439
case OP_InitPopSint64:
14440
  PrintName("InitPopSint64");
14441
  OS << "\t" << "\n";
14442
  continue;
14443
case OP_InitPopUint64:
14444
  PrintName("InitPopUint64");
14445
  OS << "\t" << "\n";
14446
  continue;
14447
case OP_InitPopIntAP:
14448
  PrintName("InitPopIntAP");
14449
  OS << "\t" << "\n";
14450
  continue;
14451
case OP_InitPopIntAPS:
14452
  PrintName("InitPopIntAPS");
14453
  OS << "\t" << "\n";
14454
  continue;
14455
case OP_InitPopBool:
14456
  PrintName("InitPopBool");
14457
  OS << "\t" << "\n";
14458
  continue;
14459
case OP_InitPopPtr:
14460
  PrintName("InitPopPtr");
14461
  OS << "\t" << "\n";
14462
  continue;
14463
case OP_InitPopFnPtr:
14464
  PrintName("InitPopFnPtr");
14465
  OS << "\t" << "\n";
14466
  continue;
14467
case OP_InitPopFloat:
14468
  PrintName("InitPopFloat");
14469
  OS << "\t" << "\n";
14470
  continue;
14471
#endif
14472
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14473
bool emitInitPopSint8(const SourceInfo &);
14474
bool emitInitPopUint8(const SourceInfo &);
14475
bool emitInitPopSint16(const SourceInfo &);
14476
bool emitInitPopUint16(const SourceInfo &);
14477
bool emitInitPopSint32(const SourceInfo &);
14478
bool emitInitPopUint32(const SourceInfo &);
14479
bool emitInitPopSint64(const SourceInfo &);
14480
bool emitInitPopUint64(const SourceInfo &);
14481
bool emitInitPopIntAP(const SourceInfo &);
14482
bool emitInitPopIntAPS(const SourceInfo &);
14483
bool emitInitPopBool(const SourceInfo &);
14484
bool emitInitPopPtr(const SourceInfo &);
14485
bool emitInitPopFnPtr(const SourceInfo &);
14486
bool emitInitPopFloat(const SourceInfo &);
14487
#endif
14488
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14489
bool emitInitPop(PrimType, const SourceInfo &I);
14490
#endif
14491
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
14492
bool
14493
#if defined(GET_EVAL_IMPL)
14494
EvalEmitter
14495
#else
14496
ByteCodeEmitter
14497
#endif
14498
0
::emitInitPop(PrimType T0, const SourceInfo &I) {
14499
0
  switch (T0) {
14500
0
  case PT_Sint8:
14501
0
    return emitInitPopSint8(I);
14502
0
  case PT_Uint8:
14503
0
    return emitInitPopUint8(I);
14504
0
  case PT_Sint16:
14505
0
    return emitInitPopSint16(I);
14506
0
  case PT_Uint16:
14507
0
    return emitInitPopUint16(I);
14508
0
  case PT_Sint32:
14509
0
    return emitInitPopSint32(I);
14510
0
  case PT_Uint32:
14511
0
    return emitInitPopUint32(I);
14512
0
  case PT_Sint64:
14513
0
    return emitInitPopSint64(I);
14514
0
  case PT_Uint64:
14515
0
    return emitInitPopUint64(I);
14516
0
  case PT_IntAP:
14517
0
    return emitInitPopIntAP(I);
14518
0
  case PT_IntAPS:
14519
0
    return emitInitPopIntAPS(I);
14520
0
  case PT_Bool:
14521
0
    return emitInitPopBool(I);
14522
0
  case PT_Ptr:
14523
0
    return emitInitPopPtr(I);
14524
0
  case PT_FnPtr:
14525
0
    return emitInitPopFnPtr(I);
14526
0
  case PT_Float:
14527
0
    return emitInitPopFloat(I);
14528
0
  }
14529
0
  llvm_unreachable("invalid enum value");
14530
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
14531
#endif
14532
#ifdef GET_LINK_IMPL
14533
0
bool ByteCodeEmitter::emitInitPopSint8(const SourceInfo &L) {
14534
0
  return emitOp<>(OP_InitPopSint8, L);
14535
0
}
14536
0
bool ByteCodeEmitter::emitInitPopUint8(const SourceInfo &L) {
14537
0
  return emitOp<>(OP_InitPopUint8, L);
14538
0
}
14539
0
bool ByteCodeEmitter::emitInitPopSint16(const SourceInfo &L) {
14540
0
  return emitOp<>(OP_InitPopSint16, L);
14541
0
}
14542
0
bool ByteCodeEmitter::emitInitPopUint16(const SourceInfo &L) {
14543
0
  return emitOp<>(OP_InitPopUint16, L);
14544
0
}
14545
0
bool ByteCodeEmitter::emitInitPopSint32(const SourceInfo &L) {
14546
0
  return emitOp<>(OP_InitPopSint32, L);
14547
0
}
14548
0
bool ByteCodeEmitter::emitInitPopUint32(const SourceInfo &L) {
14549
0
  return emitOp<>(OP_InitPopUint32, L);
14550
0
}
14551
0
bool ByteCodeEmitter::emitInitPopSint64(const SourceInfo &L) {
14552
0
  return emitOp<>(OP_InitPopSint64, L);
14553
0
}
14554
0
bool ByteCodeEmitter::emitInitPopUint64(const SourceInfo &L) {
14555
0
  return emitOp<>(OP_InitPopUint64, L);
14556
0
}
14557
0
bool ByteCodeEmitter::emitInitPopIntAP(const SourceInfo &L) {
14558
0
  return emitOp<>(OP_InitPopIntAP, L);
14559
0
}
14560
0
bool ByteCodeEmitter::emitInitPopIntAPS(const SourceInfo &L) {
14561
0
  return emitOp<>(OP_InitPopIntAPS, L);
14562
0
}
14563
0
bool ByteCodeEmitter::emitInitPopBool(const SourceInfo &L) {
14564
0
  return emitOp<>(OP_InitPopBool, L);
14565
0
}
14566
0
bool ByteCodeEmitter::emitInitPopPtr(const SourceInfo &L) {
14567
0
  return emitOp<>(OP_InitPopPtr, L);
14568
0
}
14569
0
bool ByteCodeEmitter::emitInitPopFnPtr(const SourceInfo &L) {
14570
0
  return emitOp<>(OP_InitPopFnPtr, L);
14571
0
}
14572
0
bool ByteCodeEmitter::emitInitPopFloat(const SourceInfo &L) {
14573
0
  return emitOp<>(OP_InitPopFloat, L);
14574
0
}
14575
#endif
14576
#ifdef GET_EVAL_IMPL
14577
0
bool EvalEmitter::emitInitPopSint8(const SourceInfo &L) {
14578
0
  if (!isActive()) return true;
14579
0
  CurrentSource = L;
14580
0
  return InitPop<PT_Sint8>(S, OpPC);
14581
0
}
14582
0
bool EvalEmitter::emitInitPopUint8(const SourceInfo &L) {
14583
0
  if (!isActive()) return true;
14584
0
  CurrentSource = L;
14585
0
  return InitPop<PT_Uint8>(S, OpPC);
14586
0
}
14587
0
bool EvalEmitter::emitInitPopSint16(const SourceInfo &L) {
14588
0
  if (!isActive()) return true;
14589
0
  CurrentSource = L;
14590
0
  return InitPop<PT_Sint16>(S, OpPC);
14591
0
}
14592
0
bool EvalEmitter::emitInitPopUint16(const SourceInfo &L) {
14593
0
  if (!isActive()) return true;
14594
0
  CurrentSource = L;
14595
0
  return InitPop<PT_Uint16>(S, OpPC);
14596
0
}
14597
0
bool EvalEmitter::emitInitPopSint32(const SourceInfo &L) {
14598
0
  if (!isActive()) return true;
14599
0
  CurrentSource = L;
14600
0
  return InitPop<PT_Sint32>(S, OpPC);
14601
0
}
14602
0
bool EvalEmitter::emitInitPopUint32(const SourceInfo &L) {
14603
0
  if (!isActive()) return true;
14604
0
  CurrentSource = L;
14605
0
  return InitPop<PT_Uint32>(S, OpPC);
14606
0
}
14607
0
bool EvalEmitter::emitInitPopSint64(const SourceInfo &L) {
14608
0
  if (!isActive()) return true;
14609
0
  CurrentSource = L;
14610
0
  return InitPop<PT_Sint64>(S, OpPC);
14611
0
}
14612
0
bool EvalEmitter::emitInitPopUint64(const SourceInfo &L) {
14613
0
  if (!isActive()) return true;
14614
0
  CurrentSource = L;
14615
0
  return InitPop<PT_Uint64>(S, OpPC);
14616
0
}
14617
0
bool EvalEmitter::emitInitPopIntAP(const SourceInfo &L) {
14618
0
  if (!isActive()) return true;
14619
0
  CurrentSource = L;
14620
0
  return InitPop<PT_IntAP>(S, OpPC);
14621
0
}
14622
0
bool EvalEmitter::emitInitPopIntAPS(const SourceInfo &L) {
14623
0
  if (!isActive()) return true;
14624
0
  CurrentSource = L;
14625
0
  return InitPop<PT_IntAPS>(S, OpPC);
14626
0
}
14627
0
bool EvalEmitter::emitInitPopBool(const SourceInfo &L) {
14628
0
  if (!isActive()) return true;
14629
0
  CurrentSource = L;
14630
0
  return InitPop<PT_Bool>(S, OpPC);
14631
0
}
14632
0
bool EvalEmitter::emitInitPopPtr(const SourceInfo &L) {
14633
0
  if (!isActive()) return true;
14634
0
  CurrentSource = L;
14635
0
  return InitPop<PT_Ptr>(S, OpPC);
14636
0
}
14637
0
bool EvalEmitter::emitInitPopFnPtr(const SourceInfo &L) {
14638
0
  if (!isActive()) return true;
14639
0
  CurrentSource = L;
14640
0
  return InitPop<PT_FnPtr>(S, OpPC);
14641
0
}
14642
0
bool EvalEmitter::emitInitPopFloat(const SourceInfo &L) {
14643
0
  if (!isActive()) return true;
14644
0
  CurrentSource = L;
14645
0
  return InitPop<PT_Float>(S, OpPC);
14646
0
}
14647
#endif
14648
#ifdef GET_OPCODE_NAMES
14649
OP_InitPtrPop,
14650
#endif
14651
0
#ifdef GET_INTERP
14652
0
case OP_InitPtrPop: {
14653
0
  if (!InitPtrPop(S, OpPC))
14654
0
    return false;
14655
0
  continue;
14656
0
}
14657
0
#endif
14658
#ifdef GET_DISASM
14659
case OP_InitPtrPop:
14660
  PrintName("InitPtrPop");
14661
  OS << "\t" << "\n";
14662
  continue;
14663
#endif
14664
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14665
bool emitInitPtrPop(const SourceInfo &);
14666
#endif
14667
#ifdef GET_LINK_IMPL
14668
0
bool ByteCodeEmitter::emitInitPtrPop(const SourceInfo &L) {
14669
0
  return emitOp<>(OP_InitPtrPop, L);
14670
0
}
14671
#endif
14672
#ifdef GET_EVAL_IMPL
14673
0
bool EvalEmitter::emitInitPtrPop(const SourceInfo &L) {
14674
0
  if (!isActive()) return true;
14675
0
  CurrentSource = L;
14676
0
  return InitPtrPop(S, OpPC);
14677
0
}
14678
#endif
14679
#ifdef GET_OPCODE_NAMES
14680
OP_InitThisBitFieldSint8,
14681
OP_InitThisBitFieldUint8,
14682
OP_InitThisBitFieldSint16,
14683
OP_InitThisBitFieldUint16,
14684
OP_InitThisBitFieldSint32,
14685
OP_InitThisBitFieldUint32,
14686
OP_InitThisBitFieldSint64,
14687
OP_InitThisBitFieldUint64,
14688
OP_InitThisBitFieldIntAP,
14689
OP_InitThisBitFieldIntAPS,
14690
OP_InitThisBitFieldBool,
14691
#endif
14692
0
#ifdef GET_INTERP
14693
0
case OP_InitThisBitFieldSint8: {
14694
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14695
0
  if (!InitThisBitField<PT_Sint8>(S, OpPC, V0))
14696
0
    return false;
14697
0
  continue;
14698
0
}
14699
0
case OP_InitThisBitFieldUint8: {
14700
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14701
0
  if (!InitThisBitField<PT_Uint8>(S, OpPC, V0))
14702
0
    return false;
14703
0
  continue;
14704
0
}
14705
0
case OP_InitThisBitFieldSint16: {
14706
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14707
0
  if (!InitThisBitField<PT_Sint16>(S, OpPC, V0))
14708
0
    return false;
14709
0
  continue;
14710
0
}
14711
0
case OP_InitThisBitFieldUint16: {
14712
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14713
0
  if (!InitThisBitField<PT_Uint16>(S, OpPC, V0))
14714
0
    return false;
14715
0
  continue;
14716
0
}
14717
0
case OP_InitThisBitFieldSint32: {
14718
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14719
0
  if (!InitThisBitField<PT_Sint32>(S, OpPC, V0))
14720
0
    return false;
14721
0
  continue;
14722
0
}
14723
0
case OP_InitThisBitFieldUint32: {
14724
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14725
0
  if (!InitThisBitField<PT_Uint32>(S, OpPC, V0))
14726
0
    return false;
14727
0
  continue;
14728
0
}
14729
0
case OP_InitThisBitFieldSint64: {
14730
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14731
0
  if (!InitThisBitField<PT_Sint64>(S, OpPC, V0))
14732
0
    return false;
14733
0
  continue;
14734
0
}
14735
0
case OP_InitThisBitFieldUint64: {
14736
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14737
0
  if (!InitThisBitField<PT_Uint64>(S, OpPC, V0))
14738
0
    return false;
14739
0
  continue;
14740
0
}
14741
0
case OP_InitThisBitFieldIntAP: {
14742
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14743
0
  if (!InitThisBitField<PT_IntAP>(S, OpPC, V0))
14744
0
    return false;
14745
0
  continue;
14746
0
}
14747
0
case OP_InitThisBitFieldIntAPS: {
14748
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14749
0
  if (!InitThisBitField<PT_IntAPS>(S, OpPC, V0))
14750
0
    return false;
14751
0
  continue;
14752
0
}
14753
0
case OP_InitThisBitFieldBool: {
14754
0
  auto V0 = ReadArg<const Record::Field *>(S, PC);
14755
0
  if (!InitThisBitField<PT_Bool>(S, OpPC, V0))
14756
0
    return false;
14757
0
  continue;
14758
0
}
14759
0
#endif
14760
#ifdef GET_DISASM
14761
case OP_InitThisBitFieldSint8:
14762
  PrintName("InitThisBitFieldSint8");
14763
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14764
  continue;
14765
case OP_InitThisBitFieldUint8:
14766
  PrintName("InitThisBitFieldUint8");
14767
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14768
  continue;
14769
case OP_InitThisBitFieldSint16:
14770
  PrintName("InitThisBitFieldSint16");
14771
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14772
  continue;
14773
case OP_InitThisBitFieldUint16:
14774
  PrintName("InitThisBitFieldUint16");
14775
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14776
  continue;
14777
case OP_InitThisBitFieldSint32:
14778
  PrintName("InitThisBitFieldSint32");
14779
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14780
  continue;
14781
case OP_InitThisBitFieldUint32:
14782
  PrintName("InitThisBitFieldUint32");
14783
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14784
  continue;
14785
case OP_InitThisBitFieldSint64:
14786
  PrintName("InitThisBitFieldSint64");
14787
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14788
  continue;
14789
case OP_InitThisBitFieldUint64:
14790
  PrintName("InitThisBitFieldUint64");
14791
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14792
  continue;
14793
case OP_InitThisBitFieldIntAP:
14794
  PrintName("InitThisBitFieldIntAP");
14795
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14796
  continue;
14797
case OP_InitThisBitFieldIntAPS:
14798
  PrintName("InitThisBitFieldIntAPS");
14799
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14800
  continue;
14801
case OP_InitThisBitFieldBool:
14802
  PrintName("InitThisBitFieldBool");
14803
  OS << "\t" << ReadArg<const Record::Field *>(P, PC) << " " << "\n";
14804
  continue;
14805
#endif
14806
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14807
bool emitInitThisBitFieldSint8(const Record::Field *, const SourceInfo &);
14808
bool emitInitThisBitFieldUint8(const Record::Field *, const SourceInfo &);
14809
bool emitInitThisBitFieldSint16(const Record::Field *, const SourceInfo &);
14810
bool emitInitThisBitFieldUint16(const Record::Field *, const SourceInfo &);
14811
bool emitInitThisBitFieldSint32(const Record::Field *, const SourceInfo &);
14812
bool emitInitThisBitFieldUint32(const Record::Field *, const SourceInfo &);
14813
bool emitInitThisBitFieldSint64(const Record::Field *, const SourceInfo &);
14814
bool emitInitThisBitFieldUint64(const Record::Field *, const SourceInfo &);
14815
bool emitInitThisBitFieldIntAP(const Record::Field *, const SourceInfo &);
14816
bool emitInitThisBitFieldIntAPS(const Record::Field *, const SourceInfo &);
14817
bool emitInitThisBitFieldBool(const Record::Field *, const SourceInfo &);
14818
#endif
14819
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14820
bool emitInitThisBitField(PrimType, const Record::Field *, const SourceInfo &I);
14821
#endif
14822
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
14823
bool
14824
#if defined(GET_EVAL_IMPL)
14825
EvalEmitter
14826
#else
14827
ByteCodeEmitter
14828
#endif
14829
0
::emitInitThisBitField(PrimType T0, const Record::Field * A0, const SourceInfo &I) {
14830
0
  switch (T0) {
14831
0
  case PT_Sint8:
14832
0
    return emitInitThisBitFieldSint8(A0, I);
14833
0
  case PT_Uint8:
14834
0
    return emitInitThisBitFieldUint8(A0, I);
14835
0
  case PT_Sint16:
14836
0
    return emitInitThisBitFieldSint16(A0, I);
14837
0
  case PT_Uint16:
14838
0
    return emitInitThisBitFieldUint16(A0, I);
14839
0
  case PT_Sint32:
14840
0
    return emitInitThisBitFieldSint32(A0, I);
14841
0
  case PT_Uint32:
14842
0
    return emitInitThisBitFieldUint32(A0, I);
14843
0
  case PT_Sint64:
14844
0
    return emitInitThisBitFieldSint64(A0, I);
14845
0
  case PT_Uint64:
14846
0
    return emitInitThisBitFieldUint64(A0, I);
14847
0
  case PT_IntAP:
14848
0
    return emitInitThisBitFieldIntAP(A0, I);
14849
0
  case PT_IntAPS:
14850
0
    return emitInitThisBitFieldIntAPS(A0, I);
14851
0
  case PT_Bool:
14852
0
    return emitInitThisBitFieldBool(A0, I);
14853
0
  default: llvm_unreachable("invalid type: emitInitThisBitField");
14854
0
  }
14855
0
  llvm_unreachable("invalid enum value");
14856
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitThisBitField(clang::interp::PrimType, clang::interp::Record::Field const*, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitThisBitField(clang::interp::PrimType, clang::interp::Record::Field const*, clang::interp::SourceInfo const&)
14857
#endif
14858
#ifdef GET_LINK_IMPL
14859
0
bool ByteCodeEmitter::emitInitThisBitFieldSint8(const Record::Field * A0, const SourceInfo &L) {
14860
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldSint8, A0, L);
14861
0
}
14862
0
bool ByteCodeEmitter::emitInitThisBitFieldUint8(const Record::Field * A0, const SourceInfo &L) {
14863
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldUint8, A0, L);
14864
0
}
14865
0
bool ByteCodeEmitter::emitInitThisBitFieldSint16(const Record::Field * A0, const SourceInfo &L) {
14866
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldSint16, A0, L);
14867
0
}
14868
0
bool ByteCodeEmitter::emitInitThisBitFieldUint16(const Record::Field * A0, const SourceInfo &L) {
14869
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldUint16, A0, L);
14870
0
}
14871
0
bool ByteCodeEmitter::emitInitThisBitFieldSint32(const Record::Field * A0, const SourceInfo &L) {
14872
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldSint32, A0, L);
14873
0
}
14874
0
bool ByteCodeEmitter::emitInitThisBitFieldUint32(const Record::Field * A0, const SourceInfo &L) {
14875
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldUint32, A0, L);
14876
0
}
14877
0
bool ByteCodeEmitter::emitInitThisBitFieldSint64(const Record::Field * A0, const SourceInfo &L) {
14878
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldSint64, A0, L);
14879
0
}
14880
0
bool ByteCodeEmitter::emitInitThisBitFieldUint64(const Record::Field * A0, const SourceInfo &L) {
14881
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldUint64, A0, L);
14882
0
}
14883
0
bool ByteCodeEmitter::emitInitThisBitFieldIntAP(const Record::Field * A0, const SourceInfo &L) {
14884
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldIntAP, A0, L);
14885
0
}
14886
0
bool ByteCodeEmitter::emitInitThisBitFieldIntAPS(const Record::Field * A0, const SourceInfo &L) {
14887
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldIntAPS, A0, L);
14888
0
}
14889
0
bool ByteCodeEmitter::emitInitThisBitFieldBool(const Record::Field * A0, const SourceInfo &L) {
14890
0
  return emitOp<const Record::Field *>(OP_InitThisBitFieldBool, A0, L);
14891
0
}
14892
#endif
14893
#ifdef GET_EVAL_IMPL
14894
0
bool EvalEmitter::emitInitThisBitFieldSint8(const Record::Field * A0, const SourceInfo &L) {
14895
0
  if (!isActive()) return true;
14896
0
  CurrentSource = L;
14897
0
  return InitThisBitField<PT_Sint8>(S, OpPC, A0);
14898
0
}
14899
0
bool EvalEmitter::emitInitThisBitFieldUint8(const Record::Field * A0, const SourceInfo &L) {
14900
0
  if (!isActive()) return true;
14901
0
  CurrentSource = L;
14902
0
  return InitThisBitField<PT_Uint8>(S, OpPC, A0);
14903
0
}
14904
0
bool EvalEmitter::emitInitThisBitFieldSint16(const Record::Field * A0, const SourceInfo &L) {
14905
0
  if (!isActive()) return true;
14906
0
  CurrentSource = L;
14907
0
  return InitThisBitField<PT_Sint16>(S, OpPC, A0);
14908
0
}
14909
0
bool EvalEmitter::emitInitThisBitFieldUint16(const Record::Field * A0, const SourceInfo &L) {
14910
0
  if (!isActive()) return true;
14911
0
  CurrentSource = L;
14912
0
  return InitThisBitField<PT_Uint16>(S, OpPC, A0);
14913
0
}
14914
0
bool EvalEmitter::emitInitThisBitFieldSint32(const Record::Field * A0, const SourceInfo &L) {
14915
0
  if (!isActive()) return true;
14916
0
  CurrentSource = L;
14917
0
  return InitThisBitField<PT_Sint32>(S, OpPC, A0);
14918
0
}
14919
0
bool EvalEmitter::emitInitThisBitFieldUint32(const Record::Field * A0, const SourceInfo &L) {
14920
0
  if (!isActive()) return true;
14921
0
  CurrentSource = L;
14922
0
  return InitThisBitField<PT_Uint32>(S, OpPC, A0);
14923
0
}
14924
0
bool EvalEmitter::emitInitThisBitFieldSint64(const Record::Field * A0, const SourceInfo &L) {
14925
0
  if (!isActive()) return true;
14926
0
  CurrentSource = L;
14927
0
  return InitThisBitField<PT_Sint64>(S, OpPC, A0);
14928
0
}
14929
0
bool EvalEmitter::emitInitThisBitFieldUint64(const Record::Field * A0, const SourceInfo &L) {
14930
0
  if (!isActive()) return true;
14931
0
  CurrentSource = L;
14932
0
  return InitThisBitField<PT_Uint64>(S, OpPC, A0);
14933
0
}
14934
0
bool EvalEmitter::emitInitThisBitFieldIntAP(const Record::Field * A0, const SourceInfo &L) {
14935
0
  if (!isActive()) return true;
14936
0
  CurrentSource = L;
14937
0
  return InitThisBitField<PT_IntAP>(S, OpPC, A0);
14938
0
}
14939
0
bool EvalEmitter::emitInitThisBitFieldIntAPS(const Record::Field * A0, const SourceInfo &L) {
14940
0
  if (!isActive()) return true;
14941
0
  CurrentSource = L;
14942
0
  return InitThisBitField<PT_IntAPS>(S, OpPC, A0);
14943
0
}
14944
0
bool EvalEmitter::emitInitThisBitFieldBool(const Record::Field * A0, const SourceInfo &L) {
14945
0
  if (!isActive()) return true;
14946
0
  CurrentSource = L;
14947
0
  return InitThisBitField<PT_Bool>(S, OpPC, A0);
14948
0
}
14949
#endif
14950
#ifdef GET_OPCODE_NAMES
14951
OP_InitThisFieldSint8,
14952
OP_InitThisFieldUint8,
14953
OP_InitThisFieldSint16,
14954
OP_InitThisFieldUint16,
14955
OP_InitThisFieldSint32,
14956
OP_InitThisFieldUint32,
14957
OP_InitThisFieldSint64,
14958
OP_InitThisFieldUint64,
14959
OP_InitThisFieldIntAP,
14960
OP_InitThisFieldIntAPS,
14961
OP_InitThisFieldBool,
14962
OP_InitThisFieldPtr,
14963
OP_InitThisFieldFnPtr,
14964
OP_InitThisFieldFloat,
14965
#endif
14966
0
#ifdef GET_INTERP
14967
0
case OP_InitThisFieldSint8: {
14968
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14969
0
  if (!InitThisField<PT_Sint8>(S, OpPC, V0))
14970
0
    return false;
14971
0
  continue;
14972
0
}
14973
0
case OP_InitThisFieldUint8: {
14974
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14975
0
  if (!InitThisField<PT_Uint8>(S, OpPC, V0))
14976
0
    return false;
14977
0
  continue;
14978
0
}
14979
0
case OP_InitThisFieldSint16: {
14980
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14981
0
  if (!InitThisField<PT_Sint16>(S, OpPC, V0))
14982
0
    return false;
14983
0
  continue;
14984
0
}
14985
0
case OP_InitThisFieldUint16: {
14986
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14987
0
  if (!InitThisField<PT_Uint16>(S, OpPC, V0))
14988
0
    return false;
14989
0
  continue;
14990
0
}
14991
0
case OP_InitThisFieldSint32: {
14992
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14993
0
  if (!InitThisField<PT_Sint32>(S, OpPC, V0))
14994
0
    return false;
14995
0
  continue;
14996
0
}
14997
0
case OP_InitThisFieldUint32: {
14998
0
  auto V0 = ReadArg<uint32_t>(S, PC);
14999
0
  if (!InitThisField<PT_Uint32>(S, OpPC, V0))
15000
0
    return false;
15001
0
  continue;
15002
0
}
15003
0
case OP_InitThisFieldSint64: {
15004
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15005
0
  if (!InitThisField<PT_Sint64>(S, OpPC, V0))
15006
0
    return false;
15007
0
  continue;
15008
0
}
15009
0
case OP_InitThisFieldUint64: {
15010
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15011
0
  if (!InitThisField<PT_Uint64>(S, OpPC, V0))
15012
0
    return false;
15013
0
  continue;
15014
0
}
15015
0
case OP_InitThisFieldIntAP: {
15016
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15017
0
  if (!InitThisField<PT_IntAP>(S, OpPC, V0))
15018
0
    return false;
15019
0
  continue;
15020
0
}
15021
0
case OP_InitThisFieldIntAPS: {
15022
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15023
0
  if (!InitThisField<PT_IntAPS>(S, OpPC, V0))
15024
0
    return false;
15025
0
  continue;
15026
0
}
15027
0
case OP_InitThisFieldBool: {
15028
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15029
0
  if (!InitThisField<PT_Bool>(S, OpPC, V0))
15030
0
    return false;
15031
0
  continue;
15032
0
}
15033
0
case OP_InitThisFieldPtr: {
15034
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15035
0
  if (!InitThisField<PT_Ptr>(S, OpPC, V0))
15036
0
    return false;
15037
0
  continue;
15038
0
}
15039
0
case OP_InitThisFieldFnPtr: {
15040
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15041
0
  if (!InitThisField<PT_FnPtr>(S, OpPC, V0))
15042
0
    return false;
15043
0
  continue;
15044
0
}
15045
0
case OP_InitThisFieldFloat: {
15046
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15047
0
  if (!InitThisField<PT_Float>(S, OpPC, V0))
15048
0
    return false;
15049
0
  continue;
15050
0
}
15051
0
#endif
15052
#ifdef GET_DISASM
15053
case OP_InitThisFieldSint8:
15054
  PrintName("InitThisFieldSint8");
15055
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15056
  continue;
15057
case OP_InitThisFieldUint8:
15058
  PrintName("InitThisFieldUint8");
15059
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15060
  continue;
15061
case OP_InitThisFieldSint16:
15062
  PrintName("InitThisFieldSint16");
15063
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15064
  continue;
15065
case OP_InitThisFieldUint16:
15066
  PrintName("InitThisFieldUint16");
15067
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15068
  continue;
15069
case OP_InitThisFieldSint32:
15070
  PrintName("InitThisFieldSint32");
15071
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15072
  continue;
15073
case OP_InitThisFieldUint32:
15074
  PrintName("InitThisFieldUint32");
15075
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15076
  continue;
15077
case OP_InitThisFieldSint64:
15078
  PrintName("InitThisFieldSint64");
15079
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15080
  continue;
15081
case OP_InitThisFieldUint64:
15082
  PrintName("InitThisFieldUint64");
15083
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15084
  continue;
15085
case OP_InitThisFieldIntAP:
15086
  PrintName("InitThisFieldIntAP");
15087
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15088
  continue;
15089
case OP_InitThisFieldIntAPS:
15090
  PrintName("InitThisFieldIntAPS");
15091
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15092
  continue;
15093
case OP_InitThisFieldBool:
15094
  PrintName("InitThisFieldBool");
15095
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15096
  continue;
15097
case OP_InitThisFieldPtr:
15098
  PrintName("InitThisFieldPtr");
15099
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15100
  continue;
15101
case OP_InitThisFieldFnPtr:
15102
  PrintName("InitThisFieldFnPtr");
15103
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15104
  continue;
15105
case OP_InitThisFieldFloat:
15106
  PrintName("InitThisFieldFloat");
15107
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15108
  continue;
15109
#endif
15110
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15111
bool emitInitThisFieldSint8(uint32_t, const SourceInfo &);
15112
bool emitInitThisFieldUint8(uint32_t, const SourceInfo &);
15113
bool emitInitThisFieldSint16(uint32_t, const SourceInfo &);
15114
bool emitInitThisFieldUint16(uint32_t, const SourceInfo &);
15115
bool emitInitThisFieldSint32(uint32_t, const SourceInfo &);
15116
bool emitInitThisFieldUint32(uint32_t, const SourceInfo &);
15117
bool emitInitThisFieldSint64(uint32_t, const SourceInfo &);
15118
bool emitInitThisFieldUint64(uint32_t, const SourceInfo &);
15119
bool emitInitThisFieldIntAP(uint32_t, const SourceInfo &);
15120
bool emitInitThisFieldIntAPS(uint32_t, const SourceInfo &);
15121
bool emitInitThisFieldBool(uint32_t, const SourceInfo &);
15122
bool emitInitThisFieldPtr(uint32_t, const SourceInfo &);
15123
bool emitInitThisFieldFnPtr(uint32_t, const SourceInfo &);
15124
bool emitInitThisFieldFloat(uint32_t, const SourceInfo &);
15125
#endif
15126
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15127
bool emitInitThisField(PrimType, uint32_t, const SourceInfo &I);
15128
#endif
15129
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
15130
bool
15131
#if defined(GET_EVAL_IMPL)
15132
EvalEmitter
15133
#else
15134
ByteCodeEmitter
15135
#endif
15136
0
::emitInitThisField(PrimType T0, uint32_t A0, const SourceInfo &I) {
15137
0
  switch (T0) {
15138
0
  case PT_Sint8:
15139
0
    return emitInitThisFieldSint8(A0, I);
15140
0
  case PT_Uint8:
15141
0
    return emitInitThisFieldUint8(A0, I);
15142
0
  case PT_Sint16:
15143
0
    return emitInitThisFieldSint16(A0, I);
15144
0
  case PT_Uint16:
15145
0
    return emitInitThisFieldUint16(A0, I);
15146
0
  case PT_Sint32:
15147
0
    return emitInitThisFieldSint32(A0, I);
15148
0
  case PT_Uint32:
15149
0
    return emitInitThisFieldUint32(A0, I);
15150
0
  case PT_Sint64:
15151
0
    return emitInitThisFieldSint64(A0, I);
15152
0
  case PT_Uint64:
15153
0
    return emitInitThisFieldUint64(A0, I);
15154
0
  case PT_IntAP:
15155
0
    return emitInitThisFieldIntAP(A0, I);
15156
0
  case PT_IntAPS:
15157
0
    return emitInitThisFieldIntAPS(A0, I);
15158
0
  case PT_Bool:
15159
0
    return emitInitThisFieldBool(A0, I);
15160
0
  case PT_Ptr:
15161
0
    return emitInitThisFieldPtr(A0, I);
15162
0
  case PT_FnPtr:
15163
0
    return emitInitThisFieldFnPtr(A0, I);
15164
0
  case PT_Float:
15165
0
    return emitInitThisFieldFloat(A0, I);
15166
0
  }
15167
0
  llvm_unreachable("invalid enum value");
15168
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitThisField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitThisField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
15169
#endif
15170
#ifdef GET_LINK_IMPL
15171
0
bool ByteCodeEmitter::emitInitThisFieldSint8(uint32_t A0, const SourceInfo &L) {
15172
0
  return emitOp<uint32_t>(OP_InitThisFieldSint8, A0, L);
15173
0
}
15174
0
bool ByteCodeEmitter::emitInitThisFieldUint8(uint32_t A0, const SourceInfo &L) {
15175
0
  return emitOp<uint32_t>(OP_InitThisFieldUint8, A0, L);
15176
0
}
15177
0
bool ByteCodeEmitter::emitInitThisFieldSint16(uint32_t A0, const SourceInfo &L) {
15178
0
  return emitOp<uint32_t>(OP_InitThisFieldSint16, A0, L);
15179
0
}
15180
0
bool ByteCodeEmitter::emitInitThisFieldUint16(uint32_t A0, const SourceInfo &L) {
15181
0
  return emitOp<uint32_t>(OP_InitThisFieldUint16, A0, L);
15182
0
}
15183
0
bool ByteCodeEmitter::emitInitThisFieldSint32(uint32_t A0, const SourceInfo &L) {
15184
0
  return emitOp<uint32_t>(OP_InitThisFieldSint32, A0, L);
15185
0
}
15186
0
bool ByteCodeEmitter::emitInitThisFieldUint32(uint32_t A0, const SourceInfo &L) {
15187
0
  return emitOp<uint32_t>(OP_InitThisFieldUint32, A0, L);
15188
0
}
15189
0
bool ByteCodeEmitter::emitInitThisFieldSint64(uint32_t A0, const SourceInfo &L) {
15190
0
  return emitOp<uint32_t>(OP_InitThisFieldSint64, A0, L);
15191
0
}
15192
0
bool ByteCodeEmitter::emitInitThisFieldUint64(uint32_t A0, const SourceInfo &L) {
15193
0
  return emitOp<uint32_t>(OP_InitThisFieldUint64, A0, L);
15194
0
}
15195
0
bool ByteCodeEmitter::emitInitThisFieldIntAP(uint32_t A0, const SourceInfo &L) {
15196
0
  return emitOp<uint32_t>(OP_InitThisFieldIntAP, A0, L);
15197
0
}
15198
0
bool ByteCodeEmitter::emitInitThisFieldIntAPS(uint32_t A0, const SourceInfo &L) {
15199
0
  return emitOp<uint32_t>(OP_InitThisFieldIntAPS, A0, L);
15200
0
}
15201
0
bool ByteCodeEmitter::emitInitThisFieldBool(uint32_t A0, const SourceInfo &L) {
15202
0
  return emitOp<uint32_t>(OP_InitThisFieldBool, A0, L);
15203
0
}
15204
0
bool ByteCodeEmitter::emitInitThisFieldPtr(uint32_t A0, const SourceInfo &L) {
15205
0
  return emitOp<uint32_t>(OP_InitThisFieldPtr, A0, L);
15206
0
}
15207
0
bool ByteCodeEmitter::emitInitThisFieldFnPtr(uint32_t A0, const SourceInfo &L) {
15208
0
  return emitOp<uint32_t>(OP_InitThisFieldFnPtr, A0, L);
15209
0
}
15210
0
bool ByteCodeEmitter::emitInitThisFieldFloat(uint32_t A0, const SourceInfo &L) {
15211
0
  return emitOp<uint32_t>(OP_InitThisFieldFloat, A0, L);
15212
0
}
15213
#endif
15214
#ifdef GET_EVAL_IMPL
15215
0
bool EvalEmitter::emitInitThisFieldSint8(uint32_t A0, const SourceInfo &L) {
15216
0
  if (!isActive()) return true;
15217
0
  CurrentSource = L;
15218
0
  return InitThisField<PT_Sint8>(S, OpPC, A0);
15219
0
}
15220
0
bool EvalEmitter::emitInitThisFieldUint8(uint32_t A0, const SourceInfo &L) {
15221
0
  if (!isActive()) return true;
15222
0
  CurrentSource = L;
15223
0
  return InitThisField<PT_Uint8>(S, OpPC, A0);
15224
0
}
15225
0
bool EvalEmitter::emitInitThisFieldSint16(uint32_t A0, const SourceInfo &L) {
15226
0
  if (!isActive()) return true;
15227
0
  CurrentSource = L;
15228
0
  return InitThisField<PT_Sint16>(S, OpPC, A0);
15229
0
}
15230
0
bool EvalEmitter::emitInitThisFieldUint16(uint32_t A0, const SourceInfo &L) {
15231
0
  if (!isActive()) return true;
15232
0
  CurrentSource = L;
15233
0
  return InitThisField<PT_Uint16>(S, OpPC, A0);
15234
0
}
15235
0
bool EvalEmitter::emitInitThisFieldSint32(uint32_t A0, const SourceInfo &L) {
15236
0
  if (!isActive()) return true;
15237
0
  CurrentSource = L;
15238
0
  return InitThisField<PT_Sint32>(S, OpPC, A0);
15239
0
}
15240
0
bool EvalEmitter::emitInitThisFieldUint32(uint32_t A0, const SourceInfo &L) {
15241
0
  if (!isActive()) return true;
15242
0
  CurrentSource = L;
15243
0
  return InitThisField<PT_Uint32>(S, OpPC, A0);
15244
0
}
15245
0
bool EvalEmitter::emitInitThisFieldSint64(uint32_t A0, const SourceInfo &L) {
15246
0
  if (!isActive()) return true;
15247
0
  CurrentSource = L;
15248
0
  return InitThisField<PT_Sint64>(S, OpPC, A0);
15249
0
}
15250
0
bool EvalEmitter::emitInitThisFieldUint64(uint32_t A0, const SourceInfo &L) {
15251
0
  if (!isActive()) return true;
15252
0
  CurrentSource = L;
15253
0
  return InitThisField<PT_Uint64>(S, OpPC, A0);
15254
0
}
15255
0
bool EvalEmitter::emitInitThisFieldIntAP(uint32_t A0, const SourceInfo &L) {
15256
0
  if (!isActive()) return true;
15257
0
  CurrentSource = L;
15258
0
  return InitThisField<PT_IntAP>(S, OpPC, A0);
15259
0
}
15260
0
bool EvalEmitter::emitInitThisFieldIntAPS(uint32_t A0, const SourceInfo &L) {
15261
0
  if (!isActive()) return true;
15262
0
  CurrentSource = L;
15263
0
  return InitThisField<PT_IntAPS>(S, OpPC, A0);
15264
0
}
15265
0
bool EvalEmitter::emitInitThisFieldBool(uint32_t A0, const SourceInfo &L) {
15266
0
  if (!isActive()) return true;
15267
0
  CurrentSource = L;
15268
0
  return InitThisField<PT_Bool>(S, OpPC, A0);
15269
0
}
15270
0
bool EvalEmitter::emitInitThisFieldPtr(uint32_t A0, const SourceInfo &L) {
15271
0
  if (!isActive()) return true;
15272
0
  CurrentSource = L;
15273
0
  return InitThisField<PT_Ptr>(S, OpPC, A0);
15274
0
}
15275
0
bool EvalEmitter::emitInitThisFieldFnPtr(uint32_t A0, const SourceInfo &L) {
15276
0
  if (!isActive()) return true;
15277
0
  CurrentSource = L;
15278
0
  return InitThisField<PT_FnPtr>(S, OpPC, A0);
15279
0
}
15280
0
bool EvalEmitter::emitInitThisFieldFloat(uint32_t A0, const SourceInfo &L) {
15281
0
  if (!isActive()) return true;
15282
0
  CurrentSource = L;
15283
0
  return InitThisField<PT_Float>(S, OpPC, A0);
15284
0
}
15285
#endif
15286
#ifdef GET_OPCODE_NAMES
15287
OP_InitThisFieldActiveSint8,
15288
OP_InitThisFieldActiveUint8,
15289
OP_InitThisFieldActiveSint16,
15290
OP_InitThisFieldActiveUint16,
15291
OP_InitThisFieldActiveSint32,
15292
OP_InitThisFieldActiveUint32,
15293
OP_InitThisFieldActiveSint64,
15294
OP_InitThisFieldActiveUint64,
15295
OP_InitThisFieldActiveIntAP,
15296
OP_InitThisFieldActiveIntAPS,
15297
OP_InitThisFieldActiveBool,
15298
OP_InitThisFieldActivePtr,
15299
OP_InitThisFieldActiveFnPtr,
15300
OP_InitThisFieldActiveFloat,
15301
#endif
15302
0
#ifdef GET_INTERP
15303
0
case OP_InitThisFieldActiveSint8: {
15304
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15305
0
  if (!InitThisFieldActive<PT_Sint8>(S, OpPC, V0))
15306
0
    return false;
15307
0
  continue;
15308
0
}
15309
0
case OP_InitThisFieldActiveUint8: {
15310
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15311
0
  if (!InitThisFieldActive<PT_Uint8>(S, OpPC, V0))
15312
0
    return false;
15313
0
  continue;
15314
0
}
15315
0
case OP_InitThisFieldActiveSint16: {
15316
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15317
0
  if (!InitThisFieldActive<PT_Sint16>(S, OpPC, V0))
15318
0
    return false;
15319
0
  continue;
15320
0
}
15321
0
case OP_InitThisFieldActiveUint16: {
15322
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15323
0
  if (!InitThisFieldActive<PT_Uint16>(S, OpPC, V0))
15324
0
    return false;
15325
0
  continue;
15326
0
}
15327
0
case OP_InitThisFieldActiveSint32: {
15328
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15329
0
  if (!InitThisFieldActive<PT_Sint32>(S, OpPC, V0))
15330
0
    return false;
15331
0
  continue;
15332
0
}
15333
0
case OP_InitThisFieldActiveUint32: {
15334
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15335
0
  if (!InitThisFieldActive<PT_Uint32>(S, OpPC, V0))
15336
0
    return false;
15337
0
  continue;
15338
0
}
15339
0
case OP_InitThisFieldActiveSint64: {
15340
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15341
0
  if (!InitThisFieldActive<PT_Sint64>(S, OpPC, V0))
15342
0
    return false;
15343
0
  continue;
15344
0
}
15345
0
case OP_InitThisFieldActiveUint64: {
15346
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15347
0
  if (!InitThisFieldActive<PT_Uint64>(S, OpPC, V0))
15348
0
    return false;
15349
0
  continue;
15350
0
}
15351
0
case OP_InitThisFieldActiveIntAP: {
15352
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15353
0
  if (!InitThisFieldActive<PT_IntAP>(S, OpPC, V0))
15354
0
    return false;
15355
0
  continue;
15356
0
}
15357
0
case OP_InitThisFieldActiveIntAPS: {
15358
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15359
0
  if (!InitThisFieldActive<PT_IntAPS>(S, OpPC, V0))
15360
0
    return false;
15361
0
  continue;
15362
0
}
15363
0
case OP_InitThisFieldActiveBool: {
15364
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15365
0
  if (!InitThisFieldActive<PT_Bool>(S, OpPC, V0))
15366
0
    return false;
15367
0
  continue;
15368
0
}
15369
0
case OP_InitThisFieldActivePtr: {
15370
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15371
0
  if (!InitThisFieldActive<PT_Ptr>(S, OpPC, V0))
15372
0
    return false;
15373
0
  continue;
15374
0
}
15375
0
case OP_InitThisFieldActiveFnPtr: {
15376
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15377
0
  if (!InitThisFieldActive<PT_FnPtr>(S, OpPC, V0))
15378
0
    return false;
15379
0
  continue;
15380
0
}
15381
0
case OP_InitThisFieldActiveFloat: {
15382
0
  auto V0 = ReadArg<uint32_t>(S, PC);
15383
0
  if (!InitThisFieldActive<PT_Float>(S, OpPC, V0))
15384
0
    return false;
15385
0
  continue;
15386
0
}
15387
0
#endif
15388
#ifdef GET_DISASM
15389
case OP_InitThisFieldActiveSint8:
15390
  PrintName("InitThisFieldActiveSint8");
15391
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15392
  continue;
15393
case OP_InitThisFieldActiveUint8:
15394
  PrintName("InitThisFieldActiveUint8");
15395
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15396
  continue;
15397
case OP_InitThisFieldActiveSint16:
15398
  PrintName("InitThisFieldActiveSint16");
15399
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15400
  continue;
15401
case OP_InitThisFieldActiveUint16:
15402
  PrintName("InitThisFieldActiveUint16");
15403
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15404
  continue;
15405
case OP_InitThisFieldActiveSint32:
15406
  PrintName("InitThisFieldActiveSint32");
15407
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15408
  continue;
15409
case OP_InitThisFieldActiveUint32:
15410
  PrintName("InitThisFieldActiveUint32");
15411
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15412
  continue;
15413
case OP_InitThisFieldActiveSint64:
15414
  PrintName("InitThisFieldActiveSint64");
15415
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15416
  continue;
15417
case OP_InitThisFieldActiveUint64:
15418
  PrintName("InitThisFieldActiveUint64");
15419
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15420
  continue;
15421
case OP_InitThisFieldActiveIntAP:
15422
  PrintName("InitThisFieldActiveIntAP");
15423
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15424
  continue;
15425
case OP_InitThisFieldActiveIntAPS:
15426
  PrintName("InitThisFieldActiveIntAPS");
15427
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15428
  continue;
15429
case OP_InitThisFieldActiveBool:
15430
  PrintName("InitThisFieldActiveBool");
15431
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15432
  continue;
15433
case OP_InitThisFieldActivePtr:
15434
  PrintName("InitThisFieldActivePtr");
15435
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15436
  continue;
15437
case OP_InitThisFieldActiveFnPtr:
15438
  PrintName("InitThisFieldActiveFnPtr");
15439
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15440
  continue;
15441
case OP_InitThisFieldActiveFloat:
15442
  PrintName("InitThisFieldActiveFloat");
15443
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
15444
  continue;
15445
#endif
15446
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15447
bool emitInitThisFieldActiveSint8(uint32_t, const SourceInfo &);
15448
bool emitInitThisFieldActiveUint8(uint32_t, const SourceInfo &);
15449
bool emitInitThisFieldActiveSint16(uint32_t, const SourceInfo &);
15450
bool emitInitThisFieldActiveUint16(uint32_t, const SourceInfo &);
15451
bool emitInitThisFieldActiveSint32(uint32_t, const SourceInfo &);
15452
bool emitInitThisFieldActiveUint32(uint32_t, const SourceInfo &);
15453
bool emitInitThisFieldActiveSint64(uint32_t, const SourceInfo &);
15454
bool emitInitThisFieldActiveUint64(uint32_t, const SourceInfo &);
15455
bool emitInitThisFieldActiveIntAP(uint32_t, const SourceInfo &);
15456
bool emitInitThisFieldActiveIntAPS(uint32_t, const SourceInfo &);
15457
bool emitInitThisFieldActiveBool(uint32_t, const SourceInfo &);
15458
bool emitInitThisFieldActivePtr(uint32_t, const SourceInfo &);
15459
bool emitInitThisFieldActiveFnPtr(uint32_t, const SourceInfo &);
15460
bool emitInitThisFieldActiveFloat(uint32_t, const SourceInfo &);
15461
#endif
15462
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15463
bool emitInitThisFieldActive(PrimType, uint32_t, const SourceInfo &I);
15464
#endif
15465
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
15466
bool
15467
#if defined(GET_EVAL_IMPL)
15468
EvalEmitter
15469
#else
15470
ByteCodeEmitter
15471
#endif
15472
0
::emitInitThisFieldActive(PrimType T0, uint32_t A0, const SourceInfo &I) {
15473
0
  switch (T0) {
15474
0
  case PT_Sint8:
15475
0
    return emitInitThisFieldActiveSint8(A0, I);
15476
0
  case PT_Uint8:
15477
0
    return emitInitThisFieldActiveUint8(A0, I);
15478
0
  case PT_Sint16:
15479
0
    return emitInitThisFieldActiveSint16(A0, I);
15480
0
  case PT_Uint16:
15481
0
    return emitInitThisFieldActiveUint16(A0, I);
15482
0
  case PT_Sint32:
15483
0
    return emitInitThisFieldActiveSint32(A0, I);
15484
0
  case PT_Uint32:
15485
0
    return emitInitThisFieldActiveUint32(A0, I);
15486
0
  case PT_Sint64:
15487
0
    return emitInitThisFieldActiveSint64(A0, I);
15488
0
  case PT_Uint64:
15489
0
    return emitInitThisFieldActiveUint64(A0, I);
15490
0
  case PT_IntAP:
15491
0
    return emitInitThisFieldActiveIntAP(A0, I);
15492
0
  case PT_IntAPS:
15493
0
    return emitInitThisFieldActiveIntAPS(A0, I);
15494
0
  case PT_Bool:
15495
0
    return emitInitThisFieldActiveBool(A0, I);
15496
0
  case PT_Ptr:
15497
0
    return emitInitThisFieldActivePtr(A0, I);
15498
0
  case PT_FnPtr:
15499
0
    return emitInitThisFieldActiveFnPtr(A0, I);
15500
0
  case PT_Float:
15501
0
    return emitInitThisFieldActiveFloat(A0, I);
15502
0
  }
15503
0
  llvm_unreachable("invalid enum value");
15504
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInitThisFieldActive(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInitThisFieldActive(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
15505
#endif
15506
#ifdef GET_LINK_IMPL
15507
0
bool ByteCodeEmitter::emitInitThisFieldActiveSint8(uint32_t A0, const SourceInfo &L) {
15508
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveSint8, A0, L);
15509
0
}
15510
0
bool ByteCodeEmitter::emitInitThisFieldActiveUint8(uint32_t A0, const SourceInfo &L) {
15511
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveUint8, A0, L);
15512
0
}
15513
0
bool ByteCodeEmitter::emitInitThisFieldActiveSint16(uint32_t A0, const SourceInfo &L) {
15514
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveSint16, A0, L);
15515
0
}
15516
0
bool ByteCodeEmitter::emitInitThisFieldActiveUint16(uint32_t A0, const SourceInfo &L) {
15517
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveUint16, A0, L);
15518
0
}
15519
0
bool ByteCodeEmitter::emitInitThisFieldActiveSint32(uint32_t A0, const SourceInfo &L) {
15520
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveSint32, A0, L);
15521
0
}
15522
0
bool ByteCodeEmitter::emitInitThisFieldActiveUint32(uint32_t A0, const SourceInfo &L) {
15523
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveUint32, A0, L);
15524
0
}
15525
0
bool ByteCodeEmitter::emitInitThisFieldActiveSint64(uint32_t A0, const SourceInfo &L) {
15526
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveSint64, A0, L);
15527
0
}
15528
0
bool ByteCodeEmitter::emitInitThisFieldActiveUint64(uint32_t A0, const SourceInfo &L) {
15529
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveUint64, A0, L);
15530
0
}
15531
0
bool ByteCodeEmitter::emitInitThisFieldActiveIntAP(uint32_t A0, const SourceInfo &L) {
15532
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveIntAP, A0, L);
15533
0
}
15534
0
bool ByteCodeEmitter::emitInitThisFieldActiveIntAPS(uint32_t A0, const SourceInfo &L) {
15535
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveIntAPS, A0, L);
15536
0
}
15537
0
bool ByteCodeEmitter::emitInitThisFieldActiveBool(uint32_t A0, const SourceInfo &L) {
15538
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveBool, A0, L);
15539
0
}
15540
0
bool ByteCodeEmitter::emitInitThisFieldActivePtr(uint32_t A0, const SourceInfo &L) {
15541
0
  return emitOp<uint32_t>(OP_InitThisFieldActivePtr, A0, L);
15542
0
}
15543
0
bool ByteCodeEmitter::emitInitThisFieldActiveFnPtr(uint32_t A0, const SourceInfo &L) {
15544
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveFnPtr, A0, L);
15545
0
}
15546
0
bool ByteCodeEmitter::emitInitThisFieldActiveFloat(uint32_t A0, const SourceInfo &L) {
15547
0
  return emitOp<uint32_t>(OP_InitThisFieldActiveFloat, A0, L);
15548
0
}
15549
#endif
15550
#ifdef GET_EVAL_IMPL
15551
0
bool EvalEmitter::emitInitThisFieldActiveSint8(uint32_t A0, const SourceInfo &L) {
15552
0
  if (!isActive()) return true;
15553
0
  CurrentSource = L;
15554
0
  return InitThisFieldActive<PT_Sint8>(S, OpPC, A0);
15555
0
}
15556
0
bool EvalEmitter::emitInitThisFieldActiveUint8(uint32_t A0, const SourceInfo &L) {
15557
0
  if (!isActive()) return true;
15558
0
  CurrentSource = L;
15559
0
  return InitThisFieldActive<PT_Uint8>(S, OpPC, A0);
15560
0
}
15561
0
bool EvalEmitter::emitInitThisFieldActiveSint16(uint32_t A0, const SourceInfo &L) {
15562
0
  if (!isActive()) return true;
15563
0
  CurrentSource = L;
15564
0
  return InitThisFieldActive<PT_Sint16>(S, OpPC, A0);
15565
0
}
15566
0
bool EvalEmitter::emitInitThisFieldActiveUint16(uint32_t A0, const SourceInfo &L) {
15567
0
  if (!isActive()) return true;
15568
0
  CurrentSource = L;
15569
0
  return InitThisFieldActive<PT_Uint16>(S, OpPC, A0);
15570
0
}
15571
0
bool EvalEmitter::emitInitThisFieldActiveSint32(uint32_t A0, const SourceInfo &L) {
15572
0
  if (!isActive()) return true;
15573
0
  CurrentSource = L;
15574
0
  return InitThisFieldActive<PT_Sint32>(S, OpPC, A0);
15575
0
}
15576
0
bool EvalEmitter::emitInitThisFieldActiveUint32(uint32_t A0, const SourceInfo &L) {
15577
0
  if (!isActive()) return true;
15578
0
  CurrentSource = L;
15579
0
  return InitThisFieldActive<PT_Uint32>(S, OpPC, A0);
15580
0
}
15581
0
bool EvalEmitter::emitInitThisFieldActiveSint64(uint32_t A0, const SourceInfo &L) {
15582
0
  if (!isActive()) return true;
15583
0
  CurrentSource = L;
15584
0
  return InitThisFieldActive<PT_Sint64>(S, OpPC, A0);
15585
0
}
15586
0
bool EvalEmitter::emitInitThisFieldActiveUint64(uint32_t A0, const SourceInfo &L) {
15587
0
  if (!isActive()) return true;
15588
0
  CurrentSource = L;
15589
0
  return InitThisFieldActive<PT_Uint64>(S, OpPC, A0);
15590
0
}
15591
0
bool EvalEmitter::emitInitThisFieldActiveIntAP(uint32_t A0, const SourceInfo &L) {
15592
0
  if (!isActive()) return true;
15593
0
  CurrentSource = L;
15594
0
  return InitThisFieldActive<PT_IntAP>(S, OpPC, A0);
15595
0
}
15596
0
bool EvalEmitter::emitInitThisFieldActiveIntAPS(uint32_t A0, const SourceInfo &L) {
15597
0
  if (!isActive()) return true;
15598
0
  CurrentSource = L;
15599
0
  return InitThisFieldActive<PT_IntAPS>(S, OpPC, A0);
15600
0
}
15601
0
bool EvalEmitter::emitInitThisFieldActiveBool(uint32_t A0, const SourceInfo &L) {
15602
0
  if (!isActive()) return true;
15603
0
  CurrentSource = L;
15604
0
  return InitThisFieldActive<PT_Bool>(S, OpPC, A0);
15605
0
}
15606
0
bool EvalEmitter::emitInitThisFieldActivePtr(uint32_t A0, const SourceInfo &L) {
15607
0
  if (!isActive()) return true;
15608
0
  CurrentSource = L;
15609
0
  return InitThisFieldActive<PT_Ptr>(S, OpPC, A0);
15610
0
}
15611
0
bool EvalEmitter::emitInitThisFieldActiveFnPtr(uint32_t A0, const SourceInfo &L) {
15612
0
  if (!isActive()) return true;
15613
0
  CurrentSource = L;
15614
0
  return InitThisFieldActive<PT_FnPtr>(S, OpPC, A0);
15615
0
}
15616
0
bool EvalEmitter::emitInitThisFieldActiveFloat(uint32_t A0, const SourceInfo &L) {
15617
0
  if (!isActive()) return true;
15618
0
  CurrentSource = L;
15619
0
  return InitThisFieldActive<PT_Float>(S, OpPC, A0);
15620
0
}
15621
#endif
15622
#ifdef GET_OPCODE_NAMES
15623
OP_InvBool,
15624
#endif
15625
0
#ifdef GET_INTERP
15626
0
case OP_InvBool: {
15627
0
  if (!Inv<PT_Bool>(S, OpPC))
15628
0
    return false;
15629
0
  continue;
15630
0
}
15631
0
#endif
15632
#ifdef GET_DISASM
15633
case OP_InvBool:
15634
  PrintName("InvBool");
15635
  OS << "\t" << "\n";
15636
  continue;
15637
#endif
15638
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15639
bool emitInvBool(const SourceInfo &);
15640
#endif
15641
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15642
bool emitInv(PrimType, const SourceInfo &I);
15643
#endif
15644
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
15645
bool
15646
#if defined(GET_EVAL_IMPL)
15647
EvalEmitter
15648
#else
15649
ByteCodeEmitter
15650
#endif
15651
0
::emitInv(PrimType T0, const SourceInfo &I) {
15652
0
  switch (T0) {
15653
0
  case PT_Bool:
15654
0
    return emitInvBool(I);
15655
0
  default: llvm_unreachable("invalid type: emitInv");
15656
0
  }
15657
0
  llvm_unreachable("invalid enum value");
15658
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitInv(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitInv(clang::interp::PrimType, clang::interp::SourceInfo const&)
15659
#endif
15660
#ifdef GET_LINK_IMPL
15661
0
bool ByteCodeEmitter::emitInvBool(const SourceInfo &L) {
15662
0
  return emitOp<>(OP_InvBool, L);
15663
0
}
15664
#endif
15665
#ifdef GET_EVAL_IMPL
15666
0
bool EvalEmitter::emitInvBool(const SourceInfo &L) {
15667
0
  if (!isActive()) return true;
15668
0
  CurrentSource = L;
15669
0
  return Inv<PT_Bool>(S, OpPC);
15670
0
}
15671
#endif
15672
#ifdef GET_OPCODE_NAMES
15673
OP_Invalid,
15674
#endif
15675
0
#ifdef GET_INTERP
15676
0
case OP_Invalid: {
15677
0
  if (!Invalid(S, OpPC))
15678
0
    return false;
15679
0
  continue;
15680
0
}
15681
0
#endif
15682
#ifdef GET_DISASM
15683
case OP_Invalid:
15684
  PrintName("Invalid");
15685
  OS << "\t" << "\n";
15686
  continue;
15687
#endif
15688
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15689
bool emitInvalid(const SourceInfo &);
15690
#endif
15691
#ifdef GET_LINK_IMPL
15692
0
bool ByteCodeEmitter::emitInvalid(const SourceInfo &L) {
15693
0
  return emitOp<>(OP_Invalid, L);
15694
0
}
15695
#endif
15696
#ifdef GET_EVAL_IMPL
15697
0
bool EvalEmitter::emitInvalid(const SourceInfo &L) {
15698
0
  if (!isActive()) return true;
15699
0
  CurrentSource = L;
15700
0
  return Invalid(S, OpPC);
15701
0
}
15702
#endif
15703
#ifdef GET_OPCODE_NAMES
15704
OP_InvalidCast,
15705
#endif
15706
0
#ifdef GET_INTERP
15707
0
case OP_InvalidCast: {
15708
0
  auto V0 = ReadArg<CastKind>(S, PC);
15709
0
  if (!InvalidCast(S, OpPC, V0))
15710
0
    return false;
15711
0
  continue;
15712
0
}
15713
0
#endif
15714
#ifdef GET_DISASM
15715
case OP_InvalidCast:
15716
  PrintName("InvalidCast");
15717
  OS << "\t" << ReadArg<CastKind>(P, PC) << " " << "\n";
15718
  continue;
15719
#endif
15720
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15721
bool emitInvalidCast(CastKind, const SourceInfo &);
15722
#endif
15723
#ifdef GET_LINK_IMPL
15724
0
bool ByteCodeEmitter::emitInvalidCast(CastKind A0, const SourceInfo &L) {
15725
0
  return emitOp<CastKind>(OP_InvalidCast, A0, L);
15726
0
}
15727
#endif
15728
#ifdef GET_EVAL_IMPL
15729
0
bool EvalEmitter::emitInvalidCast(CastKind A0, const SourceInfo &L) {
15730
0
  if (!isActive()) return true;
15731
0
  CurrentSource = L;
15732
0
  return InvalidCast(S, OpPC, A0);
15733
0
}
15734
#endif
15735
#ifdef GET_OPCODE_NAMES
15736
OP_InvalidDeclRef,
15737
#endif
15738
0
#ifdef GET_INTERP
15739
0
case OP_InvalidDeclRef: {
15740
0
  auto V0 = ReadArg<const DeclRefExpr *>(S, PC);
15741
0
  if (!InvalidDeclRef(S, OpPC, V0))
15742
0
    return false;
15743
0
  continue;
15744
0
}
15745
0
#endif
15746
#ifdef GET_DISASM
15747
case OP_InvalidDeclRef:
15748
  PrintName("InvalidDeclRef");
15749
  OS << "\t" << ReadArg<const DeclRefExpr *>(P, PC) << " " << "\n";
15750
  continue;
15751
#endif
15752
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15753
bool emitInvalidDeclRef(const DeclRefExpr *, const SourceInfo &);
15754
#endif
15755
#ifdef GET_LINK_IMPL
15756
0
bool ByteCodeEmitter::emitInvalidDeclRef(const DeclRefExpr * A0, const SourceInfo &L) {
15757
0
  return emitOp<const DeclRefExpr *>(OP_InvalidDeclRef, A0, L);
15758
0
}
15759
#endif
15760
#ifdef GET_EVAL_IMPL
15761
0
bool EvalEmitter::emitInvalidDeclRef(const DeclRefExpr * A0, const SourceInfo &L) {
15762
0
  if (!isActive()) return true;
15763
0
  CurrentSource = L;
15764
0
  return InvalidDeclRef(S, OpPC, A0);
15765
0
}
15766
#endif
15767
#ifdef GET_OPCODE_NAMES
15768
OP_Jf,
15769
#endif
15770
0
#ifdef GET_INTERP
15771
0
case OP_Jf: {
15772
0
  auto V0 = ReadArg<int32_t>(S, PC);
15773
0
  if (!Jf(S, PC, V0))
15774
0
    return false;
15775
0
  continue;
15776
0
}
15777
0
#endif
15778
#ifdef GET_DISASM
15779
case OP_Jf:
15780
  PrintName("Jf");
15781
  OS << "\t" << ReadArg<int32_t>(P, PC) << " " << "\n";
15782
  continue;
15783
#endif
15784
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15785
bool emitJf(int32_t, const SourceInfo &);
15786
#endif
15787
#ifdef GET_LINK_IMPL
15788
0
bool ByteCodeEmitter::emitJf(int32_t A0, const SourceInfo &L) {
15789
0
  return emitOp<int32_t>(OP_Jf, A0, L);
15790
0
}
15791
#endif
15792
#ifdef GET_OPCODE_NAMES
15793
OP_Jmp,
15794
#endif
15795
0
#ifdef GET_INTERP
15796
0
case OP_Jmp: {
15797
0
  auto V0 = ReadArg<int32_t>(S, PC);
15798
0
  if (!Jmp(S, PC, V0))
15799
0
    return false;
15800
0
  continue;
15801
0
}
15802
0
#endif
15803
#ifdef GET_DISASM
15804
case OP_Jmp:
15805
  PrintName("Jmp");
15806
  OS << "\t" << ReadArg<int32_t>(P, PC) << " " << "\n";
15807
  continue;
15808
#endif
15809
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15810
bool emitJmp(int32_t, const SourceInfo &);
15811
#endif
15812
#ifdef GET_LINK_IMPL
15813
0
bool ByteCodeEmitter::emitJmp(int32_t A0, const SourceInfo &L) {
15814
0
  return emitOp<int32_t>(OP_Jmp, A0, L);
15815
0
}
15816
#endif
15817
#ifdef GET_OPCODE_NAMES
15818
OP_Jt,
15819
#endif
15820
0
#ifdef GET_INTERP
15821
0
case OP_Jt: {
15822
0
  auto V0 = ReadArg<int32_t>(S, PC);
15823
0
  if (!Jt(S, PC, V0))
15824
0
    return false;
15825
0
  continue;
15826
0
}
15827
0
#endif
15828
#ifdef GET_DISASM
15829
case OP_Jt:
15830
  PrintName("Jt");
15831
  OS << "\t" << ReadArg<int32_t>(P, PC) << " " << "\n";
15832
  continue;
15833
#endif
15834
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15835
bool emitJt(int32_t, const SourceInfo &);
15836
#endif
15837
#ifdef GET_LINK_IMPL
15838
0
bool ByteCodeEmitter::emitJt(int32_t A0, const SourceInfo &L) {
15839
0
  return emitOp<int32_t>(OP_Jt, A0, L);
15840
0
}
15841
#endif
15842
#ifdef GET_OPCODE_NAMES
15843
OP_LESint8,
15844
OP_LEUint8,
15845
OP_LESint16,
15846
OP_LEUint16,
15847
OP_LESint32,
15848
OP_LEUint32,
15849
OP_LESint64,
15850
OP_LEUint64,
15851
OP_LEIntAP,
15852
OP_LEIntAPS,
15853
OP_LEBool,
15854
OP_LEPtr,
15855
OP_LEFloat,
15856
OP_LEFnPtr,
15857
#endif
15858
0
#ifdef GET_INTERP
15859
0
case OP_LESint8: {
15860
0
  if (!LE<PT_Sint8>(S, OpPC))
15861
0
    return false;
15862
0
  continue;
15863
0
}
15864
0
case OP_LEUint8: {
15865
0
  if (!LE<PT_Uint8>(S, OpPC))
15866
0
    return false;
15867
0
  continue;
15868
0
}
15869
0
case OP_LESint16: {
15870
0
  if (!LE<PT_Sint16>(S, OpPC))
15871
0
    return false;
15872
0
  continue;
15873
0
}
15874
0
case OP_LEUint16: {
15875
0
  if (!LE<PT_Uint16>(S, OpPC))
15876
0
    return false;
15877
0
  continue;
15878
0
}
15879
0
case OP_LESint32: {
15880
0
  if (!LE<PT_Sint32>(S, OpPC))
15881
0
    return false;
15882
0
  continue;
15883
0
}
15884
0
case OP_LEUint32: {
15885
0
  if (!LE<PT_Uint32>(S, OpPC))
15886
0
    return false;
15887
0
  continue;
15888
0
}
15889
0
case OP_LESint64: {
15890
0
  if (!LE<PT_Sint64>(S, OpPC))
15891
0
    return false;
15892
0
  continue;
15893
0
}
15894
0
case OP_LEUint64: {
15895
0
  if (!LE<PT_Uint64>(S, OpPC))
15896
0
    return false;
15897
0
  continue;
15898
0
}
15899
0
case OP_LEIntAP: {
15900
0
  if (!LE<PT_IntAP>(S, OpPC))
15901
0
    return false;
15902
0
  continue;
15903
0
}
15904
0
case OP_LEIntAPS: {
15905
0
  if (!LE<PT_IntAPS>(S, OpPC))
15906
0
    return false;
15907
0
  continue;
15908
0
}
15909
0
case OP_LEBool: {
15910
0
  if (!LE<PT_Bool>(S, OpPC))
15911
0
    return false;
15912
0
  continue;
15913
0
}
15914
0
case OP_LEPtr: {
15915
0
  if (!LE<PT_Ptr>(S, OpPC))
15916
0
    return false;
15917
0
  continue;
15918
0
}
15919
0
case OP_LEFloat: {
15920
0
  if (!LE<PT_Float>(S, OpPC))
15921
0
    return false;
15922
0
  continue;
15923
0
}
15924
0
case OP_LEFnPtr: {
15925
0
  if (!LE<PT_FnPtr>(S, OpPC))
15926
0
    return false;
15927
0
  continue;
15928
0
}
15929
0
#endif
15930
#ifdef GET_DISASM
15931
case OP_LESint8:
15932
  PrintName("LESint8");
15933
  OS << "\t" << "\n";
15934
  continue;
15935
case OP_LEUint8:
15936
  PrintName("LEUint8");
15937
  OS << "\t" << "\n";
15938
  continue;
15939
case OP_LESint16:
15940
  PrintName("LESint16");
15941
  OS << "\t" << "\n";
15942
  continue;
15943
case OP_LEUint16:
15944
  PrintName("LEUint16");
15945
  OS << "\t" << "\n";
15946
  continue;
15947
case OP_LESint32:
15948
  PrintName("LESint32");
15949
  OS << "\t" << "\n";
15950
  continue;
15951
case OP_LEUint32:
15952
  PrintName("LEUint32");
15953
  OS << "\t" << "\n";
15954
  continue;
15955
case OP_LESint64:
15956
  PrintName("LESint64");
15957
  OS << "\t" << "\n";
15958
  continue;
15959
case OP_LEUint64:
15960
  PrintName("LEUint64");
15961
  OS << "\t" << "\n";
15962
  continue;
15963
case OP_LEIntAP:
15964
  PrintName("LEIntAP");
15965
  OS << "\t" << "\n";
15966
  continue;
15967
case OP_LEIntAPS:
15968
  PrintName("LEIntAPS");
15969
  OS << "\t" << "\n";
15970
  continue;
15971
case OP_LEBool:
15972
  PrintName("LEBool");
15973
  OS << "\t" << "\n";
15974
  continue;
15975
case OP_LEPtr:
15976
  PrintName("LEPtr");
15977
  OS << "\t" << "\n";
15978
  continue;
15979
case OP_LEFloat:
15980
  PrintName("LEFloat");
15981
  OS << "\t" << "\n";
15982
  continue;
15983
case OP_LEFnPtr:
15984
  PrintName("LEFnPtr");
15985
  OS << "\t" << "\n";
15986
  continue;
15987
#endif
15988
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15989
bool emitLESint8(const SourceInfo &);
15990
bool emitLEUint8(const SourceInfo &);
15991
bool emitLESint16(const SourceInfo &);
15992
bool emitLEUint16(const SourceInfo &);
15993
bool emitLESint32(const SourceInfo &);
15994
bool emitLEUint32(const SourceInfo &);
15995
bool emitLESint64(const SourceInfo &);
15996
bool emitLEUint64(const SourceInfo &);
15997
bool emitLEIntAP(const SourceInfo &);
15998
bool emitLEIntAPS(const SourceInfo &);
15999
bool emitLEBool(const SourceInfo &);
16000
bool emitLEPtr(const SourceInfo &);
16001
bool emitLEFloat(const SourceInfo &);
16002
bool emitLEFnPtr(const SourceInfo &);
16003
#endif
16004
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16005
bool emitLE(PrimType, const SourceInfo &I);
16006
#endif
16007
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16008
bool
16009
#if defined(GET_EVAL_IMPL)
16010
EvalEmitter
16011
#else
16012
ByteCodeEmitter
16013
#endif
16014
0
::emitLE(PrimType T0, const SourceInfo &I) {
16015
0
  switch (T0) {
16016
0
  case PT_Sint8:
16017
0
    return emitLESint8(I);
16018
0
  case PT_Uint8:
16019
0
    return emitLEUint8(I);
16020
0
  case PT_Sint16:
16021
0
    return emitLESint16(I);
16022
0
  case PT_Uint16:
16023
0
    return emitLEUint16(I);
16024
0
  case PT_Sint32:
16025
0
    return emitLESint32(I);
16026
0
  case PT_Uint32:
16027
0
    return emitLEUint32(I);
16028
0
  case PT_Sint64:
16029
0
    return emitLESint64(I);
16030
0
  case PT_Uint64:
16031
0
    return emitLEUint64(I);
16032
0
  case PT_IntAP:
16033
0
    return emitLEIntAP(I);
16034
0
  case PT_IntAPS:
16035
0
    return emitLEIntAPS(I);
16036
0
  case PT_Bool:
16037
0
    return emitLEBool(I);
16038
0
  case PT_Ptr:
16039
0
    return emitLEPtr(I);
16040
0
  case PT_Float:
16041
0
    return emitLEFloat(I);
16042
0
  case PT_FnPtr:
16043
0
    return emitLEFnPtr(I);
16044
0
  }
16045
0
  llvm_unreachable("invalid enum value");
16046
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitLE(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitLE(clang::interp::PrimType, clang::interp::SourceInfo const&)
16047
#endif
16048
#ifdef GET_LINK_IMPL
16049
0
bool ByteCodeEmitter::emitLESint8(const SourceInfo &L) {
16050
0
  return emitOp<>(OP_LESint8, L);
16051
0
}
16052
0
bool ByteCodeEmitter::emitLEUint8(const SourceInfo &L) {
16053
0
  return emitOp<>(OP_LEUint8, L);
16054
0
}
16055
0
bool ByteCodeEmitter::emitLESint16(const SourceInfo &L) {
16056
0
  return emitOp<>(OP_LESint16, L);
16057
0
}
16058
0
bool ByteCodeEmitter::emitLEUint16(const SourceInfo &L) {
16059
0
  return emitOp<>(OP_LEUint16, L);
16060
0
}
16061
0
bool ByteCodeEmitter::emitLESint32(const SourceInfo &L) {
16062
0
  return emitOp<>(OP_LESint32, L);
16063
0
}
16064
0
bool ByteCodeEmitter::emitLEUint32(const SourceInfo &L) {
16065
0
  return emitOp<>(OP_LEUint32, L);
16066
0
}
16067
0
bool ByteCodeEmitter::emitLESint64(const SourceInfo &L) {
16068
0
  return emitOp<>(OP_LESint64, L);
16069
0
}
16070
0
bool ByteCodeEmitter::emitLEUint64(const SourceInfo &L) {
16071
0
  return emitOp<>(OP_LEUint64, L);
16072
0
}
16073
0
bool ByteCodeEmitter::emitLEIntAP(const SourceInfo &L) {
16074
0
  return emitOp<>(OP_LEIntAP, L);
16075
0
}
16076
0
bool ByteCodeEmitter::emitLEIntAPS(const SourceInfo &L) {
16077
0
  return emitOp<>(OP_LEIntAPS, L);
16078
0
}
16079
0
bool ByteCodeEmitter::emitLEBool(const SourceInfo &L) {
16080
0
  return emitOp<>(OP_LEBool, L);
16081
0
}
16082
0
bool ByteCodeEmitter::emitLEPtr(const SourceInfo &L) {
16083
0
  return emitOp<>(OP_LEPtr, L);
16084
0
}
16085
0
bool ByteCodeEmitter::emitLEFloat(const SourceInfo &L) {
16086
0
  return emitOp<>(OP_LEFloat, L);
16087
0
}
16088
0
bool ByteCodeEmitter::emitLEFnPtr(const SourceInfo &L) {
16089
0
  return emitOp<>(OP_LEFnPtr, L);
16090
0
}
16091
#endif
16092
#ifdef GET_EVAL_IMPL
16093
0
bool EvalEmitter::emitLESint8(const SourceInfo &L) {
16094
0
  if (!isActive()) return true;
16095
0
  CurrentSource = L;
16096
0
  return LE<PT_Sint8>(S, OpPC);
16097
0
}
16098
0
bool EvalEmitter::emitLEUint8(const SourceInfo &L) {
16099
0
  if (!isActive()) return true;
16100
0
  CurrentSource = L;
16101
0
  return LE<PT_Uint8>(S, OpPC);
16102
0
}
16103
0
bool EvalEmitter::emitLESint16(const SourceInfo &L) {
16104
0
  if (!isActive()) return true;
16105
0
  CurrentSource = L;
16106
0
  return LE<PT_Sint16>(S, OpPC);
16107
0
}
16108
0
bool EvalEmitter::emitLEUint16(const SourceInfo &L) {
16109
0
  if (!isActive()) return true;
16110
0
  CurrentSource = L;
16111
0
  return LE<PT_Uint16>(S, OpPC);
16112
0
}
16113
0
bool EvalEmitter::emitLESint32(const SourceInfo &L) {
16114
0
  if (!isActive()) return true;
16115
0
  CurrentSource = L;
16116
0
  return LE<PT_Sint32>(S, OpPC);
16117
0
}
16118
0
bool EvalEmitter::emitLEUint32(const SourceInfo &L) {
16119
0
  if (!isActive()) return true;
16120
0
  CurrentSource = L;
16121
0
  return LE<PT_Uint32>(S, OpPC);
16122
0
}
16123
0
bool EvalEmitter::emitLESint64(const SourceInfo &L) {
16124
0
  if (!isActive()) return true;
16125
0
  CurrentSource = L;
16126
0
  return LE<PT_Sint64>(S, OpPC);
16127
0
}
16128
0
bool EvalEmitter::emitLEUint64(const SourceInfo &L) {
16129
0
  if (!isActive()) return true;
16130
0
  CurrentSource = L;
16131
0
  return LE<PT_Uint64>(S, OpPC);
16132
0
}
16133
0
bool EvalEmitter::emitLEIntAP(const SourceInfo &L) {
16134
0
  if (!isActive()) return true;
16135
0
  CurrentSource = L;
16136
0
  return LE<PT_IntAP>(S, OpPC);
16137
0
}
16138
0
bool EvalEmitter::emitLEIntAPS(const SourceInfo &L) {
16139
0
  if (!isActive()) return true;
16140
0
  CurrentSource = L;
16141
0
  return LE<PT_IntAPS>(S, OpPC);
16142
0
}
16143
0
bool EvalEmitter::emitLEBool(const SourceInfo &L) {
16144
0
  if (!isActive()) return true;
16145
0
  CurrentSource = L;
16146
0
  return LE<PT_Bool>(S, OpPC);
16147
0
}
16148
0
bool EvalEmitter::emitLEPtr(const SourceInfo &L) {
16149
0
  if (!isActive()) return true;
16150
0
  CurrentSource = L;
16151
0
  return LE<PT_Ptr>(S, OpPC);
16152
0
}
16153
0
bool EvalEmitter::emitLEFloat(const SourceInfo &L) {
16154
0
  if (!isActive()) return true;
16155
0
  CurrentSource = L;
16156
0
  return LE<PT_Float>(S, OpPC);
16157
0
}
16158
0
bool EvalEmitter::emitLEFnPtr(const SourceInfo &L) {
16159
0
  if (!isActive()) return true;
16160
0
  CurrentSource = L;
16161
0
  return LE<PT_FnPtr>(S, OpPC);
16162
0
}
16163
#endif
16164
#ifdef GET_OPCODE_NAMES
16165
OP_LTSint8,
16166
OP_LTUint8,
16167
OP_LTSint16,
16168
OP_LTUint16,
16169
OP_LTSint32,
16170
OP_LTUint32,
16171
OP_LTSint64,
16172
OP_LTUint64,
16173
OP_LTIntAP,
16174
OP_LTIntAPS,
16175
OP_LTBool,
16176
OP_LTPtr,
16177
OP_LTFloat,
16178
OP_LTFnPtr,
16179
#endif
16180
0
#ifdef GET_INTERP
16181
0
case OP_LTSint8: {
16182
0
  if (!LT<PT_Sint8>(S, OpPC))
16183
0
    return false;
16184
0
  continue;
16185
0
}
16186
0
case OP_LTUint8: {
16187
0
  if (!LT<PT_Uint8>(S, OpPC))
16188
0
    return false;
16189
0
  continue;
16190
0
}
16191
0
case OP_LTSint16: {
16192
0
  if (!LT<PT_Sint16>(S, OpPC))
16193
0
    return false;
16194
0
  continue;
16195
0
}
16196
0
case OP_LTUint16: {
16197
0
  if (!LT<PT_Uint16>(S, OpPC))
16198
0
    return false;
16199
0
  continue;
16200
0
}
16201
0
case OP_LTSint32: {
16202
0
  if (!LT<PT_Sint32>(S, OpPC))
16203
0
    return false;
16204
0
  continue;
16205
0
}
16206
0
case OP_LTUint32: {
16207
0
  if (!LT<PT_Uint32>(S, OpPC))
16208
0
    return false;
16209
0
  continue;
16210
0
}
16211
0
case OP_LTSint64: {
16212
0
  if (!LT<PT_Sint64>(S, OpPC))
16213
0
    return false;
16214
0
  continue;
16215
0
}
16216
0
case OP_LTUint64: {
16217
0
  if (!LT<PT_Uint64>(S, OpPC))
16218
0
    return false;
16219
0
  continue;
16220
0
}
16221
0
case OP_LTIntAP: {
16222
0
  if (!LT<PT_IntAP>(S, OpPC))
16223
0
    return false;
16224
0
  continue;
16225
0
}
16226
0
case OP_LTIntAPS: {
16227
0
  if (!LT<PT_IntAPS>(S, OpPC))
16228
0
    return false;
16229
0
  continue;
16230
0
}
16231
0
case OP_LTBool: {
16232
0
  if (!LT<PT_Bool>(S, OpPC))
16233
0
    return false;
16234
0
  continue;
16235
0
}
16236
0
case OP_LTPtr: {
16237
0
  if (!LT<PT_Ptr>(S, OpPC))
16238
0
    return false;
16239
0
  continue;
16240
0
}
16241
0
case OP_LTFloat: {
16242
0
  if (!LT<PT_Float>(S, OpPC))
16243
0
    return false;
16244
0
  continue;
16245
0
}
16246
0
case OP_LTFnPtr: {
16247
0
  if (!LT<PT_FnPtr>(S, OpPC))
16248
0
    return false;
16249
0
  continue;
16250
0
}
16251
0
#endif
16252
#ifdef GET_DISASM
16253
case OP_LTSint8:
16254
  PrintName("LTSint8");
16255
  OS << "\t" << "\n";
16256
  continue;
16257
case OP_LTUint8:
16258
  PrintName("LTUint8");
16259
  OS << "\t" << "\n";
16260
  continue;
16261
case OP_LTSint16:
16262
  PrintName("LTSint16");
16263
  OS << "\t" << "\n";
16264
  continue;
16265
case OP_LTUint16:
16266
  PrintName("LTUint16");
16267
  OS << "\t" << "\n";
16268
  continue;
16269
case OP_LTSint32:
16270
  PrintName("LTSint32");
16271
  OS << "\t" << "\n";
16272
  continue;
16273
case OP_LTUint32:
16274
  PrintName("LTUint32");
16275
  OS << "\t" << "\n";
16276
  continue;
16277
case OP_LTSint64:
16278
  PrintName("LTSint64");
16279
  OS << "\t" << "\n";
16280
  continue;
16281
case OP_LTUint64:
16282
  PrintName("LTUint64");
16283
  OS << "\t" << "\n";
16284
  continue;
16285
case OP_LTIntAP:
16286
  PrintName("LTIntAP");
16287
  OS << "\t" << "\n";
16288
  continue;
16289
case OP_LTIntAPS:
16290
  PrintName("LTIntAPS");
16291
  OS << "\t" << "\n";
16292
  continue;
16293
case OP_LTBool:
16294
  PrintName("LTBool");
16295
  OS << "\t" << "\n";
16296
  continue;
16297
case OP_LTPtr:
16298
  PrintName("LTPtr");
16299
  OS << "\t" << "\n";
16300
  continue;
16301
case OP_LTFloat:
16302
  PrintName("LTFloat");
16303
  OS << "\t" << "\n";
16304
  continue;
16305
case OP_LTFnPtr:
16306
  PrintName("LTFnPtr");
16307
  OS << "\t" << "\n";
16308
  continue;
16309
#endif
16310
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16311
bool emitLTSint8(const SourceInfo &);
16312
bool emitLTUint8(const SourceInfo &);
16313
bool emitLTSint16(const SourceInfo &);
16314
bool emitLTUint16(const SourceInfo &);
16315
bool emitLTSint32(const SourceInfo &);
16316
bool emitLTUint32(const SourceInfo &);
16317
bool emitLTSint64(const SourceInfo &);
16318
bool emitLTUint64(const SourceInfo &);
16319
bool emitLTIntAP(const SourceInfo &);
16320
bool emitLTIntAPS(const SourceInfo &);
16321
bool emitLTBool(const SourceInfo &);
16322
bool emitLTPtr(const SourceInfo &);
16323
bool emitLTFloat(const SourceInfo &);
16324
bool emitLTFnPtr(const SourceInfo &);
16325
#endif
16326
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16327
bool emitLT(PrimType, const SourceInfo &I);
16328
#endif
16329
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16330
bool
16331
#if defined(GET_EVAL_IMPL)
16332
EvalEmitter
16333
#else
16334
ByteCodeEmitter
16335
#endif
16336
0
::emitLT(PrimType T0, const SourceInfo &I) {
16337
0
  switch (T0) {
16338
0
  case PT_Sint8:
16339
0
    return emitLTSint8(I);
16340
0
  case PT_Uint8:
16341
0
    return emitLTUint8(I);
16342
0
  case PT_Sint16:
16343
0
    return emitLTSint16(I);
16344
0
  case PT_Uint16:
16345
0
    return emitLTUint16(I);
16346
0
  case PT_Sint32:
16347
0
    return emitLTSint32(I);
16348
0
  case PT_Uint32:
16349
0
    return emitLTUint32(I);
16350
0
  case PT_Sint64:
16351
0
    return emitLTSint64(I);
16352
0
  case PT_Uint64:
16353
0
    return emitLTUint64(I);
16354
0
  case PT_IntAP:
16355
0
    return emitLTIntAP(I);
16356
0
  case PT_IntAPS:
16357
0
    return emitLTIntAPS(I);
16358
0
  case PT_Bool:
16359
0
    return emitLTBool(I);
16360
0
  case PT_Ptr:
16361
0
    return emitLTPtr(I);
16362
0
  case PT_Float:
16363
0
    return emitLTFloat(I);
16364
0
  case PT_FnPtr:
16365
0
    return emitLTFnPtr(I);
16366
0
  }
16367
0
  llvm_unreachable("invalid enum value");
16368
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitLT(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitLT(clang::interp::PrimType, clang::interp::SourceInfo const&)
16369
#endif
16370
#ifdef GET_LINK_IMPL
16371
0
bool ByteCodeEmitter::emitLTSint8(const SourceInfo &L) {
16372
0
  return emitOp<>(OP_LTSint8, L);
16373
0
}
16374
0
bool ByteCodeEmitter::emitLTUint8(const SourceInfo &L) {
16375
0
  return emitOp<>(OP_LTUint8, L);
16376
0
}
16377
0
bool ByteCodeEmitter::emitLTSint16(const SourceInfo &L) {
16378
0
  return emitOp<>(OP_LTSint16, L);
16379
0
}
16380
0
bool ByteCodeEmitter::emitLTUint16(const SourceInfo &L) {
16381
0
  return emitOp<>(OP_LTUint16, L);
16382
0
}
16383
0
bool ByteCodeEmitter::emitLTSint32(const SourceInfo &L) {
16384
0
  return emitOp<>(OP_LTSint32, L);
16385
0
}
16386
0
bool ByteCodeEmitter::emitLTUint32(const SourceInfo &L) {
16387
0
  return emitOp<>(OP_LTUint32, L);
16388
0
}
16389
0
bool ByteCodeEmitter::emitLTSint64(const SourceInfo &L) {
16390
0
  return emitOp<>(OP_LTSint64, L);
16391
0
}
16392
0
bool ByteCodeEmitter::emitLTUint64(const SourceInfo &L) {
16393
0
  return emitOp<>(OP_LTUint64, L);
16394
0
}
16395
0
bool ByteCodeEmitter::emitLTIntAP(const SourceInfo &L) {
16396
0
  return emitOp<>(OP_LTIntAP, L);
16397
0
}
16398
0
bool ByteCodeEmitter::emitLTIntAPS(const SourceInfo &L) {
16399
0
  return emitOp<>(OP_LTIntAPS, L);
16400
0
}
16401
0
bool ByteCodeEmitter::emitLTBool(const SourceInfo &L) {
16402
0
  return emitOp<>(OP_LTBool, L);
16403
0
}
16404
0
bool ByteCodeEmitter::emitLTPtr(const SourceInfo &L) {
16405
0
  return emitOp<>(OP_LTPtr, L);
16406
0
}
16407
0
bool ByteCodeEmitter::emitLTFloat(const SourceInfo &L) {
16408
0
  return emitOp<>(OP_LTFloat, L);
16409
0
}
16410
0
bool ByteCodeEmitter::emitLTFnPtr(const SourceInfo &L) {
16411
0
  return emitOp<>(OP_LTFnPtr, L);
16412
0
}
16413
#endif
16414
#ifdef GET_EVAL_IMPL
16415
0
bool EvalEmitter::emitLTSint8(const SourceInfo &L) {
16416
0
  if (!isActive()) return true;
16417
0
  CurrentSource = L;
16418
0
  return LT<PT_Sint8>(S, OpPC);
16419
0
}
16420
0
bool EvalEmitter::emitLTUint8(const SourceInfo &L) {
16421
0
  if (!isActive()) return true;
16422
0
  CurrentSource = L;
16423
0
  return LT<PT_Uint8>(S, OpPC);
16424
0
}
16425
0
bool EvalEmitter::emitLTSint16(const SourceInfo &L) {
16426
0
  if (!isActive()) return true;
16427
0
  CurrentSource = L;
16428
0
  return LT<PT_Sint16>(S, OpPC);
16429
0
}
16430
0
bool EvalEmitter::emitLTUint16(const SourceInfo &L) {
16431
0
  if (!isActive()) return true;
16432
0
  CurrentSource = L;
16433
0
  return LT<PT_Uint16>(S, OpPC);
16434
0
}
16435
0
bool EvalEmitter::emitLTSint32(const SourceInfo &L) {
16436
0
  if (!isActive()) return true;
16437
0
  CurrentSource = L;
16438
0
  return LT<PT_Sint32>(S, OpPC);
16439
0
}
16440
0
bool EvalEmitter::emitLTUint32(const SourceInfo &L) {
16441
0
  if (!isActive()) return true;
16442
0
  CurrentSource = L;
16443
0
  return LT<PT_Uint32>(S, OpPC);
16444
0
}
16445
0
bool EvalEmitter::emitLTSint64(const SourceInfo &L) {
16446
0
  if (!isActive()) return true;
16447
0
  CurrentSource = L;
16448
0
  return LT<PT_Sint64>(S, OpPC);
16449
0
}
16450
0
bool EvalEmitter::emitLTUint64(const SourceInfo &L) {
16451
0
  if (!isActive()) return true;
16452
0
  CurrentSource = L;
16453
0
  return LT<PT_Uint64>(S, OpPC);
16454
0
}
16455
0
bool EvalEmitter::emitLTIntAP(const SourceInfo &L) {
16456
0
  if (!isActive()) return true;
16457
0
  CurrentSource = L;
16458
0
  return LT<PT_IntAP>(S, OpPC);
16459
0
}
16460
0
bool EvalEmitter::emitLTIntAPS(const SourceInfo &L) {
16461
0
  if (!isActive()) return true;
16462
0
  CurrentSource = L;
16463
0
  return LT<PT_IntAPS>(S, OpPC);
16464
0
}
16465
0
bool EvalEmitter::emitLTBool(const SourceInfo &L) {
16466
0
  if (!isActive()) return true;
16467
0
  CurrentSource = L;
16468
0
  return LT<PT_Bool>(S, OpPC);
16469
0
}
16470
0
bool EvalEmitter::emitLTPtr(const SourceInfo &L) {
16471
0
  if (!isActive()) return true;
16472
0
  CurrentSource = L;
16473
0
  return LT<PT_Ptr>(S, OpPC);
16474
0
}
16475
0
bool EvalEmitter::emitLTFloat(const SourceInfo &L) {
16476
0
  if (!isActive()) return true;
16477
0
  CurrentSource = L;
16478
0
  return LT<PT_Float>(S, OpPC);
16479
0
}
16480
0
bool EvalEmitter::emitLTFnPtr(const SourceInfo &L) {
16481
0
  if (!isActive()) return true;
16482
0
  CurrentSource = L;
16483
0
  return LT<PT_FnPtr>(S, OpPC);
16484
0
}
16485
#endif
16486
#ifdef GET_OPCODE_NAMES
16487
OP_LoadSint8,
16488
OP_LoadUint8,
16489
OP_LoadSint16,
16490
OP_LoadUint16,
16491
OP_LoadSint32,
16492
OP_LoadUint32,
16493
OP_LoadSint64,
16494
OP_LoadUint64,
16495
OP_LoadIntAP,
16496
OP_LoadIntAPS,
16497
OP_LoadBool,
16498
OP_LoadPtr,
16499
OP_LoadFnPtr,
16500
OP_LoadFloat,
16501
#endif
16502
0
#ifdef GET_INTERP
16503
0
case OP_LoadSint8: {
16504
0
  if (!Load<PT_Sint8>(S, OpPC))
16505
0
    return false;
16506
0
  continue;
16507
0
}
16508
0
case OP_LoadUint8: {
16509
0
  if (!Load<PT_Uint8>(S, OpPC))
16510
0
    return false;
16511
0
  continue;
16512
0
}
16513
0
case OP_LoadSint16: {
16514
0
  if (!Load<PT_Sint16>(S, OpPC))
16515
0
    return false;
16516
0
  continue;
16517
0
}
16518
0
case OP_LoadUint16: {
16519
0
  if (!Load<PT_Uint16>(S, OpPC))
16520
0
    return false;
16521
0
  continue;
16522
0
}
16523
0
case OP_LoadSint32: {
16524
0
  if (!Load<PT_Sint32>(S, OpPC))
16525
0
    return false;
16526
0
  continue;
16527
0
}
16528
0
case OP_LoadUint32: {
16529
0
  if (!Load<PT_Uint32>(S, OpPC))
16530
0
    return false;
16531
0
  continue;
16532
0
}
16533
0
case OP_LoadSint64: {
16534
0
  if (!Load<PT_Sint64>(S, OpPC))
16535
0
    return false;
16536
0
  continue;
16537
0
}
16538
0
case OP_LoadUint64: {
16539
0
  if (!Load<PT_Uint64>(S, OpPC))
16540
0
    return false;
16541
0
  continue;
16542
0
}
16543
0
case OP_LoadIntAP: {
16544
0
  if (!Load<PT_IntAP>(S, OpPC))
16545
0
    return false;
16546
0
  continue;
16547
0
}
16548
0
case OP_LoadIntAPS: {
16549
0
  if (!Load<PT_IntAPS>(S, OpPC))
16550
0
    return false;
16551
0
  continue;
16552
0
}
16553
0
case OP_LoadBool: {
16554
0
  if (!Load<PT_Bool>(S, OpPC))
16555
0
    return false;
16556
0
  continue;
16557
0
}
16558
0
case OP_LoadPtr: {
16559
0
  if (!Load<PT_Ptr>(S, OpPC))
16560
0
    return false;
16561
0
  continue;
16562
0
}
16563
0
case OP_LoadFnPtr: {
16564
0
  if (!Load<PT_FnPtr>(S, OpPC))
16565
0
    return false;
16566
0
  continue;
16567
0
}
16568
0
case OP_LoadFloat: {
16569
0
  if (!Load<PT_Float>(S, OpPC))
16570
0
    return false;
16571
0
  continue;
16572
0
}
16573
0
#endif
16574
#ifdef GET_DISASM
16575
case OP_LoadSint8:
16576
  PrintName("LoadSint8");
16577
  OS << "\t" << "\n";
16578
  continue;
16579
case OP_LoadUint8:
16580
  PrintName("LoadUint8");
16581
  OS << "\t" << "\n";
16582
  continue;
16583
case OP_LoadSint16:
16584
  PrintName("LoadSint16");
16585
  OS << "\t" << "\n";
16586
  continue;
16587
case OP_LoadUint16:
16588
  PrintName("LoadUint16");
16589
  OS << "\t" << "\n";
16590
  continue;
16591
case OP_LoadSint32:
16592
  PrintName("LoadSint32");
16593
  OS << "\t" << "\n";
16594
  continue;
16595
case OP_LoadUint32:
16596
  PrintName("LoadUint32");
16597
  OS << "\t" << "\n";
16598
  continue;
16599
case OP_LoadSint64:
16600
  PrintName("LoadSint64");
16601
  OS << "\t" << "\n";
16602
  continue;
16603
case OP_LoadUint64:
16604
  PrintName("LoadUint64");
16605
  OS << "\t" << "\n";
16606
  continue;
16607
case OP_LoadIntAP:
16608
  PrintName("LoadIntAP");
16609
  OS << "\t" << "\n";
16610
  continue;
16611
case OP_LoadIntAPS:
16612
  PrintName("LoadIntAPS");
16613
  OS << "\t" << "\n";
16614
  continue;
16615
case OP_LoadBool:
16616
  PrintName("LoadBool");
16617
  OS << "\t" << "\n";
16618
  continue;
16619
case OP_LoadPtr:
16620
  PrintName("LoadPtr");
16621
  OS << "\t" << "\n";
16622
  continue;
16623
case OP_LoadFnPtr:
16624
  PrintName("LoadFnPtr");
16625
  OS << "\t" << "\n";
16626
  continue;
16627
case OP_LoadFloat:
16628
  PrintName("LoadFloat");
16629
  OS << "\t" << "\n";
16630
  continue;
16631
#endif
16632
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16633
bool emitLoadSint8(const SourceInfo &);
16634
bool emitLoadUint8(const SourceInfo &);
16635
bool emitLoadSint16(const SourceInfo &);
16636
bool emitLoadUint16(const SourceInfo &);
16637
bool emitLoadSint32(const SourceInfo &);
16638
bool emitLoadUint32(const SourceInfo &);
16639
bool emitLoadSint64(const SourceInfo &);
16640
bool emitLoadUint64(const SourceInfo &);
16641
bool emitLoadIntAP(const SourceInfo &);
16642
bool emitLoadIntAPS(const SourceInfo &);
16643
bool emitLoadBool(const SourceInfo &);
16644
bool emitLoadPtr(const SourceInfo &);
16645
bool emitLoadFnPtr(const SourceInfo &);
16646
bool emitLoadFloat(const SourceInfo &);
16647
#endif
16648
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16649
bool emitLoad(PrimType, const SourceInfo &I);
16650
#endif
16651
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16652
bool
16653
#if defined(GET_EVAL_IMPL)
16654
EvalEmitter
16655
#else
16656
ByteCodeEmitter
16657
#endif
16658
0
::emitLoad(PrimType T0, const SourceInfo &I) {
16659
0
  switch (T0) {
16660
0
  case PT_Sint8:
16661
0
    return emitLoadSint8(I);
16662
0
  case PT_Uint8:
16663
0
    return emitLoadUint8(I);
16664
0
  case PT_Sint16:
16665
0
    return emitLoadSint16(I);
16666
0
  case PT_Uint16:
16667
0
    return emitLoadUint16(I);
16668
0
  case PT_Sint32:
16669
0
    return emitLoadSint32(I);
16670
0
  case PT_Uint32:
16671
0
    return emitLoadUint32(I);
16672
0
  case PT_Sint64:
16673
0
    return emitLoadSint64(I);
16674
0
  case PT_Uint64:
16675
0
    return emitLoadUint64(I);
16676
0
  case PT_IntAP:
16677
0
    return emitLoadIntAP(I);
16678
0
  case PT_IntAPS:
16679
0
    return emitLoadIntAPS(I);
16680
0
  case PT_Bool:
16681
0
    return emitLoadBool(I);
16682
0
  case PT_Ptr:
16683
0
    return emitLoadPtr(I);
16684
0
  case PT_FnPtr:
16685
0
    return emitLoadFnPtr(I);
16686
0
  case PT_Float:
16687
0
    return emitLoadFloat(I);
16688
0
  }
16689
0
  llvm_unreachable("invalid enum value");
16690
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitLoad(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitLoad(clang::interp::PrimType, clang::interp::SourceInfo const&)
16691
#endif
16692
#ifdef GET_LINK_IMPL
16693
0
bool ByteCodeEmitter::emitLoadSint8(const SourceInfo &L) {
16694
0
  return emitOp<>(OP_LoadSint8, L);
16695
0
}
16696
0
bool ByteCodeEmitter::emitLoadUint8(const SourceInfo &L) {
16697
0
  return emitOp<>(OP_LoadUint8, L);
16698
0
}
16699
0
bool ByteCodeEmitter::emitLoadSint16(const SourceInfo &L) {
16700
0
  return emitOp<>(OP_LoadSint16, L);
16701
0
}
16702
0
bool ByteCodeEmitter::emitLoadUint16(const SourceInfo &L) {
16703
0
  return emitOp<>(OP_LoadUint16, L);
16704
0
}
16705
0
bool ByteCodeEmitter::emitLoadSint32(const SourceInfo &L) {
16706
0
  return emitOp<>(OP_LoadSint32, L);
16707
0
}
16708
0
bool ByteCodeEmitter::emitLoadUint32(const SourceInfo &L) {
16709
0
  return emitOp<>(OP_LoadUint32, L);
16710
0
}
16711
0
bool ByteCodeEmitter::emitLoadSint64(const SourceInfo &L) {
16712
0
  return emitOp<>(OP_LoadSint64, L);
16713
0
}
16714
0
bool ByteCodeEmitter::emitLoadUint64(const SourceInfo &L) {
16715
0
  return emitOp<>(OP_LoadUint64, L);
16716
0
}
16717
0
bool ByteCodeEmitter::emitLoadIntAP(const SourceInfo &L) {
16718
0
  return emitOp<>(OP_LoadIntAP, L);
16719
0
}
16720
0
bool ByteCodeEmitter::emitLoadIntAPS(const SourceInfo &L) {
16721
0
  return emitOp<>(OP_LoadIntAPS, L);
16722
0
}
16723
0
bool ByteCodeEmitter::emitLoadBool(const SourceInfo &L) {
16724
0
  return emitOp<>(OP_LoadBool, L);
16725
0
}
16726
0
bool ByteCodeEmitter::emitLoadPtr(const SourceInfo &L) {
16727
0
  return emitOp<>(OP_LoadPtr, L);
16728
0
}
16729
0
bool ByteCodeEmitter::emitLoadFnPtr(const SourceInfo &L) {
16730
0
  return emitOp<>(OP_LoadFnPtr, L);
16731
0
}
16732
0
bool ByteCodeEmitter::emitLoadFloat(const SourceInfo &L) {
16733
0
  return emitOp<>(OP_LoadFloat, L);
16734
0
}
16735
#endif
16736
#ifdef GET_EVAL_IMPL
16737
0
bool EvalEmitter::emitLoadSint8(const SourceInfo &L) {
16738
0
  if (!isActive()) return true;
16739
0
  CurrentSource = L;
16740
0
  return Load<PT_Sint8>(S, OpPC);
16741
0
}
16742
0
bool EvalEmitter::emitLoadUint8(const SourceInfo &L) {
16743
0
  if (!isActive()) return true;
16744
0
  CurrentSource = L;
16745
0
  return Load<PT_Uint8>(S, OpPC);
16746
0
}
16747
0
bool EvalEmitter::emitLoadSint16(const SourceInfo &L) {
16748
0
  if (!isActive()) return true;
16749
0
  CurrentSource = L;
16750
0
  return Load<PT_Sint16>(S, OpPC);
16751
0
}
16752
0
bool EvalEmitter::emitLoadUint16(const SourceInfo &L) {
16753
0
  if (!isActive()) return true;
16754
0
  CurrentSource = L;
16755
0
  return Load<PT_Uint16>(S, OpPC);
16756
0
}
16757
0
bool EvalEmitter::emitLoadSint32(const SourceInfo &L) {
16758
0
  if (!isActive()) return true;
16759
0
  CurrentSource = L;
16760
0
  return Load<PT_Sint32>(S, OpPC);
16761
0
}
16762
0
bool EvalEmitter::emitLoadUint32(const SourceInfo &L) {
16763
0
  if (!isActive()) return true;
16764
0
  CurrentSource = L;
16765
0
  return Load<PT_Uint32>(S, OpPC);
16766
0
}
16767
0
bool EvalEmitter::emitLoadSint64(const SourceInfo &L) {
16768
0
  if (!isActive()) return true;
16769
0
  CurrentSource = L;
16770
0
  return Load<PT_Sint64>(S, OpPC);
16771
0
}
16772
0
bool EvalEmitter::emitLoadUint64(const SourceInfo &L) {
16773
0
  if (!isActive()) return true;
16774
0
  CurrentSource = L;
16775
0
  return Load<PT_Uint64>(S, OpPC);
16776
0
}
16777
0
bool EvalEmitter::emitLoadIntAP(const SourceInfo &L) {
16778
0
  if (!isActive()) return true;
16779
0
  CurrentSource = L;
16780
0
  return Load<PT_IntAP>(S, OpPC);
16781
0
}
16782
0
bool EvalEmitter::emitLoadIntAPS(const SourceInfo &L) {
16783
0
  if (!isActive()) return true;
16784
0
  CurrentSource = L;
16785
0
  return Load<PT_IntAPS>(S, OpPC);
16786
0
}
16787
0
bool EvalEmitter::emitLoadBool(const SourceInfo &L) {
16788
0
  if (!isActive()) return true;
16789
0
  CurrentSource = L;
16790
0
  return Load<PT_Bool>(S, OpPC);
16791
0
}
16792
0
bool EvalEmitter::emitLoadPtr(const SourceInfo &L) {
16793
0
  if (!isActive()) return true;
16794
0
  CurrentSource = L;
16795
0
  return Load<PT_Ptr>(S, OpPC);
16796
0
}
16797
0
bool EvalEmitter::emitLoadFnPtr(const SourceInfo &L) {
16798
0
  if (!isActive()) return true;
16799
0
  CurrentSource = L;
16800
0
  return Load<PT_FnPtr>(S, OpPC);
16801
0
}
16802
0
bool EvalEmitter::emitLoadFloat(const SourceInfo &L) {
16803
0
  if (!isActive()) return true;
16804
0
  CurrentSource = L;
16805
0
  return Load<PT_Float>(S, OpPC);
16806
0
}
16807
#endif
16808
#ifdef GET_OPCODE_NAMES
16809
OP_LoadPopSint8,
16810
OP_LoadPopUint8,
16811
OP_LoadPopSint16,
16812
OP_LoadPopUint16,
16813
OP_LoadPopSint32,
16814
OP_LoadPopUint32,
16815
OP_LoadPopSint64,
16816
OP_LoadPopUint64,
16817
OP_LoadPopIntAP,
16818
OP_LoadPopIntAPS,
16819
OP_LoadPopBool,
16820
OP_LoadPopPtr,
16821
OP_LoadPopFnPtr,
16822
OP_LoadPopFloat,
16823
#endif
16824
0
#ifdef GET_INTERP
16825
0
case OP_LoadPopSint8: {
16826
0
  if (!LoadPop<PT_Sint8>(S, OpPC))
16827
0
    return false;
16828
0
  continue;
16829
0
}
16830
0
case OP_LoadPopUint8: {
16831
0
  if (!LoadPop<PT_Uint8>(S, OpPC))
16832
0
    return false;
16833
0
  continue;
16834
0
}
16835
0
case OP_LoadPopSint16: {
16836
0
  if (!LoadPop<PT_Sint16>(S, OpPC))
16837
0
    return false;
16838
0
  continue;
16839
0
}
16840
0
case OP_LoadPopUint16: {
16841
0
  if (!LoadPop<PT_Uint16>(S, OpPC))
16842
0
    return false;
16843
0
  continue;
16844
0
}
16845
0
case OP_LoadPopSint32: {
16846
0
  if (!LoadPop<PT_Sint32>(S, OpPC))
16847
0
    return false;
16848
0
  continue;
16849
0
}
16850
0
case OP_LoadPopUint32: {
16851
0
  if (!LoadPop<PT_Uint32>(S, OpPC))
16852
0
    return false;
16853
0
  continue;
16854
0
}
16855
0
case OP_LoadPopSint64: {
16856
0
  if (!LoadPop<PT_Sint64>(S, OpPC))
16857
0
    return false;
16858
0
  continue;
16859
0
}
16860
0
case OP_LoadPopUint64: {
16861
0
  if (!LoadPop<PT_Uint64>(S, OpPC))
16862
0
    return false;
16863
0
  continue;
16864
0
}
16865
0
case OP_LoadPopIntAP: {
16866
0
  if (!LoadPop<PT_IntAP>(S, OpPC))
16867
0
    return false;
16868
0
  continue;
16869
0
}
16870
0
case OP_LoadPopIntAPS: {
16871
0
  if (!LoadPop<PT_IntAPS>(S, OpPC))
16872
0
    return false;
16873
0
  continue;
16874
0
}
16875
0
case OP_LoadPopBool: {
16876
0
  if (!LoadPop<PT_Bool>(S, OpPC))
16877
0
    return false;
16878
0
  continue;
16879
0
}
16880
0
case OP_LoadPopPtr: {
16881
0
  if (!LoadPop<PT_Ptr>(S, OpPC))
16882
0
    return false;
16883
0
  continue;
16884
0
}
16885
0
case OP_LoadPopFnPtr: {
16886
0
  if (!LoadPop<PT_FnPtr>(S, OpPC))
16887
0
    return false;
16888
0
  continue;
16889
0
}
16890
0
case OP_LoadPopFloat: {
16891
0
  if (!LoadPop<PT_Float>(S, OpPC))
16892
0
    return false;
16893
0
  continue;
16894
0
}
16895
0
#endif
16896
#ifdef GET_DISASM
16897
case OP_LoadPopSint8:
16898
  PrintName("LoadPopSint8");
16899
  OS << "\t" << "\n";
16900
  continue;
16901
case OP_LoadPopUint8:
16902
  PrintName("LoadPopUint8");
16903
  OS << "\t" << "\n";
16904
  continue;
16905
case OP_LoadPopSint16:
16906
  PrintName("LoadPopSint16");
16907
  OS << "\t" << "\n";
16908
  continue;
16909
case OP_LoadPopUint16:
16910
  PrintName("LoadPopUint16");
16911
  OS << "\t" << "\n";
16912
  continue;
16913
case OP_LoadPopSint32:
16914
  PrintName("LoadPopSint32");
16915
  OS << "\t" << "\n";
16916
  continue;
16917
case OP_LoadPopUint32:
16918
  PrintName("LoadPopUint32");
16919
  OS << "\t" << "\n";
16920
  continue;
16921
case OP_LoadPopSint64:
16922
  PrintName("LoadPopSint64");
16923
  OS << "\t" << "\n";
16924
  continue;
16925
case OP_LoadPopUint64:
16926
  PrintName("LoadPopUint64");
16927
  OS << "\t" << "\n";
16928
  continue;
16929
case OP_LoadPopIntAP:
16930
  PrintName("LoadPopIntAP");
16931
  OS << "\t" << "\n";
16932
  continue;
16933
case OP_LoadPopIntAPS:
16934
  PrintName("LoadPopIntAPS");
16935
  OS << "\t" << "\n";
16936
  continue;
16937
case OP_LoadPopBool:
16938
  PrintName("LoadPopBool");
16939
  OS << "\t" << "\n";
16940
  continue;
16941
case OP_LoadPopPtr:
16942
  PrintName("LoadPopPtr");
16943
  OS << "\t" << "\n";
16944
  continue;
16945
case OP_LoadPopFnPtr:
16946
  PrintName("LoadPopFnPtr");
16947
  OS << "\t" << "\n";
16948
  continue;
16949
case OP_LoadPopFloat:
16950
  PrintName("LoadPopFloat");
16951
  OS << "\t" << "\n";
16952
  continue;
16953
#endif
16954
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16955
bool emitLoadPopSint8(const SourceInfo &);
16956
bool emitLoadPopUint8(const SourceInfo &);
16957
bool emitLoadPopSint16(const SourceInfo &);
16958
bool emitLoadPopUint16(const SourceInfo &);
16959
bool emitLoadPopSint32(const SourceInfo &);
16960
bool emitLoadPopUint32(const SourceInfo &);
16961
bool emitLoadPopSint64(const SourceInfo &);
16962
bool emitLoadPopUint64(const SourceInfo &);
16963
bool emitLoadPopIntAP(const SourceInfo &);
16964
bool emitLoadPopIntAPS(const SourceInfo &);
16965
bool emitLoadPopBool(const SourceInfo &);
16966
bool emitLoadPopPtr(const SourceInfo &);
16967
bool emitLoadPopFnPtr(const SourceInfo &);
16968
bool emitLoadPopFloat(const SourceInfo &);
16969
#endif
16970
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16971
bool emitLoadPop(PrimType, const SourceInfo &I);
16972
#endif
16973
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16974
bool
16975
#if defined(GET_EVAL_IMPL)
16976
EvalEmitter
16977
#else
16978
ByteCodeEmitter
16979
#endif
16980
0
::emitLoadPop(PrimType T0, const SourceInfo &I) {
16981
0
  switch (T0) {
16982
0
  case PT_Sint8:
16983
0
    return emitLoadPopSint8(I);
16984
0
  case PT_Uint8:
16985
0
    return emitLoadPopUint8(I);
16986
0
  case PT_Sint16:
16987
0
    return emitLoadPopSint16(I);
16988
0
  case PT_Uint16:
16989
0
    return emitLoadPopUint16(I);
16990
0
  case PT_Sint32:
16991
0
    return emitLoadPopSint32(I);
16992
0
  case PT_Uint32:
16993
0
    return emitLoadPopUint32(I);
16994
0
  case PT_Sint64:
16995
0
    return emitLoadPopSint64(I);
16996
0
  case PT_Uint64:
16997
0
    return emitLoadPopUint64(I);
16998
0
  case PT_IntAP:
16999
0
    return emitLoadPopIntAP(I);
17000
0
  case PT_IntAPS:
17001
0
    return emitLoadPopIntAPS(I);
17002
0
  case PT_Bool:
17003
0
    return emitLoadPopBool(I);
17004
0
  case PT_Ptr:
17005
0
    return emitLoadPopPtr(I);
17006
0
  case PT_FnPtr:
17007
0
    return emitLoadPopFnPtr(I);
17008
0
  case PT_Float:
17009
0
    return emitLoadPopFloat(I);
17010
0
  }
17011
0
  llvm_unreachable("invalid enum value");
17012
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitLoadPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitLoadPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
17013
#endif
17014
#ifdef GET_LINK_IMPL
17015
0
bool ByteCodeEmitter::emitLoadPopSint8(const SourceInfo &L) {
17016
0
  return emitOp<>(OP_LoadPopSint8, L);
17017
0
}
17018
0
bool ByteCodeEmitter::emitLoadPopUint8(const SourceInfo &L) {
17019
0
  return emitOp<>(OP_LoadPopUint8, L);
17020
0
}
17021
0
bool ByteCodeEmitter::emitLoadPopSint16(const SourceInfo &L) {
17022
0
  return emitOp<>(OP_LoadPopSint16, L);
17023
0
}
17024
0
bool ByteCodeEmitter::emitLoadPopUint16(const SourceInfo &L) {
17025
0
  return emitOp<>(OP_LoadPopUint16, L);
17026
0
}
17027
0
bool ByteCodeEmitter::emitLoadPopSint32(const SourceInfo &L) {
17028
0
  return emitOp<>(OP_LoadPopSint32, L);
17029
0
}
17030
0
bool ByteCodeEmitter::emitLoadPopUint32(const SourceInfo &L) {
17031
0
  return emitOp<>(OP_LoadPopUint32, L);
17032
0
}
17033
0
bool ByteCodeEmitter::emitLoadPopSint64(const SourceInfo &L) {
17034
0
  return emitOp<>(OP_LoadPopSint64, L);
17035
0
}
17036
0
bool ByteCodeEmitter::emitLoadPopUint64(const SourceInfo &L) {
17037
0
  return emitOp<>(OP_LoadPopUint64, L);
17038
0
}
17039
0
bool ByteCodeEmitter::emitLoadPopIntAP(const SourceInfo &L) {
17040
0
  return emitOp<>(OP_LoadPopIntAP, L);
17041
0
}
17042
0
bool ByteCodeEmitter::emitLoadPopIntAPS(const SourceInfo &L) {
17043
0
  return emitOp<>(OP_LoadPopIntAPS, L);
17044
0
}
17045
0
bool ByteCodeEmitter::emitLoadPopBool(const SourceInfo &L) {
17046
0
  return emitOp<>(OP_LoadPopBool, L);
17047
0
}
17048
0
bool ByteCodeEmitter::emitLoadPopPtr(const SourceInfo &L) {
17049
0
  return emitOp<>(OP_LoadPopPtr, L);
17050
0
}
17051
0
bool ByteCodeEmitter::emitLoadPopFnPtr(const SourceInfo &L) {
17052
0
  return emitOp<>(OP_LoadPopFnPtr, L);
17053
0
}
17054
0
bool ByteCodeEmitter::emitLoadPopFloat(const SourceInfo &L) {
17055
0
  return emitOp<>(OP_LoadPopFloat, L);
17056
0
}
17057
#endif
17058
#ifdef GET_EVAL_IMPL
17059
0
bool EvalEmitter::emitLoadPopSint8(const SourceInfo &L) {
17060
0
  if (!isActive()) return true;
17061
0
  CurrentSource = L;
17062
0
  return LoadPop<PT_Sint8>(S, OpPC);
17063
0
}
17064
0
bool EvalEmitter::emitLoadPopUint8(const SourceInfo &L) {
17065
0
  if (!isActive()) return true;
17066
0
  CurrentSource = L;
17067
0
  return LoadPop<PT_Uint8>(S, OpPC);
17068
0
}
17069
0
bool EvalEmitter::emitLoadPopSint16(const SourceInfo &L) {
17070
0
  if (!isActive()) return true;
17071
0
  CurrentSource = L;
17072
0
  return LoadPop<PT_Sint16>(S, OpPC);
17073
0
}
17074
0
bool EvalEmitter::emitLoadPopUint16(const SourceInfo &L) {
17075
0
  if (!isActive()) return true;
17076
0
  CurrentSource = L;
17077
0
  return LoadPop<PT_Uint16>(S, OpPC);
17078
0
}
17079
0
bool EvalEmitter::emitLoadPopSint32(const SourceInfo &L) {
17080
0
  if (!isActive()) return true;
17081
0
  CurrentSource = L;
17082
0
  return LoadPop<PT_Sint32>(S, OpPC);
17083
0
}
17084
0
bool EvalEmitter::emitLoadPopUint32(const SourceInfo &L) {
17085
0
  if (!isActive()) return true;
17086
0
  CurrentSource = L;
17087
0
  return LoadPop<PT_Uint32>(S, OpPC);
17088
0
}
17089
0
bool EvalEmitter::emitLoadPopSint64(const SourceInfo &L) {
17090
0
  if (!isActive()) return true;
17091
0
  CurrentSource = L;
17092
0
  return LoadPop<PT_Sint64>(S, OpPC);
17093
0
}
17094
0
bool EvalEmitter::emitLoadPopUint64(const SourceInfo &L) {
17095
0
  if (!isActive()) return true;
17096
0
  CurrentSource = L;
17097
0
  return LoadPop<PT_Uint64>(S, OpPC);
17098
0
}
17099
0
bool EvalEmitter::emitLoadPopIntAP(const SourceInfo &L) {
17100
0
  if (!isActive()) return true;
17101
0
  CurrentSource = L;
17102
0
  return LoadPop<PT_IntAP>(S, OpPC);
17103
0
}
17104
0
bool EvalEmitter::emitLoadPopIntAPS(const SourceInfo &L) {
17105
0
  if (!isActive()) return true;
17106
0
  CurrentSource = L;
17107
0
  return LoadPop<PT_IntAPS>(S, OpPC);
17108
0
}
17109
0
bool EvalEmitter::emitLoadPopBool(const SourceInfo &L) {
17110
0
  if (!isActive()) return true;
17111
0
  CurrentSource = L;
17112
0
  return LoadPop<PT_Bool>(S, OpPC);
17113
0
}
17114
0
bool EvalEmitter::emitLoadPopPtr(const SourceInfo &L) {
17115
0
  if (!isActive()) return true;
17116
0
  CurrentSource = L;
17117
0
  return LoadPop<PT_Ptr>(S, OpPC);
17118
0
}
17119
0
bool EvalEmitter::emitLoadPopFnPtr(const SourceInfo &L) {
17120
0
  if (!isActive()) return true;
17121
0
  CurrentSource = L;
17122
0
  return LoadPop<PT_FnPtr>(S, OpPC);
17123
0
}
17124
0
bool EvalEmitter::emitLoadPopFloat(const SourceInfo &L) {
17125
0
  if (!isActive()) return true;
17126
0
  CurrentSource = L;
17127
0
  return LoadPop<PT_Float>(S, OpPC);
17128
0
}
17129
#endif
17130
#ifdef GET_OPCODE_NAMES
17131
OP_MulSint8,
17132
OP_MulUint8,
17133
OP_MulSint16,
17134
OP_MulUint16,
17135
OP_MulSint32,
17136
OP_MulUint32,
17137
OP_MulSint64,
17138
OP_MulUint64,
17139
OP_MulIntAP,
17140
OP_MulIntAPS,
17141
OP_MulBool,
17142
#endif
17143
0
#ifdef GET_INTERP
17144
0
case OP_MulSint8: {
17145
0
  if (!Mul<PT_Sint8>(S, OpPC))
17146
0
    return false;
17147
0
  continue;
17148
0
}
17149
0
case OP_MulUint8: {
17150
0
  if (!Mul<PT_Uint8>(S, OpPC))
17151
0
    return false;
17152
0
  continue;
17153
0
}
17154
0
case OP_MulSint16: {
17155
0
  if (!Mul<PT_Sint16>(S, OpPC))
17156
0
    return false;
17157
0
  continue;
17158
0
}
17159
0
case OP_MulUint16: {
17160
0
  if (!Mul<PT_Uint16>(S, OpPC))
17161
0
    return false;
17162
0
  continue;
17163
0
}
17164
0
case OP_MulSint32: {
17165
0
  if (!Mul<PT_Sint32>(S, OpPC))
17166
0
    return false;
17167
0
  continue;
17168
0
}
17169
0
case OP_MulUint32: {
17170
0
  if (!Mul<PT_Uint32>(S, OpPC))
17171
0
    return false;
17172
0
  continue;
17173
0
}
17174
0
case OP_MulSint64: {
17175
0
  if (!Mul<PT_Sint64>(S, OpPC))
17176
0
    return false;
17177
0
  continue;
17178
0
}
17179
0
case OP_MulUint64: {
17180
0
  if (!Mul<PT_Uint64>(S, OpPC))
17181
0
    return false;
17182
0
  continue;
17183
0
}
17184
0
case OP_MulIntAP: {
17185
0
  if (!Mul<PT_IntAP>(S, OpPC))
17186
0
    return false;
17187
0
  continue;
17188
0
}
17189
0
case OP_MulIntAPS: {
17190
0
  if (!Mul<PT_IntAPS>(S, OpPC))
17191
0
    return false;
17192
0
  continue;
17193
0
}
17194
0
case OP_MulBool: {
17195
0
  if (!Mul<PT_Bool>(S, OpPC))
17196
0
    return false;
17197
0
  continue;
17198
0
}
17199
0
#endif
17200
#ifdef GET_DISASM
17201
case OP_MulSint8:
17202
  PrintName("MulSint8");
17203
  OS << "\t" << "\n";
17204
  continue;
17205
case OP_MulUint8:
17206
  PrintName("MulUint8");
17207
  OS << "\t" << "\n";
17208
  continue;
17209
case OP_MulSint16:
17210
  PrintName("MulSint16");
17211
  OS << "\t" << "\n";
17212
  continue;
17213
case OP_MulUint16:
17214
  PrintName("MulUint16");
17215
  OS << "\t" << "\n";
17216
  continue;
17217
case OP_MulSint32:
17218
  PrintName("MulSint32");
17219
  OS << "\t" << "\n";
17220
  continue;
17221
case OP_MulUint32:
17222
  PrintName("MulUint32");
17223
  OS << "\t" << "\n";
17224
  continue;
17225
case OP_MulSint64:
17226
  PrintName("MulSint64");
17227
  OS << "\t" << "\n";
17228
  continue;
17229
case OP_MulUint64:
17230
  PrintName("MulUint64");
17231
  OS << "\t" << "\n";
17232
  continue;
17233
case OP_MulIntAP:
17234
  PrintName("MulIntAP");
17235
  OS << "\t" << "\n";
17236
  continue;
17237
case OP_MulIntAPS:
17238
  PrintName("MulIntAPS");
17239
  OS << "\t" << "\n";
17240
  continue;
17241
case OP_MulBool:
17242
  PrintName("MulBool");
17243
  OS << "\t" << "\n";
17244
  continue;
17245
#endif
17246
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17247
bool emitMulSint8(const SourceInfo &);
17248
bool emitMulUint8(const SourceInfo &);
17249
bool emitMulSint16(const SourceInfo &);
17250
bool emitMulUint16(const SourceInfo &);
17251
bool emitMulSint32(const SourceInfo &);
17252
bool emitMulUint32(const SourceInfo &);
17253
bool emitMulSint64(const SourceInfo &);
17254
bool emitMulUint64(const SourceInfo &);
17255
bool emitMulIntAP(const SourceInfo &);
17256
bool emitMulIntAPS(const SourceInfo &);
17257
bool emitMulBool(const SourceInfo &);
17258
#endif
17259
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17260
bool emitMul(PrimType, const SourceInfo &I);
17261
#endif
17262
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
17263
bool
17264
#if defined(GET_EVAL_IMPL)
17265
EvalEmitter
17266
#else
17267
ByteCodeEmitter
17268
#endif
17269
0
::emitMul(PrimType T0, const SourceInfo &I) {
17270
0
  switch (T0) {
17271
0
  case PT_Sint8:
17272
0
    return emitMulSint8(I);
17273
0
  case PT_Uint8:
17274
0
    return emitMulUint8(I);
17275
0
  case PT_Sint16:
17276
0
    return emitMulSint16(I);
17277
0
  case PT_Uint16:
17278
0
    return emitMulUint16(I);
17279
0
  case PT_Sint32:
17280
0
    return emitMulSint32(I);
17281
0
  case PT_Uint32:
17282
0
    return emitMulUint32(I);
17283
0
  case PT_Sint64:
17284
0
    return emitMulSint64(I);
17285
0
  case PT_Uint64:
17286
0
    return emitMulUint64(I);
17287
0
  case PT_IntAP:
17288
0
    return emitMulIntAP(I);
17289
0
  case PT_IntAPS:
17290
0
    return emitMulIntAPS(I);
17291
0
  case PT_Bool:
17292
0
    return emitMulBool(I);
17293
0
  default: llvm_unreachable("invalid type: emitMul");
17294
0
  }
17295
0
  llvm_unreachable("invalid enum value");
17296
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitMul(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitMul(clang::interp::PrimType, clang::interp::SourceInfo const&)
17297
#endif
17298
#ifdef GET_LINK_IMPL
17299
0
bool ByteCodeEmitter::emitMulSint8(const SourceInfo &L) {
17300
0
  return emitOp<>(OP_MulSint8, L);
17301
0
}
17302
0
bool ByteCodeEmitter::emitMulUint8(const SourceInfo &L) {
17303
0
  return emitOp<>(OP_MulUint8, L);
17304
0
}
17305
0
bool ByteCodeEmitter::emitMulSint16(const SourceInfo &L) {
17306
0
  return emitOp<>(OP_MulSint16, L);
17307
0
}
17308
0
bool ByteCodeEmitter::emitMulUint16(const SourceInfo &L) {
17309
0
  return emitOp<>(OP_MulUint16, L);
17310
0
}
17311
0
bool ByteCodeEmitter::emitMulSint32(const SourceInfo &L) {
17312
0
  return emitOp<>(OP_MulSint32, L);
17313
0
}
17314
0
bool ByteCodeEmitter::emitMulUint32(const SourceInfo &L) {
17315
0
  return emitOp<>(OP_MulUint32, L);
17316
0
}
17317
0
bool ByteCodeEmitter::emitMulSint64(const SourceInfo &L) {
17318
0
  return emitOp<>(OP_MulSint64, L);
17319
0
}
17320
0
bool ByteCodeEmitter::emitMulUint64(const SourceInfo &L) {
17321
0
  return emitOp<>(OP_MulUint64, L);
17322
0
}
17323
0
bool ByteCodeEmitter::emitMulIntAP(const SourceInfo &L) {
17324
0
  return emitOp<>(OP_MulIntAP, L);
17325
0
}
17326
0
bool ByteCodeEmitter::emitMulIntAPS(const SourceInfo &L) {
17327
0
  return emitOp<>(OP_MulIntAPS, L);
17328
0
}
17329
0
bool ByteCodeEmitter::emitMulBool(const SourceInfo &L) {
17330
0
  return emitOp<>(OP_MulBool, L);
17331
0
}
17332
#endif
17333
#ifdef GET_EVAL_IMPL
17334
0
bool EvalEmitter::emitMulSint8(const SourceInfo &L) {
17335
0
  if (!isActive()) return true;
17336
0
  CurrentSource = L;
17337
0
  return Mul<PT_Sint8>(S, OpPC);
17338
0
}
17339
0
bool EvalEmitter::emitMulUint8(const SourceInfo &L) {
17340
0
  if (!isActive()) return true;
17341
0
  CurrentSource = L;
17342
0
  return Mul<PT_Uint8>(S, OpPC);
17343
0
}
17344
0
bool EvalEmitter::emitMulSint16(const SourceInfo &L) {
17345
0
  if (!isActive()) return true;
17346
0
  CurrentSource = L;
17347
0
  return Mul<PT_Sint16>(S, OpPC);
17348
0
}
17349
0
bool EvalEmitter::emitMulUint16(const SourceInfo &L) {
17350
0
  if (!isActive()) return true;
17351
0
  CurrentSource = L;
17352
0
  return Mul<PT_Uint16>(S, OpPC);
17353
0
}
17354
0
bool EvalEmitter::emitMulSint32(const SourceInfo &L) {
17355
0
  if (!isActive()) return true;
17356
0
  CurrentSource = L;
17357
0
  return Mul<PT_Sint32>(S, OpPC);
17358
0
}
17359
0
bool EvalEmitter::emitMulUint32(const SourceInfo &L) {
17360
0
  if (!isActive()) return true;
17361
0
  CurrentSource = L;
17362
0
  return Mul<PT_Uint32>(S, OpPC);
17363
0
}
17364
0
bool EvalEmitter::emitMulSint64(const SourceInfo &L) {
17365
0
  if (!isActive()) return true;
17366
0
  CurrentSource = L;
17367
0
  return Mul<PT_Sint64>(S, OpPC);
17368
0
}
17369
0
bool EvalEmitter::emitMulUint64(const SourceInfo &L) {
17370
0
  if (!isActive()) return true;
17371
0
  CurrentSource = L;
17372
0
  return Mul<PT_Uint64>(S, OpPC);
17373
0
}
17374
0
bool EvalEmitter::emitMulIntAP(const SourceInfo &L) {
17375
0
  if (!isActive()) return true;
17376
0
  CurrentSource = L;
17377
0
  return Mul<PT_IntAP>(S, OpPC);
17378
0
}
17379
0
bool EvalEmitter::emitMulIntAPS(const SourceInfo &L) {
17380
0
  if (!isActive()) return true;
17381
0
  CurrentSource = L;
17382
0
  return Mul<PT_IntAPS>(S, OpPC);
17383
0
}
17384
0
bool EvalEmitter::emitMulBool(const SourceInfo &L) {
17385
0
  if (!isActive()) return true;
17386
0
  CurrentSource = L;
17387
0
  return Mul<PT_Bool>(S, OpPC);
17388
0
}
17389
#endif
17390
#ifdef GET_OPCODE_NAMES
17391
OP_Mulf,
17392
#endif
17393
0
#ifdef GET_INTERP
17394
0
case OP_Mulf: {
17395
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
17396
0
  if (!Mulf(S, OpPC, V0))
17397
0
    return false;
17398
0
  continue;
17399
0
}
17400
0
#endif
17401
#ifdef GET_DISASM
17402
case OP_Mulf:
17403
  PrintName("Mulf");
17404
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
17405
  continue;
17406
#endif
17407
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17408
bool emitMulf(llvm::RoundingMode, const SourceInfo &);
17409
#endif
17410
#ifdef GET_LINK_IMPL
17411
0
bool ByteCodeEmitter::emitMulf(llvm::RoundingMode A0, const SourceInfo &L) {
17412
0
  return emitOp<llvm::RoundingMode>(OP_Mulf, A0, L);
17413
0
}
17414
#endif
17415
#ifdef GET_EVAL_IMPL
17416
0
bool EvalEmitter::emitMulf(llvm::RoundingMode A0, const SourceInfo &L) {
17417
0
  if (!isActive()) return true;
17418
0
  CurrentSource = L;
17419
0
  return Mulf(S, OpPC, A0);
17420
0
}
17421
#endif
17422
#ifdef GET_OPCODE_NAMES
17423
OP_NESint8,
17424
OP_NEUint8,
17425
OP_NESint16,
17426
OP_NEUint16,
17427
OP_NESint32,
17428
OP_NEUint32,
17429
OP_NESint64,
17430
OP_NEUint64,
17431
OP_NEIntAP,
17432
OP_NEIntAPS,
17433
OP_NEBool,
17434
OP_NEPtr,
17435
OP_NEFnPtr,
17436
OP_NEFloat,
17437
#endif
17438
0
#ifdef GET_INTERP
17439
0
case OP_NESint8: {
17440
0
  if (!NE<PT_Sint8>(S, OpPC))
17441
0
    return false;
17442
0
  continue;
17443
0
}
17444
0
case OP_NEUint8: {
17445
0
  if (!NE<PT_Uint8>(S, OpPC))
17446
0
    return false;
17447
0
  continue;
17448
0
}
17449
0
case OP_NESint16: {
17450
0
  if (!NE<PT_Sint16>(S, OpPC))
17451
0
    return false;
17452
0
  continue;
17453
0
}
17454
0
case OP_NEUint16: {
17455
0
  if (!NE<PT_Uint16>(S, OpPC))
17456
0
    return false;
17457
0
  continue;
17458
0
}
17459
0
case OP_NESint32: {
17460
0
  if (!NE<PT_Sint32>(S, OpPC))
17461
0
    return false;
17462
0
  continue;
17463
0
}
17464
0
case OP_NEUint32: {
17465
0
  if (!NE<PT_Uint32>(S, OpPC))
17466
0
    return false;
17467
0
  continue;
17468
0
}
17469
0
case OP_NESint64: {
17470
0
  if (!NE<PT_Sint64>(S, OpPC))
17471
0
    return false;
17472
0
  continue;
17473
0
}
17474
0
case OP_NEUint64: {
17475
0
  if (!NE<PT_Uint64>(S, OpPC))
17476
0
    return false;
17477
0
  continue;
17478
0
}
17479
0
case OP_NEIntAP: {
17480
0
  if (!NE<PT_IntAP>(S, OpPC))
17481
0
    return false;
17482
0
  continue;
17483
0
}
17484
0
case OP_NEIntAPS: {
17485
0
  if (!NE<PT_IntAPS>(S, OpPC))
17486
0
    return false;
17487
0
  continue;
17488
0
}
17489
0
case OP_NEBool: {
17490
0
  if (!NE<PT_Bool>(S, OpPC))
17491
0
    return false;
17492
0
  continue;
17493
0
}
17494
0
case OP_NEPtr: {
17495
0
  if (!NE<PT_Ptr>(S, OpPC))
17496
0
    return false;
17497
0
  continue;
17498
0
}
17499
0
case OP_NEFnPtr: {
17500
0
  if (!NE<PT_FnPtr>(S, OpPC))
17501
0
    return false;
17502
0
  continue;
17503
0
}
17504
0
case OP_NEFloat: {
17505
0
  if (!NE<PT_Float>(S, OpPC))
17506
0
    return false;
17507
0
  continue;
17508
0
}
17509
0
#endif
17510
#ifdef GET_DISASM
17511
case OP_NESint8:
17512
  PrintName("NESint8");
17513
  OS << "\t" << "\n";
17514
  continue;
17515
case OP_NEUint8:
17516
  PrintName("NEUint8");
17517
  OS << "\t" << "\n";
17518
  continue;
17519
case OP_NESint16:
17520
  PrintName("NESint16");
17521
  OS << "\t" << "\n";
17522
  continue;
17523
case OP_NEUint16:
17524
  PrintName("NEUint16");
17525
  OS << "\t" << "\n";
17526
  continue;
17527
case OP_NESint32:
17528
  PrintName("NESint32");
17529
  OS << "\t" << "\n";
17530
  continue;
17531
case OP_NEUint32:
17532
  PrintName("NEUint32");
17533
  OS << "\t" << "\n";
17534
  continue;
17535
case OP_NESint64:
17536
  PrintName("NESint64");
17537
  OS << "\t" << "\n";
17538
  continue;
17539
case OP_NEUint64:
17540
  PrintName("NEUint64");
17541
  OS << "\t" << "\n";
17542
  continue;
17543
case OP_NEIntAP:
17544
  PrintName("NEIntAP");
17545
  OS << "\t" << "\n";
17546
  continue;
17547
case OP_NEIntAPS:
17548
  PrintName("NEIntAPS");
17549
  OS << "\t" << "\n";
17550
  continue;
17551
case OP_NEBool:
17552
  PrintName("NEBool");
17553
  OS << "\t" << "\n";
17554
  continue;
17555
case OP_NEPtr:
17556
  PrintName("NEPtr");
17557
  OS << "\t" << "\n";
17558
  continue;
17559
case OP_NEFnPtr:
17560
  PrintName("NEFnPtr");
17561
  OS << "\t" << "\n";
17562
  continue;
17563
case OP_NEFloat:
17564
  PrintName("NEFloat");
17565
  OS << "\t" << "\n";
17566
  continue;
17567
#endif
17568
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17569
bool emitNESint8(const SourceInfo &);
17570
bool emitNEUint8(const SourceInfo &);
17571
bool emitNESint16(const SourceInfo &);
17572
bool emitNEUint16(const SourceInfo &);
17573
bool emitNESint32(const SourceInfo &);
17574
bool emitNEUint32(const SourceInfo &);
17575
bool emitNESint64(const SourceInfo &);
17576
bool emitNEUint64(const SourceInfo &);
17577
bool emitNEIntAP(const SourceInfo &);
17578
bool emitNEIntAPS(const SourceInfo &);
17579
bool emitNEBool(const SourceInfo &);
17580
bool emitNEPtr(const SourceInfo &);
17581
bool emitNEFnPtr(const SourceInfo &);
17582
bool emitNEFloat(const SourceInfo &);
17583
#endif
17584
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17585
bool emitNE(PrimType, const SourceInfo &I);
17586
#endif
17587
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
17588
bool
17589
#if defined(GET_EVAL_IMPL)
17590
EvalEmitter
17591
#else
17592
ByteCodeEmitter
17593
#endif
17594
0
::emitNE(PrimType T0, const SourceInfo &I) {
17595
0
  switch (T0) {
17596
0
  case PT_Sint8:
17597
0
    return emitNESint8(I);
17598
0
  case PT_Uint8:
17599
0
    return emitNEUint8(I);
17600
0
  case PT_Sint16:
17601
0
    return emitNESint16(I);
17602
0
  case PT_Uint16:
17603
0
    return emitNEUint16(I);
17604
0
  case PT_Sint32:
17605
0
    return emitNESint32(I);
17606
0
  case PT_Uint32:
17607
0
    return emitNEUint32(I);
17608
0
  case PT_Sint64:
17609
0
    return emitNESint64(I);
17610
0
  case PT_Uint64:
17611
0
    return emitNEUint64(I);
17612
0
  case PT_IntAP:
17613
0
    return emitNEIntAP(I);
17614
0
  case PT_IntAPS:
17615
0
    return emitNEIntAPS(I);
17616
0
  case PT_Bool:
17617
0
    return emitNEBool(I);
17618
0
  case PT_Ptr:
17619
0
    return emitNEPtr(I);
17620
0
  case PT_FnPtr:
17621
0
    return emitNEFnPtr(I);
17622
0
  case PT_Float:
17623
0
    return emitNEFloat(I);
17624
0
  }
17625
0
  llvm_unreachable("invalid enum value");
17626
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitNE(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitNE(clang::interp::PrimType, clang::interp::SourceInfo const&)
17627
#endif
17628
#ifdef GET_LINK_IMPL
17629
0
bool ByteCodeEmitter::emitNESint8(const SourceInfo &L) {
17630
0
  return emitOp<>(OP_NESint8, L);
17631
0
}
17632
0
bool ByteCodeEmitter::emitNEUint8(const SourceInfo &L) {
17633
0
  return emitOp<>(OP_NEUint8, L);
17634
0
}
17635
0
bool ByteCodeEmitter::emitNESint16(const SourceInfo &L) {
17636
0
  return emitOp<>(OP_NESint16, L);
17637
0
}
17638
0
bool ByteCodeEmitter::emitNEUint16(const SourceInfo &L) {
17639
0
  return emitOp<>(OP_NEUint16, L);
17640
0
}
17641
0
bool ByteCodeEmitter::emitNESint32(const SourceInfo &L) {
17642
0
  return emitOp<>(OP_NESint32, L);
17643
0
}
17644
0
bool ByteCodeEmitter::emitNEUint32(const SourceInfo &L) {
17645
0
  return emitOp<>(OP_NEUint32, L);
17646
0
}
17647
0
bool ByteCodeEmitter::emitNESint64(const SourceInfo &L) {
17648
0
  return emitOp<>(OP_NESint64, L);
17649
0
}
17650
0
bool ByteCodeEmitter::emitNEUint64(const SourceInfo &L) {
17651
0
  return emitOp<>(OP_NEUint64, L);
17652
0
}
17653
0
bool ByteCodeEmitter::emitNEIntAP(const SourceInfo &L) {
17654
0
  return emitOp<>(OP_NEIntAP, L);
17655
0
}
17656
0
bool ByteCodeEmitter::emitNEIntAPS(const SourceInfo &L) {
17657
0
  return emitOp<>(OP_NEIntAPS, L);
17658
0
}
17659
0
bool ByteCodeEmitter::emitNEBool(const SourceInfo &L) {
17660
0
  return emitOp<>(OP_NEBool, L);
17661
0
}
17662
0
bool ByteCodeEmitter::emitNEPtr(const SourceInfo &L) {
17663
0
  return emitOp<>(OP_NEPtr, L);
17664
0
}
17665
0
bool ByteCodeEmitter::emitNEFnPtr(const SourceInfo &L) {
17666
0
  return emitOp<>(OP_NEFnPtr, L);
17667
0
}
17668
0
bool ByteCodeEmitter::emitNEFloat(const SourceInfo &L) {
17669
0
  return emitOp<>(OP_NEFloat, L);
17670
0
}
17671
#endif
17672
#ifdef GET_EVAL_IMPL
17673
0
bool EvalEmitter::emitNESint8(const SourceInfo &L) {
17674
0
  if (!isActive()) return true;
17675
0
  CurrentSource = L;
17676
0
  return NE<PT_Sint8>(S, OpPC);
17677
0
}
17678
0
bool EvalEmitter::emitNEUint8(const SourceInfo &L) {
17679
0
  if (!isActive()) return true;
17680
0
  CurrentSource = L;
17681
0
  return NE<PT_Uint8>(S, OpPC);
17682
0
}
17683
0
bool EvalEmitter::emitNESint16(const SourceInfo &L) {
17684
0
  if (!isActive()) return true;
17685
0
  CurrentSource = L;
17686
0
  return NE<PT_Sint16>(S, OpPC);
17687
0
}
17688
0
bool EvalEmitter::emitNEUint16(const SourceInfo &L) {
17689
0
  if (!isActive()) return true;
17690
0
  CurrentSource = L;
17691
0
  return NE<PT_Uint16>(S, OpPC);
17692
0
}
17693
0
bool EvalEmitter::emitNESint32(const SourceInfo &L) {
17694
0
  if (!isActive()) return true;
17695
0
  CurrentSource = L;
17696
0
  return NE<PT_Sint32>(S, OpPC);
17697
0
}
17698
0
bool EvalEmitter::emitNEUint32(const SourceInfo &L) {
17699
0
  if (!isActive()) return true;
17700
0
  CurrentSource = L;
17701
0
  return NE<PT_Uint32>(S, OpPC);
17702
0
}
17703
0
bool EvalEmitter::emitNESint64(const SourceInfo &L) {
17704
0
  if (!isActive()) return true;
17705
0
  CurrentSource = L;
17706
0
  return NE<PT_Sint64>(S, OpPC);
17707
0
}
17708
0
bool EvalEmitter::emitNEUint64(const SourceInfo &L) {
17709
0
  if (!isActive()) return true;
17710
0
  CurrentSource = L;
17711
0
  return NE<PT_Uint64>(S, OpPC);
17712
0
}
17713
0
bool EvalEmitter::emitNEIntAP(const SourceInfo &L) {
17714
0
  if (!isActive()) return true;
17715
0
  CurrentSource = L;
17716
0
  return NE<PT_IntAP>(S, OpPC);
17717
0
}
17718
0
bool EvalEmitter::emitNEIntAPS(const SourceInfo &L) {
17719
0
  if (!isActive()) return true;
17720
0
  CurrentSource = L;
17721
0
  return NE<PT_IntAPS>(S, OpPC);
17722
0
}
17723
0
bool EvalEmitter::emitNEBool(const SourceInfo &L) {
17724
0
  if (!isActive()) return true;
17725
0
  CurrentSource = L;
17726
0
  return NE<PT_Bool>(S, OpPC);
17727
0
}
17728
0
bool EvalEmitter::emitNEPtr(const SourceInfo &L) {
17729
0
  if (!isActive()) return true;
17730
0
  CurrentSource = L;
17731
0
  return NE<PT_Ptr>(S, OpPC);
17732
0
}
17733
0
bool EvalEmitter::emitNEFnPtr(const SourceInfo &L) {
17734
0
  if (!isActive()) return true;
17735
0
  CurrentSource = L;
17736
0
  return NE<PT_FnPtr>(S, OpPC);
17737
0
}
17738
0
bool EvalEmitter::emitNEFloat(const SourceInfo &L) {
17739
0
  if (!isActive()) return true;
17740
0
  CurrentSource = L;
17741
0
  return NE<PT_Float>(S, OpPC);
17742
0
}
17743
#endif
17744
#ifdef GET_OPCODE_NAMES
17745
OP_NarrowPtr,
17746
#endif
17747
0
#ifdef GET_INTERP
17748
0
case OP_NarrowPtr: {
17749
0
  if (!NarrowPtr(S, OpPC))
17750
0
    return false;
17751
0
  continue;
17752
0
}
17753
0
#endif
17754
#ifdef GET_DISASM
17755
case OP_NarrowPtr:
17756
  PrintName("NarrowPtr");
17757
  OS << "\t" << "\n";
17758
  continue;
17759
#endif
17760
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17761
bool emitNarrowPtr(const SourceInfo &);
17762
#endif
17763
#ifdef GET_LINK_IMPL
17764
0
bool ByteCodeEmitter::emitNarrowPtr(const SourceInfo &L) {
17765
0
  return emitOp<>(OP_NarrowPtr, L);
17766
0
}
17767
#endif
17768
#ifdef GET_EVAL_IMPL
17769
0
bool EvalEmitter::emitNarrowPtr(const SourceInfo &L) {
17770
0
  if (!isActive()) return true;
17771
0
  CurrentSource = L;
17772
0
  return NarrowPtr(S, OpPC);
17773
0
}
17774
#endif
17775
#ifdef GET_OPCODE_NAMES
17776
OP_NegSint8,
17777
OP_NegUint8,
17778
OP_NegSint16,
17779
OP_NegUint16,
17780
OP_NegSint32,
17781
OP_NegUint32,
17782
OP_NegSint64,
17783
OP_NegUint64,
17784
OP_NegIntAP,
17785
OP_NegIntAPS,
17786
OP_NegBool,
17787
OP_NegFloat,
17788
#endif
17789
0
#ifdef GET_INTERP
17790
0
case OP_NegSint8: {
17791
0
  if (!Neg<PT_Sint8>(S, OpPC))
17792
0
    return false;
17793
0
  continue;
17794
0
}
17795
0
case OP_NegUint8: {
17796
0
  if (!Neg<PT_Uint8>(S, OpPC))
17797
0
    return false;
17798
0
  continue;
17799
0
}
17800
0
case OP_NegSint16: {
17801
0
  if (!Neg<PT_Sint16>(S, OpPC))
17802
0
    return false;
17803
0
  continue;
17804
0
}
17805
0
case OP_NegUint16: {
17806
0
  if (!Neg<PT_Uint16>(S, OpPC))
17807
0
    return false;
17808
0
  continue;
17809
0
}
17810
0
case OP_NegSint32: {
17811
0
  if (!Neg<PT_Sint32>(S, OpPC))
17812
0
    return false;
17813
0
  continue;
17814
0
}
17815
0
case OP_NegUint32: {
17816
0
  if (!Neg<PT_Uint32>(S, OpPC))
17817
0
    return false;
17818
0
  continue;
17819
0
}
17820
0
case OP_NegSint64: {
17821
0
  if (!Neg<PT_Sint64>(S, OpPC))
17822
0
    return false;
17823
0
  continue;
17824
0
}
17825
0
case OP_NegUint64: {
17826
0
  if (!Neg<PT_Uint64>(S, OpPC))
17827
0
    return false;
17828
0
  continue;
17829
0
}
17830
0
case OP_NegIntAP: {
17831
0
  if (!Neg<PT_IntAP>(S, OpPC))
17832
0
    return false;
17833
0
  continue;
17834
0
}
17835
0
case OP_NegIntAPS: {
17836
0
  if (!Neg<PT_IntAPS>(S, OpPC))
17837
0
    return false;
17838
0
  continue;
17839
0
}
17840
0
case OP_NegBool: {
17841
0
  if (!Neg<PT_Bool>(S, OpPC))
17842
0
    return false;
17843
0
  continue;
17844
0
}
17845
0
case OP_NegFloat: {
17846
0
  if (!Neg<PT_Float>(S, OpPC))
17847
0
    return false;
17848
0
  continue;
17849
0
}
17850
0
#endif
17851
#ifdef GET_DISASM
17852
case OP_NegSint8:
17853
  PrintName("NegSint8");
17854
  OS << "\t" << "\n";
17855
  continue;
17856
case OP_NegUint8:
17857
  PrintName("NegUint8");
17858
  OS << "\t" << "\n";
17859
  continue;
17860
case OP_NegSint16:
17861
  PrintName("NegSint16");
17862
  OS << "\t" << "\n";
17863
  continue;
17864
case OP_NegUint16:
17865
  PrintName("NegUint16");
17866
  OS << "\t" << "\n";
17867
  continue;
17868
case OP_NegSint32:
17869
  PrintName("NegSint32");
17870
  OS << "\t" << "\n";
17871
  continue;
17872
case OP_NegUint32:
17873
  PrintName("NegUint32");
17874
  OS << "\t" << "\n";
17875
  continue;
17876
case OP_NegSint64:
17877
  PrintName("NegSint64");
17878
  OS << "\t" << "\n";
17879
  continue;
17880
case OP_NegUint64:
17881
  PrintName("NegUint64");
17882
  OS << "\t" << "\n";
17883
  continue;
17884
case OP_NegIntAP:
17885
  PrintName("NegIntAP");
17886
  OS << "\t" << "\n";
17887
  continue;
17888
case OP_NegIntAPS:
17889
  PrintName("NegIntAPS");
17890
  OS << "\t" << "\n";
17891
  continue;
17892
case OP_NegBool:
17893
  PrintName("NegBool");
17894
  OS << "\t" << "\n";
17895
  continue;
17896
case OP_NegFloat:
17897
  PrintName("NegFloat");
17898
  OS << "\t" << "\n";
17899
  continue;
17900
#endif
17901
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17902
bool emitNegSint8(const SourceInfo &);
17903
bool emitNegUint8(const SourceInfo &);
17904
bool emitNegSint16(const SourceInfo &);
17905
bool emitNegUint16(const SourceInfo &);
17906
bool emitNegSint32(const SourceInfo &);
17907
bool emitNegUint32(const SourceInfo &);
17908
bool emitNegSint64(const SourceInfo &);
17909
bool emitNegUint64(const SourceInfo &);
17910
bool emitNegIntAP(const SourceInfo &);
17911
bool emitNegIntAPS(const SourceInfo &);
17912
bool emitNegBool(const SourceInfo &);
17913
bool emitNegFloat(const SourceInfo &);
17914
#endif
17915
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17916
bool emitNeg(PrimType, const SourceInfo &I);
17917
#endif
17918
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
17919
bool
17920
#if defined(GET_EVAL_IMPL)
17921
EvalEmitter
17922
#else
17923
ByteCodeEmitter
17924
#endif
17925
0
::emitNeg(PrimType T0, const SourceInfo &I) {
17926
0
  switch (T0) {
17927
0
  case PT_Sint8:
17928
0
    return emitNegSint8(I);
17929
0
  case PT_Uint8:
17930
0
    return emitNegUint8(I);
17931
0
  case PT_Sint16:
17932
0
    return emitNegSint16(I);
17933
0
  case PT_Uint16:
17934
0
    return emitNegUint16(I);
17935
0
  case PT_Sint32:
17936
0
    return emitNegSint32(I);
17937
0
  case PT_Uint32:
17938
0
    return emitNegUint32(I);
17939
0
  case PT_Sint64:
17940
0
    return emitNegSint64(I);
17941
0
  case PT_Uint64:
17942
0
    return emitNegUint64(I);
17943
0
  case PT_IntAP:
17944
0
    return emitNegIntAP(I);
17945
0
  case PT_IntAPS:
17946
0
    return emitNegIntAPS(I);
17947
0
  case PT_Bool:
17948
0
    return emitNegBool(I);
17949
0
  case PT_Float:
17950
0
    return emitNegFloat(I);
17951
0
  default: llvm_unreachable("invalid type: emitNeg");
17952
0
  }
17953
0
  llvm_unreachable("invalid enum value");
17954
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitNeg(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitNeg(clang::interp::PrimType, clang::interp::SourceInfo const&)
17955
#endif
17956
#ifdef GET_LINK_IMPL
17957
0
bool ByteCodeEmitter::emitNegSint8(const SourceInfo &L) {
17958
0
  return emitOp<>(OP_NegSint8, L);
17959
0
}
17960
0
bool ByteCodeEmitter::emitNegUint8(const SourceInfo &L) {
17961
0
  return emitOp<>(OP_NegUint8, L);
17962
0
}
17963
0
bool ByteCodeEmitter::emitNegSint16(const SourceInfo &L) {
17964
0
  return emitOp<>(OP_NegSint16, L);
17965
0
}
17966
0
bool ByteCodeEmitter::emitNegUint16(const SourceInfo &L) {
17967
0
  return emitOp<>(OP_NegUint16, L);
17968
0
}
17969
0
bool ByteCodeEmitter::emitNegSint32(const SourceInfo &L) {
17970
0
  return emitOp<>(OP_NegSint32, L);
17971
0
}
17972
0
bool ByteCodeEmitter::emitNegUint32(const SourceInfo &L) {
17973
0
  return emitOp<>(OP_NegUint32, L);
17974
0
}
17975
0
bool ByteCodeEmitter::emitNegSint64(const SourceInfo &L) {
17976
0
  return emitOp<>(OP_NegSint64, L);
17977
0
}
17978
0
bool ByteCodeEmitter::emitNegUint64(const SourceInfo &L) {
17979
0
  return emitOp<>(OP_NegUint64, L);
17980
0
}
17981
0
bool ByteCodeEmitter::emitNegIntAP(const SourceInfo &L) {
17982
0
  return emitOp<>(OP_NegIntAP, L);
17983
0
}
17984
0
bool ByteCodeEmitter::emitNegIntAPS(const SourceInfo &L) {
17985
0
  return emitOp<>(OP_NegIntAPS, L);
17986
0
}
17987
0
bool ByteCodeEmitter::emitNegBool(const SourceInfo &L) {
17988
0
  return emitOp<>(OP_NegBool, L);
17989
0
}
17990
0
bool ByteCodeEmitter::emitNegFloat(const SourceInfo &L) {
17991
0
  return emitOp<>(OP_NegFloat, L);
17992
0
}
17993
#endif
17994
#ifdef GET_EVAL_IMPL
17995
0
bool EvalEmitter::emitNegSint8(const SourceInfo &L) {
17996
0
  if (!isActive()) return true;
17997
0
  CurrentSource = L;
17998
0
  return Neg<PT_Sint8>(S, OpPC);
17999
0
}
18000
0
bool EvalEmitter::emitNegUint8(const SourceInfo &L) {
18001
0
  if (!isActive()) return true;
18002
0
  CurrentSource = L;
18003
0
  return Neg<PT_Uint8>(S, OpPC);
18004
0
}
18005
0
bool EvalEmitter::emitNegSint16(const SourceInfo &L) {
18006
0
  if (!isActive()) return true;
18007
0
  CurrentSource = L;
18008
0
  return Neg<PT_Sint16>(S, OpPC);
18009
0
}
18010
0
bool EvalEmitter::emitNegUint16(const SourceInfo &L) {
18011
0
  if (!isActive()) return true;
18012
0
  CurrentSource = L;
18013
0
  return Neg<PT_Uint16>(S, OpPC);
18014
0
}
18015
0
bool EvalEmitter::emitNegSint32(const SourceInfo &L) {
18016
0
  if (!isActive()) return true;
18017
0
  CurrentSource = L;
18018
0
  return Neg<PT_Sint32>(S, OpPC);
18019
0
}
18020
0
bool EvalEmitter::emitNegUint32(const SourceInfo &L) {
18021
0
  if (!isActive()) return true;
18022
0
  CurrentSource = L;
18023
0
  return Neg<PT_Uint32>(S, OpPC);
18024
0
}
18025
0
bool EvalEmitter::emitNegSint64(const SourceInfo &L) {
18026
0
  if (!isActive()) return true;
18027
0
  CurrentSource = L;
18028
0
  return Neg<PT_Sint64>(S, OpPC);
18029
0
}
18030
0
bool EvalEmitter::emitNegUint64(const SourceInfo &L) {
18031
0
  if (!isActive()) return true;
18032
0
  CurrentSource = L;
18033
0
  return Neg<PT_Uint64>(S, OpPC);
18034
0
}
18035
0
bool EvalEmitter::emitNegIntAP(const SourceInfo &L) {
18036
0
  if (!isActive()) return true;
18037
0
  CurrentSource = L;
18038
0
  return Neg<PT_IntAP>(S, OpPC);
18039
0
}
18040
0
bool EvalEmitter::emitNegIntAPS(const SourceInfo &L) {
18041
0
  if (!isActive()) return true;
18042
0
  CurrentSource = L;
18043
0
  return Neg<PT_IntAPS>(S, OpPC);
18044
0
}
18045
0
bool EvalEmitter::emitNegBool(const SourceInfo &L) {
18046
0
  if (!isActive()) return true;
18047
0
  CurrentSource = L;
18048
0
  return Neg<PT_Bool>(S, OpPC);
18049
0
}
18050
0
bool EvalEmitter::emitNegFloat(const SourceInfo &L) {
18051
0
  if (!isActive()) return true;
18052
0
  CurrentSource = L;
18053
0
  return Neg<PT_Float>(S, OpPC);
18054
0
}
18055
#endif
18056
#ifdef GET_OPCODE_NAMES
18057
OP_NoRet,
18058
#endif
18059
0
#ifdef GET_INTERP
18060
0
case OP_NoRet: {
18061
0
  if (!NoRet(S, OpPC))
18062
0
    return false;
18063
0
  continue;
18064
0
}
18065
0
#endif
18066
#ifdef GET_DISASM
18067
case OP_NoRet:
18068
  PrintName("NoRet");
18069
  OS << "\t" << "\n";
18070
  continue;
18071
#endif
18072
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18073
bool emitNoRet(const SourceInfo &);
18074
#endif
18075
#ifdef GET_LINK_IMPL
18076
0
bool ByteCodeEmitter::emitNoRet(const SourceInfo &L) {
18077
0
  return emitOp<>(OP_NoRet, L);
18078
0
}
18079
#endif
18080
#ifdef GET_EVAL_IMPL
18081
0
bool EvalEmitter::emitNoRet(const SourceInfo &L) {
18082
0
  if (!isActive()) return true;
18083
0
  CurrentSource = L;
18084
0
  return NoRet(S, OpPC);
18085
0
}
18086
#endif
18087
#ifdef GET_OPCODE_NAMES
18088
OP_NullPtr,
18089
OP_NullFnPtr,
18090
#endif
18091
0
#ifdef GET_INTERP
18092
0
case OP_NullPtr: {
18093
0
  if (!Null<PT_Ptr>(S, OpPC))
18094
0
    return false;
18095
0
  continue;
18096
0
}
18097
0
case OP_NullFnPtr: {
18098
0
  if (!Null<PT_FnPtr>(S, OpPC))
18099
0
    return false;
18100
0
  continue;
18101
0
}
18102
0
#endif
18103
#ifdef GET_DISASM
18104
case OP_NullPtr:
18105
  PrintName("NullPtr");
18106
  OS << "\t" << "\n";
18107
  continue;
18108
case OP_NullFnPtr:
18109
  PrintName("NullFnPtr");
18110
  OS << "\t" << "\n";
18111
  continue;
18112
#endif
18113
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18114
bool emitNullPtr(const SourceInfo &);
18115
bool emitNullFnPtr(const SourceInfo &);
18116
#endif
18117
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18118
bool emitNull(PrimType, const SourceInfo &I);
18119
#endif
18120
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
18121
bool
18122
#if defined(GET_EVAL_IMPL)
18123
EvalEmitter
18124
#else
18125
ByteCodeEmitter
18126
#endif
18127
0
::emitNull(PrimType T0, const SourceInfo &I) {
18128
0
  switch (T0) {
18129
0
  case PT_Ptr:
18130
0
    return emitNullPtr(I);
18131
0
  case PT_FnPtr:
18132
0
    return emitNullFnPtr(I);
18133
0
  default: llvm_unreachable("invalid type: emitNull");
18134
0
  }
18135
0
  llvm_unreachable("invalid enum value");
18136
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitNull(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitNull(clang::interp::PrimType, clang::interp::SourceInfo const&)
18137
#endif
18138
#ifdef GET_LINK_IMPL
18139
0
bool ByteCodeEmitter::emitNullPtr(const SourceInfo &L) {
18140
0
  return emitOp<>(OP_NullPtr, L);
18141
0
}
18142
0
bool ByteCodeEmitter::emitNullFnPtr(const SourceInfo &L) {
18143
0
  return emitOp<>(OP_NullFnPtr, L);
18144
0
}
18145
#endif
18146
#ifdef GET_EVAL_IMPL
18147
0
bool EvalEmitter::emitNullPtr(const SourceInfo &L) {
18148
0
  if (!isActive()) return true;
18149
0
  CurrentSource = L;
18150
0
  return Null<PT_Ptr>(S, OpPC);
18151
0
}
18152
0
bool EvalEmitter::emitNullFnPtr(const SourceInfo &L) {
18153
0
  if (!isActive()) return true;
18154
0
  CurrentSource = L;
18155
0
  return Null<PT_FnPtr>(S, OpPC);
18156
0
}
18157
#endif
18158
#ifdef GET_OPCODE_NAMES
18159
OP_OffsetOfSint8,
18160
OP_OffsetOfUint8,
18161
OP_OffsetOfSint16,
18162
OP_OffsetOfUint16,
18163
OP_OffsetOfSint32,
18164
OP_OffsetOfUint32,
18165
OP_OffsetOfSint64,
18166
OP_OffsetOfUint64,
18167
OP_OffsetOfIntAP,
18168
OP_OffsetOfIntAPS,
18169
#endif
18170
0
#ifdef GET_INTERP
18171
0
case OP_OffsetOfSint8: {
18172
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18173
0
  if (!OffsetOf<PT_Sint8>(S, OpPC, V0))
18174
0
    return false;
18175
0
  continue;
18176
0
}
18177
0
case OP_OffsetOfUint8: {
18178
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18179
0
  if (!OffsetOf<PT_Uint8>(S, OpPC, V0))
18180
0
    return false;
18181
0
  continue;
18182
0
}
18183
0
case OP_OffsetOfSint16: {
18184
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18185
0
  if (!OffsetOf<PT_Sint16>(S, OpPC, V0))
18186
0
    return false;
18187
0
  continue;
18188
0
}
18189
0
case OP_OffsetOfUint16: {
18190
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18191
0
  if (!OffsetOf<PT_Uint16>(S, OpPC, V0))
18192
0
    return false;
18193
0
  continue;
18194
0
}
18195
0
case OP_OffsetOfSint32: {
18196
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18197
0
  if (!OffsetOf<PT_Sint32>(S, OpPC, V0))
18198
0
    return false;
18199
0
  continue;
18200
0
}
18201
0
case OP_OffsetOfUint32: {
18202
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18203
0
  if (!OffsetOf<PT_Uint32>(S, OpPC, V0))
18204
0
    return false;
18205
0
  continue;
18206
0
}
18207
0
case OP_OffsetOfSint64: {
18208
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18209
0
  if (!OffsetOf<PT_Sint64>(S, OpPC, V0))
18210
0
    return false;
18211
0
  continue;
18212
0
}
18213
0
case OP_OffsetOfUint64: {
18214
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18215
0
  if (!OffsetOf<PT_Uint64>(S, OpPC, V0))
18216
0
    return false;
18217
0
  continue;
18218
0
}
18219
0
case OP_OffsetOfIntAP: {
18220
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18221
0
  if (!OffsetOf<PT_IntAP>(S, OpPC, V0))
18222
0
    return false;
18223
0
  continue;
18224
0
}
18225
0
case OP_OffsetOfIntAPS: {
18226
0
  auto V0 = ReadArg<const OffsetOfExpr *>(S, PC);
18227
0
  if (!OffsetOf<PT_IntAPS>(S, OpPC, V0))
18228
0
    return false;
18229
0
  continue;
18230
0
}
18231
0
#endif
18232
#ifdef GET_DISASM
18233
case OP_OffsetOfSint8:
18234
  PrintName("OffsetOfSint8");
18235
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18236
  continue;
18237
case OP_OffsetOfUint8:
18238
  PrintName("OffsetOfUint8");
18239
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18240
  continue;
18241
case OP_OffsetOfSint16:
18242
  PrintName("OffsetOfSint16");
18243
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18244
  continue;
18245
case OP_OffsetOfUint16:
18246
  PrintName("OffsetOfUint16");
18247
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18248
  continue;
18249
case OP_OffsetOfSint32:
18250
  PrintName("OffsetOfSint32");
18251
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18252
  continue;
18253
case OP_OffsetOfUint32:
18254
  PrintName("OffsetOfUint32");
18255
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18256
  continue;
18257
case OP_OffsetOfSint64:
18258
  PrintName("OffsetOfSint64");
18259
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18260
  continue;
18261
case OP_OffsetOfUint64:
18262
  PrintName("OffsetOfUint64");
18263
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18264
  continue;
18265
case OP_OffsetOfIntAP:
18266
  PrintName("OffsetOfIntAP");
18267
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18268
  continue;
18269
case OP_OffsetOfIntAPS:
18270
  PrintName("OffsetOfIntAPS");
18271
  OS << "\t" << ReadArg<const OffsetOfExpr *>(P, PC) << " " << "\n";
18272
  continue;
18273
#endif
18274
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18275
bool emitOffsetOfSint8(const OffsetOfExpr *, const SourceInfo &);
18276
bool emitOffsetOfUint8(const OffsetOfExpr *, const SourceInfo &);
18277
bool emitOffsetOfSint16(const OffsetOfExpr *, const SourceInfo &);
18278
bool emitOffsetOfUint16(const OffsetOfExpr *, const SourceInfo &);
18279
bool emitOffsetOfSint32(const OffsetOfExpr *, const SourceInfo &);
18280
bool emitOffsetOfUint32(const OffsetOfExpr *, const SourceInfo &);
18281
bool emitOffsetOfSint64(const OffsetOfExpr *, const SourceInfo &);
18282
bool emitOffsetOfUint64(const OffsetOfExpr *, const SourceInfo &);
18283
bool emitOffsetOfIntAP(const OffsetOfExpr *, const SourceInfo &);
18284
bool emitOffsetOfIntAPS(const OffsetOfExpr *, const SourceInfo &);
18285
#endif
18286
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18287
bool emitOffsetOf(PrimType, const OffsetOfExpr *, const SourceInfo &I);
18288
#endif
18289
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
18290
bool
18291
#if defined(GET_EVAL_IMPL)
18292
EvalEmitter
18293
#else
18294
ByteCodeEmitter
18295
#endif
18296
0
::emitOffsetOf(PrimType T0, const OffsetOfExpr * A0, const SourceInfo &I) {
18297
0
  switch (T0) {
18298
0
  case PT_Sint8:
18299
0
    return emitOffsetOfSint8(A0, I);
18300
0
  case PT_Uint8:
18301
0
    return emitOffsetOfUint8(A0, I);
18302
0
  case PT_Sint16:
18303
0
    return emitOffsetOfSint16(A0, I);
18304
0
  case PT_Uint16:
18305
0
    return emitOffsetOfUint16(A0, I);
18306
0
  case PT_Sint32:
18307
0
    return emitOffsetOfSint32(A0, I);
18308
0
  case PT_Uint32:
18309
0
    return emitOffsetOfUint32(A0, I);
18310
0
  case PT_Sint64:
18311
0
    return emitOffsetOfSint64(A0, I);
18312
0
  case PT_Uint64:
18313
0
    return emitOffsetOfUint64(A0, I);
18314
0
  case PT_IntAP:
18315
0
    return emitOffsetOfIntAP(A0, I);
18316
0
  case PT_IntAPS:
18317
0
    return emitOffsetOfIntAPS(A0, I);
18318
0
  default: llvm_unreachable("invalid type: emitOffsetOf");
18319
0
  }
18320
0
  llvm_unreachable("invalid enum value");
18321
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitOffsetOf(clang::interp::PrimType, clang::OffsetOfExpr const*, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitOffsetOf(clang::interp::PrimType, clang::OffsetOfExpr const*, clang::interp::SourceInfo const&)
18322
#endif
18323
#ifdef GET_LINK_IMPL
18324
0
bool ByteCodeEmitter::emitOffsetOfSint8(const OffsetOfExpr * A0, const SourceInfo &L) {
18325
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint8, A0, L);
18326
0
}
18327
0
bool ByteCodeEmitter::emitOffsetOfUint8(const OffsetOfExpr * A0, const SourceInfo &L) {
18328
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint8, A0, L);
18329
0
}
18330
0
bool ByteCodeEmitter::emitOffsetOfSint16(const OffsetOfExpr * A0, const SourceInfo &L) {
18331
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint16, A0, L);
18332
0
}
18333
0
bool ByteCodeEmitter::emitOffsetOfUint16(const OffsetOfExpr * A0, const SourceInfo &L) {
18334
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint16, A0, L);
18335
0
}
18336
0
bool ByteCodeEmitter::emitOffsetOfSint32(const OffsetOfExpr * A0, const SourceInfo &L) {
18337
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint32, A0, L);
18338
0
}
18339
0
bool ByteCodeEmitter::emitOffsetOfUint32(const OffsetOfExpr * A0, const SourceInfo &L) {
18340
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint32, A0, L);
18341
0
}
18342
0
bool ByteCodeEmitter::emitOffsetOfSint64(const OffsetOfExpr * A0, const SourceInfo &L) {
18343
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint64, A0, L);
18344
0
}
18345
0
bool ByteCodeEmitter::emitOffsetOfUint64(const OffsetOfExpr * A0, const SourceInfo &L) {
18346
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint64, A0, L);
18347
0
}
18348
0
bool ByteCodeEmitter::emitOffsetOfIntAP(const OffsetOfExpr * A0, const SourceInfo &L) {
18349
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfIntAP, A0, L);
18350
0
}
18351
0
bool ByteCodeEmitter::emitOffsetOfIntAPS(const OffsetOfExpr * A0, const SourceInfo &L) {
18352
0
  return emitOp<const OffsetOfExpr *>(OP_OffsetOfIntAPS, A0, L);
18353
0
}
18354
#endif
18355
#ifdef GET_EVAL_IMPL
18356
0
bool EvalEmitter::emitOffsetOfSint8(const OffsetOfExpr * A0, const SourceInfo &L) {
18357
0
  if (!isActive()) return true;
18358
0
  CurrentSource = L;
18359
0
  return OffsetOf<PT_Sint8>(S, OpPC, A0);
18360
0
}
18361
0
bool EvalEmitter::emitOffsetOfUint8(const OffsetOfExpr * A0, const SourceInfo &L) {
18362
0
  if (!isActive()) return true;
18363
0
  CurrentSource = L;
18364
0
  return OffsetOf<PT_Uint8>(S, OpPC, A0);
18365
0
}
18366
0
bool EvalEmitter::emitOffsetOfSint16(const OffsetOfExpr * A0, const SourceInfo &L) {
18367
0
  if (!isActive()) return true;
18368
0
  CurrentSource = L;
18369
0
  return OffsetOf<PT_Sint16>(S, OpPC, A0);
18370
0
}
18371
0
bool EvalEmitter::emitOffsetOfUint16(const OffsetOfExpr * A0, const SourceInfo &L) {
18372
0
  if (!isActive()) return true;
18373
0
  CurrentSource = L;
18374
0
  return OffsetOf<PT_Uint16>(S, OpPC, A0);
18375
0
}
18376
0
bool EvalEmitter::emitOffsetOfSint32(const OffsetOfExpr * A0, const SourceInfo &L) {
18377
0
  if (!isActive()) return true;
18378
0
  CurrentSource = L;
18379
0
  return OffsetOf<PT_Sint32>(S, OpPC, A0);
18380
0
}
18381
0
bool EvalEmitter::emitOffsetOfUint32(const OffsetOfExpr * A0, const SourceInfo &L) {
18382
0
  if (!isActive()) return true;
18383
0
  CurrentSource = L;
18384
0
  return OffsetOf<PT_Uint32>(S, OpPC, A0);
18385
0
}
18386
0
bool EvalEmitter::emitOffsetOfSint64(const OffsetOfExpr * A0, const SourceInfo &L) {
18387
0
  if (!isActive()) return true;
18388
0
  CurrentSource = L;
18389
0
  return OffsetOf<PT_Sint64>(S, OpPC, A0);
18390
0
}
18391
0
bool EvalEmitter::emitOffsetOfUint64(const OffsetOfExpr * A0, const SourceInfo &L) {
18392
0
  if (!isActive()) return true;
18393
0
  CurrentSource = L;
18394
0
  return OffsetOf<PT_Uint64>(S, OpPC, A0);
18395
0
}
18396
0
bool EvalEmitter::emitOffsetOfIntAP(const OffsetOfExpr * A0, const SourceInfo &L) {
18397
0
  if (!isActive()) return true;
18398
0
  CurrentSource = L;
18399
0
  return OffsetOf<PT_IntAP>(S, OpPC, A0);
18400
0
}
18401
0
bool EvalEmitter::emitOffsetOfIntAPS(const OffsetOfExpr * A0, const SourceInfo &L) {
18402
0
  if (!isActive()) return true;
18403
0
  CurrentSource = L;
18404
0
  return OffsetOf<PT_IntAPS>(S, OpPC, A0);
18405
0
}
18406
#endif
18407
#ifdef GET_OPCODE_NAMES
18408
OP_PopSint8,
18409
OP_PopUint8,
18410
OP_PopSint16,
18411
OP_PopUint16,
18412
OP_PopSint32,
18413
OP_PopUint32,
18414
OP_PopSint64,
18415
OP_PopUint64,
18416
OP_PopIntAP,
18417
OP_PopIntAPS,
18418
OP_PopBool,
18419
OP_PopPtr,
18420
OP_PopFnPtr,
18421
OP_PopFloat,
18422
#endif
18423
0
#ifdef GET_INTERP
18424
0
case OP_PopSint8: {
18425
0
  if (!Pop<PT_Sint8>(S, OpPC))
18426
0
    return false;
18427
0
  continue;
18428
0
}
18429
0
case OP_PopUint8: {
18430
0
  if (!Pop<PT_Uint8>(S, OpPC))
18431
0
    return false;
18432
0
  continue;
18433
0
}
18434
0
case OP_PopSint16: {
18435
0
  if (!Pop<PT_Sint16>(S, OpPC))
18436
0
    return false;
18437
0
  continue;
18438
0
}
18439
0
case OP_PopUint16: {
18440
0
  if (!Pop<PT_Uint16>(S, OpPC))
18441
0
    return false;
18442
0
  continue;
18443
0
}
18444
0
case OP_PopSint32: {
18445
0
  if (!Pop<PT_Sint32>(S, OpPC))
18446
0
    return false;
18447
0
  continue;
18448
0
}
18449
0
case OP_PopUint32: {
18450
0
  if (!Pop<PT_Uint32>(S, OpPC))
18451
0
    return false;
18452
0
  continue;
18453
0
}
18454
0
case OP_PopSint64: {
18455
0
  if (!Pop<PT_Sint64>(S, OpPC))
18456
0
    return false;
18457
0
  continue;
18458
0
}
18459
0
case OP_PopUint64: {
18460
0
  if (!Pop<PT_Uint64>(S, OpPC))
18461
0
    return false;
18462
0
  continue;
18463
0
}
18464
0
case OP_PopIntAP: {
18465
0
  if (!Pop<PT_IntAP>(S, OpPC))
18466
0
    return false;
18467
0
  continue;
18468
0
}
18469
0
case OP_PopIntAPS: {
18470
0
  if (!Pop<PT_IntAPS>(S, OpPC))
18471
0
    return false;
18472
0
  continue;
18473
0
}
18474
0
case OP_PopBool: {
18475
0
  if (!Pop<PT_Bool>(S, OpPC))
18476
0
    return false;
18477
0
  continue;
18478
0
}
18479
0
case OP_PopPtr: {
18480
0
  if (!Pop<PT_Ptr>(S, OpPC))
18481
0
    return false;
18482
0
  continue;
18483
0
}
18484
0
case OP_PopFnPtr: {
18485
0
  if (!Pop<PT_FnPtr>(S, OpPC))
18486
0
    return false;
18487
0
  continue;
18488
0
}
18489
0
case OP_PopFloat: {
18490
0
  if (!Pop<PT_Float>(S, OpPC))
18491
0
    return false;
18492
0
  continue;
18493
0
}
18494
0
#endif
18495
#ifdef GET_DISASM
18496
case OP_PopSint8:
18497
  PrintName("PopSint8");
18498
  OS << "\t" << "\n";
18499
  continue;
18500
case OP_PopUint8:
18501
  PrintName("PopUint8");
18502
  OS << "\t" << "\n";
18503
  continue;
18504
case OP_PopSint16:
18505
  PrintName("PopSint16");
18506
  OS << "\t" << "\n";
18507
  continue;
18508
case OP_PopUint16:
18509
  PrintName("PopUint16");
18510
  OS << "\t" << "\n";
18511
  continue;
18512
case OP_PopSint32:
18513
  PrintName("PopSint32");
18514
  OS << "\t" << "\n";
18515
  continue;
18516
case OP_PopUint32:
18517
  PrintName("PopUint32");
18518
  OS << "\t" << "\n";
18519
  continue;
18520
case OP_PopSint64:
18521
  PrintName("PopSint64");
18522
  OS << "\t" << "\n";
18523
  continue;
18524
case OP_PopUint64:
18525
  PrintName("PopUint64");
18526
  OS << "\t" << "\n";
18527
  continue;
18528
case OP_PopIntAP:
18529
  PrintName("PopIntAP");
18530
  OS << "\t" << "\n";
18531
  continue;
18532
case OP_PopIntAPS:
18533
  PrintName("PopIntAPS");
18534
  OS << "\t" << "\n";
18535
  continue;
18536
case OP_PopBool:
18537
  PrintName("PopBool");
18538
  OS << "\t" << "\n";
18539
  continue;
18540
case OP_PopPtr:
18541
  PrintName("PopPtr");
18542
  OS << "\t" << "\n";
18543
  continue;
18544
case OP_PopFnPtr:
18545
  PrintName("PopFnPtr");
18546
  OS << "\t" << "\n";
18547
  continue;
18548
case OP_PopFloat:
18549
  PrintName("PopFloat");
18550
  OS << "\t" << "\n";
18551
  continue;
18552
#endif
18553
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18554
bool emitPopSint8(const SourceInfo &);
18555
bool emitPopUint8(const SourceInfo &);
18556
bool emitPopSint16(const SourceInfo &);
18557
bool emitPopUint16(const SourceInfo &);
18558
bool emitPopSint32(const SourceInfo &);
18559
bool emitPopUint32(const SourceInfo &);
18560
bool emitPopSint64(const SourceInfo &);
18561
bool emitPopUint64(const SourceInfo &);
18562
bool emitPopIntAP(const SourceInfo &);
18563
bool emitPopIntAPS(const SourceInfo &);
18564
bool emitPopBool(const SourceInfo &);
18565
bool emitPopPtr(const SourceInfo &);
18566
bool emitPopFnPtr(const SourceInfo &);
18567
bool emitPopFloat(const SourceInfo &);
18568
#endif
18569
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18570
bool emitPop(PrimType, const SourceInfo &I);
18571
#endif
18572
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
18573
bool
18574
#if defined(GET_EVAL_IMPL)
18575
EvalEmitter
18576
#else
18577
ByteCodeEmitter
18578
#endif
18579
0
::emitPop(PrimType T0, const SourceInfo &I) {
18580
0
  switch (T0) {
18581
0
  case PT_Sint8:
18582
0
    return emitPopSint8(I);
18583
0
  case PT_Uint8:
18584
0
    return emitPopUint8(I);
18585
0
  case PT_Sint16:
18586
0
    return emitPopSint16(I);
18587
0
  case PT_Uint16:
18588
0
    return emitPopUint16(I);
18589
0
  case PT_Sint32:
18590
0
    return emitPopSint32(I);
18591
0
  case PT_Uint32:
18592
0
    return emitPopUint32(I);
18593
0
  case PT_Sint64:
18594
0
    return emitPopSint64(I);
18595
0
  case PT_Uint64:
18596
0
    return emitPopUint64(I);
18597
0
  case PT_IntAP:
18598
0
    return emitPopIntAP(I);
18599
0
  case PT_IntAPS:
18600
0
    return emitPopIntAPS(I);
18601
0
  case PT_Bool:
18602
0
    return emitPopBool(I);
18603
0
  case PT_Ptr:
18604
0
    return emitPopPtr(I);
18605
0
  case PT_FnPtr:
18606
0
    return emitPopFnPtr(I);
18607
0
  case PT_Float:
18608
0
    return emitPopFloat(I);
18609
0
  }
18610
0
  llvm_unreachable("invalid enum value");
18611
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
18612
#endif
18613
#ifdef GET_LINK_IMPL
18614
0
bool ByteCodeEmitter::emitPopSint8(const SourceInfo &L) {
18615
0
  return emitOp<>(OP_PopSint8, L);
18616
0
}
18617
0
bool ByteCodeEmitter::emitPopUint8(const SourceInfo &L) {
18618
0
  return emitOp<>(OP_PopUint8, L);
18619
0
}
18620
0
bool ByteCodeEmitter::emitPopSint16(const SourceInfo &L) {
18621
0
  return emitOp<>(OP_PopSint16, L);
18622
0
}
18623
0
bool ByteCodeEmitter::emitPopUint16(const SourceInfo &L) {
18624
0
  return emitOp<>(OP_PopUint16, L);
18625
0
}
18626
0
bool ByteCodeEmitter::emitPopSint32(const SourceInfo &L) {
18627
0
  return emitOp<>(OP_PopSint32, L);
18628
0
}
18629
0
bool ByteCodeEmitter::emitPopUint32(const SourceInfo &L) {
18630
0
  return emitOp<>(OP_PopUint32, L);
18631
0
}
18632
0
bool ByteCodeEmitter::emitPopSint64(const SourceInfo &L) {
18633
0
  return emitOp<>(OP_PopSint64, L);
18634
0
}
18635
0
bool ByteCodeEmitter::emitPopUint64(const SourceInfo &L) {
18636
0
  return emitOp<>(OP_PopUint64, L);
18637
0
}
18638
0
bool ByteCodeEmitter::emitPopIntAP(const SourceInfo &L) {
18639
0
  return emitOp<>(OP_PopIntAP, L);
18640
0
}
18641
0
bool ByteCodeEmitter::emitPopIntAPS(const SourceInfo &L) {
18642
0
  return emitOp<>(OP_PopIntAPS, L);
18643
0
}
18644
0
bool ByteCodeEmitter::emitPopBool(const SourceInfo &L) {
18645
0
  return emitOp<>(OP_PopBool, L);
18646
0
}
18647
0
bool ByteCodeEmitter::emitPopPtr(const SourceInfo &L) {
18648
0
  return emitOp<>(OP_PopPtr, L);
18649
0
}
18650
0
bool ByteCodeEmitter::emitPopFnPtr(const SourceInfo &L) {
18651
0
  return emitOp<>(OP_PopFnPtr, L);
18652
0
}
18653
0
bool ByteCodeEmitter::emitPopFloat(const SourceInfo &L) {
18654
0
  return emitOp<>(OP_PopFloat, L);
18655
0
}
18656
#endif
18657
#ifdef GET_EVAL_IMPL
18658
0
bool EvalEmitter::emitPopSint8(const SourceInfo &L) {
18659
0
  if (!isActive()) return true;
18660
0
  CurrentSource = L;
18661
0
  return Pop<PT_Sint8>(S, OpPC);
18662
0
}
18663
0
bool EvalEmitter::emitPopUint8(const SourceInfo &L) {
18664
0
  if (!isActive()) return true;
18665
0
  CurrentSource = L;
18666
0
  return Pop<PT_Uint8>(S, OpPC);
18667
0
}
18668
0
bool EvalEmitter::emitPopSint16(const SourceInfo &L) {
18669
0
  if (!isActive()) return true;
18670
0
  CurrentSource = L;
18671
0
  return Pop<PT_Sint16>(S, OpPC);
18672
0
}
18673
0
bool EvalEmitter::emitPopUint16(const SourceInfo &L) {
18674
0
  if (!isActive()) return true;
18675
0
  CurrentSource = L;
18676
0
  return Pop<PT_Uint16>(S, OpPC);
18677
0
}
18678
0
bool EvalEmitter::emitPopSint32(const SourceInfo &L) {
18679
0
  if (!isActive()) return true;
18680
0
  CurrentSource = L;
18681
0
  return Pop<PT_Sint32>(S, OpPC);
18682
0
}
18683
0
bool EvalEmitter::emitPopUint32(const SourceInfo &L) {
18684
0
  if (!isActive()) return true;
18685
0
  CurrentSource = L;
18686
0
  return Pop<PT_Uint32>(S, OpPC);
18687
0
}
18688
0
bool EvalEmitter::emitPopSint64(const SourceInfo &L) {
18689
0
  if (!isActive()) return true;
18690
0
  CurrentSource = L;
18691
0
  return Pop<PT_Sint64>(S, OpPC);
18692
0
}
18693
0
bool EvalEmitter::emitPopUint64(const SourceInfo &L) {
18694
0
  if (!isActive()) return true;
18695
0
  CurrentSource = L;
18696
0
  return Pop<PT_Uint64>(S, OpPC);
18697
0
}
18698
0
bool EvalEmitter::emitPopIntAP(const SourceInfo &L) {
18699
0
  if (!isActive()) return true;
18700
0
  CurrentSource = L;
18701
0
  return Pop<PT_IntAP>(S, OpPC);
18702
0
}
18703
0
bool EvalEmitter::emitPopIntAPS(const SourceInfo &L) {
18704
0
  if (!isActive()) return true;
18705
0
  CurrentSource = L;
18706
0
  return Pop<PT_IntAPS>(S, OpPC);
18707
0
}
18708
0
bool EvalEmitter::emitPopBool(const SourceInfo &L) {
18709
0
  if (!isActive()) return true;
18710
0
  CurrentSource = L;
18711
0
  return Pop<PT_Bool>(S, OpPC);
18712
0
}
18713
0
bool EvalEmitter::emitPopPtr(const SourceInfo &L) {
18714
0
  if (!isActive()) return true;
18715
0
  CurrentSource = L;
18716
0
  return Pop<PT_Ptr>(S, OpPC);
18717
0
}
18718
0
bool EvalEmitter::emitPopFnPtr(const SourceInfo &L) {
18719
0
  if (!isActive()) return true;
18720
0
  CurrentSource = L;
18721
0
  return Pop<PT_FnPtr>(S, OpPC);
18722
0
}
18723
0
bool EvalEmitter::emitPopFloat(const SourceInfo &L) {
18724
0
  if (!isActive()) return true;
18725
0
  CurrentSource = L;
18726
0
  return Pop<PT_Float>(S, OpPC);
18727
0
}
18728
#endif
18729
#ifdef GET_OPCODE_NAMES
18730
OP_RVOPtr,
18731
#endif
18732
0
#ifdef GET_INTERP
18733
0
case OP_RVOPtr: {
18734
0
  if (!RVOPtr(S, OpPC))
18735
0
    return false;
18736
0
  continue;
18737
0
}
18738
0
#endif
18739
#ifdef GET_DISASM
18740
case OP_RVOPtr:
18741
  PrintName("RVOPtr");
18742
  OS << "\t" << "\n";
18743
  continue;
18744
#endif
18745
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18746
bool emitRVOPtr(const SourceInfo &);
18747
#endif
18748
#ifdef GET_LINK_IMPL
18749
0
bool ByteCodeEmitter::emitRVOPtr(const SourceInfo &L) {
18750
0
  return emitOp<>(OP_RVOPtr, L);
18751
0
}
18752
#endif
18753
#ifdef GET_EVAL_IMPL
18754
0
bool EvalEmitter::emitRVOPtr(const SourceInfo &L) {
18755
0
  if (!isActive()) return true;
18756
0
  CurrentSource = L;
18757
0
  return RVOPtr(S, OpPC);
18758
0
}
18759
#endif
18760
#ifdef GET_OPCODE_NAMES
18761
OP_RemSint8,
18762
OP_RemUint8,
18763
OP_RemSint16,
18764
OP_RemUint16,
18765
OP_RemSint32,
18766
OP_RemUint32,
18767
OP_RemSint64,
18768
OP_RemUint64,
18769
OP_RemIntAP,
18770
OP_RemIntAPS,
18771
#endif
18772
0
#ifdef GET_INTERP
18773
0
case OP_RemSint8: {
18774
0
  if (!Rem<PT_Sint8>(S, OpPC))
18775
0
    return false;
18776
0
  continue;
18777
0
}
18778
0
case OP_RemUint8: {
18779
0
  if (!Rem<PT_Uint8>(S, OpPC))
18780
0
    return false;
18781
0
  continue;
18782
0
}
18783
0
case OP_RemSint16: {
18784
0
  if (!Rem<PT_Sint16>(S, OpPC))
18785
0
    return false;
18786
0
  continue;
18787
0
}
18788
0
case OP_RemUint16: {
18789
0
  if (!Rem<PT_Uint16>(S, OpPC))
18790
0
    return false;
18791
0
  continue;
18792
0
}
18793
0
case OP_RemSint32: {
18794
0
  if (!Rem<PT_Sint32>(S, OpPC))
18795
0
    return false;
18796
0
  continue;
18797
0
}
18798
0
case OP_RemUint32: {
18799
0
  if (!Rem<PT_Uint32>(S, OpPC))
18800
0
    return false;
18801
0
  continue;
18802
0
}
18803
0
case OP_RemSint64: {
18804
0
  if (!Rem<PT_Sint64>(S, OpPC))
18805
0
    return false;
18806
0
  continue;
18807
0
}
18808
0
case OP_RemUint64: {
18809
0
  if (!Rem<PT_Uint64>(S, OpPC))
18810
0
    return false;
18811
0
  continue;
18812
0
}
18813
0
case OP_RemIntAP: {
18814
0
  if (!Rem<PT_IntAP>(S, OpPC))
18815
0
    return false;
18816
0
  continue;
18817
0
}
18818
0
case OP_RemIntAPS: {
18819
0
  if (!Rem<PT_IntAPS>(S, OpPC))
18820
0
    return false;
18821
0
  continue;
18822
0
}
18823
0
#endif
18824
#ifdef GET_DISASM
18825
case OP_RemSint8:
18826
  PrintName("RemSint8");
18827
  OS << "\t" << "\n";
18828
  continue;
18829
case OP_RemUint8:
18830
  PrintName("RemUint8");
18831
  OS << "\t" << "\n";
18832
  continue;
18833
case OP_RemSint16:
18834
  PrintName("RemSint16");
18835
  OS << "\t" << "\n";
18836
  continue;
18837
case OP_RemUint16:
18838
  PrintName("RemUint16");
18839
  OS << "\t" << "\n";
18840
  continue;
18841
case OP_RemSint32:
18842
  PrintName("RemSint32");
18843
  OS << "\t" << "\n";
18844
  continue;
18845
case OP_RemUint32:
18846
  PrintName("RemUint32");
18847
  OS << "\t" << "\n";
18848
  continue;
18849
case OP_RemSint64:
18850
  PrintName("RemSint64");
18851
  OS << "\t" << "\n";
18852
  continue;
18853
case OP_RemUint64:
18854
  PrintName("RemUint64");
18855
  OS << "\t" << "\n";
18856
  continue;
18857
case OP_RemIntAP:
18858
  PrintName("RemIntAP");
18859
  OS << "\t" << "\n";
18860
  continue;
18861
case OP_RemIntAPS:
18862
  PrintName("RemIntAPS");
18863
  OS << "\t" << "\n";
18864
  continue;
18865
#endif
18866
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18867
bool emitRemSint8(const SourceInfo &);
18868
bool emitRemUint8(const SourceInfo &);
18869
bool emitRemSint16(const SourceInfo &);
18870
bool emitRemUint16(const SourceInfo &);
18871
bool emitRemSint32(const SourceInfo &);
18872
bool emitRemUint32(const SourceInfo &);
18873
bool emitRemSint64(const SourceInfo &);
18874
bool emitRemUint64(const SourceInfo &);
18875
bool emitRemIntAP(const SourceInfo &);
18876
bool emitRemIntAPS(const SourceInfo &);
18877
#endif
18878
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
18879
bool emitRem(PrimType, const SourceInfo &I);
18880
#endif
18881
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
18882
bool
18883
#if defined(GET_EVAL_IMPL)
18884
EvalEmitter
18885
#else
18886
ByteCodeEmitter
18887
#endif
18888
0
::emitRem(PrimType T0, const SourceInfo &I) {
18889
0
  switch (T0) {
18890
0
  case PT_Sint8:
18891
0
    return emitRemSint8(I);
18892
0
  case PT_Uint8:
18893
0
    return emitRemUint8(I);
18894
0
  case PT_Sint16:
18895
0
    return emitRemSint16(I);
18896
0
  case PT_Uint16:
18897
0
    return emitRemUint16(I);
18898
0
  case PT_Sint32:
18899
0
    return emitRemSint32(I);
18900
0
  case PT_Uint32:
18901
0
    return emitRemUint32(I);
18902
0
  case PT_Sint64:
18903
0
    return emitRemSint64(I);
18904
0
  case PT_Uint64:
18905
0
    return emitRemUint64(I);
18906
0
  case PT_IntAP:
18907
0
    return emitRemIntAP(I);
18908
0
  case PT_IntAPS:
18909
0
    return emitRemIntAPS(I);
18910
0
  default: llvm_unreachable("invalid type: emitRem");
18911
0
  }
18912
0
  llvm_unreachable("invalid enum value");
18913
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitRem(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitRem(clang::interp::PrimType, clang::interp::SourceInfo const&)
18914
#endif
18915
#ifdef GET_LINK_IMPL
18916
0
bool ByteCodeEmitter::emitRemSint8(const SourceInfo &L) {
18917
0
  return emitOp<>(OP_RemSint8, L);
18918
0
}
18919
0
bool ByteCodeEmitter::emitRemUint8(const SourceInfo &L) {
18920
0
  return emitOp<>(OP_RemUint8, L);
18921
0
}
18922
0
bool ByteCodeEmitter::emitRemSint16(const SourceInfo &L) {
18923
0
  return emitOp<>(OP_RemSint16, L);
18924
0
}
18925
0
bool ByteCodeEmitter::emitRemUint16(const SourceInfo &L) {
18926
0
  return emitOp<>(OP_RemUint16, L);
18927
0
}
18928
0
bool ByteCodeEmitter::emitRemSint32(const SourceInfo &L) {
18929
0
  return emitOp<>(OP_RemSint32, L);
18930
0
}
18931
0
bool ByteCodeEmitter::emitRemUint32(const SourceInfo &L) {
18932
0
  return emitOp<>(OP_RemUint32, L);
18933
0
}
18934
0
bool ByteCodeEmitter::emitRemSint64(const SourceInfo &L) {
18935
0
  return emitOp<>(OP_RemSint64, L);
18936
0
}
18937
0
bool ByteCodeEmitter::emitRemUint64(const SourceInfo &L) {
18938
0
  return emitOp<>(OP_RemUint64, L);
18939
0
}
18940
0
bool ByteCodeEmitter::emitRemIntAP(const SourceInfo &L) {
18941
0
  return emitOp<>(OP_RemIntAP, L);
18942
0
}
18943
0
bool ByteCodeEmitter::emitRemIntAPS(const SourceInfo &L) {
18944
0
  return emitOp<>(OP_RemIntAPS, L);
18945
0
}
18946
#endif
18947
#ifdef GET_EVAL_IMPL
18948
0
bool EvalEmitter::emitRemSint8(const SourceInfo &L) {
18949
0
  if (!isActive()) return true;
18950
0
  CurrentSource = L;
18951
0
  return Rem<PT_Sint8>(S, OpPC);
18952
0
}
18953
0
bool EvalEmitter::emitRemUint8(const SourceInfo &L) {
18954
0
  if (!isActive()) return true;
18955
0
  CurrentSource = L;
18956
0
  return Rem<PT_Uint8>(S, OpPC);
18957
0
}
18958
0
bool EvalEmitter::emitRemSint16(const SourceInfo &L) {
18959
0
  if (!isActive()) return true;
18960
0
  CurrentSource = L;
18961
0
  return Rem<PT_Sint16>(S, OpPC);
18962
0
}
18963
0
bool EvalEmitter::emitRemUint16(const SourceInfo &L) {
18964
0
  if (!isActive()) return true;
18965
0
  CurrentSource = L;
18966
0
  return Rem<PT_Uint16>(S, OpPC);
18967
0
}
18968
0
bool EvalEmitter::emitRemSint32(const SourceInfo &L) {
18969
0
  if (!isActive()) return true;
18970
0
  CurrentSource = L;
18971
0
  return Rem<PT_Sint32>(S, OpPC);
18972
0
}
18973
0
bool EvalEmitter::emitRemUint32(const SourceInfo &L) {
18974
0
  if (!isActive()) return true;
18975
0
  CurrentSource = L;
18976
0
  return Rem<PT_Uint32>(S, OpPC);
18977
0
}
18978
0
bool EvalEmitter::emitRemSint64(const SourceInfo &L) {
18979
0
  if (!isActive()) return true;
18980
0
  CurrentSource = L;
18981
0
  return Rem<PT_Sint64>(S, OpPC);
18982
0
}
18983
0
bool EvalEmitter::emitRemUint64(const SourceInfo &L) {
18984
0
  if (!isActive()) return true;
18985
0
  CurrentSource = L;
18986
0
  return Rem<PT_Uint64>(S, OpPC);
18987
0
}
18988
0
bool EvalEmitter::emitRemIntAP(const SourceInfo &L) {
18989
0
  if (!isActive()) return true;
18990
0
  CurrentSource = L;
18991
0
  return Rem<PT_IntAP>(S, OpPC);
18992
0
}
18993
0
bool EvalEmitter::emitRemIntAPS(const SourceInfo &L) {
18994
0
  if (!isActive()) return true;
18995
0
  CurrentSource = L;
18996
0
  return Rem<PT_IntAPS>(S, OpPC);
18997
0
}
18998
#endif
18999
#ifdef GET_OPCODE_NAMES
19000
OP_RetSint8,
19001
OP_RetUint8,
19002
OP_RetSint16,
19003
OP_RetUint16,
19004
OP_RetSint32,
19005
OP_RetUint32,
19006
OP_RetSint64,
19007
OP_RetUint64,
19008
OP_RetIntAP,
19009
OP_RetIntAPS,
19010
OP_RetBool,
19011
OP_RetPtr,
19012
OP_RetFnPtr,
19013
OP_RetFloat,
19014
#endif
19015
0
#ifdef GET_INTERP
19016
0
case OP_RetSint8: {
19017
0
  bool DoReturn = (S.Current == StartFrame);
19018
0
  if (!Ret<PT_Sint8>(S, PC, Result))
19019
0
    return false;
19020
0
  if (!S.Current || S.Current->isRoot())
19021
0
    return true;
19022
0
  if (DoReturn)
19023
0
    return true;
19024
0
  continue;
19025
0
}
19026
0
case OP_RetUint8: {
19027
0
  bool DoReturn = (S.Current == StartFrame);
19028
0
  if (!Ret<PT_Uint8>(S, PC, Result))
19029
0
    return false;
19030
0
  if (!S.Current || S.Current->isRoot())
19031
0
    return true;
19032
0
  if (DoReturn)
19033
0
    return true;
19034
0
  continue;
19035
0
}
19036
0
case OP_RetSint16: {
19037
0
  bool DoReturn = (S.Current == StartFrame);
19038
0
  if (!Ret<PT_Sint16>(S, PC, Result))
19039
0
    return false;
19040
0
  if (!S.Current || S.Current->isRoot())
19041
0
    return true;
19042
0
  if (DoReturn)
19043
0
    return true;
19044
0
  continue;
19045
0
}
19046
0
case OP_RetUint16: {
19047
0
  bool DoReturn = (S.Current == StartFrame);
19048
0
  if (!Ret<PT_Uint16>(S, PC, Result))
19049
0
    return false;
19050
0
  if (!S.Current || S.Current->isRoot())
19051
0
    return true;
19052
0
  if (DoReturn)
19053
0
    return true;
19054
0
  continue;
19055
0
}
19056
0
case OP_RetSint32: {
19057
0
  bool DoReturn = (S.Current == StartFrame);
19058
0
  if (!Ret<PT_Sint32>(S, PC, Result))
19059
0
    return false;
19060
0
  if (!S.Current || S.Current->isRoot())
19061
0
    return true;
19062
0
  if (DoReturn)
19063
0
    return true;
19064
0
  continue;
19065
0
}
19066
0
case OP_RetUint32: {
19067
0
  bool DoReturn = (S.Current == StartFrame);
19068
0
  if (!Ret<PT_Uint32>(S, PC, Result))
19069
0
    return false;
19070
0
  if (!S.Current || S.Current->isRoot())
19071
0
    return true;
19072
0
  if (DoReturn)
19073
0
    return true;
19074
0
  continue;
19075
0
}
19076
0
case OP_RetSint64: {
19077
0
  bool DoReturn = (S.Current == StartFrame);
19078
0
  if (!Ret<PT_Sint64>(S, PC, Result))
19079
0
    return false;
19080
0
  if (!S.Current || S.Current->isRoot())
19081
0
    return true;
19082
0
  if (DoReturn)
19083
0
    return true;
19084
0
  continue;
19085
0
}
19086
0
case OP_RetUint64: {
19087
0
  bool DoReturn = (S.Current == StartFrame);
19088
0
  if (!Ret<PT_Uint64>(S, PC, Result))
19089
0
    return false;
19090
0
  if (!S.Current || S.Current->isRoot())
19091
0
    return true;
19092
0
  if (DoReturn)
19093
0
    return true;
19094
0
  continue;
19095
0
}
19096
0
case OP_RetIntAP: {
19097
0
  bool DoReturn = (S.Current == StartFrame);
19098
0
  if (!Ret<PT_IntAP>(S, PC, Result))
19099
0
    return false;
19100
0
  if (!S.Current || S.Current->isRoot())
19101
0
    return true;
19102
0
  if (DoReturn)
19103
0
    return true;
19104
0
  continue;
19105
0
}
19106
0
case OP_RetIntAPS: {
19107
0
  bool DoReturn = (S.Current == StartFrame);
19108
0
  if (!Ret<PT_IntAPS>(S, PC, Result))
19109
0
    return false;
19110
0
  if (!S.Current || S.Current->isRoot())
19111
0
    return true;
19112
0
  if (DoReturn)
19113
0
    return true;
19114
0
  continue;
19115
0
}
19116
0
case OP_RetBool: {
19117
0
  bool DoReturn = (S.Current == StartFrame);
19118
0
  if (!Ret<PT_Bool>(S, PC, Result))
19119
0
    return false;
19120
0
  if (!S.Current || S.Current->isRoot())
19121
0
    return true;
19122
0
  if (DoReturn)
19123
0
    return true;
19124
0
  continue;
19125
0
}
19126
0
case OP_RetPtr: {
19127
0
  bool DoReturn = (S.Current == StartFrame);
19128
0
  if (!Ret<PT_Ptr>(S, PC, Result))
19129
0
    return false;
19130
0
  if (!S.Current || S.Current->isRoot())
19131
0
    return true;
19132
0
  if (DoReturn)
19133
0
    return true;
19134
0
  continue;
19135
0
}
19136
0
case OP_RetFnPtr: {
19137
0
  bool DoReturn = (S.Current == StartFrame);
19138
0
  if (!Ret<PT_FnPtr>(S, PC, Result))
19139
0
    return false;
19140
0
  if (!S.Current || S.Current->isRoot())
19141
0
    return true;
19142
0
  if (DoReturn)
19143
0
    return true;
19144
0
  continue;
19145
0
}
19146
0
case OP_RetFloat: {
19147
0
  bool DoReturn = (S.Current == StartFrame);
19148
0
  if (!Ret<PT_Float>(S, PC, Result))
19149
0
    return false;
19150
0
  if (!S.Current || S.Current->isRoot())
19151
0
    return true;
19152
0
  if (DoReturn)
19153
0
    return true;
19154
0
  continue;
19155
0
}
19156
0
#endif
19157
#ifdef GET_DISASM
19158
case OP_RetSint8:
19159
  PrintName("RetSint8");
19160
  OS << "\t" << "\n";
19161
  continue;
19162
case OP_RetUint8:
19163
  PrintName("RetUint8");
19164
  OS << "\t" << "\n";
19165
  continue;
19166
case OP_RetSint16:
19167
  PrintName("RetSint16");
19168
  OS << "\t" << "\n";
19169
  continue;
19170
case OP_RetUint16:
19171
  PrintName("RetUint16");
19172
  OS << "\t" << "\n";
19173
  continue;
19174
case OP_RetSint32:
19175
  PrintName("RetSint32");
19176
  OS << "\t" << "\n";
19177
  continue;
19178
case OP_RetUint32:
19179
  PrintName("RetUint32");
19180
  OS << "\t" << "\n";
19181
  continue;
19182
case OP_RetSint64:
19183
  PrintName("RetSint64");
19184
  OS << "\t" << "\n";
19185
  continue;
19186
case OP_RetUint64:
19187
  PrintName("RetUint64");
19188
  OS << "\t" << "\n";
19189
  continue;
19190
case OP_RetIntAP:
19191
  PrintName("RetIntAP");
19192
  OS << "\t" << "\n";
19193
  continue;
19194
case OP_RetIntAPS:
19195
  PrintName("RetIntAPS");
19196
  OS << "\t" << "\n";
19197
  continue;
19198
case OP_RetBool:
19199
  PrintName("RetBool");
19200
  OS << "\t" << "\n";
19201
  continue;
19202
case OP_RetPtr:
19203
  PrintName("RetPtr");
19204
  OS << "\t" << "\n";
19205
  continue;
19206
case OP_RetFnPtr:
19207
  PrintName("RetFnPtr");
19208
  OS << "\t" << "\n";
19209
  continue;
19210
case OP_RetFloat:
19211
  PrintName("RetFloat");
19212
  OS << "\t" << "\n";
19213
  continue;
19214
#endif
19215
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19216
bool emitRetSint8(const SourceInfo &);
19217
bool emitRetUint8(const SourceInfo &);
19218
bool emitRetSint16(const SourceInfo &);
19219
bool emitRetUint16(const SourceInfo &);
19220
bool emitRetSint32(const SourceInfo &);
19221
bool emitRetUint32(const SourceInfo &);
19222
bool emitRetSint64(const SourceInfo &);
19223
bool emitRetUint64(const SourceInfo &);
19224
bool emitRetIntAP(const SourceInfo &);
19225
bool emitRetIntAPS(const SourceInfo &);
19226
bool emitRetBool(const SourceInfo &);
19227
bool emitRetPtr(const SourceInfo &);
19228
bool emitRetFnPtr(const SourceInfo &);
19229
bool emitRetFloat(const SourceInfo &);
19230
#if defined(GET_EVAL_PROTO)
19231
template<PrimType>
19232
bool emitRet(const SourceInfo &);
19233
#endif
19234
#endif
19235
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19236
bool emitRet(PrimType, const SourceInfo &I);
19237
#endif
19238
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
19239
bool
19240
#if defined(GET_EVAL_IMPL)
19241
EvalEmitter
19242
#else
19243
ByteCodeEmitter
19244
#endif
19245
0
::emitRet(PrimType T0, const SourceInfo &I) {
19246
0
  switch (T0) {
19247
0
  case PT_Sint8:
19248
#ifdef GET_LINK_IMPL
19249
    return emitRetSint8
19250
#else
19251
    return emitRet<PT_Sint8>
19252
#endif
19253
0
      (I);
19254
0
  case PT_Uint8:
19255
#ifdef GET_LINK_IMPL
19256
    return emitRetUint8
19257
#else
19258
    return emitRet<PT_Uint8>
19259
#endif
19260
0
      (I);
19261
0
  case PT_Sint16:
19262
#ifdef GET_LINK_IMPL
19263
    return emitRetSint16
19264
#else
19265
    return emitRet<PT_Sint16>
19266
#endif
19267
0
      (I);
19268
0
  case PT_Uint16:
19269
#ifdef GET_LINK_IMPL
19270
    return emitRetUint16
19271
#else
19272
    return emitRet<PT_Uint16>
19273
#endif
19274
0
      (I);
19275
0
  case PT_Sint32:
19276
#ifdef GET_LINK_IMPL
19277
    return emitRetSint32
19278
#else
19279
    return emitRet<PT_Sint32>
19280
#endif
19281
0
      (I);
19282
0
  case PT_Uint32:
19283
#ifdef GET_LINK_IMPL
19284
    return emitRetUint32
19285
#else
19286
    return emitRet<PT_Uint32>
19287
#endif
19288
0
      (I);
19289
0
  case PT_Sint64:
19290
#ifdef GET_LINK_IMPL
19291
    return emitRetSint64
19292
#else
19293
    return emitRet<PT_Sint64>
19294
#endif
19295
0
      (I);
19296
0
  case PT_Uint64:
19297
#ifdef GET_LINK_IMPL
19298
    return emitRetUint64
19299
#else
19300
    return emitRet<PT_Uint64>
19301
#endif
19302
0
      (I);
19303
0
  case PT_IntAP:
19304
#ifdef GET_LINK_IMPL
19305
    return emitRetIntAP
19306
#else
19307
    return emitRet<PT_IntAP>
19308
#endif
19309
0
      (I);
19310
0
  case PT_IntAPS:
19311
#ifdef GET_LINK_IMPL
19312
    return emitRetIntAPS
19313
#else
19314
    return emitRet<PT_IntAPS>
19315
#endif
19316
0
      (I);
19317
0
  case PT_Bool:
19318
#ifdef GET_LINK_IMPL
19319
    return emitRetBool
19320
#else
19321
    return emitRet<PT_Bool>
19322
#endif
19323
0
      (I);
19324
0
  case PT_Ptr:
19325
#ifdef GET_LINK_IMPL
19326
    return emitRetPtr
19327
#else
19328
    return emitRet<PT_Ptr>
19329
#endif
19330
0
      (I);
19331
0
  case PT_FnPtr:
19332
#ifdef GET_LINK_IMPL
19333
    return emitRetFnPtr
19334
#else
19335
    return emitRet<PT_FnPtr>
19336
#endif
19337
0
      (I);
19338
0
  case PT_Float:
19339
#ifdef GET_LINK_IMPL
19340
    return emitRetFloat
19341
#else
19342
    return emitRet<PT_Float>
19343
#endif
19344
0
      (I);
19345
0
  }
19346
0
  llvm_unreachable("invalid enum value");
19347
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitRet(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitRet(clang::interp::PrimType, clang::interp::SourceInfo const&)
19348
#endif
19349
#ifdef GET_LINK_IMPL
19350
0
bool ByteCodeEmitter::emitRetSint8(const SourceInfo &L) {
19351
0
  return emitOp<>(OP_RetSint8, L);
19352
0
}
19353
0
bool ByteCodeEmitter::emitRetUint8(const SourceInfo &L) {
19354
0
  return emitOp<>(OP_RetUint8, L);
19355
0
}
19356
0
bool ByteCodeEmitter::emitRetSint16(const SourceInfo &L) {
19357
0
  return emitOp<>(OP_RetSint16, L);
19358
0
}
19359
0
bool ByteCodeEmitter::emitRetUint16(const SourceInfo &L) {
19360
0
  return emitOp<>(OP_RetUint16, L);
19361
0
}
19362
0
bool ByteCodeEmitter::emitRetSint32(const SourceInfo &L) {
19363
0
  return emitOp<>(OP_RetSint32, L);
19364
0
}
19365
0
bool ByteCodeEmitter::emitRetUint32(const SourceInfo &L) {
19366
0
  return emitOp<>(OP_RetUint32, L);
19367
0
}
19368
0
bool ByteCodeEmitter::emitRetSint64(const SourceInfo &L) {
19369
0
  return emitOp<>(OP_RetSint64, L);
19370
0
}
19371
0
bool ByteCodeEmitter::emitRetUint64(const SourceInfo &L) {
19372
0
  return emitOp<>(OP_RetUint64, L);
19373
0
}
19374
0
bool ByteCodeEmitter::emitRetIntAP(const SourceInfo &L) {
19375
0
  return emitOp<>(OP_RetIntAP, L);
19376
0
}
19377
0
bool ByteCodeEmitter::emitRetIntAPS(const SourceInfo &L) {
19378
0
  return emitOp<>(OP_RetIntAPS, L);
19379
0
}
19380
0
bool ByteCodeEmitter::emitRetBool(const SourceInfo &L) {
19381
0
  return emitOp<>(OP_RetBool, L);
19382
0
}
19383
0
bool ByteCodeEmitter::emitRetPtr(const SourceInfo &L) {
19384
0
  return emitOp<>(OP_RetPtr, L);
19385
0
}
19386
0
bool ByteCodeEmitter::emitRetFnPtr(const SourceInfo &L) {
19387
0
  return emitOp<>(OP_RetFnPtr, L);
19388
0
}
19389
0
bool ByteCodeEmitter::emitRetFloat(const SourceInfo &L) {
19390
0
  return emitOp<>(OP_RetFloat, L);
19391
0
}
19392
#endif
19393
#ifdef GET_OPCODE_NAMES
19394
OP_RetValue,
19395
#endif
19396
0
#ifdef GET_INTERP
19397
0
case OP_RetValue: {
19398
0
  bool DoReturn = (S.Current == StartFrame);
19399
0
  if (!RetValue(S, PC, Result))
19400
0
    return false;
19401
0
  if (!S.Current || S.Current->isRoot())
19402
0
    return true;
19403
0
  if (DoReturn)
19404
0
    return true;
19405
0
  continue;
19406
0
}
19407
0
#endif
19408
#ifdef GET_DISASM
19409
case OP_RetValue:
19410
  PrintName("RetValue");
19411
  OS << "\t" << "\n";
19412
  continue;
19413
#endif
19414
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19415
bool emitRetValue(const SourceInfo &);
19416
#endif
19417
#ifdef GET_LINK_IMPL
19418
0
bool ByteCodeEmitter::emitRetValue(const SourceInfo &L) {
19419
0
  return emitOp<>(OP_RetValue, L);
19420
0
}
19421
#endif
19422
#ifdef GET_OPCODE_NAMES
19423
OP_RetVoid,
19424
#endif
19425
0
#ifdef GET_INTERP
19426
0
case OP_RetVoid: {
19427
0
  bool DoReturn = (S.Current == StartFrame);
19428
0
  if (!RetVoid(S, PC, Result))
19429
0
    return false;
19430
0
  if (!S.Current || S.Current->isRoot())
19431
0
    return true;
19432
0
  if (DoReturn)
19433
0
    return true;
19434
0
  continue;
19435
0
}
19436
0
#endif
19437
#ifdef GET_DISASM
19438
case OP_RetVoid:
19439
  PrintName("RetVoid");
19440
  OS << "\t" << "\n";
19441
  continue;
19442
#endif
19443
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19444
bool emitRetVoid(const SourceInfo &);
19445
#endif
19446
#ifdef GET_LINK_IMPL
19447
0
bool ByteCodeEmitter::emitRetVoid(const SourceInfo &L) {
19448
0
  return emitOp<>(OP_RetVoid, L);
19449
0
}
19450
#endif
19451
#ifdef GET_OPCODE_NAMES
19452
OP_SetFieldSint8,
19453
OP_SetFieldUint8,
19454
OP_SetFieldSint16,
19455
OP_SetFieldUint16,
19456
OP_SetFieldSint32,
19457
OP_SetFieldUint32,
19458
OP_SetFieldSint64,
19459
OP_SetFieldUint64,
19460
OP_SetFieldIntAP,
19461
OP_SetFieldIntAPS,
19462
OP_SetFieldBool,
19463
OP_SetFieldPtr,
19464
OP_SetFieldFnPtr,
19465
OP_SetFieldFloat,
19466
#endif
19467
0
#ifdef GET_INTERP
19468
0
case OP_SetFieldSint8: {
19469
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19470
0
  if (!SetField<PT_Sint8>(S, OpPC, V0))
19471
0
    return false;
19472
0
  continue;
19473
0
}
19474
0
case OP_SetFieldUint8: {
19475
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19476
0
  if (!SetField<PT_Uint8>(S, OpPC, V0))
19477
0
    return false;
19478
0
  continue;
19479
0
}
19480
0
case OP_SetFieldSint16: {
19481
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19482
0
  if (!SetField<PT_Sint16>(S, OpPC, V0))
19483
0
    return false;
19484
0
  continue;
19485
0
}
19486
0
case OP_SetFieldUint16: {
19487
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19488
0
  if (!SetField<PT_Uint16>(S, OpPC, V0))
19489
0
    return false;
19490
0
  continue;
19491
0
}
19492
0
case OP_SetFieldSint32: {
19493
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19494
0
  if (!SetField<PT_Sint32>(S, OpPC, V0))
19495
0
    return false;
19496
0
  continue;
19497
0
}
19498
0
case OP_SetFieldUint32: {
19499
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19500
0
  if (!SetField<PT_Uint32>(S, OpPC, V0))
19501
0
    return false;
19502
0
  continue;
19503
0
}
19504
0
case OP_SetFieldSint64: {
19505
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19506
0
  if (!SetField<PT_Sint64>(S, OpPC, V0))
19507
0
    return false;
19508
0
  continue;
19509
0
}
19510
0
case OP_SetFieldUint64: {
19511
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19512
0
  if (!SetField<PT_Uint64>(S, OpPC, V0))
19513
0
    return false;
19514
0
  continue;
19515
0
}
19516
0
case OP_SetFieldIntAP: {
19517
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19518
0
  if (!SetField<PT_IntAP>(S, OpPC, V0))
19519
0
    return false;
19520
0
  continue;
19521
0
}
19522
0
case OP_SetFieldIntAPS: {
19523
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19524
0
  if (!SetField<PT_IntAPS>(S, OpPC, V0))
19525
0
    return false;
19526
0
  continue;
19527
0
}
19528
0
case OP_SetFieldBool: {
19529
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19530
0
  if (!SetField<PT_Bool>(S, OpPC, V0))
19531
0
    return false;
19532
0
  continue;
19533
0
}
19534
0
case OP_SetFieldPtr: {
19535
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19536
0
  if (!SetField<PT_Ptr>(S, OpPC, V0))
19537
0
    return false;
19538
0
  continue;
19539
0
}
19540
0
case OP_SetFieldFnPtr: {
19541
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19542
0
  if (!SetField<PT_FnPtr>(S, OpPC, V0))
19543
0
    return false;
19544
0
  continue;
19545
0
}
19546
0
case OP_SetFieldFloat: {
19547
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19548
0
  if (!SetField<PT_Float>(S, OpPC, V0))
19549
0
    return false;
19550
0
  continue;
19551
0
}
19552
0
#endif
19553
#ifdef GET_DISASM
19554
case OP_SetFieldSint8:
19555
  PrintName("SetFieldSint8");
19556
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19557
  continue;
19558
case OP_SetFieldUint8:
19559
  PrintName("SetFieldUint8");
19560
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19561
  continue;
19562
case OP_SetFieldSint16:
19563
  PrintName("SetFieldSint16");
19564
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19565
  continue;
19566
case OP_SetFieldUint16:
19567
  PrintName("SetFieldUint16");
19568
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19569
  continue;
19570
case OP_SetFieldSint32:
19571
  PrintName("SetFieldSint32");
19572
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19573
  continue;
19574
case OP_SetFieldUint32:
19575
  PrintName("SetFieldUint32");
19576
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19577
  continue;
19578
case OP_SetFieldSint64:
19579
  PrintName("SetFieldSint64");
19580
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19581
  continue;
19582
case OP_SetFieldUint64:
19583
  PrintName("SetFieldUint64");
19584
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19585
  continue;
19586
case OP_SetFieldIntAP:
19587
  PrintName("SetFieldIntAP");
19588
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19589
  continue;
19590
case OP_SetFieldIntAPS:
19591
  PrintName("SetFieldIntAPS");
19592
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19593
  continue;
19594
case OP_SetFieldBool:
19595
  PrintName("SetFieldBool");
19596
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19597
  continue;
19598
case OP_SetFieldPtr:
19599
  PrintName("SetFieldPtr");
19600
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19601
  continue;
19602
case OP_SetFieldFnPtr:
19603
  PrintName("SetFieldFnPtr");
19604
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19605
  continue;
19606
case OP_SetFieldFloat:
19607
  PrintName("SetFieldFloat");
19608
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19609
  continue;
19610
#endif
19611
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19612
bool emitSetFieldSint8(uint32_t, const SourceInfo &);
19613
bool emitSetFieldUint8(uint32_t, const SourceInfo &);
19614
bool emitSetFieldSint16(uint32_t, const SourceInfo &);
19615
bool emitSetFieldUint16(uint32_t, const SourceInfo &);
19616
bool emitSetFieldSint32(uint32_t, const SourceInfo &);
19617
bool emitSetFieldUint32(uint32_t, const SourceInfo &);
19618
bool emitSetFieldSint64(uint32_t, const SourceInfo &);
19619
bool emitSetFieldUint64(uint32_t, const SourceInfo &);
19620
bool emitSetFieldIntAP(uint32_t, const SourceInfo &);
19621
bool emitSetFieldIntAPS(uint32_t, const SourceInfo &);
19622
bool emitSetFieldBool(uint32_t, const SourceInfo &);
19623
bool emitSetFieldPtr(uint32_t, const SourceInfo &);
19624
bool emitSetFieldFnPtr(uint32_t, const SourceInfo &);
19625
bool emitSetFieldFloat(uint32_t, const SourceInfo &);
19626
#endif
19627
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19628
bool emitSetField(PrimType, uint32_t, const SourceInfo &I);
19629
#endif
19630
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
19631
bool
19632
#if defined(GET_EVAL_IMPL)
19633
EvalEmitter
19634
#else
19635
ByteCodeEmitter
19636
#endif
19637
0
::emitSetField(PrimType T0, uint32_t A0, const SourceInfo &I) {
19638
0
  switch (T0) {
19639
0
  case PT_Sint8:
19640
0
    return emitSetFieldSint8(A0, I);
19641
0
  case PT_Uint8:
19642
0
    return emitSetFieldUint8(A0, I);
19643
0
  case PT_Sint16:
19644
0
    return emitSetFieldSint16(A0, I);
19645
0
  case PT_Uint16:
19646
0
    return emitSetFieldUint16(A0, I);
19647
0
  case PT_Sint32:
19648
0
    return emitSetFieldSint32(A0, I);
19649
0
  case PT_Uint32:
19650
0
    return emitSetFieldUint32(A0, I);
19651
0
  case PT_Sint64:
19652
0
    return emitSetFieldSint64(A0, I);
19653
0
  case PT_Uint64:
19654
0
    return emitSetFieldUint64(A0, I);
19655
0
  case PT_IntAP:
19656
0
    return emitSetFieldIntAP(A0, I);
19657
0
  case PT_IntAPS:
19658
0
    return emitSetFieldIntAPS(A0, I);
19659
0
  case PT_Bool:
19660
0
    return emitSetFieldBool(A0, I);
19661
0
  case PT_Ptr:
19662
0
    return emitSetFieldPtr(A0, I);
19663
0
  case PT_FnPtr:
19664
0
    return emitSetFieldFnPtr(A0, I);
19665
0
  case PT_Float:
19666
0
    return emitSetFieldFloat(A0, I);
19667
0
  }
19668
0
  llvm_unreachable("invalid enum value");
19669
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSetField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSetField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
19670
#endif
19671
#ifdef GET_LINK_IMPL
19672
0
bool ByteCodeEmitter::emitSetFieldSint8(uint32_t A0, const SourceInfo &L) {
19673
0
  return emitOp<uint32_t>(OP_SetFieldSint8, A0, L);
19674
0
}
19675
0
bool ByteCodeEmitter::emitSetFieldUint8(uint32_t A0, const SourceInfo &L) {
19676
0
  return emitOp<uint32_t>(OP_SetFieldUint8, A0, L);
19677
0
}
19678
0
bool ByteCodeEmitter::emitSetFieldSint16(uint32_t A0, const SourceInfo &L) {
19679
0
  return emitOp<uint32_t>(OP_SetFieldSint16, A0, L);
19680
0
}
19681
0
bool ByteCodeEmitter::emitSetFieldUint16(uint32_t A0, const SourceInfo &L) {
19682
0
  return emitOp<uint32_t>(OP_SetFieldUint16, A0, L);
19683
0
}
19684
0
bool ByteCodeEmitter::emitSetFieldSint32(uint32_t A0, const SourceInfo &L) {
19685
0
  return emitOp<uint32_t>(OP_SetFieldSint32, A0, L);
19686
0
}
19687
0
bool ByteCodeEmitter::emitSetFieldUint32(uint32_t A0, const SourceInfo &L) {
19688
0
  return emitOp<uint32_t>(OP_SetFieldUint32, A0, L);
19689
0
}
19690
0
bool ByteCodeEmitter::emitSetFieldSint64(uint32_t A0, const SourceInfo &L) {
19691
0
  return emitOp<uint32_t>(OP_SetFieldSint64, A0, L);
19692
0
}
19693
0
bool ByteCodeEmitter::emitSetFieldUint64(uint32_t A0, const SourceInfo &L) {
19694
0
  return emitOp<uint32_t>(OP_SetFieldUint64, A0, L);
19695
0
}
19696
0
bool ByteCodeEmitter::emitSetFieldIntAP(uint32_t A0, const SourceInfo &L) {
19697
0
  return emitOp<uint32_t>(OP_SetFieldIntAP, A0, L);
19698
0
}
19699
0
bool ByteCodeEmitter::emitSetFieldIntAPS(uint32_t A0, const SourceInfo &L) {
19700
0
  return emitOp<uint32_t>(OP_SetFieldIntAPS, A0, L);
19701
0
}
19702
0
bool ByteCodeEmitter::emitSetFieldBool(uint32_t A0, const SourceInfo &L) {
19703
0
  return emitOp<uint32_t>(OP_SetFieldBool, A0, L);
19704
0
}
19705
0
bool ByteCodeEmitter::emitSetFieldPtr(uint32_t A0, const SourceInfo &L) {
19706
0
  return emitOp<uint32_t>(OP_SetFieldPtr, A0, L);
19707
0
}
19708
0
bool ByteCodeEmitter::emitSetFieldFnPtr(uint32_t A0, const SourceInfo &L) {
19709
0
  return emitOp<uint32_t>(OP_SetFieldFnPtr, A0, L);
19710
0
}
19711
0
bool ByteCodeEmitter::emitSetFieldFloat(uint32_t A0, const SourceInfo &L) {
19712
0
  return emitOp<uint32_t>(OP_SetFieldFloat, A0, L);
19713
0
}
19714
#endif
19715
#ifdef GET_EVAL_IMPL
19716
0
bool EvalEmitter::emitSetFieldSint8(uint32_t A0, const SourceInfo &L) {
19717
0
  if (!isActive()) return true;
19718
0
  CurrentSource = L;
19719
0
  return SetField<PT_Sint8>(S, OpPC, A0);
19720
0
}
19721
0
bool EvalEmitter::emitSetFieldUint8(uint32_t A0, const SourceInfo &L) {
19722
0
  if (!isActive()) return true;
19723
0
  CurrentSource = L;
19724
0
  return SetField<PT_Uint8>(S, OpPC, A0);
19725
0
}
19726
0
bool EvalEmitter::emitSetFieldSint16(uint32_t A0, const SourceInfo &L) {
19727
0
  if (!isActive()) return true;
19728
0
  CurrentSource = L;
19729
0
  return SetField<PT_Sint16>(S, OpPC, A0);
19730
0
}
19731
0
bool EvalEmitter::emitSetFieldUint16(uint32_t A0, const SourceInfo &L) {
19732
0
  if (!isActive()) return true;
19733
0
  CurrentSource = L;
19734
0
  return SetField<PT_Uint16>(S, OpPC, A0);
19735
0
}
19736
0
bool EvalEmitter::emitSetFieldSint32(uint32_t A0, const SourceInfo &L) {
19737
0
  if (!isActive()) return true;
19738
0
  CurrentSource = L;
19739
0
  return SetField<PT_Sint32>(S, OpPC, A0);
19740
0
}
19741
0
bool EvalEmitter::emitSetFieldUint32(uint32_t A0, const SourceInfo &L) {
19742
0
  if (!isActive()) return true;
19743
0
  CurrentSource = L;
19744
0
  return SetField<PT_Uint32>(S, OpPC, A0);
19745
0
}
19746
0
bool EvalEmitter::emitSetFieldSint64(uint32_t A0, const SourceInfo &L) {
19747
0
  if (!isActive()) return true;
19748
0
  CurrentSource = L;
19749
0
  return SetField<PT_Sint64>(S, OpPC, A0);
19750
0
}
19751
0
bool EvalEmitter::emitSetFieldUint64(uint32_t A0, const SourceInfo &L) {
19752
0
  if (!isActive()) return true;
19753
0
  CurrentSource = L;
19754
0
  return SetField<PT_Uint64>(S, OpPC, A0);
19755
0
}
19756
0
bool EvalEmitter::emitSetFieldIntAP(uint32_t A0, const SourceInfo &L) {
19757
0
  if (!isActive()) return true;
19758
0
  CurrentSource = L;
19759
0
  return SetField<PT_IntAP>(S, OpPC, A0);
19760
0
}
19761
0
bool EvalEmitter::emitSetFieldIntAPS(uint32_t A0, const SourceInfo &L) {
19762
0
  if (!isActive()) return true;
19763
0
  CurrentSource = L;
19764
0
  return SetField<PT_IntAPS>(S, OpPC, A0);
19765
0
}
19766
0
bool EvalEmitter::emitSetFieldBool(uint32_t A0, const SourceInfo &L) {
19767
0
  if (!isActive()) return true;
19768
0
  CurrentSource = L;
19769
0
  return SetField<PT_Bool>(S, OpPC, A0);
19770
0
}
19771
0
bool EvalEmitter::emitSetFieldPtr(uint32_t A0, const SourceInfo &L) {
19772
0
  if (!isActive()) return true;
19773
0
  CurrentSource = L;
19774
0
  return SetField<PT_Ptr>(S, OpPC, A0);
19775
0
}
19776
0
bool EvalEmitter::emitSetFieldFnPtr(uint32_t A0, const SourceInfo &L) {
19777
0
  if (!isActive()) return true;
19778
0
  CurrentSource = L;
19779
0
  return SetField<PT_FnPtr>(S, OpPC, A0);
19780
0
}
19781
0
bool EvalEmitter::emitSetFieldFloat(uint32_t A0, const SourceInfo &L) {
19782
0
  if (!isActive()) return true;
19783
0
  CurrentSource = L;
19784
0
  return SetField<PT_Float>(S, OpPC, A0);
19785
0
}
19786
#endif
19787
#ifdef GET_OPCODE_NAMES
19788
OP_SetGlobalSint8,
19789
OP_SetGlobalUint8,
19790
OP_SetGlobalSint16,
19791
OP_SetGlobalUint16,
19792
OP_SetGlobalSint32,
19793
OP_SetGlobalUint32,
19794
OP_SetGlobalSint64,
19795
OP_SetGlobalUint64,
19796
OP_SetGlobalIntAP,
19797
OP_SetGlobalIntAPS,
19798
OP_SetGlobalBool,
19799
OP_SetGlobalPtr,
19800
OP_SetGlobalFnPtr,
19801
OP_SetGlobalFloat,
19802
#endif
19803
0
#ifdef GET_INTERP
19804
0
case OP_SetGlobalSint8: {
19805
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19806
0
  if (!SetGlobal<PT_Sint8>(S, OpPC, V0))
19807
0
    return false;
19808
0
  continue;
19809
0
}
19810
0
case OP_SetGlobalUint8: {
19811
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19812
0
  if (!SetGlobal<PT_Uint8>(S, OpPC, V0))
19813
0
    return false;
19814
0
  continue;
19815
0
}
19816
0
case OP_SetGlobalSint16: {
19817
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19818
0
  if (!SetGlobal<PT_Sint16>(S, OpPC, V0))
19819
0
    return false;
19820
0
  continue;
19821
0
}
19822
0
case OP_SetGlobalUint16: {
19823
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19824
0
  if (!SetGlobal<PT_Uint16>(S, OpPC, V0))
19825
0
    return false;
19826
0
  continue;
19827
0
}
19828
0
case OP_SetGlobalSint32: {
19829
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19830
0
  if (!SetGlobal<PT_Sint32>(S, OpPC, V0))
19831
0
    return false;
19832
0
  continue;
19833
0
}
19834
0
case OP_SetGlobalUint32: {
19835
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19836
0
  if (!SetGlobal<PT_Uint32>(S, OpPC, V0))
19837
0
    return false;
19838
0
  continue;
19839
0
}
19840
0
case OP_SetGlobalSint64: {
19841
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19842
0
  if (!SetGlobal<PT_Sint64>(S, OpPC, V0))
19843
0
    return false;
19844
0
  continue;
19845
0
}
19846
0
case OP_SetGlobalUint64: {
19847
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19848
0
  if (!SetGlobal<PT_Uint64>(S, OpPC, V0))
19849
0
    return false;
19850
0
  continue;
19851
0
}
19852
0
case OP_SetGlobalIntAP: {
19853
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19854
0
  if (!SetGlobal<PT_IntAP>(S, OpPC, V0))
19855
0
    return false;
19856
0
  continue;
19857
0
}
19858
0
case OP_SetGlobalIntAPS: {
19859
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19860
0
  if (!SetGlobal<PT_IntAPS>(S, OpPC, V0))
19861
0
    return false;
19862
0
  continue;
19863
0
}
19864
0
case OP_SetGlobalBool: {
19865
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19866
0
  if (!SetGlobal<PT_Bool>(S, OpPC, V0))
19867
0
    return false;
19868
0
  continue;
19869
0
}
19870
0
case OP_SetGlobalPtr: {
19871
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19872
0
  if (!SetGlobal<PT_Ptr>(S, OpPC, V0))
19873
0
    return false;
19874
0
  continue;
19875
0
}
19876
0
case OP_SetGlobalFnPtr: {
19877
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19878
0
  if (!SetGlobal<PT_FnPtr>(S, OpPC, V0))
19879
0
    return false;
19880
0
  continue;
19881
0
}
19882
0
case OP_SetGlobalFloat: {
19883
0
  auto V0 = ReadArg<uint32_t>(S, PC);
19884
0
  if (!SetGlobal<PT_Float>(S, OpPC, V0))
19885
0
    return false;
19886
0
  continue;
19887
0
}
19888
0
#endif
19889
#ifdef GET_DISASM
19890
case OP_SetGlobalSint8:
19891
  PrintName("SetGlobalSint8");
19892
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19893
  continue;
19894
case OP_SetGlobalUint8:
19895
  PrintName("SetGlobalUint8");
19896
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19897
  continue;
19898
case OP_SetGlobalSint16:
19899
  PrintName("SetGlobalSint16");
19900
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19901
  continue;
19902
case OP_SetGlobalUint16:
19903
  PrintName("SetGlobalUint16");
19904
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19905
  continue;
19906
case OP_SetGlobalSint32:
19907
  PrintName("SetGlobalSint32");
19908
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19909
  continue;
19910
case OP_SetGlobalUint32:
19911
  PrintName("SetGlobalUint32");
19912
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19913
  continue;
19914
case OP_SetGlobalSint64:
19915
  PrintName("SetGlobalSint64");
19916
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19917
  continue;
19918
case OP_SetGlobalUint64:
19919
  PrintName("SetGlobalUint64");
19920
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19921
  continue;
19922
case OP_SetGlobalIntAP:
19923
  PrintName("SetGlobalIntAP");
19924
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19925
  continue;
19926
case OP_SetGlobalIntAPS:
19927
  PrintName("SetGlobalIntAPS");
19928
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19929
  continue;
19930
case OP_SetGlobalBool:
19931
  PrintName("SetGlobalBool");
19932
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19933
  continue;
19934
case OP_SetGlobalPtr:
19935
  PrintName("SetGlobalPtr");
19936
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19937
  continue;
19938
case OP_SetGlobalFnPtr:
19939
  PrintName("SetGlobalFnPtr");
19940
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19941
  continue;
19942
case OP_SetGlobalFloat:
19943
  PrintName("SetGlobalFloat");
19944
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
19945
  continue;
19946
#endif
19947
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19948
bool emitSetGlobalSint8(uint32_t, const SourceInfo &);
19949
bool emitSetGlobalUint8(uint32_t, const SourceInfo &);
19950
bool emitSetGlobalSint16(uint32_t, const SourceInfo &);
19951
bool emitSetGlobalUint16(uint32_t, const SourceInfo &);
19952
bool emitSetGlobalSint32(uint32_t, const SourceInfo &);
19953
bool emitSetGlobalUint32(uint32_t, const SourceInfo &);
19954
bool emitSetGlobalSint64(uint32_t, const SourceInfo &);
19955
bool emitSetGlobalUint64(uint32_t, const SourceInfo &);
19956
bool emitSetGlobalIntAP(uint32_t, const SourceInfo &);
19957
bool emitSetGlobalIntAPS(uint32_t, const SourceInfo &);
19958
bool emitSetGlobalBool(uint32_t, const SourceInfo &);
19959
bool emitSetGlobalPtr(uint32_t, const SourceInfo &);
19960
bool emitSetGlobalFnPtr(uint32_t, const SourceInfo &);
19961
bool emitSetGlobalFloat(uint32_t, const SourceInfo &);
19962
#endif
19963
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
19964
bool emitSetGlobal(PrimType, uint32_t, const SourceInfo &I);
19965
#endif
19966
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
19967
bool
19968
#if defined(GET_EVAL_IMPL)
19969
EvalEmitter
19970
#else
19971
ByteCodeEmitter
19972
#endif
19973
0
::emitSetGlobal(PrimType T0, uint32_t A0, const SourceInfo &I) {
19974
0
  switch (T0) {
19975
0
  case PT_Sint8:
19976
0
    return emitSetGlobalSint8(A0, I);
19977
0
  case PT_Uint8:
19978
0
    return emitSetGlobalUint8(A0, I);
19979
0
  case PT_Sint16:
19980
0
    return emitSetGlobalSint16(A0, I);
19981
0
  case PT_Uint16:
19982
0
    return emitSetGlobalUint16(A0, I);
19983
0
  case PT_Sint32:
19984
0
    return emitSetGlobalSint32(A0, I);
19985
0
  case PT_Uint32:
19986
0
    return emitSetGlobalUint32(A0, I);
19987
0
  case PT_Sint64:
19988
0
    return emitSetGlobalSint64(A0, I);
19989
0
  case PT_Uint64:
19990
0
    return emitSetGlobalUint64(A0, I);
19991
0
  case PT_IntAP:
19992
0
    return emitSetGlobalIntAP(A0, I);
19993
0
  case PT_IntAPS:
19994
0
    return emitSetGlobalIntAPS(A0, I);
19995
0
  case PT_Bool:
19996
0
    return emitSetGlobalBool(A0, I);
19997
0
  case PT_Ptr:
19998
0
    return emitSetGlobalPtr(A0, I);
19999
0
  case PT_FnPtr:
20000
0
    return emitSetGlobalFnPtr(A0, I);
20001
0
  case PT_Float:
20002
0
    return emitSetGlobalFloat(A0, I);
20003
0
  }
20004
0
  llvm_unreachable("invalid enum value");
20005
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSetGlobal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSetGlobal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
20006
#endif
20007
#ifdef GET_LINK_IMPL
20008
0
bool ByteCodeEmitter::emitSetGlobalSint8(uint32_t A0, const SourceInfo &L) {
20009
0
  return emitOp<uint32_t>(OP_SetGlobalSint8, A0, L);
20010
0
}
20011
0
bool ByteCodeEmitter::emitSetGlobalUint8(uint32_t A0, const SourceInfo &L) {
20012
0
  return emitOp<uint32_t>(OP_SetGlobalUint8, A0, L);
20013
0
}
20014
0
bool ByteCodeEmitter::emitSetGlobalSint16(uint32_t A0, const SourceInfo &L) {
20015
0
  return emitOp<uint32_t>(OP_SetGlobalSint16, A0, L);
20016
0
}
20017
0
bool ByteCodeEmitter::emitSetGlobalUint16(uint32_t A0, const SourceInfo &L) {
20018
0
  return emitOp<uint32_t>(OP_SetGlobalUint16, A0, L);
20019
0
}
20020
0
bool ByteCodeEmitter::emitSetGlobalSint32(uint32_t A0, const SourceInfo &L) {
20021
0
  return emitOp<uint32_t>(OP_SetGlobalSint32, A0, L);
20022
0
}
20023
0
bool ByteCodeEmitter::emitSetGlobalUint32(uint32_t A0, const SourceInfo &L) {
20024
0
  return emitOp<uint32_t>(OP_SetGlobalUint32, A0, L);
20025
0
}
20026
0
bool ByteCodeEmitter::emitSetGlobalSint64(uint32_t A0, const SourceInfo &L) {
20027
0
  return emitOp<uint32_t>(OP_SetGlobalSint64, A0, L);
20028
0
}
20029
0
bool ByteCodeEmitter::emitSetGlobalUint64(uint32_t A0, const SourceInfo &L) {
20030
0
  return emitOp<uint32_t>(OP_SetGlobalUint64, A0, L);
20031
0
}
20032
0
bool ByteCodeEmitter::emitSetGlobalIntAP(uint32_t A0, const SourceInfo &L) {
20033
0
  return emitOp<uint32_t>(OP_SetGlobalIntAP, A0, L);
20034
0
}
20035
0
bool ByteCodeEmitter::emitSetGlobalIntAPS(uint32_t A0, const SourceInfo &L) {
20036
0
  return emitOp<uint32_t>(OP_SetGlobalIntAPS, A0, L);
20037
0
}
20038
0
bool ByteCodeEmitter::emitSetGlobalBool(uint32_t A0, const SourceInfo &L) {
20039
0
  return emitOp<uint32_t>(OP_SetGlobalBool, A0, L);
20040
0
}
20041
0
bool ByteCodeEmitter::emitSetGlobalPtr(uint32_t A0, const SourceInfo &L) {
20042
0
  return emitOp<uint32_t>(OP_SetGlobalPtr, A0, L);
20043
0
}
20044
0
bool ByteCodeEmitter::emitSetGlobalFnPtr(uint32_t A0, const SourceInfo &L) {
20045
0
  return emitOp<uint32_t>(OP_SetGlobalFnPtr, A0, L);
20046
0
}
20047
0
bool ByteCodeEmitter::emitSetGlobalFloat(uint32_t A0, const SourceInfo &L) {
20048
0
  return emitOp<uint32_t>(OP_SetGlobalFloat, A0, L);
20049
0
}
20050
#endif
20051
#ifdef GET_EVAL_IMPL
20052
0
bool EvalEmitter::emitSetGlobalSint8(uint32_t A0, const SourceInfo &L) {
20053
0
  if (!isActive()) return true;
20054
0
  CurrentSource = L;
20055
0
  return SetGlobal<PT_Sint8>(S, OpPC, A0);
20056
0
}
20057
0
bool EvalEmitter::emitSetGlobalUint8(uint32_t A0, const SourceInfo &L) {
20058
0
  if (!isActive()) return true;
20059
0
  CurrentSource = L;
20060
0
  return SetGlobal<PT_Uint8>(S, OpPC, A0);
20061
0
}
20062
0
bool EvalEmitter::emitSetGlobalSint16(uint32_t A0, const SourceInfo &L) {
20063
0
  if (!isActive()) return true;
20064
0
  CurrentSource = L;
20065
0
  return SetGlobal<PT_Sint16>(S, OpPC, A0);
20066
0
}
20067
0
bool EvalEmitter::emitSetGlobalUint16(uint32_t A0, const SourceInfo &L) {
20068
0
  if (!isActive()) return true;
20069
0
  CurrentSource = L;
20070
0
  return SetGlobal<PT_Uint16>(S, OpPC, A0);
20071
0
}
20072
0
bool EvalEmitter::emitSetGlobalSint32(uint32_t A0, const SourceInfo &L) {
20073
0
  if (!isActive()) return true;
20074
0
  CurrentSource = L;
20075
0
  return SetGlobal<PT_Sint32>(S, OpPC, A0);
20076
0
}
20077
0
bool EvalEmitter::emitSetGlobalUint32(uint32_t A0, const SourceInfo &L) {
20078
0
  if (!isActive()) return true;
20079
0
  CurrentSource = L;
20080
0
  return SetGlobal<PT_Uint32>(S, OpPC, A0);
20081
0
}
20082
0
bool EvalEmitter::emitSetGlobalSint64(uint32_t A0, const SourceInfo &L) {
20083
0
  if (!isActive()) return true;
20084
0
  CurrentSource = L;
20085
0
  return SetGlobal<PT_Sint64>(S, OpPC, A0);
20086
0
}
20087
0
bool EvalEmitter::emitSetGlobalUint64(uint32_t A0, const SourceInfo &L) {
20088
0
  if (!isActive()) return true;
20089
0
  CurrentSource = L;
20090
0
  return SetGlobal<PT_Uint64>(S, OpPC, A0);
20091
0
}
20092
0
bool EvalEmitter::emitSetGlobalIntAP(uint32_t A0, const SourceInfo &L) {
20093
0
  if (!isActive()) return true;
20094
0
  CurrentSource = L;
20095
0
  return SetGlobal<PT_IntAP>(S, OpPC, A0);
20096
0
}
20097
0
bool EvalEmitter::emitSetGlobalIntAPS(uint32_t A0, const SourceInfo &L) {
20098
0
  if (!isActive()) return true;
20099
0
  CurrentSource = L;
20100
0
  return SetGlobal<PT_IntAPS>(S, OpPC, A0);
20101
0
}
20102
0
bool EvalEmitter::emitSetGlobalBool(uint32_t A0, const SourceInfo &L) {
20103
0
  if (!isActive()) return true;
20104
0
  CurrentSource = L;
20105
0
  return SetGlobal<PT_Bool>(S, OpPC, A0);
20106
0
}
20107
0
bool EvalEmitter::emitSetGlobalPtr(uint32_t A0, const SourceInfo &L) {
20108
0
  if (!isActive()) return true;
20109
0
  CurrentSource = L;
20110
0
  return SetGlobal<PT_Ptr>(S, OpPC, A0);
20111
0
}
20112
0
bool EvalEmitter::emitSetGlobalFnPtr(uint32_t A0, const SourceInfo &L) {
20113
0
  if (!isActive()) return true;
20114
0
  CurrentSource = L;
20115
0
  return SetGlobal<PT_FnPtr>(S, OpPC, A0);
20116
0
}
20117
0
bool EvalEmitter::emitSetGlobalFloat(uint32_t A0, const SourceInfo &L) {
20118
0
  if (!isActive()) return true;
20119
0
  CurrentSource = L;
20120
0
  return SetGlobal<PT_Float>(S, OpPC, A0);
20121
0
}
20122
#endif
20123
#ifdef GET_OPCODE_NAMES
20124
OP_SetLocalSint8,
20125
OP_SetLocalUint8,
20126
OP_SetLocalSint16,
20127
OP_SetLocalUint16,
20128
OP_SetLocalSint32,
20129
OP_SetLocalUint32,
20130
OP_SetLocalSint64,
20131
OP_SetLocalUint64,
20132
OP_SetLocalIntAP,
20133
OP_SetLocalIntAPS,
20134
OP_SetLocalBool,
20135
OP_SetLocalPtr,
20136
OP_SetLocalFnPtr,
20137
OP_SetLocalFloat,
20138
#endif
20139
0
#ifdef GET_INTERP
20140
0
case OP_SetLocalSint8: {
20141
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20142
0
  if (!SetLocal<PT_Sint8>(S, OpPC, V0))
20143
0
    return false;
20144
0
  continue;
20145
0
}
20146
0
case OP_SetLocalUint8: {
20147
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20148
0
  if (!SetLocal<PT_Uint8>(S, OpPC, V0))
20149
0
    return false;
20150
0
  continue;
20151
0
}
20152
0
case OP_SetLocalSint16: {
20153
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20154
0
  if (!SetLocal<PT_Sint16>(S, OpPC, V0))
20155
0
    return false;
20156
0
  continue;
20157
0
}
20158
0
case OP_SetLocalUint16: {
20159
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20160
0
  if (!SetLocal<PT_Uint16>(S, OpPC, V0))
20161
0
    return false;
20162
0
  continue;
20163
0
}
20164
0
case OP_SetLocalSint32: {
20165
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20166
0
  if (!SetLocal<PT_Sint32>(S, OpPC, V0))
20167
0
    return false;
20168
0
  continue;
20169
0
}
20170
0
case OP_SetLocalUint32: {
20171
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20172
0
  if (!SetLocal<PT_Uint32>(S, OpPC, V0))
20173
0
    return false;
20174
0
  continue;
20175
0
}
20176
0
case OP_SetLocalSint64: {
20177
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20178
0
  if (!SetLocal<PT_Sint64>(S, OpPC, V0))
20179
0
    return false;
20180
0
  continue;
20181
0
}
20182
0
case OP_SetLocalUint64: {
20183
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20184
0
  if (!SetLocal<PT_Uint64>(S, OpPC, V0))
20185
0
    return false;
20186
0
  continue;
20187
0
}
20188
0
case OP_SetLocalIntAP: {
20189
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20190
0
  if (!SetLocal<PT_IntAP>(S, OpPC, V0))
20191
0
    return false;
20192
0
  continue;
20193
0
}
20194
0
case OP_SetLocalIntAPS: {
20195
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20196
0
  if (!SetLocal<PT_IntAPS>(S, OpPC, V0))
20197
0
    return false;
20198
0
  continue;
20199
0
}
20200
0
case OP_SetLocalBool: {
20201
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20202
0
  if (!SetLocal<PT_Bool>(S, OpPC, V0))
20203
0
    return false;
20204
0
  continue;
20205
0
}
20206
0
case OP_SetLocalPtr: {
20207
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20208
0
  if (!SetLocal<PT_Ptr>(S, OpPC, V0))
20209
0
    return false;
20210
0
  continue;
20211
0
}
20212
0
case OP_SetLocalFnPtr: {
20213
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20214
0
  if (!SetLocal<PT_FnPtr>(S, OpPC, V0))
20215
0
    return false;
20216
0
  continue;
20217
0
}
20218
0
case OP_SetLocalFloat: {
20219
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20220
0
  if (!SetLocal<PT_Float>(S, OpPC, V0))
20221
0
    return false;
20222
0
  continue;
20223
0
}
20224
0
#endif
20225
#ifdef GET_DISASM
20226
case OP_SetLocalSint8:
20227
  PrintName("SetLocalSint8");
20228
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20229
  continue;
20230
case OP_SetLocalUint8:
20231
  PrintName("SetLocalUint8");
20232
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20233
  continue;
20234
case OP_SetLocalSint16:
20235
  PrintName("SetLocalSint16");
20236
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20237
  continue;
20238
case OP_SetLocalUint16:
20239
  PrintName("SetLocalUint16");
20240
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20241
  continue;
20242
case OP_SetLocalSint32:
20243
  PrintName("SetLocalSint32");
20244
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20245
  continue;
20246
case OP_SetLocalUint32:
20247
  PrintName("SetLocalUint32");
20248
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20249
  continue;
20250
case OP_SetLocalSint64:
20251
  PrintName("SetLocalSint64");
20252
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20253
  continue;
20254
case OP_SetLocalUint64:
20255
  PrintName("SetLocalUint64");
20256
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20257
  continue;
20258
case OP_SetLocalIntAP:
20259
  PrintName("SetLocalIntAP");
20260
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20261
  continue;
20262
case OP_SetLocalIntAPS:
20263
  PrintName("SetLocalIntAPS");
20264
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20265
  continue;
20266
case OP_SetLocalBool:
20267
  PrintName("SetLocalBool");
20268
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20269
  continue;
20270
case OP_SetLocalPtr:
20271
  PrintName("SetLocalPtr");
20272
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20273
  continue;
20274
case OP_SetLocalFnPtr:
20275
  PrintName("SetLocalFnPtr");
20276
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20277
  continue;
20278
case OP_SetLocalFloat:
20279
  PrintName("SetLocalFloat");
20280
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20281
  continue;
20282
#endif
20283
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
20284
bool emitSetLocalSint8(uint32_t, const SourceInfo &);
20285
bool emitSetLocalUint8(uint32_t, const SourceInfo &);
20286
bool emitSetLocalSint16(uint32_t, const SourceInfo &);
20287
bool emitSetLocalUint16(uint32_t, const SourceInfo &);
20288
bool emitSetLocalSint32(uint32_t, const SourceInfo &);
20289
bool emitSetLocalUint32(uint32_t, const SourceInfo &);
20290
bool emitSetLocalSint64(uint32_t, const SourceInfo &);
20291
bool emitSetLocalUint64(uint32_t, const SourceInfo &);
20292
bool emitSetLocalIntAP(uint32_t, const SourceInfo &);
20293
bool emitSetLocalIntAPS(uint32_t, const SourceInfo &);
20294
bool emitSetLocalBool(uint32_t, const SourceInfo &);
20295
bool emitSetLocalPtr(uint32_t, const SourceInfo &);
20296
bool emitSetLocalFnPtr(uint32_t, const SourceInfo &);
20297
bool emitSetLocalFloat(uint32_t, const SourceInfo &);
20298
#if defined(GET_EVAL_PROTO)
20299
template<PrimType>
20300
bool emitSetLocal(uint32_t, const SourceInfo &);
20301
#endif
20302
#endif
20303
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
20304
bool emitSetLocal(PrimType, uint32_t, const SourceInfo &I);
20305
#endif
20306
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
20307
bool
20308
#if defined(GET_EVAL_IMPL)
20309
EvalEmitter
20310
#else
20311
ByteCodeEmitter
20312
#endif
20313
0
::emitSetLocal(PrimType T0, uint32_t A0, const SourceInfo &I) {
20314
0
  switch (T0) {
20315
0
  case PT_Sint8:
20316
#ifdef GET_LINK_IMPL
20317
    return emitSetLocalSint8
20318
#else
20319
    return emitSetLocal<PT_Sint8>
20320
#endif
20321
0
      (A0, I);
20322
0
  case PT_Uint8:
20323
#ifdef GET_LINK_IMPL
20324
    return emitSetLocalUint8
20325
#else
20326
    return emitSetLocal<PT_Uint8>
20327
#endif
20328
0
      (A0, I);
20329
0
  case PT_Sint16:
20330
#ifdef GET_LINK_IMPL
20331
    return emitSetLocalSint16
20332
#else
20333
    return emitSetLocal<PT_Sint16>
20334
#endif
20335
0
      (A0, I);
20336
0
  case PT_Uint16:
20337
#ifdef GET_LINK_IMPL
20338
    return emitSetLocalUint16
20339
#else
20340
    return emitSetLocal<PT_Uint16>
20341
#endif
20342
0
      (A0, I);
20343
0
  case PT_Sint32:
20344
#ifdef GET_LINK_IMPL
20345
    return emitSetLocalSint32
20346
#else
20347
    return emitSetLocal<PT_Sint32>
20348
#endif
20349
0
      (A0, I);
20350
0
  case PT_Uint32:
20351
#ifdef GET_LINK_IMPL
20352
    return emitSetLocalUint32
20353
#else
20354
    return emitSetLocal<PT_Uint32>
20355
#endif
20356
0
      (A0, I);
20357
0
  case PT_Sint64:
20358
#ifdef GET_LINK_IMPL
20359
    return emitSetLocalSint64
20360
#else
20361
    return emitSetLocal<PT_Sint64>
20362
#endif
20363
0
      (A0, I);
20364
0
  case PT_Uint64:
20365
#ifdef GET_LINK_IMPL
20366
    return emitSetLocalUint64
20367
#else
20368
    return emitSetLocal<PT_Uint64>
20369
#endif
20370
0
      (A0, I);
20371
0
  case PT_IntAP:
20372
#ifdef GET_LINK_IMPL
20373
    return emitSetLocalIntAP
20374
#else
20375
    return emitSetLocal<PT_IntAP>
20376
#endif
20377
0
      (A0, I);
20378
0
  case PT_IntAPS:
20379
#ifdef GET_LINK_IMPL
20380
    return emitSetLocalIntAPS
20381
#else
20382
    return emitSetLocal<PT_IntAPS>
20383
#endif
20384
0
      (A0, I);
20385
0
  case PT_Bool:
20386
#ifdef GET_LINK_IMPL
20387
    return emitSetLocalBool
20388
#else
20389
    return emitSetLocal<PT_Bool>
20390
#endif
20391
0
      (A0, I);
20392
0
  case PT_Ptr:
20393
#ifdef GET_LINK_IMPL
20394
    return emitSetLocalPtr
20395
#else
20396
    return emitSetLocal<PT_Ptr>
20397
#endif
20398
0
      (A0, I);
20399
0
  case PT_FnPtr:
20400
#ifdef GET_LINK_IMPL
20401
    return emitSetLocalFnPtr
20402
#else
20403
    return emitSetLocal<PT_FnPtr>
20404
#endif
20405
0
      (A0, I);
20406
0
  case PT_Float:
20407
#ifdef GET_LINK_IMPL
20408
    return emitSetLocalFloat
20409
#else
20410
    return emitSetLocal<PT_Float>
20411
#endif
20412
0
      (A0, I);
20413
0
  }
20414
0
  llvm_unreachable("invalid enum value");
20415
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSetLocal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSetLocal(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
20416
#endif
20417
#ifdef GET_LINK_IMPL
20418
0
bool ByteCodeEmitter::emitSetLocalSint8(uint32_t A0, const SourceInfo &L) {
20419
0
  return emitOp<uint32_t>(OP_SetLocalSint8, A0, L);
20420
0
}
20421
0
bool ByteCodeEmitter::emitSetLocalUint8(uint32_t A0, const SourceInfo &L) {
20422
0
  return emitOp<uint32_t>(OP_SetLocalUint8, A0, L);
20423
0
}
20424
0
bool ByteCodeEmitter::emitSetLocalSint16(uint32_t A0, const SourceInfo &L) {
20425
0
  return emitOp<uint32_t>(OP_SetLocalSint16, A0, L);
20426
0
}
20427
0
bool ByteCodeEmitter::emitSetLocalUint16(uint32_t A0, const SourceInfo &L) {
20428
0
  return emitOp<uint32_t>(OP_SetLocalUint16, A0, L);
20429
0
}
20430
0
bool ByteCodeEmitter::emitSetLocalSint32(uint32_t A0, const SourceInfo &L) {
20431
0
  return emitOp<uint32_t>(OP_SetLocalSint32, A0, L);
20432
0
}
20433
0
bool ByteCodeEmitter::emitSetLocalUint32(uint32_t A0, const SourceInfo &L) {
20434
0
  return emitOp<uint32_t>(OP_SetLocalUint32, A0, L);
20435
0
}
20436
0
bool ByteCodeEmitter::emitSetLocalSint64(uint32_t A0, const SourceInfo &L) {
20437
0
  return emitOp<uint32_t>(OP_SetLocalSint64, A0, L);
20438
0
}
20439
0
bool ByteCodeEmitter::emitSetLocalUint64(uint32_t A0, const SourceInfo &L) {
20440
0
  return emitOp<uint32_t>(OP_SetLocalUint64, A0, L);
20441
0
}
20442
0
bool ByteCodeEmitter::emitSetLocalIntAP(uint32_t A0, const SourceInfo &L) {
20443
0
  return emitOp<uint32_t>(OP_SetLocalIntAP, A0, L);
20444
0
}
20445
0
bool ByteCodeEmitter::emitSetLocalIntAPS(uint32_t A0, const SourceInfo &L) {
20446
0
  return emitOp<uint32_t>(OP_SetLocalIntAPS, A0, L);
20447
0
}
20448
0
bool ByteCodeEmitter::emitSetLocalBool(uint32_t A0, const SourceInfo &L) {
20449
0
  return emitOp<uint32_t>(OP_SetLocalBool, A0, L);
20450
0
}
20451
0
bool ByteCodeEmitter::emitSetLocalPtr(uint32_t A0, const SourceInfo &L) {
20452
0
  return emitOp<uint32_t>(OP_SetLocalPtr, A0, L);
20453
0
}
20454
0
bool ByteCodeEmitter::emitSetLocalFnPtr(uint32_t A0, const SourceInfo &L) {
20455
0
  return emitOp<uint32_t>(OP_SetLocalFnPtr, A0, L);
20456
0
}
20457
0
bool ByteCodeEmitter::emitSetLocalFloat(uint32_t A0, const SourceInfo &L) {
20458
0
  return emitOp<uint32_t>(OP_SetLocalFloat, A0, L);
20459
0
}
20460
#endif
20461
#ifdef GET_OPCODE_NAMES
20462
OP_SetParamSint8,
20463
OP_SetParamUint8,
20464
OP_SetParamSint16,
20465
OP_SetParamUint16,
20466
OP_SetParamSint32,
20467
OP_SetParamUint32,
20468
OP_SetParamSint64,
20469
OP_SetParamUint64,
20470
OP_SetParamIntAP,
20471
OP_SetParamIntAPS,
20472
OP_SetParamBool,
20473
OP_SetParamPtr,
20474
OP_SetParamFnPtr,
20475
OP_SetParamFloat,
20476
#endif
20477
0
#ifdef GET_INTERP
20478
0
case OP_SetParamSint8: {
20479
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20480
0
  if (!SetParam<PT_Sint8>(S, OpPC, V0))
20481
0
    return false;
20482
0
  continue;
20483
0
}
20484
0
case OP_SetParamUint8: {
20485
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20486
0
  if (!SetParam<PT_Uint8>(S, OpPC, V0))
20487
0
    return false;
20488
0
  continue;
20489
0
}
20490
0
case OP_SetParamSint16: {
20491
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20492
0
  if (!SetParam<PT_Sint16>(S, OpPC, V0))
20493
0
    return false;
20494
0
  continue;
20495
0
}
20496
0
case OP_SetParamUint16: {
20497
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20498
0
  if (!SetParam<PT_Uint16>(S, OpPC, V0))
20499
0
    return false;
20500
0
  continue;
20501
0
}
20502
0
case OP_SetParamSint32: {
20503
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20504
0
  if (!SetParam<PT_Sint32>(S, OpPC, V0))
20505
0
    return false;
20506
0
  continue;
20507
0
}
20508
0
case OP_SetParamUint32: {
20509
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20510
0
  if (!SetParam<PT_Uint32>(S, OpPC, V0))
20511
0
    return false;
20512
0
  continue;
20513
0
}
20514
0
case OP_SetParamSint64: {
20515
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20516
0
  if (!SetParam<PT_Sint64>(S, OpPC, V0))
20517
0
    return false;
20518
0
  continue;
20519
0
}
20520
0
case OP_SetParamUint64: {
20521
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20522
0
  if (!SetParam<PT_Uint64>(S, OpPC, V0))
20523
0
    return false;
20524
0
  continue;
20525
0
}
20526
0
case OP_SetParamIntAP: {
20527
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20528
0
  if (!SetParam<PT_IntAP>(S, OpPC, V0))
20529
0
    return false;
20530
0
  continue;
20531
0
}
20532
0
case OP_SetParamIntAPS: {
20533
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20534
0
  if (!SetParam<PT_IntAPS>(S, OpPC, V0))
20535
0
    return false;
20536
0
  continue;
20537
0
}
20538
0
case OP_SetParamBool: {
20539
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20540
0
  if (!SetParam<PT_Bool>(S, OpPC, V0))
20541
0
    return false;
20542
0
  continue;
20543
0
}
20544
0
case OP_SetParamPtr: {
20545
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20546
0
  if (!SetParam<PT_Ptr>(S, OpPC, V0))
20547
0
    return false;
20548
0
  continue;
20549
0
}
20550
0
case OP_SetParamFnPtr: {
20551
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20552
0
  if (!SetParam<PT_FnPtr>(S, OpPC, V0))
20553
0
    return false;
20554
0
  continue;
20555
0
}
20556
0
case OP_SetParamFloat: {
20557
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20558
0
  if (!SetParam<PT_Float>(S, OpPC, V0))
20559
0
    return false;
20560
0
  continue;
20561
0
}
20562
0
#endif
20563
#ifdef GET_DISASM
20564
case OP_SetParamSint8:
20565
  PrintName("SetParamSint8");
20566
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20567
  continue;
20568
case OP_SetParamUint8:
20569
  PrintName("SetParamUint8");
20570
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20571
  continue;
20572
case OP_SetParamSint16:
20573
  PrintName("SetParamSint16");
20574
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20575
  continue;
20576
case OP_SetParamUint16:
20577
  PrintName("SetParamUint16");
20578
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20579
  continue;
20580
case OP_SetParamSint32:
20581
  PrintName("SetParamSint32");
20582
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20583
  continue;
20584
case OP_SetParamUint32:
20585
  PrintName("SetParamUint32");
20586
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20587
  continue;
20588
case OP_SetParamSint64:
20589
  PrintName("SetParamSint64");
20590
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20591
  continue;
20592
case OP_SetParamUint64:
20593
  PrintName("SetParamUint64");
20594
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20595
  continue;
20596
case OP_SetParamIntAP:
20597
  PrintName("SetParamIntAP");
20598
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20599
  continue;
20600
case OP_SetParamIntAPS:
20601
  PrintName("SetParamIntAPS");
20602
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20603
  continue;
20604
case OP_SetParamBool:
20605
  PrintName("SetParamBool");
20606
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20607
  continue;
20608
case OP_SetParamPtr:
20609
  PrintName("SetParamPtr");
20610
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20611
  continue;
20612
case OP_SetParamFnPtr:
20613
  PrintName("SetParamFnPtr");
20614
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20615
  continue;
20616
case OP_SetParamFloat:
20617
  PrintName("SetParamFloat");
20618
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20619
  continue;
20620
#endif
20621
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
20622
bool emitSetParamSint8(uint32_t, const SourceInfo &);
20623
bool emitSetParamUint8(uint32_t, const SourceInfo &);
20624
bool emitSetParamSint16(uint32_t, const SourceInfo &);
20625
bool emitSetParamUint16(uint32_t, const SourceInfo &);
20626
bool emitSetParamSint32(uint32_t, const SourceInfo &);
20627
bool emitSetParamUint32(uint32_t, const SourceInfo &);
20628
bool emitSetParamSint64(uint32_t, const SourceInfo &);
20629
bool emitSetParamUint64(uint32_t, const SourceInfo &);
20630
bool emitSetParamIntAP(uint32_t, const SourceInfo &);
20631
bool emitSetParamIntAPS(uint32_t, const SourceInfo &);
20632
bool emitSetParamBool(uint32_t, const SourceInfo &);
20633
bool emitSetParamPtr(uint32_t, const SourceInfo &);
20634
bool emitSetParamFnPtr(uint32_t, const SourceInfo &);
20635
bool emitSetParamFloat(uint32_t, const SourceInfo &);
20636
#endif
20637
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
20638
bool emitSetParam(PrimType, uint32_t, const SourceInfo &I);
20639
#endif
20640
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
20641
bool
20642
#if defined(GET_EVAL_IMPL)
20643
EvalEmitter
20644
#else
20645
ByteCodeEmitter
20646
#endif
20647
0
::emitSetParam(PrimType T0, uint32_t A0, const SourceInfo &I) {
20648
0
  switch (T0) {
20649
0
  case PT_Sint8:
20650
0
    return emitSetParamSint8(A0, I);
20651
0
  case PT_Uint8:
20652
0
    return emitSetParamUint8(A0, I);
20653
0
  case PT_Sint16:
20654
0
    return emitSetParamSint16(A0, I);
20655
0
  case PT_Uint16:
20656
0
    return emitSetParamUint16(A0, I);
20657
0
  case PT_Sint32:
20658
0
    return emitSetParamSint32(A0, I);
20659
0
  case PT_Uint32:
20660
0
    return emitSetParamUint32(A0, I);
20661
0
  case PT_Sint64:
20662
0
    return emitSetParamSint64(A0, I);
20663
0
  case PT_Uint64:
20664
0
    return emitSetParamUint64(A0, I);
20665
0
  case PT_IntAP:
20666
0
    return emitSetParamIntAP(A0, I);
20667
0
  case PT_IntAPS:
20668
0
    return emitSetParamIntAPS(A0, I);
20669
0
  case PT_Bool:
20670
0
    return emitSetParamBool(A0, I);
20671
0
  case PT_Ptr:
20672
0
    return emitSetParamPtr(A0, I);
20673
0
  case PT_FnPtr:
20674
0
    return emitSetParamFnPtr(A0, I);
20675
0
  case PT_Float:
20676
0
    return emitSetParamFloat(A0, I);
20677
0
  }
20678
0
  llvm_unreachable("invalid enum value");
20679
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSetParam(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSetParam(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
20680
#endif
20681
#ifdef GET_LINK_IMPL
20682
0
bool ByteCodeEmitter::emitSetParamSint8(uint32_t A0, const SourceInfo &L) {
20683
0
  return emitOp<uint32_t>(OP_SetParamSint8, A0, L);
20684
0
}
20685
0
bool ByteCodeEmitter::emitSetParamUint8(uint32_t A0, const SourceInfo &L) {
20686
0
  return emitOp<uint32_t>(OP_SetParamUint8, A0, L);
20687
0
}
20688
0
bool ByteCodeEmitter::emitSetParamSint16(uint32_t A0, const SourceInfo &L) {
20689
0
  return emitOp<uint32_t>(OP_SetParamSint16, A0, L);
20690
0
}
20691
0
bool ByteCodeEmitter::emitSetParamUint16(uint32_t A0, const SourceInfo &L) {
20692
0
  return emitOp<uint32_t>(OP_SetParamUint16, A0, L);
20693
0
}
20694
0
bool ByteCodeEmitter::emitSetParamSint32(uint32_t A0, const SourceInfo &L) {
20695
0
  return emitOp<uint32_t>(OP_SetParamSint32, A0, L);
20696
0
}
20697
0
bool ByteCodeEmitter::emitSetParamUint32(uint32_t A0, const SourceInfo &L) {
20698
0
  return emitOp<uint32_t>(OP_SetParamUint32, A0, L);
20699
0
}
20700
0
bool ByteCodeEmitter::emitSetParamSint64(uint32_t A0, const SourceInfo &L) {
20701
0
  return emitOp<uint32_t>(OP_SetParamSint64, A0, L);
20702
0
}
20703
0
bool ByteCodeEmitter::emitSetParamUint64(uint32_t A0, const SourceInfo &L) {
20704
0
  return emitOp<uint32_t>(OP_SetParamUint64, A0, L);
20705
0
}
20706
0
bool ByteCodeEmitter::emitSetParamIntAP(uint32_t A0, const SourceInfo &L) {
20707
0
  return emitOp<uint32_t>(OP_SetParamIntAP, A0, L);
20708
0
}
20709
0
bool ByteCodeEmitter::emitSetParamIntAPS(uint32_t A0, const SourceInfo &L) {
20710
0
  return emitOp<uint32_t>(OP_SetParamIntAPS, A0, L);
20711
0
}
20712
0
bool ByteCodeEmitter::emitSetParamBool(uint32_t A0, const SourceInfo &L) {
20713
0
  return emitOp<uint32_t>(OP_SetParamBool, A0, L);
20714
0
}
20715
0
bool ByteCodeEmitter::emitSetParamPtr(uint32_t A0, const SourceInfo &L) {
20716
0
  return emitOp<uint32_t>(OP_SetParamPtr, A0, L);
20717
0
}
20718
0
bool ByteCodeEmitter::emitSetParamFnPtr(uint32_t A0, const SourceInfo &L) {
20719
0
  return emitOp<uint32_t>(OP_SetParamFnPtr, A0, L);
20720
0
}
20721
0
bool ByteCodeEmitter::emitSetParamFloat(uint32_t A0, const SourceInfo &L) {
20722
0
  return emitOp<uint32_t>(OP_SetParamFloat, A0, L);
20723
0
}
20724
#endif
20725
#ifdef GET_EVAL_IMPL
20726
0
bool EvalEmitter::emitSetParamSint8(uint32_t A0, const SourceInfo &L) {
20727
0
  if (!isActive()) return true;
20728
0
  CurrentSource = L;
20729
0
  return SetParam<PT_Sint8>(S, OpPC, A0);
20730
0
}
20731
0
bool EvalEmitter::emitSetParamUint8(uint32_t A0, const SourceInfo &L) {
20732
0
  if (!isActive()) return true;
20733
0
  CurrentSource = L;
20734
0
  return SetParam<PT_Uint8>(S, OpPC, A0);
20735
0
}
20736
0
bool EvalEmitter::emitSetParamSint16(uint32_t A0, const SourceInfo &L) {
20737
0
  if (!isActive()) return true;
20738
0
  CurrentSource = L;
20739
0
  return SetParam<PT_Sint16>(S, OpPC, A0);
20740
0
}
20741
0
bool EvalEmitter::emitSetParamUint16(uint32_t A0, const SourceInfo &L) {
20742
0
  if (!isActive()) return true;
20743
0
  CurrentSource = L;
20744
0
  return SetParam<PT_Uint16>(S, OpPC, A0);
20745
0
}
20746
0
bool EvalEmitter::emitSetParamSint32(uint32_t A0, const SourceInfo &L) {
20747
0
  if (!isActive()) return true;
20748
0
  CurrentSource = L;
20749
0
  return SetParam<PT_Sint32>(S, OpPC, A0);
20750
0
}
20751
0
bool EvalEmitter::emitSetParamUint32(uint32_t A0, const SourceInfo &L) {
20752
0
  if (!isActive()) return true;
20753
0
  CurrentSource = L;
20754
0
  return SetParam<PT_Uint32>(S, OpPC, A0);
20755
0
}
20756
0
bool EvalEmitter::emitSetParamSint64(uint32_t A0, const SourceInfo &L) {
20757
0
  if (!isActive()) return true;
20758
0
  CurrentSource = L;
20759
0
  return SetParam<PT_Sint64>(S, OpPC, A0);
20760
0
}
20761
0
bool EvalEmitter::emitSetParamUint64(uint32_t A0, const SourceInfo &L) {
20762
0
  if (!isActive()) return true;
20763
0
  CurrentSource = L;
20764
0
  return SetParam<PT_Uint64>(S, OpPC, A0);
20765
0
}
20766
0
bool EvalEmitter::emitSetParamIntAP(uint32_t A0, const SourceInfo &L) {
20767
0
  if (!isActive()) return true;
20768
0
  CurrentSource = L;
20769
0
  return SetParam<PT_IntAP>(S, OpPC, A0);
20770
0
}
20771
0
bool EvalEmitter::emitSetParamIntAPS(uint32_t A0, const SourceInfo &L) {
20772
0
  if (!isActive()) return true;
20773
0
  CurrentSource = L;
20774
0
  return SetParam<PT_IntAPS>(S, OpPC, A0);
20775
0
}
20776
0
bool EvalEmitter::emitSetParamBool(uint32_t A0, const SourceInfo &L) {
20777
0
  if (!isActive()) return true;
20778
0
  CurrentSource = L;
20779
0
  return SetParam<PT_Bool>(S, OpPC, A0);
20780
0
}
20781
0
bool EvalEmitter::emitSetParamPtr(uint32_t A0, const SourceInfo &L) {
20782
0
  if (!isActive()) return true;
20783
0
  CurrentSource = L;
20784
0
  return SetParam<PT_Ptr>(S, OpPC, A0);
20785
0
}
20786
0
bool EvalEmitter::emitSetParamFnPtr(uint32_t A0, const SourceInfo &L) {
20787
0
  if (!isActive()) return true;
20788
0
  CurrentSource = L;
20789
0
  return SetParam<PT_FnPtr>(S, OpPC, A0);
20790
0
}
20791
0
bool EvalEmitter::emitSetParamFloat(uint32_t A0, const SourceInfo &L) {
20792
0
  if (!isActive()) return true;
20793
0
  CurrentSource = L;
20794
0
  return SetParam<PT_Float>(S, OpPC, A0);
20795
0
}
20796
#endif
20797
#ifdef GET_OPCODE_NAMES
20798
OP_SetThisFieldSint8,
20799
OP_SetThisFieldUint8,
20800
OP_SetThisFieldSint16,
20801
OP_SetThisFieldUint16,
20802
OP_SetThisFieldSint32,
20803
OP_SetThisFieldUint32,
20804
OP_SetThisFieldSint64,
20805
OP_SetThisFieldUint64,
20806
OP_SetThisFieldIntAP,
20807
OP_SetThisFieldIntAPS,
20808
OP_SetThisFieldBool,
20809
OP_SetThisFieldPtr,
20810
OP_SetThisFieldFnPtr,
20811
OP_SetThisFieldFloat,
20812
#endif
20813
0
#ifdef GET_INTERP
20814
0
case OP_SetThisFieldSint8: {
20815
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20816
0
  if (!SetThisField<PT_Sint8>(S, OpPC, V0))
20817
0
    return false;
20818
0
  continue;
20819
0
}
20820
0
case OP_SetThisFieldUint8: {
20821
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20822
0
  if (!SetThisField<PT_Uint8>(S, OpPC, V0))
20823
0
    return false;
20824
0
  continue;
20825
0
}
20826
0
case OP_SetThisFieldSint16: {
20827
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20828
0
  if (!SetThisField<PT_Sint16>(S, OpPC, V0))
20829
0
    return false;
20830
0
  continue;
20831
0
}
20832
0
case OP_SetThisFieldUint16: {
20833
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20834
0
  if (!SetThisField<PT_Uint16>(S, OpPC, V0))
20835
0
    return false;
20836
0
  continue;
20837
0
}
20838
0
case OP_SetThisFieldSint32: {
20839
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20840
0
  if (!SetThisField<PT_Sint32>(S, OpPC, V0))
20841
0
    return false;
20842
0
  continue;
20843
0
}
20844
0
case OP_SetThisFieldUint32: {
20845
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20846
0
  if (!SetThisField<PT_Uint32>(S, OpPC, V0))
20847
0
    return false;
20848
0
  continue;
20849
0
}
20850
0
case OP_SetThisFieldSint64: {
20851
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20852
0
  if (!SetThisField<PT_Sint64>(S, OpPC, V0))
20853
0
    return false;
20854
0
  continue;
20855
0
}
20856
0
case OP_SetThisFieldUint64: {
20857
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20858
0
  if (!SetThisField<PT_Uint64>(S, OpPC, V0))
20859
0
    return false;
20860
0
  continue;
20861
0
}
20862
0
case OP_SetThisFieldIntAP: {
20863
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20864
0
  if (!SetThisField<PT_IntAP>(S, OpPC, V0))
20865
0
    return false;
20866
0
  continue;
20867
0
}
20868
0
case OP_SetThisFieldIntAPS: {
20869
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20870
0
  if (!SetThisField<PT_IntAPS>(S, OpPC, V0))
20871
0
    return false;
20872
0
  continue;
20873
0
}
20874
0
case OP_SetThisFieldBool: {
20875
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20876
0
  if (!SetThisField<PT_Bool>(S, OpPC, V0))
20877
0
    return false;
20878
0
  continue;
20879
0
}
20880
0
case OP_SetThisFieldPtr: {
20881
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20882
0
  if (!SetThisField<PT_Ptr>(S, OpPC, V0))
20883
0
    return false;
20884
0
  continue;
20885
0
}
20886
0
case OP_SetThisFieldFnPtr: {
20887
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20888
0
  if (!SetThisField<PT_FnPtr>(S, OpPC, V0))
20889
0
    return false;
20890
0
  continue;
20891
0
}
20892
0
case OP_SetThisFieldFloat: {
20893
0
  auto V0 = ReadArg<uint32_t>(S, PC);
20894
0
  if (!SetThisField<PT_Float>(S, OpPC, V0))
20895
0
    return false;
20896
0
  continue;
20897
0
}
20898
0
#endif
20899
#ifdef GET_DISASM
20900
case OP_SetThisFieldSint8:
20901
  PrintName("SetThisFieldSint8");
20902
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20903
  continue;
20904
case OP_SetThisFieldUint8:
20905
  PrintName("SetThisFieldUint8");
20906
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20907
  continue;
20908
case OP_SetThisFieldSint16:
20909
  PrintName("SetThisFieldSint16");
20910
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20911
  continue;
20912
case OP_SetThisFieldUint16:
20913
  PrintName("SetThisFieldUint16");
20914
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20915
  continue;
20916
case OP_SetThisFieldSint32:
20917
  PrintName("SetThisFieldSint32");
20918
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20919
  continue;
20920
case OP_SetThisFieldUint32:
20921
  PrintName("SetThisFieldUint32");
20922
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20923
  continue;
20924
case OP_SetThisFieldSint64:
20925
  PrintName("SetThisFieldSint64");
20926
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20927
  continue;
20928
case OP_SetThisFieldUint64:
20929
  PrintName("SetThisFieldUint64");
20930
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20931
  continue;
20932
case OP_SetThisFieldIntAP:
20933
  PrintName("SetThisFieldIntAP");
20934
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20935
  continue;
20936
case OP_SetThisFieldIntAPS:
20937
  PrintName("SetThisFieldIntAPS");
20938
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20939
  continue;
20940
case OP_SetThisFieldBool:
20941
  PrintName("SetThisFieldBool");
20942
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20943
  continue;
20944
case OP_SetThisFieldPtr:
20945
  PrintName("SetThisFieldPtr");
20946
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20947
  continue;
20948
case OP_SetThisFieldFnPtr:
20949
  PrintName("SetThisFieldFnPtr");
20950
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20951
  continue;
20952
case OP_SetThisFieldFloat:
20953
  PrintName("SetThisFieldFloat");
20954
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
20955
  continue;
20956
#endif
20957
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
20958
bool emitSetThisFieldSint8(uint32_t, const SourceInfo &);
20959
bool emitSetThisFieldUint8(uint32_t, const SourceInfo &);
20960
bool emitSetThisFieldSint16(uint32_t, const SourceInfo &);
20961
bool emitSetThisFieldUint16(uint32_t, const SourceInfo &);
20962
bool emitSetThisFieldSint32(uint32_t, const SourceInfo &);
20963
bool emitSetThisFieldUint32(uint32_t, const SourceInfo &);
20964
bool emitSetThisFieldSint64(uint32_t, const SourceInfo &);
20965
bool emitSetThisFieldUint64(uint32_t, const SourceInfo &);
20966
bool emitSetThisFieldIntAP(uint32_t, const SourceInfo &);
20967
bool emitSetThisFieldIntAPS(uint32_t, const SourceInfo &);
20968
bool emitSetThisFieldBool(uint32_t, const SourceInfo &);
20969
bool emitSetThisFieldPtr(uint32_t, const SourceInfo &);
20970
bool emitSetThisFieldFnPtr(uint32_t, const SourceInfo &);
20971
bool emitSetThisFieldFloat(uint32_t, const SourceInfo &);
20972
#endif
20973
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
20974
bool emitSetThisField(PrimType, uint32_t, const SourceInfo &I);
20975
#endif
20976
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
20977
bool
20978
#if defined(GET_EVAL_IMPL)
20979
EvalEmitter
20980
#else
20981
ByteCodeEmitter
20982
#endif
20983
0
::emitSetThisField(PrimType T0, uint32_t A0, const SourceInfo &I) {
20984
0
  switch (T0) {
20985
0
  case PT_Sint8:
20986
0
    return emitSetThisFieldSint8(A0, I);
20987
0
  case PT_Uint8:
20988
0
    return emitSetThisFieldUint8(A0, I);
20989
0
  case PT_Sint16:
20990
0
    return emitSetThisFieldSint16(A0, I);
20991
0
  case PT_Uint16:
20992
0
    return emitSetThisFieldUint16(A0, I);
20993
0
  case PT_Sint32:
20994
0
    return emitSetThisFieldSint32(A0, I);
20995
0
  case PT_Uint32:
20996
0
    return emitSetThisFieldUint32(A0, I);
20997
0
  case PT_Sint64:
20998
0
    return emitSetThisFieldSint64(A0, I);
20999
0
  case PT_Uint64:
21000
0
    return emitSetThisFieldUint64(A0, I);
21001
0
  case PT_IntAP:
21002
0
    return emitSetThisFieldIntAP(A0, I);
21003
0
  case PT_IntAPS:
21004
0
    return emitSetThisFieldIntAPS(A0, I);
21005
0
  case PT_Bool:
21006
0
    return emitSetThisFieldBool(A0, I);
21007
0
  case PT_Ptr:
21008
0
    return emitSetThisFieldPtr(A0, I);
21009
0
  case PT_FnPtr:
21010
0
    return emitSetThisFieldFnPtr(A0, I);
21011
0
  case PT_Float:
21012
0
    return emitSetThisFieldFloat(A0, I);
21013
0
  }
21014
0
  llvm_unreachable("invalid enum value");
21015
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSetThisField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSetThisField(clang::interp::PrimType, unsigned int, clang::interp::SourceInfo const&)
21016
#endif
21017
#ifdef GET_LINK_IMPL
21018
0
bool ByteCodeEmitter::emitSetThisFieldSint8(uint32_t A0, const SourceInfo &L) {
21019
0
  return emitOp<uint32_t>(OP_SetThisFieldSint8, A0, L);
21020
0
}
21021
0
bool ByteCodeEmitter::emitSetThisFieldUint8(uint32_t A0, const SourceInfo &L) {
21022
0
  return emitOp<uint32_t>(OP_SetThisFieldUint8, A0, L);
21023
0
}
21024
0
bool ByteCodeEmitter::emitSetThisFieldSint16(uint32_t A0, const SourceInfo &L) {
21025
0
  return emitOp<uint32_t>(OP_SetThisFieldSint16, A0, L);
21026
0
}
21027
0
bool ByteCodeEmitter::emitSetThisFieldUint16(uint32_t A0, const SourceInfo &L) {
21028
0
  return emitOp<uint32_t>(OP_SetThisFieldUint16, A0, L);
21029
0
}
21030
0
bool ByteCodeEmitter::emitSetThisFieldSint32(uint32_t A0, const SourceInfo &L) {
21031
0
  return emitOp<uint32_t>(OP_SetThisFieldSint32, A0, L);
21032
0
}
21033
0
bool ByteCodeEmitter::emitSetThisFieldUint32(uint32_t A0, const SourceInfo &L) {
21034
0
  return emitOp<uint32_t>(OP_SetThisFieldUint32, A0, L);
21035
0
}
21036
0
bool ByteCodeEmitter::emitSetThisFieldSint64(uint32_t A0, const SourceInfo &L) {
21037
0
  return emitOp<uint32_t>(OP_SetThisFieldSint64, A0, L);
21038
0
}
21039
0
bool ByteCodeEmitter::emitSetThisFieldUint64(uint32_t A0, const SourceInfo &L) {
21040
0
  return emitOp<uint32_t>(OP_SetThisFieldUint64, A0, L);
21041
0
}
21042
0
bool ByteCodeEmitter::emitSetThisFieldIntAP(uint32_t A0, const SourceInfo &L) {
21043
0
  return emitOp<uint32_t>(OP_SetThisFieldIntAP, A0, L);
21044
0
}
21045
0
bool ByteCodeEmitter::emitSetThisFieldIntAPS(uint32_t A0, const SourceInfo &L) {
21046
0
  return emitOp<uint32_t>(OP_SetThisFieldIntAPS, A0, L);
21047
0
}
21048
0
bool ByteCodeEmitter::emitSetThisFieldBool(uint32_t A0, const SourceInfo &L) {
21049
0
  return emitOp<uint32_t>(OP_SetThisFieldBool, A0, L);
21050
0
}
21051
0
bool ByteCodeEmitter::emitSetThisFieldPtr(uint32_t A0, const SourceInfo &L) {
21052
0
  return emitOp<uint32_t>(OP_SetThisFieldPtr, A0, L);
21053
0
}
21054
0
bool ByteCodeEmitter::emitSetThisFieldFnPtr(uint32_t A0, const SourceInfo &L) {
21055
0
  return emitOp<uint32_t>(OP_SetThisFieldFnPtr, A0, L);
21056
0
}
21057
0
bool ByteCodeEmitter::emitSetThisFieldFloat(uint32_t A0, const SourceInfo &L) {
21058
0
  return emitOp<uint32_t>(OP_SetThisFieldFloat, A0, L);
21059
0
}
21060
#endif
21061
#ifdef GET_EVAL_IMPL
21062
0
bool EvalEmitter::emitSetThisFieldSint8(uint32_t A0, const SourceInfo &L) {
21063
0
  if (!isActive()) return true;
21064
0
  CurrentSource = L;
21065
0
  return SetThisField<PT_Sint8>(S, OpPC, A0);
21066
0
}
21067
0
bool EvalEmitter::emitSetThisFieldUint8(uint32_t A0, const SourceInfo &L) {
21068
0
  if (!isActive()) return true;
21069
0
  CurrentSource = L;
21070
0
  return SetThisField<PT_Uint8>(S, OpPC, A0);
21071
0
}
21072
0
bool EvalEmitter::emitSetThisFieldSint16(uint32_t A0, const SourceInfo &L) {
21073
0
  if (!isActive()) return true;
21074
0
  CurrentSource = L;
21075
0
  return SetThisField<PT_Sint16>(S, OpPC, A0);
21076
0
}
21077
0
bool EvalEmitter::emitSetThisFieldUint16(uint32_t A0, const SourceInfo &L) {
21078
0
  if (!isActive()) return true;
21079
0
  CurrentSource = L;
21080
0
  return SetThisField<PT_Uint16>(S, OpPC, A0);
21081
0
}
21082
0
bool EvalEmitter::emitSetThisFieldSint32(uint32_t A0, const SourceInfo &L) {
21083
0
  if (!isActive()) return true;
21084
0
  CurrentSource = L;
21085
0
  return SetThisField<PT_Sint32>(S, OpPC, A0);
21086
0
}
21087
0
bool EvalEmitter::emitSetThisFieldUint32(uint32_t A0, const SourceInfo &L) {
21088
0
  if (!isActive()) return true;
21089
0
  CurrentSource = L;
21090
0
  return SetThisField<PT_Uint32>(S, OpPC, A0);
21091
0
}
21092
0
bool EvalEmitter::emitSetThisFieldSint64(uint32_t A0, const SourceInfo &L) {
21093
0
  if (!isActive()) return true;
21094
0
  CurrentSource = L;
21095
0
  return SetThisField<PT_Sint64>(S, OpPC, A0);
21096
0
}
21097
0
bool EvalEmitter::emitSetThisFieldUint64(uint32_t A0, const SourceInfo &L) {
21098
0
  if (!isActive()) return true;
21099
0
  CurrentSource = L;
21100
0
  return SetThisField<PT_Uint64>(S, OpPC, A0);
21101
0
}
21102
0
bool EvalEmitter::emitSetThisFieldIntAP(uint32_t A0, const SourceInfo &L) {
21103
0
  if (!isActive()) return true;
21104
0
  CurrentSource = L;
21105
0
  return SetThisField<PT_IntAP>(S, OpPC, A0);
21106
0
}
21107
0
bool EvalEmitter::emitSetThisFieldIntAPS(uint32_t A0, const SourceInfo &L) {
21108
0
  if (!isActive()) return true;
21109
0
  CurrentSource = L;
21110
0
  return SetThisField<PT_IntAPS>(S, OpPC, A0);
21111
0
}
21112
0
bool EvalEmitter::emitSetThisFieldBool(uint32_t A0, const SourceInfo &L) {
21113
0
  if (!isActive()) return true;
21114
0
  CurrentSource = L;
21115
0
  return SetThisField<PT_Bool>(S, OpPC, A0);
21116
0
}
21117
0
bool EvalEmitter::emitSetThisFieldPtr(uint32_t A0, const SourceInfo &L) {
21118
0
  if (!isActive()) return true;
21119
0
  CurrentSource = L;
21120
0
  return SetThisField<PT_Ptr>(S, OpPC, A0);
21121
0
}
21122
0
bool EvalEmitter::emitSetThisFieldFnPtr(uint32_t A0, const SourceInfo &L) {
21123
0
  if (!isActive()) return true;
21124
0
  CurrentSource = L;
21125
0
  return SetThisField<PT_FnPtr>(S, OpPC, A0);
21126
0
}
21127
0
bool EvalEmitter::emitSetThisFieldFloat(uint32_t A0, const SourceInfo &L) {
21128
0
  if (!isActive()) return true;
21129
0
  CurrentSource = L;
21130
0
  return SetThisField<PT_Float>(S, OpPC, A0);
21131
0
}
21132
#endif
21133
#ifdef GET_OPCODE_NAMES
21134
OP_ShlSint8Sint8,
21135
OP_ShlSint8Uint8,
21136
OP_ShlSint8Sint16,
21137
OP_ShlSint8Uint16,
21138
OP_ShlSint8Sint32,
21139
OP_ShlSint8Uint32,
21140
OP_ShlSint8Sint64,
21141
OP_ShlSint8Uint64,
21142
OP_ShlSint8IntAP,
21143
OP_ShlSint8IntAPS,
21144
OP_ShlUint8Sint8,
21145
OP_ShlUint8Uint8,
21146
OP_ShlUint8Sint16,
21147
OP_ShlUint8Uint16,
21148
OP_ShlUint8Sint32,
21149
OP_ShlUint8Uint32,
21150
OP_ShlUint8Sint64,
21151
OP_ShlUint8Uint64,
21152
OP_ShlUint8IntAP,
21153
OP_ShlUint8IntAPS,
21154
OP_ShlSint16Sint8,
21155
OP_ShlSint16Uint8,
21156
OP_ShlSint16Sint16,
21157
OP_ShlSint16Uint16,
21158
OP_ShlSint16Sint32,
21159
OP_ShlSint16Uint32,
21160
OP_ShlSint16Sint64,
21161
OP_ShlSint16Uint64,
21162
OP_ShlSint16IntAP,
21163
OP_ShlSint16IntAPS,
21164
OP_ShlUint16Sint8,
21165
OP_ShlUint16Uint8,
21166
OP_ShlUint16Sint16,
21167
OP_ShlUint16Uint16,
21168
OP_ShlUint16Sint32,
21169
OP_ShlUint16Uint32,
21170
OP_ShlUint16Sint64,
21171
OP_ShlUint16Uint64,
21172
OP_ShlUint16IntAP,
21173
OP_ShlUint16IntAPS,
21174
OP_ShlSint32Sint8,
21175
OP_ShlSint32Uint8,
21176
OP_ShlSint32Sint16,
21177
OP_ShlSint32Uint16,
21178
OP_ShlSint32Sint32,
21179
OP_ShlSint32Uint32,
21180
OP_ShlSint32Sint64,
21181
OP_ShlSint32Uint64,
21182
OP_ShlSint32IntAP,
21183
OP_ShlSint32IntAPS,
21184
OP_ShlUint32Sint8,
21185
OP_ShlUint32Uint8,
21186
OP_ShlUint32Sint16,
21187
OP_ShlUint32Uint16,
21188
OP_ShlUint32Sint32,
21189
OP_ShlUint32Uint32,
21190
OP_ShlUint32Sint64,
21191
OP_ShlUint32Uint64,
21192
OP_ShlUint32IntAP,
21193
OP_ShlUint32IntAPS,
21194
OP_ShlSint64Sint8,
21195
OP_ShlSint64Uint8,
21196
OP_ShlSint64Sint16,
21197
OP_ShlSint64Uint16,
21198
OP_ShlSint64Sint32,
21199
OP_ShlSint64Uint32,
21200
OP_ShlSint64Sint64,
21201
OP_ShlSint64Uint64,
21202
OP_ShlSint64IntAP,
21203
OP_ShlSint64IntAPS,
21204
OP_ShlUint64Sint8,
21205
OP_ShlUint64Uint8,
21206
OP_ShlUint64Sint16,
21207
OP_ShlUint64Uint16,
21208
OP_ShlUint64Sint32,
21209
OP_ShlUint64Uint32,
21210
OP_ShlUint64Sint64,
21211
OP_ShlUint64Uint64,
21212
OP_ShlUint64IntAP,
21213
OP_ShlUint64IntAPS,
21214
OP_ShlIntAPSint8,
21215
OP_ShlIntAPUint8,
21216
OP_ShlIntAPSint16,
21217
OP_ShlIntAPUint16,
21218
OP_ShlIntAPSint32,
21219
OP_ShlIntAPUint32,
21220
OP_ShlIntAPSint64,
21221
OP_ShlIntAPUint64,
21222
OP_ShlIntAPIntAP,
21223
OP_ShlIntAPIntAPS,
21224
OP_ShlIntAPSSint8,
21225
OP_ShlIntAPSUint8,
21226
OP_ShlIntAPSSint16,
21227
OP_ShlIntAPSUint16,
21228
OP_ShlIntAPSSint32,
21229
OP_ShlIntAPSUint32,
21230
OP_ShlIntAPSSint64,
21231
OP_ShlIntAPSUint64,
21232
OP_ShlIntAPSIntAP,
21233
OP_ShlIntAPSIntAPS,
21234
#endif
21235
0
#ifdef GET_INTERP
21236
0
case OP_ShlSint8Sint8: {
21237
0
  if (!Shl<PT_Sint8, PT_Sint8>(S, OpPC))
21238
0
    return false;
21239
0
  continue;
21240
0
}
21241
0
case OP_ShlSint8Uint8: {
21242
0
  if (!Shl<PT_Sint8, PT_Uint8>(S, OpPC))
21243
0
    return false;
21244
0
  continue;
21245
0
}
21246
0
case OP_ShlSint8Sint16: {
21247
0
  if (!Shl<PT_Sint8, PT_Sint16>(S, OpPC))
21248
0
    return false;
21249
0
  continue;
21250
0
}
21251
0
case OP_ShlSint8Uint16: {
21252
0
  if (!Shl<PT_Sint8, PT_Uint16>(S, OpPC))
21253
0
    return false;
21254
0
  continue;
21255
0
}
21256
0
case OP_ShlSint8Sint32: {
21257
0
  if (!Shl<PT_Sint8, PT_Sint32>(S, OpPC))
21258
0
    return false;
21259
0
  continue;
21260
0
}
21261
0
case OP_ShlSint8Uint32: {
21262
0
  if (!Shl<PT_Sint8, PT_Uint32>(S, OpPC))
21263
0
    return false;
21264
0
  continue;
21265
0
}
21266
0
case OP_ShlSint8Sint64: {
21267
0
  if (!Shl<PT_Sint8, PT_Sint64>(S, OpPC))
21268
0
    return false;
21269
0
  continue;
21270
0
}
21271
0
case OP_ShlSint8Uint64: {
21272
0
  if (!Shl<PT_Sint8, PT_Uint64>(S, OpPC))
21273
0
    return false;
21274
0
  continue;
21275
0
}
21276
0
case OP_ShlSint8IntAP: {
21277
0
  if (!Shl<PT_Sint8, PT_IntAP>(S, OpPC))
21278
0
    return false;
21279
0
  continue;
21280
0
}
21281
0
case OP_ShlSint8IntAPS: {
21282
0
  if (!Shl<PT_Sint8, PT_IntAPS>(S, OpPC))
21283
0
    return false;
21284
0
  continue;
21285
0
}
21286
0
case OP_ShlUint8Sint8: {
21287
0
  if (!Shl<PT_Uint8, PT_Sint8>(S, OpPC))
21288
0
    return false;
21289
0
  continue;
21290
0
}
21291
0
case OP_ShlUint8Uint8: {
21292
0
  if (!Shl<PT_Uint8, PT_Uint8>(S, OpPC))
21293
0
    return false;
21294
0
  continue;
21295
0
}
21296
0
case OP_ShlUint8Sint16: {
21297
0
  if (!Shl<PT_Uint8, PT_Sint16>(S, OpPC))
21298
0
    return false;
21299
0
  continue;
21300
0
}
21301
0
case OP_ShlUint8Uint16: {
21302
0
  if (!Shl<PT_Uint8, PT_Uint16>(S, OpPC))
21303
0
    return false;
21304
0
  continue;
21305
0
}
21306
0
case OP_ShlUint8Sint32: {
21307
0
  if (!Shl<PT_Uint8, PT_Sint32>(S, OpPC))
21308
0
    return false;
21309
0
  continue;
21310
0
}
21311
0
case OP_ShlUint8Uint32: {
21312
0
  if (!Shl<PT_Uint8, PT_Uint32>(S, OpPC))
21313
0
    return false;
21314
0
  continue;
21315
0
}
21316
0
case OP_ShlUint8Sint64: {
21317
0
  if (!Shl<PT_Uint8, PT_Sint64>(S, OpPC))
21318
0
    return false;
21319
0
  continue;
21320
0
}
21321
0
case OP_ShlUint8Uint64: {
21322
0
  if (!Shl<PT_Uint8, PT_Uint64>(S, OpPC))
21323
0
    return false;
21324
0
  continue;
21325
0
}
21326
0
case OP_ShlUint8IntAP: {
21327
0
  if (!Shl<PT_Uint8, PT_IntAP>(S, OpPC))
21328
0
    return false;
21329
0
  continue;
21330
0
}
21331
0
case OP_ShlUint8IntAPS: {
21332
0
  if (!Shl<PT_Uint8, PT_IntAPS>(S, OpPC))
21333
0
    return false;
21334
0
  continue;
21335
0
}
21336
0
case OP_ShlSint16Sint8: {
21337
0
  if (!Shl<PT_Sint16, PT_Sint8>(S, OpPC))
21338
0
    return false;
21339
0
  continue;
21340
0
}
21341
0
case OP_ShlSint16Uint8: {
21342
0
  if (!Shl<PT_Sint16, PT_Uint8>(S, OpPC))
21343
0
    return false;
21344
0
  continue;
21345
0
}
21346
0
case OP_ShlSint16Sint16: {
21347
0
  if (!Shl<PT_Sint16, PT_Sint16>(S, OpPC))
21348
0
    return false;
21349
0
  continue;
21350
0
}
21351
0
case OP_ShlSint16Uint16: {
21352
0
  if (!Shl<PT_Sint16, PT_Uint16>(S, OpPC))
21353
0
    return false;
21354
0
  continue;
21355
0
}
21356
0
case OP_ShlSint16Sint32: {
21357
0
  if (!Shl<PT_Sint16, PT_Sint32>(S, OpPC))
21358
0
    return false;
21359
0
  continue;
21360
0
}
21361
0
case OP_ShlSint16Uint32: {
21362
0
  if (!Shl<PT_Sint16, PT_Uint32>(S, OpPC))
21363
0
    return false;
21364
0
  continue;
21365
0
}
21366
0
case OP_ShlSint16Sint64: {
21367
0
  if (!Shl<PT_Sint16, PT_Sint64>(S, OpPC))
21368
0
    return false;
21369
0
  continue;
21370
0
}
21371
0
case OP_ShlSint16Uint64: {
21372
0
  if (!Shl<PT_Sint16, PT_Uint64>(S, OpPC))
21373
0
    return false;
21374
0
  continue;
21375
0
}
21376
0
case OP_ShlSint16IntAP: {
21377
0
  if (!Shl<PT_Sint16, PT_IntAP>(S, OpPC))
21378
0
    return false;
21379
0
  continue;
21380
0
}
21381
0
case OP_ShlSint16IntAPS: {
21382
0
  if (!Shl<PT_Sint16, PT_IntAPS>(S, OpPC))
21383
0
    return false;
21384
0
  continue;
21385
0
}
21386
0
case OP_ShlUint16Sint8: {
21387
0
  if (!Shl<PT_Uint16, PT_Sint8>(S, OpPC))
21388
0
    return false;
21389
0
  continue;
21390
0
}
21391
0
case OP_ShlUint16Uint8: {
21392
0
  if (!Shl<PT_Uint16, PT_Uint8>(S, OpPC))
21393
0
    return false;
21394
0
  continue;
21395
0
}
21396
0
case OP_ShlUint16Sint16: {
21397
0
  if (!Shl<PT_Uint16, PT_Sint16>(S, OpPC))
21398
0
    return false;
21399
0
  continue;
21400
0
}
21401
0
case OP_ShlUint16Uint16: {
21402
0
  if (!Shl<PT_Uint16, PT_Uint16>(S, OpPC))
21403
0
    return false;
21404
0
  continue;
21405
0
}
21406
0
case OP_ShlUint16Sint32: {
21407
0
  if (!Shl<PT_Uint16, PT_Sint32>(S, OpPC))
21408
0
    return false;
21409
0
  continue;
21410
0
}
21411
0
case OP_ShlUint16Uint32: {
21412
0
  if (!Shl<PT_Uint16, PT_Uint32>(S, OpPC))
21413
0
    return false;
21414
0
  continue;
21415
0
}
21416
0
case OP_ShlUint16Sint64: {
21417
0
  if (!Shl<PT_Uint16, PT_Sint64>(S, OpPC))
21418
0
    return false;
21419
0
  continue;
21420
0
}
21421
0
case OP_ShlUint16Uint64: {
21422
0
  if (!Shl<PT_Uint16, PT_Uint64>(S, OpPC))
21423
0
    return false;
21424
0
  continue;
21425
0
}
21426
0
case OP_ShlUint16IntAP: {
21427
0
  if (!Shl<PT_Uint16, PT_IntAP>(S, OpPC))
21428
0
    return false;
21429
0
  continue;
21430
0
}
21431
0
case OP_ShlUint16IntAPS: {
21432
0
  if (!Shl<PT_Uint16, PT_IntAPS>(S, OpPC))
21433
0
    return false;
21434
0
  continue;
21435
0
}
21436
0
case OP_ShlSint32Sint8: {
21437
0
  if (!Shl<PT_Sint32, PT_Sint8>(S, OpPC))
21438
0
    return false;
21439
0
  continue;
21440
0
}
21441
0
case OP_ShlSint32Uint8: {
21442
0
  if (!Shl<PT_Sint32, PT_Uint8>(S, OpPC))
21443
0
    return false;
21444
0
  continue;
21445
0
}
21446
0
case OP_ShlSint32Sint16: {
21447
0
  if (!Shl<PT_Sint32, PT_Sint16>(S, OpPC))
21448
0
    return false;
21449
0
  continue;
21450
0
}
21451
0
case OP_ShlSint32Uint16: {
21452
0
  if (!Shl<PT_Sint32, PT_Uint16>(S, OpPC))
21453
0
    return false;
21454
0
  continue;
21455
0
}
21456
0
case OP_ShlSint32Sint32: {
21457
0
  if (!Shl<PT_Sint32, PT_Sint32>(S, OpPC))
21458
0
    return false;
21459
0
  continue;
21460
0
}
21461
0
case OP_ShlSint32Uint32: {
21462
0
  if (!Shl<PT_Sint32, PT_Uint32>(S, OpPC))
21463
0
    return false;
21464
0
  continue;
21465
0
}
21466
0
case OP_ShlSint32Sint64: {
21467
0
  if (!Shl<PT_Sint32, PT_Sint64>(S, OpPC))
21468
0
    return false;
21469
0
  continue;
21470
0
}
21471
0
case OP_ShlSint32Uint64: {
21472
0
  if (!Shl<PT_Sint32, PT_Uint64>(S, OpPC))
21473
0
    return false;
21474
0
  continue;
21475
0
}
21476
0
case OP_ShlSint32IntAP: {
21477
0
  if (!Shl<PT_Sint32, PT_IntAP>(S, OpPC))
21478
0
    return false;
21479
0
  continue;
21480
0
}
21481
0
case OP_ShlSint32IntAPS: {
21482
0
  if (!Shl<PT_Sint32, PT_IntAPS>(S, OpPC))
21483
0
    return false;
21484
0
  continue;
21485
0
}
21486
0
case OP_ShlUint32Sint8: {
21487
0
  if (!Shl<PT_Uint32, PT_Sint8>(S, OpPC))
21488
0
    return false;
21489
0
  continue;
21490
0
}
21491
0
case OP_ShlUint32Uint8: {
21492
0
  if (!Shl<PT_Uint32, PT_Uint8>(S, OpPC))
21493
0
    return false;
21494
0
  continue;
21495
0
}
21496
0
case OP_ShlUint32Sint16: {
21497
0
  if (!Shl<PT_Uint32, PT_Sint16>(S, OpPC))
21498
0
    return false;
21499
0
  continue;
21500
0
}
21501
0
case OP_ShlUint32Uint16: {
21502
0
  if (!Shl<PT_Uint32, PT_Uint16>(S, OpPC))
21503
0
    return false;
21504
0
  continue;
21505
0
}
21506
0
case OP_ShlUint32Sint32: {
21507
0
  if (!Shl<PT_Uint32, PT_Sint32>(S, OpPC))
21508
0
    return false;
21509
0
  continue;
21510
0
}
21511
0
case OP_ShlUint32Uint32: {
21512
0
  if (!Shl<PT_Uint32, PT_Uint32>(S, OpPC))
21513
0
    return false;
21514
0
  continue;
21515
0
}
21516
0
case OP_ShlUint32Sint64: {
21517
0
  if (!Shl<PT_Uint32, PT_Sint64>(S, OpPC))
21518
0
    return false;
21519
0
  continue;
21520
0
}
21521
0
case OP_ShlUint32Uint64: {
21522
0
  if (!Shl<PT_Uint32, PT_Uint64>(S, OpPC))
21523
0
    return false;
21524
0
  continue;
21525
0
}
21526
0
case OP_ShlUint32IntAP: {
21527
0
  if (!Shl<PT_Uint32, PT_IntAP>(S, OpPC))
21528
0
    return false;
21529
0
  continue;
21530
0
}
21531
0
case OP_ShlUint32IntAPS: {
21532
0
  if (!Shl<PT_Uint32, PT_IntAPS>(S, OpPC))
21533
0
    return false;
21534
0
  continue;
21535
0
}
21536
0
case OP_ShlSint64Sint8: {
21537
0
  if (!Shl<PT_Sint64, PT_Sint8>(S, OpPC))
21538
0
    return false;
21539
0
  continue;
21540
0
}
21541
0
case OP_ShlSint64Uint8: {
21542
0
  if (!Shl<PT_Sint64, PT_Uint8>(S, OpPC))
21543
0
    return false;
21544
0
  continue;
21545
0
}
21546
0
case OP_ShlSint64Sint16: {
21547
0
  if (!Shl<PT_Sint64, PT_Sint16>(S, OpPC))
21548
0
    return false;
21549
0
  continue;
21550
0
}
21551
0
case OP_ShlSint64Uint16: {
21552
0
  if (!Shl<PT_Sint64, PT_Uint16>(S, OpPC))
21553
0
    return false;
21554
0
  continue;
21555
0
}
21556
0
case OP_ShlSint64Sint32: {
21557
0
  if (!Shl<PT_Sint64, PT_Sint32>(S, OpPC))
21558
0
    return false;
21559
0
  continue;
21560
0
}
21561
0
case OP_ShlSint64Uint32: {
21562
0
  if (!Shl<PT_Sint64, PT_Uint32>(S, OpPC))
21563
0
    return false;
21564
0
  continue;
21565
0
}
21566
0
case OP_ShlSint64Sint64: {
21567
0
  if (!Shl<PT_Sint64, PT_Sint64>(S, OpPC))
21568
0
    return false;
21569
0
  continue;
21570
0
}
21571
0
case OP_ShlSint64Uint64: {
21572
0
  if (!Shl<PT_Sint64, PT_Uint64>(S, OpPC))
21573
0
    return false;
21574
0
  continue;
21575
0
}
21576
0
case OP_ShlSint64IntAP: {
21577
0
  if (!Shl<PT_Sint64, PT_IntAP>(S, OpPC))
21578
0
    return false;
21579
0
  continue;
21580
0
}
21581
0
case OP_ShlSint64IntAPS: {
21582
0
  if (!Shl<PT_Sint64, PT_IntAPS>(S, OpPC))
21583
0
    return false;
21584
0
  continue;
21585
0
}
21586
0
case OP_ShlUint64Sint8: {
21587
0
  if (!Shl<PT_Uint64, PT_Sint8>(S, OpPC))
21588
0
    return false;
21589
0
  continue;
21590
0
}
21591
0
case OP_ShlUint64Uint8: {
21592
0
  if (!Shl<PT_Uint64, PT_Uint8>(S, OpPC))
21593
0
    return false;
21594
0
  continue;
21595
0
}
21596
0
case OP_ShlUint64Sint16: {
21597
0
  if (!Shl<PT_Uint64, PT_Sint16>(S, OpPC))
21598
0
    return false;
21599
0
  continue;
21600
0
}
21601
0
case OP_ShlUint64Uint16: {
21602
0
  if (!Shl<PT_Uint64, PT_Uint16>(S, OpPC))
21603
0
    return false;
21604
0
  continue;
21605
0
}
21606
0
case OP_ShlUint64Sint32: {
21607
0
  if (!Shl<PT_Uint64, PT_Sint32>(S, OpPC))
21608
0
    return false;
21609
0
  continue;
21610
0
}
21611
0
case OP_ShlUint64Uint32: {
21612
0
  if (!Shl<PT_Uint64, PT_Uint32>(S, OpPC))
21613
0
    return false;
21614
0
  continue;
21615
0
}
21616
0
case OP_ShlUint64Sint64: {
21617
0
  if (!Shl<PT_Uint64, PT_Sint64>(S, OpPC))
21618
0
    return false;
21619
0
  continue;
21620
0
}
21621
0
case OP_ShlUint64Uint64: {
21622
0
  if (!Shl<PT_Uint64, PT_Uint64>(S, OpPC))
21623
0
    return false;
21624
0
  continue;
21625
0
}
21626
0
case OP_ShlUint64IntAP: {
21627
0
  if (!Shl<PT_Uint64, PT_IntAP>(S, OpPC))
21628
0
    return false;
21629
0
  continue;
21630
0
}
21631
0
case OP_ShlUint64IntAPS: {
21632
0
  if (!Shl<PT_Uint64, PT_IntAPS>(S, OpPC))
21633
0
    return false;
21634
0
  continue;
21635
0
}
21636
0
case OP_ShlIntAPSint8: {
21637
0
  if (!Shl<PT_IntAP, PT_Sint8>(S, OpPC))
21638
0
    return false;
21639
0
  continue;
21640
0
}
21641
0
case OP_ShlIntAPUint8: {
21642
0
  if (!Shl<PT_IntAP, PT_Uint8>(S, OpPC))
21643
0
    return false;
21644
0
  continue;
21645
0
}
21646
0
case OP_ShlIntAPSint16: {
21647
0
  if (!Shl<PT_IntAP, PT_Sint16>(S, OpPC))
21648
0
    return false;
21649
0
  continue;
21650
0
}
21651
0
case OP_ShlIntAPUint16: {
21652
0
  if (!Shl<PT_IntAP, PT_Uint16>(S, OpPC))
21653
0
    return false;
21654
0
  continue;
21655
0
}
21656
0
case OP_ShlIntAPSint32: {
21657
0
  if (!Shl<PT_IntAP, PT_Sint32>(S, OpPC))
21658
0
    return false;
21659
0
  continue;
21660
0
}
21661
0
case OP_ShlIntAPUint32: {
21662
0
  if (!Shl<PT_IntAP, PT_Uint32>(S, OpPC))
21663
0
    return false;
21664
0
  continue;
21665
0
}
21666
0
case OP_ShlIntAPSint64: {
21667
0
  if (!Shl<PT_IntAP, PT_Sint64>(S, OpPC))
21668
0
    return false;
21669
0
  continue;
21670
0
}
21671
0
case OP_ShlIntAPUint64: {
21672
0
  if (!Shl<PT_IntAP, PT_Uint64>(S, OpPC))
21673
0
    return false;
21674
0
  continue;
21675
0
}
21676
0
case OP_ShlIntAPIntAP: {
21677
0
  if (!Shl<PT_IntAP, PT_IntAP>(S, OpPC))
21678
0
    return false;
21679
0
  continue;
21680
0
}
21681
0
case OP_ShlIntAPIntAPS: {
21682
0
  if (!Shl<PT_IntAP, PT_IntAPS>(S, OpPC))
21683
0
    return false;
21684
0
  continue;
21685
0
}
21686
0
case OP_ShlIntAPSSint8: {
21687
0
  if (!Shl<PT_IntAPS, PT_Sint8>(S, OpPC))
21688
0
    return false;
21689
0
  continue;
21690
0
}
21691
0
case OP_ShlIntAPSUint8: {
21692
0
  if (!Shl<PT_IntAPS, PT_Uint8>(S, OpPC))
21693
0
    return false;
21694
0
  continue;
21695
0
}
21696
0
case OP_ShlIntAPSSint16: {
21697
0
  if (!Shl<PT_IntAPS, PT_Sint16>(S, OpPC))
21698
0
    return false;
21699
0
  continue;
21700
0
}
21701
0
case OP_ShlIntAPSUint16: {
21702
0
  if (!Shl<PT_IntAPS, PT_Uint16>(S, OpPC))
21703
0
    return false;
21704
0
  continue;
21705
0
}
21706
0
case OP_ShlIntAPSSint32: {
21707
0
  if (!Shl<PT_IntAPS, PT_Sint32>(S, OpPC))
21708
0
    return false;
21709
0
  continue;
21710
0
}
21711
0
case OP_ShlIntAPSUint32: {
21712
0
  if (!Shl<PT_IntAPS, PT_Uint32>(S, OpPC))
21713
0
    return false;
21714
0
  continue;
21715
0
}
21716
0
case OP_ShlIntAPSSint64: {
21717
0
  if (!Shl<PT_IntAPS, PT_Sint64>(S, OpPC))
21718
0
    return false;
21719
0
  continue;
21720
0
}
21721
0
case OP_ShlIntAPSUint64: {
21722
0
  if (!Shl<PT_IntAPS, PT_Uint64>(S, OpPC))
21723
0
    return false;
21724
0
  continue;
21725
0
}
21726
0
case OP_ShlIntAPSIntAP: {
21727
0
  if (!Shl<PT_IntAPS, PT_IntAP>(S, OpPC))
21728
0
    return false;
21729
0
  continue;
21730
0
}
21731
0
case OP_ShlIntAPSIntAPS: {
21732
0
  if (!Shl<PT_IntAPS, PT_IntAPS>(S, OpPC))
21733
0
    return false;
21734
0
  continue;
21735
0
}
21736
0
#endif
21737
#ifdef GET_DISASM
21738
case OP_ShlSint8Sint8:
21739
  PrintName("ShlSint8Sint8");
21740
  OS << "\t" << "\n";
21741
  continue;
21742
case OP_ShlSint8Uint8:
21743
  PrintName("ShlSint8Uint8");
21744
  OS << "\t" << "\n";
21745
  continue;
21746
case OP_ShlSint8Sint16:
21747
  PrintName("ShlSint8Sint16");
21748
  OS << "\t" << "\n";
21749
  continue;
21750
case OP_ShlSint8Uint16:
21751
  PrintName("ShlSint8Uint16");
21752
  OS << "\t" << "\n";
21753
  continue;
21754
case OP_ShlSint8Sint32:
21755
  PrintName("ShlSint8Sint32");
21756
  OS << "\t" << "\n";
21757
  continue;
21758
case OP_ShlSint8Uint32:
21759
  PrintName("ShlSint8Uint32");
21760
  OS << "\t" << "\n";
21761
  continue;
21762
case OP_ShlSint8Sint64:
21763
  PrintName("ShlSint8Sint64");
21764
  OS << "\t" << "\n";
21765
  continue;
21766
case OP_ShlSint8Uint64:
21767
  PrintName("ShlSint8Uint64");
21768
  OS << "\t" << "\n";
21769
  continue;
21770
case OP_ShlSint8IntAP:
21771
  PrintName("ShlSint8IntAP");
21772
  OS << "\t" << "\n";
21773
  continue;
21774
case OP_ShlSint8IntAPS:
21775
  PrintName("ShlSint8IntAPS");
21776
  OS << "\t" << "\n";
21777
  continue;
21778
case OP_ShlUint8Sint8:
21779
  PrintName("ShlUint8Sint8");
21780
  OS << "\t" << "\n";
21781
  continue;
21782
case OP_ShlUint8Uint8:
21783
  PrintName("ShlUint8Uint8");
21784
  OS << "\t" << "\n";
21785
  continue;
21786
case OP_ShlUint8Sint16:
21787
  PrintName("ShlUint8Sint16");
21788
  OS << "\t" << "\n";
21789
  continue;
21790
case OP_ShlUint8Uint16:
21791
  PrintName("ShlUint8Uint16");
21792
  OS << "\t" << "\n";
21793
  continue;
21794
case OP_ShlUint8Sint32:
21795
  PrintName("ShlUint8Sint32");
21796
  OS << "\t" << "\n";
21797
  continue;
21798
case OP_ShlUint8Uint32:
21799
  PrintName("ShlUint8Uint32");
21800
  OS << "\t" << "\n";
21801
  continue;
21802
case OP_ShlUint8Sint64:
21803
  PrintName("ShlUint8Sint64");
21804
  OS << "\t" << "\n";
21805
  continue;
21806
case OP_ShlUint8Uint64:
21807
  PrintName("ShlUint8Uint64");
21808
  OS << "\t" << "\n";
21809
  continue;
21810
case OP_ShlUint8IntAP:
21811
  PrintName("ShlUint8IntAP");
21812
  OS << "\t" << "\n";
21813
  continue;
21814
case OP_ShlUint8IntAPS:
21815
  PrintName("ShlUint8IntAPS");
21816
  OS << "\t" << "\n";
21817
  continue;
21818
case OP_ShlSint16Sint8:
21819
  PrintName("ShlSint16Sint8");
21820
  OS << "\t" << "\n";
21821
  continue;
21822
case OP_ShlSint16Uint8:
21823
  PrintName("ShlSint16Uint8");
21824
  OS << "\t" << "\n";
21825
  continue;
21826
case OP_ShlSint16Sint16:
21827
  PrintName("ShlSint16Sint16");
21828
  OS << "\t" << "\n";
21829
  continue;
21830
case OP_ShlSint16Uint16:
21831
  PrintName("ShlSint16Uint16");
21832
  OS << "\t" << "\n";
21833
  continue;
21834
case OP_ShlSint16Sint32:
21835
  PrintName("ShlSint16Sint32");
21836
  OS << "\t" << "\n";
21837
  continue;
21838
case OP_ShlSint16Uint32:
21839
  PrintName("ShlSint16Uint32");
21840
  OS << "\t" << "\n";
21841
  continue;
21842
case OP_ShlSint16Sint64:
21843
  PrintName("ShlSint16Sint64");
21844
  OS << "\t" << "\n";
21845
  continue;
21846
case OP_ShlSint16Uint64:
21847
  PrintName("ShlSint16Uint64");
21848
  OS << "\t" << "\n";
21849
  continue;
21850
case OP_ShlSint16IntAP:
21851
  PrintName("ShlSint16IntAP");
21852
  OS << "\t" << "\n";
21853
  continue;
21854
case OP_ShlSint16IntAPS:
21855
  PrintName("ShlSint16IntAPS");
21856
  OS << "\t" << "\n";
21857
  continue;
21858
case OP_ShlUint16Sint8:
21859
  PrintName("ShlUint16Sint8");
21860
  OS << "\t" << "\n";
21861
  continue;
21862
case OP_ShlUint16Uint8:
21863
  PrintName("ShlUint16Uint8");
21864
  OS << "\t" << "\n";
21865
  continue;
21866
case OP_ShlUint16Sint16:
21867
  PrintName("ShlUint16Sint16");
21868
  OS << "\t" << "\n";
21869
  continue;
21870
case OP_ShlUint16Uint16:
21871
  PrintName("ShlUint16Uint16");
21872
  OS << "\t" << "\n";
21873
  continue;
21874
case OP_ShlUint16Sint32:
21875
  PrintName("ShlUint16Sint32");
21876
  OS << "\t" << "\n";
21877
  continue;
21878
case OP_ShlUint16Uint32:
21879
  PrintName("ShlUint16Uint32");
21880
  OS << "\t" << "\n";
21881
  continue;
21882
case OP_ShlUint16Sint64:
21883
  PrintName("ShlUint16Sint64");
21884
  OS << "\t" << "\n";
21885
  continue;
21886
case OP_ShlUint16Uint64:
21887
  PrintName("ShlUint16Uint64");
21888
  OS << "\t" << "\n";
21889
  continue;
21890
case OP_ShlUint16IntAP:
21891
  PrintName("ShlUint16IntAP");
21892
  OS << "\t" << "\n";
21893
  continue;
21894
case OP_ShlUint16IntAPS:
21895
  PrintName("ShlUint16IntAPS");
21896
  OS << "\t" << "\n";
21897
  continue;
21898
case OP_ShlSint32Sint8:
21899
  PrintName("ShlSint32Sint8");
21900
  OS << "\t" << "\n";
21901
  continue;
21902
case OP_ShlSint32Uint8:
21903
  PrintName("ShlSint32Uint8");
21904
  OS << "\t" << "\n";
21905
  continue;
21906
case OP_ShlSint32Sint16:
21907
  PrintName("ShlSint32Sint16");
21908
  OS << "\t" << "\n";
21909
  continue;
21910
case OP_ShlSint32Uint16:
21911
  PrintName("ShlSint32Uint16");
21912
  OS << "\t" << "\n";
21913
  continue;
21914
case OP_ShlSint32Sint32:
21915
  PrintName("ShlSint32Sint32");
21916
  OS << "\t" << "\n";
21917
  continue;
21918
case OP_ShlSint32Uint32:
21919
  PrintName("ShlSint32Uint32");
21920
  OS << "\t" << "\n";
21921
  continue;
21922
case OP_ShlSint32Sint64:
21923
  PrintName("ShlSint32Sint64");
21924
  OS << "\t" << "\n";
21925
  continue;
21926
case OP_ShlSint32Uint64:
21927
  PrintName("ShlSint32Uint64");
21928
  OS << "\t" << "\n";
21929
  continue;
21930
case OP_ShlSint32IntAP:
21931
  PrintName("ShlSint32IntAP");
21932
  OS << "\t" << "\n";
21933
  continue;
21934
case OP_ShlSint32IntAPS:
21935
  PrintName("ShlSint32IntAPS");
21936
  OS << "\t" << "\n";
21937
  continue;
21938
case OP_ShlUint32Sint8:
21939
  PrintName("ShlUint32Sint8");
21940
  OS << "\t" << "\n";
21941
  continue;
21942
case OP_ShlUint32Uint8:
21943
  PrintName("ShlUint32Uint8");
21944
  OS << "\t" << "\n";
21945
  continue;
21946
case OP_ShlUint32Sint16:
21947
  PrintName("ShlUint32Sint16");
21948
  OS << "\t" << "\n";
21949
  continue;
21950
case OP_ShlUint32Uint16:
21951
  PrintName("ShlUint32Uint16");
21952
  OS << "\t" << "\n";
21953
  continue;
21954
case OP_ShlUint32Sint32:
21955
  PrintName("ShlUint32Sint32");
21956
  OS << "\t" << "\n";
21957
  continue;
21958
case OP_ShlUint32Uint32:
21959
  PrintName("ShlUint32Uint32");
21960
  OS << "\t" << "\n";
21961
  continue;
21962
case OP_ShlUint32Sint64:
21963
  PrintName("ShlUint32Sint64");
21964
  OS << "\t" << "\n";
21965
  continue;
21966
case OP_ShlUint32Uint64:
21967
  PrintName("ShlUint32Uint64");
21968
  OS << "\t" << "\n";
21969
  continue;
21970
case OP_ShlUint32IntAP:
21971
  PrintName("ShlUint32IntAP");
21972
  OS << "\t" << "\n";
21973
  continue;
21974
case OP_ShlUint32IntAPS:
21975
  PrintName("ShlUint32IntAPS");
21976
  OS << "\t" << "\n";
21977
  continue;
21978
case OP_ShlSint64Sint8:
21979
  PrintName("ShlSint64Sint8");
21980
  OS << "\t" << "\n";
21981
  continue;
21982
case OP_ShlSint64Uint8:
21983
  PrintName("ShlSint64Uint8");
21984
  OS << "\t" << "\n";
21985
  continue;
21986
case OP_ShlSint64Sint16:
21987
  PrintName("ShlSint64Sint16");
21988
  OS << "\t" << "\n";
21989
  continue;
21990
case OP_ShlSint64Uint16:
21991
  PrintName("ShlSint64Uint16");
21992
  OS << "\t" << "\n";
21993
  continue;
21994
case OP_ShlSint64Sint32:
21995
  PrintName("ShlSint64Sint32");
21996
  OS << "\t" << "\n";
21997
  continue;
21998
case OP_ShlSint64Uint32:
21999
  PrintName("ShlSint64Uint32");
22000
  OS << "\t" << "\n";
22001
  continue;
22002
case OP_ShlSint64Sint64:
22003
  PrintName("ShlSint64Sint64");
22004
  OS << "\t" << "\n";
22005
  continue;
22006
case OP_ShlSint64Uint64:
22007
  PrintName("ShlSint64Uint64");
22008
  OS << "\t" << "\n";
22009
  continue;
22010
case OP_ShlSint64IntAP:
22011
  PrintName("ShlSint64IntAP");
22012
  OS << "\t" << "\n";
22013
  continue;
22014
case OP_ShlSint64IntAPS:
22015
  PrintName("ShlSint64IntAPS");
22016
  OS << "\t" << "\n";
22017
  continue;
22018
case OP_ShlUint64Sint8:
22019
  PrintName("ShlUint64Sint8");
22020
  OS << "\t" << "\n";
22021
  continue;
22022
case OP_ShlUint64Uint8:
22023
  PrintName("ShlUint64Uint8");
22024
  OS << "\t" << "\n";
22025
  continue;
22026
case OP_ShlUint64Sint16:
22027
  PrintName("ShlUint64Sint16");
22028
  OS << "\t" << "\n";
22029
  continue;
22030
case OP_ShlUint64Uint16:
22031
  PrintName("ShlUint64Uint16");
22032
  OS << "\t" << "\n";
22033
  continue;
22034
case OP_ShlUint64Sint32:
22035
  PrintName("ShlUint64Sint32");
22036
  OS << "\t" << "\n";
22037
  continue;
22038
case OP_ShlUint64Uint32:
22039
  PrintName("ShlUint64Uint32");
22040
  OS << "\t" << "\n";
22041
  continue;
22042
case OP_ShlUint64Sint64:
22043
  PrintName("ShlUint64Sint64");
22044
  OS << "\t" << "\n";
22045
  continue;
22046
case OP_ShlUint64Uint64:
22047
  PrintName("ShlUint64Uint64");
22048
  OS << "\t" << "\n";
22049
  continue;
22050
case OP_ShlUint64IntAP:
22051
  PrintName("ShlUint64IntAP");
22052
  OS << "\t" << "\n";
22053
  continue;
22054
case OP_ShlUint64IntAPS:
22055
  PrintName("ShlUint64IntAPS");
22056
  OS << "\t" << "\n";
22057
  continue;
22058
case OP_ShlIntAPSint8:
22059
  PrintName("ShlIntAPSint8");
22060
  OS << "\t" << "\n";
22061
  continue;
22062
case OP_ShlIntAPUint8:
22063
  PrintName("ShlIntAPUint8");
22064
  OS << "\t" << "\n";
22065
  continue;
22066
case OP_ShlIntAPSint16:
22067
  PrintName("ShlIntAPSint16");
22068
  OS << "\t" << "\n";
22069
  continue;
22070
case OP_ShlIntAPUint16:
22071
  PrintName("ShlIntAPUint16");
22072
  OS << "\t" << "\n";
22073
  continue;
22074
case OP_ShlIntAPSint32:
22075
  PrintName("ShlIntAPSint32");
22076
  OS << "\t" << "\n";
22077
  continue;
22078
case OP_ShlIntAPUint32:
22079
  PrintName("ShlIntAPUint32");
22080
  OS << "\t" << "\n";
22081
  continue;
22082
case OP_ShlIntAPSint64:
22083
  PrintName("ShlIntAPSint64");
22084
  OS << "\t" << "\n";
22085
  continue;
22086
case OP_ShlIntAPUint64:
22087
  PrintName("ShlIntAPUint64");
22088
  OS << "\t" << "\n";
22089
  continue;
22090
case OP_ShlIntAPIntAP:
22091
  PrintName("ShlIntAPIntAP");
22092
  OS << "\t" << "\n";
22093
  continue;
22094
case OP_ShlIntAPIntAPS:
22095
  PrintName("ShlIntAPIntAPS");
22096
  OS << "\t" << "\n";
22097
  continue;
22098
case OP_ShlIntAPSSint8:
22099
  PrintName("ShlIntAPSSint8");
22100
  OS << "\t" << "\n";
22101
  continue;
22102
case OP_ShlIntAPSUint8:
22103
  PrintName("ShlIntAPSUint8");
22104
  OS << "\t" << "\n";
22105
  continue;
22106
case OP_ShlIntAPSSint16:
22107
  PrintName("ShlIntAPSSint16");
22108
  OS << "\t" << "\n";
22109
  continue;
22110
case OP_ShlIntAPSUint16:
22111
  PrintName("ShlIntAPSUint16");
22112
  OS << "\t" << "\n";
22113
  continue;
22114
case OP_ShlIntAPSSint32:
22115
  PrintName("ShlIntAPSSint32");
22116
  OS << "\t" << "\n";
22117
  continue;
22118
case OP_ShlIntAPSUint32:
22119
  PrintName("ShlIntAPSUint32");
22120
  OS << "\t" << "\n";
22121
  continue;
22122
case OP_ShlIntAPSSint64:
22123
  PrintName("ShlIntAPSSint64");
22124
  OS << "\t" << "\n";
22125
  continue;
22126
case OP_ShlIntAPSUint64:
22127
  PrintName("ShlIntAPSUint64");
22128
  OS << "\t" << "\n";
22129
  continue;
22130
case OP_ShlIntAPSIntAP:
22131
  PrintName("ShlIntAPSIntAP");
22132
  OS << "\t" << "\n";
22133
  continue;
22134
case OP_ShlIntAPSIntAPS:
22135
  PrintName("ShlIntAPSIntAPS");
22136
  OS << "\t" << "\n";
22137
  continue;
22138
#endif
22139
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
22140
bool emitShlSint8Sint8(const SourceInfo &);
22141
bool emitShlSint8Uint8(const SourceInfo &);
22142
bool emitShlSint8Sint16(const SourceInfo &);
22143
bool emitShlSint8Uint16(const SourceInfo &);
22144
bool emitShlSint8Sint32(const SourceInfo &);
22145
bool emitShlSint8Uint32(const SourceInfo &);
22146
bool emitShlSint8Sint64(const SourceInfo &);
22147
bool emitShlSint8Uint64(const SourceInfo &);
22148
bool emitShlSint8IntAP(const SourceInfo &);
22149
bool emitShlSint8IntAPS(const SourceInfo &);
22150
bool emitShlUint8Sint8(const SourceInfo &);
22151
bool emitShlUint8Uint8(const SourceInfo &);
22152
bool emitShlUint8Sint16(const SourceInfo &);
22153
bool emitShlUint8Uint16(const SourceInfo &);
22154
bool emitShlUint8Sint32(const SourceInfo &);
22155
bool emitShlUint8Uint32(const SourceInfo &);
22156
bool emitShlUint8Sint64(const SourceInfo &);
22157
bool emitShlUint8Uint64(const SourceInfo &);
22158
bool emitShlUint8IntAP(const SourceInfo &);
22159
bool emitShlUint8IntAPS(const SourceInfo &);
22160
bool emitShlSint16Sint8(const SourceInfo &);
22161
bool emitShlSint16Uint8(const SourceInfo &);
22162
bool emitShlSint16Sint16(const SourceInfo &);
22163
bool emitShlSint16Uint16(const SourceInfo &);
22164
bool emitShlSint16Sint32(const SourceInfo &);
22165
bool emitShlSint16Uint32(const SourceInfo &);
22166
bool emitShlSint16Sint64(const SourceInfo &);
22167
bool emitShlSint16Uint64(const SourceInfo &);
22168
bool emitShlSint16IntAP(const SourceInfo &);
22169
bool emitShlSint16IntAPS(const SourceInfo &);
22170
bool emitShlUint16Sint8(const SourceInfo &);
22171
bool emitShlUint16Uint8(const SourceInfo &);
22172
bool emitShlUint16Sint16(const SourceInfo &);
22173
bool emitShlUint16Uint16(const SourceInfo &);
22174
bool emitShlUint16Sint32(const SourceInfo &);
22175
bool emitShlUint16Uint32(const SourceInfo &);
22176
bool emitShlUint16Sint64(const SourceInfo &);
22177
bool emitShlUint16Uint64(const SourceInfo &);
22178
bool emitShlUint16IntAP(const SourceInfo &);
22179
bool emitShlUint16IntAPS(const SourceInfo &);
22180
bool emitShlSint32Sint8(const SourceInfo &);
22181
bool emitShlSint32Uint8(const SourceInfo &);
22182
bool emitShlSint32Sint16(const SourceInfo &);
22183
bool emitShlSint32Uint16(const SourceInfo &);
22184
bool emitShlSint32Sint32(const SourceInfo &);
22185
bool emitShlSint32Uint32(const SourceInfo &);
22186
bool emitShlSint32Sint64(const SourceInfo &);
22187
bool emitShlSint32Uint64(const SourceInfo &);
22188
bool emitShlSint32IntAP(const SourceInfo &);
22189
bool emitShlSint32IntAPS(const SourceInfo &);
22190
bool emitShlUint32Sint8(const SourceInfo &);
22191
bool emitShlUint32Uint8(const SourceInfo &);
22192
bool emitShlUint32Sint16(const SourceInfo &);
22193
bool emitShlUint32Uint16(const SourceInfo &);
22194
bool emitShlUint32Sint32(const SourceInfo &);
22195
bool emitShlUint32Uint32(const SourceInfo &);
22196
bool emitShlUint32Sint64(const SourceInfo &);
22197
bool emitShlUint32Uint64(const SourceInfo &);
22198
bool emitShlUint32IntAP(const SourceInfo &);
22199
bool emitShlUint32IntAPS(const SourceInfo &);
22200
bool emitShlSint64Sint8(const SourceInfo &);
22201
bool emitShlSint64Uint8(const SourceInfo &);
22202
bool emitShlSint64Sint16(const SourceInfo &);
22203
bool emitShlSint64Uint16(const SourceInfo &);
22204
bool emitShlSint64Sint32(const SourceInfo &);
22205
bool emitShlSint64Uint32(const SourceInfo &);
22206
bool emitShlSint64Sint64(const SourceInfo &);
22207
bool emitShlSint64Uint64(const SourceInfo &);
22208
bool emitShlSint64IntAP(const SourceInfo &);
22209
bool emitShlSint64IntAPS(const SourceInfo &);
22210
bool emitShlUint64Sint8(const SourceInfo &);
22211
bool emitShlUint64Uint8(const SourceInfo &);
22212
bool emitShlUint64Sint16(const SourceInfo &);
22213
bool emitShlUint64Uint16(const SourceInfo &);
22214
bool emitShlUint64Sint32(const SourceInfo &);
22215
bool emitShlUint64Uint32(const SourceInfo &);
22216
bool emitShlUint64Sint64(const SourceInfo &);
22217
bool emitShlUint64Uint64(const SourceInfo &);
22218
bool emitShlUint64IntAP(const SourceInfo &);
22219
bool emitShlUint64IntAPS(const SourceInfo &);
22220
bool emitShlIntAPSint8(const SourceInfo &);
22221
bool emitShlIntAPUint8(const SourceInfo &);
22222
bool emitShlIntAPSint16(const SourceInfo &);
22223
bool emitShlIntAPUint16(const SourceInfo &);
22224
bool emitShlIntAPSint32(const SourceInfo &);
22225
bool emitShlIntAPUint32(const SourceInfo &);
22226
bool emitShlIntAPSint64(const SourceInfo &);
22227
bool emitShlIntAPUint64(const SourceInfo &);
22228
bool emitShlIntAPIntAP(const SourceInfo &);
22229
bool emitShlIntAPIntAPS(const SourceInfo &);
22230
bool emitShlIntAPSSint8(const SourceInfo &);
22231
bool emitShlIntAPSUint8(const SourceInfo &);
22232
bool emitShlIntAPSSint16(const SourceInfo &);
22233
bool emitShlIntAPSUint16(const SourceInfo &);
22234
bool emitShlIntAPSSint32(const SourceInfo &);
22235
bool emitShlIntAPSUint32(const SourceInfo &);
22236
bool emitShlIntAPSSint64(const SourceInfo &);
22237
bool emitShlIntAPSUint64(const SourceInfo &);
22238
bool emitShlIntAPSIntAP(const SourceInfo &);
22239
bool emitShlIntAPSIntAPS(const SourceInfo &);
22240
#endif
22241
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
22242
bool emitShl(PrimType, PrimType, const SourceInfo &I);
22243
#endif
22244
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
22245
bool
22246
#if defined(GET_EVAL_IMPL)
22247
EvalEmitter
22248
#else
22249
ByteCodeEmitter
22250
#endif
22251
0
::emitShl(PrimType T0, PrimType T1, const SourceInfo &I) {
22252
0
  switch (T0) {
22253
0
  case PT_Sint8:
22254
0
  switch (T1) {
22255
0
  case PT_Sint8:
22256
0
    return emitShlSint8Sint8(I);
22257
0
  case PT_Uint8:
22258
0
    return emitShlSint8Uint8(I);
22259
0
  case PT_Sint16:
22260
0
    return emitShlSint8Sint16(I);
22261
0
  case PT_Uint16:
22262
0
    return emitShlSint8Uint16(I);
22263
0
  case PT_Sint32:
22264
0
    return emitShlSint8Sint32(I);
22265
0
  case PT_Uint32:
22266
0
    return emitShlSint8Uint32(I);
22267
0
  case PT_Sint64:
22268
0
    return emitShlSint8Sint64(I);
22269
0
  case PT_Uint64:
22270
0
    return emitShlSint8Uint64(I);
22271
0
  case PT_IntAP:
22272
0
    return emitShlSint8IntAP(I);
22273
0
  case PT_IntAPS:
22274
0
    return emitShlSint8IntAPS(I);
22275
0
  default: llvm_unreachable("invalid type: emitShl");
22276
0
  }
22277
0
  llvm_unreachable("invalid enum value");
22278
0
  case PT_Uint8:
22279
0
  switch (T1) {
22280
0
  case PT_Sint8:
22281
0
    return emitShlUint8Sint8(I);
22282
0
  case PT_Uint8:
22283
0
    return emitShlUint8Uint8(I);
22284
0
  case PT_Sint16:
22285
0
    return emitShlUint8Sint16(I);
22286
0
  case PT_Uint16:
22287
0
    return emitShlUint8Uint16(I);
22288
0
  case PT_Sint32:
22289
0
    return emitShlUint8Sint32(I);
22290
0
  case PT_Uint32:
22291
0
    return emitShlUint8Uint32(I);
22292
0
  case PT_Sint64:
22293
0
    return emitShlUint8Sint64(I);
22294
0
  case PT_Uint64:
22295
0
    return emitShlUint8Uint64(I);
22296
0
  case PT_IntAP:
22297
0
    return emitShlUint8IntAP(I);
22298
0
  case PT_IntAPS:
22299
0
    return emitShlUint8IntAPS(I);
22300
0
  default: llvm_unreachable("invalid type: emitShl");
22301
0
  }
22302
0
  llvm_unreachable("invalid enum value");
22303
0
  case PT_Sint16:
22304
0
  switch (T1) {
22305
0
  case PT_Sint8:
22306
0
    return emitShlSint16Sint8(I);
22307
0
  case PT_Uint8:
22308
0
    return emitShlSint16Uint8(I);
22309
0
  case PT_Sint16:
22310
0
    return emitShlSint16Sint16(I);
22311
0
  case PT_Uint16:
22312
0
    return emitShlSint16Uint16(I);
22313
0
  case PT_Sint32:
22314
0
    return emitShlSint16Sint32(I);
22315
0
  case PT_Uint32:
22316
0
    return emitShlSint16Uint32(I);
22317
0
  case PT_Sint64:
22318
0
    return emitShlSint16Sint64(I);
22319
0
  case PT_Uint64:
22320
0
    return emitShlSint16Uint64(I);
22321
0
  case PT_IntAP:
22322
0
    return emitShlSint16IntAP(I);
22323
0
  case PT_IntAPS:
22324
0
    return emitShlSint16IntAPS(I);
22325
0
  default: llvm_unreachable("invalid type: emitShl");
22326
0
  }
22327
0
  llvm_unreachable("invalid enum value");
22328
0
  case PT_Uint16:
22329
0
  switch (T1) {
22330
0
  case PT_Sint8:
22331
0
    return emitShlUint16Sint8(I);
22332
0
  case PT_Uint8:
22333
0
    return emitShlUint16Uint8(I);
22334
0
  case PT_Sint16:
22335
0
    return emitShlUint16Sint16(I);
22336
0
  case PT_Uint16:
22337
0
    return emitShlUint16Uint16(I);
22338
0
  case PT_Sint32:
22339
0
    return emitShlUint16Sint32(I);
22340
0
  case PT_Uint32:
22341
0
    return emitShlUint16Uint32(I);
22342
0
  case PT_Sint64:
22343
0
    return emitShlUint16Sint64(I);
22344
0
  case PT_Uint64:
22345
0
    return emitShlUint16Uint64(I);
22346
0
  case PT_IntAP:
22347
0
    return emitShlUint16IntAP(I);
22348
0
  case PT_IntAPS:
22349
0
    return emitShlUint16IntAPS(I);
22350
0
  default: llvm_unreachable("invalid type: emitShl");
22351
0
  }
22352
0
  llvm_unreachable("invalid enum value");
22353
0
  case PT_Sint32:
22354
0
  switch (T1) {
22355
0
  case PT_Sint8:
22356
0
    return emitShlSint32Sint8(I);
22357
0
  case PT_Uint8:
22358
0
    return emitShlSint32Uint8(I);
22359
0
  case PT_Sint16:
22360
0
    return emitShlSint32Sint16(I);
22361
0
  case PT_Uint16:
22362
0
    return emitShlSint32Uint16(I);
22363
0
  case PT_Sint32:
22364
0
    return emitShlSint32Sint32(I);
22365
0
  case PT_Uint32:
22366
0
    return emitShlSint32Uint32(I);
22367
0
  case PT_Sint64:
22368
0
    return emitShlSint32Sint64(I);
22369
0
  case PT_Uint64:
22370
0
    return emitShlSint32Uint64(I);
22371
0
  case PT_IntAP:
22372
0
    return emitShlSint32IntAP(I);
22373
0
  case PT_IntAPS:
22374
0
    return emitShlSint32IntAPS(I);
22375
0
  default: llvm_unreachable("invalid type: emitShl");
22376
0
  }
22377
0
  llvm_unreachable("invalid enum value");
22378
0
  case PT_Uint32:
22379
0
  switch (T1) {
22380
0
  case PT_Sint8:
22381
0
    return emitShlUint32Sint8(I);
22382
0
  case PT_Uint8:
22383
0
    return emitShlUint32Uint8(I);
22384
0
  case PT_Sint16:
22385
0
    return emitShlUint32Sint16(I);
22386
0
  case PT_Uint16:
22387
0
    return emitShlUint32Uint16(I);
22388
0
  case PT_Sint32:
22389
0
    return emitShlUint32Sint32(I);
22390
0
  case PT_Uint32:
22391
0
    return emitShlUint32Uint32(I);
22392
0
  case PT_Sint64:
22393
0
    return emitShlUint32Sint64(I);
22394
0
  case PT_Uint64:
22395
0
    return emitShlUint32Uint64(I);
22396
0
  case PT_IntAP:
22397
0
    return emitShlUint32IntAP(I);
22398
0
  case PT_IntAPS:
22399
0
    return emitShlUint32IntAPS(I);
22400
0
  default: llvm_unreachable("invalid type: emitShl");
22401
0
  }
22402
0
  llvm_unreachable("invalid enum value");
22403
0
  case PT_Sint64:
22404
0
  switch (T1) {
22405
0
  case PT_Sint8:
22406
0
    return emitShlSint64Sint8(I);
22407
0
  case PT_Uint8:
22408
0
    return emitShlSint64Uint8(I);
22409
0
  case PT_Sint16:
22410
0
    return emitShlSint64Sint16(I);
22411
0
  case PT_Uint16:
22412
0
    return emitShlSint64Uint16(I);
22413
0
  case PT_Sint32:
22414
0
    return emitShlSint64Sint32(I);
22415
0
  case PT_Uint32:
22416
0
    return emitShlSint64Uint32(I);
22417
0
  case PT_Sint64:
22418
0
    return emitShlSint64Sint64(I);
22419
0
  case PT_Uint64:
22420
0
    return emitShlSint64Uint64(I);
22421
0
  case PT_IntAP:
22422
0
    return emitShlSint64IntAP(I);
22423
0
  case PT_IntAPS:
22424
0
    return emitShlSint64IntAPS(I);
22425
0
  default: llvm_unreachable("invalid type: emitShl");
22426
0
  }
22427
0
  llvm_unreachable("invalid enum value");
22428
0
  case PT_Uint64:
22429
0
  switch (T1) {
22430
0
  case PT_Sint8:
22431
0
    return emitShlUint64Sint8(I);
22432
0
  case PT_Uint8:
22433
0
    return emitShlUint64Uint8(I);
22434
0
  case PT_Sint16:
22435
0
    return emitShlUint64Sint16(I);
22436
0
  case PT_Uint16:
22437
0
    return emitShlUint64Uint16(I);
22438
0
  case PT_Sint32:
22439
0
    return emitShlUint64Sint32(I);
22440
0
  case PT_Uint32:
22441
0
    return emitShlUint64Uint32(I);
22442
0
  case PT_Sint64:
22443
0
    return emitShlUint64Sint64(I);
22444
0
  case PT_Uint64:
22445
0
    return emitShlUint64Uint64(I);
22446
0
  case PT_IntAP:
22447
0
    return emitShlUint64IntAP(I);
22448
0
  case PT_IntAPS:
22449
0
    return emitShlUint64IntAPS(I);
22450
0
  default: llvm_unreachable("invalid type: emitShl");
22451
0
  }
22452
0
  llvm_unreachable("invalid enum value");
22453
0
  case PT_IntAP:
22454
0
  switch (T1) {
22455
0
  case PT_Sint8:
22456
0
    return emitShlIntAPSint8(I);
22457
0
  case PT_Uint8:
22458
0
    return emitShlIntAPUint8(I);
22459
0
  case PT_Sint16:
22460
0
    return emitShlIntAPSint16(I);
22461
0
  case PT_Uint16:
22462
0
    return emitShlIntAPUint16(I);
22463
0
  case PT_Sint32:
22464
0
    return emitShlIntAPSint32(I);
22465
0
  case PT_Uint32:
22466
0
    return emitShlIntAPUint32(I);
22467
0
  case PT_Sint64:
22468
0
    return emitShlIntAPSint64(I);
22469
0
  case PT_Uint64:
22470
0
    return emitShlIntAPUint64(I);
22471
0
  case PT_IntAP:
22472
0
    return emitShlIntAPIntAP(I);
22473
0
  case PT_IntAPS:
22474
0
    return emitShlIntAPIntAPS(I);
22475
0
  default: llvm_unreachable("invalid type: emitShl");
22476
0
  }
22477
0
  llvm_unreachable("invalid enum value");
22478
0
  case PT_IntAPS:
22479
0
  switch (T1) {
22480
0
  case PT_Sint8:
22481
0
    return emitShlIntAPSSint8(I);
22482
0
  case PT_Uint8:
22483
0
    return emitShlIntAPSUint8(I);
22484
0
  case PT_Sint16:
22485
0
    return emitShlIntAPSSint16(I);
22486
0
  case PT_Uint16:
22487
0
    return emitShlIntAPSUint16(I);
22488
0
  case PT_Sint32:
22489
0
    return emitShlIntAPSSint32(I);
22490
0
  case PT_Uint32:
22491
0
    return emitShlIntAPSUint32(I);
22492
0
  case PT_Sint64:
22493
0
    return emitShlIntAPSSint64(I);
22494
0
  case PT_Uint64:
22495
0
    return emitShlIntAPSUint64(I);
22496
0
  case PT_IntAP:
22497
0
    return emitShlIntAPSIntAP(I);
22498
0
  case PT_IntAPS:
22499
0
    return emitShlIntAPSIntAPS(I);
22500
0
  default: llvm_unreachable("invalid type: emitShl");
22501
0
  }
22502
0
  llvm_unreachable("invalid enum value");
22503
0
  default: llvm_unreachable("invalid type: emitShl");
22504
0
  }
22505
0
  llvm_unreachable("invalid enum value");
22506
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitShl(clang::interp::PrimType, clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitShl(clang::interp::PrimType, clang::interp::PrimType, clang::interp::SourceInfo const&)
22507
#endif
22508
#ifdef GET_LINK_IMPL
22509
0
bool ByteCodeEmitter::emitShlSint8Sint8(const SourceInfo &L) {
22510
0
  return emitOp<>(OP_ShlSint8Sint8, L);
22511
0
}
22512
0
bool ByteCodeEmitter::emitShlSint8Uint8(const SourceInfo &L) {
22513
0
  return emitOp<>(OP_ShlSint8Uint8, L);
22514
0
}
22515
0
bool ByteCodeEmitter::emitShlSint8Sint16(const SourceInfo &L) {
22516
0
  return emitOp<>(OP_ShlSint8Sint16, L);
22517
0
}
22518
0
bool ByteCodeEmitter::emitShlSint8Uint16(const SourceInfo &L) {
22519
0
  return emitOp<>(OP_ShlSint8Uint16, L);
22520
0
}
22521
0
bool ByteCodeEmitter::emitShlSint8Sint32(const SourceInfo &L) {
22522
0
  return emitOp<>(OP_ShlSint8Sint32, L);
22523
0
}
22524
0
bool ByteCodeEmitter::emitShlSint8Uint32(const SourceInfo &L) {
22525
0
  return emitOp<>(OP_ShlSint8Uint32, L);
22526
0
}
22527
0
bool ByteCodeEmitter::emitShlSint8Sint64(const SourceInfo &L) {
22528
0
  return emitOp<>(OP_ShlSint8Sint64, L);
22529
0
}
22530
0
bool ByteCodeEmitter::emitShlSint8Uint64(const SourceInfo &L) {
22531
0
  return emitOp<>(OP_ShlSint8Uint64, L);
22532
0
}
22533
0
bool ByteCodeEmitter::emitShlSint8IntAP(const SourceInfo &L) {
22534
0
  return emitOp<>(OP_ShlSint8IntAP, L);
22535
0
}
22536
0
bool ByteCodeEmitter::emitShlSint8IntAPS(const SourceInfo &L) {
22537
0
  return emitOp<>(OP_ShlSint8IntAPS, L);
22538
0
}
22539
0
bool ByteCodeEmitter::emitShlUint8Sint8(const SourceInfo &L) {
22540
0
  return emitOp<>(OP_ShlUint8Sint8, L);
22541
0
}
22542
0
bool ByteCodeEmitter::emitShlUint8Uint8(const SourceInfo &L) {
22543
0
  return emitOp<>(OP_ShlUint8Uint8, L);
22544
0
}
22545
0
bool ByteCodeEmitter::emitShlUint8Sint16(const SourceInfo &L) {
22546
0
  return emitOp<>(OP_ShlUint8Sint16, L);
22547
0
}
22548
0
bool ByteCodeEmitter::emitShlUint8Uint16(const SourceInfo &L) {
22549
0
  return emitOp<>(OP_ShlUint8Uint16, L);
22550
0
}
22551
0
bool ByteCodeEmitter::emitShlUint8Sint32(const SourceInfo &L) {
22552
0
  return emitOp<>(OP_ShlUint8Sint32, L);
22553
0
}
22554
0
bool ByteCodeEmitter::emitShlUint8Uint32(const SourceInfo &L) {
22555
0
  return emitOp<>(OP_ShlUint8Uint32, L);
22556
0
}
22557
0
bool ByteCodeEmitter::emitShlUint8Sint64(const SourceInfo &L) {
22558
0
  return emitOp<>(OP_ShlUint8Sint64, L);
22559
0
}
22560
0
bool ByteCodeEmitter::emitShlUint8Uint64(const SourceInfo &L) {
22561
0
  return emitOp<>(OP_ShlUint8Uint64, L);
22562
0
}
22563
0
bool ByteCodeEmitter::emitShlUint8IntAP(const SourceInfo &L) {
22564
0
  return emitOp<>(OP_ShlUint8IntAP, L);
22565
0
}
22566
0
bool ByteCodeEmitter::emitShlUint8IntAPS(const SourceInfo &L) {
22567
0
  return emitOp<>(OP_ShlUint8IntAPS, L);
22568
0
}
22569
0
bool ByteCodeEmitter::emitShlSint16Sint8(const SourceInfo &L) {
22570
0
  return emitOp<>(OP_ShlSint16Sint8, L);
22571
0
}
22572
0
bool ByteCodeEmitter::emitShlSint16Uint8(const SourceInfo &L) {
22573
0
  return emitOp<>(OP_ShlSint16Uint8, L);
22574
0
}
22575
0
bool ByteCodeEmitter::emitShlSint16Sint16(const SourceInfo &L) {
22576
0
  return emitOp<>(OP_ShlSint16Sint16, L);
22577
0
}
22578
0
bool ByteCodeEmitter::emitShlSint16Uint16(const SourceInfo &L) {
22579
0
  return emitOp<>(OP_ShlSint16Uint16, L);
22580
0
}
22581
0
bool ByteCodeEmitter::emitShlSint16Sint32(const SourceInfo &L) {
22582
0
  return emitOp<>(OP_ShlSint16Sint32, L);
22583
0
}
22584
0
bool ByteCodeEmitter::emitShlSint16Uint32(const SourceInfo &L) {
22585
0
  return emitOp<>(OP_ShlSint16Uint32, L);
22586
0
}
22587
0
bool ByteCodeEmitter::emitShlSint16Sint64(const SourceInfo &L) {
22588
0
  return emitOp<>(OP_ShlSint16Sint64, L);
22589
0
}
22590
0
bool ByteCodeEmitter::emitShlSint16Uint64(const SourceInfo &L) {
22591
0
  return emitOp<>(OP_ShlSint16Uint64, L);
22592
0
}
22593
0
bool ByteCodeEmitter::emitShlSint16IntAP(const SourceInfo &L) {
22594
0
  return emitOp<>(OP_ShlSint16IntAP, L);
22595
0
}
22596
0
bool ByteCodeEmitter::emitShlSint16IntAPS(const SourceInfo &L) {
22597
0
  return emitOp<>(OP_ShlSint16IntAPS, L);
22598
0
}
22599
0
bool ByteCodeEmitter::emitShlUint16Sint8(const SourceInfo &L) {
22600
0
  return emitOp<>(OP_ShlUint16Sint8, L);
22601
0
}
22602
0
bool ByteCodeEmitter::emitShlUint16Uint8(const SourceInfo &L) {
22603
0
  return emitOp<>(OP_ShlUint16Uint8, L);
22604
0
}
22605
0
bool ByteCodeEmitter::emitShlUint16Sint16(const SourceInfo &L) {
22606
0
  return emitOp<>(OP_ShlUint16Sint16, L);
22607
0
}
22608
0
bool ByteCodeEmitter::emitShlUint16Uint16(const SourceInfo &L) {
22609
0
  return emitOp<>(OP_ShlUint16Uint16, L);
22610
0
}
22611
0
bool ByteCodeEmitter::emitShlUint16Sint32(const SourceInfo &L) {
22612
0
  return emitOp<>(OP_ShlUint16Sint32, L);
22613
0
}
22614
0
bool ByteCodeEmitter::emitShlUint16Uint32(const SourceInfo &L) {
22615
0
  return emitOp<>(OP_ShlUint16Uint32, L);
22616
0
}
22617
0
bool ByteCodeEmitter::emitShlUint16Sint64(const SourceInfo &L) {
22618
0
  return emitOp<>(OP_ShlUint16Sint64, L);
22619
0
}
22620
0
bool ByteCodeEmitter::emitShlUint16Uint64(const SourceInfo &L) {
22621
0
  return emitOp<>(OP_ShlUint16Uint64, L);
22622
0
}
22623
0
bool ByteCodeEmitter::emitShlUint16IntAP(const SourceInfo &L) {
22624
0
  return emitOp<>(OP_ShlUint16IntAP, L);
22625
0
}
22626
0
bool ByteCodeEmitter::emitShlUint16IntAPS(const SourceInfo &L) {
22627
0
  return emitOp<>(OP_ShlUint16IntAPS, L);
22628
0
}
22629
0
bool ByteCodeEmitter::emitShlSint32Sint8(const SourceInfo &L) {
22630
0
  return emitOp<>(OP_ShlSint32Sint8, L);
22631
0
}
22632
0
bool ByteCodeEmitter::emitShlSint32Uint8(const SourceInfo &L) {
22633
0
  return emitOp<>(OP_ShlSint32Uint8, L);
22634
0
}
22635
0
bool ByteCodeEmitter::emitShlSint32Sint16(const SourceInfo &L) {
22636
0
  return emitOp<>(OP_ShlSint32Sint16, L);
22637
0
}
22638
0
bool ByteCodeEmitter::emitShlSint32Uint16(const SourceInfo &L) {
22639
0
  return emitOp<>(OP_ShlSint32Uint16, L);
22640
0
}
22641
0
bool ByteCodeEmitter::emitShlSint32Sint32(const SourceInfo &L) {
22642
0
  return emitOp<>(OP_ShlSint32Sint32, L);
22643
0
}
22644
0
bool ByteCodeEmitter::emitShlSint32Uint32(const SourceInfo &L) {
22645
0
  return emitOp<>(OP_ShlSint32Uint32, L);
22646
0
}
22647
0
bool ByteCodeEmitter::emitShlSint32Sint64(const SourceInfo &L) {
22648
0
  return emitOp<>(OP_ShlSint32Sint64, L);
22649
0
}
22650
0
bool ByteCodeEmitter::emitShlSint32Uint64(const SourceInfo &L) {
22651
0
  return emitOp<>(OP_ShlSint32Uint64, L);
22652
0
}
22653
0
bool ByteCodeEmitter::emitShlSint32IntAP(const SourceInfo &L) {
22654
0
  return emitOp<>(OP_ShlSint32IntAP, L);
22655
0
}
22656
0
bool ByteCodeEmitter::emitShlSint32IntAPS(const SourceInfo &L) {
22657
0
  return emitOp<>(OP_ShlSint32IntAPS, L);
22658
0
}
22659
0
bool ByteCodeEmitter::emitShlUint32Sint8(const SourceInfo &L) {
22660
0
  return emitOp<>(OP_ShlUint32Sint8, L);
22661
0
}
22662
0
bool ByteCodeEmitter::emitShlUint32Uint8(const SourceInfo &L) {
22663
0
  return emitOp<>(OP_ShlUint32Uint8, L);
22664
0
}
22665
0
bool ByteCodeEmitter::emitShlUint32Sint16(const SourceInfo &L) {
22666
0
  return emitOp<>(OP_ShlUint32Sint16, L);
22667
0
}
22668
0
bool ByteCodeEmitter::emitShlUint32Uint16(const SourceInfo &L) {
22669
0
  return emitOp<>(OP_ShlUint32Uint16, L);
22670
0
}
22671
0
bool ByteCodeEmitter::emitShlUint32Sint32(const SourceInfo &L) {
22672
0
  return emitOp<>(OP_ShlUint32Sint32, L);
22673
0
}
22674
0
bool ByteCodeEmitter::emitShlUint32Uint32(const SourceInfo &L) {
22675
0
  return emitOp<>(OP_ShlUint32Uint32, L);
22676
0
}
22677
0
bool ByteCodeEmitter::emitShlUint32Sint64(const SourceInfo &L) {
22678
0
  return emitOp<>(OP_ShlUint32Sint64, L);
22679
0
}
22680
0
bool ByteCodeEmitter::emitShlUint32Uint64(const SourceInfo &L) {
22681
0
  return emitOp<>(OP_ShlUint32Uint64, L);
22682
0
}
22683
0
bool ByteCodeEmitter::emitShlUint32IntAP(const SourceInfo &L) {
22684
0
  return emitOp<>(OP_ShlUint32IntAP, L);
22685
0
}
22686
0
bool ByteCodeEmitter::emitShlUint32IntAPS(const SourceInfo &L) {
22687
0
  return emitOp<>(OP_ShlUint32IntAPS, L);
22688
0
}
22689
0
bool ByteCodeEmitter::emitShlSint64Sint8(const SourceInfo &L) {
22690
0
  return emitOp<>(OP_ShlSint64Sint8, L);
22691
0
}
22692
0
bool ByteCodeEmitter::emitShlSint64Uint8(const SourceInfo &L) {
22693
0
  return emitOp<>(OP_ShlSint64Uint8, L);
22694
0
}
22695
0
bool ByteCodeEmitter::emitShlSint64Sint16(const SourceInfo &L) {
22696
0
  return emitOp<>(OP_ShlSint64Sint16, L);
22697
0
}
22698
0
bool ByteCodeEmitter::emitShlSint64Uint16(const SourceInfo &L) {
22699
0
  return emitOp<>(OP_ShlSint64Uint16, L);
22700
0
}
22701
0
bool ByteCodeEmitter::emitShlSint64Sint32(const SourceInfo &L) {
22702
0
  return emitOp<>(OP_ShlSint64Sint32, L);
22703
0
}
22704
0
bool ByteCodeEmitter::emitShlSint64Uint32(const SourceInfo &L) {
22705
0
  return emitOp<>(OP_ShlSint64Uint32, L);
22706
0
}
22707
0
bool ByteCodeEmitter::emitShlSint64Sint64(const SourceInfo &L) {
22708
0
  return emitOp<>(OP_ShlSint64Sint64, L);
22709
0
}
22710
0
bool ByteCodeEmitter::emitShlSint64Uint64(const SourceInfo &L) {
22711
0
  return emitOp<>(OP_ShlSint64Uint64, L);
22712
0
}
22713
0
bool ByteCodeEmitter::emitShlSint64IntAP(const SourceInfo &L) {
22714
0
  return emitOp<>(OP_ShlSint64IntAP, L);
22715
0
}
22716
0
bool ByteCodeEmitter::emitShlSint64IntAPS(const SourceInfo &L) {
22717
0
  return emitOp<>(OP_ShlSint64IntAPS, L);
22718
0
}
22719
0
bool ByteCodeEmitter::emitShlUint64Sint8(const SourceInfo &L) {
22720
0
  return emitOp<>(OP_ShlUint64Sint8, L);
22721
0
}
22722
0
bool ByteCodeEmitter::emitShlUint64Uint8(const SourceInfo &L) {
22723
0
  return emitOp<>(OP_ShlUint64Uint8, L);
22724
0
}
22725
0
bool ByteCodeEmitter::emitShlUint64Sint16(const SourceInfo &L) {
22726
0
  return emitOp<>(OP_ShlUint64Sint16, L);
22727
0
}
22728
0
bool ByteCodeEmitter::emitShlUint64Uint16(const SourceInfo &L) {
22729
0
  return emitOp<>(OP_ShlUint64Uint16, L);
22730
0
}
22731
0
bool ByteCodeEmitter::emitShlUint64Sint32(const SourceInfo &L) {
22732
0
  return emitOp<>(OP_ShlUint64Sint32, L);
22733
0
}
22734
0
bool ByteCodeEmitter::emitShlUint64Uint32(const SourceInfo &L) {
22735
0
  return emitOp<>(OP_ShlUint64Uint32, L);
22736
0
}
22737
0
bool ByteCodeEmitter::emitShlUint64Sint64(const SourceInfo &L) {
22738
0
  return emitOp<>(OP_ShlUint64Sint64, L);
22739
0
}
22740
0
bool ByteCodeEmitter::emitShlUint64Uint64(const SourceInfo &L) {
22741
0
  return emitOp<>(OP_ShlUint64Uint64, L);
22742
0
}
22743
0
bool ByteCodeEmitter::emitShlUint64IntAP(const SourceInfo &L) {
22744
0
  return emitOp<>(OP_ShlUint64IntAP, L);
22745
0
}
22746
0
bool ByteCodeEmitter::emitShlUint64IntAPS(const SourceInfo &L) {
22747
0
  return emitOp<>(OP_ShlUint64IntAPS, L);
22748
0
}
22749
0
bool ByteCodeEmitter::emitShlIntAPSint8(const SourceInfo &L) {
22750
0
  return emitOp<>(OP_ShlIntAPSint8, L);
22751
0
}
22752
0
bool ByteCodeEmitter::emitShlIntAPUint8(const SourceInfo &L) {
22753
0
  return emitOp<>(OP_ShlIntAPUint8, L);
22754
0
}
22755
0
bool ByteCodeEmitter::emitShlIntAPSint16(const SourceInfo &L) {
22756
0
  return emitOp<>(OP_ShlIntAPSint16, L);
22757
0
}
22758
0
bool ByteCodeEmitter::emitShlIntAPUint16(const SourceInfo &L) {
22759
0
  return emitOp<>(OP_ShlIntAPUint16, L);
22760
0
}
22761
0
bool ByteCodeEmitter::emitShlIntAPSint32(const SourceInfo &L) {
22762
0
  return emitOp<>(OP_ShlIntAPSint32, L);
22763
0
}
22764
0
bool ByteCodeEmitter::emitShlIntAPUint32(const SourceInfo &L) {
22765
0
  return emitOp<>(OP_ShlIntAPUint32, L);
22766
0
}
22767
0
bool ByteCodeEmitter::emitShlIntAPSint64(const SourceInfo &L) {
22768
0
  return emitOp<>(OP_ShlIntAPSint64, L);
22769
0
}
22770
0
bool ByteCodeEmitter::emitShlIntAPUint64(const SourceInfo &L) {
22771
0
  return emitOp<>(OP_ShlIntAPUint64, L);
22772
0
}
22773
0
bool ByteCodeEmitter::emitShlIntAPIntAP(const SourceInfo &L) {
22774
0
  return emitOp<>(OP_ShlIntAPIntAP, L);
22775
0
}
22776
0
bool ByteCodeEmitter::emitShlIntAPIntAPS(const SourceInfo &L) {
22777
0
  return emitOp<>(OP_ShlIntAPIntAPS, L);
22778
0
}
22779
0
bool ByteCodeEmitter::emitShlIntAPSSint8(const SourceInfo &L) {
22780
0
  return emitOp<>(OP_ShlIntAPSSint8, L);
22781
0
}
22782
0
bool ByteCodeEmitter::emitShlIntAPSUint8(const SourceInfo &L) {
22783
0
  return emitOp<>(OP_ShlIntAPSUint8, L);
22784
0
}
22785
0
bool ByteCodeEmitter::emitShlIntAPSSint16(const SourceInfo &L) {
22786
0
  return emitOp<>(OP_ShlIntAPSSint16, L);
22787
0
}
22788
0
bool ByteCodeEmitter::emitShlIntAPSUint16(const SourceInfo &L) {
22789
0
  return emitOp<>(OP_ShlIntAPSUint16, L);
22790
0
}
22791
0
bool ByteCodeEmitter::emitShlIntAPSSint32(const SourceInfo &L) {
22792
0
  return emitOp<>(OP_ShlIntAPSSint32, L);
22793
0
}
22794
0
bool ByteCodeEmitter::emitShlIntAPSUint32(const SourceInfo &L) {
22795
0
  return emitOp<>(OP_ShlIntAPSUint32, L);
22796
0
}
22797
0
bool ByteCodeEmitter::emitShlIntAPSSint64(const SourceInfo &L) {
22798
0
  return emitOp<>(OP_ShlIntAPSSint64, L);
22799
0
}
22800
0
bool ByteCodeEmitter::emitShlIntAPSUint64(const SourceInfo &L) {
22801
0
  return emitOp<>(OP_ShlIntAPSUint64, L);
22802
0
}
22803
0
bool ByteCodeEmitter::emitShlIntAPSIntAP(const SourceInfo &L) {
22804
0
  return emitOp<>(OP_ShlIntAPSIntAP, L);
22805
0
}
22806
0
bool ByteCodeEmitter::emitShlIntAPSIntAPS(const SourceInfo &L) {
22807
0
  return emitOp<>(OP_ShlIntAPSIntAPS, L);
22808
0
}
22809
#endif
22810
#ifdef GET_EVAL_IMPL
22811
0
bool EvalEmitter::emitShlSint8Sint8(const SourceInfo &L) {
22812
0
  if (!isActive()) return true;
22813
0
  CurrentSource = L;
22814
0
  return Shl<PT_Sint8, PT_Sint8>(S, OpPC);
22815
0
}
22816
0
bool EvalEmitter::emitShlSint8Uint8(const SourceInfo &L) {
22817
0
  if (!isActive()) return true;
22818
0
  CurrentSource = L;
22819
0
  return Shl<PT_Sint8, PT_Uint8>(S, OpPC);
22820
0
}
22821
0
bool EvalEmitter::emitShlSint8Sint16(const SourceInfo &L) {
22822
0
  if (!isActive()) return true;
22823
0
  CurrentSource = L;
22824
0
  return Shl<PT_Sint8, PT_Sint16>(S, OpPC);
22825
0
}
22826
0
bool EvalEmitter::emitShlSint8Uint16(const SourceInfo &L) {
22827
0
  if (!isActive()) return true;
22828
0
  CurrentSource = L;
22829
0
  return Shl<PT_Sint8, PT_Uint16>(S, OpPC);
22830
0
}
22831
0
bool EvalEmitter::emitShlSint8Sint32(const SourceInfo &L) {
22832
0
  if (!isActive()) return true;
22833
0
  CurrentSource = L;
22834
0
  return Shl<PT_Sint8, PT_Sint32>(S, OpPC);
22835
0
}
22836
0
bool EvalEmitter::emitShlSint8Uint32(const SourceInfo &L) {
22837
0
  if (!isActive()) return true;
22838
0
  CurrentSource = L;
22839
0
  return Shl<PT_Sint8, PT_Uint32>(S, OpPC);
22840
0
}
22841
0
bool EvalEmitter::emitShlSint8Sint64(const SourceInfo &L) {
22842
0
  if (!isActive()) return true;
22843
0
  CurrentSource = L;
22844
0
  return Shl<PT_Sint8, PT_Sint64>(S, OpPC);
22845
0
}
22846
0
bool EvalEmitter::emitShlSint8Uint64(const SourceInfo &L) {
22847
0
  if (!isActive()) return true;
22848
0
  CurrentSource = L;
22849
0
  return Shl<PT_Sint8, PT_Uint64>(S, OpPC);
22850
0
}
22851
0
bool EvalEmitter::emitShlSint8IntAP(const SourceInfo &L) {
22852
0
  if (!isActive()) return true;
22853
0
  CurrentSource = L;
22854
0
  return Shl<PT_Sint8, PT_IntAP>(S, OpPC);
22855
0
}
22856
0
bool EvalEmitter::emitShlSint8IntAPS(const SourceInfo &L) {
22857
0
  if (!isActive()) return true;
22858
0
  CurrentSource = L;
22859
0
  return Shl<PT_Sint8, PT_IntAPS>(S, OpPC);
22860
0
}
22861
0
bool EvalEmitter::emitShlUint8Sint8(const SourceInfo &L) {
22862
0
  if (!isActive()) return true;
22863
0
  CurrentSource = L;
22864
0
  return Shl<PT_Uint8, PT_Sint8>(S, OpPC);
22865
0
}
22866
0
bool EvalEmitter::emitShlUint8Uint8(const SourceInfo &L) {
22867
0
  if (!isActive()) return true;
22868
0
  CurrentSource = L;
22869
0
  return Shl<PT_Uint8, PT_Uint8>(S, OpPC);
22870
0
}
22871
0
bool EvalEmitter::emitShlUint8Sint16(const SourceInfo &L) {
22872
0
  if (!isActive()) return true;
22873
0
  CurrentSource = L;
22874
0
  return Shl<PT_Uint8, PT_Sint16>(S, OpPC);
22875
0
}
22876
0
bool EvalEmitter::emitShlUint8Uint16(const SourceInfo &L) {
22877
0
  if (!isActive()) return true;
22878
0
  CurrentSource = L;
22879
0
  return Shl<PT_Uint8, PT_Uint16>(S, OpPC);
22880
0
}
22881
0
bool EvalEmitter::emitShlUint8Sint32(const SourceInfo &L) {
22882
0
  if (!isActive()) return true;
22883
0
  CurrentSource = L;
22884
0
  return Shl<PT_Uint8, PT_Sint32>(S, OpPC);
22885
0
}
22886
0
bool EvalEmitter::emitShlUint8Uint32(const SourceInfo &L) {
22887
0
  if (!isActive()) return true;
22888
0
  CurrentSource = L;
22889
0
  return Shl<PT_Uint8, PT_Uint32>(S, OpPC);
22890
0
}
22891
0
bool EvalEmitter::emitShlUint8Sint64(const SourceInfo &L) {
22892
0
  if (!isActive()) return true;
22893
0
  CurrentSource = L;
22894
0
  return Shl<PT_Uint8, PT_Sint64>(S, OpPC);
22895
0
}
22896
0
bool EvalEmitter::emitShlUint8Uint64(const SourceInfo &L) {
22897
0
  if (!isActive()) return true;
22898
0
  CurrentSource = L;
22899
0
  return Shl<PT_Uint8, PT_Uint64>(S, OpPC);
22900
0
}
22901
0
bool EvalEmitter::emitShlUint8IntAP(const SourceInfo &L) {
22902
0
  if (!isActive()) return true;
22903
0
  CurrentSource = L;
22904
0
  return Shl<PT_Uint8, PT_IntAP>(S, OpPC);
22905
0
}
22906
0
bool EvalEmitter::emitShlUint8IntAPS(const SourceInfo &L) {
22907
0
  if (!isActive()) return true;
22908
0
  CurrentSource = L;
22909
0
  return Shl<PT_Uint8, PT_IntAPS>(S, OpPC);
22910
0
}
22911
0
bool EvalEmitter::emitShlSint16Sint8(const SourceInfo &L) {
22912
0
  if (!isActive()) return true;
22913
0
  CurrentSource = L;
22914
0
  return Shl<PT_Sint16, PT_Sint8>(S, OpPC);
22915
0
}
22916
0
bool EvalEmitter::emitShlSint16Uint8(const SourceInfo &L) {
22917
0
  if (!isActive()) return true;
22918
0
  CurrentSource = L;
22919
0
  return Shl<PT_Sint16, PT_Uint8>(S, OpPC);
22920
0
}
22921
0
bool EvalEmitter::emitShlSint16Sint16(const SourceInfo &L) {
22922
0
  if (!isActive()) return true;
22923
0
  CurrentSource = L;
22924
0
  return Shl<PT_Sint16, PT_Sint16>(S, OpPC);
22925
0
}
22926
0
bool EvalEmitter::emitShlSint16Uint16(const SourceInfo &L) {
22927
0
  if (!isActive()) return true;
22928
0
  CurrentSource = L;
22929
0
  return Shl<PT_Sint16, PT_Uint16>(S, OpPC);
22930
0
}
22931
0
bool EvalEmitter::emitShlSint16Sint32(const SourceInfo &L) {
22932
0
  if (!isActive()) return true;
22933
0
  CurrentSource = L;
22934
0
  return Shl<PT_Sint16, PT_Sint32>(S, OpPC);
22935
0
}
22936
0
bool EvalEmitter::emitShlSint16Uint32(const SourceInfo &L) {
22937
0
  if (!isActive()) return true;
22938
0
  CurrentSource = L;
22939
0
  return Shl<PT_Sint16, PT_Uint32>(S, OpPC);
22940
0
}
22941
0
bool EvalEmitter::emitShlSint16Sint64(const SourceInfo &L) {
22942
0
  if (!isActive()) return true;
22943
0
  CurrentSource = L;
22944
0
  return Shl<PT_Sint16, PT_Sint64>(S, OpPC);
22945
0
}
22946
0
bool EvalEmitter::emitShlSint16Uint64(const SourceInfo &L) {
22947
0
  if (!isActive()) return true;
22948
0
  CurrentSource = L;
22949
0
  return Shl<PT_Sint16, PT_Uint64>(S, OpPC);
22950
0
}
22951
0
bool EvalEmitter::emitShlSint16IntAP(const SourceInfo &L) {
22952
0
  if (!isActive()) return true;
22953
0
  CurrentSource = L;
22954
0
  return Shl<PT_Sint16, PT_IntAP>(S, OpPC);
22955
0
}
22956
0
bool EvalEmitter::emitShlSint16IntAPS(const SourceInfo &L) {
22957
0
  if (!isActive()) return true;
22958
0
  CurrentSource = L;
22959
0
  return Shl<PT_Sint16, PT_IntAPS>(S, OpPC);
22960
0
}
22961
0
bool EvalEmitter::emitShlUint16Sint8(const SourceInfo &L) {
22962
0
  if (!isActive()) return true;
22963
0
  CurrentSource = L;
22964
0
  return Shl<PT_Uint16, PT_Sint8>(S, OpPC);
22965
0
}
22966
0
bool EvalEmitter::emitShlUint16Uint8(const SourceInfo &L) {
22967
0
  if (!isActive()) return true;
22968
0
  CurrentSource = L;
22969
0
  return Shl<PT_Uint16, PT_Uint8>(S, OpPC);
22970
0
}
22971
0
bool EvalEmitter::emitShlUint16Sint16(const SourceInfo &L) {
22972
0
  if (!isActive()) return true;
22973
0
  CurrentSource = L;
22974
0
  return Shl<PT_Uint16, PT_Sint16>(S, OpPC);
22975
0
}
22976
0
bool EvalEmitter::emitShlUint16Uint16(const SourceInfo &L) {
22977
0
  if (!isActive()) return true;
22978
0
  CurrentSource = L;
22979
0
  return Shl<PT_Uint16, PT_Uint16>(S, OpPC);
22980
0
}
22981
0
bool EvalEmitter::emitShlUint16Sint32(const SourceInfo &L) {
22982
0
  if (!isActive()) return true;
22983
0
  CurrentSource = L;
22984
0
  return Shl<PT_Uint16, PT_Sint32>(S, OpPC);
22985
0
}
22986
0
bool EvalEmitter::emitShlUint16Uint32(const SourceInfo &L) {
22987
0
  if (!isActive()) return true;
22988
0
  CurrentSource = L;
22989
0
  return Shl<PT_Uint16, PT_Uint32>(S, OpPC);
22990
0
}
22991
0
bool EvalEmitter::emitShlUint16Sint64(const SourceInfo &L) {
22992
0
  if (!isActive()) return true;
22993
0
  CurrentSource = L;
22994
0
  return Shl<PT_Uint16, PT_Sint64>(S, OpPC);
22995
0
}
22996
0
bool EvalEmitter::emitShlUint16Uint64(const SourceInfo &L) {
22997
0
  if (!isActive()) return true;
22998
0
  CurrentSource = L;
22999
0
  return Shl<PT_Uint16, PT_Uint64>(S, OpPC);
23000
0
}
23001
0
bool EvalEmitter::emitShlUint16IntAP(const SourceInfo &L) {
23002
0
  if (!isActive()) return true;
23003
0
  CurrentSource = L;
23004
0
  return Shl<PT_Uint16, PT_IntAP>(S, OpPC);
23005
0
}
23006
0
bool EvalEmitter::emitShlUint16IntAPS(const SourceInfo &L) {
23007
0
  if (!isActive()) return true;
23008
0
  CurrentSource = L;
23009
0
  return Shl<PT_Uint16, PT_IntAPS>(S, OpPC);
23010
0
}
23011
0
bool EvalEmitter::emitShlSint32Sint8(const SourceInfo &L) {
23012
0
  if (!isActive()) return true;
23013
0
  CurrentSource = L;
23014
0
  return Shl<PT_Sint32, PT_Sint8>(S, OpPC);
23015
0
}
23016
0
bool EvalEmitter::emitShlSint32Uint8(const SourceInfo &L) {
23017
0
  if (!isActive()) return true;
23018
0
  CurrentSource = L;
23019
0
  return Shl<PT_Sint32, PT_Uint8>(S, OpPC);
23020
0
}
23021
0
bool EvalEmitter::emitShlSint32Sint16(const SourceInfo &L) {
23022
0
  if (!isActive()) return true;
23023
0
  CurrentSource = L;
23024
0
  return Shl<PT_Sint32, PT_Sint16>(S, OpPC);
23025
0
}
23026
0
bool EvalEmitter::emitShlSint32Uint16(const SourceInfo &L) {
23027
0
  if (!isActive()) return true;
23028
0
  CurrentSource = L;
23029
0
  return Shl<PT_Sint32, PT_Uint16>(S, OpPC);
23030
0
}
23031
0
bool EvalEmitter::emitShlSint32Sint32(const SourceInfo &L) {
23032
0
  if (!isActive()) return true;
23033
0
  CurrentSource = L;
23034
0
  return Shl<PT_Sint32, PT_Sint32>(S, OpPC);
23035
0
}
23036
0
bool EvalEmitter::emitShlSint32Uint32(const SourceInfo &L) {
23037
0
  if (!isActive()) return true;
23038
0
  CurrentSource = L;
23039
0
  return Shl<PT_Sint32, PT_Uint32>(S, OpPC);
23040
0
}
23041
0
bool EvalEmitter::emitShlSint32Sint64(const SourceInfo &L) {
23042
0
  if (!isActive()) return true;
23043
0
  CurrentSource = L;
23044
0
  return Shl<PT_Sint32, PT_Sint64>(S, OpPC);
23045
0
}
23046
0
bool EvalEmitter::emitShlSint32Uint64(const SourceInfo &L) {
23047
0
  if (!isActive()) return true;
23048
0
  CurrentSource = L;
23049
0
  return Shl<PT_Sint32, PT_Uint64>(S, OpPC);
23050
0
}
23051
0
bool EvalEmitter::emitShlSint32IntAP(const SourceInfo &L) {
23052
0
  if (!isActive()) return true;
23053
0
  CurrentSource = L;
23054
0
  return Shl<PT_Sint32, PT_IntAP>(S, OpPC);
23055
0
}
23056
0
bool EvalEmitter::emitShlSint32IntAPS(const SourceInfo &L) {
23057
0
  if (!isActive()) return true;
23058
0
  CurrentSource = L;
23059
0
  return Shl<PT_Sint32, PT_IntAPS>(S, OpPC);
23060
0
}
23061
0
bool EvalEmitter::emitShlUint32Sint8(const SourceInfo &L) {
23062
0
  if (!isActive()) return true;
23063
0
  CurrentSource = L;
23064
0
  return Shl<PT_Uint32, PT_Sint8>(S, OpPC);
23065
0
}
23066
0
bool EvalEmitter::emitShlUint32Uint8(const SourceInfo &L) {
23067
0
  if (!isActive()) return true;
23068
0
  CurrentSource = L;
23069
0
  return Shl<PT_Uint32, PT_Uint8>(S, OpPC);
23070
0
}
23071
0
bool EvalEmitter::emitShlUint32Sint16(const SourceInfo &L) {
23072
0
  if (!isActive()) return true;
23073
0
  CurrentSource = L;
23074
0
  return Shl<PT_Uint32, PT_Sint16>(S, OpPC);
23075
0
}
23076
0
bool EvalEmitter::emitShlUint32Uint16(const SourceInfo &L) {
23077
0
  if (!isActive()) return true;
23078
0
  CurrentSource = L;
23079
0
  return Shl<PT_Uint32, PT_Uint16>(S, OpPC);
23080
0
}
23081
0
bool EvalEmitter::emitShlUint32Sint32(const SourceInfo &L) {
23082
0
  if (!isActive()) return true;
23083
0
  CurrentSource = L;
23084
0
  return Shl<PT_Uint32, PT_Sint32>(S, OpPC);
23085
0
}
23086
0
bool EvalEmitter::emitShlUint32Uint32(const SourceInfo &L) {
23087
0
  if (!isActive()) return true;
23088
0
  CurrentSource = L;
23089
0
  return Shl<PT_Uint32, PT_Uint32>(S, OpPC);
23090
0
}
23091
0
bool EvalEmitter::emitShlUint32Sint64(const SourceInfo &L) {
23092
0
  if (!isActive()) return true;
23093
0
  CurrentSource = L;
23094
0
  return Shl<PT_Uint32, PT_Sint64>(S, OpPC);
23095
0
}
23096
0
bool EvalEmitter::emitShlUint32Uint64(const SourceInfo &L) {
23097
0
  if (!isActive()) return true;
23098
0
  CurrentSource = L;
23099
0
  return Shl<PT_Uint32, PT_Uint64>(S, OpPC);
23100
0
}
23101
0
bool EvalEmitter::emitShlUint32IntAP(const SourceInfo &L) {
23102
0
  if (!isActive()) return true;
23103
0
  CurrentSource = L;
23104
0
  return Shl<PT_Uint32, PT_IntAP>(S, OpPC);
23105
0
}
23106
0
bool EvalEmitter::emitShlUint32IntAPS(const SourceInfo &L) {
23107
0
  if (!isActive()) return true;
23108
0
  CurrentSource = L;
23109
0
  return Shl<PT_Uint32, PT_IntAPS>(S, OpPC);
23110
0
}
23111
0
bool EvalEmitter::emitShlSint64Sint8(const SourceInfo &L) {
23112
0
  if (!isActive()) return true;
23113
0
  CurrentSource = L;
23114
0
  return Shl<PT_Sint64, PT_Sint8>(S, OpPC);
23115
0
}
23116
0
bool EvalEmitter::emitShlSint64Uint8(const SourceInfo &L) {
23117
0
  if (!isActive()) return true;
23118
0
  CurrentSource = L;
23119
0
  return Shl<PT_Sint64, PT_Uint8>(S, OpPC);
23120
0
}
23121
0
bool EvalEmitter::emitShlSint64Sint16(const SourceInfo &L) {
23122
0
  if (!isActive()) return true;
23123
0
  CurrentSource = L;
23124
0
  return Shl<PT_Sint64, PT_Sint16>(S, OpPC);
23125
0
}
23126
0
bool EvalEmitter::emitShlSint64Uint16(const SourceInfo &L) {
23127
0
  if (!isActive()) return true;
23128
0
  CurrentSource = L;
23129
0
  return Shl<PT_Sint64, PT_Uint16>(S, OpPC);
23130
0
}
23131
0
bool EvalEmitter::emitShlSint64Sint32(const SourceInfo &L) {
23132
0
  if (!isActive()) return true;
23133
0
  CurrentSource = L;
23134
0
  return Shl<PT_Sint64, PT_Sint32>(S, OpPC);
23135
0
}
23136
0
bool EvalEmitter::emitShlSint64Uint32(const SourceInfo &L) {
23137
0
  if (!isActive()) return true;
23138
0
  CurrentSource = L;
23139
0
  return Shl<PT_Sint64, PT_Uint32>(S, OpPC);
23140
0
}
23141
0
bool EvalEmitter::emitShlSint64Sint64(const SourceInfo &L) {
23142
0
  if (!isActive()) return true;
23143
0
  CurrentSource = L;
23144
0
  return Shl<PT_Sint64, PT_Sint64>(S, OpPC);
23145
0
}
23146
0
bool EvalEmitter::emitShlSint64Uint64(const SourceInfo &L) {
23147
0
  if (!isActive()) return true;
23148
0
  CurrentSource = L;
23149
0
  return Shl<PT_Sint64, PT_Uint64>(S, OpPC);
23150
0
}
23151
0
bool EvalEmitter::emitShlSint64IntAP(const SourceInfo &L) {
23152
0
  if (!isActive()) return true;
23153
0
  CurrentSource = L;
23154
0
  return Shl<PT_Sint64, PT_IntAP>(S, OpPC);
23155
0
}
23156
0
bool EvalEmitter::emitShlSint64IntAPS(const SourceInfo &L) {
23157
0
  if (!isActive()) return true;
23158
0
  CurrentSource = L;
23159
0
  return Shl<PT_Sint64, PT_IntAPS>(S, OpPC);
23160
0
}
23161
0
bool EvalEmitter::emitShlUint64Sint8(const SourceInfo &L) {
23162
0
  if (!isActive()) return true;
23163
0
  CurrentSource = L;
23164
0
  return Shl<PT_Uint64, PT_Sint8>(S, OpPC);
23165
0
}
23166
0
bool EvalEmitter::emitShlUint64Uint8(const SourceInfo &L) {
23167
0
  if (!isActive()) return true;
23168
0
  CurrentSource = L;
23169
0
  return Shl<PT_Uint64, PT_Uint8>(S, OpPC);
23170
0
}
23171
0
bool EvalEmitter::emitShlUint64Sint16(const SourceInfo &L) {
23172
0
  if (!isActive()) return true;
23173
0
  CurrentSource = L;
23174
0
  return Shl<PT_Uint64, PT_Sint16>(S, OpPC);
23175
0
}
23176
0
bool EvalEmitter::emitShlUint64Uint16(const SourceInfo &L) {
23177
0
  if (!isActive()) return true;
23178
0
  CurrentSource = L;
23179
0
  return Shl<PT_Uint64, PT_Uint16>(S, OpPC);
23180
0
}
23181
0
bool EvalEmitter::emitShlUint64Sint32(const SourceInfo &L) {
23182
0
  if (!isActive()) return true;
23183
0
  CurrentSource = L;
23184
0
  return Shl<PT_Uint64, PT_Sint32>(S, OpPC);
23185
0
}
23186
0
bool EvalEmitter::emitShlUint64Uint32(const SourceInfo &L) {
23187
0
  if (!isActive()) return true;
23188
0
  CurrentSource = L;
23189
0
  return Shl<PT_Uint64, PT_Uint32>(S, OpPC);
23190
0
}
23191
0
bool EvalEmitter::emitShlUint64Sint64(const SourceInfo &L) {
23192
0
  if (!isActive()) return true;
23193
0
  CurrentSource = L;
23194
0
  return Shl<PT_Uint64, PT_Sint64>(S, OpPC);
23195
0
}
23196
0
bool EvalEmitter::emitShlUint64Uint64(const SourceInfo &L) {
23197
0
  if (!isActive()) return true;
23198
0
  CurrentSource = L;
23199
0
  return Shl<PT_Uint64, PT_Uint64>(S, OpPC);
23200
0
}
23201
0
bool EvalEmitter::emitShlUint64IntAP(const SourceInfo &L) {
23202
0
  if (!isActive()) return true;
23203
0
  CurrentSource = L;
23204
0
  return Shl<PT_Uint64, PT_IntAP>(S, OpPC);
23205
0
}
23206
0
bool EvalEmitter::emitShlUint64IntAPS(const SourceInfo &L) {
23207
0
  if (!isActive()) return true;
23208
0
  CurrentSource = L;
23209
0
  return Shl<PT_Uint64, PT_IntAPS>(S, OpPC);
23210
0
}
23211
0
bool EvalEmitter::emitShlIntAPSint8(const SourceInfo &L) {
23212
0
  if (!isActive()) return true;
23213
0
  CurrentSource = L;
23214
0
  return Shl<PT_IntAP, PT_Sint8>(S, OpPC);
23215
0
}
23216
0
bool EvalEmitter::emitShlIntAPUint8(const SourceInfo &L) {
23217
0
  if (!isActive()) return true;
23218
0
  CurrentSource = L;
23219
0
  return Shl<PT_IntAP, PT_Uint8>(S, OpPC);
23220
0
}
23221
0
bool EvalEmitter::emitShlIntAPSint16(const SourceInfo &L) {
23222
0
  if (!isActive()) return true;
23223
0
  CurrentSource = L;
23224
0
  return Shl<PT_IntAP, PT_Sint16>(S, OpPC);
23225
0
}
23226
0
bool EvalEmitter::emitShlIntAPUint16(const SourceInfo &L) {
23227
0
  if (!isActive()) return true;
23228
0
  CurrentSource = L;
23229
0
  return Shl<PT_IntAP, PT_Uint16>(S, OpPC);
23230
0
}
23231
0
bool EvalEmitter::emitShlIntAPSint32(const SourceInfo &L) {
23232
0
  if (!isActive()) return true;
23233
0
  CurrentSource = L;
23234
0
  return Shl<PT_IntAP, PT_Sint32>(S, OpPC);
23235
0
}
23236
0
bool EvalEmitter::emitShlIntAPUint32(const SourceInfo &L) {
23237
0
  if (!isActive()) return true;
23238
0
  CurrentSource = L;
23239
0
  return Shl<PT_IntAP, PT_Uint32>(S, OpPC);
23240
0
}
23241
0
bool EvalEmitter::emitShlIntAPSint64(const SourceInfo &L) {
23242
0
  if (!isActive()) return true;
23243
0
  CurrentSource = L;
23244
0
  return Shl<PT_IntAP, PT_Sint64>(S, OpPC);
23245
0
}
23246
0
bool EvalEmitter::emitShlIntAPUint64(const SourceInfo &L) {
23247
0
  if (!isActive()) return true;
23248
0
  CurrentSource = L;
23249
0
  return Shl<PT_IntAP, PT_Uint64>(S, OpPC);
23250
0
}
23251
0
bool EvalEmitter::emitShlIntAPIntAP(const SourceInfo &L) {
23252
0
  if (!isActive()) return true;
23253
0
  CurrentSource = L;
23254
0
  return Shl<PT_IntAP, PT_IntAP>(S, OpPC);
23255
0
}
23256
0
bool EvalEmitter::emitShlIntAPIntAPS(const SourceInfo &L) {
23257
0
  if (!isActive()) return true;
23258
0
  CurrentSource = L;
23259
0
  return Shl<PT_IntAP, PT_IntAPS>(S, OpPC);
23260
0
}
23261
0
bool EvalEmitter::emitShlIntAPSSint8(const SourceInfo &L) {
23262
0
  if (!isActive()) return true;
23263
0
  CurrentSource = L;
23264
0
  return Shl<PT_IntAPS, PT_Sint8>(S, OpPC);
23265
0
}
23266
0
bool EvalEmitter::emitShlIntAPSUint8(const SourceInfo &L) {
23267
0
  if (!isActive()) return true;
23268
0
  CurrentSource = L;
23269
0
  return Shl<PT_IntAPS, PT_Uint8>(S, OpPC);
23270
0
}
23271
0
bool EvalEmitter::emitShlIntAPSSint16(const SourceInfo &L) {
23272
0
  if (!isActive()) return true;
23273
0
  CurrentSource = L;
23274
0
  return Shl<PT_IntAPS, PT_Sint16>(S, OpPC);
23275
0
}
23276
0
bool EvalEmitter::emitShlIntAPSUint16(const SourceInfo &L) {
23277
0
  if (!isActive()) return true;
23278
0
  CurrentSource = L;
23279
0
  return Shl<PT_IntAPS, PT_Uint16>(S, OpPC);
23280
0
}
23281
0
bool EvalEmitter::emitShlIntAPSSint32(const SourceInfo &L) {
23282
0
  if (!isActive()) return true;
23283
0
  CurrentSource = L;
23284
0
  return Shl<PT_IntAPS, PT_Sint32>(S, OpPC);
23285
0
}
23286
0
bool EvalEmitter::emitShlIntAPSUint32(const SourceInfo &L) {
23287
0
  if (!isActive()) return true;
23288
0
  CurrentSource = L;
23289
0
  return Shl<PT_IntAPS, PT_Uint32>(S, OpPC);
23290
0
}
23291
0
bool EvalEmitter::emitShlIntAPSSint64(const SourceInfo &L) {
23292
0
  if (!isActive()) return true;
23293
0
  CurrentSource = L;
23294
0
  return Shl<PT_IntAPS, PT_Sint64>(S, OpPC);
23295
0
}
23296
0
bool EvalEmitter::emitShlIntAPSUint64(const SourceInfo &L) {
23297
0
  if (!isActive()) return true;
23298
0
  CurrentSource = L;
23299
0
  return Shl<PT_IntAPS, PT_Uint64>(S, OpPC);
23300
0
}
23301
0
bool EvalEmitter::emitShlIntAPSIntAP(const SourceInfo &L) {
23302
0
  if (!isActive()) return true;
23303
0
  CurrentSource = L;
23304
0
  return Shl<PT_IntAPS, PT_IntAP>(S, OpPC);
23305
0
}
23306
0
bool EvalEmitter::emitShlIntAPSIntAPS(const SourceInfo &L) {
23307
0
  if (!isActive()) return true;
23308
0
  CurrentSource = L;
23309
0
  return Shl<PT_IntAPS, PT_IntAPS>(S, OpPC);
23310
0
}
23311
#endif
23312
#ifdef GET_OPCODE_NAMES
23313
OP_ShrSint8Sint8,
23314
OP_ShrSint8Uint8,
23315
OP_ShrSint8Sint16,
23316
OP_ShrSint8Uint16,
23317
OP_ShrSint8Sint32,
23318
OP_ShrSint8Uint32,
23319
OP_ShrSint8Sint64,
23320
OP_ShrSint8Uint64,
23321
OP_ShrSint8IntAP,
23322
OP_ShrSint8IntAPS,
23323
OP_ShrUint8Sint8,
23324
OP_ShrUint8Uint8,
23325
OP_ShrUint8Sint16,
23326
OP_ShrUint8Uint16,
23327
OP_ShrUint8Sint32,
23328
OP_ShrUint8Uint32,
23329
OP_ShrUint8Sint64,
23330
OP_ShrUint8Uint64,
23331
OP_ShrUint8IntAP,
23332
OP_ShrUint8IntAPS,
23333
OP_ShrSint16Sint8,
23334
OP_ShrSint16Uint8,
23335
OP_ShrSint16Sint16,
23336
OP_ShrSint16Uint16,
23337
OP_ShrSint16Sint32,
23338
OP_ShrSint16Uint32,
23339
OP_ShrSint16Sint64,
23340
OP_ShrSint16Uint64,
23341
OP_ShrSint16IntAP,
23342
OP_ShrSint16IntAPS,
23343
OP_ShrUint16Sint8,
23344
OP_ShrUint16Uint8,
23345
OP_ShrUint16Sint16,
23346
OP_ShrUint16Uint16,
23347
OP_ShrUint16Sint32,
23348
OP_ShrUint16Uint32,
23349
OP_ShrUint16Sint64,
23350
OP_ShrUint16Uint64,
23351
OP_ShrUint16IntAP,
23352
OP_ShrUint16IntAPS,
23353
OP_ShrSint32Sint8,
23354
OP_ShrSint32Uint8,
23355
OP_ShrSint32Sint16,
23356
OP_ShrSint32Uint16,
23357
OP_ShrSint32Sint32,
23358
OP_ShrSint32Uint32,
23359
OP_ShrSint32Sint64,
23360
OP_ShrSint32Uint64,
23361
OP_ShrSint32IntAP,
23362
OP_ShrSint32IntAPS,
23363
OP_ShrUint32Sint8,
23364
OP_ShrUint32Uint8,
23365
OP_ShrUint32Sint16,
23366
OP_ShrUint32Uint16,
23367
OP_ShrUint32Sint32,
23368
OP_ShrUint32Uint32,
23369
OP_ShrUint32Sint64,
23370
OP_ShrUint32Uint64,
23371
OP_ShrUint32IntAP,
23372
OP_ShrUint32IntAPS,
23373
OP_ShrSint64Sint8,
23374
OP_ShrSint64Uint8,
23375
OP_ShrSint64Sint16,
23376
OP_ShrSint64Uint16,
23377
OP_ShrSint64Sint32,
23378
OP_ShrSint64Uint32,
23379
OP_ShrSint64Sint64,
23380
OP_ShrSint64Uint64,
23381
OP_ShrSint64IntAP,
23382
OP_ShrSint64IntAPS,
23383
OP_ShrUint64Sint8,
23384
OP_ShrUint64Uint8,
23385
OP_ShrUint64Sint16,
23386
OP_ShrUint64Uint16,
23387
OP_ShrUint64Sint32,
23388
OP_ShrUint64Uint32,
23389
OP_ShrUint64Sint64,
23390
OP_ShrUint64Uint64,
23391
OP_ShrUint64IntAP,
23392
OP_ShrUint64IntAPS,
23393
OP_ShrIntAPSint8,
23394
OP_ShrIntAPUint8,
23395
OP_ShrIntAPSint16,
23396
OP_ShrIntAPUint16,
23397
OP_ShrIntAPSint32,
23398
OP_ShrIntAPUint32,
23399
OP_ShrIntAPSint64,
23400
OP_ShrIntAPUint64,
23401
OP_ShrIntAPIntAP,
23402
OP_ShrIntAPIntAPS,
23403
OP_ShrIntAPSSint8,
23404
OP_ShrIntAPSUint8,
23405
OP_ShrIntAPSSint16,
23406
OP_ShrIntAPSUint16,
23407
OP_ShrIntAPSSint32,
23408
OP_ShrIntAPSUint32,
23409
OP_ShrIntAPSSint64,
23410
OP_ShrIntAPSUint64,
23411
OP_ShrIntAPSIntAP,
23412
OP_ShrIntAPSIntAPS,
23413
#endif
23414
0
#ifdef GET_INTERP
23415
0
case OP_ShrSint8Sint8: {
23416
0
  if (!Shr<PT_Sint8, PT_Sint8>(S, OpPC))
23417
0
    return false;
23418
0
  continue;
23419
0
}
23420
0
case OP_ShrSint8Uint8: {
23421
0
  if (!Shr<PT_Sint8, PT_Uint8>(S, OpPC))
23422
0
    return false;
23423
0
  continue;
23424
0
}
23425
0
case OP_ShrSint8Sint16: {
23426
0
  if (!Shr<PT_Sint8, PT_Sint16>(S, OpPC))
23427
0
    return false;
23428
0
  continue;
23429
0
}
23430
0
case OP_ShrSint8Uint16: {
23431
0
  if (!Shr<PT_Sint8, PT_Uint16>(S, OpPC))
23432
0
    return false;
23433
0
  continue;
23434
0
}
23435
0
case OP_ShrSint8Sint32: {
23436
0
  if (!Shr<PT_Sint8, PT_Sint32>(S, OpPC))
23437
0
    return false;
23438
0
  continue;
23439
0
}
23440
0
case OP_ShrSint8Uint32: {
23441
0
  if (!Shr<PT_Sint8, PT_Uint32>(S, OpPC))
23442
0
    return false;
23443
0
  continue;
23444
0
}
23445
0
case OP_ShrSint8Sint64: {
23446
0
  if (!Shr<PT_Sint8, PT_Sint64>(S, OpPC))
23447
0
    return false;
23448
0
  continue;
23449
0
}
23450
0
case OP_ShrSint8Uint64: {
23451
0
  if (!Shr<PT_Sint8, PT_Uint64>(S, OpPC))
23452
0
    return false;
23453
0
  continue;
23454
0
}
23455
0
case OP_ShrSint8IntAP: {
23456
0
  if (!Shr<PT_Sint8, PT_IntAP>(S, OpPC))
23457
0
    return false;
23458
0
  continue;
23459
0
}
23460
0
case OP_ShrSint8IntAPS: {
23461
0
  if (!Shr<PT_Sint8, PT_IntAPS>(S, OpPC))
23462
0
    return false;
23463
0
  continue;
23464
0
}
23465
0
case OP_ShrUint8Sint8: {
23466
0
  if (!Shr<PT_Uint8, PT_Sint8>(S, OpPC))
23467
0
    return false;
23468
0
  continue;
23469
0
}
23470
0
case OP_ShrUint8Uint8: {
23471
0
  if (!Shr<PT_Uint8, PT_Uint8>(S, OpPC))
23472
0
    return false;
23473
0
  continue;
23474
0
}
23475
0
case OP_ShrUint8Sint16: {
23476
0
  if (!Shr<PT_Uint8, PT_Sint16>(S, OpPC))
23477
0
    return false;
23478
0
  continue;
23479
0
}
23480
0
case OP_ShrUint8Uint16: {
23481
0
  if (!Shr<PT_Uint8, PT_Uint16>(S, OpPC))
23482
0
    return false;
23483
0
  continue;
23484
0
}
23485
0
case OP_ShrUint8Sint32: {
23486
0
  if (!Shr<PT_Uint8, PT_Sint32>(S, OpPC))
23487
0
    return false;
23488
0
  continue;
23489
0
}
23490
0
case OP_ShrUint8Uint32: {
23491
0
  if (!Shr<PT_Uint8, PT_Uint32>(S, OpPC))
23492
0
    return false;
23493
0
  continue;
23494
0
}
23495
0
case OP_ShrUint8Sint64: {
23496
0
  if (!Shr<PT_Uint8, PT_Sint64>(S, OpPC))
23497
0
    return false;
23498
0
  continue;
23499
0
}
23500
0
case OP_ShrUint8Uint64: {
23501
0
  if (!Shr<PT_Uint8, PT_Uint64>(S, OpPC))
23502
0
    return false;
23503
0
  continue;
23504
0
}
23505
0
case OP_ShrUint8IntAP: {
23506
0
  if (!Shr<PT_Uint8, PT_IntAP>(S, OpPC))
23507
0
    return false;
23508
0
  continue;
23509
0
}
23510
0
case OP_ShrUint8IntAPS: {
23511
0
  if (!Shr<PT_Uint8, PT_IntAPS>(S, OpPC))
23512
0
    return false;
23513
0
  continue;
23514
0
}
23515
0
case OP_ShrSint16Sint8: {
23516
0
  if (!Shr<PT_Sint16, PT_Sint8>(S, OpPC))
23517
0
    return false;
23518
0
  continue;
23519
0
}
23520
0
case OP_ShrSint16Uint8: {
23521
0
  if (!Shr<PT_Sint16, PT_Uint8>(S, OpPC))
23522
0
    return false;
23523
0
  continue;
23524
0
}
23525
0
case OP_ShrSint16Sint16: {
23526
0
  if (!Shr<PT_Sint16, PT_Sint16>(S, OpPC))
23527
0
    return false;
23528
0
  continue;
23529
0
}
23530
0
case OP_ShrSint16Uint16: {
23531
0
  if (!Shr<PT_Sint16, PT_Uint16>(S, OpPC))
23532
0
    return false;
23533
0
  continue;
23534
0
}
23535
0
case OP_ShrSint16Sint32: {
23536
0
  if (!Shr<PT_Sint16, PT_Sint32>(S, OpPC))
23537
0
    return false;
23538
0
  continue;
23539
0
}
23540
0
case OP_ShrSint16Uint32: {
23541
0
  if (!Shr<PT_Sint16, PT_Uint32>(S, OpPC))
23542
0
    return false;
23543
0
  continue;
23544
0
}
23545
0
case OP_ShrSint16Sint64: {
23546
0
  if (!Shr<PT_Sint16, PT_Sint64>(S, OpPC))
23547
0
    return false;
23548
0
  continue;
23549
0
}
23550
0
case OP_ShrSint16Uint64: {
23551
0
  if (!Shr<PT_Sint16, PT_Uint64>(S, OpPC))
23552
0
    return false;
23553
0
  continue;
23554
0
}
23555
0
case OP_ShrSint16IntAP: {
23556
0
  if (!Shr<PT_Sint16, PT_IntAP>(S, OpPC))
23557
0
    return false;
23558
0
  continue;
23559
0
}
23560
0
case OP_ShrSint16IntAPS: {
23561
0
  if (!Shr<PT_Sint16, PT_IntAPS>(S, OpPC))
23562
0
    return false;
23563
0
  continue;
23564
0
}
23565
0
case OP_ShrUint16Sint8: {
23566
0
  if (!Shr<PT_Uint16, PT_Sint8>(S, OpPC))
23567
0
    return false;
23568
0
  continue;
23569
0
}
23570
0
case OP_ShrUint16Uint8: {
23571
0
  if (!Shr<PT_Uint16, PT_Uint8>(S, OpPC))
23572
0
    return false;
23573
0
  continue;
23574
0
}
23575
0
case OP_ShrUint16Sint16: {
23576
0
  if (!Shr<PT_Uint16, PT_Sint16>(S, OpPC))
23577
0
    return false;
23578
0
  continue;
23579
0
}
23580
0
case OP_ShrUint16Uint16: {
23581
0
  if (!Shr<PT_Uint16, PT_Uint16>(S, OpPC))
23582
0
    return false;
23583
0
  continue;
23584
0
}
23585
0
case OP_ShrUint16Sint32: {
23586
0
  if (!Shr<PT_Uint16, PT_Sint32>(S, OpPC))
23587
0
    return false;
23588
0
  continue;
23589
0
}
23590
0
case OP_ShrUint16Uint32: {
23591
0
  if (!Shr<PT_Uint16, PT_Uint32>(S, OpPC))
23592
0
    return false;
23593
0
  continue;
23594
0
}
23595
0
case OP_ShrUint16Sint64: {
23596
0
  if (!Shr<PT_Uint16, PT_Sint64>(S, OpPC))
23597
0
    return false;
23598
0
  continue;
23599
0
}
23600
0
case OP_ShrUint16Uint64: {
23601
0
  if (!Shr<PT_Uint16, PT_Uint64>(S, OpPC))
23602
0
    return false;
23603
0
  continue;
23604
0
}
23605
0
case OP_ShrUint16IntAP: {
23606
0
  if (!Shr<PT_Uint16, PT_IntAP>(S, OpPC))
23607
0
    return false;
23608
0
  continue;
23609
0
}
23610
0
case OP_ShrUint16IntAPS: {
23611
0
  if (!Shr<PT_Uint16, PT_IntAPS>(S, OpPC))
23612
0
    return false;
23613
0
  continue;
23614
0
}
23615
0
case OP_ShrSint32Sint8: {
23616
0
  if (!Shr<PT_Sint32, PT_Sint8>(S, OpPC))
23617
0
    return false;
23618
0
  continue;
23619
0
}
23620
0
case OP_ShrSint32Uint8: {
23621
0
  if (!Shr<PT_Sint32, PT_Uint8>(S, OpPC))
23622
0
    return false;
23623
0
  continue;
23624
0
}
23625
0
case OP_ShrSint32Sint16: {
23626
0
  if (!Shr<PT_Sint32, PT_Sint16>(S, OpPC))
23627
0
    return false;
23628
0
  continue;
23629
0
}
23630
0
case OP_ShrSint32Uint16: {
23631
0
  if (!Shr<PT_Sint32, PT_Uint16>(S, OpPC))
23632
0
    return false;
23633
0
  continue;
23634
0
}
23635
0
case OP_ShrSint32Sint32: {
23636
0
  if (!Shr<PT_Sint32, PT_Sint32>(S, OpPC))
23637
0
    return false;
23638
0
  continue;
23639
0
}
23640
0
case OP_ShrSint32Uint32: {
23641
0
  if (!Shr<PT_Sint32, PT_Uint32>(S, OpPC))
23642
0
    return false;
23643
0
  continue;
23644
0
}
23645
0
case OP_ShrSint32Sint64: {
23646
0
  if (!Shr<PT_Sint32, PT_Sint64>(S, OpPC))
23647
0
    return false;
23648
0
  continue;
23649
0
}
23650
0
case OP_ShrSint32Uint64: {
23651
0
  if (!Shr<PT_Sint32, PT_Uint64>(S, OpPC))
23652
0
    return false;
23653
0
  continue;
23654
0
}
23655
0
case OP_ShrSint32IntAP: {
23656
0
  if (!Shr<PT_Sint32, PT_IntAP>(S, OpPC))
23657
0
    return false;
23658
0
  continue;
23659
0
}
23660
0
case OP_ShrSint32IntAPS: {
23661
0
  if (!Shr<PT_Sint32, PT_IntAPS>(S, OpPC))
23662
0
    return false;
23663
0
  continue;
23664
0
}
23665
0
case OP_ShrUint32Sint8: {
23666
0
  if (!Shr<PT_Uint32, PT_Sint8>(S, OpPC))
23667
0
    return false;
23668
0
  continue;
23669
0
}
23670
0
case OP_ShrUint32Uint8: {
23671
0
  if (!Shr<PT_Uint32, PT_Uint8>(S, OpPC))
23672
0
    return false;
23673
0
  continue;
23674
0
}
23675
0
case OP_ShrUint32Sint16: {
23676
0
  if (!Shr<PT_Uint32, PT_Sint16>(S, OpPC))
23677
0
    return false;
23678
0
  continue;
23679
0
}
23680
0
case OP_ShrUint32Uint16: {
23681
0
  if (!Shr<PT_Uint32, PT_Uint16>(S, OpPC))
23682
0
    return false;
23683
0
  continue;
23684
0
}
23685
0
case OP_ShrUint32Sint32: {
23686
0
  if (!Shr<PT_Uint32, PT_Sint32>(S, OpPC))
23687
0
    return false;
23688
0
  continue;
23689
0
}
23690
0
case OP_ShrUint32Uint32: {
23691
0
  if (!Shr<PT_Uint32, PT_Uint32>(S, OpPC))
23692
0
    return false;
23693
0
  continue;
23694
0
}
23695
0
case OP_ShrUint32Sint64: {
23696
0
  if (!Shr<PT_Uint32, PT_Sint64>(S, OpPC))
23697
0
    return false;
23698
0
  continue;
23699
0
}
23700
0
case OP_ShrUint32Uint64: {
23701
0
  if (!Shr<PT_Uint32, PT_Uint64>(S, OpPC))
23702
0
    return false;
23703
0
  continue;
23704
0
}
23705
0
case OP_ShrUint32IntAP: {
23706
0
  if (!Shr<PT_Uint32, PT_IntAP>(S, OpPC))
23707
0
    return false;
23708
0
  continue;
23709
0
}
23710
0
case OP_ShrUint32IntAPS: {
23711
0
  if (!Shr<PT_Uint32, PT_IntAPS>(S, OpPC))
23712
0
    return false;
23713
0
  continue;
23714
0
}
23715
0
case OP_ShrSint64Sint8: {
23716
0
  if (!Shr<PT_Sint64, PT_Sint8>(S, OpPC))
23717
0
    return false;
23718
0
  continue;
23719
0
}
23720
0
case OP_ShrSint64Uint8: {
23721
0
  if (!Shr<PT_Sint64, PT_Uint8>(S, OpPC))
23722
0
    return false;
23723
0
  continue;
23724
0
}
23725
0
case OP_ShrSint64Sint16: {
23726
0
  if (!Shr<PT_Sint64, PT_Sint16>(S, OpPC))
23727
0
    return false;
23728
0
  continue;
23729
0
}
23730
0
case OP_ShrSint64Uint16: {
23731
0
  if (!Shr<PT_Sint64, PT_Uint16>(S, OpPC))
23732
0
    return false;
23733
0
  continue;
23734
0
}
23735
0
case OP_ShrSint64Sint32: {
23736
0
  if (!Shr<PT_Sint64, PT_Sint32>(S, OpPC))
23737
0
    return false;
23738
0
  continue;
23739
0
}
23740
0
case OP_ShrSint64Uint32: {
23741
0
  if (!Shr<PT_Sint64, PT_Uint32>(S, OpPC))
23742
0
    return false;
23743
0
  continue;
23744
0
}
23745
0
case OP_ShrSint64Sint64: {
23746
0
  if (!Shr<PT_Sint64, PT_Sint64>(S, OpPC))
23747
0
    return false;
23748
0
  continue;
23749
0
}
23750
0
case OP_ShrSint64Uint64: {
23751
0
  if (!Shr<PT_Sint64, PT_Uint64>(S, OpPC))
23752
0
    return false;
23753
0
  continue;
23754
0
}
23755
0
case OP_ShrSint64IntAP: {
23756
0
  if (!Shr<PT_Sint64, PT_IntAP>(S, OpPC))
23757
0
    return false;
23758
0
  continue;
23759
0
}
23760
0
case OP_ShrSint64IntAPS: {
23761
0
  if (!Shr<PT_Sint64, PT_IntAPS>(S, OpPC))
23762
0
    return false;
23763
0
  continue;
23764
0
}
23765
0
case OP_ShrUint64Sint8: {
23766
0
  if (!Shr<PT_Uint64, PT_Sint8>(S, OpPC))
23767
0
    return false;
23768
0
  continue;
23769
0
}
23770
0
case OP_ShrUint64Uint8: {
23771
0
  if (!Shr<PT_Uint64, PT_Uint8>(S, OpPC))
23772
0
    return false;
23773
0
  continue;
23774
0
}
23775
0
case OP_ShrUint64Sint16: {
23776
0
  if (!Shr<PT_Uint64, PT_Sint16>(S, OpPC))
23777
0
    return false;
23778
0
  continue;
23779
0
}
23780
0
case OP_ShrUint64Uint16: {
23781
0
  if (!Shr<PT_Uint64, PT_Uint16>(S, OpPC))
23782
0
    return false;
23783
0
  continue;
23784
0
}
23785
0
case OP_ShrUint64Sint32: {
23786
0
  if (!Shr<PT_Uint64, PT_Sint32>(S, OpPC))
23787
0
    return false;
23788
0
  continue;
23789
0
}
23790
0
case OP_ShrUint64Uint32: {
23791
0
  if (!Shr<PT_Uint64, PT_Uint32>(S, OpPC))
23792
0
    return false;
23793
0
  continue;
23794
0
}
23795
0
case OP_ShrUint64Sint64: {
23796
0
  if (!Shr<PT_Uint64, PT_Sint64>(S, OpPC))
23797
0
    return false;
23798
0
  continue;
23799
0
}
23800
0
case OP_ShrUint64Uint64: {
23801
0
  if (!Shr<PT_Uint64, PT_Uint64>(S, OpPC))
23802
0
    return false;
23803
0
  continue;
23804
0
}
23805
0
case OP_ShrUint64IntAP: {
23806
0
  if (!Shr<PT_Uint64, PT_IntAP>(S, OpPC))
23807
0
    return false;
23808
0
  continue;
23809
0
}
23810
0
case OP_ShrUint64IntAPS: {
23811
0
  if (!Shr<PT_Uint64, PT_IntAPS>(S, OpPC))
23812
0
    return false;
23813
0
  continue;
23814
0
}
23815
0
case OP_ShrIntAPSint8: {
23816
0
  if (!Shr<PT_IntAP, PT_Sint8>(S, OpPC))
23817
0
    return false;
23818
0
  continue;
23819
0
}
23820
0
case OP_ShrIntAPUint8: {
23821
0
  if (!Shr<PT_IntAP, PT_Uint8>(S, OpPC))
23822
0
    return false;
23823
0
  continue;
23824
0
}
23825
0
case OP_ShrIntAPSint16: {
23826
0
  if (!Shr<PT_IntAP, PT_Sint16>(S, OpPC))
23827
0
    return false;
23828
0
  continue;
23829
0
}
23830
0
case OP_ShrIntAPUint16: {
23831
0
  if (!Shr<PT_IntAP, PT_Uint16>(S, OpPC))
23832
0
    return false;
23833
0
  continue;
23834
0
}
23835
0
case OP_ShrIntAPSint32: {
23836
0
  if (!Shr<PT_IntAP, PT_Sint32>(S, OpPC))
23837
0
    return false;
23838
0
  continue;
23839
0
}
23840
0
case OP_ShrIntAPUint32: {
23841
0
  if (!Shr<PT_IntAP, PT_Uint32>(S, OpPC))
23842
0
    return false;
23843
0
  continue;
23844
0
}
23845
0
case OP_ShrIntAPSint64: {
23846
0
  if (!Shr<PT_IntAP, PT_Sint64>(S, OpPC))
23847
0
    return false;
23848
0
  continue;
23849
0
}
23850
0
case OP_ShrIntAPUint64: {
23851
0
  if (!Shr<PT_IntAP, PT_Uint64>(S, OpPC))
23852
0
    return false;
23853
0
  continue;
23854
0
}
23855
0
case OP_ShrIntAPIntAP: {
23856
0
  if (!Shr<PT_IntAP, PT_IntAP>(S, OpPC))
23857
0
    return false;
23858
0
  continue;
23859
0
}
23860
0
case OP_ShrIntAPIntAPS: {
23861
0
  if (!Shr<PT_IntAP, PT_IntAPS>(S, OpPC))
23862
0
    return false;
23863
0
  continue;
23864
0
}
23865
0
case OP_ShrIntAPSSint8: {
23866
0
  if (!Shr<PT_IntAPS, PT_Sint8>(S, OpPC))
23867
0
    return false;
23868
0
  continue;
23869
0
}
23870
0
case OP_ShrIntAPSUint8: {
23871
0
  if (!Shr<PT_IntAPS, PT_Uint8>(S, OpPC))
23872
0
    return false;
23873
0
  continue;
23874
0
}
23875
0
case OP_ShrIntAPSSint16: {
23876
0
  if (!Shr<PT_IntAPS, PT_Sint16>(S, OpPC))
23877
0
    return false;
23878
0
  continue;
23879
0
}
23880
0
case OP_ShrIntAPSUint16: {
23881
0
  if (!Shr<PT_IntAPS, PT_Uint16>(S, OpPC))
23882
0
    return false;
23883
0
  continue;
23884
0
}
23885
0
case OP_ShrIntAPSSint32: {
23886
0
  if (!Shr<PT_IntAPS, PT_Sint32>(S, OpPC))
23887
0
    return false;
23888
0
  continue;
23889
0
}
23890
0
case OP_ShrIntAPSUint32: {
23891
0
  if (!Shr<PT_IntAPS, PT_Uint32>(S, OpPC))
23892
0
    return false;
23893
0
  continue;
23894
0
}
23895
0
case OP_ShrIntAPSSint64: {
23896
0
  if (!Shr<PT_IntAPS, PT_Sint64>(S, OpPC))
23897
0
    return false;
23898
0
  continue;
23899
0
}
23900
0
case OP_ShrIntAPSUint64: {
23901
0
  if (!Shr<PT_IntAPS, PT_Uint64>(S, OpPC))
23902
0
    return false;
23903
0
  continue;
23904
0
}
23905
0
case OP_ShrIntAPSIntAP: {
23906
0
  if (!Shr<PT_IntAPS, PT_IntAP>(S, OpPC))
23907
0
    return false;
23908
0
  continue;
23909
0
}
23910
0
case OP_ShrIntAPSIntAPS: {
23911
0
  if (!Shr<PT_IntAPS, PT_IntAPS>(S, OpPC))
23912
0
    return false;
23913
0
  continue;
23914
0
}
23915
0
#endif
23916
#ifdef GET_DISASM
23917
case OP_ShrSint8Sint8:
23918
  PrintName("ShrSint8Sint8");
23919
  OS << "\t" << "\n";
23920
  continue;
23921
case OP_ShrSint8Uint8:
23922
  PrintName("ShrSint8Uint8");
23923
  OS << "\t" << "\n";
23924
  continue;
23925
case OP_ShrSint8Sint16:
23926
  PrintName("ShrSint8Sint16");
23927
  OS << "\t" << "\n";
23928
  continue;
23929
case OP_ShrSint8Uint16:
23930
  PrintName("ShrSint8Uint16");
23931
  OS << "\t" << "\n";
23932
  continue;
23933
case OP_ShrSint8Sint32:
23934
  PrintName("ShrSint8Sint32");
23935
  OS << "\t" << "\n";
23936
  continue;
23937
case OP_ShrSint8Uint32:
23938
  PrintName("ShrSint8Uint32");
23939
  OS << "\t" << "\n";
23940
  continue;
23941
case OP_ShrSint8Sint64:
23942
  PrintName("ShrSint8Sint64");
23943
  OS << "\t" << "\n";
23944
  continue;
23945
case OP_ShrSint8Uint64:
23946
  PrintName("ShrSint8Uint64");
23947
  OS << "\t" << "\n";
23948
  continue;
23949
case OP_ShrSint8IntAP:
23950
  PrintName("ShrSint8IntAP");
23951
  OS << "\t" << "\n";
23952
  continue;
23953
case OP_ShrSint8IntAPS:
23954
  PrintName("ShrSint8IntAPS");
23955
  OS << "\t" << "\n";
23956
  continue;
23957
case OP_ShrUint8Sint8:
23958
  PrintName("ShrUint8Sint8");
23959
  OS << "\t" << "\n";
23960
  continue;
23961
case OP_ShrUint8Uint8:
23962
  PrintName("ShrUint8Uint8");
23963
  OS << "\t" << "\n";
23964
  continue;
23965
case OP_ShrUint8Sint16:
23966
  PrintName("ShrUint8Sint16");
23967
  OS << "\t" << "\n";
23968
  continue;
23969
case OP_ShrUint8Uint16:
23970
  PrintName("ShrUint8Uint16");
23971
  OS << "\t" << "\n";
23972
  continue;
23973
case OP_ShrUint8Sint32:
23974
  PrintName("ShrUint8Sint32");
23975
  OS << "\t" << "\n";
23976
  continue;
23977
case OP_ShrUint8Uint32:
23978
  PrintName("ShrUint8Uint32");
23979
  OS << "\t" << "\n";
23980
  continue;
23981
case OP_ShrUint8Sint64:
23982
  PrintName("ShrUint8Sint64");
23983
  OS << "\t" << "\n";
23984
  continue;
23985
case OP_ShrUint8Uint64:
23986
  PrintName("ShrUint8Uint64");
23987
  OS << "\t" << "\n";
23988
  continue;
23989
case OP_ShrUint8IntAP:
23990
  PrintName("ShrUint8IntAP");
23991
  OS << "\t" << "\n";
23992
  continue;
23993
case OP_ShrUint8IntAPS:
23994
  PrintName("ShrUint8IntAPS");
23995
  OS << "\t" << "\n";
23996
  continue;
23997
case OP_ShrSint16Sint8:
23998
  PrintName("ShrSint16Sint8");
23999
  OS << "\t" << "\n";
24000
  continue;
24001
case OP_ShrSint16Uint8:
24002
  PrintName("ShrSint16Uint8");
24003
  OS << "\t" << "\n";
24004
  continue;
24005
case OP_ShrSint16Sint16:
24006
  PrintName("ShrSint16Sint16");
24007
  OS << "\t" << "\n";
24008
  continue;
24009
case OP_ShrSint16Uint16:
24010
  PrintName("ShrSint16Uint16");
24011
  OS << "\t" << "\n";
24012
  continue;
24013
case OP_ShrSint16Sint32:
24014
  PrintName("ShrSint16Sint32");
24015
  OS << "\t" << "\n";
24016
  continue;
24017
case OP_ShrSint16Uint32:
24018
  PrintName("ShrSint16Uint32");
24019
  OS << "\t" << "\n";
24020
  continue;
24021
case OP_ShrSint16Sint64:
24022
  PrintName("ShrSint16Sint64");
24023
  OS << "\t" << "\n";
24024
  continue;
24025
case OP_ShrSint16Uint64:
24026
  PrintName("ShrSint16Uint64");
24027
  OS << "\t" << "\n";
24028
  continue;
24029
case OP_ShrSint16IntAP:
24030
  PrintName("ShrSint16IntAP");
24031
  OS << "\t" << "\n";
24032
  continue;
24033
case OP_ShrSint16IntAPS:
24034
  PrintName("ShrSint16IntAPS");
24035
  OS << "\t" << "\n";
24036
  continue;
24037
case OP_ShrUint16Sint8:
24038
  PrintName("ShrUint16Sint8");
24039
  OS << "\t" << "\n";
24040
  continue;
24041
case OP_ShrUint16Uint8:
24042
  PrintName("ShrUint16Uint8");
24043
  OS << "\t" << "\n";
24044
  continue;
24045
case OP_ShrUint16Sint16:
24046
  PrintName("ShrUint16Sint16");
24047
  OS << "\t" << "\n";
24048
  continue;
24049
case OP_ShrUint16Uint16:
24050
  PrintName("ShrUint16Uint16");
24051
  OS << "\t" << "\n";
24052
  continue;
24053
case OP_ShrUint16Sint32:
24054
  PrintName("ShrUint16Sint32");
24055
  OS << "\t" << "\n";
24056
  continue;
24057
case OP_ShrUint16Uint32:
24058
  PrintName("ShrUint16Uint32");
24059
  OS << "\t" << "\n";
24060
  continue;
24061
case OP_ShrUint16Sint64:
24062
  PrintName("ShrUint16Sint64");
24063
  OS << "\t" << "\n";
24064
  continue;
24065
case OP_ShrUint16Uint64:
24066
  PrintName("ShrUint16Uint64");
24067
  OS << "\t" << "\n";
24068
  continue;
24069
case OP_ShrUint16IntAP:
24070
  PrintName("ShrUint16IntAP");
24071
  OS << "\t" << "\n";
24072
  continue;
24073
case OP_ShrUint16IntAPS:
24074
  PrintName("ShrUint16IntAPS");
24075
  OS << "\t" << "\n";
24076
  continue;
24077
case OP_ShrSint32Sint8:
24078
  PrintName("ShrSint32Sint8");
24079
  OS << "\t" << "\n";
24080
  continue;
24081
case OP_ShrSint32Uint8:
24082
  PrintName("ShrSint32Uint8");
24083
  OS << "\t" << "\n";
24084
  continue;
24085
case OP_ShrSint32Sint16:
24086
  PrintName("ShrSint32Sint16");
24087
  OS << "\t" << "\n";
24088
  continue;
24089
case OP_ShrSint32Uint16:
24090
  PrintName("ShrSint32Uint16");
24091
  OS << "\t" << "\n";
24092
  continue;
24093
case OP_ShrSint32Sint32:
24094
  PrintName("ShrSint32Sint32");
24095
  OS << "\t" << "\n";
24096
  continue;
24097
case OP_ShrSint32Uint32:
24098
  PrintName("ShrSint32Uint32");
24099
  OS << "\t" << "\n";
24100
  continue;
24101
case OP_ShrSint32Sint64:
24102
  PrintName("ShrSint32Sint64");
24103
  OS << "\t" << "\n";
24104
  continue;
24105
case OP_ShrSint32Uint64:
24106
  PrintName("ShrSint32Uint64");
24107
  OS << "\t" << "\n";
24108
  continue;
24109
case OP_ShrSint32IntAP:
24110
  PrintName("ShrSint32IntAP");
24111
  OS << "\t" << "\n";
24112
  continue;
24113
case OP_ShrSint32IntAPS:
24114
  PrintName("ShrSint32IntAPS");
24115
  OS << "\t" << "\n";
24116
  continue;
24117
case OP_ShrUint32Sint8:
24118
  PrintName("ShrUint32Sint8");
24119
  OS << "\t" << "\n";
24120
  continue;
24121
case OP_ShrUint32Uint8:
24122
  PrintName("ShrUint32Uint8");
24123
  OS << "\t" << "\n";
24124
  continue;
24125
case OP_ShrUint32Sint16:
24126
  PrintName("ShrUint32Sint16");
24127
  OS << "\t" << "\n";
24128
  continue;
24129
case OP_ShrUint32Uint16:
24130
  PrintName("ShrUint32Uint16");
24131
  OS << "\t" << "\n";
24132
  continue;
24133
case OP_ShrUint32Sint32:
24134
  PrintName("ShrUint32Sint32");
24135
  OS << "\t" << "\n";
24136
  continue;
24137
case OP_ShrUint32Uint32:
24138
  PrintName("ShrUint32Uint32");
24139
  OS << "\t" << "\n";
24140
  continue;
24141
case OP_ShrUint32Sint64:
24142
  PrintName("ShrUint32Sint64");
24143
  OS << "\t" << "\n";
24144
  continue;
24145
case OP_ShrUint32Uint64:
24146
  PrintName("ShrUint32Uint64");
24147
  OS << "\t" << "\n";
24148
  continue;
24149
case OP_ShrUint32IntAP:
24150
  PrintName("ShrUint32IntAP");
24151
  OS << "\t" << "\n";
24152
  continue;
24153
case OP_ShrUint32IntAPS:
24154
  PrintName("ShrUint32IntAPS");
24155
  OS << "\t" << "\n";
24156
  continue;
24157
case OP_ShrSint64Sint8:
24158
  PrintName("ShrSint64Sint8");
24159
  OS << "\t" << "\n";
24160
  continue;
24161
case OP_ShrSint64Uint8:
24162
  PrintName("ShrSint64Uint8");
24163
  OS << "\t" << "\n";
24164
  continue;
24165
case OP_ShrSint64Sint16:
24166
  PrintName("ShrSint64Sint16");
24167
  OS << "\t" << "\n";
24168
  continue;
24169
case OP_ShrSint64Uint16:
24170
  PrintName("ShrSint64Uint16");
24171
  OS << "\t" << "\n";
24172
  continue;
24173
case OP_ShrSint64Sint32:
24174
  PrintName("ShrSint64Sint32");
24175
  OS << "\t" << "\n";
24176
  continue;
24177
case OP_ShrSint64Uint32:
24178
  PrintName("ShrSint64Uint32");
24179
  OS << "\t" << "\n";
24180
  continue;
24181
case OP_ShrSint64Sint64:
24182
  PrintName("ShrSint64Sint64");
24183
  OS << "\t" << "\n";
24184
  continue;
24185
case OP_ShrSint64Uint64:
24186
  PrintName("ShrSint64Uint64");
24187
  OS << "\t" << "\n";
24188
  continue;
24189
case OP_ShrSint64IntAP:
24190
  PrintName("ShrSint64IntAP");
24191
  OS << "\t" << "\n";
24192
  continue;
24193
case OP_ShrSint64IntAPS:
24194
  PrintName("ShrSint64IntAPS");
24195
  OS << "\t" << "\n";
24196
  continue;
24197
case OP_ShrUint64Sint8:
24198
  PrintName("ShrUint64Sint8");
24199
  OS << "\t" << "\n";
24200
  continue;
24201
case OP_ShrUint64Uint8:
24202
  PrintName("ShrUint64Uint8");
24203
  OS << "\t" << "\n";
24204
  continue;
24205
case OP_ShrUint64Sint16:
24206
  PrintName("ShrUint64Sint16");
24207
  OS << "\t" << "\n";
24208
  continue;
24209
case OP_ShrUint64Uint16:
24210
  PrintName("ShrUint64Uint16");
24211
  OS << "\t" << "\n";
24212
  continue;
24213
case OP_ShrUint64Sint32:
24214
  PrintName("ShrUint64Sint32");
24215
  OS << "\t" << "\n";
24216
  continue;
24217
case OP_ShrUint64Uint32:
24218
  PrintName("ShrUint64Uint32");
24219
  OS << "\t" << "\n";
24220
  continue;
24221
case OP_ShrUint64Sint64:
24222
  PrintName("ShrUint64Sint64");
24223
  OS << "\t" << "\n";
24224
  continue;
24225
case OP_ShrUint64Uint64:
24226
  PrintName("ShrUint64Uint64");
24227
  OS << "\t" << "\n";
24228
  continue;
24229
case OP_ShrUint64IntAP:
24230
  PrintName("ShrUint64IntAP");
24231
  OS << "\t" << "\n";
24232
  continue;
24233
case OP_ShrUint64IntAPS:
24234
  PrintName("ShrUint64IntAPS");
24235
  OS << "\t" << "\n";
24236
  continue;
24237
case OP_ShrIntAPSint8:
24238
  PrintName("ShrIntAPSint8");
24239
  OS << "\t" << "\n";
24240
  continue;
24241
case OP_ShrIntAPUint8:
24242
  PrintName("ShrIntAPUint8");
24243
  OS << "\t" << "\n";
24244
  continue;
24245
case OP_ShrIntAPSint16:
24246
  PrintName("ShrIntAPSint16");
24247
  OS << "\t" << "\n";
24248
  continue;
24249
case OP_ShrIntAPUint16:
24250
  PrintName("ShrIntAPUint16");
24251
  OS << "\t" << "\n";
24252
  continue;
24253
case OP_ShrIntAPSint32:
24254
  PrintName("ShrIntAPSint32");
24255
  OS << "\t" << "\n";
24256
  continue;
24257
case OP_ShrIntAPUint32:
24258
  PrintName("ShrIntAPUint32");
24259
  OS << "\t" << "\n";
24260
  continue;
24261
case OP_ShrIntAPSint64:
24262
  PrintName("ShrIntAPSint64");
24263
  OS << "\t" << "\n";
24264
  continue;
24265
case OP_ShrIntAPUint64:
24266
  PrintName("ShrIntAPUint64");
24267
  OS << "\t" << "\n";
24268
  continue;
24269
case OP_ShrIntAPIntAP:
24270
  PrintName("ShrIntAPIntAP");
24271
  OS << "\t" << "\n";
24272
  continue;
24273
case OP_ShrIntAPIntAPS:
24274
  PrintName("ShrIntAPIntAPS");
24275
  OS << "\t" << "\n";
24276
  continue;
24277
case OP_ShrIntAPSSint8:
24278
  PrintName("ShrIntAPSSint8");
24279
  OS << "\t" << "\n";
24280
  continue;
24281
case OP_ShrIntAPSUint8:
24282
  PrintName("ShrIntAPSUint8");
24283
  OS << "\t" << "\n";
24284
  continue;
24285
case OP_ShrIntAPSSint16:
24286
  PrintName("ShrIntAPSSint16");
24287
  OS << "\t" << "\n";
24288
  continue;
24289
case OP_ShrIntAPSUint16:
24290
  PrintName("ShrIntAPSUint16");
24291
  OS << "\t" << "\n";
24292
  continue;
24293
case OP_ShrIntAPSSint32:
24294
  PrintName("ShrIntAPSSint32");
24295
  OS << "\t" << "\n";
24296
  continue;
24297
case OP_ShrIntAPSUint32:
24298
  PrintName("ShrIntAPSUint32");
24299
  OS << "\t" << "\n";
24300
  continue;
24301
case OP_ShrIntAPSSint64:
24302
  PrintName("ShrIntAPSSint64");
24303
  OS << "\t" << "\n";
24304
  continue;
24305
case OP_ShrIntAPSUint64:
24306
  PrintName("ShrIntAPSUint64");
24307
  OS << "\t" << "\n";
24308
  continue;
24309
case OP_ShrIntAPSIntAP:
24310
  PrintName("ShrIntAPSIntAP");
24311
  OS << "\t" << "\n";
24312
  continue;
24313
case OP_ShrIntAPSIntAPS:
24314
  PrintName("ShrIntAPSIntAPS");
24315
  OS << "\t" << "\n";
24316
  continue;
24317
#endif
24318
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24319
bool emitShrSint8Sint8(const SourceInfo &);
24320
bool emitShrSint8Uint8(const SourceInfo &);
24321
bool emitShrSint8Sint16(const SourceInfo &);
24322
bool emitShrSint8Uint16(const SourceInfo &);
24323
bool emitShrSint8Sint32(const SourceInfo &);
24324
bool emitShrSint8Uint32(const SourceInfo &);
24325
bool emitShrSint8Sint64(const SourceInfo &);
24326
bool emitShrSint8Uint64(const SourceInfo &);
24327
bool emitShrSint8IntAP(const SourceInfo &);
24328
bool emitShrSint8IntAPS(const SourceInfo &);
24329
bool emitShrUint8Sint8(const SourceInfo &);
24330
bool emitShrUint8Uint8(const SourceInfo &);
24331
bool emitShrUint8Sint16(const SourceInfo &);
24332
bool emitShrUint8Uint16(const SourceInfo &);
24333
bool emitShrUint8Sint32(const SourceInfo &);
24334
bool emitShrUint8Uint32(const SourceInfo &);
24335
bool emitShrUint8Sint64(const SourceInfo &);
24336
bool emitShrUint8Uint64(const SourceInfo &);
24337
bool emitShrUint8IntAP(const SourceInfo &);
24338
bool emitShrUint8IntAPS(const SourceInfo &);
24339
bool emitShrSint16Sint8(const SourceInfo &);
24340
bool emitShrSint16Uint8(const SourceInfo &);
24341
bool emitShrSint16Sint16(const SourceInfo &);
24342
bool emitShrSint16Uint16(const SourceInfo &);
24343
bool emitShrSint16Sint32(const SourceInfo &);
24344
bool emitShrSint16Uint32(const SourceInfo &);
24345
bool emitShrSint16Sint64(const SourceInfo &);
24346
bool emitShrSint16Uint64(const SourceInfo &);
24347
bool emitShrSint16IntAP(const SourceInfo &);
24348
bool emitShrSint16IntAPS(const SourceInfo &);
24349
bool emitShrUint16Sint8(const SourceInfo &);
24350
bool emitShrUint16Uint8(const SourceInfo &);
24351
bool emitShrUint16Sint16(const SourceInfo &);
24352
bool emitShrUint16Uint16(const SourceInfo &);
24353
bool emitShrUint16Sint32(const SourceInfo &);
24354
bool emitShrUint16Uint32(const SourceInfo &);
24355
bool emitShrUint16Sint64(const SourceInfo &);
24356
bool emitShrUint16Uint64(const SourceInfo &);
24357
bool emitShrUint16IntAP(const SourceInfo &);
24358
bool emitShrUint16IntAPS(const SourceInfo &);
24359
bool emitShrSint32Sint8(const SourceInfo &);
24360
bool emitShrSint32Uint8(const SourceInfo &);
24361
bool emitShrSint32Sint16(const SourceInfo &);
24362
bool emitShrSint32Uint16(const SourceInfo &);
24363
bool emitShrSint32Sint32(const SourceInfo &);
24364
bool emitShrSint32Uint32(const SourceInfo &);
24365
bool emitShrSint32Sint64(const SourceInfo &);
24366
bool emitShrSint32Uint64(const SourceInfo &);
24367
bool emitShrSint32IntAP(const SourceInfo &);
24368
bool emitShrSint32IntAPS(const SourceInfo &);
24369
bool emitShrUint32Sint8(const SourceInfo &);
24370
bool emitShrUint32Uint8(const SourceInfo &);
24371
bool emitShrUint32Sint16(const SourceInfo &);
24372
bool emitShrUint32Uint16(const SourceInfo &);
24373
bool emitShrUint32Sint32(const SourceInfo &);
24374
bool emitShrUint32Uint32(const SourceInfo &);
24375
bool emitShrUint32Sint64(const SourceInfo &);
24376
bool emitShrUint32Uint64(const SourceInfo &);
24377
bool emitShrUint32IntAP(const SourceInfo &);
24378
bool emitShrUint32IntAPS(const SourceInfo &);
24379
bool emitShrSint64Sint8(const SourceInfo &);
24380
bool emitShrSint64Uint8(const SourceInfo &);
24381
bool emitShrSint64Sint16(const SourceInfo &);
24382
bool emitShrSint64Uint16(const SourceInfo &);
24383
bool emitShrSint64Sint32(const SourceInfo &);
24384
bool emitShrSint64Uint32(const SourceInfo &);
24385
bool emitShrSint64Sint64(const SourceInfo &);
24386
bool emitShrSint64Uint64(const SourceInfo &);
24387
bool emitShrSint64IntAP(const SourceInfo &);
24388
bool emitShrSint64IntAPS(const SourceInfo &);
24389
bool emitShrUint64Sint8(const SourceInfo &);
24390
bool emitShrUint64Uint8(const SourceInfo &);
24391
bool emitShrUint64Sint16(const SourceInfo &);
24392
bool emitShrUint64Uint16(const SourceInfo &);
24393
bool emitShrUint64Sint32(const SourceInfo &);
24394
bool emitShrUint64Uint32(const SourceInfo &);
24395
bool emitShrUint64Sint64(const SourceInfo &);
24396
bool emitShrUint64Uint64(const SourceInfo &);
24397
bool emitShrUint64IntAP(const SourceInfo &);
24398
bool emitShrUint64IntAPS(const SourceInfo &);
24399
bool emitShrIntAPSint8(const SourceInfo &);
24400
bool emitShrIntAPUint8(const SourceInfo &);
24401
bool emitShrIntAPSint16(const SourceInfo &);
24402
bool emitShrIntAPUint16(const SourceInfo &);
24403
bool emitShrIntAPSint32(const SourceInfo &);
24404
bool emitShrIntAPUint32(const SourceInfo &);
24405
bool emitShrIntAPSint64(const SourceInfo &);
24406
bool emitShrIntAPUint64(const SourceInfo &);
24407
bool emitShrIntAPIntAP(const SourceInfo &);
24408
bool emitShrIntAPIntAPS(const SourceInfo &);
24409
bool emitShrIntAPSSint8(const SourceInfo &);
24410
bool emitShrIntAPSUint8(const SourceInfo &);
24411
bool emitShrIntAPSSint16(const SourceInfo &);
24412
bool emitShrIntAPSUint16(const SourceInfo &);
24413
bool emitShrIntAPSSint32(const SourceInfo &);
24414
bool emitShrIntAPSUint32(const SourceInfo &);
24415
bool emitShrIntAPSSint64(const SourceInfo &);
24416
bool emitShrIntAPSUint64(const SourceInfo &);
24417
bool emitShrIntAPSIntAP(const SourceInfo &);
24418
bool emitShrIntAPSIntAPS(const SourceInfo &);
24419
#endif
24420
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24421
bool emitShr(PrimType, PrimType, const SourceInfo &I);
24422
#endif
24423
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
24424
bool
24425
#if defined(GET_EVAL_IMPL)
24426
EvalEmitter
24427
#else
24428
ByteCodeEmitter
24429
#endif
24430
0
::emitShr(PrimType T0, PrimType T1, const SourceInfo &I) {
24431
0
  switch (T0) {
24432
0
  case PT_Sint8:
24433
0
  switch (T1) {
24434
0
  case PT_Sint8:
24435
0
    return emitShrSint8Sint8(I);
24436
0
  case PT_Uint8:
24437
0
    return emitShrSint8Uint8(I);
24438
0
  case PT_Sint16:
24439
0
    return emitShrSint8Sint16(I);
24440
0
  case PT_Uint16:
24441
0
    return emitShrSint8Uint16(I);
24442
0
  case PT_Sint32:
24443
0
    return emitShrSint8Sint32(I);
24444
0
  case PT_Uint32:
24445
0
    return emitShrSint8Uint32(I);
24446
0
  case PT_Sint64:
24447
0
    return emitShrSint8Sint64(I);
24448
0
  case PT_Uint64:
24449
0
    return emitShrSint8Uint64(I);
24450
0
  case PT_IntAP:
24451
0
    return emitShrSint8IntAP(I);
24452
0
  case PT_IntAPS:
24453
0
    return emitShrSint8IntAPS(I);
24454
0
  default: llvm_unreachable("invalid type: emitShr");
24455
0
  }
24456
0
  llvm_unreachable("invalid enum value");
24457
0
  case PT_Uint8:
24458
0
  switch (T1) {
24459
0
  case PT_Sint8:
24460
0
    return emitShrUint8Sint8(I);
24461
0
  case PT_Uint8:
24462
0
    return emitShrUint8Uint8(I);
24463
0
  case PT_Sint16:
24464
0
    return emitShrUint8Sint16(I);
24465
0
  case PT_Uint16:
24466
0
    return emitShrUint8Uint16(I);
24467
0
  case PT_Sint32:
24468
0
    return emitShrUint8Sint32(I);
24469
0
  case PT_Uint32:
24470
0
    return emitShrUint8Uint32(I);
24471
0
  case PT_Sint64:
24472
0
    return emitShrUint8Sint64(I);
24473
0
  case PT_Uint64:
24474
0
    return emitShrUint8Uint64(I);
24475
0
  case PT_IntAP:
24476
0
    return emitShrUint8IntAP(I);
24477
0
  case PT_IntAPS:
24478
0
    return emitShrUint8IntAPS(I);
24479
0
  default: llvm_unreachable("invalid type: emitShr");
24480
0
  }
24481
0
  llvm_unreachable("invalid enum value");
24482
0
  case PT_Sint16:
24483
0
  switch (T1) {
24484
0
  case PT_Sint8:
24485
0
    return emitShrSint16Sint8(I);
24486
0
  case PT_Uint8:
24487
0
    return emitShrSint16Uint8(I);
24488
0
  case PT_Sint16:
24489
0
    return emitShrSint16Sint16(I);
24490
0
  case PT_Uint16:
24491
0
    return emitShrSint16Uint16(I);
24492
0
  case PT_Sint32:
24493
0
    return emitShrSint16Sint32(I);
24494
0
  case PT_Uint32:
24495
0
    return emitShrSint16Uint32(I);
24496
0
  case PT_Sint64:
24497
0
    return emitShrSint16Sint64(I);
24498
0
  case PT_Uint64:
24499
0
    return emitShrSint16Uint64(I);
24500
0
  case PT_IntAP:
24501
0
    return emitShrSint16IntAP(I);
24502
0
  case PT_IntAPS:
24503
0
    return emitShrSint16IntAPS(I);
24504
0
  default: llvm_unreachable("invalid type: emitShr");
24505
0
  }
24506
0
  llvm_unreachable("invalid enum value");
24507
0
  case PT_Uint16:
24508
0
  switch (T1) {
24509
0
  case PT_Sint8:
24510
0
    return emitShrUint16Sint8(I);
24511
0
  case PT_Uint8:
24512
0
    return emitShrUint16Uint8(I);
24513
0
  case PT_Sint16:
24514
0
    return emitShrUint16Sint16(I);
24515
0
  case PT_Uint16:
24516
0
    return emitShrUint16Uint16(I);
24517
0
  case PT_Sint32:
24518
0
    return emitShrUint16Sint32(I);
24519
0
  case PT_Uint32:
24520
0
    return emitShrUint16Uint32(I);
24521
0
  case PT_Sint64:
24522
0
    return emitShrUint16Sint64(I);
24523
0
  case PT_Uint64:
24524
0
    return emitShrUint16Uint64(I);
24525
0
  case PT_IntAP:
24526
0
    return emitShrUint16IntAP(I);
24527
0
  case PT_IntAPS:
24528
0
    return emitShrUint16IntAPS(I);
24529
0
  default: llvm_unreachable("invalid type: emitShr");
24530
0
  }
24531
0
  llvm_unreachable("invalid enum value");
24532
0
  case PT_Sint32:
24533
0
  switch (T1) {
24534
0
  case PT_Sint8:
24535
0
    return emitShrSint32Sint8(I);
24536
0
  case PT_Uint8:
24537
0
    return emitShrSint32Uint8(I);
24538
0
  case PT_Sint16:
24539
0
    return emitShrSint32Sint16(I);
24540
0
  case PT_Uint16:
24541
0
    return emitShrSint32Uint16(I);
24542
0
  case PT_Sint32:
24543
0
    return emitShrSint32Sint32(I);
24544
0
  case PT_Uint32:
24545
0
    return emitShrSint32Uint32(I);
24546
0
  case PT_Sint64:
24547
0
    return emitShrSint32Sint64(I);
24548
0
  case PT_Uint64:
24549
0
    return emitShrSint32Uint64(I);
24550
0
  case PT_IntAP:
24551
0
    return emitShrSint32IntAP(I);
24552
0
  case PT_IntAPS:
24553
0
    return emitShrSint32IntAPS(I);
24554
0
  default: llvm_unreachable("invalid type: emitShr");
24555
0
  }
24556
0
  llvm_unreachable("invalid enum value");
24557
0
  case PT_Uint32:
24558
0
  switch (T1) {
24559
0
  case PT_Sint8:
24560
0
    return emitShrUint32Sint8(I);
24561
0
  case PT_Uint8:
24562
0
    return emitShrUint32Uint8(I);
24563
0
  case PT_Sint16:
24564
0
    return emitShrUint32Sint16(I);
24565
0
  case PT_Uint16:
24566
0
    return emitShrUint32Uint16(I);
24567
0
  case PT_Sint32:
24568
0
    return emitShrUint32Sint32(I);
24569
0
  case PT_Uint32:
24570
0
    return emitShrUint32Uint32(I);
24571
0
  case PT_Sint64:
24572
0
    return emitShrUint32Sint64(I);
24573
0
  case PT_Uint64:
24574
0
    return emitShrUint32Uint64(I);
24575
0
  case PT_IntAP:
24576
0
    return emitShrUint32IntAP(I);
24577
0
  case PT_IntAPS:
24578
0
    return emitShrUint32IntAPS(I);
24579
0
  default: llvm_unreachable("invalid type: emitShr");
24580
0
  }
24581
0
  llvm_unreachable("invalid enum value");
24582
0
  case PT_Sint64:
24583
0
  switch (T1) {
24584
0
  case PT_Sint8:
24585
0
    return emitShrSint64Sint8(I);
24586
0
  case PT_Uint8:
24587
0
    return emitShrSint64Uint8(I);
24588
0
  case PT_Sint16:
24589
0
    return emitShrSint64Sint16(I);
24590
0
  case PT_Uint16:
24591
0
    return emitShrSint64Uint16(I);
24592
0
  case PT_Sint32:
24593
0
    return emitShrSint64Sint32(I);
24594
0
  case PT_Uint32:
24595
0
    return emitShrSint64Uint32(I);
24596
0
  case PT_Sint64:
24597
0
    return emitShrSint64Sint64(I);
24598
0
  case PT_Uint64:
24599
0
    return emitShrSint64Uint64(I);
24600
0
  case PT_IntAP:
24601
0
    return emitShrSint64IntAP(I);
24602
0
  case PT_IntAPS:
24603
0
    return emitShrSint64IntAPS(I);
24604
0
  default: llvm_unreachable("invalid type: emitShr");
24605
0
  }
24606
0
  llvm_unreachable("invalid enum value");
24607
0
  case PT_Uint64:
24608
0
  switch (T1) {
24609
0
  case PT_Sint8:
24610
0
    return emitShrUint64Sint8(I);
24611
0
  case PT_Uint8:
24612
0
    return emitShrUint64Uint8(I);
24613
0
  case PT_Sint16:
24614
0
    return emitShrUint64Sint16(I);
24615
0
  case PT_Uint16:
24616
0
    return emitShrUint64Uint16(I);
24617
0
  case PT_Sint32:
24618
0
    return emitShrUint64Sint32(I);
24619
0
  case PT_Uint32:
24620
0
    return emitShrUint64Uint32(I);
24621
0
  case PT_Sint64:
24622
0
    return emitShrUint64Sint64(I);
24623
0
  case PT_Uint64:
24624
0
    return emitShrUint64Uint64(I);
24625
0
  case PT_IntAP:
24626
0
    return emitShrUint64IntAP(I);
24627
0
  case PT_IntAPS:
24628
0
    return emitShrUint64IntAPS(I);
24629
0
  default: llvm_unreachable("invalid type: emitShr");
24630
0
  }
24631
0
  llvm_unreachable("invalid enum value");
24632
0
  case PT_IntAP:
24633
0
  switch (T1) {
24634
0
  case PT_Sint8:
24635
0
    return emitShrIntAPSint8(I);
24636
0
  case PT_Uint8:
24637
0
    return emitShrIntAPUint8(I);
24638
0
  case PT_Sint16:
24639
0
    return emitShrIntAPSint16(I);
24640
0
  case PT_Uint16:
24641
0
    return emitShrIntAPUint16(I);
24642
0
  case PT_Sint32:
24643
0
    return emitShrIntAPSint32(I);
24644
0
  case PT_Uint32:
24645
0
    return emitShrIntAPUint32(I);
24646
0
  case PT_Sint64:
24647
0
    return emitShrIntAPSint64(I);
24648
0
  case PT_Uint64:
24649
0
    return emitShrIntAPUint64(I);
24650
0
  case PT_IntAP:
24651
0
    return emitShrIntAPIntAP(I);
24652
0
  case PT_IntAPS:
24653
0
    return emitShrIntAPIntAPS(I);
24654
0
  default: llvm_unreachable("invalid type: emitShr");
24655
0
  }
24656
0
  llvm_unreachable("invalid enum value");
24657
0
  case PT_IntAPS:
24658
0
  switch (T1) {
24659
0
  case PT_Sint8:
24660
0
    return emitShrIntAPSSint8(I);
24661
0
  case PT_Uint8:
24662
0
    return emitShrIntAPSUint8(I);
24663
0
  case PT_Sint16:
24664
0
    return emitShrIntAPSSint16(I);
24665
0
  case PT_Uint16:
24666
0
    return emitShrIntAPSUint16(I);
24667
0
  case PT_Sint32:
24668
0
    return emitShrIntAPSSint32(I);
24669
0
  case PT_Uint32:
24670
0
    return emitShrIntAPSUint32(I);
24671
0
  case PT_Sint64:
24672
0
    return emitShrIntAPSSint64(I);
24673
0
  case PT_Uint64:
24674
0
    return emitShrIntAPSUint64(I);
24675
0
  case PT_IntAP:
24676
0
    return emitShrIntAPSIntAP(I);
24677
0
  case PT_IntAPS:
24678
0
    return emitShrIntAPSIntAPS(I);
24679
0
  default: llvm_unreachable("invalid type: emitShr");
24680
0
  }
24681
0
  llvm_unreachable("invalid enum value");
24682
0
  default: llvm_unreachable("invalid type: emitShr");
24683
0
  }
24684
0
  llvm_unreachable("invalid enum value");
24685
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitShr(clang::interp::PrimType, clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitShr(clang::interp::PrimType, clang::interp::PrimType, clang::interp::SourceInfo const&)
24686
#endif
24687
#ifdef GET_LINK_IMPL
24688
0
bool ByteCodeEmitter::emitShrSint8Sint8(const SourceInfo &L) {
24689
0
  return emitOp<>(OP_ShrSint8Sint8, L);
24690
0
}
24691
0
bool ByteCodeEmitter::emitShrSint8Uint8(const SourceInfo &L) {
24692
0
  return emitOp<>(OP_ShrSint8Uint8, L);
24693
0
}
24694
0
bool ByteCodeEmitter::emitShrSint8Sint16(const SourceInfo &L) {
24695
0
  return emitOp<>(OP_ShrSint8Sint16, L);
24696
0
}
24697
0
bool ByteCodeEmitter::emitShrSint8Uint16(const SourceInfo &L) {
24698
0
  return emitOp<>(OP_ShrSint8Uint16, L);
24699
0
}
24700
0
bool ByteCodeEmitter::emitShrSint8Sint32(const SourceInfo &L) {
24701
0
  return emitOp<>(OP_ShrSint8Sint32, L);
24702
0
}
24703
0
bool ByteCodeEmitter::emitShrSint8Uint32(const SourceInfo &L) {
24704
0
  return emitOp<>(OP_ShrSint8Uint32, L);
24705
0
}
24706
0
bool ByteCodeEmitter::emitShrSint8Sint64(const SourceInfo &L) {
24707
0
  return emitOp<>(OP_ShrSint8Sint64, L);
24708
0
}
24709
0
bool ByteCodeEmitter::emitShrSint8Uint64(const SourceInfo &L) {
24710
0
  return emitOp<>(OP_ShrSint8Uint64, L);
24711
0
}
24712
0
bool ByteCodeEmitter::emitShrSint8IntAP(const SourceInfo &L) {
24713
0
  return emitOp<>(OP_ShrSint8IntAP, L);
24714
0
}
24715
0
bool ByteCodeEmitter::emitShrSint8IntAPS(const SourceInfo &L) {
24716
0
  return emitOp<>(OP_ShrSint8IntAPS, L);
24717
0
}
24718
0
bool ByteCodeEmitter::emitShrUint8Sint8(const SourceInfo &L) {
24719
0
  return emitOp<>(OP_ShrUint8Sint8, L);
24720
0
}
24721
0
bool ByteCodeEmitter::emitShrUint8Uint8(const SourceInfo &L) {
24722
0
  return emitOp<>(OP_ShrUint8Uint8, L);
24723
0
}
24724
0
bool ByteCodeEmitter::emitShrUint8Sint16(const SourceInfo &L) {
24725
0
  return emitOp<>(OP_ShrUint8Sint16, L);
24726
0
}
24727
0
bool ByteCodeEmitter::emitShrUint8Uint16(const SourceInfo &L) {
24728
0
  return emitOp<>(OP_ShrUint8Uint16, L);
24729
0
}
24730
0
bool ByteCodeEmitter::emitShrUint8Sint32(const SourceInfo &L) {
24731
0
  return emitOp<>(OP_ShrUint8Sint32, L);
24732
0
}
24733
0
bool ByteCodeEmitter::emitShrUint8Uint32(const SourceInfo &L) {
24734
0
  return emitOp<>(OP_ShrUint8Uint32, L);
24735
0
}
24736
0
bool ByteCodeEmitter::emitShrUint8Sint64(const SourceInfo &L) {
24737
0
  return emitOp<>(OP_ShrUint8Sint64, L);
24738
0
}
24739
0
bool ByteCodeEmitter::emitShrUint8Uint64(const SourceInfo &L) {
24740
0
  return emitOp<>(OP_ShrUint8Uint64, L);
24741
0
}
24742
0
bool ByteCodeEmitter::emitShrUint8IntAP(const SourceInfo &L) {
24743
0
  return emitOp<>(OP_ShrUint8IntAP, L);
24744
0
}
24745
0
bool ByteCodeEmitter::emitShrUint8IntAPS(const SourceInfo &L) {
24746
0
  return emitOp<>(OP_ShrUint8IntAPS, L);
24747
0
}
24748
0
bool ByteCodeEmitter::emitShrSint16Sint8(const SourceInfo &L) {
24749
0
  return emitOp<>(OP_ShrSint16Sint8, L);
24750
0
}
24751
0
bool ByteCodeEmitter::emitShrSint16Uint8(const SourceInfo &L) {
24752
0
  return emitOp<>(OP_ShrSint16Uint8, L);
24753
0
}
24754
0
bool ByteCodeEmitter::emitShrSint16Sint16(const SourceInfo &L) {
24755
0
  return emitOp<>(OP_ShrSint16Sint16, L);
24756
0
}
24757
0
bool ByteCodeEmitter::emitShrSint16Uint16(const SourceInfo &L) {
24758
0
  return emitOp<>(OP_ShrSint16Uint16, L);
24759
0
}
24760
0
bool ByteCodeEmitter::emitShrSint16Sint32(const SourceInfo &L) {
24761
0
  return emitOp<>(OP_ShrSint16Sint32, L);
24762
0
}
24763
0
bool ByteCodeEmitter::emitShrSint16Uint32(const SourceInfo &L) {
24764
0
  return emitOp<>(OP_ShrSint16Uint32, L);
24765
0
}
24766
0
bool ByteCodeEmitter::emitShrSint16Sint64(const SourceInfo &L) {
24767
0
  return emitOp<>(OP_ShrSint16Sint64, L);
24768
0
}
24769
0
bool ByteCodeEmitter::emitShrSint16Uint64(const SourceInfo &L) {
24770
0
  return emitOp<>(OP_ShrSint16Uint64, L);
24771
0
}
24772
0
bool ByteCodeEmitter::emitShrSint16IntAP(const SourceInfo &L) {
24773
0
  return emitOp<>(OP_ShrSint16IntAP, L);
24774
0
}
24775
0
bool ByteCodeEmitter::emitShrSint16IntAPS(const SourceInfo &L) {
24776
0
  return emitOp<>(OP_ShrSint16IntAPS, L);
24777
0
}
24778
0
bool ByteCodeEmitter::emitShrUint16Sint8(const SourceInfo &L) {
24779
0
  return emitOp<>(OP_ShrUint16Sint8, L);
24780
0
}
24781
0
bool ByteCodeEmitter::emitShrUint16Uint8(const SourceInfo &L) {
24782
0
  return emitOp<>(OP_ShrUint16Uint8, L);
24783
0
}
24784
0
bool ByteCodeEmitter::emitShrUint16Sint16(const SourceInfo &L) {
24785
0
  return emitOp<>(OP_ShrUint16Sint16, L);
24786
0
}
24787
0
bool ByteCodeEmitter::emitShrUint16Uint16(const SourceInfo &L) {
24788
0
  return emitOp<>(OP_ShrUint16Uint16, L);
24789
0
}
24790
0
bool ByteCodeEmitter::emitShrUint16Sint32(const SourceInfo &L) {
24791
0
  return emitOp<>(OP_ShrUint16Sint32, L);
24792
0
}
24793
0
bool ByteCodeEmitter::emitShrUint16Uint32(const SourceInfo &L) {
24794
0
  return emitOp<>(OP_ShrUint16Uint32, L);
24795
0
}
24796
0
bool ByteCodeEmitter::emitShrUint16Sint64(const SourceInfo &L) {
24797
0
  return emitOp<>(OP_ShrUint16Sint64, L);
24798
0
}
24799
0
bool ByteCodeEmitter::emitShrUint16Uint64(const SourceInfo &L) {
24800
0
  return emitOp<>(OP_ShrUint16Uint64, L);
24801
0
}
24802
0
bool ByteCodeEmitter::emitShrUint16IntAP(const SourceInfo &L) {
24803
0
  return emitOp<>(OP_ShrUint16IntAP, L);
24804
0
}
24805
0
bool ByteCodeEmitter::emitShrUint16IntAPS(const SourceInfo &L) {
24806
0
  return emitOp<>(OP_ShrUint16IntAPS, L);
24807
0
}
24808
0
bool ByteCodeEmitter::emitShrSint32Sint8(const SourceInfo &L) {
24809
0
  return emitOp<>(OP_ShrSint32Sint8, L);
24810
0
}
24811
0
bool ByteCodeEmitter::emitShrSint32Uint8(const SourceInfo &L) {
24812
0
  return emitOp<>(OP_ShrSint32Uint8, L);
24813
0
}
24814
0
bool ByteCodeEmitter::emitShrSint32Sint16(const SourceInfo &L) {
24815
0
  return emitOp<>(OP_ShrSint32Sint16, L);
24816
0
}
24817
0
bool ByteCodeEmitter::emitShrSint32Uint16(const SourceInfo &L) {
24818
0
  return emitOp<>(OP_ShrSint32Uint16, L);
24819
0
}
24820
0
bool ByteCodeEmitter::emitShrSint32Sint32(const SourceInfo &L) {
24821
0
  return emitOp<>(OP_ShrSint32Sint32, L);
24822
0
}
24823
0
bool ByteCodeEmitter::emitShrSint32Uint32(const SourceInfo &L) {
24824
0
  return emitOp<>(OP_ShrSint32Uint32, L);
24825
0
}
24826
0
bool ByteCodeEmitter::emitShrSint32Sint64(const SourceInfo &L) {
24827
0
  return emitOp<>(OP_ShrSint32Sint64, L);
24828
0
}
24829
0
bool ByteCodeEmitter::emitShrSint32Uint64(const SourceInfo &L) {
24830
0
  return emitOp<>(OP_ShrSint32Uint64, L);
24831
0
}
24832
0
bool ByteCodeEmitter::emitShrSint32IntAP(const SourceInfo &L) {
24833
0
  return emitOp<>(OP_ShrSint32IntAP, L);
24834
0
}
24835
0
bool ByteCodeEmitter::emitShrSint32IntAPS(const SourceInfo &L) {
24836
0
  return emitOp<>(OP_ShrSint32IntAPS, L);
24837
0
}
24838
0
bool ByteCodeEmitter::emitShrUint32Sint8(const SourceInfo &L) {
24839
0
  return emitOp<>(OP_ShrUint32Sint8, L);
24840
0
}
24841
0
bool ByteCodeEmitter::emitShrUint32Uint8(const SourceInfo &L) {
24842
0
  return emitOp<>(OP_ShrUint32Uint8, L);
24843
0
}
24844
0
bool ByteCodeEmitter::emitShrUint32Sint16(const SourceInfo &L) {
24845
0
  return emitOp<>(OP_ShrUint32Sint16, L);
24846
0
}
24847
0
bool ByteCodeEmitter::emitShrUint32Uint16(const SourceInfo &L) {
24848
0
  return emitOp<>(OP_ShrUint32Uint16, L);
24849
0
}
24850
0
bool ByteCodeEmitter::emitShrUint32Sint32(const SourceInfo &L) {
24851
0
  return emitOp<>(OP_ShrUint32Sint32, L);
24852
0
}
24853
0
bool ByteCodeEmitter::emitShrUint32Uint32(const SourceInfo &L) {
24854
0
  return emitOp<>(OP_ShrUint32Uint32, L);
24855
0
}
24856
0
bool ByteCodeEmitter::emitShrUint32Sint64(const SourceInfo &L) {
24857
0
  return emitOp<>(OP_ShrUint32Sint64, L);
24858
0
}
24859
0
bool ByteCodeEmitter::emitShrUint32Uint64(const SourceInfo &L) {
24860
0
  return emitOp<>(OP_ShrUint32Uint64, L);
24861
0
}
24862
0
bool ByteCodeEmitter::emitShrUint32IntAP(const SourceInfo &L) {
24863
0
  return emitOp<>(OP_ShrUint32IntAP, L);
24864
0
}
24865
0
bool ByteCodeEmitter::emitShrUint32IntAPS(const SourceInfo &L) {
24866
0
  return emitOp<>(OP_ShrUint32IntAPS, L);
24867
0
}
24868
0
bool ByteCodeEmitter::emitShrSint64Sint8(const SourceInfo &L) {
24869
0
  return emitOp<>(OP_ShrSint64Sint8, L);
24870
0
}
24871
0
bool ByteCodeEmitter::emitShrSint64Uint8(const SourceInfo &L) {
24872
0
  return emitOp<>(OP_ShrSint64Uint8, L);
24873
0
}
24874
0
bool ByteCodeEmitter::emitShrSint64Sint16(const SourceInfo &L) {
24875
0
  return emitOp<>(OP_ShrSint64Sint16, L);
24876
0
}
24877
0
bool ByteCodeEmitter::emitShrSint64Uint16(const SourceInfo &L) {
24878
0
  return emitOp<>(OP_ShrSint64Uint16, L);
24879
0
}
24880
0
bool ByteCodeEmitter::emitShrSint64Sint32(const SourceInfo &L) {
24881
0
  return emitOp<>(OP_ShrSint64Sint32, L);
24882
0
}
24883
0
bool ByteCodeEmitter::emitShrSint64Uint32(const SourceInfo &L) {
24884
0
  return emitOp<>(OP_ShrSint64Uint32, L);
24885
0
}
24886
0
bool ByteCodeEmitter::emitShrSint64Sint64(const SourceInfo &L) {
24887
0
  return emitOp<>(OP_ShrSint64Sint64, L);
24888
0
}
24889
0
bool ByteCodeEmitter::emitShrSint64Uint64(const SourceInfo &L) {
24890
0
  return emitOp<>(OP_ShrSint64Uint64, L);
24891
0
}
24892
0
bool ByteCodeEmitter::emitShrSint64IntAP(const SourceInfo &L) {
24893
0
  return emitOp<>(OP_ShrSint64IntAP, L);
24894
0
}
24895
0
bool ByteCodeEmitter::emitShrSint64IntAPS(const SourceInfo &L) {
24896
0
  return emitOp<>(OP_ShrSint64IntAPS, L);
24897
0
}
24898
0
bool ByteCodeEmitter::emitShrUint64Sint8(const SourceInfo &L) {
24899
0
  return emitOp<>(OP_ShrUint64Sint8, L);
24900
0
}
24901
0
bool ByteCodeEmitter::emitShrUint64Uint8(const SourceInfo &L) {
24902
0
  return emitOp<>(OP_ShrUint64Uint8, L);
24903
0
}
24904
0
bool ByteCodeEmitter::emitShrUint64Sint16(const SourceInfo &L) {
24905
0
  return emitOp<>(OP_ShrUint64Sint16, L);
24906
0
}
24907
0
bool ByteCodeEmitter::emitShrUint64Uint16(const SourceInfo &L) {
24908
0
  return emitOp<>(OP_ShrUint64Uint16, L);
24909
0
}
24910
0
bool ByteCodeEmitter::emitShrUint64Sint32(const SourceInfo &L) {
24911
0
  return emitOp<>(OP_ShrUint64Sint32, L);
24912
0
}
24913
0
bool ByteCodeEmitter::emitShrUint64Uint32(const SourceInfo &L) {
24914
0
  return emitOp<>(OP_ShrUint64Uint32, L);
24915
0
}
24916
0
bool ByteCodeEmitter::emitShrUint64Sint64(const SourceInfo &L) {
24917
0
  return emitOp<>(OP_ShrUint64Sint64, L);
24918
0
}
24919
0
bool ByteCodeEmitter::emitShrUint64Uint64(const SourceInfo &L) {
24920
0
  return emitOp<>(OP_ShrUint64Uint64, L);
24921
0
}
24922
0
bool ByteCodeEmitter::emitShrUint64IntAP(const SourceInfo &L) {
24923
0
  return emitOp<>(OP_ShrUint64IntAP, L);
24924
0
}
24925
0
bool ByteCodeEmitter::emitShrUint64IntAPS(const SourceInfo &L) {
24926
0
  return emitOp<>(OP_ShrUint64IntAPS, L);
24927
0
}
24928
0
bool ByteCodeEmitter::emitShrIntAPSint8(const SourceInfo &L) {
24929
0
  return emitOp<>(OP_ShrIntAPSint8, L);
24930
0
}
24931
0
bool ByteCodeEmitter::emitShrIntAPUint8(const SourceInfo &L) {
24932
0
  return emitOp<>(OP_ShrIntAPUint8, L);
24933
0
}
24934
0
bool ByteCodeEmitter::emitShrIntAPSint16(const SourceInfo &L) {
24935
0
  return emitOp<>(OP_ShrIntAPSint16, L);
24936
0
}
24937
0
bool ByteCodeEmitter::emitShrIntAPUint16(const SourceInfo &L) {
24938
0
  return emitOp<>(OP_ShrIntAPUint16, L);
24939
0
}
24940
0
bool ByteCodeEmitter::emitShrIntAPSint32(const SourceInfo &L) {
24941
0
  return emitOp<>(OP_ShrIntAPSint32, L);
24942
0
}
24943
0
bool ByteCodeEmitter::emitShrIntAPUint32(const SourceInfo &L) {
24944
0
  return emitOp<>(OP_ShrIntAPUint32, L);
24945
0
}
24946
0
bool ByteCodeEmitter::emitShrIntAPSint64(const SourceInfo &L) {
24947
0
  return emitOp<>(OP_ShrIntAPSint64, L);
24948
0
}
24949
0
bool ByteCodeEmitter::emitShrIntAPUint64(const SourceInfo &L) {
24950
0
  return emitOp<>(OP_ShrIntAPUint64, L);
24951
0
}
24952
0
bool ByteCodeEmitter::emitShrIntAPIntAP(const SourceInfo &L) {
24953
0
  return emitOp<>(OP_ShrIntAPIntAP, L);
24954
0
}
24955
0
bool ByteCodeEmitter::emitShrIntAPIntAPS(const SourceInfo &L) {
24956
0
  return emitOp<>(OP_ShrIntAPIntAPS, L);
24957
0
}
24958
0
bool ByteCodeEmitter::emitShrIntAPSSint8(const SourceInfo &L) {
24959
0
  return emitOp<>(OP_ShrIntAPSSint8, L);
24960
0
}
24961
0
bool ByteCodeEmitter::emitShrIntAPSUint8(const SourceInfo &L) {
24962
0
  return emitOp<>(OP_ShrIntAPSUint8, L);
24963
0
}
24964
0
bool ByteCodeEmitter::emitShrIntAPSSint16(const SourceInfo &L) {
24965
0
  return emitOp<>(OP_ShrIntAPSSint16, L);
24966
0
}
24967
0
bool ByteCodeEmitter::emitShrIntAPSUint16(const SourceInfo &L) {
24968
0
  return emitOp<>(OP_ShrIntAPSUint16, L);
24969
0
}
24970
0
bool ByteCodeEmitter::emitShrIntAPSSint32(const SourceInfo &L) {
24971
0
  return emitOp<>(OP_ShrIntAPSSint32, L);
24972
0
}
24973
0
bool ByteCodeEmitter::emitShrIntAPSUint32(const SourceInfo &L) {
24974
0
  return emitOp<>(OP_ShrIntAPSUint32, L);
24975
0
}
24976
0
bool ByteCodeEmitter::emitShrIntAPSSint64(const SourceInfo &L) {
24977
0
  return emitOp<>(OP_ShrIntAPSSint64, L);
24978
0
}
24979
0
bool ByteCodeEmitter::emitShrIntAPSUint64(const SourceInfo &L) {
24980
0
  return emitOp<>(OP_ShrIntAPSUint64, L);
24981
0
}
24982
0
bool ByteCodeEmitter::emitShrIntAPSIntAP(const SourceInfo &L) {
24983
0
  return emitOp<>(OP_ShrIntAPSIntAP, L);
24984
0
}
24985
0
bool ByteCodeEmitter::emitShrIntAPSIntAPS(const SourceInfo &L) {
24986
0
  return emitOp<>(OP_ShrIntAPSIntAPS, L);
24987
0
}
24988
#endif
24989
#ifdef GET_EVAL_IMPL
24990
0
bool EvalEmitter::emitShrSint8Sint8(const SourceInfo &L) {
24991
0
  if (!isActive()) return true;
24992
0
  CurrentSource = L;
24993
0
  return Shr<PT_Sint8, PT_Sint8>(S, OpPC);
24994
0
}
24995
0
bool EvalEmitter::emitShrSint8Uint8(const SourceInfo &L) {
24996
0
  if (!isActive()) return true;
24997
0
  CurrentSource = L;
24998
0
  return Shr<PT_Sint8, PT_Uint8>(S, OpPC);
24999
0
}
25000
0
bool EvalEmitter::emitShrSint8Sint16(const SourceInfo &L) {
25001
0
  if (!isActive()) return true;
25002
0
  CurrentSource = L;
25003
0
  return Shr<PT_Sint8, PT_Sint16>(S, OpPC);
25004
0
}
25005
0
bool EvalEmitter::emitShrSint8Uint16(const SourceInfo &L) {
25006
0
  if (!isActive()) return true;
25007
0
  CurrentSource = L;
25008
0
  return Shr<PT_Sint8, PT_Uint16>(S, OpPC);
25009
0
}
25010
0
bool EvalEmitter::emitShrSint8Sint32(const SourceInfo &L) {
25011
0
  if (!isActive()) return true;
25012
0
  CurrentSource = L;
25013
0
  return Shr<PT_Sint8, PT_Sint32>(S, OpPC);
25014
0
}
25015
0
bool EvalEmitter::emitShrSint8Uint32(const SourceInfo &L) {
25016
0
  if (!isActive()) return true;
25017
0
  CurrentSource = L;
25018
0
  return Shr<PT_Sint8, PT_Uint32>(S, OpPC);
25019
0
}
25020
0
bool EvalEmitter::emitShrSint8Sint64(const SourceInfo &L) {
25021
0
  if (!isActive()) return true;
25022
0
  CurrentSource = L;
25023
0
  return Shr<PT_Sint8, PT_Sint64>(S, OpPC);
25024
0
}
25025
0
bool EvalEmitter::emitShrSint8Uint64(const SourceInfo &L) {
25026
0
  if (!isActive()) return true;
25027
0
  CurrentSource = L;
25028
0
  return Shr<PT_Sint8, PT_Uint64>(S, OpPC);
25029
0
}
25030
0
bool EvalEmitter::emitShrSint8IntAP(const SourceInfo &L) {
25031
0
  if (!isActive()) return true;
25032
0
  CurrentSource = L;
25033
0
  return Shr<PT_Sint8, PT_IntAP>(S, OpPC);
25034
0
}
25035
0
bool EvalEmitter::emitShrSint8IntAPS(const SourceInfo &L) {
25036
0
  if (!isActive()) return true;
25037
0
  CurrentSource = L;
25038
0
  return Shr<PT_Sint8, PT_IntAPS>(S, OpPC);
25039
0
}
25040
0
bool EvalEmitter::emitShrUint8Sint8(const SourceInfo &L) {
25041
0
  if (!isActive()) return true;
25042
0
  CurrentSource = L;
25043
0
  return Shr<PT_Uint8, PT_Sint8>(S, OpPC);
25044
0
}
25045
0
bool EvalEmitter::emitShrUint8Uint8(const SourceInfo &L) {
25046
0
  if (!isActive()) return true;
25047
0
  CurrentSource = L;
25048
0
  return Shr<PT_Uint8, PT_Uint8>(S, OpPC);
25049
0
}
25050
0
bool EvalEmitter::emitShrUint8Sint16(const SourceInfo &L) {
25051
0
  if (!isActive()) return true;
25052
0
  CurrentSource = L;
25053
0
  return Shr<PT_Uint8, PT_Sint16>(S, OpPC);
25054
0
}
25055
0
bool EvalEmitter::emitShrUint8Uint16(const SourceInfo &L) {
25056
0
  if (!isActive()) return true;
25057
0
  CurrentSource = L;
25058
0
  return Shr<PT_Uint8, PT_Uint16>(S, OpPC);
25059
0
}
25060
0
bool EvalEmitter::emitShrUint8Sint32(const SourceInfo &L) {
25061
0
  if (!isActive()) return true;
25062
0
  CurrentSource = L;
25063
0
  return Shr<PT_Uint8, PT_Sint32>(S, OpPC);
25064
0
}
25065
0
bool EvalEmitter::emitShrUint8Uint32(const SourceInfo &L) {
25066
0
  if (!isActive()) return true;
25067
0
  CurrentSource = L;
25068
0
  return Shr<PT_Uint8, PT_Uint32>(S, OpPC);
25069
0
}
25070
0
bool EvalEmitter::emitShrUint8Sint64(const SourceInfo &L) {
25071
0
  if (!isActive()) return true;
25072
0
  CurrentSource = L;
25073
0
  return Shr<PT_Uint8, PT_Sint64>(S, OpPC);
25074
0
}
25075
0
bool EvalEmitter::emitShrUint8Uint64(const SourceInfo &L) {
25076
0
  if (!isActive()) return true;
25077
0
  CurrentSource = L;
25078
0
  return Shr<PT_Uint8, PT_Uint64>(S, OpPC);
25079
0
}
25080
0
bool EvalEmitter::emitShrUint8IntAP(const SourceInfo &L) {
25081
0
  if (!isActive()) return true;
25082
0
  CurrentSource = L;
25083
0
  return Shr<PT_Uint8, PT_IntAP>(S, OpPC);
25084
0
}
25085
0
bool EvalEmitter::emitShrUint8IntAPS(const SourceInfo &L) {
25086
0
  if (!isActive()) return true;
25087
0
  CurrentSource = L;
25088
0
  return Shr<PT_Uint8, PT_IntAPS>(S, OpPC);
25089
0
}
25090
0
bool EvalEmitter::emitShrSint16Sint8(const SourceInfo &L) {
25091
0
  if (!isActive()) return true;
25092
0
  CurrentSource = L;
25093
0
  return Shr<PT_Sint16, PT_Sint8>(S, OpPC);
25094
0
}
25095
0
bool EvalEmitter::emitShrSint16Uint8(const SourceInfo &L) {
25096
0
  if (!isActive()) return true;
25097
0
  CurrentSource = L;
25098
0
  return Shr<PT_Sint16, PT_Uint8>(S, OpPC);
25099
0
}
25100
0
bool EvalEmitter::emitShrSint16Sint16(const SourceInfo &L) {
25101
0
  if (!isActive()) return true;
25102
0
  CurrentSource = L;
25103
0
  return Shr<PT_Sint16, PT_Sint16>(S, OpPC);
25104
0
}
25105
0
bool EvalEmitter::emitShrSint16Uint16(const SourceInfo &L) {
25106
0
  if (!isActive()) return true;
25107
0
  CurrentSource = L;
25108
0
  return Shr<PT_Sint16, PT_Uint16>(S, OpPC);
25109
0
}
25110
0
bool EvalEmitter::emitShrSint16Sint32(const SourceInfo &L) {
25111
0
  if (!isActive()) return true;
25112
0
  CurrentSource = L;
25113
0
  return Shr<PT_Sint16, PT_Sint32>(S, OpPC);
25114
0
}
25115
0
bool EvalEmitter::emitShrSint16Uint32(const SourceInfo &L) {
25116
0
  if (!isActive()) return true;
25117
0
  CurrentSource = L;
25118
0
  return Shr<PT_Sint16, PT_Uint32>(S, OpPC);
25119
0
}
25120
0
bool EvalEmitter::emitShrSint16Sint64(const SourceInfo &L) {
25121
0
  if (!isActive()) return true;
25122
0
  CurrentSource = L;
25123
0
  return Shr<PT_Sint16, PT_Sint64>(S, OpPC);
25124
0
}
25125
0
bool EvalEmitter::emitShrSint16Uint64(const SourceInfo &L) {
25126
0
  if (!isActive()) return true;
25127
0
  CurrentSource = L;
25128
0
  return Shr<PT_Sint16, PT_Uint64>(S, OpPC);
25129
0
}
25130
0
bool EvalEmitter::emitShrSint16IntAP(const SourceInfo &L) {
25131
0
  if (!isActive()) return true;
25132
0
  CurrentSource = L;
25133
0
  return Shr<PT_Sint16, PT_IntAP>(S, OpPC);
25134
0
}
25135
0
bool EvalEmitter::emitShrSint16IntAPS(const SourceInfo &L) {
25136
0
  if (!isActive()) return true;
25137
0
  CurrentSource = L;
25138
0
  return Shr<PT_Sint16, PT_IntAPS>(S, OpPC);
25139
0
}
25140
0
bool EvalEmitter::emitShrUint16Sint8(const SourceInfo &L) {
25141
0
  if (!isActive()) return true;
25142
0
  CurrentSource = L;
25143
0
  return Shr<PT_Uint16, PT_Sint8>(S, OpPC);
25144
0
}
25145
0
bool EvalEmitter::emitShrUint16Uint8(const SourceInfo &L) {
25146
0
  if (!isActive()) return true;
25147
0
  CurrentSource = L;
25148
0
  return Shr<PT_Uint16, PT_Uint8>(S, OpPC);
25149
0
}
25150
0
bool EvalEmitter::emitShrUint16Sint16(const SourceInfo &L) {
25151
0
  if (!isActive()) return true;
25152
0
  CurrentSource = L;
25153
0
  return Shr<PT_Uint16, PT_Sint16>(S, OpPC);
25154
0
}
25155
0
bool EvalEmitter::emitShrUint16Uint16(const SourceInfo &L) {
25156
0
  if (!isActive()) return true;
25157
0
  CurrentSource = L;
25158
0
  return Shr<PT_Uint16, PT_Uint16>(S, OpPC);
25159
0
}
25160
0
bool EvalEmitter::emitShrUint16Sint32(const SourceInfo &L) {
25161
0
  if (!isActive()) return true;
25162
0
  CurrentSource = L;
25163
0
  return Shr<PT_Uint16, PT_Sint32>(S, OpPC);
25164
0
}
25165
0
bool EvalEmitter::emitShrUint16Uint32(const SourceInfo &L) {
25166
0
  if (!isActive()) return true;
25167
0
  CurrentSource = L;
25168
0
  return Shr<PT_Uint16, PT_Uint32>(S, OpPC);
25169
0
}
25170
0
bool EvalEmitter::emitShrUint16Sint64(const SourceInfo &L) {
25171
0
  if (!isActive()) return true;
25172
0
  CurrentSource = L;
25173
0
  return Shr<PT_Uint16, PT_Sint64>(S, OpPC);
25174
0
}
25175
0
bool EvalEmitter::emitShrUint16Uint64(const SourceInfo &L) {
25176
0
  if (!isActive()) return true;
25177
0
  CurrentSource = L;
25178
0
  return Shr<PT_Uint16, PT_Uint64>(S, OpPC);
25179
0
}
25180
0
bool EvalEmitter::emitShrUint16IntAP(const SourceInfo &L) {
25181
0
  if (!isActive()) return true;
25182
0
  CurrentSource = L;
25183
0
  return Shr<PT_Uint16, PT_IntAP>(S, OpPC);
25184
0
}
25185
0
bool EvalEmitter::emitShrUint16IntAPS(const SourceInfo &L) {
25186
0
  if (!isActive()) return true;
25187
0
  CurrentSource = L;
25188
0
  return Shr<PT_Uint16, PT_IntAPS>(S, OpPC);
25189
0
}
25190
0
bool EvalEmitter::emitShrSint32Sint8(const SourceInfo &L) {
25191
0
  if (!isActive()) return true;
25192
0
  CurrentSource = L;
25193
0
  return Shr<PT_Sint32, PT_Sint8>(S, OpPC);
25194
0
}
25195
0
bool EvalEmitter::emitShrSint32Uint8(const SourceInfo &L) {
25196
0
  if (!isActive()) return true;
25197
0
  CurrentSource = L;
25198
0
  return Shr<PT_Sint32, PT_Uint8>(S, OpPC);
25199
0
}
25200
0
bool EvalEmitter::emitShrSint32Sint16(const SourceInfo &L) {
25201
0
  if (!isActive()) return true;
25202
0
  CurrentSource = L;
25203
0
  return Shr<PT_Sint32, PT_Sint16>(S, OpPC);
25204
0
}
25205
0
bool EvalEmitter::emitShrSint32Uint16(const SourceInfo &L) {
25206
0
  if (!isActive()) return true;
25207
0
  CurrentSource = L;
25208
0
  return Shr<PT_Sint32, PT_Uint16>(S, OpPC);
25209
0
}
25210
0
bool EvalEmitter::emitShrSint32Sint32(const SourceInfo &L) {
25211
0
  if (!isActive()) return true;
25212
0
  CurrentSource = L;
25213
0
  return Shr<PT_Sint32, PT_Sint32>(S, OpPC);
25214
0
}
25215
0
bool EvalEmitter::emitShrSint32Uint32(const SourceInfo &L) {
25216
0
  if (!isActive()) return true;
25217
0
  CurrentSource = L;
25218
0
  return Shr<PT_Sint32, PT_Uint32>(S, OpPC);
25219
0
}
25220
0
bool EvalEmitter::emitShrSint32Sint64(const SourceInfo &L) {
25221
0
  if (!isActive()) return true;
25222
0
  CurrentSource = L;
25223
0
  return Shr<PT_Sint32, PT_Sint64>(S, OpPC);
25224
0
}
25225
0
bool EvalEmitter::emitShrSint32Uint64(const SourceInfo &L) {
25226
0
  if (!isActive()) return true;
25227
0
  CurrentSource = L;
25228
0
  return Shr<PT_Sint32, PT_Uint64>(S, OpPC);
25229
0
}
25230
0
bool EvalEmitter::emitShrSint32IntAP(const SourceInfo &L) {
25231
0
  if (!isActive()) return true;
25232
0
  CurrentSource = L;
25233
0
  return Shr<PT_Sint32, PT_IntAP>(S, OpPC);
25234
0
}
25235
0
bool EvalEmitter::emitShrSint32IntAPS(const SourceInfo &L) {
25236
0
  if (!isActive()) return true;
25237
0
  CurrentSource = L;
25238
0
  return Shr<PT_Sint32, PT_IntAPS>(S, OpPC);
25239
0
}
25240
0
bool EvalEmitter::emitShrUint32Sint8(const SourceInfo &L) {
25241
0
  if (!isActive()) return true;
25242
0
  CurrentSource = L;
25243
0
  return Shr<PT_Uint32, PT_Sint8>(S, OpPC);
25244
0
}
25245
0
bool EvalEmitter::emitShrUint32Uint8(const SourceInfo &L) {
25246
0
  if (!isActive()) return true;
25247
0
  CurrentSource = L;
25248
0
  return Shr<PT_Uint32, PT_Uint8>(S, OpPC);
25249
0
}
25250
0
bool EvalEmitter::emitShrUint32Sint16(const SourceInfo &L) {
25251
0
  if (!isActive()) return true;
25252
0
  CurrentSource = L;
25253
0
  return Shr<PT_Uint32, PT_Sint16>(S, OpPC);
25254
0
}
25255
0
bool EvalEmitter::emitShrUint32Uint16(const SourceInfo &L) {
25256
0
  if (!isActive()) return true;
25257
0
  CurrentSource = L;
25258
0
  return Shr<PT_Uint32, PT_Uint16>(S, OpPC);
25259
0
}
25260
0
bool EvalEmitter::emitShrUint32Sint32(const SourceInfo &L) {
25261
0
  if (!isActive()) return true;
25262
0
  CurrentSource = L;
25263
0
  return Shr<PT_Uint32, PT_Sint32>(S, OpPC);
25264
0
}
25265
0
bool EvalEmitter::emitShrUint32Uint32(const SourceInfo &L) {
25266
0
  if (!isActive()) return true;
25267
0
  CurrentSource = L;
25268
0
  return Shr<PT_Uint32, PT_Uint32>(S, OpPC);
25269
0
}
25270
0
bool EvalEmitter::emitShrUint32Sint64(const SourceInfo &L) {
25271
0
  if (!isActive()) return true;
25272
0
  CurrentSource = L;
25273
0
  return Shr<PT_Uint32, PT_Sint64>(S, OpPC);
25274
0
}
25275
0
bool EvalEmitter::emitShrUint32Uint64(const SourceInfo &L) {
25276
0
  if (!isActive()) return true;
25277
0
  CurrentSource = L;
25278
0
  return Shr<PT_Uint32, PT_Uint64>(S, OpPC);
25279
0
}
25280
0
bool EvalEmitter::emitShrUint32IntAP(const SourceInfo &L) {
25281
0
  if (!isActive()) return true;
25282
0
  CurrentSource = L;
25283
0
  return Shr<PT_Uint32, PT_IntAP>(S, OpPC);
25284
0
}
25285
0
bool EvalEmitter::emitShrUint32IntAPS(const SourceInfo &L) {
25286
0
  if (!isActive()) return true;
25287
0
  CurrentSource = L;
25288
0
  return Shr<PT_Uint32, PT_IntAPS>(S, OpPC);
25289
0
}
25290
0
bool EvalEmitter::emitShrSint64Sint8(const SourceInfo &L) {
25291
0
  if (!isActive()) return true;
25292
0
  CurrentSource = L;
25293
0
  return Shr<PT_Sint64, PT_Sint8>(S, OpPC);
25294
0
}
25295
0
bool EvalEmitter::emitShrSint64Uint8(const SourceInfo &L) {
25296
0
  if (!isActive()) return true;
25297
0
  CurrentSource = L;
25298
0
  return Shr<PT_Sint64, PT_Uint8>(S, OpPC);
25299
0
}
25300
0
bool EvalEmitter::emitShrSint64Sint16(const SourceInfo &L) {
25301
0
  if (!isActive()) return true;
25302
0
  CurrentSource = L;
25303
0
  return Shr<PT_Sint64, PT_Sint16>(S, OpPC);
25304
0
}
25305
0
bool EvalEmitter::emitShrSint64Uint16(const SourceInfo &L) {
25306
0
  if (!isActive()) return true;
25307
0
  CurrentSource = L;
25308
0
  return Shr<PT_Sint64, PT_Uint16>(S, OpPC);
25309
0
}
25310
0
bool EvalEmitter::emitShrSint64Sint32(const SourceInfo &L) {
25311
0
  if (!isActive()) return true;
25312
0
  CurrentSource = L;
25313
0
  return Shr<PT_Sint64, PT_Sint32>(S, OpPC);
25314
0
}
25315
0
bool EvalEmitter::emitShrSint64Uint32(const SourceInfo &L) {
25316
0
  if (!isActive()) return true;
25317
0
  CurrentSource = L;
25318
0
  return Shr<PT_Sint64, PT_Uint32>(S, OpPC);
25319
0
}
25320
0
bool EvalEmitter::emitShrSint64Sint64(const SourceInfo &L) {
25321
0
  if (!isActive()) return true;
25322
0
  CurrentSource = L;
25323
0
  return Shr<PT_Sint64, PT_Sint64>(S, OpPC);
25324
0
}
25325
0
bool EvalEmitter::emitShrSint64Uint64(const SourceInfo &L) {
25326
0
  if (!isActive()) return true;
25327
0
  CurrentSource = L;
25328
0
  return Shr<PT_Sint64, PT_Uint64>(S, OpPC);
25329
0
}
25330
0
bool EvalEmitter::emitShrSint64IntAP(const SourceInfo &L) {
25331
0
  if (!isActive()) return true;
25332
0
  CurrentSource = L;
25333
0
  return Shr<PT_Sint64, PT_IntAP>(S, OpPC);
25334
0
}
25335
0
bool EvalEmitter::emitShrSint64IntAPS(const SourceInfo &L) {
25336
0
  if (!isActive()) return true;
25337
0
  CurrentSource = L;
25338
0
  return Shr<PT_Sint64, PT_IntAPS>(S, OpPC);
25339
0
}
25340
0
bool EvalEmitter::emitShrUint64Sint8(const SourceInfo &L) {
25341
0
  if (!isActive()) return true;
25342
0
  CurrentSource = L;
25343
0
  return Shr<PT_Uint64, PT_Sint8>(S, OpPC);
25344
0
}
25345
0
bool EvalEmitter::emitShrUint64Uint8(const SourceInfo &L) {
25346
0
  if (!isActive()) return true;
25347
0
  CurrentSource = L;
25348
0
  return Shr<PT_Uint64, PT_Uint8>(S, OpPC);
25349
0
}
25350
0
bool EvalEmitter::emitShrUint64Sint16(const SourceInfo &L) {
25351
0
  if (!isActive()) return true;
25352
0
  CurrentSource = L;
25353
0
  return Shr<PT_Uint64, PT_Sint16>(S, OpPC);
25354
0
}
25355
0
bool EvalEmitter::emitShrUint64Uint16(const SourceInfo &L) {
25356
0
  if (!isActive()) return true;
25357
0
  CurrentSource = L;
25358
0
  return Shr<PT_Uint64, PT_Uint16>(S, OpPC);
25359
0
}
25360
0
bool EvalEmitter::emitShrUint64Sint32(const SourceInfo &L) {
25361
0
  if (!isActive()) return true;
25362
0
  CurrentSource = L;
25363
0
  return Shr<PT_Uint64, PT_Sint32>(S, OpPC);
25364
0
}
25365
0
bool EvalEmitter::emitShrUint64Uint32(const SourceInfo &L) {
25366
0
  if (!isActive()) return true;
25367
0
  CurrentSource = L;
25368
0
  return Shr<PT_Uint64, PT_Uint32>(S, OpPC);
25369
0
}
25370
0
bool EvalEmitter::emitShrUint64Sint64(const SourceInfo &L) {
25371
0
  if (!isActive()) return true;
25372
0
  CurrentSource = L;
25373
0
  return Shr<PT_Uint64, PT_Sint64>(S, OpPC);
25374
0
}
25375
0
bool EvalEmitter::emitShrUint64Uint64(const SourceInfo &L) {
25376
0
  if (!isActive()) return true;
25377
0
  CurrentSource = L;
25378
0
  return Shr<PT_Uint64, PT_Uint64>(S, OpPC);
25379
0
}
25380
0
bool EvalEmitter::emitShrUint64IntAP(const SourceInfo &L) {
25381
0
  if (!isActive()) return true;
25382
0
  CurrentSource = L;
25383
0
  return Shr<PT_Uint64, PT_IntAP>(S, OpPC);
25384
0
}
25385
0
bool EvalEmitter::emitShrUint64IntAPS(const SourceInfo &L) {
25386
0
  if (!isActive()) return true;
25387
0
  CurrentSource = L;
25388
0
  return Shr<PT_Uint64, PT_IntAPS>(S, OpPC);
25389
0
}
25390
0
bool EvalEmitter::emitShrIntAPSint8(const SourceInfo &L) {
25391
0
  if (!isActive()) return true;
25392
0
  CurrentSource = L;
25393
0
  return Shr<PT_IntAP, PT_Sint8>(S, OpPC);
25394
0
}
25395
0
bool EvalEmitter::emitShrIntAPUint8(const SourceInfo &L) {
25396
0
  if (!isActive()) return true;
25397
0
  CurrentSource = L;
25398
0
  return Shr<PT_IntAP, PT_Uint8>(S, OpPC);
25399
0
}
25400
0
bool EvalEmitter::emitShrIntAPSint16(const SourceInfo &L) {
25401
0
  if (!isActive()) return true;
25402
0
  CurrentSource = L;
25403
0
  return Shr<PT_IntAP, PT_Sint16>(S, OpPC);
25404
0
}
25405
0
bool EvalEmitter::emitShrIntAPUint16(const SourceInfo &L) {
25406
0
  if (!isActive()) return true;
25407
0
  CurrentSource = L;
25408
0
  return Shr<PT_IntAP, PT_Uint16>(S, OpPC);
25409
0
}
25410
0
bool EvalEmitter::emitShrIntAPSint32(const SourceInfo &L) {
25411
0
  if (!isActive()) return true;
25412
0
  CurrentSource = L;
25413
0
  return Shr<PT_IntAP, PT_Sint32>(S, OpPC);
25414
0
}
25415
0
bool EvalEmitter::emitShrIntAPUint32(const SourceInfo &L) {
25416
0
  if (!isActive()) return true;
25417
0
  CurrentSource = L;
25418
0
  return Shr<PT_IntAP, PT_Uint32>(S, OpPC);
25419
0
}
25420
0
bool EvalEmitter::emitShrIntAPSint64(const SourceInfo &L) {
25421
0
  if (!isActive()) return true;
25422
0
  CurrentSource = L;
25423
0
  return Shr<PT_IntAP, PT_Sint64>(S, OpPC);
25424
0
}
25425
0
bool EvalEmitter::emitShrIntAPUint64(const SourceInfo &L) {
25426
0
  if (!isActive()) return true;
25427
0
  CurrentSource = L;
25428
0
  return Shr<PT_IntAP, PT_Uint64>(S, OpPC);
25429
0
}
25430
0
bool EvalEmitter::emitShrIntAPIntAP(const SourceInfo &L) {
25431
0
  if (!isActive()) return true;
25432
0
  CurrentSource = L;
25433
0
  return Shr<PT_IntAP, PT_IntAP>(S, OpPC);
25434
0
}
25435
0
bool EvalEmitter::emitShrIntAPIntAPS(const SourceInfo &L) {
25436
0
  if (!isActive()) return true;
25437
0
  CurrentSource = L;
25438
0
  return Shr<PT_IntAP, PT_IntAPS>(S, OpPC);
25439
0
}
25440
0
bool EvalEmitter::emitShrIntAPSSint8(const SourceInfo &L) {
25441
0
  if (!isActive()) return true;
25442
0
  CurrentSource = L;
25443
0
  return Shr<PT_IntAPS, PT_Sint8>(S, OpPC);
25444
0
}
25445
0
bool EvalEmitter::emitShrIntAPSUint8(const SourceInfo &L) {
25446
0
  if (!isActive()) return true;
25447
0
  CurrentSource = L;
25448
0
  return Shr<PT_IntAPS, PT_Uint8>(S, OpPC);
25449
0
}
25450
0
bool EvalEmitter::emitShrIntAPSSint16(const SourceInfo &L) {
25451
0
  if (!isActive()) return true;
25452
0
  CurrentSource = L;
25453
0
  return Shr<PT_IntAPS, PT_Sint16>(S, OpPC);
25454
0
}
25455
0
bool EvalEmitter::emitShrIntAPSUint16(const SourceInfo &L) {
25456
0
  if (!isActive()) return true;
25457
0
  CurrentSource = L;
25458
0
  return Shr<PT_IntAPS, PT_Uint16>(S, OpPC);
25459
0
}
25460
0
bool EvalEmitter::emitShrIntAPSSint32(const SourceInfo &L) {
25461
0
  if (!isActive()) return true;
25462
0
  CurrentSource = L;
25463
0
  return Shr<PT_IntAPS, PT_Sint32>(S, OpPC);
25464
0
}
25465
0
bool EvalEmitter::emitShrIntAPSUint32(const SourceInfo &L) {
25466
0
  if (!isActive()) return true;
25467
0
  CurrentSource = L;
25468
0
  return Shr<PT_IntAPS, PT_Uint32>(S, OpPC);
25469
0
}
25470
0
bool EvalEmitter::emitShrIntAPSSint64(const SourceInfo &L) {
25471
0
  if (!isActive()) return true;
25472
0
  CurrentSource = L;
25473
0
  return Shr<PT_IntAPS, PT_Sint64>(S, OpPC);
25474
0
}
25475
0
bool EvalEmitter::emitShrIntAPSUint64(const SourceInfo &L) {
25476
0
  if (!isActive()) return true;
25477
0
  CurrentSource = L;
25478
0
  return Shr<PT_IntAPS, PT_Uint64>(S, OpPC);
25479
0
}
25480
0
bool EvalEmitter::emitShrIntAPSIntAP(const SourceInfo &L) {
25481
0
  if (!isActive()) return true;
25482
0
  CurrentSource = L;
25483
0
  return Shr<PT_IntAPS, PT_IntAP>(S, OpPC);
25484
0
}
25485
0
bool EvalEmitter::emitShrIntAPSIntAPS(const SourceInfo &L) {
25486
0
  if (!isActive()) return true;
25487
0
  CurrentSource = L;
25488
0
  return Shr<PT_IntAPS, PT_IntAPS>(S, OpPC);
25489
0
}
25490
#endif
25491
#ifdef GET_OPCODE_NAMES
25492
OP_StoreSint8,
25493
OP_StoreUint8,
25494
OP_StoreSint16,
25495
OP_StoreUint16,
25496
OP_StoreSint32,
25497
OP_StoreUint32,
25498
OP_StoreSint64,
25499
OP_StoreUint64,
25500
OP_StoreIntAP,
25501
OP_StoreIntAPS,
25502
OP_StoreBool,
25503
OP_StorePtr,
25504
OP_StoreFnPtr,
25505
OP_StoreFloat,
25506
#endif
25507
0
#ifdef GET_INTERP
25508
0
case OP_StoreSint8: {
25509
0
  if (!Store<PT_Sint8>(S, OpPC))
25510
0
    return false;
25511
0
  continue;
25512
0
}
25513
0
case OP_StoreUint8: {
25514
0
  if (!Store<PT_Uint8>(S, OpPC))
25515
0
    return false;
25516
0
  continue;
25517
0
}
25518
0
case OP_StoreSint16: {
25519
0
  if (!Store<PT_Sint16>(S, OpPC))
25520
0
    return false;
25521
0
  continue;
25522
0
}
25523
0
case OP_StoreUint16: {
25524
0
  if (!Store<PT_Uint16>(S, OpPC))
25525
0
    return false;
25526
0
  continue;
25527
0
}
25528
0
case OP_StoreSint32: {
25529
0
  if (!Store<PT_Sint32>(S, OpPC))
25530
0
    return false;
25531
0
  continue;
25532
0
}
25533
0
case OP_StoreUint32: {
25534
0
  if (!Store<PT_Uint32>(S, OpPC))
25535
0
    return false;
25536
0
  continue;
25537
0
}
25538
0
case OP_StoreSint64: {
25539
0
  if (!Store<PT_Sint64>(S, OpPC))
25540
0
    return false;
25541
0
  continue;
25542
0
}
25543
0
case OP_StoreUint64: {
25544
0
  if (!Store<PT_Uint64>(S, OpPC))
25545
0
    return false;
25546
0
  continue;
25547
0
}
25548
0
case OP_StoreIntAP: {
25549
0
  if (!Store<PT_IntAP>(S, OpPC))
25550
0
    return false;
25551
0
  continue;
25552
0
}
25553
0
case OP_StoreIntAPS: {
25554
0
  if (!Store<PT_IntAPS>(S, OpPC))
25555
0
    return false;
25556
0
  continue;
25557
0
}
25558
0
case OP_StoreBool: {
25559
0
  if (!Store<PT_Bool>(S, OpPC))
25560
0
    return false;
25561
0
  continue;
25562
0
}
25563
0
case OP_StorePtr: {
25564
0
  if (!Store<PT_Ptr>(S, OpPC))
25565
0
    return false;
25566
0
  continue;
25567
0
}
25568
0
case OP_StoreFnPtr: {
25569
0
  if (!Store<PT_FnPtr>(S, OpPC))
25570
0
    return false;
25571
0
  continue;
25572
0
}
25573
0
case OP_StoreFloat: {
25574
0
  if (!Store<PT_Float>(S, OpPC))
25575
0
    return false;
25576
0
  continue;
25577
0
}
25578
0
#endif
25579
#ifdef GET_DISASM
25580
case OP_StoreSint8:
25581
  PrintName("StoreSint8");
25582
  OS << "\t" << "\n";
25583
  continue;
25584
case OP_StoreUint8:
25585
  PrintName("StoreUint8");
25586
  OS << "\t" << "\n";
25587
  continue;
25588
case OP_StoreSint16:
25589
  PrintName("StoreSint16");
25590
  OS << "\t" << "\n";
25591
  continue;
25592
case OP_StoreUint16:
25593
  PrintName("StoreUint16");
25594
  OS << "\t" << "\n";
25595
  continue;
25596
case OP_StoreSint32:
25597
  PrintName("StoreSint32");
25598
  OS << "\t" << "\n";
25599
  continue;
25600
case OP_StoreUint32:
25601
  PrintName("StoreUint32");
25602
  OS << "\t" << "\n";
25603
  continue;
25604
case OP_StoreSint64:
25605
  PrintName("StoreSint64");
25606
  OS << "\t" << "\n";
25607
  continue;
25608
case OP_StoreUint64:
25609
  PrintName("StoreUint64");
25610
  OS << "\t" << "\n";
25611
  continue;
25612
case OP_StoreIntAP:
25613
  PrintName("StoreIntAP");
25614
  OS << "\t" << "\n";
25615
  continue;
25616
case OP_StoreIntAPS:
25617
  PrintName("StoreIntAPS");
25618
  OS << "\t" << "\n";
25619
  continue;
25620
case OP_StoreBool:
25621
  PrintName("StoreBool");
25622
  OS << "\t" << "\n";
25623
  continue;
25624
case OP_StorePtr:
25625
  PrintName("StorePtr");
25626
  OS << "\t" << "\n";
25627
  continue;
25628
case OP_StoreFnPtr:
25629
  PrintName("StoreFnPtr");
25630
  OS << "\t" << "\n";
25631
  continue;
25632
case OP_StoreFloat:
25633
  PrintName("StoreFloat");
25634
  OS << "\t" << "\n";
25635
  continue;
25636
#endif
25637
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25638
bool emitStoreSint8(const SourceInfo &);
25639
bool emitStoreUint8(const SourceInfo &);
25640
bool emitStoreSint16(const SourceInfo &);
25641
bool emitStoreUint16(const SourceInfo &);
25642
bool emitStoreSint32(const SourceInfo &);
25643
bool emitStoreUint32(const SourceInfo &);
25644
bool emitStoreSint64(const SourceInfo &);
25645
bool emitStoreUint64(const SourceInfo &);
25646
bool emitStoreIntAP(const SourceInfo &);
25647
bool emitStoreIntAPS(const SourceInfo &);
25648
bool emitStoreBool(const SourceInfo &);
25649
bool emitStorePtr(const SourceInfo &);
25650
bool emitStoreFnPtr(const SourceInfo &);
25651
bool emitStoreFloat(const SourceInfo &);
25652
#endif
25653
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25654
bool emitStore(PrimType, const SourceInfo &I);
25655
#endif
25656
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
25657
bool
25658
#if defined(GET_EVAL_IMPL)
25659
EvalEmitter
25660
#else
25661
ByteCodeEmitter
25662
#endif
25663
0
::emitStore(PrimType T0, const SourceInfo &I) {
25664
0
  switch (T0) {
25665
0
  case PT_Sint8:
25666
0
    return emitStoreSint8(I);
25667
0
  case PT_Uint8:
25668
0
    return emitStoreUint8(I);
25669
0
  case PT_Sint16:
25670
0
    return emitStoreSint16(I);
25671
0
  case PT_Uint16:
25672
0
    return emitStoreUint16(I);
25673
0
  case PT_Sint32:
25674
0
    return emitStoreSint32(I);
25675
0
  case PT_Uint32:
25676
0
    return emitStoreUint32(I);
25677
0
  case PT_Sint64:
25678
0
    return emitStoreSint64(I);
25679
0
  case PT_Uint64:
25680
0
    return emitStoreUint64(I);
25681
0
  case PT_IntAP:
25682
0
    return emitStoreIntAP(I);
25683
0
  case PT_IntAPS:
25684
0
    return emitStoreIntAPS(I);
25685
0
  case PT_Bool:
25686
0
    return emitStoreBool(I);
25687
0
  case PT_Ptr:
25688
0
    return emitStorePtr(I);
25689
0
  case PT_FnPtr:
25690
0
    return emitStoreFnPtr(I);
25691
0
  case PT_Float:
25692
0
    return emitStoreFloat(I);
25693
0
  }
25694
0
  llvm_unreachable("invalid enum value");
25695
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitStore(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitStore(clang::interp::PrimType, clang::interp::SourceInfo const&)
25696
#endif
25697
#ifdef GET_LINK_IMPL
25698
0
bool ByteCodeEmitter::emitStoreSint8(const SourceInfo &L) {
25699
0
  return emitOp<>(OP_StoreSint8, L);
25700
0
}
25701
0
bool ByteCodeEmitter::emitStoreUint8(const SourceInfo &L) {
25702
0
  return emitOp<>(OP_StoreUint8, L);
25703
0
}
25704
0
bool ByteCodeEmitter::emitStoreSint16(const SourceInfo &L) {
25705
0
  return emitOp<>(OP_StoreSint16, L);
25706
0
}
25707
0
bool ByteCodeEmitter::emitStoreUint16(const SourceInfo &L) {
25708
0
  return emitOp<>(OP_StoreUint16, L);
25709
0
}
25710
0
bool ByteCodeEmitter::emitStoreSint32(const SourceInfo &L) {
25711
0
  return emitOp<>(OP_StoreSint32, L);
25712
0
}
25713
0
bool ByteCodeEmitter::emitStoreUint32(const SourceInfo &L) {
25714
0
  return emitOp<>(OP_StoreUint32, L);
25715
0
}
25716
0
bool ByteCodeEmitter::emitStoreSint64(const SourceInfo &L) {
25717
0
  return emitOp<>(OP_StoreSint64, L);
25718
0
}
25719
0
bool ByteCodeEmitter::emitStoreUint64(const SourceInfo &L) {
25720
0
  return emitOp<>(OP_StoreUint64, L);
25721
0
}
25722
0
bool ByteCodeEmitter::emitStoreIntAP(const SourceInfo &L) {
25723
0
  return emitOp<>(OP_StoreIntAP, L);
25724
0
}
25725
0
bool ByteCodeEmitter::emitStoreIntAPS(const SourceInfo &L) {
25726
0
  return emitOp<>(OP_StoreIntAPS, L);
25727
0
}
25728
0
bool ByteCodeEmitter::emitStoreBool(const SourceInfo &L) {
25729
0
  return emitOp<>(OP_StoreBool, L);
25730
0
}
25731
0
bool ByteCodeEmitter::emitStorePtr(const SourceInfo &L) {
25732
0
  return emitOp<>(OP_StorePtr, L);
25733
0
}
25734
0
bool ByteCodeEmitter::emitStoreFnPtr(const SourceInfo &L) {
25735
0
  return emitOp<>(OP_StoreFnPtr, L);
25736
0
}
25737
0
bool ByteCodeEmitter::emitStoreFloat(const SourceInfo &L) {
25738
0
  return emitOp<>(OP_StoreFloat, L);
25739
0
}
25740
#endif
25741
#ifdef GET_EVAL_IMPL
25742
0
bool EvalEmitter::emitStoreSint8(const SourceInfo &L) {
25743
0
  if (!isActive()) return true;
25744
0
  CurrentSource = L;
25745
0
  return Store<PT_Sint8>(S, OpPC);
25746
0
}
25747
0
bool EvalEmitter::emitStoreUint8(const SourceInfo &L) {
25748
0
  if (!isActive()) return true;
25749
0
  CurrentSource = L;
25750
0
  return Store<PT_Uint8>(S, OpPC);
25751
0
}
25752
0
bool EvalEmitter::emitStoreSint16(const SourceInfo &L) {
25753
0
  if (!isActive()) return true;
25754
0
  CurrentSource = L;
25755
0
  return Store<PT_Sint16>(S, OpPC);
25756
0
}
25757
0
bool EvalEmitter::emitStoreUint16(const SourceInfo &L) {
25758
0
  if (!isActive()) return true;
25759
0
  CurrentSource = L;
25760
0
  return Store<PT_Uint16>(S, OpPC);
25761
0
}
25762
0
bool EvalEmitter::emitStoreSint32(const SourceInfo &L) {
25763
0
  if (!isActive()) return true;
25764
0
  CurrentSource = L;
25765
0
  return Store<PT_Sint32>(S, OpPC);
25766
0
}
25767
0
bool EvalEmitter::emitStoreUint32(const SourceInfo &L) {
25768
0
  if (!isActive()) return true;
25769
0
  CurrentSource = L;
25770
0
  return Store<PT_Uint32>(S, OpPC);
25771
0
}
25772
0
bool EvalEmitter::emitStoreSint64(const SourceInfo &L) {
25773
0
  if (!isActive()) return true;
25774
0
  CurrentSource = L;
25775
0
  return Store<PT_Sint64>(S, OpPC);
25776
0
}
25777
0
bool EvalEmitter::emitStoreUint64(const SourceInfo &L) {
25778
0
  if (!isActive()) return true;
25779
0
  CurrentSource = L;
25780
0
  return Store<PT_Uint64>(S, OpPC);
25781
0
}
25782
0
bool EvalEmitter::emitStoreIntAP(const SourceInfo &L) {
25783
0
  if (!isActive()) return true;
25784
0
  CurrentSource = L;
25785
0
  return Store<PT_IntAP>(S, OpPC);
25786
0
}
25787
0
bool EvalEmitter::emitStoreIntAPS(const SourceInfo &L) {
25788
0
  if (!isActive()) return true;
25789
0
  CurrentSource = L;
25790
0
  return Store<PT_IntAPS>(S, OpPC);
25791
0
}
25792
0
bool EvalEmitter::emitStoreBool(const SourceInfo &L) {
25793
0
  if (!isActive()) return true;
25794
0
  CurrentSource = L;
25795
0
  return Store<PT_Bool>(S, OpPC);
25796
0
}
25797
0
bool EvalEmitter::emitStorePtr(const SourceInfo &L) {
25798
0
  if (!isActive()) return true;
25799
0
  CurrentSource = L;
25800
0
  return Store<PT_Ptr>(S, OpPC);
25801
0
}
25802
0
bool EvalEmitter::emitStoreFnPtr(const SourceInfo &L) {
25803
0
  if (!isActive()) return true;
25804
0
  CurrentSource = L;
25805
0
  return Store<PT_FnPtr>(S, OpPC);
25806
0
}
25807
0
bool EvalEmitter::emitStoreFloat(const SourceInfo &L) {
25808
0
  if (!isActive()) return true;
25809
0
  CurrentSource = L;
25810
0
  return Store<PT_Float>(S, OpPC);
25811
0
}
25812
#endif
25813
#ifdef GET_OPCODE_NAMES
25814
OP_StoreBitFieldSint8,
25815
OP_StoreBitFieldUint8,
25816
OP_StoreBitFieldSint16,
25817
OP_StoreBitFieldUint16,
25818
OP_StoreBitFieldSint32,
25819
OP_StoreBitFieldUint32,
25820
OP_StoreBitFieldSint64,
25821
OP_StoreBitFieldUint64,
25822
OP_StoreBitFieldIntAP,
25823
OP_StoreBitFieldIntAPS,
25824
OP_StoreBitFieldBool,
25825
#endif
25826
0
#ifdef GET_INTERP
25827
0
case OP_StoreBitFieldSint8: {
25828
0
  if (!StoreBitField<PT_Sint8>(S, OpPC))
25829
0
    return false;
25830
0
  continue;
25831
0
}
25832
0
case OP_StoreBitFieldUint8: {
25833
0
  if (!StoreBitField<PT_Uint8>(S, OpPC))
25834
0
    return false;
25835
0
  continue;
25836
0
}
25837
0
case OP_StoreBitFieldSint16: {
25838
0
  if (!StoreBitField<PT_Sint16>(S, OpPC))
25839
0
    return false;
25840
0
  continue;
25841
0
}
25842
0
case OP_StoreBitFieldUint16: {
25843
0
  if (!StoreBitField<PT_Uint16>(S, OpPC))
25844
0
    return false;
25845
0
  continue;
25846
0
}
25847
0
case OP_StoreBitFieldSint32: {
25848
0
  if (!StoreBitField<PT_Sint32>(S, OpPC))
25849
0
    return false;
25850
0
  continue;
25851
0
}
25852
0
case OP_StoreBitFieldUint32: {
25853
0
  if (!StoreBitField<PT_Uint32>(S, OpPC))
25854
0
    return false;
25855
0
  continue;
25856
0
}
25857
0
case OP_StoreBitFieldSint64: {
25858
0
  if (!StoreBitField<PT_Sint64>(S, OpPC))
25859
0
    return false;
25860
0
  continue;
25861
0
}
25862
0
case OP_StoreBitFieldUint64: {
25863
0
  if (!StoreBitField<PT_Uint64>(S, OpPC))
25864
0
    return false;
25865
0
  continue;
25866
0
}
25867
0
case OP_StoreBitFieldIntAP: {
25868
0
  if (!StoreBitField<PT_IntAP>(S, OpPC))
25869
0
    return false;
25870
0
  continue;
25871
0
}
25872
0
case OP_StoreBitFieldIntAPS: {
25873
0
  if (!StoreBitField<PT_IntAPS>(S, OpPC))
25874
0
    return false;
25875
0
  continue;
25876
0
}
25877
0
case OP_StoreBitFieldBool: {
25878
0
  if (!StoreBitField<PT_Bool>(S, OpPC))
25879
0
    return false;
25880
0
  continue;
25881
0
}
25882
0
#endif
25883
#ifdef GET_DISASM
25884
case OP_StoreBitFieldSint8:
25885
  PrintName("StoreBitFieldSint8");
25886
  OS << "\t" << "\n";
25887
  continue;
25888
case OP_StoreBitFieldUint8:
25889
  PrintName("StoreBitFieldUint8");
25890
  OS << "\t" << "\n";
25891
  continue;
25892
case OP_StoreBitFieldSint16:
25893
  PrintName("StoreBitFieldSint16");
25894
  OS << "\t" << "\n";
25895
  continue;
25896
case OP_StoreBitFieldUint16:
25897
  PrintName("StoreBitFieldUint16");
25898
  OS << "\t" << "\n";
25899
  continue;
25900
case OP_StoreBitFieldSint32:
25901
  PrintName("StoreBitFieldSint32");
25902
  OS << "\t" << "\n";
25903
  continue;
25904
case OP_StoreBitFieldUint32:
25905
  PrintName("StoreBitFieldUint32");
25906
  OS << "\t" << "\n";
25907
  continue;
25908
case OP_StoreBitFieldSint64:
25909
  PrintName("StoreBitFieldSint64");
25910
  OS << "\t" << "\n";
25911
  continue;
25912
case OP_StoreBitFieldUint64:
25913
  PrintName("StoreBitFieldUint64");
25914
  OS << "\t" << "\n";
25915
  continue;
25916
case OP_StoreBitFieldIntAP:
25917
  PrintName("StoreBitFieldIntAP");
25918
  OS << "\t" << "\n";
25919
  continue;
25920
case OP_StoreBitFieldIntAPS:
25921
  PrintName("StoreBitFieldIntAPS");
25922
  OS << "\t" << "\n";
25923
  continue;
25924
case OP_StoreBitFieldBool:
25925
  PrintName("StoreBitFieldBool");
25926
  OS << "\t" << "\n";
25927
  continue;
25928
#endif
25929
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25930
bool emitStoreBitFieldSint8(const SourceInfo &);
25931
bool emitStoreBitFieldUint8(const SourceInfo &);
25932
bool emitStoreBitFieldSint16(const SourceInfo &);
25933
bool emitStoreBitFieldUint16(const SourceInfo &);
25934
bool emitStoreBitFieldSint32(const SourceInfo &);
25935
bool emitStoreBitFieldUint32(const SourceInfo &);
25936
bool emitStoreBitFieldSint64(const SourceInfo &);
25937
bool emitStoreBitFieldUint64(const SourceInfo &);
25938
bool emitStoreBitFieldIntAP(const SourceInfo &);
25939
bool emitStoreBitFieldIntAPS(const SourceInfo &);
25940
bool emitStoreBitFieldBool(const SourceInfo &);
25941
#endif
25942
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25943
bool emitStoreBitField(PrimType, const SourceInfo &I);
25944
#endif
25945
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
25946
bool
25947
#if defined(GET_EVAL_IMPL)
25948
EvalEmitter
25949
#else
25950
ByteCodeEmitter
25951
#endif
25952
0
::emitStoreBitField(PrimType T0, const SourceInfo &I) {
25953
0
  switch (T0) {
25954
0
  case PT_Sint8:
25955
0
    return emitStoreBitFieldSint8(I);
25956
0
  case PT_Uint8:
25957
0
    return emitStoreBitFieldUint8(I);
25958
0
  case PT_Sint16:
25959
0
    return emitStoreBitFieldSint16(I);
25960
0
  case PT_Uint16:
25961
0
    return emitStoreBitFieldUint16(I);
25962
0
  case PT_Sint32:
25963
0
    return emitStoreBitFieldSint32(I);
25964
0
  case PT_Uint32:
25965
0
    return emitStoreBitFieldUint32(I);
25966
0
  case PT_Sint64:
25967
0
    return emitStoreBitFieldSint64(I);
25968
0
  case PT_Uint64:
25969
0
    return emitStoreBitFieldUint64(I);
25970
0
  case PT_IntAP:
25971
0
    return emitStoreBitFieldIntAP(I);
25972
0
  case PT_IntAPS:
25973
0
    return emitStoreBitFieldIntAPS(I);
25974
0
  case PT_Bool:
25975
0
    return emitStoreBitFieldBool(I);
25976
0
  default: llvm_unreachable("invalid type: emitStoreBitField");
25977
0
  }
25978
0
  llvm_unreachable("invalid enum value");
25979
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitStoreBitField(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitStoreBitField(clang::interp::PrimType, clang::interp::SourceInfo const&)
25980
#endif
25981
#ifdef GET_LINK_IMPL
25982
0
bool ByteCodeEmitter::emitStoreBitFieldSint8(const SourceInfo &L) {
25983
0
  return emitOp<>(OP_StoreBitFieldSint8, L);
25984
0
}
25985
0
bool ByteCodeEmitter::emitStoreBitFieldUint8(const SourceInfo &L) {
25986
0
  return emitOp<>(OP_StoreBitFieldUint8, L);
25987
0
}
25988
0
bool ByteCodeEmitter::emitStoreBitFieldSint16(const SourceInfo &L) {
25989
0
  return emitOp<>(OP_StoreBitFieldSint16, L);
25990
0
}
25991
0
bool ByteCodeEmitter::emitStoreBitFieldUint16(const SourceInfo &L) {
25992
0
  return emitOp<>(OP_StoreBitFieldUint16, L);
25993
0
}
25994
0
bool ByteCodeEmitter::emitStoreBitFieldSint32(const SourceInfo &L) {
25995
0
  return emitOp<>(OP_StoreBitFieldSint32, L);
25996
0
}
25997
0
bool ByteCodeEmitter::emitStoreBitFieldUint32(const SourceInfo &L) {
25998
0
  return emitOp<>(OP_StoreBitFieldUint32, L);
25999
0
}
26000
0
bool ByteCodeEmitter::emitStoreBitFieldSint64(const SourceInfo &L) {
26001
0
  return emitOp<>(OP_StoreBitFieldSint64, L);
26002
0
}
26003
0
bool ByteCodeEmitter::emitStoreBitFieldUint64(const SourceInfo &L) {
26004
0
  return emitOp<>(OP_StoreBitFieldUint64, L);
26005
0
}
26006
0
bool ByteCodeEmitter::emitStoreBitFieldIntAP(const SourceInfo &L) {
26007
0
  return emitOp<>(OP_StoreBitFieldIntAP, L);
26008
0
}
26009
0
bool ByteCodeEmitter::emitStoreBitFieldIntAPS(const SourceInfo &L) {
26010
0
  return emitOp<>(OP_StoreBitFieldIntAPS, L);
26011
0
}
26012
0
bool ByteCodeEmitter::emitStoreBitFieldBool(const SourceInfo &L) {
26013
0
  return emitOp<>(OP_StoreBitFieldBool, L);
26014
0
}
26015
#endif
26016
#ifdef GET_EVAL_IMPL
26017
0
bool EvalEmitter::emitStoreBitFieldSint8(const SourceInfo &L) {
26018
0
  if (!isActive()) return true;
26019
0
  CurrentSource = L;
26020
0
  return StoreBitField<PT_Sint8>(S, OpPC);
26021
0
}
26022
0
bool EvalEmitter::emitStoreBitFieldUint8(const SourceInfo &L) {
26023
0
  if (!isActive()) return true;
26024
0
  CurrentSource = L;
26025
0
  return StoreBitField<PT_Uint8>(S, OpPC);
26026
0
}
26027
0
bool EvalEmitter::emitStoreBitFieldSint16(const SourceInfo &L) {
26028
0
  if (!isActive()) return true;
26029
0
  CurrentSource = L;
26030
0
  return StoreBitField<PT_Sint16>(S, OpPC);
26031
0
}
26032
0
bool EvalEmitter::emitStoreBitFieldUint16(const SourceInfo &L) {
26033
0
  if (!isActive()) return true;
26034
0
  CurrentSource = L;
26035
0
  return StoreBitField<PT_Uint16>(S, OpPC);
26036
0
}
26037
0
bool EvalEmitter::emitStoreBitFieldSint32(const SourceInfo &L) {
26038
0
  if (!isActive()) return true;
26039
0
  CurrentSource = L;
26040
0
  return StoreBitField<PT_Sint32>(S, OpPC);
26041
0
}
26042
0
bool EvalEmitter::emitStoreBitFieldUint32(const SourceInfo &L) {
26043
0
  if (!isActive()) return true;
26044
0
  CurrentSource = L;
26045
0
  return StoreBitField<PT_Uint32>(S, OpPC);
26046
0
}
26047
0
bool EvalEmitter::emitStoreBitFieldSint64(const SourceInfo &L) {
26048
0
  if (!isActive()) return true;
26049
0
  CurrentSource = L;
26050
0
  return StoreBitField<PT_Sint64>(S, OpPC);
26051
0
}
26052
0
bool EvalEmitter::emitStoreBitFieldUint64(const SourceInfo &L) {
26053
0
  if (!isActive()) return true;
26054
0
  CurrentSource = L;
26055
0
  return StoreBitField<PT_Uint64>(S, OpPC);
26056
0
}
26057
0
bool EvalEmitter::emitStoreBitFieldIntAP(const SourceInfo &L) {
26058
0
  if (!isActive()) return true;
26059
0
  CurrentSource = L;
26060
0
  return StoreBitField<PT_IntAP>(S, OpPC);
26061
0
}
26062
0
bool EvalEmitter::emitStoreBitFieldIntAPS(const SourceInfo &L) {
26063
0
  if (!isActive()) return true;
26064
0
  CurrentSource = L;
26065
0
  return StoreBitField<PT_IntAPS>(S, OpPC);
26066
0
}
26067
0
bool EvalEmitter::emitStoreBitFieldBool(const SourceInfo &L) {
26068
0
  if (!isActive()) return true;
26069
0
  CurrentSource = L;
26070
0
  return StoreBitField<PT_Bool>(S, OpPC);
26071
0
}
26072
#endif
26073
#ifdef GET_OPCODE_NAMES
26074
OP_StoreBitFieldPopSint8,
26075
OP_StoreBitFieldPopUint8,
26076
OP_StoreBitFieldPopSint16,
26077
OP_StoreBitFieldPopUint16,
26078
OP_StoreBitFieldPopSint32,
26079
OP_StoreBitFieldPopUint32,
26080
OP_StoreBitFieldPopSint64,
26081
OP_StoreBitFieldPopUint64,
26082
OP_StoreBitFieldPopIntAP,
26083
OP_StoreBitFieldPopIntAPS,
26084
OP_StoreBitFieldPopBool,
26085
#endif
26086
0
#ifdef GET_INTERP
26087
0
case OP_StoreBitFieldPopSint8: {
26088
0
  if (!StoreBitFieldPop<PT_Sint8>(S, OpPC))
26089
0
    return false;
26090
0
  continue;
26091
0
}
26092
0
case OP_StoreBitFieldPopUint8: {
26093
0
  if (!StoreBitFieldPop<PT_Uint8>(S, OpPC))
26094
0
    return false;
26095
0
  continue;
26096
0
}
26097
0
case OP_StoreBitFieldPopSint16: {
26098
0
  if (!StoreBitFieldPop<PT_Sint16>(S, OpPC))
26099
0
    return false;
26100
0
  continue;
26101
0
}
26102
0
case OP_StoreBitFieldPopUint16: {
26103
0
  if (!StoreBitFieldPop<PT_Uint16>(S, OpPC))
26104
0
    return false;
26105
0
  continue;
26106
0
}
26107
0
case OP_StoreBitFieldPopSint32: {
26108
0
  if (!StoreBitFieldPop<PT_Sint32>(S, OpPC))
26109
0
    return false;
26110
0
  continue;
26111
0
}
26112
0
case OP_StoreBitFieldPopUint32: {
26113
0
  if (!StoreBitFieldPop<PT_Uint32>(S, OpPC))
26114
0
    return false;
26115
0
  continue;
26116
0
}
26117
0
case OP_StoreBitFieldPopSint64: {
26118
0
  if (!StoreBitFieldPop<PT_Sint64>(S, OpPC))
26119
0
    return false;
26120
0
  continue;
26121
0
}
26122
0
case OP_StoreBitFieldPopUint64: {
26123
0
  if (!StoreBitFieldPop<PT_Uint64>(S, OpPC))
26124
0
    return false;
26125
0
  continue;
26126
0
}
26127
0
case OP_StoreBitFieldPopIntAP: {
26128
0
  if (!StoreBitFieldPop<PT_IntAP>(S, OpPC))
26129
0
    return false;
26130
0
  continue;
26131
0
}
26132
0
case OP_StoreBitFieldPopIntAPS: {
26133
0
  if (!StoreBitFieldPop<PT_IntAPS>(S, OpPC))
26134
0
    return false;
26135
0
  continue;
26136
0
}
26137
0
case OP_StoreBitFieldPopBool: {
26138
0
  if (!StoreBitFieldPop<PT_Bool>(S, OpPC))
26139
0
    return false;
26140
0
  continue;
26141
0
}
26142
0
#endif
26143
#ifdef GET_DISASM
26144
case OP_StoreBitFieldPopSint8:
26145
  PrintName("StoreBitFieldPopSint8");
26146
  OS << "\t" << "\n";
26147
  continue;
26148
case OP_StoreBitFieldPopUint8:
26149
  PrintName("StoreBitFieldPopUint8");
26150
  OS << "\t" << "\n";
26151
  continue;
26152
case OP_StoreBitFieldPopSint16:
26153
  PrintName("StoreBitFieldPopSint16");
26154
  OS << "\t" << "\n";
26155
  continue;
26156
case OP_StoreBitFieldPopUint16:
26157
  PrintName("StoreBitFieldPopUint16");
26158
  OS << "\t" << "\n";
26159
  continue;
26160
case OP_StoreBitFieldPopSint32:
26161
  PrintName("StoreBitFieldPopSint32");
26162
  OS << "\t" << "\n";
26163
  continue;
26164
case OP_StoreBitFieldPopUint32:
26165
  PrintName("StoreBitFieldPopUint32");
26166
  OS << "\t" << "\n";
26167
  continue;
26168
case OP_StoreBitFieldPopSint64:
26169
  PrintName("StoreBitFieldPopSint64");
26170
  OS << "\t" << "\n";
26171
  continue;
26172
case OP_StoreBitFieldPopUint64:
26173
  PrintName("StoreBitFieldPopUint64");
26174
  OS << "\t" << "\n";
26175
  continue;
26176
case OP_StoreBitFieldPopIntAP:
26177
  PrintName("StoreBitFieldPopIntAP");
26178
  OS << "\t" << "\n";
26179
  continue;
26180
case OP_StoreBitFieldPopIntAPS:
26181
  PrintName("StoreBitFieldPopIntAPS");
26182
  OS << "\t" << "\n";
26183
  continue;
26184
case OP_StoreBitFieldPopBool:
26185
  PrintName("StoreBitFieldPopBool");
26186
  OS << "\t" << "\n";
26187
  continue;
26188
#endif
26189
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26190
bool emitStoreBitFieldPopSint8(const SourceInfo &);
26191
bool emitStoreBitFieldPopUint8(const SourceInfo &);
26192
bool emitStoreBitFieldPopSint16(const SourceInfo &);
26193
bool emitStoreBitFieldPopUint16(const SourceInfo &);
26194
bool emitStoreBitFieldPopSint32(const SourceInfo &);
26195
bool emitStoreBitFieldPopUint32(const SourceInfo &);
26196
bool emitStoreBitFieldPopSint64(const SourceInfo &);
26197
bool emitStoreBitFieldPopUint64(const SourceInfo &);
26198
bool emitStoreBitFieldPopIntAP(const SourceInfo &);
26199
bool emitStoreBitFieldPopIntAPS(const SourceInfo &);
26200
bool emitStoreBitFieldPopBool(const SourceInfo &);
26201
#endif
26202
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26203
bool emitStoreBitFieldPop(PrimType, const SourceInfo &I);
26204
#endif
26205
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
26206
bool
26207
#if defined(GET_EVAL_IMPL)
26208
EvalEmitter
26209
#else
26210
ByteCodeEmitter
26211
#endif
26212
0
::emitStoreBitFieldPop(PrimType T0, const SourceInfo &I) {
26213
0
  switch (T0) {
26214
0
  case PT_Sint8:
26215
0
    return emitStoreBitFieldPopSint8(I);
26216
0
  case PT_Uint8:
26217
0
    return emitStoreBitFieldPopUint8(I);
26218
0
  case PT_Sint16:
26219
0
    return emitStoreBitFieldPopSint16(I);
26220
0
  case PT_Uint16:
26221
0
    return emitStoreBitFieldPopUint16(I);
26222
0
  case PT_Sint32:
26223
0
    return emitStoreBitFieldPopSint32(I);
26224
0
  case PT_Uint32:
26225
0
    return emitStoreBitFieldPopUint32(I);
26226
0
  case PT_Sint64:
26227
0
    return emitStoreBitFieldPopSint64(I);
26228
0
  case PT_Uint64:
26229
0
    return emitStoreBitFieldPopUint64(I);
26230
0
  case PT_IntAP:
26231
0
    return emitStoreBitFieldPopIntAP(I);
26232
0
  case PT_IntAPS:
26233
0
    return emitStoreBitFieldPopIntAPS(I);
26234
0
  case PT_Bool:
26235
0
    return emitStoreBitFieldPopBool(I);
26236
0
  default: llvm_unreachable("invalid type: emitStoreBitFieldPop");
26237
0
  }
26238
0
  llvm_unreachable("invalid enum value");
26239
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitStoreBitFieldPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitStoreBitFieldPop(clang::interp::PrimType, clang::interp::SourceInfo const&)
26240
#endif
26241
#ifdef GET_LINK_IMPL
26242
0
bool ByteCodeEmitter::emitStoreBitFieldPopSint8(const SourceInfo &L) {
26243
0
  return emitOp<>(OP_StoreBitFieldPopSint8, L);
26244
0
}
26245
0
bool ByteCodeEmitter::emitStoreBitFieldPopUint8(const SourceInfo &L) {
26246
0
  return emitOp<>(OP_StoreBitFieldPopUint8, L);
26247
0
}
26248
0
bool ByteCodeEmitter::emitStoreBitFieldPopSint16(const SourceInfo &L) {
26249
0
  return emitOp<>(OP_StoreBitFieldPopSint16, L);
26250
0
}
26251
0
bool ByteCodeEmitter::emitStoreBitFieldPopUint16(const SourceInfo &L) {
26252
0
  return emitOp<>(OP_StoreBitFieldPopUint16, L);
26253
0
}
26254
0
bool ByteCodeEmitter::emitStoreBitFieldPopSint32(const SourceInfo &L) {
26255
0
  return emitOp<>(OP_StoreBitFieldPopSint32, L);
26256
0
}
26257
0
bool ByteCodeEmitter::emitStoreBitFieldPopUint32(const SourceInfo &L) {
26258
0
  return emitOp<>(OP_StoreBitFieldPopUint32, L);
26259
0
}
26260
0
bool ByteCodeEmitter::emitStoreBitFieldPopSint64(const SourceInfo &L) {
26261
0
  return emitOp<>(OP_StoreBitFieldPopSint64, L);
26262
0
}
26263
0
bool ByteCodeEmitter::emitStoreBitFieldPopUint64(const SourceInfo &L) {
26264
0
  return emitOp<>(OP_StoreBitFieldPopUint64, L);
26265
0
}
26266
0
bool ByteCodeEmitter::emitStoreBitFieldPopIntAP(const SourceInfo &L) {
26267
0
  return emitOp<>(OP_StoreBitFieldPopIntAP, L);
26268
0
}
26269
0
bool ByteCodeEmitter::emitStoreBitFieldPopIntAPS(const SourceInfo &L) {
26270
0
  return emitOp<>(OP_StoreBitFieldPopIntAPS, L);
26271
0
}
26272
0
bool ByteCodeEmitter::emitStoreBitFieldPopBool(const SourceInfo &L) {
26273
0
  return emitOp<>(OP_StoreBitFieldPopBool, L);
26274
0
}
26275
#endif
26276
#ifdef GET_EVAL_IMPL
26277
0
bool EvalEmitter::emitStoreBitFieldPopSint8(const SourceInfo &L) {
26278
0
  if (!isActive()) return true;
26279
0
  CurrentSource = L;
26280
0
  return StoreBitFieldPop<PT_Sint8>(S, OpPC);
26281
0
}
26282
0
bool EvalEmitter::emitStoreBitFieldPopUint8(const SourceInfo &L) {
26283
0
  if (!isActive()) return true;
26284
0
  CurrentSource = L;
26285
0
  return StoreBitFieldPop<PT_Uint8>(S, OpPC);
26286
0
}
26287
0
bool EvalEmitter::emitStoreBitFieldPopSint16(const SourceInfo &L) {
26288
0
  if (!isActive()) return true;
26289
0
  CurrentSource = L;
26290
0
  return StoreBitFieldPop<PT_Sint16>(S, OpPC);
26291
0
}
26292
0
bool EvalEmitter::emitStoreBitFieldPopUint16(const SourceInfo &L) {
26293
0
  if (!isActive()) return true;
26294
0
  CurrentSource = L;
26295
0
  return StoreBitFieldPop<PT_Uint16>(S, OpPC);
26296
0
}
26297
0
bool EvalEmitter::emitStoreBitFieldPopSint32(const SourceInfo &L) {
26298
0
  if (!isActive()) return true;
26299
0
  CurrentSource = L;
26300
0
  return StoreBitFieldPop<PT_Sint32>(S, OpPC);
26301
0
}
26302
0
bool EvalEmitter::emitStoreBitFieldPopUint32(const SourceInfo &L) {
26303
0
  if (!isActive()) return true;
26304
0
  CurrentSource = L;
26305
0
  return StoreBitFieldPop<PT_Uint32>(S, OpPC);
26306
0
}
26307
0
bool EvalEmitter::emitStoreBitFieldPopSint64(const SourceInfo &L) {
26308
0
  if (!isActive()) return true;
26309
0
  CurrentSource = L;
26310
0
  return StoreBitFieldPop<PT_Sint64>(S, OpPC);
26311
0
}
26312
0
bool EvalEmitter::emitStoreBitFieldPopUint64(const SourceInfo &L) {
26313
0
  if (!isActive()) return true;
26314
0
  CurrentSource = L;
26315
0
  return StoreBitFieldPop<PT_Uint64>(S, OpPC);
26316
0
}
26317
0
bool EvalEmitter::emitStoreBitFieldPopIntAP(const SourceInfo &L) {
26318
0
  if (!isActive()) return true;
26319
0
  CurrentSource = L;
26320
0
  return StoreBitFieldPop<PT_IntAP>(S, OpPC);
26321
0
}
26322
0
bool EvalEmitter::emitStoreBitFieldPopIntAPS(const SourceInfo &L) {
26323
0
  if (!isActive()) return true;
26324
0
  CurrentSource = L;
26325
0
  return StoreBitFieldPop<PT_IntAPS>(S, OpPC);
26326
0
}
26327
0
bool EvalEmitter::emitStoreBitFieldPopBool(const SourceInfo &L) {
26328
0
  if (!isActive()) return true;
26329
0
  CurrentSource = L;
26330
0
  return StoreBitFieldPop<PT_Bool>(S, OpPC);
26331
0
}
26332
#endif
26333
#ifdef GET_OPCODE_NAMES
26334
OP_StorePopSint8,
26335
OP_StorePopUint8,
26336
OP_StorePopSint16,
26337
OP_StorePopUint16,
26338
OP_StorePopSint32,
26339
OP_StorePopUint32,
26340
OP_StorePopSint64,
26341
OP_StorePopUint64,
26342
OP_StorePopIntAP,
26343
OP_StorePopIntAPS,
26344
OP_StorePopBool,
26345
OP_StorePopPtr,
26346
OP_StorePopFnPtr,
26347
OP_StorePopFloat,
26348
#endif
26349
0
#ifdef GET_INTERP
26350
0
case OP_StorePopSint8: {
26351
0
  if (!StorePop<PT_Sint8>(S, OpPC))
26352
0
    return false;
26353
0
  continue;
26354
0
}
26355
0
case OP_StorePopUint8: {
26356
0
  if (!StorePop<PT_Uint8>(S, OpPC))
26357
0
    return false;
26358
0
  continue;
26359
0
}
26360
0
case OP_StorePopSint16: {
26361
0
  if (!StorePop<PT_Sint16>(S, OpPC))
26362
0
    return false;
26363
0
  continue;
26364
0
}
26365
0
case OP_StorePopUint16: {
26366
0
  if (!StorePop<PT_Uint16>(S, OpPC))
26367
0
    return false;
26368
0
  continue;
26369
0
}
26370
0
case OP_StorePopSint32: {
26371
0
  if (!StorePop<PT_Sint32>(S, OpPC))
26372
0
    return false;
26373
0
  continue;
26374
0
}
26375
0
case OP_StorePopUint32: {
26376
0
  if (!StorePop<PT_Uint32>(S, OpPC))
26377
0
    return false;
26378
0
  continue;
26379
0
}
26380
0
case OP_StorePopSint64: {
26381
0
  if (!StorePop<PT_Sint64>(S, OpPC))
26382
0
    return false;
26383
0
  continue;
26384
0
}
26385
0
case OP_StorePopUint64: {
26386
0
  if (!StorePop<PT_Uint64>(S, OpPC))
26387
0
    return false;
26388
0
  continue;
26389
0
}
26390
0
case OP_StorePopIntAP: {
26391
0
  if (!StorePop<PT_IntAP>(S, OpPC))
26392
0
    return false;
26393
0
  continue;
26394
0
}
26395
0
case OP_StorePopIntAPS: {
26396
0
  if (!StorePop<PT_IntAPS>(S, OpPC))
26397
0
    return false;
26398
0
  continue;
26399
0
}
26400
0
case OP_StorePopBool: {
26401
0
  if (!StorePop<PT_Bool>(S, OpPC))
26402
0
    return false;
26403
0
  continue;
26404
0
}
26405
0
case OP_StorePopPtr: {
26406
0
  if (!StorePop<PT_Ptr>(S, OpPC))
26407
0
    return false;
26408
0
  continue;
26409
0
}
26410
0
case OP_StorePopFnPtr: {
26411
0
  if (!StorePop<PT_FnPtr>(S, OpPC))
26412
0
    return false;
26413
0
  continue;
26414
0
}
26415
0
case OP_StorePopFloat: {
26416
0
  if (!StorePop<PT_Float>(S, OpPC))
26417
0
    return false;
26418
0
  continue;
26419
0
}
26420
0
#endif
26421
#ifdef GET_DISASM
26422
case OP_StorePopSint8:
26423
  PrintName("StorePopSint8");
26424
  OS << "\t" << "\n";
26425
  continue;
26426
case OP_StorePopUint8:
26427
  PrintName("StorePopUint8");
26428
  OS << "\t" << "\n";
26429
  continue;
26430
case OP_StorePopSint16:
26431
  PrintName("StorePopSint16");
26432
  OS << "\t" << "\n";
26433
  continue;
26434
case OP_StorePopUint16:
26435
  PrintName("StorePopUint16");
26436
  OS << "\t" << "\n";
26437
  continue;
26438
case OP_StorePopSint32:
26439
  PrintName("StorePopSint32");
26440
  OS << "\t" << "\n";
26441
  continue;
26442
case OP_StorePopUint32:
26443
  PrintName("StorePopUint32");
26444
  OS << "\t" << "\n";
26445
  continue;
26446
case OP_StorePopSint64:
26447
  PrintName("StorePopSint64");
26448
  OS << "\t" << "\n";
26449
  continue;
26450
case OP_StorePopUint64:
26451
  PrintName("StorePopUint64");
26452
  OS << "\t" << "\n";
26453
  continue;
26454
case OP_StorePopIntAP:
26455
  PrintName("StorePopIntAP");
26456
  OS << "\t" << "\n";
26457
  continue;
26458
case OP_StorePopIntAPS:
26459
  PrintName("StorePopIntAPS");
26460
  OS << "\t" << "\n";
26461
  continue;
26462
case OP_StorePopBool:
26463
  PrintName("StorePopBool");
26464
  OS << "\t" << "\n";
26465
  continue;
26466
case OP_StorePopPtr:
26467
  PrintName("StorePopPtr");
26468
  OS << "\t" << "\n";
26469
  continue;
26470
case OP_StorePopFnPtr:
26471
  PrintName("StorePopFnPtr");
26472
  OS << "\t" << "\n";
26473
  continue;
26474
case OP_StorePopFloat:
26475
  PrintName("StorePopFloat");
26476
  OS << "\t" << "\n";
26477
  continue;
26478
#endif
26479
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26480
bool emitStorePopSint8(const SourceInfo &);
26481
bool emitStorePopUint8(const SourceInfo &);
26482
bool emitStorePopSint16(const SourceInfo &);
26483
bool emitStorePopUint16(const SourceInfo &);
26484
bool emitStorePopSint32(const SourceInfo &);
26485
bool emitStorePopUint32(const SourceInfo &);
26486
bool emitStorePopSint64(const SourceInfo &);
26487
bool emitStorePopUint64(const SourceInfo &);
26488
bool emitStorePopIntAP(const SourceInfo &);
26489
bool emitStorePopIntAPS(const SourceInfo &);
26490
bool emitStorePopBool(const SourceInfo &);
26491
bool emitStorePopPtr(const SourceInfo &);
26492
bool emitStorePopFnPtr(const SourceInfo &);
26493
bool emitStorePopFloat(const SourceInfo &);
26494
#endif
26495
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26496
bool emitStorePop(PrimType, const SourceInfo &I);
26497
#endif
26498
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
26499
bool
26500
#if defined(GET_EVAL_IMPL)
26501
EvalEmitter
26502
#else
26503
ByteCodeEmitter
26504
#endif
26505
0
::emitStorePop(PrimType T0, const SourceInfo &I) {
26506
0
  switch (T0) {
26507
0
  case PT_Sint8:
26508
0
    return emitStorePopSint8(I);
26509
0
  case PT_Uint8:
26510
0
    return emitStorePopUint8(I);
26511
0
  case PT_Sint16:
26512
0
    return emitStorePopSint16(I);
26513
0
  case PT_Uint16:
26514
0
    return emitStorePopUint16(I);
26515
0
  case PT_Sint32:
26516
0
    return emitStorePopSint32(I);
26517
0
  case PT_Uint32:
26518
0
    return emitStorePopUint32(I);
26519
0
  case PT_Sint64:
26520
0
    return emitStorePopSint64(I);
26521
0
  case PT_Uint64:
26522
0
    return emitStorePopUint64(I);
26523
0
  case PT_IntAP:
26524
0
    return emitStorePopIntAP(I);
26525
0
  case PT_IntAPS:
26526
0
    return emitStorePopIntAPS(I);
26527
0
  case PT_Bool:
26528
0
    return emitStorePopBool(I);
26529
0
  case PT_Ptr:
26530
0
    return emitStorePopPtr(I);
26531
0
  case PT_FnPtr:
26532
0
    return emitStorePopFnPtr(I);
26533
0
  case PT_Float:
26534
0
    return emitStorePopFloat(I);
26535
0
  }
26536
0
  llvm_unreachable("invalid enum value");
26537
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitStorePop(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitStorePop(clang::interp::PrimType, clang::interp::SourceInfo const&)
26538
#endif
26539
#ifdef GET_LINK_IMPL
26540
0
bool ByteCodeEmitter::emitStorePopSint8(const SourceInfo &L) {
26541
0
  return emitOp<>(OP_StorePopSint8, L);
26542
0
}
26543
0
bool ByteCodeEmitter::emitStorePopUint8(const SourceInfo &L) {
26544
0
  return emitOp<>(OP_StorePopUint8, L);
26545
0
}
26546
0
bool ByteCodeEmitter::emitStorePopSint16(const SourceInfo &L) {
26547
0
  return emitOp<>(OP_StorePopSint16, L);
26548
0
}
26549
0
bool ByteCodeEmitter::emitStorePopUint16(const SourceInfo &L) {
26550
0
  return emitOp<>(OP_StorePopUint16, L);
26551
0
}
26552
0
bool ByteCodeEmitter::emitStorePopSint32(const SourceInfo &L) {
26553
0
  return emitOp<>(OP_StorePopSint32, L);
26554
0
}
26555
0
bool ByteCodeEmitter::emitStorePopUint32(const SourceInfo &L) {
26556
0
  return emitOp<>(OP_StorePopUint32, L);
26557
0
}
26558
0
bool ByteCodeEmitter::emitStorePopSint64(const SourceInfo &L) {
26559
0
  return emitOp<>(OP_StorePopSint64, L);
26560
0
}
26561
0
bool ByteCodeEmitter::emitStorePopUint64(const SourceInfo &L) {
26562
0
  return emitOp<>(OP_StorePopUint64, L);
26563
0
}
26564
0
bool ByteCodeEmitter::emitStorePopIntAP(const SourceInfo &L) {
26565
0
  return emitOp<>(OP_StorePopIntAP, L);
26566
0
}
26567
0
bool ByteCodeEmitter::emitStorePopIntAPS(const SourceInfo &L) {
26568
0
  return emitOp<>(OP_StorePopIntAPS, L);
26569
0
}
26570
0
bool ByteCodeEmitter::emitStorePopBool(const SourceInfo &L) {
26571
0
  return emitOp<>(OP_StorePopBool, L);
26572
0
}
26573
0
bool ByteCodeEmitter::emitStorePopPtr(const SourceInfo &L) {
26574
0
  return emitOp<>(OP_StorePopPtr, L);
26575
0
}
26576
0
bool ByteCodeEmitter::emitStorePopFnPtr(const SourceInfo &L) {
26577
0
  return emitOp<>(OP_StorePopFnPtr, L);
26578
0
}
26579
0
bool ByteCodeEmitter::emitStorePopFloat(const SourceInfo &L) {
26580
0
  return emitOp<>(OP_StorePopFloat, L);
26581
0
}
26582
#endif
26583
#ifdef GET_EVAL_IMPL
26584
0
bool EvalEmitter::emitStorePopSint8(const SourceInfo &L) {
26585
0
  if (!isActive()) return true;
26586
0
  CurrentSource = L;
26587
0
  return StorePop<PT_Sint8>(S, OpPC);
26588
0
}
26589
0
bool EvalEmitter::emitStorePopUint8(const SourceInfo &L) {
26590
0
  if (!isActive()) return true;
26591
0
  CurrentSource = L;
26592
0
  return StorePop<PT_Uint8>(S, OpPC);
26593
0
}
26594
0
bool EvalEmitter::emitStorePopSint16(const SourceInfo &L) {
26595
0
  if (!isActive()) return true;
26596
0
  CurrentSource = L;
26597
0
  return StorePop<PT_Sint16>(S, OpPC);
26598
0
}
26599
0
bool EvalEmitter::emitStorePopUint16(const SourceInfo &L) {
26600
0
  if (!isActive()) return true;
26601
0
  CurrentSource = L;
26602
0
  return StorePop<PT_Uint16>(S, OpPC);
26603
0
}
26604
0
bool EvalEmitter::emitStorePopSint32(const SourceInfo &L) {
26605
0
  if (!isActive()) return true;
26606
0
  CurrentSource = L;
26607
0
  return StorePop<PT_Sint32>(S, OpPC);
26608
0
}
26609
0
bool EvalEmitter::emitStorePopUint32(const SourceInfo &L) {
26610
0
  if (!isActive()) return true;
26611
0
  CurrentSource = L;
26612
0
  return StorePop<PT_Uint32>(S, OpPC);
26613
0
}
26614
0
bool EvalEmitter::emitStorePopSint64(const SourceInfo &L) {
26615
0
  if (!isActive()) return true;
26616
0
  CurrentSource = L;
26617
0
  return StorePop<PT_Sint64>(S, OpPC);
26618
0
}
26619
0
bool EvalEmitter::emitStorePopUint64(const SourceInfo &L) {
26620
0
  if (!isActive()) return true;
26621
0
  CurrentSource = L;
26622
0
  return StorePop<PT_Uint64>(S, OpPC);
26623
0
}
26624
0
bool EvalEmitter::emitStorePopIntAP(const SourceInfo &L) {
26625
0
  if (!isActive()) return true;
26626
0
  CurrentSource = L;
26627
0
  return StorePop<PT_IntAP>(S, OpPC);
26628
0
}
26629
0
bool EvalEmitter::emitStorePopIntAPS(const SourceInfo &L) {
26630
0
  if (!isActive()) return true;
26631
0
  CurrentSource = L;
26632
0
  return StorePop<PT_IntAPS>(S, OpPC);
26633
0
}
26634
0
bool EvalEmitter::emitStorePopBool(const SourceInfo &L) {
26635
0
  if (!isActive()) return true;
26636
0
  CurrentSource = L;
26637
0
  return StorePop<PT_Bool>(S, OpPC);
26638
0
}
26639
0
bool EvalEmitter::emitStorePopPtr(const SourceInfo &L) {
26640
0
  if (!isActive()) return true;
26641
0
  CurrentSource = L;
26642
0
  return StorePop<PT_Ptr>(S, OpPC);
26643
0
}
26644
0
bool EvalEmitter::emitStorePopFnPtr(const SourceInfo &L) {
26645
0
  if (!isActive()) return true;
26646
0
  CurrentSource = L;
26647
0
  return StorePop<PT_FnPtr>(S, OpPC);
26648
0
}
26649
0
bool EvalEmitter::emitStorePopFloat(const SourceInfo &L) {
26650
0
  if (!isActive()) return true;
26651
0
  CurrentSource = L;
26652
0
  return StorePop<PT_Float>(S, OpPC);
26653
0
}
26654
#endif
26655
#ifdef GET_OPCODE_NAMES
26656
OP_SubSint8,
26657
OP_SubUint8,
26658
OP_SubSint16,
26659
OP_SubUint16,
26660
OP_SubSint32,
26661
OP_SubUint32,
26662
OP_SubSint64,
26663
OP_SubUint64,
26664
OP_SubIntAP,
26665
OP_SubIntAPS,
26666
OP_SubBool,
26667
#endif
26668
0
#ifdef GET_INTERP
26669
0
case OP_SubSint8: {
26670
0
  if (!Sub<PT_Sint8>(S, OpPC))
26671
0
    return false;
26672
0
  continue;
26673
0
}
26674
0
case OP_SubUint8: {
26675
0
  if (!Sub<PT_Uint8>(S, OpPC))
26676
0
    return false;
26677
0
  continue;
26678
0
}
26679
0
case OP_SubSint16: {
26680
0
  if (!Sub<PT_Sint16>(S, OpPC))
26681
0
    return false;
26682
0
  continue;
26683
0
}
26684
0
case OP_SubUint16: {
26685
0
  if (!Sub<PT_Uint16>(S, OpPC))
26686
0
    return false;
26687
0
  continue;
26688
0
}
26689
0
case OP_SubSint32: {
26690
0
  if (!Sub<PT_Sint32>(S, OpPC))
26691
0
    return false;
26692
0
  continue;
26693
0
}
26694
0
case OP_SubUint32: {
26695
0
  if (!Sub<PT_Uint32>(S, OpPC))
26696
0
    return false;
26697
0
  continue;
26698
0
}
26699
0
case OP_SubSint64: {
26700
0
  if (!Sub<PT_Sint64>(S, OpPC))
26701
0
    return false;
26702
0
  continue;
26703
0
}
26704
0
case OP_SubUint64: {
26705
0
  if (!Sub<PT_Uint64>(S, OpPC))
26706
0
    return false;
26707
0
  continue;
26708
0
}
26709
0
case OP_SubIntAP: {
26710
0
  if (!Sub<PT_IntAP>(S, OpPC))
26711
0
    return false;
26712
0
  continue;
26713
0
}
26714
0
case OP_SubIntAPS: {
26715
0
  if (!Sub<PT_IntAPS>(S, OpPC))
26716
0
    return false;
26717
0
  continue;
26718
0
}
26719
0
case OP_SubBool: {
26720
0
  if (!Sub<PT_Bool>(S, OpPC))
26721
0
    return false;
26722
0
  continue;
26723
0
}
26724
0
#endif
26725
#ifdef GET_DISASM
26726
case OP_SubSint8:
26727
  PrintName("SubSint8");
26728
  OS << "\t" << "\n";
26729
  continue;
26730
case OP_SubUint8:
26731
  PrintName("SubUint8");
26732
  OS << "\t" << "\n";
26733
  continue;
26734
case OP_SubSint16:
26735
  PrintName("SubSint16");
26736
  OS << "\t" << "\n";
26737
  continue;
26738
case OP_SubUint16:
26739
  PrintName("SubUint16");
26740
  OS << "\t" << "\n";
26741
  continue;
26742
case OP_SubSint32:
26743
  PrintName("SubSint32");
26744
  OS << "\t" << "\n";
26745
  continue;
26746
case OP_SubUint32:
26747
  PrintName("SubUint32");
26748
  OS << "\t" << "\n";
26749
  continue;
26750
case OP_SubSint64:
26751
  PrintName("SubSint64");
26752
  OS << "\t" << "\n";
26753
  continue;
26754
case OP_SubUint64:
26755
  PrintName("SubUint64");
26756
  OS << "\t" << "\n";
26757
  continue;
26758
case OP_SubIntAP:
26759
  PrintName("SubIntAP");
26760
  OS << "\t" << "\n";
26761
  continue;
26762
case OP_SubIntAPS:
26763
  PrintName("SubIntAPS");
26764
  OS << "\t" << "\n";
26765
  continue;
26766
case OP_SubBool:
26767
  PrintName("SubBool");
26768
  OS << "\t" << "\n";
26769
  continue;
26770
#endif
26771
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26772
bool emitSubSint8(const SourceInfo &);
26773
bool emitSubUint8(const SourceInfo &);
26774
bool emitSubSint16(const SourceInfo &);
26775
bool emitSubUint16(const SourceInfo &);
26776
bool emitSubSint32(const SourceInfo &);
26777
bool emitSubUint32(const SourceInfo &);
26778
bool emitSubSint64(const SourceInfo &);
26779
bool emitSubUint64(const SourceInfo &);
26780
bool emitSubIntAP(const SourceInfo &);
26781
bool emitSubIntAPS(const SourceInfo &);
26782
bool emitSubBool(const SourceInfo &);
26783
#endif
26784
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26785
bool emitSub(PrimType, const SourceInfo &I);
26786
#endif
26787
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
26788
bool
26789
#if defined(GET_EVAL_IMPL)
26790
EvalEmitter
26791
#else
26792
ByteCodeEmitter
26793
#endif
26794
0
::emitSub(PrimType T0, const SourceInfo &I) {
26795
0
  switch (T0) {
26796
0
  case PT_Sint8:
26797
0
    return emitSubSint8(I);
26798
0
  case PT_Uint8:
26799
0
    return emitSubUint8(I);
26800
0
  case PT_Sint16:
26801
0
    return emitSubSint16(I);
26802
0
  case PT_Uint16:
26803
0
    return emitSubUint16(I);
26804
0
  case PT_Sint32:
26805
0
    return emitSubSint32(I);
26806
0
  case PT_Uint32:
26807
0
    return emitSubUint32(I);
26808
0
  case PT_Sint64:
26809
0
    return emitSubSint64(I);
26810
0
  case PT_Uint64:
26811
0
    return emitSubUint64(I);
26812
0
  case PT_IntAP:
26813
0
    return emitSubIntAP(I);
26814
0
  case PT_IntAPS:
26815
0
    return emitSubIntAPS(I);
26816
0
  case PT_Bool:
26817
0
    return emitSubBool(I);
26818
0
  default: llvm_unreachable("invalid type: emitSub");
26819
0
  }
26820
0
  llvm_unreachable("invalid enum value");
26821
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSub(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSub(clang::interp::PrimType, clang::interp::SourceInfo const&)
26822
#endif
26823
#ifdef GET_LINK_IMPL
26824
0
bool ByteCodeEmitter::emitSubSint8(const SourceInfo &L) {
26825
0
  return emitOp<>(OP_SubSint8, L);
26826
0
}
26827
0
bool ByteCodeEmitter::emitSubUint8(const SourceInfo &L) {
26828
0
  return emitOp<>(OP_SubUint8, L);
26829
0
}
26830
0
bool ByteCodeEmitter::emitSubSint16(const SourceInfo &L) {
26831
0
  return emitOp<>(OP_SubSint16, L);
26832
0
}
26833
0
bool ByteCodeEmitter::emitSubUint16(const SourceInfo &L) {
26834
0
  return emitOp<>(OP_SubUint16, L);
26835
0
}
26836
0
bool ByteCodeEmitter::emitSubSint32(const SourceInfo &L) {
26837
0
  return emitOp<>(OP_SubSint32, L);
26838
0
}
26839
0
bool ByteCodeEmitter::emitSubUint32(const SourceInfo &L) {
26840
0
  return emitOp<>(OP_SubUint32, L);
26841
0
}
26842
0
bool ByteCodeEmitter::emitSubSint64(const SourceInfo &L) {
26843
0
  return emitOp<>(OP_SubSint64, L);
26844
0
}
26845
0
bool ByteCodeEmitter::emitSubUint64(const SourceInfo &L) {
26846
0
  return emitOp<>(OP_SubUint64, L);
26847
0
}
26848
0
bool ByteCodeEmitter::emitSubIntAP(const SourceInfo &L) {
26849
0
  return emitOp<>(OP_SubIntAP, L);
26850
0
}
26851
0
bool ByteCodeEmitter::emitSubIntAPS(const SourceInfo &L) {
26852
0
  return emitOp<>(OP_SubIntAPS, L);
26853
0
}
26854
0
bool ByteCodeEmitter::emitSubBool(const SourceInfo &L) {
26855
0
  return emitOp<>(OP_SubBool, L);
26856
0
}
26857
#endif
26858
#ifdef GET_EVAL_IMPL
26859
0
bool EvalEmitter::emitSubSint8(const SourceInfo &L) {
26860
0
  if (!isActive()) return true;
26861
0
  CurrentSource = L;
26862
0
  return Sub<PT_Sint8>(S, OpPC);
26863
0
}
26864
0
bool EvalEmitter::emitSubUint8(const SourceInfo &L) {
26865
0
  if (!isActive()) return true;
26866
0
  CurrentSource = L;
26867
0
  return Sub<PT_Uint8>(S, OpPC);
26868
0
}
26869
0
bool EvalEmitter::emitSubSint16(const SourceInfo &L) {
26870
0
  if (!isActive()) return true;
26871
0
  CurrentSource = L;
26872
0
  return Sub<PT_Sint16>(S, OpPC);
26873
0
}
26874
0
bool EvalEmitter::emitSubUint16(const SourceInfo &L) {
26875
0
  if (!isActive()) return true;
26876
0
  CurrentSource = L;
26877
0
  return Sub<PT_Uint16>(S, OpPC);
26878
0
}
26879
0
bool EvalEmitter::emitSubSint32(const SourceInfo &L) {
26880
0
  if (!isActive()) return true;
26881
0
  CurrentSource = L;
26882
0
  return Sub<PT_Sint32>(S, OpPC);
26883
0
}
26884
0
bool EvalEmitter::emitSubUint32(const SourceInfo &L) {
26885
0
  if (!isActive()) return true;
26886
0
  CurrentSource = L;
26887
0
  return Sub<PT_Uint32>(S, OpPC);
26888
0
}
26889
0
bool EvalEmitter::emitSubSint64(const SourceInfo &L) {
26890
0
  if (!isActive()) return true;
26891
0
  CurrentSource = L;
26892
0
  return Sub<PT_Sint64>(S, OpPC);
26893
0
}
26894
0
bool EvalEmitter::emitSubUint64(const SourceInfo &L) {
26895
0
  if (!isActive()) return true;
26896
0
  CurrentSource = L;
26897
0
  return Sub<PT_Uint64>(S, OpPC);
26898
0
}
26899
0
bool EvalEmitter::emitSubIntAP(const SourceInfo &L) {
26900
0
  if (!isActive()) return true;
26901
0
  CurrentSource = L;
26902
0
  return Sub<PT_IntAP>(S, OpPC);
26903
0
}
26904
0
bool EvalEmitter::emitSubIntAPS(const SourceInfo &L) {
26905
0
  if (!isActive()) return true;
26906
0
  CurrentSource = L;
26907
0
  return Sub<PT_IntAPS>(S, OpPC);
26908
0
}
26909
0
bool EvalEmitter::emitSubBool(const SourceInfo &L) {
26910
0
  if (!isActive()) return true;
26911
0
  CurrentSource = L;
26912
0
  return Sub<PT_Bool>(S, OpPC);
26913
0
}
26914
#endif
26915
#ifdef GET_OPCODE_NAMES
26916
OP_SubOffsetSint8,
26917
OP_SubOffsetUint8,
26918
OP_SubOffsetSint16,
26919
OP_SubOffsetUint16,
26920
OP_SubOffsetSint32,
26921
OP_SubOffsetUint32,
26922
OP_SubOffsetSint64,
26923
OP_SubOffsetUint64,
26924
OP_SubOffsetIntAP,
26925
OP_SubOffsetIntAPS,
26926
OP_SubOffsetBool,
26927
#endif
26928
0
#ifdef GET_INTERP
26929
0
case OP_SubOffsetSint8: {
26930
0
  if (!SubOffset<PT_Sint8>(S, OpPC))
26931
0
    return false;
26932
0
  continue;
26933
0
}
26934
0
case OP_SubOffsetUint8: {
26935
0
  if (!SubOffset<PT_Uint8>(S, OpPC))
26936
0
    return false;
26937
0
  continue;
26938
0
}
26939
0
case OP_SubOffsetSint16: {
26940
0
  if (!SubOffset<PT_Sint16>(S, OpPC))
26941
0
    return false;
26942
0
  continue;
26943
0
}
26944
0
case OP_SubOffsetUint16: {
26945
0
  if (!SubOffset<PT_Uint16>(S, OpPC))
26946
0
    return false;
26947
0
  continue;
26948
0
}
26949
0
case OP_SubOffsetSint32: {
26950
0
  if (!SubOffset<PT_Sint32>(S, OpPC))
26951
0
    return false;
26952
0
  continue;
26953
0
}
26954
0
case OP_SubOffsetUint32: {
26955
0
  if (!SubOffset<PT_Uint32>(S, OpPC))
26956
0
    return false;
26957
0
  continue;
26958
0
}
26959
0
case OP_SubOffsetSint64: {
26960
0
  if (!SubOffset<PT_Sint64>(S, OpPC))
26961
0
    return false;
26962
0
  continue;
26963
0
}
26964
0
case OP_SubOffsetUint64: {
26965
0
  if (!SubOffset<PT_Uint64>(S, OpPC))
26966
0
    return false;
26967
0
  continue;
26968
0
}
26969
0
case OP_SubOffsetIntAP: {
26970
0
  if (!SubOffset<PT_IntAP>(S, OpPC))
26971
0
    return false;
26972
0
  continue;
26973
0
}
26974
0
case OP_SubOffsetIntAPS: {
26975
0
  if (!SubOffset<PT_IntAPS>(S, OpPC))
26976
0
    return false;
26977
0
  continue;
26978
0
}
26979
0
case OP_SubOffsetBool: {
26980
0
  if (!SubOffset<PT_Bool>(S, OpPC))
26981
0
    return false;
26982
0
  continue;
26983
0
}
26984
0
#endif
26985
#ifdef GET_DISASM
26986
case OP_SubOffsetSint8:
26987
  PrintName("SubOffsetSint8");
26988
  OS << "\t" << "\n";
26989
  continue;
26990
case OP_SubOffsetUint8:
26991
  PrintName("SubOffsetUint8");
26992
  OS << "\t" << "\n";
26993
  continue;
26994
case OP_SubOffsetSint16:
26995
  PrintName("SubOffsetSint16");
26996
  OS << "\t" << "\n";
26997
  continue;
26998
case OP_SubOffsetUint16:
26999
  PrintName("SubOffsetUint16");
27000
  OS << "\t" << "\n";
27001
  continue;
27002
case OP_SubOffsetSint32:
27003
  PrintName("SubOffsetSint32");
27004
  OS << "\t" << "\n";
27005
  continue;
27006
case OP_SubOffsetUint32:
27007
  PrintName("SubOffsetUint32");
27008
  OS << "\t" << "\n";
27009
  continue;
27010
case OP_SubOffsetSint64:
27011
  PrintName("SubOffsetSint64");
27012
  OS << "\t" << "\n";
27013
  continue;
27014
case OP_SubOffsetUint64:
27015
  PrintName("SubOffsetUint64");
27016
  OS << "\t" << "\n";
27017
  continue;
27018
case OP_SubOffsetIntAP:
27019
  PrintName("SubOffsetIntAP");
27020
  OS << "\t" << "\n";
27021
  continue;
27022
case OP_SubOffsetIntAPS:
27023
  PrintName("SubOffsetIntAPS");
27024
  OS << "\t" << "\n";
27025
  continue;
27026
case OP_SubOffsetBool:
27027
  PrintName("SubOffsetBool");
27028
  OS << "\t" << "\n";
27029
  continue;
27030
#endif
27031
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27032
bool emitSubOffsetSint8(const SourceInfo &);
27033
bool emitSubOffsetUint8(const SourceInfo &);
27034
bool emitSubOffsetSint16(const SourceInfo &);
27035
bool emitSubOffsetUint16(const SourceInfo &);
27036
bool emitSubOffsetSint32(const SourceInfo &);
27037
bool emitSubOffsetUint32(const SourceInfo &);
27038
bool emitSubOffsetSint64(const SourceInfo &);
27039
bool emitSubOffsetUint64(const SourceInfo &);
27040
bool emitSubOffsetIntAP(const SourceInfo &);
27041
bool emitSubOffsetIntAPS(const SourceInfo &);
27042
bool emitSubOffsetBool(const SourceInfo &);
27043
#endif
27044
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27045
bool emitSubOffset(PrimType, const SourceInfo &I);
27046
#endif
27047
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
27048
bool
27049
#if defined(GET_EVAL_IMPL)
27050
EvalEmitter
27051
#else
27052
ByteCodeEmitter
27053
#endif
27054
0
::emitSubOffset(PrimType T0, const SourceInfo &I) {
27055
0
  switch (T0) {
27056
0
  case PT_Sint8:
27057
0
    return emitSubOffsetSint8(I);
27058
0
  case PT_Uint8:
27059
0
    return emitSubOffsetUint8(I);
27060
0
  case PT_Sint16:
27061
0
    return emitSubOffsetSint16(I);
27062
0
  case PT_Uint16:
27063
0
    return emitSubOffsetUint16(I);
27064
0
  case PT_Sint32:
27065
0
    return emitSubOffsetSint32(I);
27066
0
  case PT_Uint32:
27067
0
    return emitSubOffsetUint32(I);
27068
0
  case PT_Sint64:
27069
0
    return emitSubOffsetSint64(I);
27070
0
  case PT_Uint64:
27071
0
    return emitSubOffsetUint64(I);
27072
0
  case PT_IntAP:
27073
0
    return emitSubOffsetIntAP(I);
27074
0
  case PT_IntAPS:
27075
0
    return emitSubOffsetIntAPS(I);
27076
0
  case PT_Bool:
27077
0
    return emitSubOffsetBool(I);
27078
0
  default: llvm_unreachable("invalid type: emitSubOffset");
27079
0
  }
27080
0
  llvm_unreachable("invalid enum value");
27081
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSubOffset(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSubOffset(clang::interp::PrimType, clang::interp::SourceInfo const&)
27082
#endif
27083
#ifdef GET_LINK_IMPL
27084
0
bool ByteCodeEmitter::emitSubOffsetSint8(const SourceInfo &L) {
27085
0
  return emitOp<>(OP_SubOffsetSint8, L);
27086
0
}
27087
0
bool ByteCodeEmitter::emitSubOffsetUint8(const SourceInfo &L) {
27088
0
  return emitOp<>(OP_SubOffsetUint8, L);
27089
0
}
27090
0
bool ByteCodeEmitter::emitSubOffsetSint16(const SourceInfo &L) {
27091
0
  return emitOp<>(OP_SubOffsetSint16, L);
27092
0
}
27093
0
bool ByteCodeEmitter::emitSubOffsetUint16(const SourceInfo &L) {
27094
0
  return emitOp<>(OP_SubOffsetUint16, L);
27095
0
}
27096
0
bool ByteCodeEmitter::emitSubOffsetSint32(const SourceInfo &L) {
27097
0
  return emitOp<>(OP_SubOffsetSint32, L);
27098
0
}
27099
0
bool ByteCodeEmitter::emitSubOffsetUint32(const SourceInfo &L) {
27100
0
  return emitOp<>(OP_SubOffsetUint32, L);
27101
0
}
27102
0
bool ByteCodeEmitter::emitSubOffsetSint64(const SourceInfo &L) {
27103
0
  return emitOp<>(OP_SubOffsetSint64, L);
27104
0
}
27105
0
bool ByteCodeEmitter::emitSubOffsetUint64(const SourceInfo &L) {
27106
0
  return emitOp<>(OP_SubOffsetUint64, L);
27107
0
}
27108
0
bool ByteCodeEmitter::emitSubOffsetIntAP(const SourceInfo &L) {
27109
0
  return emitOp<>(OP_SubOffsetIntAP, L);
27110
0
}
27111
0
bool ByteCodeEmitter::emitSubOffsetIntAPS(const SourceInfo &L) {
27112
0
  return emitOp<>(OP_SubOffsetIntAPS, L);
27113
0
}
27114
0
bool ByteCodeEmitter::emitSubOffsetBool(const SourceInfo &L) {
27115
0
  return emitOp<>(OP_SubOffsetBool, L);
27116
0
}
27117
#endif
27118
#ifdef GET_EVAL_IMPL
27119
0
bool EvalEmitter::emitSubOffsetSint8(const SourceInfo &L) {
27120
0
  if (!isActive()) return true;
27121
0
  CurrentSource = L;
27122
0
  return SubOffset<PT_Sint8>(S, OpPC);
27123
0
}
27124
0
bool EvalEmitter::emitSubOffsetUint8(const SourceInfo &L) {
27125
0
  if (!isActive()) return true;
27126
0
  CurrentSource = L;
27127
0
  return SubOffset<PT_Uint8>(S, OpPC);
27128
0
}
27129
0
bool EvalEmitter::emitSubOffsetSint16(const SourceInfo &L) {
27130
0
  if (!isActive()) return true;
27131
0
  CurrentSource = L;
27132
0
  return SubOffset<PT_Sint16>(S, OpPC);
27133
0
}
27134
0
bool EvalEmitter::emitSubOffsetUint16(const SourceInfo &L) {
27135
0
  if (!isActive()) return true;
27136
0
  CurrentSource = L;
27137
0
  return SubOffset<PT_Uint16>(S, OpPC);
27138
0
}
27139
0
bool EvalEmitter::emitSubOffsetSint32(const SourceInfo &L) {
27140
0
  if (!isActive()) return true;
27141
0
  CurrentSource = L;
27142
0
  return SubOffset<PT_Sint32>(S, OpPC);
27143
0
}
27144
0
bool EvalEmitter::emitSubOffsetUint32(const SourceInfo &L) {
27145
0
  if (!isActive()) return true;
27146
0
  CurrentSource = L;
27147
0
  return SubOffset<PT_Uint32>(S, OpPC);
27148
0
}
27149
0
bool EvalEmitter::emitSubOffsetSint64(const SourceInfo &L) {
27150
0
  if (!isActive()) return true;
27151
0
  CurrentSource = L;
27152
0
  return SubOffset<PT_Sint64>(S, OpPC);
27153
0
}
27154
0
bool EvalEmitter::emitSubOffsetUint64(const SourceInfo &L) {
27155
0
  if (!isActive()) return true;
27156
0
  CurrentSource = L;
27157
0
  return SubOffset<PT_Uint64>(S, OpPC);
27158
0
}
27159
0
bool EvalEmitter::emitSubOffsetIntAP(const SourceInfo &L) {
27160
0
  if (!isActive()) return true;
27161
0
  CurrentSource = L;
27162
0
  return SubOffset<PT_IntAP>(S, OpPC);
27163
0
}
27164
0
bool EvalEmitter::emitSubOffsetIntAPS(const SourceInfo &L) {
27165
0
  if (!isActive()) return true;
27166
0
  CurrentSource = L;
27167
0
  return SubOffset<PT_IntAPS>(S, OpPC);
27168
0
}
27169
0
bool EvalEmitter::emitSubOffsetBool(const SourceInfo &L) {
27170
0
  if (!isActive()) return true;
27171
0
  CurrentSource = L;
27172
0
  return SubOffset<PT_Bool>(S, OpPC);
27173
0
}
27174
#endif
27175
#ifdef GET_OPCODE_NAMES
27176
OP_SubPtrSint8,
27177
OP_SubPtrUint8,
27178
OP_SubPtrSint16,
27179
OP_SubPtrUint16,
27180
OP_SubPtrSint32,
27181
OP_SubPtrUint32,
27182
OP_SubPtrSint64,
27183
OP_SubPtrUint64,
27184
OP_SubPtrIntAP,
27185
OP_SubPtrIntAPS,
27186
#endif
27187
0
#ifdef GET_INTERP
27188
0
case OP_SubPtrSint8: {
27189
0
  if (!SubPtr<PT_Sint8>(S, OpPC))
27190
0
    return false;
27191
0
  continue;
27192
0
}
27193
0
case OP_SubPtrUint8: {
27194
0
  if (!SubPtr<PT_Uint8>(S, OpPC))
27195
0
    return false;
27196
0
  continue;
27197
0
}
27198
0
case OP_SubPtrSint16: {
27199
0
  if (!SubPtr<PT_Sint16>(S, OpPC))
27200
0
    return false;
27201
0
  continue;
27202
0
}
27203
0
case OP_SubPtrUint16: {
27204
0
  if (!SubPtr<PT_Uint16>(S, OpPC))
27205
0
    return false;
27206
0
  continue;
27207
0
}
27208
0
case OP_SubPtrSint32: {
27209
0
  if (!SubPtr<PT_Sint32>(S, OpPC))
27210
0
    return false;
27211
0
  continue;
27212
0
}
27213
0
case OP_SubPtrUint32: {
27214
0
  if (!SubPtr<PT_Uint32>(S, OpPC))
27215
0
    return false;
27216
0
  continue;
27217
0
}
27218
0
case OP_SubPtrSint64: {
27219
0
  if (!SubPtr<PT_Sint64>(S, OpPC))
27220
0
    return false;
27221
0
  continue;
27222
0
}
27223
0
case OP_SubPtrUint64: {
27224
0
  if (!SubPtr<PT_Uint64>(S, OpPC))
27225
0
    return false;
27226
0
  continue;
27227
0
}
27228
0
case OP_SubPtrIntAP: {
27229
0
  if (!SubPtr<PT_IntAP>(S, OpPC))
27230
0
    return false;
27231
0
  continue;
27232
0
}
27233
0
case OP_SubPtrIntAPS: {
27234
0
  if (!SubPtr<PT_IntAPS>(S, OpPC))
27235
0
    return false;
27236
0
  continue;
27237
0
}
27238
0
#endif
27239
#ifdef GET_DISASM
27240
case OP_SubPtrSint8:
27241
  PrintName("SubPtrSint8");
27242
  OS << "\t" << "\n";
27243
  continue;
27244
case OP_SubPtrUint8:
27245
  PrintName("SubPtrUint8");
27246
  OS << "\t" << "\n";
27247
  continue;
27248
case OP_SubPtrSint16:
27249
  PrintName("SubPtrSint16");
27250
  OS << "\t" << "\n";
27251
  continue;
27252
case OP_SubPtrUint16:
27253
  PrintName("SubPtrUint16");
27254
  OS << "\t" << "\n";
27255
  continue;
27256
case OP_SubPtrSint32:
27257
  PrintName("SubPtrSint32");
27258
  OS << "\t" << "\n";
27259
  continue;
27260
case OP_SubPtrUint32:
27261
  PrintName("SubPtrUint32");
27262
  OS << "\t" << "\n";
27263
  continue;
27264
case OP_SubPtrSint64:
27265
  PrintName("SubPtrSint64");
27266
  OS << "\t" << "\n";
27267
  continue;
27268
case OP_SubPtrUint64:
27269
  PrintName("SubPtrUint64");
27270
  OS << "\t" << "\n";
27271
  continue;
27272
case OP_SubPtrIntAP:
27273
  PrintName("SubPtrIntAP");
27274
  OS << "\t" << "\n";
27275
  continue;
27276
case OP_SubPtrIntAPS:
27277
  PrintName("SubPtrIntAPS");
27278
  OS << "\t" << "\n";
27279
  continue;
27280
#endif
27281
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27282
bool emitSubPtrSint8(const SourceInfo &);
27283
bool emitSubPtrUint8(const SourceInfo &);
27284
bool emitSubPtrSint16(const SourceInfo &);
27285
bool emitSubPtrUint16(const SourceInfo &);
27286
bool emitSubPtrSint32(const SourceInfo &);
27287
bool emitSubPtrUint32(const SourceInfo &);
27288
bool emitSubPtrSint64(const SourceInfo &);
27289
bool emitSubPtrUint64(const SourceInfo &);
27290
bool emitSubPtrIntAP(const SourceInfo &);
27291
bool emitSubPtrIntAPS(const SourceInfo &);
27292
#endif
27293
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27294
bool emitSubPtr(PrimType, const SourceInfo &I);
27295
#endif
27296
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
27297
bool
27298
#if defined(GET_EVAL_IMPL)
27299
EvalEmitter
27300
#else
27301
ByteCodeEmitter
27302
#endif
27303
0
::emitSubPtr(PrimType T0, const SourceInfo &I) {
27304
0
  switch (T0) {
27305
0
  case PT_Sint8:
27306
0
    return emitSubPtrSint8(I);
27307
0
  case PT_Uint8:
27308
0
    return emitSubPtrUint8(I);
27309
0
  case PT_Sint16:
27310
0
    return emitSubPtrSint16(I);
27311
0
  case PT_Uint16:
27312
0
    return emitSubPtrUint16(I);
27313
0
  case PT_Sint32:
27314
0
    return emitSubPtrSint32(I);
27315
0
  case PT_Uint32:
27316
0
    return emitSubPtrUint32(I);
27317
0
  case PT_Sint64:
27318
0
    return emitSubPtrSint64(I);
27319
0
  case PT_Uint64:
27320
0
    return emitSubPtrUint64(I);
27321
0
  case PT_IntAP:
27322
0
    return emitSubPtrIntAP(I);
27323
0
  case PT_IntAPS:
27324
0
    return emitSubPtrIntAPS(I);
27325
0
  default: llvm_unreachable("invalid type: emitSubPtr");
27326
0
  }
27327
0
  llvm_unreachable("invalid enum value");
27328
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitSubPtr(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitSubPtr(clang::interp::PrimType, clang::interp::SourceInfo const&)
27329
#endif
27330
#ifdef GET_LINK_IMPL
27331
0
bool ByteCodeEmitter::emitSubPtrSint8(const SourceInfo &L) {
27332
0
  return emitOp<>(OP_SubPtrSint8, L);
27333
0
}
27334
0
bool ByteCodeEmitter::emitSubPtrUint8(const SourceInfo &L) {
27335
0
  return emitOp<>(OP_SubPtrUint8, L);
27336
0
}
27337
0
bool ByteCodeEmitter::emitSubPtrSint16(const SourceInfo &L) {
27338
0
  return emitOp<>(OP_SubPtrSint16, L);
27339
0
}
27340
0
bool ByteCodeEmitter::emitSubPtrUint16(const SourceInfo &L) {
27341
0
  return emitOp<>(OP_SubPtrUint16, L);
27342
0
}
27343
0
bool ByteCodeEmitter::emitSubPtrSint32(const SourceInfo &L) {
27344
0
  return emitOp<>(OP_SubPtrSint32, L);
27345
0
}
27346
0
bool ByteCodeEmitter::emitSubPtrUint32(const SourceInfo &L) {
27347
0
  return emitOp<>(OP_SubPtrUint32, L);
27348
0
}
27349
0
bool ByteCodeEmitter::emitSubPtrSint64(const SourceInfo &L) {
27350
0
  return emitOp<>(OP_SubPtrSint64, L);
27351
0
}
27352
0
bool ByteCodeEmitter::emitSubPtrUint64(const SourceInfo &L) {
27353
0
  return emitOp<>(OP_SubPtrUint64, L);
27354
0
}
27355
0
bool ByteCodeEmitter::emitSubPtrIntAP(const SourceInfo &L) {
27356
0
  return emitOp<>(OP_SubPtrIntAP, L);
27357
0
}
27358
0
bool ByteCodeEmitter::emitSubPtrIntAPS(const SourceInfo &L) {
27359
0
  return emitOp<>(OP_SubPtrIntAPS, L);
27360
0
}
27361
#endif
27362
#ifdef GET_EVAL_IMPL
27363
0
bool EvalEmitter::emitSubPtrSint8(const SourceInfo &L) {
27364
0
  if (!isActive()) return true;
27365
0
  CurrentSource = L;
27366
0
  return SubPtr<PT_Sint8>(S, OpPC);
27367
0
}
27368
0
bool EvalEmitter::emitSubPtrUint8(const SourceInfo &L) {
27369
0
  if (!isActive()) return true;
27370
0
  CurrentSource = L;
27371
0
  return SubPtr<PT_Uint8>(S, OpPC);
27372
0
}
27373
0
bool EvalEmitter::emitSubPtrSint16(const SourceInfo &L) {
27374
0
  if (!isActive()) return true;
27375
0
  CurrentSource = L;
27376
0
  return SubPtr<PT_Sint16>(S, OpPC);
27377
0
}
27378
0
bool EvalEmitter::emitSubPtrUint16(const SourceInfo &L) {
27379
0
  if (!isActive()) return true;
27380
0
  CurrentSource = L;
27381
0
  return SubPtr<PT_Uint16>(S, OpPC);
27382
0
}
27383
0
bool EvalEmitter::emitSubPtrSint32(const SourceInfo &L) {
27384
0
  if (!isActive()) return true;
27385
0
  CurrentSource = L;
27386
0
  return SubPtr<PT_Sint32>(S, OpPC);
27387
0
}
27388
0
bool EvalEmitter::emitSubPtrUint32(const SourceInfo &L) {
27389
0
  if (!isActive()) return true;
27390
0
  CurrentSource = L;
27391
0
  return SubPtr<PT_Uint32>(S, OpPC);
27392
0
}
27393
0
bool EvalEmitter::emitSubPtrSint64(const SourceInfo &L) {
27394
0
  if (!isActive()) return true;
27395
0
  CurrentSource = L;
27396
0
  return SubPtr<PT_Sint64>(S, OpPC);
27397
0
}
27398
0
bool EvalEmitter::emitSubPtrUint64(const SourceInfo &L) {
27399
0
  if (!isActive()) return true;
27400
0
  CurrentSource = L;
27401
0
  return SubPtr<PT_Uint64>(S, OpPC);
27402
0
}
27403
0
bool EvalEmitter::emitSubPtrIntAP(const SourceInfo &L) {
27404
0
  if (!isActive()) return true;
27405
0
  CurrentSource = L;
27406
0
  return SubPtr<PT_IntAP>(S, OpPC);
27407
0
}
27408
0
bool EvalEmitter::emitSubPtrIntAPS(const SourceInfo &L) {
27409
0
  if (!isActive()) return true;
27410
0
  CurrentSource = L;
27411
0
  return SubPtr<PT_IntAPS>(S, OpPC);
27412
0
}
27413
#endif
27414
#ifdef GET_OPCODE_NAMES
27415
OP_Subf,
27416
#endif
27417
0
#ifdef GET_INTERP
27418
0
case OP_Subf: {
27419
0
  auto V0 = ReadArg<llvm::RoundingMode>(S, PC);
27420
0
  if (!Subf(S, OpPC, V0))
27421
0
    return false;
27422
0
  continue;
27423
0
}
27424
0
#endif
27425
#ifdef GET_DISASM
27426
case OP_Subf:
27427
  PrintName("Subf");
27428
  OS << "\t" << ReadArg<llvm::RoundingMode>(P, PC) << " " << "\n";
27429
  continue;
27430
#endif
27431
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27432
bool emitSubf(llvm::RoundingMode, const SourceInfo &);
27433
#endif
27434
#ifdef GET_LINK_IMPL
27435
0
bool ByteCodeEmitter::emitSubf(llvm::RoundingMode A0, const SourceInfo &L) {
27436
0
  return emitOp<llvm::RoundingMode>(OP_Subf, A0, L);
27437
0
}
27438
#endif
27439
#ifdef GET_EVAL_IMPL
27440
0
bool EvalEmitter::emitSubf(llvm::RoundingMode A0, const SourceInfo &L) {
27441
0
  if (!isActive()) return true;
27442
0
  CurrentSource = L;
27443
0
  return Subf(S, OpPC, A0);
27444
0
}
27445
#endif
27446
#ifdef GET_OPCODE_NAMES
27447
OP_This,
27448
#endif
27449
0
#ifdef GET_INTERP
27450
0
case OP_This: {
27451
0
  if (!This(S, OpPC))
27452
0
    return false;
27453
0
  continue;
27454
0
}
27455
0
#endif
27456
#ifdef GET_DISASM
27457
case OP_This:
27458
  PrintName("This");
27459
  OS << "\t" << "\n";
27460
  continue;
27461
#endif
27462
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27463
bool emitThis(const SourceInfo &);
27464
#endif
27465
#ifdef GET_LINK_IMPL
27466
0
bool ByteCodeEmitter::emitThis(const SourceInfo &L) {
27467
0
  return emitOp<>(OP_This, L);
27468
0
}
27469
#endif
27470
#ifdef GET_EVAL_IMPL
27471
0
bool EvalEmitter::emitThis(const SourceInfo &L) {
27472
0
  if (!isActive()) return true;
27473
0
  CurrentSource = L;
27474
0
  return This(S, OpPC);
27475
0
}
27476
#endif
27477
#ifdef GET_OPCODE_NAMES
27478
OP_ZeroSint8,
27479
OP_ZeroUint8,
27480
OP_ZeroSint16,
27481
OP_ZeroUint16,
27482
OP_ZeroSint32,
27483
OP_ZeroUint32,
27484
OP_ZeroSint64,
27485
OP_ZeroUint64,
27486
OP_ZeroBool,
27487
#endif
27488
0
#ifdef GET_INTERP
27489
0
case OP_ZeroSint8: {
27490
0
  if (!Zero<PT_Sint8>(S, OpPC))
27491
0
    return false;
27492
0
  continue;
27493
0
}
27494
0
case OP_ZeroUint8: {
27495
0
  if (!Zero<PT_Uint8>(S, OpPC))
27496
0
    return false;
27497
0
  continue;
27498
0
}
27499
0
case OP_ZeroSint16: {
27500
0
  if (!Zero<PT_Sint16>(S, OpPC))
27501
0
    return false;
27502
0
  continue;
27503
0
}
27504
0
case OP_ZeroUint16: {
27505
0
  if (!Zero<PT_Uint16>(S, OpPC))
27506
0
    return false;
27507
0
  continue;
27508
0
}
27509
0
case OP_ZeroSint32: {
27510
0
  if (!Zero<PT_Sint32>(S, OpPC))
27511
0
    return false;
27512
0
  continue;
27513
0
}
27514
0
case OP_ZeroUint32: {
27515
0
  if (!Zero<PT_Uint32>(S, OpPC))
27516
0
    return false;
27517
0
  continue;
27518
0
}
27519
0
case OP_ZeroSint64: {
27520
0
  if (!Zero<PT_Sint64>(S, OpPC))
27521
0
    return false;
27522
0
  continue;
27523
0
}
27524
0
case OP_ZeroUint64: {
27525
0
  if (!Zero<PT_Uint64>(S, OpPC))
27526
0
    return false;
27527
0
  continue;
27528
0
}
27529
0
case OP_ZeroBool: {
27530
0
  if (!Zero<PT_Bool>(S, OpPC))
27531
0
    return false;
27532
0
  continue;
27533
0
}
27534
0
#endif
27535
#ifdef GET_DISASM
27536
case OP_ZeroSint8:
27537
  PrintName("ZeroSint8");
27538
  OS << "\t" << "\n";
27539
  continue;
27540
case OP_ZeroUint8:
27541
  PrintName("ZeroUint8");
27542
  OS << "\t" << "\n";
27543
  continue;
27544
case OP_ZeroSint16:
27545
  PrintName("ZeroSint16");
27546
  OS << "\t" << "\n";
27547
  continue;
27548
case OP_ZeroUint16:
27549
  PrintName("ZeroUint16");
27550
  OS << "\t" << "\n";
27551
  continue;
27552
case OP_ZeroSint32:
27553
  PrintName("ZeroSint32");
27554
  OS << "\t" << "\n";
27555
  continue;
27556
case OP_ZeroUint32:
27557
  PrintName("ZeroUint32");
27558
  OS << "\t" << "\n";
27559
  continue;
27560
case OP_ZeroSint64:
27561
  PrintName("ZeroSint64");
27562
  OS << "\t" << "\n";
27563
  continue;
27564
case OP_ZeroUint64:
27565
  PrintName("ZeroUint64");
27566
  OS << "\t" << "\n";
27567
  continue;
27568
case OP_ZeroBool:
27569
  PrintName("ZeroBool");
27570
  OS << "\t" << "\n";
27571
  continue;
27572
#endif
27573
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27574
bool emitZeroSint8(const SourceInfo &);
27575
bool emitZeroUint8(const SourceInfo &);
27576
bool emitZeroSint16(const SourceInfo &);
27577
bool emitZeroUint16(const SourceInfo &);
27578
bool emitZeroSint32(const SourceInfo &);
27579
bool emitZeroUint32(const SourceInfo &);
27580
bool emitZeroSint64(const SourceInfo &);
27581
bool emitZeroUint64(const SourceInfo &);
27582
bool emitZeroBool(const SourceInfo &);
27583
#endif
27584
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27585
bool emitZero(PrimType, const SourceInfo &I);
27586
#endif
27587
#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
27588
bool
27589
#if defined(GET_EVAL_IMPL)
27590
EvalEmitter
27591
#else
27592
ByteCodeEmitter
27593
#endif
27594
0
::emitZero(PrimType T0, const SourceInfo &I) {
27595
0
  switch (T0) {
27596
0
  case PT_Sint8:
27597
0
    return emitZeroSint8(I);
27598
0
  case PT_Uint8:
27599
0
    return emitZeroUint8(I);
27600
0
  case PT_Sint16:
27601
0
    return emitZeroSint16(I);
27602
0
  case PT_Uint16:
27603
0
    return emitZeroUint16(I);
27604
0
  case PT_Sint32:
27605
0
    return emitZeroSint32(I);
27606
0
  case PT_Uint32:
27607
0
    return emitZeroUint32(I);
27608
0
  case PT_Sint64:
27609
0
    return emitZeroSint64(I);
27610
0
  case PT_Uint64:
27611
0
    return emitZeroUint64(I);
27612
0
  case PT_Bool:
27613
0
    return emitZeroBool(I);
27614
0
  default: llvm_unreachable("invalid type: emitZero");
27615
0
  }
27616
0
  llvm_unreachable("invalid enum value");
27617
0
}
Unexecuted instantiation: clang::interp::EvalEmitter::emitZero(clang::interp::PrimType, clang::interp::SourceInfo const&)
Unexecuted instantiation: clang::interp::ByteCodeEmitter::emitZero(clang::interp::PrimType, clang::interp::SourceInfo const&)
27618
#endif
27619
#ifdef GET_LINK_IMPL
27620
0
bool ByteCodeEmitter::emitZeroSint8(const SourceInfo &L) {
27621
0
  return emitOp<>(OP_ZeroSint8, L);
27622
0
}
27623
0
bool ByteCodeEmitter::emitZeroUint8(const SourceInfo &L) {
27624
0
  return emitOp<>(OP_ZeroUint8, L);
27625
0
}
27626
0
bool ByteCodeEmitter::emitZeroSint16(const SourceInfo &L) {
27627
0
  return emitOp<>(OP_ZeroSint16, L);
27628
0
}
27629
0
bool ByteCodeEmitter::emitZeroUint16(const SourceInfo &L) {
27630
0
  return emitOp<>(OP_ZeroUint16, L);
27631
0
}
27632
0
bool ByteCodeEmitter::emitZeroSint32(const SourceInfo &L) {
27633
0
  return emitOp<>(OP_ZeroSint32, L);
27634
0
}
27635
0
bool ByteCodeEmitter::emitZeroUint32(const SourceInfo &L) {
27636
0
  return emitOp<>(OP_ZeroUint32, L);
27637
0
}
27638
0
bool ByteCodeEmitter::emitZeroSint64(const SourceInfo &L) {
27639
0
  return emitOp<>(OP_ZeroSint64, L);
27640
0
}
27641
0
bool ByteCodeEmitter::emitZeroUint64(const SourceInfo &L) {
27642
0
  return emitOp<>(OP_ZeroUint64, L);
27643
0
}
27644
0
bool ByteCodeEmitter::emitZeroBool(const SourceInfo &L) {
27645
0
  return emitOp<>(OP_ZeroBool, L);
27646
0
}
27647
#endif
27648
#ifdef GET_EVAL_IMPL
27649
0
bool EvalEmitter::emitZeroSint8(const SourceInfo &L) {
27650
0
  if (!isActive()) return true;
27651
0
  CurrentSource = L;
27652
0
  return Zero<PT_Sint8>(S, OpPC);
27653
0
}
27654
0
bool EvalEmitter::emitZeroUint8(const SourceInfo &L) {
27655
0
  if (!isActive()) return true;
27656
0
  CurrentSource = L;
27657
0
  return Zero<PT_Uint8>(S, OpPC);
27658
0
}
27659
0
bool EvalEmitter::emitZeroSint16(const SourceInfo &L) {
27660
0
  if (!isActive()) return true;
27661
0
  CurrentSource = L;
27662
0
  return Zero<PT_Sint16>(S, OpPC);
27663
0
}
27664
0
bool EvalEmitter::emitZeroUint16(const SourceInfo &L) {
27665
0
  if (!isActive()) return true;
27666
0
  CurrentSource = L;
27667
0
  return Zero<PT_Uint16>(S, OpPC);
27668
0
}
27669
0
bool EvalEmitter::emitZeroSint32(const SourceInfo &L) {
27670
0
  if (!isActive()) return true;
27671
0
  CurrentSource = L;
27672
0
  return Zero<PT_Sint32>(S, OpPC);
27673
0
}
27674
0
bool EvalEmitter::emitZeroUint32(const SourceInfo &L) {
27675
0
  if (!isActive()) return true;
27676
0
  CurrentSource = L;
27677
0
  return Zero<PT_Uint32>(S, OpPC);
27678
0
}
27679
0
bool EvalEmitter::emitZeroSint64(const SourceInfo &L) {
27680
0
  if (!isActive()) return true;
27681
0
  CurrentSource = L;
27682
0
  return Zero<PT_Sint64>(S, OpPC);
27683
0
}
27684
0
bool EvalEmitter::emitZeroUint64(const SourceInfo &L) {
27685
0
  if (!isActive()) return true;
27686
0
  CurrentSource = L;
27687
0
  return Zero<PT_Uint64>(S, OpPC);
27688
0
}
27689
0
bool EvalEmitter::emitZeroBool(const SourceInfo &L) {
27690
0
  if (!isActive()) return true;
27691
0
  CurrentSource = L;
27692
0
  return Zero<PT_Bool>(S, OpPC);
27693
0
}
27694
#endif
27695
#ifdef GET_OPCODE_NAMES
27696
OP_ZeroIntAP,
27697
#endif
27698
0
#ifdef GET_INTERP
27699
0
case OP_ZeroIntAP: {
27700
0
  auto V0 = ReadArg<uint32_t>(S, PC);
27701
0
  if (!ZeroIntAP(S, OpPC, V0))
27702
0
    return false;
27703
0
  continue;
27704
0
}
27705
0
#endif
27706
#ifdef GET_DISASM
27707
case OP_ZeroIntAP:
27708
  PrintName("ZeroIntAP");
27709
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
27710
  continue;
27711
#endif
27712
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27713
bool emitZeroIntAP(uint32_t, const SourceInfo &);
27714
#endif
27715
#ifdef GET_LINK_IMPL
27716
0
bool ByteCodeEmitter::emitZeroIntAP(uint32_t A0, const SourceInfo &L) {
27717
0
  return emitOp<uint32_t>(OP_ZeroIntAP, A0, L);
27718
0
}
27719
#endif
27720
#ifdef GET_EVAL_IMPL
27721
0
bool EvalEmitter::emitZeroIntAP(uint32_t A0, const SourceInfo &L) {
27722
0
  if (!isActive()) return true;
27723
0
  CurrentSource = L;
27724
0
  return ZeroIntAP(S, OpPC, A0);
27725
0
}
27726
#endif
27727
#ifdef GET_OPCODE_NAMES
27728
OP_ZeroIntAPS,
27729
#endif
27730
0
#ifdef GET_INTERP
27731
0
case OP_ZeroIntAPS: {
27732
0
  auto V0 = ReadArg<uint32_t>(S, PC);
27733
0
  if (!ZeroIntAPS(S, OpPC, V0))
27734
0
    return false;
27735
0
  continue;
27736
0
}
27737
0
#endif
27738
#ifdef GET_DISASM
27739
case OP_ZeroIntAPS:
27740
  PrintName("ZeroIntAPS");
27741
  OS << "\t" << ReadArg<uint32_t>(P, PC) << " " << "\n";
27742
  continue;
27743
#endif
27744
#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27745
bool emitZeroIntAPS(uint32_t, const SourceInfo &);
27746
#endif
27747
#ifdef GET_LINK_IMPL
27748
0
bool ByteCodeEmitter::emitZeroIntAPS(uint32_t A0, const SourceInfo &L) {
27749
0
  return emitOp<uint32_t>(OP_ZeroIntAPS, A0, L);
27750
0
}
27751
#endif
27752
#ifdef GET_EVAL_IMPL
27753
0
bool EvalEmitter::emitZeroIntAPS(uint32_t A0, const SourceInfo &L) {
27754
0
  if (!isActive()) return true;
27755
0
  CurrentSource = L;
27756
0
  return ZeroIntAPS(S, OpPC, A0);
27757
0
}
27758
#endif