1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements some functions that will create standard C libcalls.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/Transforms/Utils/BuildLibCalls.h"
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/Analysis/TargetLibraryInfo.h"
18 #include "llvm/IR/Constants.h"
19 #include "llvm/IR/DataLayout.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/IRBuilder.h"
22 #include "llvm/IR/Intrinsics.h"
23 #include "llvm/IR/LLVMContext.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/IR/Type.h"
29 #define DEBUG_TYPE "build-libcalls"
31 //- Infer Attributes ---------------------------------------------------------//
33 STATISTIC(NumReadNone, "Number of functions inferred as readnone");
34 STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
35 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
36 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
37 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
38 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
39 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
40 STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
42 static bool setDoesNotAccessMemory(Function &F) {
43 if (F.doesNotAccessMemory())
45 F.setDoesNotAccessMemory();
50 static bool setOnlyReadsMemory(Function &F) {
51 if (F.onlyReadsMemory())
53 F.setOnlyReadsMemory();
58 static bool setOnlyAccessesArgMemory(Function &F) {
59 if (F.onlyAccessesArgMemory())
61 F.setOnlyAccessesArgMemory();
66 static bool setDoesNotThrow(Function &F) {
74 static bool setRetDoesNotAlias(Function &F) {
75 if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
77 F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
82 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
83 if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
85 F.addParamAttr(ArgNo, Attribute::NoCapture);
90 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
91 if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
93 F.addParamAttr(ArgNo, Attribute::ReadOnly);
98 static bool setRetNonNull(Function &F) {
99 assert(F.getReturnType()->isPointerTy() &&
100 "nonnull applies only to pointers");
101 if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NonNull))
103 F.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
108 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
110 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
113 bool Changed = false;
114 switch (TheLibFunc) {
117 Changed |= setOnlyReadsMemory(F);
118 Changed |= setDoesNotThrow(F);
119 Changed |= setOnlyAccessesArgMemory(F);
120 Changed |= setDoesNotCapture(F, 0);
123 case LibFunc_strrchr:
124 Changed |= setOnlyReadsMemory(F);
125 Changed |= setDoesNotThrow(F);
130 case LibFunc_strtoul:
131 case LibFunc_strtoll:
132 case LibFunc_strtold:
133 case LibFunc_strtoull:
134 Changed |= setDoesNotThrow(F);
135 Changed |= setDoesNotCapture(F, 1);
136 Changed |= setOnlyReadsMemory(F, 0);
141 case LibFunc_strncat:
142 case LibFunc_strncpy:
143 case LibFunc_stpncpy:
144 Changed |= setDoesNotThrow(F);
145 Changed |= setDoesNotCapture(F, 1);
146 Changed |= setOnlyReadsMemory(F, 1);
148 case LibFunc_strxfrm:
149 Changed |= setDoesNotThrow(F);
150 Changed |= setDoesNotCapture(F, 0);
151 Changed |= setDoesNotCapture(F, 1);
152 Changed |= setOnlyReadsMemory(F, 1);
154 case LibFunc_strcmp: // 0,1
155 case LibFunc_strspn: // 0,1
156 case LibFunc_strncmp: // 0,1
157 case LibFunc_strcspn: // 0,1
158 case LibFunc_strcoll: // 0,1
159 case LibFunc_strcasecmp: // 0,1
160 case LibFunc_strncasecmp: //
161 Changed |= setOnlyReadsMemory(F);
162 Changed |= setDoesNotThrow(F);
163 Changed |= setDoesNotCapture(F, 0);
164 Changed |= setDoesNotCapture(F, 1);
167 case LibFunc_strpbrk:
168 Changed |= setOnlyReadsMemory(F);
169 Changed |= setDoesNotThrow(F);
170 Changed |= setDoesNotCapture(F, 1);
173 case LibFunc_strtok_r:
174 Changed |= setDoesNotThrow(F);
175 Changed |= setDoesNotCapture(F, 1);
176 Changed |= setOnlyReadsMemory(F, 1);
179 Changed |= setDoesNotThrow(F);
180 Changed |= setDoesNotCapture(F, 0);
181 Changed |= setOnlyReadsMemory(F, 0);
184 case LibFunc_setvbuf:
185 Changed |= setDoesNotThrow(F);
186 Changed |= setDoesNotCapture(F, 0);
189 case LibFunc_strndup:
190 Changed |= setDoesNotThrow(F);
191 Changed |= setRetDoesNotAlias(F);
192 Changed |= setDoesNotCapture(F, 0);
193 Changed |= setOnlyReadsMemory(F, 0);
196 case LibFunc_statvfs:
197 Changed |= setDoesNotThrow(F);
198 Changed |= setDoesNotCapture(F, 0);
199 Changed |= setDoesNotCapture(F, 1);
200 Changed |= setOnlyReadsMemory(F, 0);
203 Changed |= setDoesNotThrow(F);
204 Changed |= setDoesNotCapture(F, 0);
205 Changed |= setDoesNotCapture(F, 1);
206 Changed |= setOnlyReadsMemory(F, 0);
207 Changed |= setOnlyReadsMemory(F, 1);
209 case LibFunc_sprintf:
210 Changed |= setDoesNotThrow(F);
211 Changed |= setDoesNotCapture(F, 0);
212 Changed |= setDoesNotCapture(F, 1);
213 Changed |= setOnlyReadsMemory(F, 1);
215 case LibFunc_snprintf:
216 Changed |= setDoesNotThrow(F);
217 Changed |= setDoesNotCapture(F, 0);
218 Changed |= setDoesNotCapture(F, 2);
219 Changed |= setOnlyReadsMemory(F, 2);
221 case LibFunc_setitimer:
222 Changed |= setDoesNotThrow(F);
223 Changed |= setDoesNotCapture(F, 1);
224 Changed |= setDoesNotCapture(F, 2);
225 Changed |= setOnlyReadsMemory(F, 1);
228 // May throw; "system" is a valid pthread cancellation point.
229 Changed |= setDoesNotCapture(F, 0);
230 Changed |= setOnlyReadsMemory(F, 0);
233 Changed |= setDoesNotThrow(F);
234 Changed |= setRetDoesNotAlias(F);
237 Changed |= setOnlyReadsMemory(F);
238 Changed |= setDoesNotThrow(F);
239 Changed |= setDoesNotCapture(F, 0);
240 Changed |= setDoesNotCapture(F, 1);
243 case LibFunc_memrchr:
244 Changed |= setOnlyReadsMemory(F);
245 Changed |= setDoesNotThrow(F);
250 Changed |= setDoesNotThrow(F);
251 Changed |= setDoesNotCapture(F, 1);
254 case LibFunc_mempcpy:
255 case LibFunc_memccpy:
256 case LibFunc_memmove:
257 Changed |= setDoesNotThrow(F);
258 Changed |= setDoesNotCapture(F, 1);
259 Changed |= setOnlyReadsMemory(F, 1);
261 case LibFunc_memcpy_chk:
262 Changed |= setDoesNotThrow(F);
264 case LibFunc_memalign:
265 Changed |= setRetDoesNotAlias(F);
268 Changed |= setDoesNotThrow(F);
269 Changed |= setDoesNotCapture(F, 0);
270 Changed |= setOnlyReadsMemory(F, 0);
273 Changed |= setDoesNotThrow(F);
274 Changed |= setDoesNotCapture(F, 0);
276 case LibFunc_realloc:
277 Changed |= setDoesNotThrow(F);
278 Changed |= setRetDoesNotAlias(F);
279 Changed |= setDoesNotCapture(F, 0);
282 // May throw; "read" is a valid pthread cancellation point.
283 Changed |= setDoesNotCapture(F, 1);
286 Changed |= setDoesNotThrow(F);
287 Changed |= setDoesNotCapture(F, 0);
291 case LibFunc_realpath:
292 Changed |= setDoesNotThrow(F);
293 Changed |= setDoesNotCapture(F, 0);
294 Changed |= setOnlyReadsMemory(F, 0);
297 Changed |= setDoesNotThrow(F);
298 Changed |= setDoesNotCapture(F, 0);
299 Changed |= setDoesNotCapture(F, 1);
300 Changed |= setOnlyReadsMemory(F, 0);
301 Changed |= setOnlyReadsMemory(F, 1);
303 case LibFunc_readlink:
304 Changed |= setDoesNotThrow(F);
305 Changed |= setDoesNotCapture(F, 0);
306 Changed |= setDoesNotCapture(F, 1);
307 Changed |= setOnlyReadsMemory(F, 0);
310 // May throw; "write" is a valid pthread cancellation point.
311 Changed |= setDoesNotCapture(F, 1);
312 Changed |= setOnlyReadsMemory(F, 1);
315 Changed |= setDoesNotThrow(F);
316 Changed |= setDoesNotCapture(F, 0);
317 Changed |= setDoesNotCapture(F, 1);
318 Changed |= setOnlyReadsMemory(F, 0);
321 Changed |= setDoesNotThrow(F);
322 Changed |= setOnlyReadsMemory(F);
323 Changed |= setDoesNotCapture(F, 0);
324 Changed |= setDoesNotCapture(F, 1);
327 Changed |= setDoesNotThrow(F);
328 Changed |= setDoesNotCapture(F, 0);
331 Changed |= setDoesNotThrow(F);
332 Changed |= setRetDoesNotAlias(F);
336 Changed |= setDoesNotThrow(F);
337 Changed |= setDoesNotCapture(F, 0);
338 Changed |= setOnlyReadsMemory(F, 0);
340 case LibFunc_ctermid:
341 case LibFunc_clearerr:
342 case LibFunc_closedir:
343 Changed |= setDoesNotThrow(F);
344 Changed |= setDoesNotCapture(F, 0);
350 Changed |= setDoesNotThrow(F);
351 Changed |= setOnlyReadsMemory(F);
352 Changed |= setDoesNotCapture(F, 0);
355 Changed |= setDoesNotThrow(F);
356 Changed |= setDoesNotCapture(F, 0);
357 Changed |= setOnlyReadsMemory(F, 0);
360 Changed |= setDoesNotThrow(F);
361 Changed |= setRetDoesNotAlias(F);
362 Changed |= setDoesNotCapture(F, 0);
363 Changed |= setDoesNotCapture(F, 1);
364 Changed |= setOnlyReadsMemory(F, 0);
365 Changed |= setOnlyReadsMemory(F, 1);
368 Changed |= setDoesNotThrow(F);
369 Changed |= setRetDoesNotAlias(F);
370 Changed |= setDoesNotCapture(F, 1);
371 Changed |= setOnlyReadsMemory(F, 1);
383 case LibFunc_fsetpos:
384 case LibFunc_flockfile:
385 case LibFunc_funlockfile:
386 case LibFunc_ftrylockfile:
387 Changed |= setDoesNotThrow(F);
388 Changed |= setDoesNotCapture(F, 0);
391 Changed |= setDoesNotThrow(F);
392 Changed |= setDoesNotCapture(F, 0);
393 Changed |= setOnlyReadsMemory(F);
400 case LibFunc_fstatvfs:
401 Changed |= setDoesNotThrow(F);
402 Changed |= setDoesNotCapture(F, 1);
405 Changed |= setDoesNotThrow(F);
406 Changed |= setDoesNotCapture(F, 2);
409 Changed |= setDoesNotThrow(F);
410 Changed |= setDoesNotCapture(F, 0);
411 Changed |= setDoesNotCapture(F, 3);
414 Changed |= setDoesNotThrow(F);
415 Changed |= setDoesNotCapture(F, 0);
416 Changed |= setDoesNotCapture(F, 3);
417 // FIXME: readonly #1?
420 Changed |= setDoesNotThrow(F);
421 Changed |= setDoesNotCapture(F, 0);
422 Changed |= setDoesNotCapture(F, 1);
423 Changed |= setOnlyReadsMemory(F, 0);
426 case LibFunc_fprintf:
427 Changed |= setDoesNotThrow(F);
428 Changed |= setDoesNotCapture(F, 0);
429 Changed |= setDoesNotCapture(F, 1);
430 Changed |= setOnlyReadsMemory(F, 1);
432 case LibFunc_fgetpos:
433 Changed |= setDoesNotThrow(F);
434 Changed |= setDoesNotCapture(F, 0);
435 Changed |= setDoesNotCapture(F, 1);
438 case LibFunc_getlogin_r:
439 case LibFunc_getc_unlocked:
440 Changed |= setDoesNotThrow(F);
441 Changed |= setDoesNotCapture(F, 0);
444 Changed |= setDoesNotThrow(F);
445 Changed |= setOnlyReadsMemory(F);
446 Changed |= setDoesNotCapture(F, 0);
449 case LibFunc_getchar:
450 Changed |= setDoesNotThrow(F);
452 case LibFunc_getitimer:
453 Changed |= setDoesNotThrow(F);
454 Changed |= setDoesNotCapture(F, 1);
456 case LibFunc_getpwnam:
457 Changed |= setDoesNotThrow(F);
458 Changed |= setDoesNotCapture(F, 0);
459 Changed |= setOnlyReadsMemory(F, 0);
462 Changed |= setDoesNotThrow(F);
463 Changed |= setDoesNotCapture(F, 1);
466 Changed |= setDoesNotThrow(F);
467 Changed |= setDoesNotCapture(F, 0);
470 Changed |= setDoesNotThrow(F);
471 Changed |= setDoesNotCapture(F, 0);
472 Changed |= setOnlyReadsMemory(F, 0);
474 case LibFunc_unsetenv:
475 Changed |= setDoesNotThrow(F);
476 Changed |= setDoesNotCapture(F, 0);
477 Changed |= setOnlyReadsMemory(F, 0);
481 Changed |= setDoesNotThrow(F);
482 Changed |= setDoesNotCapture(F, 0);
483 Changed |= setDoesNotCapture(F, 1);
484 Changed |= setOnlyReadsMemory(F, 0);
485 Changed |= setOnlyReadsMemory(F, 1);
488 Changed |= setDoesNotThrow(F);
489 Changed |= setDoesNotCapture(F, 1);
494 Changed |= setDoesNotThrow(F);
495 Changed |= setDoesNotCapture(F, 0);
496 Changed |= setOnlyReadsMemory(F, 0);
499 // May throw; "pread" is a valid pthread cancellation point.
500 Changed |= setDoesNotCapture(F, 1);
503 // May throw; "pwrite" is a valid pthread cancellation point.
504 Changed |= setDoesNotCapture(F, 1);
505 Changed |= setOnlyReadsMemory(F, 1);
507 case LibFunc_putchar:
508 Changed |= setDoesNotThrow(F);
511 Changed |= setDoesNotThrow(F);
512 Changed |= setRetDoesNotAlias(F);
513 Changed |= setDoesNotCapture(F, 0);
514 Changed |= setDoesNotCapture(F, 1);
515 Changed |= setOnlyReadsMemory(F, 0);
516 Changed |= setOnlyReadsMemory(F, 1);
519 Changed |= setDoesNotThrow(F);
520 Changed |= setDoesNotCapture(F, 0);
523 Changed |= setDoesNotThrow(F);
524 Changed |= setDoesNotCapture(F, 0);
525 Changed |= setOnlyReadsMemory(F, 0);
527 case LibFunc_vsscanf:
528 Changed |= setDoesNotThrow(F);
529 Changed |= setDoesNotCapture(F, 0);
530 Changed |= setDoesNotCapture(F, 1);
531 Changed |= setOnlyReadsMemory(F, 0);
532 Changed |= setOnlyReadsMemory(F, 1);
534 case LibFunc_vfscanf:
535 Changed |= setDoesNotThrow(F);
536 Changed |= setDoesNotCapture(F, 0);
537 Changed |= setDoesNotCapture(F, 1);
538 Changed |= setOnlyReadsMemory(F, 1);
541 Changed |= setDoesNotThrow(F);
542 Changed |= setRetDoesNotAlias(F);
544 case LibFunc_vprintf:
545 Changed |= setDoesNotThrow(F);
546 Changed |= setDoesNotCapture(F, 0);
547 Changed |= setOnlyReadsMemory(F, 0);
549 case LibFunc_vfprintf:
550 case LibFunc_vsprintf:
551 Changed |= setDoesNotThrow(F);
552 Changed |= setDoesNotCapture(F, 0);
553 Changed |= setDoesNotCapture(F, 1);
554 Changed |= setOnlyReadsMemory(F, 1);
556 case LibFunc_vsnprintf:
557 Changed |= setDoesNotThrow(F);
558 Changed |= setDoesNotCapture(F, 0);
559 Changed |= setDoesNotCapture(F, 2);
560 Changed |= setOnlyReadsMemory(F, 2);
563 // May throw; "open" is a valid pthread cancellation point.
564 Changed |= setDoesNotCapture(F, 0);
565 Changed |= setOnlyReadsMemory(F, 0);
567 case LibFunc_opendir:
568 Changed |= setDoesNotThrow(F);
569 Changed |= setRetDoesNotAlias(F);
570 Changed |= setDoesNotCapture(F, 0);
571 Changed |= setOnlyReadsMemory(F, 0);
573 case LibFunc_tmpfile:
574 Changed |= setDoesNotThrow(F);
575 Changed |= setRetDoesNotAlias(F);
578 Changed |= setDoesNotThrow(F);
579 Changed |= setDoesNotCapture(F, 0);
585 Changed |= setDoesNotThrow(F);
586 Changed |= setDoesNotAccessMemory(F);
589 Changed |= setDoesNotThrow(F);
590 Changed |= setDoesNotCapture(F, 0);
591 Changed |= setDoesNotCapture(F, 1);
592 Changed |= setOnlyReadsMemory(F, 0);
595 Changed |= setDoesNotThrow(F);
596 Changed |= setDoesNotCapture(F, 0);
597 Changed |= setOnlyReadsMemory(F, 0);
600 // May throw; places call through function pointer.
601 Changed |= setDoesNotCapture(F, 3);
603 case LibFunc_dunder_strdup:
604 case LibFunc_dunder_strndup:
605 Changed |= setDoesNotThrow(F);
606 Changed |= setRetDoesNotAlias(F);
607 Changed |= setDoesNotCapture(F, 0);
608 Changed |= setOnlyReadsMemory(F, 0);
610 case LibFunc_dunder_strtok_r:
611 Changed |= setDoesNotThrow(F);
612 Changed |= setDoesNotCapture(F, 1);
613 Changed |= setOnlyReadsMemory(F, 1);
615 case LibFunc_under_IO_getc:
616 Changed |= setDoesNotThrow(F);
617 Changed |= setDoesNotCapture(F, 0);
619 case LibFunc_under_IO_putc:
620 Changed |= setDoesNotThrow(F);
621 Changed |= setDoesNotCapture(F, 1);
623 case LibFunc_dunder_isoc99_scanf:
624 Changed |= setDoesNotThrow(F);
625 Changed |= setDoesNotCapture(F, 0);
626 Changed |= setOnlyReadsMemory(F, 0);
629 case LibFunc_lstat64:
630 case LibFunc_statvfs64:
631 Changed |= setDoesNotThrow(F);
632 Changed |= setDoesNotCapture(F, 0);
633 Changed |= setDoesNotCapture(F, 1);
634 Changed |= setOnlyReadsMemory(F, 0);
636 case LibFunc_dunder_isoc99_sscanf:
637 Changed |= setDoesNotThrow(F);
638 Changed |= setDoesNotCapture(F, 0);
639 Changed |= setDoesNotCapture(F, 1);
640 Changed |= setOnlyReadsMemory(F, 0);
641 Changed |= setOnlyReadsMemory(F, 1);
643 case LibFunc_fopen64:
644 Changed |= setDoesNotThrow(F);
645 Changed |= setRetDoesNotAlias(F);
646 Changed |= setDoesNotCapture(F, 0);
647 Changed |= setDoesNotCapture(F, 1);
648 Changed |= setOnlyReadsMemory(F, 0);
649 Changed |= setOnlyReadsMemory(F, 1);
651 case LibFunc_fseeko64:
652 case LibFunc_ftello64:
653 Changed |= setDoesNotThrow(F);
654 Changed |= setDoesNotCapture(F, 0);
656 case LibFunc_tmpfile64:
657 Changed |= setDoesNotThrow(F);
658 Changed |= setRetDoesNotAlias(F);
660 case LibFunc_fstat64:
661 case LibFunc_fstatvfs64:
662 Changed |= setDoesNotThrow(F);
663 Changed |= setDoesNotCapture(F, 1);
666 // May throw; "open" is a valid pthread cancellation point.
667 Changed |= setDoesNotCapture(F, 0);
668 Changed |= setOnlyReadsMemory(F, 0);
670 case LibFunc_gettimeofday:
671 // Currently some platforms have the restrict keyword on the arguments to
672 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
674 Changed |= setDoesNotThrow(F);
675 Changed |= setDoesNotCapture(F, 0);
676 Changed |= setDoesNotCapture(F, 1);
678 case LibFunc_Znwj: // new(unsigned int)
679 case LibFunc_Znwm: // new(unsigned long)
680 case LibFunc_Znaj: // new[](unsigned int)
681 case LibFunc_Znam: // new[](unsigned long)
682 case LibFunc_msvc_new_int: // new(unsigned int)
683 case LibFunc_msvc_new_longlong: // new(unsigned long long)
684 case LibFunc_msvc_new_array_int: // new[](unsigned int)
685 case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
686 // Operator new always returns a nonnull noalias pointer
687 Changed |= setRetNonNull(F);
688 Changed |= setRetDoesNotAlias(F);
690 //TODO: add LibFunc entries for:
691 //case LibFunc_memset_pattern4:
692 //case LibFunc_memset_pattern8:
693 case LibFunc_memset_pattern16:
694 Changed |= setOnlyAccessesArgMemory(F);
695 Changed |= setDoesNotCapture(F, 0);
696 Changed |= setDoesNotCapture(F, 1);
697 Changed |= setOnlyReadsMemory(F, 1);
699 // int __nvvm_reflect(const char *)
700 case LibFunc_nvvm_reflect:
701 Changed |= setDoesNotAccessMemory(F);
702 Changed |= setDoesNotThrow(F);
706 // FIXME: It'd be really nice to cover all the library functions we're
712 //- Emit LibCalls ------------------------------------------------------------//
714 Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
715 unsigned AS = V->getType()->getPointerAddressSpace();
716 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
719 Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
720 const TargetLibraryInfo *TLI) {
721 if (!TLI->has(LibFunc_strlen))
724 Module *M = B.GetInsertBlock()->getModule();
725 LLVMContext &Context = B.GetInsertBlock()->getContext();
726 Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),
728 inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);
729 CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");
730 if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
731 CI->setCallingConv(F->getCallingConv());
736 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
737 const TargetLibraryInfo *TLI) {
738 if (!TLI->has(LibFunc_strchr))
741 Module *M = B.GetInsertBlock()->getModule();
742 Type *I8Ptr = B.getInt8PtrTy();
743 Type *I32Ty = B.getInt32Ty();
745 M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty);
746 inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);
747 CallInst *CI = B.CreateCall(
748 StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");
749 if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
750 CI->setCallingConv(F->getCallingConv());
754 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
755 const DataLayout &DL, const TargetLibraryInfo *TLI) {
756 if (!TLI->has(LibFunc_strncmp))
759 Module *M = B.GetInsertBlock()->getModule();
760 LLVMContext &Context = B.GetInsertBlock()->getContext();
761 Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),
762 B.getInt8PtrTy(), B.getInt8PtrTy(),
763 DL.getIntPtrType(Context));
764 inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);
765 CallInst *CI = B.CreateCall(
766 StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");
768 if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
769 CI->setCallingConv(F->getCallingConv());
774 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
775 const TargetLibraryInfo *TLI, StringRef Name) {
776 if (!TLI->has(LibFunc_strcpy))
779 Module *M = B.GetInsertBlock()->getModule();
780 Type *I8Ptr = B.getInt8PtrTy();
781 Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr);
782 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
784 B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
785 if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
786 CI->setCallingConv(F->getCallingConv());
790 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
791 const TargetLibraryInfo *TLI, StringRef Name) {
792 if (!TLI->has(LibFunc_strncpy))
795 Module *M = B.GetInsertBlock()->getModule();
796 Type *I8Ptr = B.getInt8PtrTy();
797 Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
799 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
800 CallInst *CI = B.CreateCall(
801 StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");
802 if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
803 CI->setCallingConv(F->getCallingConv());
807 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
808 IRBuilder<> &B, const DataLayout &DL,
809 const TargetLibraryInfo *TLI) {
810 if (!TLI->has(LibFunc_memcpy_chk))
813 Module *M = B.GetInsertBlock()->getModule();
815 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
816 Attribute::NoUnwind);
817 LLVMContext &Context = B.GetInsertBlock()->getContext();
818 Value *MemCpy = M->getOrInsertFunction(
819 "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
820 B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
821 DL.getIntPtrType(Context));
822 Dst = castToCStr(Dst, B);
823 Src = castToCStr(Src, B);
824 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
825 if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
826 CI->setCallingConv(F->getCallingConv());
830 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
831 const DataLayout &DL, const TargetLibraryInfo *TLI) {
832 if (!TLI->has(LibFunc_memchr))
835 Module *M = B.GetInsertBlock()->getModule();
836 LLVMContext &Context = B.GetInsertBlock()->getContext();
837 Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),
838 B.getInt8PtrTy(), B.getInt32Ty(),
839 DL.getIntPtrType(Context));
840 inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);
841 CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");
843 if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
844 CI->setCallingConv(F->getCallingConv());
849 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
850 const DataLayout &DL, const TargetLibraryInfo *TLI) {
851 if (!TLI->has(LibFunc_memcmp))
854 Module *M = B.GetInsertBlock()->getModule();
855 LLVMContext &Context = B.GetInsertBlock()->getContext();
856 Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),
857 B.getInt8PtrTy(), B.getInt8PtrTy(),
858 DL.getIntPtrType(Context));
859 inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);
860 CallInst *CI = B.CreateCall(
861 MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "memcmp");
863 if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
864 CI->setCallingConv(F->getCallingConv());
869 /// Append a suffix to the function name according to the type of 'Op'.
870 static void appendTypeSuffix(Value *Op, StringRef &Name,
871 SmallString<20> &NameBuffer) {
872 if (!Op->getType()->isDoubleTy()) {
875 if (Op->getType()->isFloatTy())
884 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
885 const AttributeList &Attrs) {
886 SmallString<20> NameBuffer;
887 appendTypeSuffix(Op, Name, NameBuffer);
889 Module *M = B.GetInsertBlock()->getModule();
890 Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
892 CallInst *CI = B.CreateCall(Callee, Op, Name);
894 // The incoming attribute set may have come from a speculatable intrinsic, but
895 // is being replaced with a library call which is not allowed to be
897 CI->setAttributes(Attrs.removeAttribute(B.getContext(),
898 AttributeList::FunctionIndex,
899 Attribute::Speculatable));
900 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
901 CI->setCallingConv(F->getCallingConv());
906 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
907 IRBuilder<> &B, const AttributeList &Attrs) {
908 SmallString<20> NameBuffer;
909 appendTypeSuffix(Op1, Name, NameBuffer);
911 Module *M = B.GetInsertBlock()->getModule();
912 Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
914 CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
915 CI->setAttributes(Attrs);
916 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
917 CI->setCallingConv(F->getCallingConv());
922 Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
923 const TargetLibraryInfo *TLI) {
924 if (!TLI->has(LibFunc_putchar))
927 Module *M = B.GetInsertBlock()->getModule();
928 Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(), B.getInt32Ty());
929 inferLibFuncAttributes(*M->getFunction("putchar"), *TLI);
930 CallInst *CI = B.CreateCall(PutChar,
931 B.CreateIntCast(Char,
937 if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
938 CI->setCallingConv(F->getCallingConv());
942 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
943 const TargetLibraryInfo *TLI) {
944 if (!TLI->has(LibFunc_puts))
947 Module *M = B.GetInsertBlock()->getModule();
949 M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy());
950 inferLibFuncAttributes(*M->getFunction("puts"), *TLI);
951 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");
952 if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
953 CI->setCallingConv(F->getCallingConv());
957 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
958 const TargetLibraryInfo *TLI) {
959 if (!TLI->has(LibFunc_fputc))
962 Module *M = B.GetInsertBlock()->getModule();
963 Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),
965 if (File->getType()->isPointerTy())
966 inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);
967 Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
969 CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
971 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
972 CI->setCallingConv(Fn->getCallingConv());
976 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
977 const TargetLibraryInfo *TLI) {
978 if (!TLI->has(LibFunc_fputs))
981 Module *M = B.GetInsertBlock()->getModule();
982 StringRef FPutsName = TLI->getName(LibFunc_fputs);
983 Constant *F = M->getOrInsertFunction(
984 FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());
985 if (File->getType()->isPointerTy())
986 inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
987 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
989 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
990 CI->setCallingConv(Fn->getCallingConv());
994 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
995 const DataLayout &DL, const TargetLibraryInfo *TLI) {
996 if (!TLI->has(LibFunc_fwrite))
999 Module *M = B.GetInsertBlock()->getModule();
1000 LLVMContext &Context = B.GetInsertBlock()->getContext();
1001 StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1002 Constant *F = M->getOrInsertFunction(
1003 FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1004 DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1006 if (File->getType()->isPointerTy())
1007 inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
1009 B.CreateCall(F, {castToCStr(Ptr, B), Size,
1010 ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1012 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1013 CI->setCallingConv(Fn->getCallingConv());