1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "../../src/mock/abckit_mock.h"
17 #include "../../src/mock/mock_values.h"
18
19 #include <cstring>
20 #include <iostream>
21 #include <gtest/gtest.h>
22
23 namespace libabckit::mock::graph_api {
24
25 // NOLINTBEGIN(readability-identifier-naming)
26
GgetIsa(AbckitGraph * graph)27 enum AbckitIsaType GgetIsa(AbckitGraph *graph)
28 {
29 g_calledFuncs.push(__func__);
30
31 EXPECT_TRUE(graph == DEFAULT_GRAPH);
32 return DEFAULT_ENUM_ISA_TYPE;
33 }
34
GgetFile(AbckitGraph * graph)35 AbckitFile *GgetFile(AbckitGraph *graph)
36 {
37 g_calledFuncs.push(__func__);
38
39 EXPECT_TRUE(graph == DEFAULT_GRAPH);
40 return DEFAULT_FILE;
41 }
42
GgetStartBasicBlock(AbckitGraph * graph)43 AbckitBasicBlock *GgetStartBasicBlock(AbckitGraph *graph)
44 {
45 g_calledFuncs.push(__func__);
46
47 EXPECT_TRUE(graph == DEFAULT_GRAPH);
48 return DEFAULT_BB;
49 }
50
GgetEndBasicBlock(AbckitGraph * graph)51 AbckitBasicBlock *GgetEndBasicBlock(AbckitGraph *graph)
52 {
53 g_calledFuncs.push(__func__);
54
55 EXPECT_TRUE(graph == DEFAULT_GRAPH);
56 return DEFAULT_BB;
57 }
58
GgetNumberOfBasicBlocks(AbckitGraph * graph)59 uint32_t GgetNumberOfBasicBlocks(AbckitGraph *graph)
60 {
61 g_calledFuncs.push(__func__);
62
63 EXPECT_TRUE(graph == DEFAULT_GRAPH);
64 return DEFAULT_U32;
65 }
66
GvisitBlocksRpo(AbckitGraph * graph,void * data,bool (* cb)(AbckitBasicBlock * basicBlock,void * data))67 bool GvisitBlocksRpo(AbckitGraph *graph, void *data, bool (*cb)(AbckitBasicBlock *basicBlock, void *data))
68 {
69 g_calledFuncs.push(__func__);
70
71 EXPECT_TRUE(graph == DEFAULT_GRAPH);
72 cb(DEFAULT_BB, data);
73 return DEFAULT_BOOL;
74 }
75
GgetBasicBlock(AbckitGraph * graph,uint32_t id)76 AbckitBasicBlock *GgetBasicBlock(AbckitGraph *graph, uint32_t id)
77 {
78 g_calledFuncs.push(__func__);
79
80 EXPECT_TRUE(graph == DEFAULT_GRAPH);
81 EXPECT_TRUE(id == DEFAULT_U32);
82 return DEFAULT_BB;
83 }
84
GgetParameter(AbckitGraph * graph,uint32_t index)85 AbckitInst *GgetParameter(AbckitGraph *graph, uint32_t index)
86 {
87 g_calledFuncs.push(__func__);
88
89 EXPECT_TRUE(graph == DEFAULT_GRAPH);
90 EXPECT_TRUE(index == DEFAULT_U32);
91 return DEFAULT_INST;
92 }
93
GgetNumberOfParameters(AbckitGraph * graph)94 uint32_t GgetNumberOfParameters(AbckitGraph *graph)
95 {
96 g_calledFuncs.push(__func__);
97
98 EXPECT_TRUE(graph == DEFAULT_GRAPH);
99 return DEFAULT_U32;
100 }
101
GinsertTryCatch(AbckitBasicBlock * tryFirstBB,AbckitBasicBlock * tryLastBB,AbckitBasicBlock * catchBeginBB,AbckitBasicBlock * catchEndBB)102 void GinsertTryCatch(AbckitBasicBlock *tryFirstBB, AbckitBasicBlock *tryLastBB, AbckitBasicBlock *catchBeginBB,
103 AbckitBasicBlock *catchEndBB)
104 {
105 g_calledFuncs.push(__func__);
106
107 EXPECT_TRUE(tryFirstBB == DEFAULT_BB);
108 EXPECT_TRUE(tryLastBB == DEFAULT_BB);
109 EXPECT_TRUE(catchBeginBB == DEFAULT_BB);
110 EXPECT_TRUE(catchEndBB == DEFAULT_BB);
111 }
112
Gdump(AbckitGraph * graph,int32_t fd)113 void Gdump(AbckitGraph *graph, int32_t fd)
114 {
115 g_calledFuncs.push(__func__);
116
117 EXPECT_TRUE(graph == DEFAULT_GRAPH);
118 EXPECT_TRUE(fd == DEFAULT_I32);
119 }
120
GfindOrCreateConstantI32(AbckitGraph * graph,int32_t value)121 AbckitInst *GfindOrCreateConstantI32(AbckitGraph *graph, int32_t value)
122 {
123 g_calledFuncs.push(__func__);
124
125 EXPECT_TRUE(graph == DEFAULT_GRAPH);
126 EXPECT_TRUE(value == DEFAULT_I32);
127 return DEFAULT_INST;
128 }
129
GfindOrCreateConstantI64(AbckitGraph * graph,int64_t value)130 AbckitInst *GfindOrCreateConstantI64(AbckitGraph *graph, int64_t value)
131 {
132 g_calledFuncs.push(__func__);
133
134 EXPECT_TRUE(graph == DEFAULT_GRAPH);
135 EXPECT_TRUE(value == DEFAULT_I64);
136 return DEFAULT_INST;
137 }
138
GfindOrCreateConstantU64(AbckitGraph * graph,uint64_t value)139 AbckitInst *GfindOrCreateConstantU64(AbckitGraph *graph, uint64_t value)
140 {
141 g_calledFuncs.push(__func__);
142
143 EXPECT_TRUE(graph == DEFAULT_GRAPH);
144 EXPECT_TRUE(value == DEFAULT_U64);
145 return DEFAULT_INST;
146 }
147
GfindOrCreateConstantF64(AbckitGraph * graph,double value)148 AbckitInst *GfindOrCreateConstantF64(AbckitGraph *graph, double value)
149 {
150 g_calledFuncs.push(__func__);
151
152 EXPECT_TRUE(graph == DEFAULT_GRAPH);
153 EXPECT_TRUE(value == DEFAULT_DOUBLE);
154 return DEFAULT_INST;
155 }
156
GrunPassRemoveUnreachableBlocks(AbckitGraph * graph)157 void GrunPassRemoveUnreachableBlocks(AbckitGraph *graph)
158 {
159 g_calledFuncs.push(__func__);
160
161 EXPECT_TRUE(graph == DEFAULT_GRAPH);
162 }
163
BBCreateEmpty(AbckitGraph * graph)164 AbckitBasicBlock *BBCreateEmpty(AbckitGraph *graph)
165 {
166 g_calledFuncs.push(__func__);
167
168 EXPECT_TRUE(graph == DEFAULT_GRAPH);
169 return DEFAULT_BB;
170 }
171
BBGetId(AbckitBasicBlock * basicBlock)172 uint32_t BBGetId(AbckitBasicBlock *basicBlock)
173 {
174 g_calledFuncs.push(__func__);
175
176 EXPECT_TRUE(basicBlock == DEFAULT_BB);
177 return DEFAULT_U32;
178 }
179
BBGetGraph(AbckitBasicBlock * basicBlock)180 AbckitGraph *BBGetGraph(AbckitBasicBlock *basicBlock)
181 {
182 g_calledFuncs.push(__func__);
183
184 EXPECT_TRUE(basicBlock == DEFAULT_BB);
185 return DEFAULT_GRAPH;
186 }
187
BBGetPredBlockCount(AbckitBasicBlock * basicBlock)188 uint64_t BBGetPredBlockCount(AbckitBasicBlock *basicBlock)
189 {
190 g_calledFuncs.push(__func__);
191
192 EXPECT_TRUE(basicBlock == DEFAULT_BB);
193 return DEFAULT_I64;
194 }
195
BBGetPredBlock(AbckitBasicBlock * basicBlock,uint32_t index)196 AbckitBasicBlock *BBGetPredBlock(AbckitBasicBlock *basicBlock, uint32_t index)
197 {
198 g_calledFuncs.push(__func__);
199
200 EXPECT_TRUE(basicBlock == DEFAULT_BB);
201 EXPECT_TRUE(index == DEFAULT_U32);
202 return DEFAULT_BB;
203 }
204
BBVisitPredBlocks(AbckitBasicBlock * basicBlock,void * data,bool (* cb)(AbckitBasicBlock * predBasicBlock,void * data))205 bool BBVisitPredBlocks(AbckitBasicBlock *basicBlock, void *data,
206 bool (*cb)(AbckitBasicBlock *predBasicBlock, void *data))
207 {
208 g_calledFuncs.push(__func__);
209
210 EXPECT_TRUE(basicBlock == DEFAULT_BB);
211 cb(DEFAULT_BB, data);
212 return DEFAULT_BB;
213 }
214
BBGetSuccBlockCount(AbckitBasicBlock * basicBlock)215 uint64_t BBGetSuccBlockCount(AbckitBasicBlock *basicBlock)
216 {
217 g_calledFuncs.push(__func__);
218
219 EXPECT_TRUE(basicBlock == DEFAULT_BB);
220 return DEFAULT_I64;
221 }
222
BBGetSuccBlock(AbckitBasicBlock * basicBlock,uint32_t index)223 AbckitBasicBlock *BBGetSuccBlock(AbckitBasicBlock *basicBlock, uint32_t index)
224 {
225 g_calledFuncs.push(__func__);
226
227 EXPECT_TRUE(basicBlock == DEFAULT_BB);
228 EXPECT_TRUE(index == DEFAULT_U32);
229 return DEFAULT_BB;
230 }
231
BBInsertSuccBlock(AbckitBasicBlock * basicBlock,AbckitBasicBlock * succBlock,uint32_t index)232 void BBInsertSuccBlock(AbckitBasicBlock *basicBlock, AbckitBasicBlock *succBlock, uint32_t index)
233 {
234 g_calledFuncs.push(__func__);
235
236 EXPECT_TRUE(basicBlock == DEFAULT_BB);
237 EXPECT_TRUE(succBlock == DEFAULT_BB);
238 EXPECT_TRUE(index == DEFAULT_U32);
239 }
240
BBAppendSuccBlock(AbckitBasicBlock * basicBlock,AbckitBasicBlock * succBlock)241 void BBAppendSuccBlock(AbckitBasicBlock *basicBlock, AbckitBasicBlock *succBlock)
242 {
243 g_calledFuncs.push(__func__);
244
245 EXPECT_TRUE(basicBlock == DEFAULT_BB);
246 EXPECT_TRUE(succBlock == DEFAULT_BB);
247 }
248
BBdisconnectSuccBlock(AbckitBasicBlock * basicBlock,uint32_t index)249 void BBdisconnectSuccBlock(AbckitBasicBlock *basicBlock, uint32_t index)
250 {
251 g_calledFuncs.push(__func__);
252
253 EXPECT_TRUE(basicBlock == DEFAULT_BB);
254 EXPECT_TRUE(index == DEFAULT_U32);
255 }
256
BBVisitSuccBlocks(AbckitBasicBlock * basicBlock,void * data,bool (* cb)(AbckitBasicBlock * succBasicBlock,void * data))257 bool BBVisitSuccBlocks(AbckitBasicBlock *basicBlock, void *data,
258 bool (*cb)(AbckitBasicBlock *succBasicBlock, void *data))
259 {
260 g_calledFuncs.push(__func__);
261
262 EXPECT_TRUE(basicBlock == DEFAULT_BB);
263 cb(DEFAULT_BB, data);
264 return DEFAULT_BOOL;
265 }
266
BBGetTrueBranch(AbckitBasicBlock * basicBlock)267 AbckitBasicBlock *BBGetTrueBranch(AbckitBasicBlock *basicBlock)
268 {
269 g_calledFuncs.push(__func__);
270
271 EXPECT_TRUE(basicBlock == DEFAULT_BB);
272 return DEFAULT_BB;
273 }
274
BBGetFalseBranch(AbckitBasicBlock * basicBlock)275 AbckitBasicBlock *BBGetFalseBranch(AbckitBasicBlock *basicBlock)
276 {
277 g_calledFuncs.push(__func__);
278
279 EXPECT_TRUE(basicBlock == DEFAULT_BB);
280 return DEFAULT_BB;
281 }
282
BBSplitBlockAfterInstruction(AbckitBasicBlock * basicBlock,AbckitInst * inst,bool makeEdge)283 AbckitBasicBlock *BBSplitBlockAfterInstruction(AbckitBasicBlock *basicBlock, AbckitInst *inst, bool makeEdge)
284 {
285 g_calledFuncs.push(__func__);
286
287 EXPECT_TRUE(basicBlock == DEFAULT_BB);
288 EXPECT_TRUE(inst == DEFAULT_INST);
289 EXPECT_TRUE(makeEdge == DEFAULT_BOOL);
290 return DEFAULT_BB;
291 }
292
BBAddInstFront(AbckitBasicBlock * basicBlock,AbckitInst * inst)293 void BBAddInstFront(AbckitBasicBlock *basicBlock, AbckitInst *inst)
294 {
295 g_calledFuncs.push(__func__);
296
297 EXPECT_TRUE(basicBlock == DEFAULT_BB);
298 EXPECT_TRUE(inst == DEFAULT_INST);
299 }
300
BBAddInstBack(AbckitBasicBlock * basicBlock,AbckitInst * inst)301 void BBAddInstBack(AbckitBasicBlock *basicBlock, AbckitInst *inst)
302 {
303 g_calledFuncs.push(__func__);
304
305 EXPECT_TRUE(basicBlock == DEFAULT_BB);
306 EXPECT_TRUE(inst == DEFAULT_INST);
307 }
308
BBRemoveAllInsts(AbckitBasicBlock * basicBlock)309 void BBRemoveAllInsts(AbckitBasicBlock *basicBlock)
310 {
311 g_calledFuncs.push(__func__);
312
313 EXPECT_TRUE(basicBlock == DEFAULT_BB);
314 }
315
BBGetFirstInst(AbckitBasicBlock * basicBlock)316 AbckitInst *BBGetFirstInst(AbckitBasicBlock *basicBlock)
317 {
318 g_calledFuncs.push(__func__);
319
320 EXPECT_TRUE(basicBlock == DEFAULT_BB);
321 return DEFAULT_INST;
322 }
323
BBGetLastInst(AbckitBasicBlock * basicBlock)324 AbckitInst *BBGetLastInst(AbckitBasicBlock *basicBlock)
325 {
326 g_calledFuncs.push(__func__);
327
328 EXPECT_TRUE(basicBlock == DEFAULT_BB);
329 return DEFAULT_INST;
330 }
331
BBGetNumberOfInstructions(AbckitBasicBlock * basicBlock)332 uint32_t BBGetNumberOfInstructions(AbckitBasicBlock *basicBlock)
333 {
334 g_calledFuncs.push(__func__);
335
336 EXPECT_TRUE(basicBlock == DEFAULT_BB);
337 return DEFAULT_U32;
338 }
339
BBGetImmediateDominator(AbckitBasicBlock * basicBlock)340 AbckitBasicBlock *BBGetImmediateDominator(AbckitBasicBlock *basicBlock)
341 {
342 g_calledFuncs.push(__func__);
343
344 EXPECT_TRUE(basicBlock == DEFAULT_BB);
345 return DEFAULT_BB;
346 }
347
BBCheckDominance(AbckitBasicBlock * basicBlock,AbckitBasicBlock * dominator)348 bool BBCheckDominance(AbckitBasicBlock *basicBlock, AbckitBasicBlock *dominator)
349 {
350 g_calledFuncs.push(__func__);
351
352 EXPECT_TRUE(basicBlock == DEFAULT_BB);
353 EXPECT_TRUE(dominator == DEFAULT_BB);
354 return DEFAULT_BOOL;
355 }
356
BBVisitDominatedBlocks(AbckitBasicBlock * basicBlock,void * data,bool (* cb)(AbckitBasicBlock * dominatedBasicBlock,void * data))357 bool BBVisitDominatedBlocks(AbckitBasicBlock *basicBlock, void *data,
358 bool (*cb)(AbckitBasicBlock *dominatedBasicBlock, void *data))
359 {
360 g_calledFuncs.push(__func__);
361
362 EXPECT_TRUE(basicBlock == DEFAULT_BB);
363 cb(DEFAULT_BB, data);
364 return DEFAULT_BOOL;
365 }
366
BBIsStart(AbckitBasicBlock * basicBlock)367 bool BBIsStart(AbckitBasicBlock *basicBlock)
368 {
369 g_calledFuncs.push(__func__);
370
371 EXPECT_TRUE(basicBlock == DEFAULT_BB);
372 return DEFAULT_BOOL;
373 }
374
BBIsEnd(AbckitBasicBlock * basicBlock)375 bool BBIsEnd(AbckitBasicBlock *basicBlock)
376 {
377 g_calledFuncs.push(__func__);
378
379 EXPECT_TRUE(basicBlock == DEFAULT_BB);
380 return DEFAULT_BOOL;
381 }
382
BBIsLoopHead(AbckitBasicBlock * basicBlock)383 bool BBIsLoopHead(AbckitBasicBlock *basicBlock)
384 {
385 g_calledFuncs.push(__func__);
386
387 EXPECT_TRUE(basicBlock == DEFAULT_BB);
388 return DEFAULT_BOOL;
389 }
390
BBIsLoopPrehead(AbckitBasicBlock * basicBlock)391 bool BBIsLoopPrehead(AbckitBasicBlock *basicBlock)
392 {
393 g_calledFuncs.push(__func__);
394
395 EXPECT_TRUE(basicBlock == DEFAULT_BB);
396 return DEFAULT_BOOL;
397 }
398
BBIsTryBegin(AbckitBasicBlock * basicBlock)399 bool BBIsTryBegin(AbckitBasicBlock *basicBlock)
400 {
401 g_calledFuncs.push(__func__);
402
403 EXPECT_TRUE(basicBlock == DEFAULT_BB);
404 return DEFAULT_BOOL;
405 }
406
BBIsTry(AbckitBasicBlock * basicBlock)407 bool BBIsTry(AbckitBasicBlock *basicBlock)
408 {
409 g_calledFuncs.push(__func__);
410
411 EXPECT_TRUE(basicBlock == DEFAULT_BB);
412 return DEFAULT_BOOL;
413 }
414
BBIsTryEnd(AbckitBasicBlock * basicBlock)415 bool BBIsTryEnd(AbckitBasicBlock *basicBlock)
416 {
417 g_calledFuncs.push(__func__);
418
419 EXPECT_TRUE(basicBlock == DEFAULT_BB);
420 return DEFAULT_BOOL;
421 }
422
BBIsCatchBegin(AbckitBasicBlock * basicBlock)423 bool BBIsCatchBegin(AbckitBasicBlock *basicBlock)
424 {
425 g_calledFuncs.push(__func__);
426
427 EXPECT_TRUE(basicBlock == DEFAULT_BB);
428 return DEFAULT_BOOL;
429 }
430
BBIsCatch(AbckitBasicBlock * basicBlock)431 bool BBIsCatch(AbckitBasicBlock *basicBlock)
432 {
433 g_calledFuncs.push(__func__);
434
435 EXPECT_TRUE(basicBlock == DEFAULT_BB);
436 return DEFAULT_BOOL;
437 }
438
BBDump(AbckitBasicBlock * basicBlock,int32_t fd)439 void BBDump(AbckitBasicBlock *basicBlock, int32_t fd)
440 {
441 g_calledFuncs.push(__func__);
442
443 EXPECT_TRUE(basicBlock == DEFAULT_BB);
444 EXPECT_TRUE(fd == DEFAULT_I32);
445 }
446
BBCreatePhi(AbckitBasicBlock * basicBlock,size_t argCount,...)447 AbckitInst *BBCreatePhi(AbckitBasicBlock *basicBlock, size_t argCount, ...)
448 {
449 g_calledFuncs.push(__func__);
450
451 EXPECT_TRUE(basicBlock == DEFAULT_BB);
452 EXPECT_TRUE(argCount == 2U);
453 return DEFAULT_INST;
454 }
455
BBCreateCatchPhi(AbckitBasicBlock * catchBegin,size_t argCount,...)456 AbckitInst *BBCreateCatchPhi(AbckitBasicBlock *catchBegin, size_t argCount, ...)
457 {
458 g_calledFuncs.push(__func__);
459
460 EXPECT_TRUE(catchBegin == DEFAULT_BB);
461 EXPECT_TRUE(argCount == 2U);
462 return DEFAULT_INST;
463 }
464
Iremove(AbckitInst * inst)465 void Iremove(AbckitInst *inst)
466 {
467 g_calledFuncs.push(__func__);
468
469 EXPECT_TRUE(inst == DEFAULT_INST);
470 }
471
IgetId(AbckitInst * inst)472 uint32_t IgetId(AbckitInst *inst)
473 {
474 g_calledFuncs.push(__func__);
475
476 EXPECT_TRUE(inst == DEFAULT_INST);
477 return DEFAULT_U32;
478 }
479
IgetNext(AbckitInst * inst)480 AbckitInst *IgetNext(AbckitInst *inst)
481 {
482 g_calledFuncs.push(__func__);
483
484 EXPECT_TRUE(inst == DEFAULT_INST);
485 return DEFAULT_INST;
486 }
487
IgetPrev(AbckitInst * inst)488 AbckitInst *IgetPrev(AbckitInst *inst)
489 {
490 g_calledFuncs.push(__func__);
491
492 EXPECT_TRUE(inst == DEFAULT_INST);
493 return DEFAULT_INST;
494 }
495
IinsertAfter(AbckitInst * newInst,AbckitInst * ref)496 void IinsertAfter(AbckitInst *newInst, AbckitInst *ref)
497 {
498 g_calledFuncs.push(__func__);
499
500 EXPECT_TRUE(newInst == DEFAULT_INST);
501 EXPECT_TRUE(ref == DEFAULT_INST);
502 }
503
IinsertBefore(AbckitInst * newInst,AbckitInst * ref)504 void IinsertBefore(AbckitInst *newInst, AbckitInst *ref)
505 {
506 g_calledFuncs.push(__func__);
507
508 EXPECT_TRUE(newInst == DEFAULT_INST);
509 EXPECT_TRUE(ref == DEFAULT_INST);
510 }
511
IgetType(AbckitInst * inst)512 AbckitType *IgetType(AbckitInst *inst)
513 {
514 g_calledFuncs.push(__func__);
515
516 EXPECT_TRUE(inst == DEFAULT_INST);
517 return DEFAULT_TYPE;
518 }
519
IgetBasicBlock(AbckitInst * inst)520 AbckitBasicBlock *IgetBasicBlock(AbckitInst *inst)
521 {
522 g_calledFuncs.push(__func__);
523
524 EXPECT_TRUE(inst == DEFAULT_INST);
525 return DEFAULT_BB;
526 }
527
IgetGraph(AbckitInst * inst)528 AbckitGraph *IgetGraph(AbckitInst *inst)
529 {
530 g_calledFuncs.push(__func__);
531
532 EXPECT_TRUE(inst == DEFAULT_INST);
533 return DEFAULT_GRAPH;
534 }
535
IcheckDominance(AbckitInst * inst,AbckitInst * dominator)536 bool IcheckDominance(AbckitInst *inst, AbckitInst *dominator)
537 {
538 g_calledFuncs.push(__func__);
539
540 EXPECT_TRUE(inst == DEFAULT_INST);
541 EXPECT_TRUE(dominator == DEFAULT_INST);
542 return DEFAULT_BOOL;
543 }
544
IcheckIsCall(AbckitInst * inst)545 bool IcheckIsCall(AbckitInst *inst)
546 {
547 g_calledFuncs.push(__func__);
548
549 EXPECT_TRUE(inst == DEFAULT_INST);
550 return DEFAULT_BOOL;
551 }
552
IgetUserCount(AbckitInst * inst)553 uint32_t IgetUserCount(AbckitInst *inst)
554 {
555 g_calledFuncs.push(__func__);
556
557 EXPECT_TRUE(inst == DEFAULT_INST);
558 return DEFAULT_U32;
559 }
560
IvisitUsers(AbckitInst * inst,void * data,bool (* cb)(AbckitInst * user,void * data))561 bool IvisitUsers(AbckitInst *inst, void *data, bool (*cb)(AbckitInst *user, void *data))
562 {
563 g_calledFuncs.push(__func__);
564
565 EXPECT_TRUE(inst == DEFAULT_INST);
566 cb(DEFAULT_INST, data);
567 return DEFAULT_BOOL;
568 }
569
IgetInputCount(AbckitInst * inst)570 uint32_t IgetInputCount(AbckitInst *inst)
571 {
572 g_calledFuncs.push(__func__);
573
574 EXPECT_TRUE(inst == DEFAULT_INST);
575 return DEFAULT_U32;
576 }
577
IgetInput(AbckitInst * inst,uint32_t index)578 AbckitInst *IgetInput(AbckitInst *inst, uint32_t index)
579 {
580 g_calledFuncs.push(__func__);
581
582 EXPECT_TRUE(inst == DEFAULT_INST);
583 EXPECT_TRUE(index == DEFAULT_U32);
584 return DEFAULT_INST;
585 }
586
IvisitInputs(AbckitInst * inst,void * data,bool (* cb)(AbckitInst * input,size_t inputIdx,void * data))587 bool IvisitInputs(AbckitInst *inst, void *data, bool (*cb)(AbckitInst *input, size_t inputIdx, void *data))
588 {
589 g_calledFuncs.push(__func__);
590
591 EXPECT_TRUE(inst == DEFAULT_INST);
592 cb(DEFAULT_INST, DEFAULT_SIZE_T, data);
593 return DEFAULT_BOOL;
594 }
595
IsetInput(AbckitInst * inst,AbckitInst * input,uint32_t index)596 void IsetInput(AbckitInst *inst, AbckitInst *input, uint32_t index)
597 {
598 g_calledFuncs.push(__func__);
599
600 EXPECT_TRUE(inst == DEFAULT_INST);
601 EXPECT_TRUE(input == DEFAULT_INST);
602 EXPECT_TRUE(index == DEFAULT_U32);
603 }
604
IsetInputs(AbckitInst * inst,size_t argCount,...)605 void IsetInputs(AbckitInst *inst, size_t argCount, ...)
606 {
607 g_calledFuncs.push(__func__);
608
609 EXPECT_TRUE(inst == DEFAULT_INST);
610 EXPECT_TRUE(argCount == 2U);
611 }
612
IappendInput(AbckitInst * inst,AbckitInst * input)613 void IappendInput(AbckitInst *inst, AbckitInst *input)
614 {
615 g_calledFuncs.push(__func__);
616
617 EXPECT_TRUE(inst == DEFAULT_INST);
618 EXPECT_TRUE(input == DEFAULT_INST);
619 }
620
Idump(AbckitInst * inst,int32_t fd)621 void Idump(AbckitInst *inst, int32_t fd)
622 {
623 g_calledFuncs.push(__func__);
624
625 EXPECT_TRUE(inst == DEFAULT_INST);
626 EXPECT_TRUE(fd == DEFAULT_I32);
627 }
628
IgetFunction(AbckitInst * inst)629 AbckitCoreFunction *IgetFunction(AbckitInst *inst)
630 {
631 g_calledFuncs.push(__func__);
632
633 EXPECT_TRUE(inst == DEFAULT_INST);
634 return DEFAULT_CORE_FUNCTION;
635 }
636
IsetFunction(AbckitInst * inst,AbckitCoreFunction * function)637 void IsetFunction(AbckitInst *inst, AbckitCoreFunction *function)
638 {
639 g_calledFuncs.push(__func__);
640
641 EXPECT_TRUE(inst == DEFAULT_INST);
642 EXPECT_TRUE(function == DEFAULT_CORE_FUNCTION);
643 }
644
IgetImmediate(AbckitInst * inst,size_t index)645 uint64_t IgetImmediate(AbckitInst *inst, size_t index)
646 {
647 g_calledFuncs.push(__func__);
648
649 EXPECT_TRUE(inst == DEFAULT_INST);
650 EXPECT_TRUE(index == DEFAULT_SIZE_T);
651 return DEFAULT_I64;
652 }
653
IsetImmediate(AbckitInst * inst,size_t index,uint64_t imm)654 void IsetImmediate(AbckitInst *inst, size_t index, uint64_t imm)
655 {
656 g_calledFuncs.push(__func__);
657
658 EXPECT_TRUE(inst == DEFAULT_INST);
659 EXPECT_TRUE(index == DEFAULT_SIZE_T);
660 EXPECT_TRUE(imm == DEFAULT_U64);
661 }
662
IgetImmediateSize(AbckitInst * inst,size_t index)663 AbckitBitImmSize IgetImmediateSize(AbckitInst *inst, size_t index)
664 {
665 g_calledFuncs.push(__func__);
666
667 EXPECT_TRUE(inst == DEFAULT_INST);
668 EXPECT_TRUE(index == DEFAULT_SIZE_T);
669 return DEFAULT_ENUM_BITSIZE;
670 }
671
IgetImmediateCount(AbckitInst * inst)672 uint64_t IgetImmediateCount(AbckitInst *inst)
673 {
674 g_calledFuncs.push(__func__);
675
676 EXPECT_TRUE(inst == DEFAULT_INST);
677 return DEFAULT_I64;
678 }
679
IgetLiteralArray(AbckitInst * inst)680 AbckitLiteralArray *IgetLiteralArray(AbckitInst *inst)
681 {
682 g_calledFuncs.push(__func__);
683
684 EXPECT_TRUE(inst == DEFAULT_INST);
685 return DEFAULT_LITERAL_ARRAY;
686 }
687
IsetLiteralArray(AbckitInst * inst,AbckitLiteralArray * la)688 void IsetLiteralArray(AbckitInst *inst, AbckitLiteralArray *la)
689 {
690 g_calledFuncs.push(__func__);
691
692 EXPECT_TRUE(inst == DEFAULT_INST);
693 EXPECT_TRUE(la == DEFAULT_LITERAL_ARRAY);
694 }
695
IgetString(AbckitInst * inst)696 AbckitString *IgetString(AbckitInst *inst)
697 {
698 g_calledFuncs.push(__func__);
699
700 EXPECT_TRUE(inst == DEFAULT_INST);
701 return DEFAULT_STRING;
702 }
703
IsetString(AbckitInst * inst,AbckitString * s)704 void IsetString(AbckitInst *inst, AbckitString *s)
705 {
706 g_calledFuncs.push(__func__);
707
708 EXPECT_TRUE(inst == DEFAULT_INST);
709 EXPECT_TRUE(s == DEFAULT_STRING);
710 }
711
IgetConstantValueI32(AbckitInst * inst)712 int32_t IgetConstantValueI32(AbckitInst *inst)
713 {
714 g_calledFuncs.push(__func__);
715
716 EXPECT_TRUE(inst == DEFAULT_INST);
717 return DEFAULT_I32;
718 }
719
IgetConstantValueI64(AbckitInst * inst)720 int64_t IgetConstantValueI64(AbckitInst *inst)
721 {
722 g_calledFuncs.push(__func__);
723
724 EXPECT_TRUE(inst == DEFAULT_INST);
725 return DEFAULT_I64;
726 }
727
IgetConstantValueU64(AbckitInst * inst)728 uint64_t IgetConstantValueU64(AbckitInst *inst)
729 {
730 g_calledFuncs.push(__func__);
731
732 EXPECT_TRUE(inst == DEFAULT_INST);
733 return DEFAULT_I64;
734 }
735
IgetConstantValueF64(AbckitInst * inst)736 double IgetConstantValueF64(AbckitInst *inst)
737 {
738 g_calledFuncs.push(__func__);
739
740 EXPECT_TRUE(inst == DEFAULT_INST);
741 return DEFAULT_DOUBLE;
742 }
743
744 AbckitGraphApi g_graphApiImpl = {
745 GgetIsa,
746 GgetFile,
747
748 // ========================================
749 // Api for Graph manipulation
750 // ========================================
751
752 GgetStartBasicBlock,
753 GgetEndBasicBlock,
754 GgetNumberOfBasicBlocks,
755 GvisitBlocksRpo,
756 GgetBasicBlock,
757 GgetParameter,
758 GgetNumberOfParameters,
759 GinsertTryCatch,
760 Gdump,
761 GfindOrCreateConstantI32,
762 GfindOrCreateConstantI64,
763 GfindOrCreateConstantU64,
764 GfindOrCreateConstantF64,
765 GrunPassRemoveUnreachableBlocks,
766
767 // ========================================
768 // Api for basic block manipulation
769 // ========================================
770
771 BBCreateEmpty,
772 BBGetId,
773 BBGetGraph,
774 BBGetPredBlockCount,
775 BBGetPredBlock,
776 BBVisitPredBlocks,
777 BBGetSuccBlockCount,
778 BBGetSuccBlock,
779 BBInsertSuccBlock,
780 BBAppendSuccBlock,
781 BBdisconnectSuccBlock,
782 BBVisitSuccBlocks,
783 BBGetTrueBranch,
784 BBGetFalseBranch,
785 BBSplitBlockAfterInstruction,
786 BBAddInstFront,
787 BBAddInstBack,
788 BBRemoveAllInsts,
789 BBGetFirstInst,
790 BBGetLastInst,
791 BBGetNumberOfInstructions,
792 BBGetImmediateDominator,
793 BBCheckDominance,
794 BBVisitDominatedBlocks,
795 BBIsStart,
796 BBIsEnd,
797 BBIsLoopHead,
798 BBIsLoopPrehead,
799 BBIsTryBegin,
800 BBIsTry,
801 BBIsTryEnd,
802 BBIsCatchBegin,
803 BBIsCatch,
804 BBDump,
805 BBCreatePhi,
806 BBCreateCatchPhi,
807
808 // ========================================
809 // Api for instruction manipulation
810 // ========================================
811
812 Iremove,
813 IgetId,
814 IgetNext,
815 IgetPrev,
816 IinsertAfter,
817 IinsertBefore,
818 IgetType,
819 IgetBasicBlock,
820 IgetGraph,
821 IcheckDominance,
822 IcheckIsCall,
823 IgetUserCount,
824 IvisitUsers,
825 IgetInputCount,
826 IgetInput,
827 IvisitInputs,
828 IsetInput,
829 IsetInputs,
830 IappendInput,
831 Idump,
832 IgetFunction,
833 IsetFunction,
834 IgetImmediate,
835 IsetImmediate,
836 IgetImmediateSize,
837 IgetImmediateCount,
838 IgetLiteralArray,
839 IsetLiteralArray,
840 IgetString,
841 IsetString,
842 IgetConstantValueI32,
843 IgetConstantValueI64,
844 IgetConstantValueU64,
845 IgetConstantValueF64,
846 };
847
848 // NOLINTEND(readability-identifier-naming)
849
850 } // namespace libabckit::mock::graph_api
851
AbckitGetMockGraphApiImpl(AbckitApiVersion version)852 AbckitGraphApi const *AbckitGetMockGraphApiImpl([[maybe_unused]] AbckitApiVersion version)
853 {
854 return &libabckit::mock::graph_api::g_graphApiImpl;
855 }
856