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 graph 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 <cassert>
17 #include "libabckit/include/c/abckit.h"
18 #include "libabckit/include/c/ir_core.h"
19
20 #include "libabckit/src/metadata_inspect_impl.h"
21 #include "libabckit/src/ir_impl.h"
22 #include "libabckit/src/helpers_common.h"
23 #include "libabckit/src/adapter_static/ir_static.h"
24
25 #include "libabckit/src/macros.h"
26 #include "libabckit/src/logger.h"
27
28 #include <cstdint>
29 #include <iostream>
30
31 namespace libabckit {
32
33 // ========================================
34 // Api for Graph manipulation
35 // ========================================
36
GgetIsa(AbckitGraph * graph)37 extern "C" AbckitIsaType GgetIsa(AbckitGraph *graph)
38 {
39 LIBABCKIT_CLEAR_LAST_ERROR;
40 LIBABCKIT_IMPLEMENTED;
41 LIBABCKIT_BAD_ARGUMENT(graph, ABCKIT_ISA_TYPE_UNSUPPORTED);
42 if (IsDynamic(graph->function->owningModule->target)) {
43 return AbckitIsaType::ABCKIT_ISA_TYPE_DYNAMIC;
44 }
45 return AbckitIsaType::ABCKIT_ISA_TYPE_STATIC;
46 }
47
GgetFile(AbckitGraph * graph)48 extern "C" AbckitFile *GgetFile(AbckitGraph *graph)
49 {
50 LIBABCKIT_CLEAR_LAST_ERROR;
51 LIBABCKIT_IMPLEMENTED;
52
53 LIBABCKIT_BAD_ARGUMENT(graph, nullptr);
54
55 return graph->file;
56 }
57
GgetStartBasicBlock(AbckitGraph * graph)58 extern "C" AbckitBasicBlock *GgetStartBasicBlock(AbckitGraph *graph)
59 {
60 LIBABCKIT_CLEAR_LAST_ERROR;
61 LIBABCKIT_IMPLEMENTED;
62 return GgetStartBasicBlockStatic(graph);
63 }
64
GgetEndBasicBlock(AbckitGraph * graph)65 extern "C" AbckitBasicBlock *GgetEndBasicBlock([[maybe_unused]] AbckitGraph *graph)
66 {
67 LIBABCKIT_CLEAR_LAST_ERROR;
68 LIBABCKIT_IMPLEMENTED;
69 return GgetEndBasicBlockStatic(graph);
70 }
71
GgetNumberOfBasicBlocks(AbckitGraph * graph)72 extern "C" uint32_t GgetNumberOfBasicBlocks(AbckitGraph *graph)
73 {
74 LIBABCKIT_CLEAR_LAST_ERROR;
75 LIBABCKIT_IMPLEMENTED;
76
77 return GgetNumberOfBasicBlocksStatic(graph);
78 }
79
GvisitBlocksRPO(AbckitGraph * graph,void * data,bool (* cb)(AbckitBasicBlock * bb,void * data))80 extern "C" bool GvisitBlocksRPO([[maybe_unused]] AbckitGraph *graph, [[maybe_unused]] void *data,
81 [[maybe_unused]] bool (*cb)(AbckitBasicBlock *bb, void *data))
82 {
83 LIBABCKIT_CLEAR_LAST_ERROR;
84 LIBABCKIT_IMPLEMENTED;
85 return GvisitBlocksRPOStatic(graph, data, cb);
86 }
87
GgetBasicBlock(AbckitGraph * graph,uint32_t id)88 extern "C" AbckitBasicBlock *GgetBasicBlock(AbckitGraph *graph, uint32_t id)
89 {
90 LIBABCKIT_CLEAR_LAST_ERROR;
91 LIBABCKIT_IMPLEMENTED;
92
93 return GgetBasicBlockStatic(graph, id);
94 }
95
GgetNumberOfParameters(AbckitGraph * graph)96 extern "C" uint32_t GgetNumberOfParameters(AbckitGraph *graph)
97 {
98 LIBABCKIT_CLEAR_LAST_ERROR;
99 LIBABCKIT_IMPLEMENTED;
100
101 LIBABCKIT_BAD_ARGUMENT(graph, 0);
102
103 return GgetNumberOfParametersStatic(graph);
104 }
105
GgetParameter(AbckitGraph * graph,uint32_t index)106 extern "C" AbckitInst *GgetParameter(AbckitGraph *graph, uint32_t index)
107 {
108 LIBABCKIT_CLEAR_LAST_ERROR;
109 LIBABCKIT_IMPLEMENTED;
110
111 return GgetParameterStatic(graph, index);
112 }
113
GinsertTryCatch(AbckitBasicBlock * tryFirstBB,AbckitBasicBlock * tryLastBB,AbckitBasicBlock * catchBeginBB,AbckitBasicBlock * catchEndBB)114 extern "C" void GinsertTryCatch(AbckitBasicBlock *tryFirstBB, AbckitBasicBlock *tryLastBB,
115 AbckitBasicBlock *catchBeginBB, AbckitBasicBlock *catchEndBB)
116 {
117 LIBABCKIT_CLEAR_LAST_ERROR;
118 LIBABCKIT_IMPLEMENTED;
119
120 LIBABCKIT_BAD_ARGUMENT_VOID(tryFirstBB);
121 LIBABCKIT_BAD_ARGUMENT_VOID(tryLastBB);
122 LIBABCKIT_BAD_ARGUMENT_VOID(catchBeginBB);
123 LIBABCKIT_BAD_ARGUMENT_VOID(catchEndBB);
124
125 GinsertTryCatchStatic(tryFirstBB, tryLastBB, catchBeginBB, catchEndBB);
126 }
127
Gdump(AbckitGraph * graph,int32_t fd)128 extern "C" void Gdump(AbckitGraph *graph, int32_t fd)
129 {
130 LIBABCKIT_CLEAR_LAST_ERROR;
131 LIBABCKIT_IMPLEMENTED;
132
133 LIBABCKIT_BAD_ARGUMENT_VOID(graph)
134
135 GdumpStatic(graph, fd);
136 }
137
GrunPassRemoveUnreachableBlocks(AbckitGraph * graph)138 extern "C" void GrunPassRemoveUnreachableBlocks(AbckitGraph *graph)
139 {
140 LIBABCKIT_CLEAR_LAST_ERROR;
141 LIBABCKIT_IMPLEMENTED;
142
143 LIBABCKIT_BAD_ARGUMENT_VOID(graph)
144
145 GrunPassRemoveUnreachableBlocksStatic(graph);
146 }
147
148 // ========================================
149 // Api for basic block manipulation
150 // ========================================
151
BBcreateEmpty(AbckitGraph * graph)152 extern "C" AbckitBasicBlock *BBcreateEmpty(AbckitGraph *graph)
153 {
154 LIBABCKIT_CLEAR_LAST_ERROR;
155 LIBABCKIT_IMPLEMENTED;
156
157 return BBcreateEmptyStatic(graph);
158 }
159
BBgetId(AbckitBasicBlock * basicBlock)160 extern "C" uint32_t BBgetId(AbckitBasicBlock *basicBlock)
161 {
162 LIBABCKIT_CLEAR_LAST_ERROR;
163 LIBABCKIT_IMPLEMENTED;
164
165 return BBgetIdStatic(basicBlock);
166 }
167
BBgetGraph(AbckitBasicBlock * basicBlock)168 extern "C" AbckitGraph *BBgetGraph(AbckitBasicBlock *basicBlock)
169 {
170 LIBABCKIT_CLEAR_LAST_ERROR;
171 LIBABCKIT_IMPLEMENTED;
172
173 return BBgetGraphStatic(basicBlock);
174 }
175
BBgetPredBlockCount(AbckitBasicBlock * basicBlock)176 extern "C" uint64_t BBgetPredBlockCount(AbckitBasicBlock *basicBlock)
177 {
178 LIBABCKIT_CLEAR_LAST_ERROR;
179 LIBABCKIT_IMPLEMENTED;
180
181 return BBgetPredBlockCountStatic(basicBlock);
182 }
183
BBgetPredBlock(AbckitBasicBlock * basicBlock,uint32_t index)184 extern "C" AbckitBasicBlock *BBgetPredBlock(AbckitBasicBlock *basicBlock, uint32_t index)
185 {
186 LIBABCKIT_CLEAR_LAST_ERROR;
187 LIBABCKIT_IMPLEMENTED;
188
189 return BBgetPredBlockStatic(basicBlock, index);
190 }
191
BBvisitPredBlocks(AbckitBasicBlock * basicBlock,void * data,bool (* cb)(AbckitBasicBlock * predBasicBlock,void * data))192 extern "C" bool BBvisitPredBlocks(AbckitBasicBlock *basicBlock, void *data,
193 bool (*cb)(AbckitBasicBlock *predBasicBlock, void *data))
194 {
195 LIBABCKIT_CLEAR_LAST_ERROR;
196 LIBABCKIT_IMPLEMENTED;
197
198 return BBvisitPredBlocksStatic(basicBlock, data, cb);
199 }
200
BBgetSuccBlockCount(AbckitBasicBlock * basicBlock)201 extern "C" uint64_t BBgetSuccBlockCount(AbckitBasicBlock *basicBlock)
202 {
203 LIBABCKIT_IMPLEMENTED;
204 LIBABCKIT_CLEAR_LAST_ERROR;
205
206 return BBgetSuccBlockCountStatic(basicBlock);
207 }
208
BBgetSuccBlock(AbckitBasicBlock * basicBlock,uint32_t index)209 extern "C" AbckitBasicBlock *BBgetSuccBlock(AbckitBasicBlock *basicBlock, uint32_t index)
210 {
211 LIBABCKIT_IMPLEMENTED;
212 LIBABCKIT_CLEAR_LAST_ERROR;
213
214 return BBgetSuccBlockStatic(basicBlock, index);
215 }
216
BBinsertSuccBlock(AbckitBasicBlock * basicBlock,AbckitBasicBlock * succBlock,uint32_t index)217 extern "C" void BBinsertSuccBlock(AbckitBasicBlock *basicBlock, AbckitBasicBlock *succBlock, uint32_t index)
218 {
219 LIBABCKIT_CLEAR_LAST_ERROR;
220 LIBABCKIT_IMPLEMENTED;
221
222 BBinsertSuccBlockStatic(basicBlock, succBlock, index);
223 }
224
BBappendSuccBlock(AbckitBasicBlock * basicBlock,AbckitBasicBlock * succBlock)225 extern "C" void BBappendSuccBlock(AbckitBasicBlock *basicBlock, AbckitBasicBlock *succBlock)
226 {
227 LIBABCKIT_CLEAR_LAST_ERROR;
228 LIBABCKIT_IMPLEMENTED;
229
230 BBappendSuccBlockStatic(basicBlock, succBlock);
231 }
232
BBdisconnectSuccBlock(AbckitBasicBlock * bb,uint32_t index)233 extern "C" void BBdisconnectSuccBlock(AbckitBasicBlock *bb, uint32_t index)
234 {
235 LIBABCKIT_CLEAR_LAST_ERROR;
236 LIBABCKIT_IMPLEMENTED;
237
238 BBdisconnectSuccBlockStatic(bb, index);
239 }
240
BBvisitSuccBlocks(AbckitBasicBlock * basicBlock,void * data,bool (* cb)(AbckitBasicBlock * succBasicBlock,void * data))241 extern "C" bool BBvisitSuccBlocks(AbckitBasicBlock *basicBlock, void *data,
242 bool (*cb)(AbckitBasicBlock *succBasicBlock, void *data))
243 {
244 LIBABCKIT_CLEAR_LAST_ERROR;
245 LIBABCKIT_IMPLEMENTED;
246 return BBvisitSuccBlocksStatic(basicBlock, data, cb);
247 }
248
BBgetTrueBranch(AbckitBasicBlock * basicBlock)249 extern "C" AbckitBasicBlock *BBgetTrueBranch(AbckitBasicBlock *basicBlock)
250 {
251 LIBABCKIT_CLEAR_LAST_ERROR;
252 LIBABCKIT_IMPLEMENTED;
253
254 return BBgetTrueBranchStatic(basicBlock);
255 }
256
BBgetFalseBranch(AbckitBasicBlock * curBasicBlock)257 extern "C" AbckitBasicBlock *BBgetFalseBranch(AbckitBasicBlock *curBasicBlock)
258 {
259 LIBABCKIT_CLEAR_LAST_ERROR;
260 LIBABCKIT_IMPLEMENTED;
261
262 return BBgetFalseBranchStatic(curBasicBlock);
263 }
264
BBsplitBlockAfterInstruction(AbckitBasicBlock * basicBlock,AbckitInst * inst,bool makeEdge)265 extern "C" AbckitBasicBlock *BBsplitBlockAfterInstruction(AbckitBasicBlock *basicBlock, AbckitInst *inst, bool makeEdge)
266 {
267 LIBABCKIT_CLEAR_LAST_ERROR;
268 LIBABCKIT_IMPLEMENTED;
269
270 return BBsplitBlockAfterInstructionStatic(basicBlock, inst, makeEdge);
271 }
272
BBaddInstFront(AbckitBasicBlock * basicBlock,AbckitInst * inst)273 extern "C" void BBaddInstFront(AbckitBasicBlock *basicBlock, AbckitInst *inst)
274 {
275 LIBABCKIT_CLEAR_LAST_ERROR;
276 LIBABCKIT_IMPLEMENTED;
277 BBaddInstFrontStatic(basicBlock, inst);
278 }
279
BBaddInstBack(AbckitBasicBlock * basicBlock,AbckitInst * inst)280 extern "C" void BBaddInstBack(AbckitBasicBlock *basicBlock, AbckitInst *inst)
281 {
282 LIBABCKIT_CLEAR_LAST_ERROR;
283 LIBABCKIT_IMPLEMENTED;
284 BBaddInstBackStatic(basicBlock, inst);
285 }
286
BBremoveAllInsts(AbckitBasicBlock * basicBlock)287 extern "C" void BBremoveAllInsts(AbckitBasicBlock *basicBlock)
288 {
289 LIBABCKIT_CLEAR_LAST_ERROR;
290 LIBABCKIT_IMPLEMENTED;
291
292 LIBABCKIT_BAD_ARGUMENT_VOID(basicBlock)
293
294 return BBremoveAllInstsStatic(basicBlock);
295 }
296
BBgetFirstInst(AbckitBasicBlock * basicBlock)297 extern "C" AbckitInst *BBgetFirstInst(AbckitBasicBlock *basicBlock)
298 {
299 LIBABCKIT_CLEAR_LAST_ERROR;
300 LIBABCKIT_IMPLEMENTED;
301 return BBgetFirstInstStatic(basicBlock);
302 }
303
BBgetLastInst(AbckitBasicBlock * basicBlock)304 extern "C" AbckitInst *BBgetLastInst(AbckitBasicBlock *basicBlock)
305 {
306 LIBABCKIT_CLEAR_LAST_ERROR;
307 LIBABCKIT_IMPLEMENTED;
308 return BBgetLastInstStatic(basicBlock);
309 }
310
BBgetNumberOfInstructions(AbckitBasicBlock * basicBlock)311 extern "C" uint32_t BBgetNumberOfInstructions(AbckitBasicBlock *basicBlock)
312 {
313 LIBABCKIT_CLEAR_LAST_ERROR;
314 LIBABCKIT_IMPLEMENTED;
315
316 return BBgetNumberOfInstructionsStatic(basicBlock);
317 }
318
BBgetImmediateDominator(AbckitBasicBlock * basicBlock)319 extern "C" AbckitBasicBlock *BBgetImmediateDominator(AbckitBasicBlock *basicBlock)
320 {
321 LIBABCKIT_CLEAR_LAST_ERROR;
322 LIBABCKIT_IMPLEMENTED;
323
324 return BBgetImmediateDominatorStatic(basicBlock);
325 }
326
BBcheckDominance(AbckitBasicBlock * basicBlock,AbckitBasicBlock * dominator)327 extern "C" bool BBcheckDominance(AbckitBasicBlock *basicBlock, AbckitBasicBlock *dominator)
328 {
329 LIBABCKIT_CLEAR_LAST_ERROR;
330 LIBABCKIT_IMPLEMENTED;
331
332 return BBcheckDominanceStatic(basicBlock, dominator);
333 }
334
BBvisitDominatedBlocks(AbckitBasicBlock * basicBlock,void * data,bool (* cb)(AbckitBasicBlock * dominatedBasicBlock,void * data))335 extern "C" bool BBvisitDominatedBlocks(AbckitBasicBlock *basicBlock, void *data,
336 bool (*cb)(AbckitBasicBlock *dominatedBasicBlock, void *data))
337 {
338 LIBABCKIT_CLEAR_LAST_ERROR;
339 LIBABCKIT_IMPLEMENTED;
340
341 return BBvisitDominatedBlocksStatic(basicBlock, data, cb);
342 }
343
BBisStart(AbckitBasicBlock * basicBlock)344 extern "C" bool BBisStart(AbckitBasicBlock *basicBlock)
345 {
346 LIBABCKIT_CLEAR_LAST_ERROR;
347 LIBABCKIT_IMPLEMENTED;
348
349 return BBisStartStatic(basicBlock);
350 }
351
BBisEnd(AbckitBasicBlock * basicBlock)352 extern "C" bool BBisEnd(AbckitBasicBlock *basicBlock)
353 {
354 LIBABCKIT_CLEAR_LAST_ERROR;
355 LIBABCKIT_IMPLEMENTED;
356
357 return BBisEndStatic(basicBlock);
358 }
359
BBisLoopHead(AbckitBasicBlock * basicBlock)360 extern "C" bool BBisLoopHead(AbckitBasicBlock *basicBlock)
361 {
362 LIBABCKIT_CLEAR_LAST_ERROR;
363 LIBABCKIT_IMPLEMENTED;
364
365 return BBisLoopHeadStatic(basicBlock);
366 }
367
BBisLoopPrehead(AbckitBasicBlock * basicBlock)368 extern "C" bool BBisLoopPrehead(AbckitBasicBlock *basicBlock)
369 {
370 LIBABCKIT_CLEAR_LAST_ERROR;
371 LIBABCKIT_IMPLEMENTED;
372
373 return BBisLoopPreheadStatic(basicBlock);
374 }
375
BBisTryBegin(AbckitBasicBlock * basicBlock)376 extern "C" bool BBisTryBegin(AbckitBasicBlock *basicBlock)
377 {
378 LIBABCKIT_CLEAR_LAST_ERROR;
379 LIBABCKIT_IMPLEMENTED;
380
381 return BBisTryBeginStatic(basicBlock);
382 }
383
BBisTry(AbckitBasicBlock * basicBlock)384 extern "C" bool BBisTry(AbckitBasicBlock *basicBlock)
385 {
386 LIBABCKIT_CLEAR_LAST_ERROR;
387 LIBABCKIT_IMPLEMENTED;
388
389 return BBisTryStatic(basicBlock);
390 }
391
BBisTryEnd(AbckitBasicBlock * basicBlock)392 extern "C" bool BBisTryEnd(AbckitBasicBlock *basicBlock)
393 {
394 LIBABCKIT_CLEAR_LAST_ERROR;
395 LIBABCKIT_IMPLEMENTED;
396
397 return BBisTryEndStatic(basicBlock);
398 }
399
BBisCatchBegin(AbckitBasicBlock * basicBlock)400 extern "C" bool BBisCatchBegin(AbckitBasicBlock *basicBlock)
401 {
402 LIBABCKIT_CLEAR_LAST_ERROR;
403 LIBABCKIT_IMPLEMENTED;
404
405 return BBisCatchBeginStatic(basicBlock);
406 }
407
BBisCatch(AbckitBasicBlock * basicBlock)408 extern "C" bool BBisCatch(AbckitBasicBlock *basicBlock)
409 {
410 LIBABCKIT_CLEAR_LAST_ERROR;
411 LIBABCKIT_IMPLEMENTED;
412
413 return BBisCatchStatic(basicBlock);
414 }
415
BBdump(AbckitBasicBlock * basicBlock,int32_t fd)416 extern "C" void BBdump(AbckitBasicBlock *basicBlock, int32_t fd)
417 {
418 LIBABCKIT_CLEAR_LAST_ERROR;
419 LIBABCKIT_IMPLEMENTED;
420
421 BBdumpStatic(basicBlock, fd);
422 }
423
BBcreatePhi(AbckitBasicBlock * bb,size_t argCount,...)424 extern "C" AbckitInst *BBcreatePhi(AbckitBasicBlock *bb, size_t argCount, ...)
425 {
426 LIBABCKIT_CLEAR_LAST_ERROR;
427 LIBABCKIT_IMPLEMENTED;
428
429 LIBABCKIT_BAD_ARGUMENT(bb, nullptr);
430
431 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
432 std::va_list args;
433 va_start(args, argCount);
434
435 auto *inst = BBcreatePhiStatic(bb, argCount, args);
436 va_end(args);
437 return inst;
438 }
439
BBcreateCatchPhi(AbckitBasicBlock * catchBegin,size_t argCount,...)440 extern "C" AbckitInst *BBcreateCatchPhi(AbckitBasicBlock *catchBegin, size_t argCount, ...)
441 {
442 LIBABCKIT_CLEAR_LAST_ERROR;
443 LIBABCKIT_IMPLEMENTED;
444
445 LIBABCKIT_BAD_ARGUMENT(catchBegin, nullptr);
446
447 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
448 std::va_list args;
449 va_start(args, argCount);
450
451 auto inst = BBcreateCatchPhiStatic(catchBegin, argCount, args);
452 va_end(args);
453 return inst;
454 }
455
456 // ========================================
457 // Api for instruction manipulation
458 // ========================================
459
GfindOrCreateConstantI64(AbckitGraph * graph,int64_t value)460 extern "C" AbckitInst *GfindOrCreateConstantI64(AbckitGraph *graph, int64_t value)
461 {
462 LIBABCKIT_CLEAR_LAST_ERROR;
463 LIBABCKIT_IMPLEMENTED;
464
465 LIBABCKIT_BAD_ARGUMENT(graph, nullptr);
466
467 return GfindOrCreateConstantI64Static(graph, value);
468 }
469
GfindOrCreateConstantI32(AbckitGraph * graph,int32_t value)470 extern "C" AbckitInst *GfindOrCreateConstantI32(AbckitGraph *graph, int32_t value)
471 {
472 LIBABCKIT_CLEAR_LAST_ERROR;
473 LIBABCKIT_IMPLEMENTED;
474
475 LIBABCKIT_BAD_ARGUMENT(graph, nullptr);
476
477 return GfindOrCreateConstantI32Static(graph, value);
478 }
479
GfindOrCreateConstantU64(AbckitGraph * graph,uint64_t value)480 extern "C" AbckitInst *GfindOrCreateConstantU64(AbckitGraph *graph, uint64_t value)
481 {
482 LIBABCKIT_CLEAR_LAST_ERROR;
483 LIBABCKIT_IMPLEMENTED;
484
485 LIBABCKIT_BAD_ARGUMENT(graph, nullptr);
486
487 return GfindOrCreateConstantU64Static(graph, value);
488 }
489
GfindOrCreateConstantF64(AbckitGraph * graph,double value)490 extern "C" AbckitInst *GfindOrCreateConstantF64(AbckitGraph *graph, double value)
491 {
492 LIBABCKIT_CLEAR_LAST_ERROR;
493 LIBABCKIT_IMPLEMENTED;
494
495 LIBABCKIT_BAD_ARGUMENT(graph, nullptr);
496
497 return GfindOrCreateConstantF64Static(graph, value);
498 }
499
Iremove(AbckitInst * inst)500 extern "C" void Iremove(AbckitInst *inst)
501 {
502 LIBABCKIT_CLEAR_LAST_ERROR;
503 LIBABCKIT_IMPLEMENTED;
504
505 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
506
507 return IremoveStatic(inst);
508 }
509
IgetId(AbckitInst * inst)510 extern "C" uint32_t IgetId(AbckitInst *inst)
511 {
512 LIBABCKIT_CLEAR_LAST_ERROR;
513 LIBABCKIT_IMPLEMENTED;
514
515 LIBABCKIT_BAD_ARGUMENT(inst, 0);
516
517 return IgetIdStatic(inst);
518 }
519
IgetNext(AbckitInst * inst)520 extern "C" AbckitInst *IgetNext(AbckitInst *inst)
521 {
522 LIBABCKIT_CLEAR_LAST_ERROR;
523 LIBABCKIT_IMPLEMENTED;
524
525 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
526
527 return IgetNextStatic(inst);
528 }
529
IgetPrev(AbckitInst * instprev)530 extern "C" AbckitInst *IgetPrev(AbckitInst *instprev)
531 {
532 LIBABCKIT_CLEAR_LAST_ERROR;
533 LIBABCKIT_IMPLEMENTED;
534
535 LIBABCKIT_BAD_ARGUMENT(instprev, nullptr);
536
537 return IgetPrevStatic(instprev);
538 }
539
IinsertAfter(AbckitInst * inst,AbckitInst * refInst)540 extern "C" void IinsertAfter(AbckitInst *inst, AbckitInst *refInst)
541 {
542 LIBABCKIT_CLEAR_LAST_ERROR;
543 LIBABCKIT_IMPLEMENTED;
544 return IinsertAfterStatic(inst, refInst);
545 }
546
IinsertBefore(AbckitInst * inst,AbckitInst * refInst)547 extern "C" void IinsertBefore(AbckitInst *inst, AbckitInst *refInst)
548 {
549 LIBABCKIT_CLEAR_LAST_ERROR;
550 LIBABCKIT_IMPLEMENTED;
551 return IinsertBeforeStatic(inst, refInst);
552 }
553
IgetType(AbckitInst * inst)554 extern "C" AbckitType *IgetType(AbckitInst *inst)
555 {
556 LIBABCKIT_CLEAR_LAST_ERROR;
557 LIBABCKIT_IMPLEMENTED;
558
559 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
560 return IgetTypeStatic(inst);
561 }
562
IgetBasicBlock(AbckitInst * inst)563 extern "C" AbckitBasicBlock *IgetBasicBlock(AbckitInst *inst)
564 {
565 LIBABCKIT_CLEAR_LAST_ERROR;
566 LIBABCKIT_IMPLEMENTED;
567 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
568 return IgetBasicBlockStatic(inst);
569 }
570
IgetGraph(AbckitInst * inst)571 extern "C" AbckitGraph *IgetGraph(AbckitInst *inst)
572 {
573 LIBABCKIT_CLEAR_LAST_ERROR;
574 LIBABCKIT_IMPLEMENTED;
575 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
576 return IgetGraphStatic(inst);
577 }
578
IcheckIsCall(AbckitInst * inst)579 extern "C" bool IcheckIsCall(AbckitInst *inst)
580 {
581 LIBABCKIT_CLEAR_LAST_ERROR;
582 LIBABCKIT_IMPLEMENTED;
583 LIBABCKIT_BAD_ARGUMENT(inst, false);
584 return IcheckIsCallStatic(inst);
585 }
586
IcheckDominance(AbckitInst * inst,AbckitInst * dominator)587 extern "C" bool IcheckDominance(AbckitInst *inst, AbckitInst *dominator)
588 {
589 LIBABCKIT_CLEAR_LAST_ERROR;
590 LIBABCKIT_IMPLEMENTED;
591
592 LIBABCKIT_BAD_ARGUMENT(inst, false);
593 LIBABCKIT_BAD_ARGUMENT(dominator, false);
594
595 return IcheckDominanceStatic(inst, dominator);
596 }
597
IgetUserCount(AbckitInst * inst)598 extern "C" uint32_t IgetUserCount(AbckitInst *inst)
599 {
600 LIBABCKIT_CLEAR_LAST_ERROR;
601 LIBABCKIT_IMPLEMENTED;
602
603 LIBABCKIT_BAD_ARGUMENT(inst, 0);
604
605 return IgetUserCountStatic(inst);
606 }
607
IvisitUsers(AbckitInst * inst,void * data,bool (* cb)(AbckitInst * user,void * data))608 extern "C" bool IvisitUsers(AbckitInst *inst, void *data, bool (*cb)(AbckitInst *user, void *data))
609 {
610 LIBABCKIT_CLEAR_LAST_ERROR;
611 LIBABCKIT_IMPLEMENTED;
612
613 LIBABCKIT_BAD_ARGUMENT(inst, false)
614 LIBABCKIT_BAD_ARGUMENT(cb, false)
615
616 return IvisitUsersStatic(inst, data, cb);
617 }
618
IgetInputCount(AbckitInst * inst)619 extern "C" uint32_t IgetInputCount(AbckitInst *inst)
620 {
621 LIBABCKIT_CLEAR_LAST_ERROR;
622 LIBABCKIT_IMPLEMENTED;
623
624 LIBABCKIT_BAD_ARGUMENT(inst, 0);
625
626 return IgetInputCountStatic(inst);
627 }
628
IgetInput(AbckitInst * inst,uint32_t index)629 extern "C" AbckitInst *IgetInput(AbckitInst *inst, uint32_t index)
630 {
631 LIBABCKIT_CLEAR_LAST_ERROR;
632 LIBABCKIT_IMPLEMENTED;
633
634 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
635
636 return IgetInputStatic(inst, index);
637 }
638
IvisitInputs(AbckitInst * inst,void * data,bool (* cb)(AbckitInst * input,size_t inputIdx,void * data))639 extern "C" bool IvisitInputs(AbckitInst *inst, void *data, bool (*cb)(AbckitInst *input, size_t inputIdx, void *data))
640 {
641 LIBABCKIT_CLEAR_LAST_ERROR;
642 LIBABCKIT_IMPLEMENTED;
643
644 LIBABCKIT_BAD_ARGUMENT(inst, false)
645 LIBABCKIT_BAD_ARGUMENT(cb, false)
646
647 return IvisitInputsStatic(inst, data, cb);
648 }
649
IsetInput(AbckitInst * inst,AbckitInst * input,uint32_t index)650 extern "C" void IsetInput(AbckitInst *inst, AbckitInst *input, uint32_t index)
651 {
652 LIBABCKIT_CLEAR_LAST_ERROR;
653 LIBABCKIT_IMPLEMENTED;
654
655 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
656 LIBABCKIT_BAD_ARGUMENT_VOID(input);
657
658 LIBABCKIT_WRONG_CTX_VOID(inst->graph, input->graph);
659 IsetInputStatic(inst, input, index);
660 }
661
IsetInputs(AbckitInst * inst,size_t argCount,...)662 extern "C" void IsetInputs(AbckitInst *inst, size_t argCount, ...)
663 {
664 LIBABCKIT_CLEAR_LAST_ERROR;
665 LIBABCKIT_IMPLEMENTED;
666
667 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
668
669 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)
670 std::va_list args;
671 va_start(args, argCount);
672 IsetInputsStatic(inst, argCount, args);
673 va_end(args);
674 }
675
IappendInput(AbckitInst * inst,AbckitInst * input)676 extern "C" void IappendInput(AbckitInst *inst, AbckitInst *input)
677 {
678 LIBABCKIT_CLEAR_LAST_ERROR;
679 LIBABCKIT_IMPLEMENTED;
680
681 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
682 LIBABCKIT_BAD_ARGUMENT_VOID(input);
683
684 LIBABCKIT_WRONG_CTX_VOID(inst->graph, input->graph);
685 IappendInputStatic(inst, input);
686 }
687
Idump(AbckitInst * inst,int32_t fd)688 extern "C" void Idump(AbckitInst *inst, int32_t fd)
689 {
690 LIBABCKIT_CLEAR_LAST_ERROR;
691 LIBABCKIT_IMPLEMENTED;
692
693 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
694
695 IdumpStatic(inst, fd);
696 }
697
IgetFunction(AbckitInst * inst)698 extern "C" AbckitCoreFunction *IgetFunction(AbckitInst *inst)
699 {
700 LIBABCKIT_CLEAR_LAST_ERROR;
701 LIBABCKIT_IMPLEMENTED;
702
703 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
704
705 return IgetFunctionStatic(inst);
706 }
707
IsetFunction(AbckitInst * inst,AbckitCoreFunction * function)708 extern "C" void IsetFunction(AbckitInst *inst, AbckitCoreFunction *function)
709 {
710 LIBABCKIT_CLEAR_LAST_ERROR;
711 LIBABCKIT_IMPLEMENTED;
712
713 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
714 LIBABCKIT_BAD_ARGUMENT_VOID(function);
715
716 LIBABCKIT_INTERNAL_ERROR_VOID(function->owningModule);
717 LIBABCKIT_INTERNAL_ERROR_VOID(inst->graph);
718 LIBABCKIT_WRONG_CTX_VOID(inst->graph->file, function->owningModule->file);
719 return IsetFunctionStatic(inst, function);
720 }
721
IgetImmediate(AbckitInst * inst,size_t idx)722 extern "C" uint64_t IgetImmediate(AbckitInst *inst, size_t idx)
723 {
724 LIBABCKIT_CLEAR_LAST_ERROR;
725 LIBABCKIT_IMPLEMENTED;
726 LIBABCKIT_BAD_ARGUMENT(inst, 0);
727
728 return IgetImmediateStatic(inst, idx);
729 }
730
IsetImmediate(AbckitInst * inst,size_t idx,uint64_t imm)731 extern "C" void IsetImmediate(AbckitInst *inst, size_t idx, uint64_t imm)
732 {
733 LIBABCKIT_CLEAR_LAST_ERROR;
734 LIBABCKIT_IMPLEMENTED;
735 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
736
737 IsetImmediateStatic(inst, idx, imm);
738 }
739
IgetImmediateSize(AbckitInst * inst,size_t idx)740 extern "C" AbckitBitImmSize IgetImmediateSize(AbckitInst *inst, size_t idx)
741 {
742 LIBABCKIT_CLEAR_LAST_ERROR;
743 LIBABCKIT_IMPLEMENTED;
744 LIBABCKIT_BAD_ARGUMENT(inst, AbckitBitImmSize::BITSIZE_0);
745
746 return IgetImmediateSizeStatic(inst, idx);
747 }
748
IgetImmediateCount(AbckitInst * inst)749 extern "C" uint64_t IgetImmediateCount(AbckitInst *inst)
750 {
751 LIBABCKIT_CLEAR_LAST_ERROR;
752 LIBABCKIT_IMPLEMENTED;
753 LIBABCKIT_BAD_ARGUMENT(inst, 0);
754
755 return IgetImmediateCountStatic(inst);
756 }
757
IgetLiteralArray(AbckitInst * inst)758 extern "C" AbckitLiteralArray *IgetLiteralArray(AbckitInst *inst)
759 {
760 LIBABCKIT_CLEAR_LAST_ERROR;
761 LIBABCKIT_IMPLEMENTED;
762
763 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
764 return IgetLiteralArrayStatic(inst);
765 }
766
IsetLiteralArray(AbckitInst * inst,AbckitLiteralArray * la)767 extern "C" void IsetLiteralArray(AbckitInst *inst, AbckitLiteralArray *la)
768 {
769 LIBABCKIT_CLEAR_LAST_ERROR;
770 LIBABCKIT_IMPLEMENTED;
771
772 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
773 LIBABCKIT_BAD_ARGUMENT_VOID(la);
774
775 return IsetLiteralArrayStatic(inst, la);
776 }
777
IgetString(AbckitInst * inst)778 extern "C" AbckitString *IgetString(AbckitInst *inst)
779 {
780 LIBABCKIT_CLEAR_LAST_ERROR;
781 LIBABCKIT_IMPLEMENTED;
782
783 LIBABCKIT_BAD_ARGUMENT(inst, nullptr);
784
785 return IgetStringStatic(inst);
786 }
787
IsetString(AbckitInst * inst,AbckitString * str)788 extern "C" void IsetString(AbckitInst *inst, AbckitString *str)
789 {
790 LIBABCKIT_CLEAR_LAST_ERROR;
791 LIBABCKIT_IMPLEMENTED;
792
793 LIBABCKIT_BAD_ARGUMENT_VOID(inst);
794 LIBABCKIT_BAD_ARGUMENT_VOID(str);
795
796 return IsetStringStatic(inst, str);
797 }
798
IgetConstantValueI32(AbckitInst * inst)799 extern "C" int32_t IgetConstantValueI32(AbckitInst *inst)
800 {
801 LIBABCKIT_CLEAR_LAST_ERROR;
802 LIBABCKIT_IMPLEMENTED;
803 LIBABCKIT_BAD_ARGUMENT(inst, 0);
804
805 return IgetConstantValueI32Static(inst);
806 }
807
IgetConstantValueI64(AbckitInst * inst)808 extern "C" int64_t IgetConstantValueI64(AbckitInst *inst)
809 {
810 LIBABCKIT_CLEAR_LAST_ERROR;
811 LIBABCKIT_IMPLEMENTED;
812 LIBABCKIT_BAD_ARGUMENT(inst, 0);
813
814 return IgetConstantValueI64Static(inst);
815 }
816
IgetConstantValueU64(AbckitInst * inst)817 extern "C" uint64_t IgetConstantValueU64(AbckitInst *inst)
818 {
819 LIBABCKIT_CLEAR_LAST_ERROR;
820 LIBABCKIT_IMPLEMENTED;
821 LIBABCKIT_BAD_ARGUMENT(inst, 0);
822
823 return IgetConstantValueU64Static(inst);
824 }
825
IgetConstantValueF64(AbckitInst * inst)826 extern "C" double IgetConstantValueF64(AbckitInst *inst)
827 {
828 LIBABCKIT_CLEAR_LAST_ERROR;
829 LIBABCKIT_IMPLEMENTED;
830 LIBABCKIT_BAD_ARGUMENT(inst, 0);
831
832 return IgetConstantValueF64Static(inst);
833 }
834
835 AbckitGraphApi g_graphApiImpl = {
836 GgetIsa,
837 GgetFile,
838
839 // ========================================
840 // Api for Graph manipulation
841 // ========================================
842
843 GgetStartBasicBlock,
844 GgetEndBasicBlock,
845 GgetNumberOfBasicBlocks,
846 GvisitBlocksRPO,
847 GgetBasicBlock,
848 GgetParameter,
849 GgetNumberOfParameters,
850 GinsertTryCatch,
851 Gdump,
852 GfindOrCreateConstantI32,
853 GfindOrCreateConstantI64,
854 GfindOrCreateConstantU64,
855 GfindOrCreateConstantF64,
856 GrunPassRemoveUnreachableBlocks,
857
858 // ========================================
859 // Api for basic block manipulation
860 // ========================================
861
862 BBcreateEmpty,
863 BBgetId,
864 BBgetGraph,
865 BBgetPredBlockCount,
866 BBgetPredBlock,
867 BBvisitPredBlocks,
868 BBgetSuccBlockCount,
869 BBgetSuccBlock,
870 BBinsertSuccBlock,
871 BBappendSuccBlock,
872 BBdisconnectSuccBlock,
873 BBvisitSuccBlocks,
874 BBgetTrueBranch,
875 BBgetFalseBranch,
876 BBsplitBlockAfterInstruction,
877 BBaddInstFront,
878 BBaddInstBack,
879 BBremoveAllInsts,
880 BBgetFirstInst,
881 BBgetLastInst,
882 BBgetNumberOfInstructions,
883 BBgetImmediateDominator,
884 BBcheckDominance,
885 BBvisitDominatedBlocks,
886 BBisStart,
887 BBisEnd,
888 BBisLoopHead,
889 BBisLoopPrehead,
890 BBisTryBegin,
891 BBisTry,
892 BBisTryEnd,
893 BBisCatchBegin,
894 BBisCatch,
895 BBdump,
896 BBcreatePhi,
897 BBcreateCatchPhi,
898
899 // ========================================
900 // Api for instruction manipulation
901 // ========================================
902
903 Iremove,
904 IgetId,
905 IgetNext,
906 IgetPrev,
907 IinsertAfter,
908 IinsertBefore,
909 IgetType,
910 IgetBasicBlock,
911 IgetGraph,
912 IcheckDominance,
913 IcheckIsCall,
914 IgetUserCount,
915 IvisitUsers,
916 IgetInputCount,
917 IgetInput,
918 IvisitInputs,
919 IsetInput,
920 IsetInputs,
921 IappendInput,
922 Idump,
923 IgetFunction,
924 IsetFunction,
925 IgetImmediate,
926 IsetImmediate,
927 IgetImmediateSize,
928 IgetImmediateCount,
929 IgetLiteralArray,
930 IsetLiteralArray,
931 IgetString,
932 IsetString,
933 IgetConstantValueI32,
934 IgetConstantValueI64,
935 IgetConstantValueU64,
936 IgetConstantValueF64,
937 };
938
939 } // namespace libabckit
940
941 #ifdef ABCKIT_ENABLE_MOCK_IMPLEMENTATION
942 #include "./mock/abckit_mock.h"
943 #endif
944
AbckitGetGraphApiImpl(AbckitApiVersion version)945 extern "C" AbckitGraphApi const *AbckitGetGraphApiImpl(AbckitApiVersion version)
946 {
947 #ifdef ABCKIT_ENABLE_MOCK_IMPLEMENTATION
948 return AbckitGetMockGraphApiImpl(version);
949 #endif
950 switch (version) {
951 case ABCKIT_VERSION_RELEASE_1_0_0:
952 return &libabckit::g_graphApiImpl;
953 default:
954 libabckit::statuses::SetLastError(ABCKIT_STATUS_UNKNOWN_API_VERSION);
955 return nullptr;
956 }
957 }
958