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 setDoesNotCapture(Function &F, unsigned n) {
75 if (F.doesNotCapture(n))
77 F.setDoesNotCapture(n);
82 static bool setOnlyReadsMemory(Function &F, unsigned n) {
83 if (F.onlyReadsMemory(n))
85 F.setOnlyReadsMemory(n);
90 static bool setDoesNotAlias(Function &F, unsigned n) {
91 if (F.doesNotAlias(n))
98 static bool setNonNull(Function &F, unsigned n) {
100 (n != AttributeList::ReturnIndex || F.getReturnType()->isPointerTy()) &&
101 "nonnull applies only to pointers");
102 if (F.getAttributes().hasAttribute(n, Attribute::NonNull))
104 F.addAttribute(n, Attribute::NonNull);
109 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
111 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
114 bool Changed = false;
115 switch (TheLibFunc) {
117 Changed |= setOnlyReadsMemory(F);
118 Changed |= setDoesNotThrow(F);
119 Changed |= setDoesNotCapture(F, 1);
122 case LibFunc_strrchr:
123 Changed |= setOnlyReadsMemory(F);
124 Changed |= setDoesNotThrow(F);
129 case LibFunc_strtoul:
130 case LibFunc_strtoll:
131 case LibFunc_strtold:
132 case LibFunc_strtoull:
133 Changed |= setDoesNotThrow(F);
134 Changed |= setDoesNotCapture(F, 2);
135 Changed |= setOnlyReadsMemory(F, 1);
140 case LibFunc_strncat:
141 case LibFunc_strncpy:
142 case LibFunc_stpncpy:
143 Changed |= setDoesNotThrow(F);
144 Changed |= setDoesNotCapture(F, 2);
145 Changed |= setOnlyReadsMemory(F, 2);
147 case LibFunc_strxfrm:
148 Changed |= setDoesNotThrow(F);
149 Changed |= setDoesNotCapture(F, 1);
150 Changed |= setDoesNotCapture(F, 2);
151 Changed |= setOnlyReadsMemory(F, 2);
153 case LibFunc_strcmp: // 0,1
154 case LibFunc_strspn: // 0,1
155 case LibFunc_strncmp: // 0,1
156 case LibFunc_strcspn: // 0,1
157 case LibFunc_strcoll: // 0,1
158 case LibFunc_strcasecmp: // 0,1
159 case LibFunc_strncasecmp: //
160 Changed |= setOnlyReadsMemory(F);
161 Changed |= setDoesNotThrow(F);
162 Changed |= setDoesNotCapture(F, 1);
163 Changed |= setDoesNotCapture(F, 2);
166 case LibFunc_strpbrk:
167 Changed |= setOnlyReadsMemory(F);
168 Changed |= setDoesNotThrow(F);
169 Changed |= setDoesNotCapture(F, 2);
172 case LibFunc_strtok_r:
173 Changed |= setDoesNotThrow(F);
174 Changed |= setDoesNotCapture(F, 2);
175 Changed |= setOnlyReadsMemory(F, 2);
178 Changed |= setDoesNotThrow(F);
179 Changed |= setDoesNotCapture(F, 1);
180 Changed |= setOnlyReadsMemory(F, 1);
183 case LibFunc_setvbuf:
184 Changed |= setDoesNotThrow(F);
185 Changed |= setDoesNotCapture(F, 1);
188 case LibFunc_strndup:
189 Changed |= setDoesNotThrow(F);
190 Changed |= setDoesNotAlias(F, 0);
191 Changed |= setDoesNotCapture(F, 1);
192 Changed |= setOnlyReadsMemory(F, 1);
195 case LibFunc_statvfs:
196 Changed |= setDoesNotThrow(F);
197 Changed |= setDoesNotCapture(F, 1);
198 Changed |= setDoesNotCapture(F, 2);
199 Changed |= setOnlyReadsMemory(F, 1);
202 Changed |= setDoesNotThrow(F);
203 Changed |= setDoesNotCapture(F, 1);
204 Changed |= setDoesNotCapture(F, 2);
205 Changed |= setOnlyReadsMemory(F, 1);
206 Changed |= setOnlyReadsMemory(F, 2);
208 case LibFunc_sprintf:
209 Changed |= setDoesNotThrow(F);
210 Changed |= setDoesNotCapture(F, 1);
211 Changed |= setDoesNotCapture(F, 2);
212 Changed |= setOnlyReadsMemory(F, 2);
214 case LibFunc_snprintf:
215 Changed |= setDoesNotThrow(F);
216 Changed |= setDoesNotCapture(F, 1);
217 Changed |= setDoesNotCapture(F, 3);
218 Changed |= setOnlyReadsMemory(F, 3);
220 case LibFunc_setitimer:
221 Changed |= setDoesNotThrow(F);
222 Changed |= setDoesNotCapture(F, 2);
223 Changed |= setDoesNotCapture(F, 3);
224 Changed |= setOnlyReadsMemory(F, 2);
227 // May throw; "system" is a valid pthread cancellation point.
228 Changed |= setDoesNotCapture(F, 1);
229 Changed |= setOnlyReadsMemory(F, 1);
232 Changed |= setDoesNotThrow(F);
233 Changed |= setDoesNotAlias(F, 0);
236 Changed |= setOnlyReadsMemory(F);
237 Changed |= setDoesNotThrow(F);
238 Changed |= setDoesNotCapture(F, 1);
239 Changed |= setDoesNotCapture(F, 2);
242 case LibFunc_memrchr:
243 Changed |= setOnlyReadsMemory(F);
244 Changed |= setDoesNotThrow(F);
249 Changed |= setDoesNotThrow(F);
250 Changed |= setDoesNotCapture(F, 2);
253 case LibFunc_mempcpy:
254 case LibFunc_memccpy:
255 case LibFunc_memmove:
256 Changed |= setDoesNotThrow(F);
257 Changed |= setDoesNotCapture(F, 2);
258 Changed |= setOnlyReadsMemory(F, 2);
260 case LibFunc_memcpy_chk:
261 Changed |= setDoesNotThrow(F);
263 case LibFunc_memalign:
264 Changed |= setDoesNotAlias(F, 0);
267 Changed |= setDoesNotThrow(F);
268 Changed |= setDoesNotCapture(F, 1);
269 Changed |= setOnlyReadsMemory(F, 1);
272 Changed |= setDoesNotThrow(F);
273 Changed |= setDoesNotCapture(F, 1);
275 case LibFunc_realloc:
276 Changed |= setDoesNotThrow(F);
277 Changed |= setDoesNotAlias(F, 0);
278 Changed |= setDoesNotCapture(F, 1);
281 // May throw; "read" is a valid pthread cancellation point.
282 Changed |= setDoesNotCapture(F, 2);
285 Changed |= setDoesNotThrow(F);
286 Changed |= setDoesNotCapture(F, 1);
290 case LibFunc_realpath:
291 Changed |= setDoesNotThrow(F);
292 Changed |= setDoesNotCapture(F, 1);
293 Changed |= setOnlyReadsMemory(F, 1);
296 Changed |= setDoesNotThrow(F);
297 Changed |= setDoesNotCapture(F, 1);
298 Changed |= setDoesNotCapture(F, 2);
299 Changed |= setOnlyReadsMemory(F, 1);
300 Changed |= setOnlyReadsMemory(F, 2);
302 case LibFunc_readlink:
303 Changed |= setDoesNotThrow(F);
304 Changed |= setDoesNotCapture(F, 1);
305 Changed |= setDoesNotCapture(F, 2);
306 Changed |= setOnlyReadsMemory(F, 1);
309 // May throw; "write" is a valid pthread cancellation point.
310 Changed |= setDoesNotCapture(F, 2);
311 Changed |= setOnlyReadsMemory(F, 2);
314 Changed |= setDoesNotThrow(F);
315 Changed |= setDoesNotCapture(F, 1);
316 Changed |= setDoesNotCapture(F, 2);
317 Changed |= setOnlyReadsMemory(F, 1);
320 Changed |= setDoesNotThrow(F);
321 Changed |= setOnlyReadsMemory(F);
322 Changed |= setDoesNotCapture(F, 1);
323 Changed |= setDoesNotCapture(F, 2);
326 Changed |= setDoesNotThrow(F);
327 Changed |= setDoesNotCapture(F, 1);
330 Changed |= setDoesNotThrow(F);
331 Changed |= setDoesNotAlias(F, 0);
335 Changed |= setDoesNotThrow(F);
336 Changed |= setDoesNotCapture(F, 1);
337 Changed |= setOnlyReadsMemory(F, 1);
339 case LibFunc_ctermid:
340 case LibFunc_clearerr:
341 case LibFunc_closedir:
342 Changed |= setDoesNotThrow(F);
343 Changed |= setDoesNotCapture(F, 1);
349 Changed |= setDoesNotThrow(F);
350 Changed |= setOnlyReadsMemory(F);
351 Changed |= setDoesNotCapture(F, 1);
354 Changed |= setDoesNotThrow(F);
355 Changed |= setDoesNotCapture(F, 1);
356 Changed |= setOnlyReadsMemory(F, 1);
359 Changed |= setDoesNotThrow(F);
360 Changed |= setDoesNotAlias(F, 0);
361 Changed |= setDoesNotCapture(F, 1);
362 Changed |= setDoesNotCapture(F, 2);
363 Changed |= setOnlyReadsMemory(F, 1);
364 Changed |= setOnlyReadsMemory(F, 2);
367 Changed |= setDoesNotThrow(F);
368 Changed |= setDoesNotAlias(F, 0);
369 Changed |= setDoesNotCapture(F, 2);
370 Changed |= setOnlyReadsMemory(F, 2);
382 case LibFunc_fsetpos:
383 case LibFunc_flockfile:
384 case LibFunc_funlockfile:
385 case LibFunc_ftrylockfile:
386 Changed |= setDoesNotThrow(F);
387 Changed |= setDoesNotCapture(F, 1);
390 Changed |= setDoesNotThrow(F);
391 Changed |= setDoesNotCapture(F, 1);
392 Changed |= setOnlyReadsMemory(F);
399 case LibFunc_fstatvfs:
400 Changed |= setDoesNotThrow(F);
401 Changed |= setDoesNotCapture(F, 2);
404 Changed |= setDoesNotThrow(F);
405 Changed |= setDoesNotCapture(F, 3);
408 Changed |= setDoesNotThrow(F);
409 Changed |= setDoesNotCapture(F, 1);
410 Changed |= setDoesNotCapture(F, 4);
413 Changed |= setDoesNotThrow(F);
414 Changed |= setDoesNotCapture(F, 1);
415 Changed |= setDoesNotCapture(F, 4);
416 // FIXME: readonly #1?
419 Changed |= setDoesNotThrow(F);
420 Changed |= setDoesNotCapture(F, 1);
421 Changed |= setDoesNotCapture(F, 2);
422 Changed |= setOnlyReadsMemory(F, 1);
425 case LibFunc_fprintf:
426 Changed |= setDoesNotThrow(F);
427 Changed |= setDoesNotCapture(F, 1);
428 Changed |= setDoesNotCapture(F, 2);
429 Changed |= setOnlyReadsMemory(F, 2);
431 case LibFunc_fgetpos:
432 Changed |= setDoesNotThrow(F);
433 Changed |= setDoesNotCapture(F, 1);
434 Changed |= setDoesNotCapture(F, 2);
437 case LibFunc_getlogin_r:
438 case LibFunc_getc_unlocked:
439 Changed |= setDoesNotThrow(F);
440 Changed |= setDoesNotCapture(F, 1);
443 Changed |= setDoesNotThrow(F);
444 Changed |= setOnlyReadsMemory(F);
445 Changed |= setDoesNotCapture(F, 1);
448 case LibFunc_getchar:
449 Changed |= setDoesNotThrow(F);
451 case LibFunc_getitimer:
452 Changed |= setDoesNotThrow(F);
453 Changed |= setDoesNotCapture(F, 2);
455 case LibFunc_getpwnam:
456 Changed |= setDoesNotThrow(F);
457 Changed |= setDoesNotCapture(F, 1);
458 Changed |= setOnlyReadsMemory(F, 1);
461 Changed |= setDoesNotThrow(F);
462 Changed |= setDoesNotCapture(F, 2);
465 Changed |= setDoesNotThrow(F);
466 Changed |= setDoesNotCapture(F, 1);
469 Changed |= setDoesNotThrow(F);
470 Changed |= setDoesNotCapture(F, 1);
471 Changed |= setOnlyReadsMemory(F, 1);
473 case LibFunc_unsetenv:
474 Changed |= setDoesNotThrow(F);
475 Changed |= setDoesNotCapture(F, 1);
476 Changed |= setOnlyReadsMemory(F, 1);
480 Changed |= setDoesNotThrow(F);
481 Changed |= setDoesNotCapture(F, 1);
482 Changed |= setDoesNotCapture(F, 2);
483 Changed |= setOnlyReadsMemory(F, 1);
484 Changed |= setOnlyReadsMemory(F, 2);
487 Changed |= setDoesNotThrow(F);
488 Changed |= setDoesNotCapture(F, 2);
493 Changed |= setDoesNotThrow(F);
494 Changed |= setDoesNotCapture(F, 1);
495 Changed |= setOnlyReadsMemory(F, 1);
498 // May throw; "pread" is a valid pthread cancellation point.
499 Changed |= setDoesNotCapture(F, 2);
502 // May throw; "pwrite" is a valid pthread cancellation point.
503 Changed |= setDoesNotCapture(F, 2);
504 Changed |= setOnlyReadsMemory(F, 2);
506 case LibFunc_putchar:
507 Changed |= setDoesNotThrow(F);
510 Changed |= setDoesNotThrow(F);
511 Changed |= setDoesNotAlias(F, 0);
512 Changed |= setDoesNotCapture(F, 1);
513 Changed |= setDoesNotCapture(F, 2);
514 Changed |= setOnlyReadsMemory(F, 1);
515 Changed |= setOnlyReadsMemory(F, 2);
518 Changed |= setDoesNotThrow(F);
519 Changed |= setDoesNotCapture(F, 1);
522 Changed |= setDoesNotThrow(F);
523 Changed |= setDoesNotCapture(F, 1);
524 Changed |= setOnlyReadsMemory(F, 1);
526 case LibFunc_vsscanf:
527 Changed |= setDoesNotThrow(F);
528 Changed |= setDoesNotCapture(F, 1);
529 Changed |= setDoesNotCapture(F, 2);
530 Changed |= setOnlyReadsMemory(F, 1);
531 Changed |= setOnlyReadsMemory(F, 2);
533 case LibFunc_vfscanf:
534 Changed |= setDoesNotThrow(F);
535 Changed |= setDoesNotCapture(F, 1);
536 Changed |= setDoesNotCapture(F, 2);
537 Changed |= setOnlyReadsMemory(F, 2);
540 Changed |= setDoesNotThrow(F);
541 Changed |= setDoesNotAlias(F, 0);
543 case LibFunc_vprintf:
544 Changed |= setDoesNotThrow(F);
545 Changed |= setDoesNotCapture(F, 1);
546 Changed |= setOnlyReadsMemory(F, 1);
548 case LibFunc_vfprintf:
549 case LibFunc_vsprintf:
550 Changed |= setDoesNotThrow(F);
551 Changed |= setDoesNotCapture(F, 1);
552 Changed |= setDoesNotCapture(F, 2);
553 Changed |= setOnlyReadsMemory(F, 2);
555 case LibFunc_vsnprintf:
556 Changed |= setDoesNotThrow(F);
557 Changed |= setDoesNotCapture(F, 1);
558 Changed |= setDoesNotCapture(F, 3);
559 Changed |= setOnlyReadsMemory(F, 3);
562 // May throw; "open" is a valid pthread cancellation point.
563 Changed |= setDoesNotCapture(F, 1);
564 Changed |= setOnlyReadsMemory(F, 1);
566 case LibFunc_opendir:
567 Changed |= setDoesNotThrow(F);
568 Changed |= setDoesNotAlias(F, 0);
569 Changed |= setDoesNotCapture(F, 1);
570 Changed |= setOnlyReadsMemory(F, 1);
572 case LibFunc_tmpfile:
573 Changed |= setDoesNotThrow(F);
574 Changed |= setDoesNotAlias(F, 0);
577 Changed |= setDoesNotThrow(F);
578 Changed |= setDoesNotCapture(F, 1);
584 Changed |= setDoesNotThrow(F);
585 Changed |= setDoesNotAccessMemory(F);
588 Changed |= setDoesNotThrow(F);
589 Changed |= setDoesNotCapture(F, 1);
590 Changed |= setDoesNotCapture(F, 2);
591 Changed |= setOnlyReadsMemory(F, 1);
594 Changed |= setDoesNotThrow(F);
595 Changed |= setDoesNotCapture(F, 1);
596 Changed |= setOnlyReadsMemory(F, 1);
599 // May throw; places call through function pointer.
600 Changed |= setDoesNotCapture(F, 4);
602 case LibFunc_dunder_strdup:
603 case LibFunc_dunder_strndup:
604 Changed |= setDoesNotThrow(F);
605 Changed |= setDoesNotAlias(F, 0);
606 Changed |= setDoesNotCapture(F, 1);
607 Changed |= setOnlyReadsMemory(F, 1);
609 case LibFunc_dunder_strtok_r:
610 Changed |= setDoesNotThrow(F);
611 Changed |= setDoesNotCapture(F, 2);
612 Changed |= setOnlyReadsMemory(F, 2);
614 case LibFunc_under_IO_getc:
615 Changed |= setDoesNotThrow(F);
616 Changed |= setDoesNotCapture(F, 1);
618 case LibFunc_under_IO_putc:
619 Changed |= setDoesNotThrow(F);
620 Changed |= setDoesNotCapture(F, 2);
622 case LibFunc_dunder_isoc99_scanf:
623 Changed |= setDoesNotThrow(F);
624 Changed |= setDoesNotCapture(F, 1);
625 Changed |= setOnlyReadsMemory(F, 1);
628 case LibFunc_lstat64:
629 case LibFunc_statvfs64:
630 Changed |= setDoesNotThrow(F);
631 Changed |= setDoesNotCapture(F, 1);
632 Changed |= setDoesNotCapture(F, 2);
633 Changed |= setOnlyReadsMemory(F, 1);
635 case LibFunc_dunder_isoc99_sscanf:
636 Changed |= setDoesNotThrow(F);
637 Changed |= setDoesNotCapture(F, 1);
638 Changed |= setDoesNotCapture(F, 2);
639 Changed |= setOnlyReadsMemory(F, 1);
640 Changed |= setOnlyReadsMemory(F, 2);
642 case LibFunc_fopen64:
643 Changed |= setDoesNotThrow(F);
644 Changed |= setDoesNotAlias(F, 0);
645 Changed |= setDoesNotCapture(F, 1);
646 Changed |= setDoesNotCapture(F, 2);
647 Changed |= setOnlyReadsMemory(F, 1);
648 Changed |= setOnlyReadsMemory(F, 2);
650 case LibFunc_fseeko64:
651 case LibFunc_ftello64:
652 Changed |= setDoesNotThrow(F);
653 Changed |= setDoesNotCapture(F, 1);
655 case LibFunc_tmpfile64:
656 Changed |= setDoesNotThrow(F);
657 Changed |= setDoesNotAlias(F, 0);
659 case LibFunc_fstat64:
660 case LibFunc_fstatvfs64:
661 Changed |= setDoesNotThrow(F);
662 Changed |= setDoesNotCapture(F, 2);
665 // May throw; "open" is a valid pthread cancellation point.
666 Changed |= setDoesNotCapture(F, 1);
667 Changed |= setOnlyReadsMemory(F, 1);
669 case LibFunc_gettimeofday:
670 // Currently some platforms have the restrict keyword on the arguments to
671 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
673 Changed |= setDoesNotThrow(F);
674 Changed |= setDoesNotCapture(F, 1);
675 Changed |= setDoesNotCapture(F, 2);
677 case LibFunc_Znwj: // new(unsigned int)
678 case LibFunc_Znwm: // new(unsigned long)
679 case LibFunc_Znaj: // new[](unsigned int)
680 case LibFunc_Znam: // new[](unsigned long)
681 case LibFunc_msvc_new_int: // new(unsigned int)
682 case LibFunc_msvc_new_longlong: // new(unsigned long long)
683 case LibFunc_msvc_new_array_int: // new[](unsigned int)
684 case LibFunc_msvc_new_array_longlong: // new[](unsigned long long)
685 // Operator new always returns a nonnull noalias pointer
686 Changed |= setNonNull(F, AttributeList::ReturnIndex);
687 Changed |= setDoesNotAlias(F, AttributeList::ReturnIndex);
689 //TODO: add LibFunc entries for:
690 //case LibFunc_memset_pattern4:
691 //case LibFunc_memset_pattern8:
692 case LibFunc_memset_pattern16:
693 Changed |= setOnlyAccessesArgMemory(F);
694 Changed |= setDoesNotCapture(F, 1);
695 Changed |= setDoesNotCapture(F, 2);
696 Changed |= setOnlyReadsMemory(F, 2);
698 // int __nvvm_reflect(const char *)
699 case LibFunc_nvvm_reflect:
700 Changed |= setDoesNotAccessMemory(F);
701 Changed |= setDoesNotThrow(F);
705 // FIXME: It'd be really nice to cover all the library functions we're
711 //- Emit LibCalls ------------------------------------------------------------//
713 Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
714 unsigned AS = V->getType()->getPointerAddressSpace();
715 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
718 Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
719 const TargetLibraryInfo *TLI) {
720 if (!TLI->has(LibFunc_strlen))
723 Module *M = B.GetInsertBlock()->getModule();
724 LLVMContext &Context = B.GetInsertBlock()->getContext();
725 Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),
727 inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);
728 CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");
729 if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
730 CI->setCallingConv(F->getCallingConv());
735 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
736 const TargetLibraryInfo *TLI) {
737 if (!TLI->has(LibFunc_strchr))
740 Module *M = B.GetInsertBlock()->getModule();
741 Type *I8Ptr = B.getInt8PtrTy();
742 Type *I32Ty = B.getInt32Ty();
744 M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty);
745 inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);
746 CallInst *CI = B.CreateCall(
747 StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");
748 if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
749 CI->setCallingConv(F->getCallingConv());
753 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
754 const DataLayout &DL, const TargetLibraryInfo *TLI) {
755 if (!TLI->has(LibFunc_strncmp))
758 Module *M = B.GetInsertBlock()->getModule();
759 LLVMContext &Context = B.GetInsertBlock()->getContext();
760 Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),
761 B.getInt8PtrTy(), B.getInt8PtrTy(),
762 DL.getIntPtrType(Context));
763 inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);
764 CallInst *CI = B.CreateCall(
765 StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");
767 if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
768 CI->setCallingConv(F->getCallingConv());
773 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
774 const TargetLibraryInfo *TLI, StringRef Name) {
775 if (!TLI->has(LibFunc_strcpy))
778 Module *M = B.GetInsertBlock()->getModule();
779 Type *I8Ptr = B.getInt8PtrTy();
780 Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr);
781 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
783 B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
784 if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
785 CI->setCallingConv(F->getCallingConv());
789 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
790 const TargetLibraryInfo *TLI, StringRef Name) {
791 if (!TLI->has(LibFunc_strncpy))
794 Module *M = B.GetInsertBlock()->getModule();
795 Type *I8Ptr = B.getInt8PtrTy();
796 Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
798 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
799 CallInst *CI = B.CreateCall(
800 StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");
801 if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
802 CI->setCallingConv(F->getCallingConv());
806 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
807 IRBuilder<> &B, const DataLayout &DL,
808 const TargetLibraryInfo *TLI) {
809 if (!TLI->has(LibFunc_memcpy_chk))
812 Module *M = B.GetInsertBlock()->getModule();
814 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
815 Attribute::NoUnwind);
816 LLVMContext &Context = B.GetInsertBlock()->getContext();
817 Value *MemCpy = M->getOrInsertFunction(
818 "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
819 B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
820 DL.getIntPtrType(Context));
821 Dst = castToCStr(Dst, B);
822 Src = castToCStr(Src, B);
823 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
824 if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
825 CI->setCallingConv(F->getCallingConv());
829 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
830 const DataLayout &DL, const TargetLibraryInfo *TLI) {
831 if (!TLI->has(LibFunc_memchr))
834 Module *M = B.GetInsertBlock()->getModule();
835 LLVMContext &Context = B.GetInsertBlock()->getContext();
836 Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),
837 B.getInt8PtrTy(), B.getInt32Ty(),
838 DL.getIntPtrType(Context));
839 inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);
840 CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");
842 if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
843 CI->setCallingConv(F->getCallingConv());
848 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
849 const DataLayout &DL, const TargetLibraryInfo *TLI) {
850 if (!TLI->has(LibFunc_memcmp))
853 Module *M = B.GetInsertBlock()->getModule();
854 LLVMContext &Context = B.GetInsertBlock()->getContext();
855 Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),
856 B.getInt8PtrTy(), B.getInt8PtrTy(),
857 DL.getIntPtrType(Context));
858 inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);
859 CallInst *CI = B.CreateCall(
860 MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "memcmp");
862 if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
863 CI->setCallingConv(F->getCallingConv());
868 /// Append a suffix to the function name according to the type of 'Op'.
869 static void appendTypeSuffix(Value *Op, StringRef &Name,
870 SmallString<20> &NameBuffer) {
871 if (!Op->getType()->isDoubleTy()) {
874 if (Op->getType()->isFloatTy())
883 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
884 const AttributeList &Attrs) {
885 SmallString<20> NameBuffer;
886 appendTypeSuffix(Op, Name, NameBuffer);
888 Module *M = B.GetInsertBlock()->getModule();
889 Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
891 CallInst *CI = B.CreateCall(Callee, Op, Name);
892 CI->setAttributes(Attrs);
893 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
894 CI->setCallingConv(F->getCallingConv());
899 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
900 IRBuilder<> &B, const AttributeList &Attrs) {
901 SmallString<20> NameBuffer;
902 appendTypeSuffix(Op1, Name, NameBuffer);
904 Module *M = B.GetInsertBlock()->getModule();
905 Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
907 CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
908 CI->setAttributes(Attrs);
909 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
910 CI->setCallingConv(F->getCallingConv());
915 Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
916 const TargetLibraryInfo *TLI) {
917 if (!TLI->has(LibFunc_putchar))
920 Module *M = B.GetInsertBlock()->getModule();
921 Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(), B.getInt32Ty());
922 inferLibFuncAttributes(*M->getFunction("putchar"), *TLI);
923 CallInst *CI = B.CreateCall(PutChar,
924 B.CreateIntCast(Char,
930 if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
931 CI->setCallingConv(F->getCallingConv());
935 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
936 const TargetLibraryInfo *TLI) {
937 if (!TLI->has(LibFunc_puts))
940 Module *M = B.GetInsertBlock()->getModule();
942 M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy());
943 inferLibFuncAttributes(*M->getFunction("puts"), *TLI);
944 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");
945 if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
946 CI->setCallingConv(F->getCallingConv());
950 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
951 const TargetLibraryInfo *TLI) {
952 if (!TLI->has(LibFunc_fputc))
955 Module *M = B.GetInsertBlock()->getModule();
956 Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),
958 if (File->getType()->isPointerTy())
959 inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);
960 Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
962 CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
964 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
965 CI->setCallingConv(Fn->getCallingConv());
969 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
970 const TargetLibraryInfo *TLI) {
971 if (!TLI->has(LibFunc_fputs))
974 Module *M = B.GetInsertBlock()->getModule();
975 StringRef FPutsName = TLI->getName(LibFunc_fputs);
976 Constant *F = M->getOrInsertFunction(
977 FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());
978 if (File->getType()->isPointerTy())
979 inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
980 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
982 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
983 CI->setCallingConv(Fn->getCallingConv());
987 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
988 const DataLayout &DL, const TargetLibraryInfo *TLI) {
989 if (!TLI->has(LibFunc_fwrite))
992 Module *M = B.GetInsertBlock()->getModule();
993 LLVMContext &Context = B.GetInsertBlock()->getContext();
994 StringRef FWriteName = TLI->getName(LibFunc_fwrite);
995 Constant *F = M->getOrInsertFunction(
996 FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
997 DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
999 if (File->getType()->isPointerTy())
1000 inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
1002 B.CreateCall(F, {castToCStr(Ptr, B), Size,
1003 ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1005 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1006 CI->setCallingConv(Fn->getCallingConv());