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) {
99 assert((n != AttributeSet::ReturnIndex ||
100 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) {
110 LibFunc::Func TheLibFunc;
111 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
114 bool Changed = false;
115 switch (TheLibFunc) {
116 case LibFunc::strlen:
117 Changed |= setOnlyReadsMemory(F);
118 Changed |= setDoesNotThrow(F);
119 Changed |= setDoesNotCapture(F, 1);
121 case LibFunc::strchr:
122 case LibFunc::strrchr:
123 Changed |= setOnlyReadsMemory(F);
124 Changed |= setDoesNotThrow(F);
126 case LibFunc::strtol:
127 case LibFunc::strtod:
128 case LibFunc::strtof:
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);
137 case LibFunc::strcpy:
138 case LibFunc::stpcpy:
139 case LibFunc::strcat:
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);
165 case LibFunc::strstr:
166 case LibFunc::strpbrk:
167 Changed |= setOnlyReadsMemory(F);
168 Changed |= setDoesNotThrow(F);
169 Changed |= setDoesNotCapture(F, 2);
171 case LibFunc::strtok:
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);
182 case LibFunc::setbuf:
183 case LibFunc::setvbuf:
184 Changed |= setDoesNotThrow(F);
185 Changed |= setDoesNotCapture(F, 1);
187 case LibFunc::strdup:
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);
201 case LibFunc::sscanf:
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);
226 case LibFunc::system:
227 // May throw; "system" is a valid pthread cancellation point.
228 Changed |= setDoesNotCapture(F, 1);
229 Changed |= setOnlyReadsMemory(F, 1);
231 case LibFunc::malloc:
232 Changed |= setDoesNotThrow(F);
233 Changed |= setDoesNotAlias(F, 0);
235 case LibFunc::memcmp:
236 Changed |= setOnlyReadsMemory(F);
237 Changed |= setDoesNotThrow(F);
238 Changed |= setDoesNotCapture(F, 1);
239 Changed |= setDoesNotCapture(F, 2);
241 case LibFunc::memchr:
242 case LibFunc::memrchr:
243 Changed |= setOnlyReadsMemory(F);
244 Changed |= setDoesNotThrow(F);
249 Changed |= setDoesNotThrow(F);
250 Changed |= setDoesNotCapture(F, 2);
252 case LibFunc::memcpy:
253 case LibFunc::memccpy:
254 case LibFunc::memmove:
255 Changed |= setDoesNotThrow(F);
256 Changed |= setDoesNotCapture(F, 2);
257 Changed |= setOnlyReadsMemory(F, 2);
259 case LibFunc::memcpy_chk:
260 Changed |= setDoesNotThrow(F);
262 case LibFunc::memalign:
263 Changed |= setDoesNotAlias(F, 0);
266 Changed |= setDoesNotThrow(F);
267 Changed |= setDoesNotCapture(F, 1);
268 Changed |= setOnlyReadsMemory(F, 1);
270 case LibFunc::mktime:
271 Changed |= setDoesNotThrow(F);
272 Changed |= setDoesNotCapture(F, 1);
274 case LibFunc::realloc:
275 Changed |= setDoesNotThrow(F);
276 Changed |= setDoesNotAlias(F, 0);
277 Changed |= setDoesNotCapture(F, 1);
280 // May throw; "read" is a valid pthread cancellation point.
281 Changed |= setDoesNotCapture(F, 2);
283 case LibFunc::rewind:
284 Changed |= setDoesNotThrow(F);
285 Changed |= setDoesNotCapture(F, 1);
288 case LibFunc::remove:
289 case LibFunc::realpath:
290 Changed |= setDoesNotThrow(F);
291 Changed |= setDoesNotCapture(F, 1);
292 Changed |= setOnlyReadsMemory(F, 1);
294 case LibFunc::rename:
295 Changed |= setDoesNotThrow(F);
296 Changed |= setDoesNotCapture(F, 1);
297 Changed |= setDoesNotCapture(F, 2);
298 Changed |= setOnlyReadsMemory(F, 1);
299 Changed |= setOnlyReadsMemory(F, 2);
301 case LibFunc::readlink:
302 Changed |= setDoesNotThrow(F);
303 Changed |= setDoesNotCapture(F, 1);
304 Changed |= setDoesNotCapture(F, 2);
305 Changed |= setOnlyReadsMemory(F, 1);
308 // May throw; "write" is a valid pthread cancellation point.
309 Changed |= setDoesNotCapture(F, 2);
310 Changed |= setOnlyReadsMemory(F, 2);
313 Changed |= setDoesNotThrow(F);
314 Changed |= setDoesNotCapture(F, 1);
315 Changed |= setDoesNotCapture(F, 2);
316 Changed |= setOnlyReadsMemory(F, 1);
319 Changed |= setDoesNotThrow(F);
320 Changed |= setOnlyReadsMemory(F);
321 Changed |= setDoesNotCapture(F, 1);
322 Changed |= setDoesNotCapture(F, 2);
325 Changed |= setDoesNotThrow(F);
326 Changed |= setDoesNotCapture(F, 1);
328 case LibFunc::calloc:
329 Changed |= setDoesNotThrow(F);
330 Changed |= setDoesNotAlias(F, 0);
334 Changed |= setDoesNotThrow(F);
335 Changed |= setDoesNotCapture(F, 1);
336 Changed |= setOnlyReadsMemory(F, 1);
338 case LibFunc::ctermid:
339 case LibFunc::clearerr:
340 case LibFunc::closedir:
341 Changed |= setDoesNotThrow(F);
342 Changed |= setDoesNotCapture(F, 1);
348 Changed |= setDoesNotThrow(F);
349 Changed |= setOnlyReadsMemory(F);
350 Changed |= setDoesNotCapture(F, 1);
352 case LibFunc::access:
353 Changed |= setDoesNotThrow(F);
354 Changed |= setDoesNotCapture(F, 1);
355 Changed |= setOnlyReadsMemory(F, 1);
358 Changed |= setDoesNotThrow(F);
359 Changed |= setDoesNotAlias(F, 0);
360 Changed |= setDoesNotCapture(F, 1);
361 Changed |= setDoesNotCapture(F, 2);
362 Changed |= setOnlyReadsMemory(F, 1);
363 Changed |= setOnlyReadsMemory(F, 2);
365 case LibFunc::fdopen:
366 Changed |= setDoesNotThrow(F);
367 Changed |= setDoesNotAlias(F, 0);
368 Changed |= setDoesNotCapture(F, 2);
369 Changed |= setOnlyReadsMemory(F, 2);
376 case LibFunc::fseeko:
377 case LibFunc::ftello:
378 case LibFunc::fileno:
379 case LibFunc::fflush:
380 case LibFunc::fclose:
381 case LibFunc::fsetpos:
382 case LibFunc::flockfile:
383 case LibFunc::funlockfile:
384 case LibFunc::ftrylockfile:
385 Changed |= setDoesNotThrow(F);
386 Changed |= setDoesNotCapture(F, 1);
388 case LibFunc::ferror:
389 Changed |= setDoesNotThrow(F);
390 Changed |= setDoesNotCapture(F, 1);
391 Changed |= setOnlyReadsMemory(F);
396 case LibFunc::frexpf:
397 case LibFunc::frexpl:
398 case LibFunc::fstatvfs:
399 Changed |= setDoesNotThrow(F);
400 Changed |= setDoesNotCapture(F, 2);
403 Changed |= setDoesNotThrow(F);
404 Changed |= setDoesNotCapture(F, 3);
407 Changed |= setDoesNotThrow(F);
408 Changed |= setDoesNotCapture(F, 1);
409 Changed |= setDoesNotCapture(F, 4);
411 case LibFunc::fwrite:
412 Changed |= setDoesNotThrow(F);
413 Changed |= setDoesNotCapture(F, 1);
414 Changed |= setDoesNotCapture(F, 4);
415 // FIXME: readonly #1?
418 Changed |= setDoesNotThrow(F);
419 Changed |= setDoesNotCapture(F, 1);
420 Changed |= setDoesNotCapture(F, 2);
421 Changed |= setOnlyReadsMemory(F, 1);
423 case LibFunc::fscanf:
424 case LibFunc::fprintf:
425 Changed |= setDoesNotThrow(F);
426 Changed |= setDoesNotCapture(F, 1);
427 Changed |= setDoesNotCapture(F, 2);
428 Changed |= setOnlyReadsMemory(F, 2);
430 case LibFunc::fgetpos:
431 Changed |= setDoesNotThrow(F);
432 Changed |= setDoesNotCapture(F, 1);
433 Changed |= setDoesNotCapture(F, 2);
436 case LibFunc::getlogin_r:
437 case LibFunc::getc_unlocked:
438 Changed |= setDoesNotThrow(F);
439 Changed |= setDoesNotCapture(F, 1);
441 case LibFunc::getenv:
442 Changed |= setDoesNotThrow(F);
443 Changed |= setOnlyReadsMemory(F);
444 Changed |= setDoesNotCapture(F, 1);
447 case LibFunc::getchar:
448 Changed |= setDoesNotThrow(F);
450 case LibFunc::getitimer:
451 Changed |= setDoesNotThrow(F);
452 Changed |= setDoesNotCapture(F, 2);
454 case LibFunc::getpwnam:
455 Changed |= setDoesNotThrow(F);
456 Changed |= setDoesNotCapture(F, 1);
457 Changed |= setOnlyReadsMemory(F, 1);
459 case LibFunc::ungetc:
460 Changed |= setDoesNotThrow(F);
461 Changed |= setDoesNotCapture(F, 2);
464 Changed |= setDoesNotThrow(F);
465 Changed |= setDoesNotCapture(F, 1);
467 case LibFunc::unlink:
468 Changed |= setDoesNotThrow(F);
469 Changed |= setDoesNotCapture(F, 1);
470 Changed |= setOnlyReadsMemory(F, 1);
472 case LibFunc::unsetenv:
473 Changed |= setDoesNotThrow(F);
474 Changed |= setDoesNotCapture(F, 1);
475 Changed |= setOnlyReadsMemory(F, 1);
478 case LibFunc::utimes:
479 Changed |= setDoesNotThrow(F);
480 Changed |= setDoesNotCapture(F, 1);
481 Changed |= setDoesNotCapture(F, 2);
482 Changed |= setOnlyReadsMemory(F, 1);
483 Changed |= setOnlyReadsMemory(F, 2);
486 Changed |= setDoesNotThrow(F);
487 Changed |= setDoesNotCapture(F, 2);
490 case LibFunc::printf:
491 case LibFunc::perror:
492 Changed |= setDoesNotThrow(F);
493 Changed |= setDoesNotCapture(F, 1);
494 Changed |= setOnlyReadsMemory(F, 1);
497 // May throw; "pread" is a valid pthread cancellation point.
498 Changed |= setDoesNotCapture(F, 2);
500 case LibFunc::pwrite:
501 // May throw; "pwrite" is a valid pthread cancellation point.
502 Changed |= setDoesNotCapture(F, 2);
503 Changed |= setOnlyReadsMemory(F, 2);
505 case LibFunc::putchar:
506 Changed |= setDoesNotThrow(F);
509 Changed |= setDoesNotThrow(F);
510 Changed |= setDoesNotAlias(F, 0);
511 Changed |= setDoesNotCapture(F, 1);
512 Changed |= setDoesNotCapture(F, 2);
513 Changed |= setOnlyReadsMemory(F, 1);
514 Changed |= setOnlyReadsMemory(F, 2);
516 case LibFunc::pclose:
517 Changed |= setDoesNotThrow(F);
518 Changed |= setDoesNotCapture(F, 1);
520 case LibFunc::vscanf:
521 Changed |= setDoesNotThrow(F);
522 Changed |= setDoesNotCapture(F, 1);
523 Changed |= setOnlyReadsMemory(F, 1);
525 case LibFunc::vsscanf:
526 Changed |= setDoesNotThrow(F);
527 Changed |= setDoesNotCapture(F, 1);
528 Changed |= setDoesNotCapture(F, 2);
529 Changed |= setOnlyReadsMemory(F, 1);
530 Changed |= setOnlyReadsMemory(F, 2);
532 case LibFunc::vfscanf:
533 Changed |= setDoesNotThrow(F);
534 Changed |= setDoesNotCapture(F, 1);
535 Changed |= setDoesNotCapture(F, 2);
536 Changed |= setOnlyReadsMemory(F, 2);
538 case LibFunc::valloc:
539 Changed |= setDoesNotThrow(F);
540 Changed |= setDoesNotAlias(F, 0);
542 case LibFunc::vprintf:
543 Changed |= setDoesNotThrow(F);
544 Changed |= setDoesNotCapture(F, 1);
545 Changed |= setOnlyReadsMemory(F, 1);
547 case LibFunc::vfprintf:
548 case LibFunc::vsprintf:
549 Changed |= setDoesNotThrow(F);
550 Changed |= setDoesNotCapture(F, 1);
551 Changed |= setDoesNotCapture(F, 2);
552 Changed |= setOnlyReadsMemory(F, 2);
554 case LibFunc::vsnprintf:
555 Changed |= setDoesNotThrow(F);
556 Changed |= setDoesNotCapture(F, 1);
557 Changed |= setDoesNotCapture(F, 3);
558 Changed |= setOnlyReadsMemory(F, 3);
561 // May throw; "open" is a valid pthread cancellation point.
562 Changed |= setDoesNotCapture(F, 1);
563 Changed |= setOnlyReadsMemory(F, 1);
565 case LibFunc::opendir:
566 Changed |= setDoesNotThrow(F);
567 Changed |= setDoesNotAlias(F, 0);
568 Changed |= setDoesNotCapture(F, 1);
569 Changed |= setOnlyReadsMemory(F, 1);
571 case LibFunc::tmpfile:
572 Changed |= setDoesNotThrow(F);
573 Changed |= setDoesNotAlias(F, 0);
576 Changed |= setDoesNotThrow(F);
577 Changed |= setDoesNotCapture(F, 1);
583 Changed |= setDoesNotThrow(F);
584 Changed |= setDoesNotAccessMemory(F);
587 Changed |= setDoesNotThrow(F);
588 Changed |= setDoesNotCapture(F, 1);
589 Changed |= setDoesNotCapture(F, 2);
590 Changed |= setOnlyReadsMemory(F, 1);
592 case LibFunc::lchown:
593 Changed |= setDoesNotThrow(F);
594 Changed |= setDoesNotCapture(F, 1);
595 Changed |= setOnlyReadsMemory(F, 1);
598 // May throw; places call through function pointer.
599 Changed |= setDoesNotCapture(F, 4);
601 case LibFunc::dunder_strdup:
602 case LibFunc::dunder_strndup:
603 Changed |= setDoesNotThrow(F);
604 Changed |= setDoesNotAlias(F, 0);
605 Changed |= setDoesNotCapture(F, 1);
606 Changed |= setOnlyReadsMemory(F, 1);
608 case LibFunc::dunder_strtok_r:
609 Changed |= setDoesNotThrow(F);
610 Changed |= setDoesNotCapture(F, 2);
611 Changed |= setOnlyReadsMemory(F, 2);
613 case LibFunc::under_IO_getc:
614 Changed |= setDoesNotThrow(F);
615 Changed |= setDoesNotCapture(F, 1);
617 case LibFunc::under_IO_putc:
618 Changed |= setDoesNotThrow(F);
619 Changed |= setDoesNotCapture(F, 2);
621 case LibFunc::dunder_isoc99_scanf:
622 Changed |= setDoesNotThrow(F);
623 Changed |= setDoesNotCapture(F, 1);
624 Changed |= setOnlyReadsMemory(F, 1);
626 case LibFunc::stat64:
627 case LibFunc::lstat64:
628 case LibFunc::statvfs64:
629 Changed |= setDoesNotThrow(F);
630 Changed |= setDoesNotCapture(F, 1);
631 Changed |= setDoesNotCapture(F, 2);
632 Changed |= setOnlyReadsMemory(F, 1);
634 case LibFunc::dunder_isoc99_sscanf:
635 Changed |= setDoesNotThrow(F);
636 Changed |= setDoesNotCapture(F, 1);
637 Changed |= setDoesNotCapture(F, 2);
638 Changed |= setOnlyReadsMemory(F, 1);
639 Changed |= setOnlyReadsMemory(F, 2);
641 case LibFunc::fopen64:
642 Changed |= setDoesNotThrow(F);
643 Changed |= setDoesNotAlias(F, 0);
644 Changed |= setDoesNotCapture(F, 1);
645 Changed |= setDoesNotCapture(F, 2);
646 Changed |= setOnlyReadsMemory(F, 1);
647 Changed |= setOnlyReadsMemory(F, 2);
649 case LibFunc::fseeko64:
650 case LibFunc::ftello64:
651 Changed |= setDoesNotThrow(F);
652 Changed |= setDoesNotCapture(F, 1);
654 case LibFunc::tmpfile64:
655 Changed |= setDoesNotThrow(F);
656 Changed |= setDoesNotAlias(F, 0);
658 case LibFunc::fstat64:
659 case LibFunc::fstatvfs64:
660 Changed |= setDoesNotThrow(F);
661 Changed |= setDoesNotCapture(F, 2);
663 case LibFunc::open64:
664 // May throw; "open" is a valid pthread cancellation point.
665 Changed |= setDoesNotCapture(F, 1);
666 Changed |= setOnlyReadsMemory(F, 1);
668 case LibFunc::gettimeofday:
669 // Currently some platforms have the restrict keyword on the arguments to
670 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
672 Changed |= setDoesNotThrow(F);
673 Changed |= setDoesNotCapture(F, 1);
674 Changed |= setDoesNotCapture(F, 2);
676 case LibFunc::Znwj: // new(unsigned int)
677 case LibFunc::Znwm: // new(unsigned long)
678 case LibFunc::Znaj: // new[](unsigned int)
679 case LibFunc::Znam: // new[](unsigned long)
680 case LibFunc::msvc_new_int: // new(unsigned int)
681 case LibFunc::msvc_new_longlong: // new(unsigned long long)
682 case LibFunc::msvc_new_array_int: // new[](unsigned int)
683 case LibFunc::msvc_new_array_longlong: // new[](unsigned long long)
684 // Operator new always returns a nonnull noalias pointer
685 Changed |= setNonNull(F, AttributeSet::ReturnIndex);
686 Changed |= setDoesNotAlias(F, AttributeSet::ReturnIndex);
688 //TODO: add LibFunc entries for:
689 //case LibFunc::memset_pattern4:
690 //case LibFunc::memset_pattern8:
691 case LibFunc::memset_pattern16:
692 Changed |= setOnlyAccessesArgMemory(F);
693 Changed |= setDoesNotCapture(F, 1);
694 Changed |= setDoesNotCapture(F, 2);
695 Changed |= setOnlyReadsMemory(F, 2);
697 // int __nvvm_reflect(const char *)
698 case LibFunc::nvvm_reflect:
699 Changed |= setDoesNotAccessMemory(F);
700 Changed |= setDoesNotThrow(F);
704 // FIXME: It'd be really nice to cover all the library functions we're
710 //- Emit LibCalls ------------------------------------------------------------//
712 Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
713 unsigned AS = V->getType()->getPointerAddressSpace();
714 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
717 Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
718 const TargetLibraryInfo *TLI) {
719 if (!TLI->has(LibFunc::strlen))
722 Module *M = B.GetInsertBlock()->getModule();
723 LLVMContext &Context = B.GetInsertBlock()->getContext();
724 Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),
725 B.getInt8PtrTy(), nullptr);
726 inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);
727 CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");
728 if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
729 CI->setCallingConv(F->getCallingConv());
734 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
735 const TargetLibraryInfo *TLI) {
736 if (!TLI->has(LibFunc::strchr))
739 Module *M = B.GetInsertBlock()->getModule();
740 Type *I8Ptr = B.getInt8PtrTy();
741 Type *I32Ty = B.getInt32Ty();
743 M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty, nullptr);
744 inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);
745 CallInst *CI = B.CreateCall(
746 StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");
747 if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
748 CI->setCallingConv(F->getCallingConv());
752 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
753 const DataLayout &DL, const TargetLibraryInfo *TLI) {
754 if (!TLI->has(LibFunc::strncmp))
757 Module *M = B.GetInsertBlock()->getModule();
758 LLVMContext &Context = B.GetInsertBlock()->getContext();
759 Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),
760 B.getInt8PtrTy(), B.getInt8PtrTy(),
761 DL.getIntPtrType(Context), nullptr);
762 inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);
763 CallInst *CI = B.CreateCall(
764 StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");
766 if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
767 CI->setCallingConv(F->getCallingConv());
772 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
773 const TargetLibraryInfo *TLI, StringRef Name) {
774 if (!TLI->has(LibFunc::strcpy))
777 Module *M = B.GetInsertBlock()->getModule();
778 Type *I8Ptr = B.getInt8PtrTy();
779 Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr, nullptr);
780 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
782 B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);
783 if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
784 CI->setCallingConv(F->getCallingConv());
788 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
789 const TargetLibraryInfo *TLI, StringRef Name) {
790 if (!TLI->has(LibFunc::strncpy))
793 Module *M = B.GetInsertBlock()->getModule();
794 Type *I8Ptr = B.getInt8PtrTy();
795 Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,
796 Len->getType(), nullptr);
797 inferLibFuncAttributes(*M->getFunction(Name), *TLI);
798 CallInst *CI = B.CreateCall(
799 StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");
800 if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
801 CI->setCallingConv(F->getCallingConv());
805 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
806 IRBuilder<> &B, const DataLayout &DL,
807 const TargetLibraryInfo *TLI) {
808 if (!TLI->has(LibFunc::memcpy_chk))
811 Module *M = B.GetInsertBlock()->getModule();
813 AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
814 Attribute::NoUnwind);
815 LLVMContext &Context = B.GetInsertBlock()->getContext();
816 Value *MemCpy = M->getOrInsertFunction(
817 "__memcpy_chk", AttributeSet::get(M->getContext(), AS), B.getInt8PtrTy(),
818 B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
819 DL.getIntPtrType(Context), nullptr);
820 Dst = castToCStr(Dst, B);
821 Src = castToCStr(Src, B);
822 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
823 if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
824 CI->setCallingConv(F->getCallingConv());
828 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
829 const DataLayout &DL, const TargetLibraryInfo *TLI) {
830 if (!TLI->has(LibFunc::memchr))
833 Module *M = B.GetInsertBlock()->getModule();
834 LLVMContext &Context = B.GetInsertBlock()->getContext();
835 Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),
836 B.getInt8PtrTy(), B.getInt32Ty(),
837 DL.getIntPtrType(Context), nullptr);
838 inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);
839 CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");
841 if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
842 CI->setCallingConv(F->getCallingConv());
847 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
848 const DataLayout &DL, const TargetLibraryInfo *TLI) {
849 if (!TLI->has(LibFunc::memcmp))
852 Module *M = B.GetInsertBlock()->getModule();
853 LLVMContext &Context = B.GetInsertBlock()->getContext();
854 Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),
855 B.getInt8PtrTy(), B.getInt8PtrTy(),
856 DL.getIntPtrType(Context), nullptr);
857 inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);
858 CallInst *CI = B.CreateCall(
859 MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "memcmp");
861 if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
862 CI->setCallingConv(F->getCallingConv());
867 /// Append a suffix to the function name according to the type of 'Op'.
868 static void appendTypeSuffix(Value *Op, StringRef &Name,
869 SmallString<20> &NameBuffer) {
870 if (!Op->getType()->isDoubleTy()) {
873 if (Op->getType()->isFloatTy())
882 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
883 const AttributeSet &Attrs) {
884 SmallString<20> NameBuffer;
885 appendTypeSuffix(Op, Name, NameBuffer);
887 Module *M = B.GetInsertBlock()->getModule();
888 Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
889 Op->getType(), nullptr);
890 CallInst *CI = B.CreateCall(Callee, Op, Name);
891 CI->setAttributes(Attrs);
892 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
893 CI->setCallingConv(F->getCallingConv());
898 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
899 IRBuilder<> &B, const AttributeSet &Attrs) {
900 SmallString<20> NameBuffer;
901 appendTypeSuffix(Op1, Name, NameBuffer);
903 Module *M = B.GetInsertBlock()->getModule();
904 Value *Callee = M->getOrInsertFunction(Name, Op1->getType(), Op1->getType(),
905 Op2->getType(), nullptr);
906 CallInst *CI = B.CreateCall(Callee, {Op1, Op2}, Name);
907 CI->setAttributes(Attrs);
908 if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
909 CI->setCallingConv(F->getCallingConv());
914 Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
915 const TargetLibraryInfo *TLI) {
916 if (!TLI->has(LibFunc::putchar))
919 Module *M = B.GetInsertBlock()->getModule();
920 Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(),
921 B.getInt32Ty(), nullptr);
922 CallInst *CI = B.CreateCall(PutChar,
923 B.CreateIntCast(Char,
929 if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
930 CI->setCallingConv(F->getCallingConv());
934 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
935 const TargetLibraryInfo *TLI) {
936 if (!TLI->has(LibFunc::puts))
939 Module *M = B.GetInsertBlock()->getModule();
941 M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy(), nullptr);
942 inferLibFuncAttributes(*M->getFunction("puts"), *TLI);
943 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");
944 if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
945 CI->setCallingConv(F->getCallingConv());
949 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
950 const TargetLibraryInfo *TLI) {
951 if (!TLI->has(LibFunc::fputc))
954 Module *M = B.GetInsertBlock()->getModule();
955 Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),
956 File->getType(), nullptr);
957 if (File->getType()->isPointerTy())
958 inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);
959 Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
961 CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
963 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
964 CI->setCallingConv(Fn->getCallingConv());
968 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
969 const TargetLibraryInfo *TLI) {
970 if (!TLI->has(LibFunc::fputs))
973 Module *M = B.GetInsertBlock()->getModule();
974 StringRef FPutsName = TLI->getName(LibFunc::fputs);
975 Constant *F = M->getOrInsertFunction(
976 FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType(), nullptr);
977 if (File->getType()->isPointerTy())
978 inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);
979 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");
981 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
982 CI->setCallingConv(Fn->getCallingConv());
986 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
987 const DataLayout &DL, const TargetLibraryInfo *TLI) {
988 if (!TLI->has(LibFunc::fwrite))
991 Module *M = B.GetInsertBlock()->getModule();
992 LLVMContext &Context = B.GetInsertBlock()->getContext();
993 StringRef FWriteName = TLI->getName(LibFunc::fwrite);
994 Constant *F = M->getOrInsertFunction(
995 FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
996 DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType(),
998 if (File->getType()->isPointerTy())
999 inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
1001 B.CreateCall(F, {castToCStr(Ptr, B), Size,
1002 ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1004 if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1005 CI->setCallingConv(Fn->getCallingConv());