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