[ORC] Add std::tuple support to SimplePackedSerialization.
[llvm-project.git] / llvm / lib / Transforms / Utils / BuildLibCalls.cpp
blobc17e7b7f3a5bb99b04193502a12df644c79ec622
1 //===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements some functions that will create standard C libcalls.
11 //===----------------------------------------------------------------------===//
13 #include "llvm/Transforms/Utils/BuildLibCalls.h"
14 #include "llvm/ADT/SmallString.h"
15 #include "llvm/ADT/Statistic.h"
16 #include "llvm/Analysis/TargetLibraryInfo.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/DataLayout.h"
19 #include "llvm/IR/Function.h"
20 #include "llvm/IR/IRBuilder.h"
21 #include "llvm/IR/Intrinsics.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/IR/Type.h"
25 #include "llvm/Analysis/MemoryBuiltins.h"
27 using namespace llvm;
29 #define DEBUG_TYPE "build-libcalls"
31 //- Infer Attributes ---------------------------------------------------------//
33 STATISTIC(NumReadNone, "Number of functions inferred as readnone");
34 STATISTIC(NumInaccessibleMemOnly,
35 "Number of functions inferred as inaccessiblememonly");
36 STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
37 STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
38 STATISTIC(NumInaccessibleMemOrArgMemOnly,
39 "Number of functions inferred as inaccessiblemem_or_argmemonly");
40 STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
41 STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
42 STATISTIC(NumWriteOnlyArg, "Number of arguments inferred as writeonly");
43 STATISTIC(NumSExtArg, "Number of arguments inferred as signext");
44 STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
45 STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
46 STATISTIC(NumNoUndef, "Number of function returns inferred as noundef returns");
47 STATISTIC(NumReturnedArg, "Number of arguments inferred as returned");
48 STATISTIC(NumWillReturn, "Number of functions inferred as willreturn");
50 static bool setDoesNotAccessMemory(Function &F) {
51 if (F.doesNotAccessMemory())
52 return false;
53 F.setDoesNotAccessMemory();
54 ++NumReadNone;
55 return true;
58 static bool setOnlyAccessesInaccessibleMemory(Function &F) {
59 if (F.onlyAccessesInaccessibleMemory())
60 return false;
61 F.setOnlyAccessesInaccessibleMemory();
62 ++NumInaccessibleMemOnly;
63 return true;
66 static bool setOnlyReadsMemory(Function &F) {
67 if (F.onlyReadsMemory())
68 return false;
69 F.setOnlyReadsMemory();
70 ++NumReadOnly;
71 return true;
74 static bool setOnlyAccessesArgMemory(Function &F) {
75 if (F.onlyAccessesArgMemory())
76 return false;
77 F.setOnlyAccessesArgMemory();
78 ++NumArgMemOnly;
79 return true;
82 static bool setOnlyAccessesInaccessibleMemOrArgMem(Function &F) {
83 if (F.onlyAccessesInaccessibleMemOrArgMem())
84 return false;
85 F.setOnlyAccessesInaccessibleMemOrArgMem();
86 ++NumInaccessibleMemOrArgMemOnly;
87 return true;
90 static bool setDoesNotThrow(Function &F) {
91 if (F.doesNotThrow())
92 return false;
93 F.setDoesNotThrow();
94 ++NumNoUnwind;
95 return true;
98 static bool setRetDoesNotAlias(Function &F) {
99 if (F.hasRetAttribute(Attribute::NoAlias))
100 return false;
101 F.addRetAttr(Attribute::NoAlias);
102 ++NumNoAlias;
103 return true;
106 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
107 if (F.hasParamAttribute(ArgNo, Attribute::NoCapture))
108 return false;
109 F.addParamAttr(ArgNo, Attribute::NoCapture);
110 ++NumNoCapture;
111 return true;
114 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
115 if (F.hasParamAttribute(ArgNo, Attribute::NoAlias))
116 return false;
117 F.addParamAttr(ArgNo, Attribute::NoAlias);
118 ++NumNoAlias;
119 return true;
122 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
123 if (F.hasParamAttribute(ArgNo, Attribute::ReadOnly))
124 return false;
125 F.addParamAttr(ArgNo, Attribute::ReadOnly);
126 ++NumReadOnlyArg;
127 return true;
130 static bool setOnlyWritesMemory(Function &F, unsigned ArgNo) {
131 if (F.hasParamAttribute(ArgNo, Attribute::WriteOnly))
132 return false;
133 F.addParamAttr(ArgNo, Attribute::WriteOnly);
134 ++NumWriteOnlyArg;
135 return true;
138 static bool setSignExtendedArg(Function &F, unsigned ArgNo) {
139 if (F.hasParamAttribute(ArgNo, Attribute::SExt))
140 return false;
141 F.addParamAttr(ArgNo, Attribute::SExt);
142 ++NumSExtArg;
143 return true;
146 static bool setRetNoUndef(Function &F) {
147 if (!F.getReturnType()->isVoidTy() &&
148 !F.hasRetAttribute(Attribute::NoUndef)) {
149 F.addRetAttr(Attribute::NoUndef);
150 ++NumNoUndef;
151 return true;
153 return false;
156 static bool setArgsNoUndef(Function &F) {
157 bool Changed = false;
158 for (unsigned ArgNo = 0; ArgNo < F.arg_size(); ++ArgNo) {
159 if (!F.hasParamAttribute(ArgNo, Attribute::NoUndef)) {
160 F.addParamAttr(ArgNo, Attribute::NoUndef);
161 ++NumNoUndef;
162 Changed = true;
165 return Changed;
168 static bool setArgNoUndef(Function &F, unsigned ArgNo) {
169 if (F.hasParamAttribute(ArgNo, Attribute::NoUndef))
170 return false;
171 F.addParamAttr(ArgNo, Attribute::NoUndef);
172 ++NumNoUndef;
173 return true;
176 static bool setRetAndArgsNoUndef(Function &F) {
177 return setRetNoUndef(F) | setArgsNoUndef(F);
180 static bool setReturnedArg(Function &F, unsigned ArgNo) {
181 if (F.hasParamAttribute(ArgNo, Attribute::Returned))
182 return false;
183 F.addParamAttr(ArgNo, Attribute::Returned);
184 ++NumReturnedArg;
185 return true;
188 static bool setNonLazyBind(Function &F) {
189 if (F.hasFnAttribute(Attribute::NonLazyBind))
190 return false;
191 F.addFnAttr(Attribute::NonLazyBind);
192 return true;
195 static bool setDoesNotFreeMemory(Function &F) {
196 if (F.hasFnAttribute(Attribute::NoFree))
197 return false;
198 F.addFnAttr(Attribute::NoFree);
199 return true;
202 static bool setWillReturn(Function &F) {
203 if (F.hasFnAttribute(Attribute::WillReturn))
204 return false;
205 F.addFnAttr(Attribute::WillReturn);
206 ++NumWillReturn;
207 return true;
210 bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,
211 const TargetLibraryInfo &TLI) {
212 Function *F = M->getFunction(Name);
213 if (!F)
214 return false;
215 return inferLibFuncAttributes(*F, TLI);
218 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
219 LibFunc TheLibFunc;
220 if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
221 return false;
223 bool Changed = false;
225 if(!isLibFreeFunction(&F, TheLibFunc) && !isReallocLikeFn(&F, &TLI))
226 Changed |= setDoesNotFreeMemory(F);
228 if (F.getParent() != nullptr && F.getParent()->getRtLibUseGOT())
229 Changed |= setNonLazyBind(F);
231 switch (TheLibFunc) {
232 case LibFunc_strlen:
233 case LibFunc_wcslen:
234 Changed |= setOnlyReadsMemory(F);
235 Changed |= setDoesNotThrow(F);
236 Changed |= setOnlyAccessesArgMemory(F);
237 Changed |= setWillReturn(F);
238 Changed |= setDoesNotCapture(F, 0);
239 return Changed;
240 case LibFunc_strchr:
241 case LibFunc_strrchr:
242 Changed |= setOnlyAccessesArgMemory(F);
243 Changed |= setOnlyReadsMemory(F);
244 Changed |= setDoesNotThrow(F);
245 Changed |= setWillReturn(F);
246 return Changed;
247 case LibFunc_strtol:
248 case LibFunc_strtod:
249 case LibFunc_strtof:
250 case LibFunc_strtoul:
251 case LibFunc_strtoll:
252 case LibFunc_strtold:
253 case LibFunc_strtoull:
254 Changed |= setDoesNotThrow(F);
255 Changed |= setWillReturn(F);
256 Changed |= setDoesNotCapture(F, 1);
257 Changed |= setOnlyReadsMemory(F, 0);
258 return Changed;
259 case LibFunc_strcat:
260 case LibFunc_strncat:
261 Changed |= setOnlyAccessesArgMemory(F);
262 Changed |= setDoesNotThrow(F);
263 Changed |= setWillReturn(F);
264 Changed |= setReturnedArg(F, 0);
265 Changed |= setDoesNotCapture(F, 1);
266 Changed |= setOnlyReadsMemory(F, 1);
267 Changed |= setDoesNotAlias(F, 0);
268 Changed |= setDoesNotAlias(F, 1);
269 return Changed;
270 case LibFunc_strcpy:
271 case LibFunc_strncpy:
272 Changed |= setReturnedArg(F, 0);
273 LLVM_FALLTHROUGH;
274 case LibFunc_stpcpy:
275 case LibFunc_stpncpy:
276 Changed |= setOnlyAccessesArgMemory(F);
277 Changed |= setDoesNotThrow(F);
278 Changed |= setWillReturn(F);
279 Changed |= setDoesNotCapture(F, 1);
280 Changed |= setOnlyWritesMemory(F, 0);
281 Changed |= setOnlyReadsMemory(F, 1);
282 Changed |= setDoesNotAlias(F, 0);
283 Changed |= setDoesNotAlias(F, 1);
284 return Changed;
285 case LibFunc_strxfrm:
286 Changed |= setDoesNotThrow(F);
287 Changed |= setWillReturn(F);
288 Changed |= setDoesNotCapture(F, 0);
289 Changed |= setDoesNotCapture(F, 1);
290 Changed |= setOnlyReadsMemory(F, 1);
291 return Changed;
292 case LibFunc_strcmp: // 0,1
293 case LibFunc_strspn: // 0,1
294 case LibFunc_strncmp: // 0,1
295 case LibFunc_strcspn: // 0,1
296 Changed |= setDoesNotThrow(F);
297 Changed |= setOnlyAccessesArgMemory(F);
298 Changed |= setWillReturn(F);
299 Changed |= setOnlyReadsMemory(F);
300 Changed |= setDoesNotCapture(F, 0);
301 Changed |= setDoesNotCapture(F, 1);
302 return Changed;
303 case LibFunc_strcoll:
304 case LibFunc_strcasecmp: // 0,1
305 case LibFunc_strncasecmp: //
306 // Those functions may depend on the locale, which may be accessed through
307 // global memory.
308 Changed |= setOnlyReadsMemory(F);
309 Changed |= setDoesNotThrow(F);
310 Changed |= setWillReturn(F);
311 Changed |= setDoesNotCapture(F, 0);
312 Changed |= setDoesNotCapture(F, 1);
313 return Changed;
314 case LibFunc_strstr:
315 case LibFunc_strpbrk:
316 Changed |= setOnlyAccessesArgMemory(F);
317 Changed |= setOnlyReadsMemory(F);
318 Changed |= setDoesNotThrow(F);
319 Changed |= setWillReturn(F);
320 Changed |= setDoesNotCapture(F, 1);
321 return Changed;
322 case LibFunc_strtok:
323 case LibFunc_strtok_r:
324 Changed |= setDoesNotThrow(F);
325 Changed |= setWillReturn(F);
326 Changed |= setDoesNotCapture(F, 1);
327 Changed |= setOnlyReadsMemory(F, 1);
328 return Changed;
329 case LibFunc_scanf:
330 Changed |= setRetAndArgsNoUndef(F);
331 Changed |= setDoesNotThrow(F);
332 Changed |= setDoesNotCapture(F, 0);
333 Changed |= setOnlyReadsMemory(F, 0);
334 return Changed;
335 case LibFunc_setbuf:
336 case LibFunc_setvbuf:
337 Changed |= setRetAndArgsNoUndef(F);
338 Changed |= setDoesNotThrow(F);
339 Changed |= setDoesNotCapture(F, 0);
340 return Changed;
341 case LibFunc_strndup:
342 Changed |= setArgNoUndef(F, 1);
343 LLVM_FALLTHROUGH;
344 case LibFunc_strdup:
345 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
346 Changed |= setDoesNotThrow(F);
347 Changed |= setRetDoesNotAlias(F);
348 Changed |= setWillReturn(F);
349 Changed |= setDoesNotCapture(F, 0);
350 Changed |= setOnlyReadsMemory(F, 0);
351 return Changed;
352 case LibFunc_stat:
353 case LibFunc_statvfs:
354 Changed |= setRetAndArgsNoUndef(F);
355 Changed |= setDoesNotThrow(F);
356 Changed |= setDoesNotCapture(F, 0);
357 Changed |= setDoesNotCapture(F, 1);
358 Changed |= setOnlyReadsMemory(F, 0);
359 return Changed;
360 case LibFunc_sscanf:
361 Changed |= setRetAndArgsNoUndef(F);
362 Changed |= setDoesNotThrow(F);
363 Changed |= setDoesNotCapture(F, 0);
364 Changed |= setDoesNotCapture(F, 1);
365 Changed |= setOnlyReadsMemory(F, 0);
366 Changed |= setOnlyReadsMemory(F, 1);
367 return Changed;
368 case LibFunc_sprintf:
369 Changed |= setRetAndArgsNoUndef(F);
370 Changed |= setDoesNotThrow(F);
371 Changed |= setDoesNotCapture(F, 0);
372 Changed |= setDoesNotAlias(F, 0);
373 Changed |= setOnlyWritesMemory(F, 0);
374 Changed |= setDoesNotCapture(F, 1);
375 Changed |= setOnlyReadsMemory(F, 1);
376 return Changed;
377 case LibFunc_snprintf:
378 Changed |= setRetAndArgsNoUndef(F);
379 Changed |= setDoesNotThrow(F);
380 Changed |= setDoesNotCapture(F, 0);
381 Changed |= setDoesNotAlias(F, 0);
382 Changed |= setOnlyWritesMemory(F, 0);
383 Changed |= setDoesNotCapture(F, 2);
384 Changed |= setOnlyReadsMemory(F, 2);
385 return Changed;
386 case LibFunc_setitimer:
387 Changed |= setRetAndArgsNoUndef(F);
388 Changed |= setDoesNotThrow(F);
389 Changed |= setWillReturn(F);
390 Changed |= setDoesNotCapture(F, 1);
391 Changed |= setDoesNotCapture(F, 2);
392 Changed |= setOnlyReadsMemory(F, 1);
393 return Changed;
394 case LibFunc_system:
395 // May throw; "system" is a valid pthread cancellation point.
396 Changed |= setRetAndArgsNoUndef(F);
397 Changed |= setDoesNotCapture(F, 0);
398 Changed |= setOnlyReadsMemory(F, 0);
399 return Changed;
400 case LibFunc_malloc:
401 case LibFunc_vec_malloc:
402 Changed |= setOnlyAccessesInaccessibleMemory(F);
403 Changed |= setRetAndArgsNoUndef(F);
404 Changed |= setDoesNotThrow(F);
405 Changed |= setRetDoesNotAlias(F);
406 Changed |= setWillReturn(F);
407 return Changed;
408 case LibFunc_memcmp:
409 Changed |= setOnlyAccessesArgMemory(F);
410 Changed |= setOnlyReadsMemory(F);
411 Changed |= setDoesNotThrow(F);
412 Changed |= setWillReturn(F);
413 Changed |= setDoesNotCapture(F, 0);
414 Changed |= setDoesNotCapture(F, 1);
415 return Changed;
416 case LibFunc_memchr:
417 case LibFunc_memrchr:
418 Changed |= setDoesNotThrow(F);
419 Changed |= setOnlyAccessesArgMemory(F);
420 Changed |= setOnlyReadsMemory(F);
421 Changed |= setWillReturn(F);
422 return Changed;
423 case LibFunc_modf:
424 case LibFunc_modff:
425 case LibFunc_modfl:
426 Changed |= setDoesNotThrow(F);
427 Changed |= setWillReturn(F);
428 Changed |= setDoesNotCapture(F, 1);
429 return Changed;
430 case LibFunc_memcpy:
431 Changed |= setDoesNotThrow(F);
432 Changed |= setOnlyAccessesArgMemory(F);
433 Changed |= setWillReturn(F);
434 Changed |= setDoesNotAlias(F, 0);
435 Changed |= setReturnedArg(F, 0);
436 Changed |= setOnlyWritesMemory(F, 0);
437 Changed |= setDoesNotAlias(F, 1);
438 Changed |= setDoesNotCapture(F, 1);
439 Changed |= setOnlyReadsMemory(F, 1);
440 return Changed;
441 case LibFunc_memmove:
442 Changed |= setDoesNotThrow(F);
443 Changed |= setOnlyAccessesArgMemory(F);
444 Changed |= setWillReturn(F);
445 Changed |= setReturnedArg(F, 0);
446 Changed |= setOnlyWritesMemory(F, 0);
447 Changed |= setDoesNotCapture(F, 1);
448 Changed |= setOnlyReadsMemory(F, 1);
449 return Changed;
450 case LibFunc_mempcpy:
451 case LibFunc_memccpy:
452 Changed |= setDoesNotThrow(F);
453 Changed |= setOnlyAccessesArgMemory(F);
454 Changed |= setWillReturn(F);
455 Changed |= setDoesNotAlias(F, 0);
456 Changed |= setOnlyWritesMemory(F, 0);
457 Changed |= setDoesNotAlias(F, 1);
458 Changed |= setDoesNotCapture(F, 1);
459 Changed |= setOnlyReadsMemory(F, 1);
460 return Changed;
461 case LibFunc_memcpy_chk:
462 Changed |= setDoesNotThrow(F);
463 return Changed;
464 case LibFunc_memalign:
465 Changed |= setOnlyAccessesInaccessibleMemory(F);
466 Changed |= setRetNoUndef(F);
467 Changed |= setDoesNotThrow(F);
468 Changed |= setRetDoesNotAlias(F);
469 Changed |= setWillReturn(F);
470 return Changed;
471 case LibFunc_mkdir:
472 Changed |= setRetAndArgsNoUndef(F);
473 Changed |= setDoesNotThrow(F);
474 Changed |= setDoesNotCapture(F, 0);
475 Changed |= setOnlyReadsMemory(F, 0);
476 return Changed;
477 case LibFunc_mktime:
478 Changed |= setRetAndArgsNoUndef(F);
479 Changed |= setDoesNotThrow(F);
480 Changed |= setWillReturn(F);
481 Changed |= setDoesNotCapture(F, 0);
482 return Changed;
483 case LibFunc_realloc:
484 case LibFunc_vec_realloc:
485 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
486 Changed |= setRetNoUndef(F);
487 Changed |= setDoesNotThrow(F);
488 Changed |= setRetDoesNotAlias(F);
489 Changed |= setWillReturn(F);
490 Changed |= setDoesNotCapture(F, 0);
491 Changed |= setArgNoUndef(F, 1);
492 return Changed;
493 case LibFunc_reallocf:
494 Changed |= setRetNoUndef(F);
495 Changed |= setWillReturn(F);
496 Changed |= setArgNoUndef(F, 1);
497 return Changed;
498 case LibFunc_read:
499 // May throw; "read" is a valid pthread cancellation point.
500 Changed |= setRetAndArgsNoUndef(F);
501 Changed |= setDoesNotCapture(F, 1);
502 return Changed;
503 case LibFunc_rewind:
504 Changed |= setRetAndArgsNoUndef(F);
505 Changed |= setDoesNotThrow(F);
506 Changed |= setDoesNotCapture(F, 0);
507 return Changed;
508 case LibFunc_rmdir:
509 case LibFunc_remove:
510 case LibFunc_realpath:
511 Changed |= setRetAndArgsNoUndef(F);
512 Changed |= setDoesNotThrow(F);
513 Changed |= setDoesNotCapture(F, 0);
514 Changed |= setOnlyReadsMemory(F, 0);
515 return Changed;
516 case LibFunc_rename:
517 Changed |= setRetAndArgsNoUndef(F);
518 Changed |= setDoesNotThrow(F);
519 Changed |= setDoesNotCapture(F, 0);
520 Changed |= setDoesNotCapture(F, 1);
521 Changed |= setOnlyReadsMemory(F, 0);
522 Changed |= setOnlyReadsMemory(F, 1);
523 return Changed;
524 case LibFunc_readlink:
525 Changed |= setRetAndArgsNoUndef(F);
526 Changed |= setDoesNotThrow(F);
527 Changed |= setDoesNotCapture(F, 0);
528 Changed |= setDoesNotCapture(F, 1);
529 Changed |= setOnlyReadsMemory(F, 0);
530 return Changed;
531 case LibFunc_write:
532 // May throw; "write" is a valid pthread cancellation point.
533 Changed |= setRetAndArgsNoUndef(F);
534 Changed |= setDoesNotCapture(F, 1);
535 Changed |= setOnlyReadsMemory(F, 1);
536 return Changed;
537 case LibFunc_aligned_alloc:
538 Changed |= setOnlyAccessesInaccessibleMemory(F);
539 Changed |= setRetAndArgsNoUndef(F);
540 Changed |= setDoesNotThrow(F);
541 Changed |= setRetDoesNotAlias(F);
542 Changed |= setWillReturn(F);
543 return Changed;
544 case LibFunc_bcopy:
545 Changed |= setDoesNotThrow(F);
546 Changed |= setOnlyAccessesArgMemory(F);
547 Changed |= setWillReturn(F);
548 Changed |= setDoesNotCapture(F, 0);
549 Changed |= setOnlyReadsMemory(F, 0);
550 Changed |= setOnlyWritesMemory(F, 1);
551 Changed |= setDoesNotCapture(F, 1);
552 return Changed;
553 case LibFunc_bcmp:
554 Changed |= setDoesNotThrow(F);
555 Changed |= setOnlyAccessesArgMemory(F);
556 Changed |= setOnlyReadsMemory(F);
557 Changed |= setWillReturn(F);
558 Changed |= setDoesNotCapture(F, 0);
559 Changed |= setDoesNotCapture(F, 1);
560 return Changed;
561 case LibFunc_bzero:
562 Changed |= setDoesNotThrow(F);
563 Changed |= setOnlyAccessesArgMemory(F);
564 Changed |= setWillReturn(F);
565 Changed |= setDoesNotCapture(F, 0);
566 Changed |= setOnlyWritesMemory(F, 0);
567 return Changed;
568 case LibFunc_calloc:
569 case LibFunc_vec_calloc:
570 Changed |= setRetAndArgsNoUndef(F);
571 Changed |= setDoesNotThrow(F);
572 Changed |= setRetDoesNotAlias(F);
573 Changed |= setWillReturn(F);
574 return Changed;
575 case LibFunc_chmod:
576 case LibFunc_chown:
577 Changed |= setRetAndArgsNoUndef(F);
578 Changed |= setDoesNotThrow(F);
579 Changed |= setDoesNotCapture(F, 0);
580 Changed |= setOnlyReadsMemory(F, 0);
581 return Changed;
582 case LibFunc_ctermid:
583 case LibFunc_clearerr:
584 case LibFunc_closedir:
585 Changed |= setRetAndArgsNoUndef(F);
586 Changed |= setDoesNotThrow(F);
587 Changed |= setDoesNotCapture(F, 0);
588 return Changed;
589 case LibFunc_atoi:
590 case LibFunc_atol:
591 case LibFunc_atof:
592 case LibFunc_atoll:
593 Changed |= setDoesNotThrow(F);
594 Changed |= setOnlyReadsMemory(F);
595 Changed |= setWillReturn(F);
596 Changed |= setDoesNotCapture(F, 0);
597 return Changed;
598 case LibFunc_access:
599 Changed |= setRetAndArgsNoUndef(F);
600 Changed |= setDoesNotThrow(F);
601 Changed |= setDoesNotCapture(F, 0);
602 Changed |= setOnlyReadsMemory(F, 0);
603 return Changed;
604 case LibFunc_fopen:
605 Changed |= setRetAndArgsNoUndef(F);
606 Changed |= setDoesNotThrow(F);
607 Changed |= setRetDoesNotAlias(F);
608 Changed |= setDoesNotCapture(F, 0);
609 Changed |= setDoesNotCapture(F, 1);
610 Changed |= setOnlyReadsMemory(F, 0);
611 Changed |= setOnlyReadsMemory(F, 1);
612 return Changed;
613 case LibFunc_fdopen:
614 Changed |= setRetAndArgsNoUndef(F);
615 Changed |= setDoesNotThrow(F);
616 Changed |= setRetDoesNotAlias(F);
617 Changed |= setDoesNotCapture(F, 1);
618 Changed |= setOnlyReadsMemory(F, 1);
619 return Changed;
620 case LibFunc_feof:
621 Changed |= setRetAndArgsNoUndef(F);
622 Changed |= setDoesNotThrow(F);
623 Changed |= setDoesNotCapture(F, 0);
624 return Changed;
625 case LibFunc_free:
626 case LibFunc_vec_free:
627 Changed |= setOnlyAccessesInaccessibleMemOrArgMem(F);
628 Changed |= setArgsNoUndef(F);
629 Changed |= setDoesNotThrow(F);
630 Changed |= setWillReturn(F);
631 Changed |= setDoesNotCapture(F, 0);
632 return Changed;
633 case LibFunc_fseek:
634 case LibFunc_ftell:
635 case LibFunc_fgetc:
636 case LibFunc_fgetc_unlocked:
637 case LibFunc_fseeko:
638 case LibFunc_ftello:
639 case LibFunc_fileno:
640 case LibFunc_fflush:
641 case LibFunc_fclose:
642 case LibFunc_fsetpos:
643 case LibFunc_flockfile:
644 case LibFunc_funlockfile:
645 case LibFunc_ftrylockfile:
646 Changed |= setRetAndArgsNoUndef(F);
647 Changed |= setDoesNotThrow(F);
648 Changed |= setDoesNotCapture(F, 0);
649 return Changed;
650 case LibFunc_ferror:
651 Changed |= setRetAndArgsNoUndef(F);
652 Changed |= setDoesNotThrow(F);
653 Changed |= setDoesNotCapture(F, 0);
654 Changed |= setOnlyReadsMemory(F);
655 return Changed;
656 case LibFunc_fputc:
657 case LibFunc_fputc_unlocked:
658 case LibFunc_fstat:
659 Changed |= setRetAndArgsNoUndef(F);
660 Changed |= setDoesNotThrow(F);
661 Changed |= setDoesNotCapture(F, 1);
662 return Changed;
663 case LibFunc_frexp:
664 case LibFunc_frexpf:
665 case LibFunc_frexpl:
666 Changed |= setDoesNotThrow(F);
667 Changed |= setWillReturn(F);
668 Changed |= setDoesNotCapture(F, 1);
669 return Changed;
670 case LibFunc_fstatvfs:
671 Changed |= setRetAndArgsNoUndef(F);
672 Changed |= setDoesNotThrow(F);
673 Changed |= setDoesNotCapture(F, 1);
674 return Changed;
675 case LibFunc_fgets:
676 case LibFunc_fgets_unlocked:
677 Changed |= setRetAndArgsNoUndef(F);
678 Changed |= setDoesNotThrow(F);
679 Changed |= setDoesNotCapture(F, 2);
680 return Changed;
681 case LibFunc_fread:
682 case LibFunc_fread_unlocked:
683 Changed |= setRetAndArgsNoUndef(F);
684 Changed |= setDoesNotThrow(F);
685 Changed |= setDoesNotCapture(F, 0);
686 Changed |= setDoesNotCapture(F, 3);
687 return Changed;
688 case LibFunc_fwrite:
689 case LibFunc_fwrite_unlocked:
690 Changed |= setRetAndArgsNoUndef(F);
691 Changed |= setDoesNotThrow(F);
692 Changed |= setDoesNotCapture(F, 0);
693 Changed |= setDoesNotCapture(F, 3);
694 // FIXME: readonly #1?
695 return Changed;
696 case LibFunc_fputs:
697 case LibFunc_fputs_unlocked:
698 Changed |= setRetAndArgsNoUndef(F);
699 Changed |= setDoesNotThrow(F);
700 Changed |= setDoesNotCapture(F, 0);
701 Changed |= setDoesNotCapture(F, 1);
702 Changed |= setOnlyReadsMemory(F, 0);
703 return Changed;
704 case LibFunc_fscanf:
705 case LibFunc_fprintf:
706 Changed |= setRetAndArgsNoUndef(F);
707 Changed |= setDoesNotThrow(F);
708 Changed |= setDoesNotCapture(F, 0);
709 Changed |= setDoesNotCapture(F, 1);
710 Changed |= setOnlyReadsMemory(F, 1);
711 return Changed;
712 case LibFunc_fgetpos:
713 Changed |= setRetAndArgsNoUndef(F);
714 Changed |= setDoesNotThrow(F);
715 Changed |= setDoesNotCapture(F, 0);
716 Changed |= setDoesNotCapture(F, 1);
717 return Changed;
718 case LibFunc_getc:
719 Changed |= setRetAndArgsNoUndef(F);
720 Changed |= setDoesNotThrow(F);
721 Changed |= setDoesNotCapture(F, 0);
722 return Changed;
723 case LibFunc_getlogin_r:
724 Changed |= setRetAndArgsNoUndef(F);
725 Changed |= setDoesNotThrow(F);
726 Changed |= setDoesNotCapture(F, 0);
727 return Changed;
728 case LibFunc_getc_unlocked:
729 Changed |= setRetAndArgsNoUndef(F);
730 Changed |= setDoesNotThrow(F);
731 Changed |= setDoesNotCapture(F, 0);
732 return Changed;
733 case LibFunc_getenv:
734 Changed |= setRetAndArgsNoUndef(F);
735 Changed |= setDoesNotThrow(F);
736 Changed |= setOnlyReadsMemory(F);
737 Changed |= setDoesNotCapture(F, 0);
738 return Changed;
739 case LibFunc_gets:
740 case LibFunc_getchar:
741 case LibFunc_getchar_unlocked:
742 Changed |= setRetAndArgsNoUndef(F);
743 Changed |= setDoesNotThrow(F);
744 return Changed;
745 case LibFunc_getitimer:
746 Changed |= setRetAndArgsNoUndef(F);
747 Changed |= setDoesNotThrow(F);
748 Changed |= setDoesNotCapture(F, 1);
749 return Changed;
750 case LibFunc_getpwnam:
751 Changed |= setRetAndArgsNoUndef(F);
752 Changed |= setDoesNotThrow(F);
753 Changed |= setDoesNotCapture(F, 0);
754 Changed |= setOnlyReadsMemory(F, 0);
755 return Changed;
756 case LibFunc_ungetc:
757 Changed |= setRetAndArgsNoUndef(F);
758 Changed |= setDoesNotThrow(F);
759 Changed |= setDoesNotCapture(F, 1);
760 return Changed;
761 case LibFunc_uname:
762 Changed |= setRetAndArgsNoUndef(F);
763 Changed |= setDoesNotThrow(F);
764 Changed |= setDoesNotCapture(F, 0);
765 return Changed;
766 case LibFunc_unlink:
767 Changed |= setRetAndArgsNoUndef(F);
768 Changed |= setDoesNotThrow(F);
769 Changed |= setDoesNotCapture(F, 0);
770 Changed |= setOnlyReadsMemory(F, 0);
771 return Changed;
772 case LibFunc_unsetenv:
773 Changed |= setRetAndArgsNoUndef(F);
774 Changed |= setDoesNotThrow(F);
775 Changed |= setDoesNotCapture(F, 0);
776 Changed |= setOnlyReadsMemory(F, 0);
777 return Changed;
778 case LibFunc_utime:
779 case LibFunc_utimes:
780 Changed |= setRetAndArgsNoUndef(F);
781 Changed |= setDoesNotThrow(F);
782 Changed |= setDoesNotCapture(F, 0);
783 Changed |= setDoesNotCapture(F, 1);
784 Changed |= setOnlyReadsMemory(F, 0);
785 Changed |= setOnlyReadsMemory(F, 1);
786 return Changed;
787 case LibFunc_putc:
788 case LibFunc_putc_unlocked:
789 Changed |= setRetAndArgsNoUndef(F);
790 Changed |= setDoesNotThrow(F);
791 Changed |= setDoesNotCapture(F, 1);
792 return Changed;
793 case LibFunc_puts:
794 case LibFunc_printf:
795 case LibFunc_perror:
796 Changed |= setRetAndArgsNoUndef(F);
797 Changed |= setDoesNotThrow(F);
798 Changed |= setDoesNotCapture(F, 0);
799 Changed |= setOnlyReadsMemory(F, 0);
800 return Changed;
801 case LibFunc_pread:
802 // May throw; "pread" is a valid pthread cancellation point.
803 Changed |= setRetAndArgsNoUndef(F);
804 Changed |= setDoesNotCapture(F, 1);
805 return Changed;
806 case LibFunc_pwrite:
807 // May throw; "pwrite" is a valid pthread cancellation point.
808 Changed |= setRetAndArgsNoUndef(F);
809 Changed |= setDoesNotCapture(F, 1);
810 Changed |= setOnlyReadsMemory(F, 1);
811 return Changed;
812 case LibFunc_putchar:
813 case LibFunc_putchar_unlocked:
814 Changed |= setRetAndArgsNoUndef(F);
815 Changed |= setDoesNotThrow(F);
816 return Changed;
817 case LibFunc_popen:
818 Changed |= setRetAndArgsNoUndef(F);
819 Changed |= setDoesNotThrow(F);
820 Changed |= setRetDoesNotAlias(F);
821 Changed |= setDoesNotCapture(F, 0);
822 Changed |= setDoesNotCapture(F, 1);
823 Changed |= setOnlyReadsMemory(F, 0);
824 Changed |= setOnlyReadsMemory(F, 1);
825 return Changed;
826 case LibFunc_pclose:
827 Changed |= setRetAndArgsNoUndef(F);
828 Changed |= setDoesNotThrow(F);
829 Changed |= setDoesNotCapture(F, 0);
830 return Changed;
831 case LibFunc_vscanf:
832 Changed |= setRetAndArgsNoUndef(F);
833 Changed |= setDoesNotThrow(F);
834 Changed |= setDoesNotCapture(F, 0);
835 Changed |= setOnlyReadsMemory(F, 0);
836 return Changed;
837 case LibFunc_vsscanf:
838 Changed |= setRetAndArgsNoUndef(F);
839 Changed |= setDoesNotThrow(F);
840 Changed |= setDoesNotCapture(F, 0);
841 Changed |= setDoesNotCapture(F, 1);
842 Changed |= setOnlyReadsMemory(F, 0);
843 Changed |= setOnlyReadsMemory(F, 1);
844 return Changed;
845 case LibFunc_vfscanf:
846 Changed |= setRetAndArgsNoUndef(F);
847 Changed |= setDoesNotThrow(F);
848 Changed |= setDoesNotCapture(F, 0);
849 Changed |= setDoesNotCapture(F, 1);
850 Changed |= setOnlyReadsMemory(F, 1);
851 return Changed;
852 case LibFunc_valloc:
853 Changed |= setOnlyAccessesInaccessibleMemory(F);
854 Changed |= setRetAndArgsNoUndef(F);
855 Changed |= setDoesNotThrow(F);
856 Changed |= setRetDoesNotAlias(F);
857 Changed |= setWillReturn(F);
858 return Changed;
859 case LibFunc_vprintf:
860 Changed |= setRetAndArgsNoUndef(F);
861 Changed |= setDoesNotThrow(F);
862 Changed |= setDoesNotCapture(F, 0);
863 Changed |= setOnlyReadsMemory(F, 0);
864 return Changed;
865 case LibFunc_vfprintf:
866 case LibFunc_vsprintf:
867 Changed |= setRetAndArgsNoUndef(F);
868 Changed |= setDoesNotThrow(F);
869 Changed |= setDoesNotCapture(F, 0);
870 Changed |= setDoesNotCapture(F, 1);
871 Changed |= setOnlyReadsMemory(F, 1);
872 return Changed;
873 case LibFunc_vsnprintf:
874 Changed |= setRetAndArgsNoUndef(F);
875 Changed |= setDoesNotThrow(F);
876 Changed |= setDoesNotCapture(F, 0);
877 Changed |= setDoesNotCapture(F, 2);
878 Changed |= setOnlyReadsMemory(F, 2);
879 return Changed;
880 case LibFunc_open:
881 // May throw; "open" is a valid pthread cancellation point.
882 Changed |= setRetAndArgsNoUndef(F);
883 Changed |= setDoesNotCapture(F, 0);
884 Changed |= setOnlyReadsMemory(F, 0);
885 return Changed;
886 case LibFunc_opendir:
887 Changed |= setRetAndArgsNoUndef(F);
888 Changed |= setDoesNotThrow(F);
889 Changed |= setRetDoesNotAlias(F);
890 Changed |= setDoesNotCapture(F, 0);
891 Changed |= setOnlyReadsMemory(F, 0);
892 return Changed;
893 case LibFunc_tmpfile:
894 Changed |= setRetAndArgsNoUndef(F);
895 Changed |= setDoesNotThrow(F);
896 Changed |= setRetDoesNotAlias(F);
897 return Changed;
898 case LibFunc_times:
899 Changed |= setRetAndArgsNoUndef(F);
900 Changed |= setDoesNotThrow(F);
901 Changed |= setDoesNotCapture(F, 0);
902 return Changed;
903 case LibFunc_htonl:
904 case LibFunc_htons:
905 case LibFunc_ntohl:
906 case LibFunc_ntohs:
907 Changed |= setDoesNotThrow(F);
908 Changed |= setDoesNotAccessMemory(F);
909 return Changed;
910 case LibFunc_lstat:
911 Changed |= setRetAndArgsNoUndef(F);
912 Changed |= setDoesNotThrow(F);
913 Changed |= setDoesNotCapture(F, 0);
914 Changed |= setDoesNotCapture(F, 1);
915 Changed |= setOnlyReadsMemory(F, 0);
916 return Changed;
917 case LibFunc_lchown:
918 Changed |= setRetAndArgsNoUndef(F);
919 Changed |= setDoesNotThrow(F);
920 Changed |= setDoesNotCapture(F, 0);
921 Changed |= setOnlyReadsMemory(F, 0);
922 return Changed;
923 case LibFunc_qsort:
924 // May throw; places call through function pointer.
925 // Cannot give undef pointer/size
926 Changed |= setRetAndArgsNoUndef(F);
927 Changed |= setDoesNotCapture(F, 3);
928 return Changed;
929 case LibFunc_dunder_strndup:
930 Changed |= setArgNoUndef(F, 1);
931 LLVM_FALLTHROUGH;
932 case LibFunc_dunder_strdup:
933 Changed |= setDoesNotThrow(F);
934 Changed |= setRetDoesNotAlias(F);
935 Changed |= setWillReturn(F);
936 Changed |= setDoesNotCapture(F, 0);
937 Changed |= setOnlyReadsMemory(F, 0);
938 return Changed;
939 case LibFunc_dunder_strtok_r:
940 Changed |= setDoesNotThrow(F);
941 Changed |= setDoesNotCapture(F, 1);
942 Changed |= setOnlyReadsMemory(F, 1);
943 return Changed;
944 case LibFunc_under_IO_getc:
945 Changed |= setRetAndArgsNoUndef(F);
946 Changed |= setDoesNotThrow(F);
947 Changed |= setDoesNotCapture(F, 0);
948 return Changed;
949 case LibFunc_under_IO_putc:
950 Changed |= setRetAndArgsNoUndef(F);
951 Changed |= setDoesNotThrow(F);
952 Changed |= setDoesNotCapture(F, 1);
953 return Changed;
954 case LibFunc_dunder_isoc99_scanf:
955 Changed |= setRetAndArgsNoUndef(F);
956 Changed |= setDoesNotThrow(F);
957 Changed |= setDoesNotCapture(F, 0);
958 Changed |= setOnlyReadsMemory(F, 0);
959 return Changed;
960 case LibFunc_stat64:
961 case LibFunc_lstat64:
962 case LibFunc_statvfs64:
963 Changed |= setRetAndArgsNoUndef(F);
964 Changed |= setDoesNotThrow(F);
965 Changed |= setDoesNotCapture(F, 0);
966 Changed |= setDoesNotCapture(F, 1);
967 Changed |= setOnlyReadsMemory(F, 0);
968 return Changed;
969 case LibFunc_dunder_isoc99_sscanf:
970 Changed |= setRetAndArgsNoUndef(F);
971 Changed |= setDoesNotThrow(F);
972 Changed |= setDoesNotCapture(F, 0);
973 Changed |= setDoesNotCapture(F, 1);
974 Changed |= setOnlyReadsMemory(F, 0);
975 Changed |= setOnlyReadsMemory(F, 1);
976 return Changed;
977 case LibFunc_fopen64:
978 Changed |= setRetAndArgsNoUndef(F);
979 Changed |= setDoesNotThrow(F);
980 Changed |= setRetDoesNotAlias(F);
981 Changed |= setDoesNotCapture(F, 0);
982 Changed |= setDoesNotCapture(F, 1);
983 Changed |= setOnlyReadsMemory(F, 0);
984 Changed |= setOnlyReadsMemory(F, 1);
985 return Changed;
986 case LibFunc_fseeko64:
987 case LibFunc_ftello64:
988 Changed |= setRetAndArgsNoUndef(F);
989 Changed |= setDoesNotThrow(F);
990 Changed |= setDoesNotCapture(F, 0);
991 return Changed;
992 case LibFunc_tmpfile64:
993 Changed |= setRetAndArgsNoUndef(F);
994 Changed |= setDoesNotThrow(F);
995 Changed |= setRetDoesNotAlias(F);
996 return Changed;
997 case LibFunc_fstat64:
998 case LibFunc_fstatvfs64:
999 Changed |= setRetAndArgsNoUndef(F);
1000 Changed |= setDoesNotThrow(F);
1001 Changed |= setDoesNotCapture(F, 1);
1002 return Changed;
1003 case LibFunc_open64:
1004 // May throw; "open" is a valid pthread cancellation point.
1005 Changed |= setRetAndArgsNoUndef(F);
1006 Changed |= setDoesNotCapture(F, 0);
1007 Changed |= setOnlyReadsMemory(F, 0);
1008 return Changed;
1009 case LibFunc_gettimeofday:
1010 // Currently some platforms have the restrict keyword on the arguments to
1011 // gettimeofday. To be conservative, do not add noalias to gettimeofday's
1012 // arguments.
1013 Changed |= setRetAndArgsNoUndef(F);
1014 Changed |= setDoesNotThrow(F);
1015 Changed |= setDoesNotCapture(F, 0);
1016 Changed |= setDoesNotCapture(F, 1);
1017 return Changed;
1018 // TODO: add LibFunc entries for:
1019 // case LibFunc_memset_pattern4:
1020 // case LibFunc_memset_pattern8:
1021 case LibFunc_memset_pattern16:
1022 Changed |= setOnlyAccessesArgMemory(F);
1023 Changed |= setDoesNotCapture(F, 0);
1024 Changed |= setOnlyWritesMemory(F, 0);
1025 Changed |= setDoesNotCapture(F, 1);
1026 Changed |= setOnlyReadsMemory(F, 1);
1027 return Changed;
1028 case LibFunc_memset:
1029 Changed |= setOnlyAccessesArgMemory(F);
1030 Changed |= setWillReturn(F);
1031 Changed |= setDoesNotThrow(F);
1032 Changed |= setOnlyWritesMemory(F, 0);
1033 return Changed;
1034 // int __nvvm_reflect(const char *)
1035 case LibFunc_nvvm_reflect:
1036 Changed |= setRetAndArgsNoUndef(F);
1037 Changed |= setDoesNotAccessMemory(F);
1038 Changed |= setDoesNotThrow(F);
1039 return Changed;
1040 case LibFunc_ldexp:
1041 case LibFunc_ldexpf:
1042 case LibFunc_ldexpl:
1043 Changed |= setSignExtendedArg(F, 1);
1044 Changed |= setWillReturn(F);
1045 return Changed;
1046 case LibFunc_abs:
1047 case LibFunc_acos:
1048 case LibFunc_acosf:
1049 case LibFunc_acosh:
1050 case LibFunc_acoshf:
1051 case LibFunc_acoshl:
1052 case LibFunc_acosl:
1053 case LibFunc_asin:
1054 case LibFunc_asinf:
1055 case LibFunc_asinh:
1056 case LibFunc_asinhf:
1057 case LibFunc_asinhl:
1058 case LibFunc_asinl:
1059 case LibFunc_atan:
1060 case LibFunc_atan2:
1061 case LibFunc_atan2f:
1062 case LibFunc_atan2l:
1063 case LibFunc_atanf:
1064 case LibFunc_atanh:
1065 case LibFunc_atanhf:
1066 case LibFunc_atanhl:
1067 case LibFunc_atanl:
1068 case LibFunc_cbrt:
1069 case LibFunc_cbrtf:
1070 case LibFunc_cbrtl:
1071 case LibFunc_ceil:
1072 case LibFunc_ceilf:
1073 case LibFunc_ceill:
1074 case LibFunc_copysign:
1075 case LibFunc_copysignf:
1076 case LibFunc_copysignl:
1077 case LibFunc_cos:
1078 case LibFunc_cosh:
1079 case LibFunc_coshf:
1080 case LibFunc_coshl:
1081 case LibFunc_cosf:
1082 case LibFunc_cosl:
1083 case LibFunc_cospi:
1084 case LibFunc_cospif:
1085 case LibFunc_exp:
1086 case LibFunc_expf:
1087 case LibFunc_expl:
1088 case LibFunc_exp2:
1089 case LibFunc_exp2f:
1090 case LibFunc_exp2l:
1091 case LibFunc_expm1:
1092 case LibFunc_expm1f:
1093 case LibFunc_expm1l:
1094 case LibFunc_fabs:
1095 case LibFunc_fabsf:
1096 case LibFunc_fabsl:
1097 case LibFunc_ffs:
1098 case LibFunc_ffsl:
1099 case LibFunc_ffsll:
1100 case LibFunc_floor:
1101 case LibFunc_floorf:
1102 case LibFunc_floorl:
1103 case LibFunc_fls:
1104 case LibFunc_flsl:
1105 case LibFunc_flsll:
1106 case LibFunc_fmax:
1107 case LibFunc_fmaxf:
1108 case LibFunc_fmaxl:
1109 case LibFunc_fmin:
1110 case LibFunc_fminf:
1111 case LibFunc_fminl:
1112 case LibFunc_fmod:
1113 case LibFunc_fmodf:
1114 case LibFunc_fmodl:
1115 case LibFunc_isascii:
1116 case LibFunc_isdigit:
1117 case LibFunc_labs:
1118 case LibFunc_llabs:
1119 case LibFunc_log:
1120 case LibFunc_log10:
1121 case LibFunc_log10f:
1122 case LibFunc_log10l:
1123 case LibFunc_log1p:
1124 case LibFunc_log1pf:
1125 case LibFunc_log1pl:
1126 case LibFunc_log2:
1127 case LibFunc_log2f:
1128 case LibFunc_log2l:
1129 case LibFunc_logb:
1130 case LibFunc_logbf:
1131 case LibFunc_logbl:
1132 case LibFunc_logf:
1133 case LibFunc_logl:
1134 case LibFunc_nearbyint:
1135 case LibFunc_nearbyintf:
1136 case LibFunc_nearbyintl:
1137 case LibFunc_pow:
1138 case LibFunc_powf:
1139 case LibFunc_powl:
1140 case LibFunc_rint:
1141 case LibFunc_rintf:
1142 case LibFunc_rintl:
1143 case LibFunc_round:
1144 case LibFunc_roundf:
1145 case LibFunc_roundl:
1146 case LibFunc_sin:
1147 case LibFunc_sincospif_stret:
1148 case LibFunc_sinf:
1149 case LibFunc_sinh:
1150 case LibFunc_sinhf:
1151 case LibFunc_sinhl:
1152 case LibFunc_sinl:
1153 case LibFunc_sinpi:
1154 case LibFunc_sinpif:
1155 case LibFunc_sqrt:
1156 case LibFunc_sqrtf:
1157 case LibFunc_sqrtl:
1158 case LibFunc_strnlen:
1159 case LibFunc_tan:
1160 case LibFunc_tanf:
1161 case LibFunc_tanh:
1162 case LibFunc_tanhf:
1163 case LibFunc_tanhl:
1164 case LibFunc_tanl:
1165 case LibFunc_toascii:
1166 case LibFunc_trunc:
1167 case LibFunc_truncf:
1168 case LibFunc_truncl:
1169 Changed |= setDoesNotThrow(F);
1170 Changed |= setDoesNotFreeMemory(F);
1171 Changed |= setWillReturn(F);
1172 return Changed;
1173 default:
1174 // FIXME: It'd be really nice to cover all the library functions we're
1175 // aware of here.
1176 return false;
1180 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
1181 LibFunc DoubleFn, LibFunc FloatFn, LibFunc LongDoubleFn) {
1182 switch (Ty->getTypeID()) {
1183 case Type::HalfTyID:
1184 return false;
1185 case Type::FloatTyID:
1186 return TLI->has(FloatFn);
1187 case Type::DoubleTyID:
1188 return TLI->has(DoubleFn);
1189 default:
1190 return TLI->has(LongDoubleFn);
1194 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
1195 LibFunc DoubleFn, LibFunc FloatFn,
1196 LibFunc LongDoubleFn) {
1197 assert(hasFloatFn(TLI, Ty, DoubleFn, FloatFn, LongDoubleFn) &&
1198 "Cannot get name for unavailable function!");
1200 switch (Ty->getTypeID()) {
1201 case Type::HalfTyID:
1202 llvm_unreachable("No name for HalfTy!");
1203 case Type::FloatTyID:
1204 return TLI->getName(FloatFn);
1205 case Type::DoubleTyID:
1206 return TLI->getName(DoubleFn);
1207 default:
1208 return TLI->getName(LongDoubleFn);
1212 //- Emit LibCalls ------------------------------------------------------------//
1214 Value *llvm::castToCStr(Value *V, IRBuilderBase &B) {
1215 unsigned AS = V->getType()->getPointerAddressSpace();
1216 return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
1219 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
1220 ArrayRef<Type *> ParamTypes,
1221 ArrayRef<Value *> Operands, IRBuilderBase &B,
1222 const TargetLibraryInfo *TLI,
1223 bool IsVaArgs = false) {
1224 if (!TLI->has(TheLibFunc))
1225 return nullptr;
1227 Module *M = B.GetInsertBlock()->getModule();
1228 StringRef FuncName = TLI->getName(TheLibFunc);
1229 FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
1230 FunctionCallee Callee = M->getOrInsertFunction(FuncName, FuncType);
1231 inferLibFuncAttributes(M, FuncName, *TLI);
1232 CallInst *CI = B.CreateCall(Callee, Operands, FuncName);
1233 if (const Function *F =
1234 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1235 CI->setCallingConv(F->getCallingConv());
1236 return CI;
1239 Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL,
1240 const TargetLibraryInfo *TLI) {
1241 LLVMContext &Context = B.GetInsertBlock()->getContext();
1242 return emitLibCall(LibFunc_strlen, DL.getIntPtrType(Context),
1243 B.getInt8PtrTy(), castToCStr(Ptr, B), B, TLI);
1246 Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B,
1247 const TargetLibraryInfo *TLI) {
1248 return emitLibCall(LibFunc_strdup, B.getInt8PtrTy(), B.getInt8PtrTy(),
1249 castToCStr(Ptr, B), B, TLI);
1252 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B,
1253 const TargetLibraryInfo *TLI) {
1254 Type *I8Ptr = B.getInt8PtrTy();
1255 Type *I32Ty = B.getInt32Ty();
1256 return emitLibCall(LibFunc_strchr, I8Ptr, {I8Ptr, I32Ty},
1257 {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
1260 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1261 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1262 LLVMContext &Context = B.GetInsertBlock()->getContext();
1263 return emitLibCall(
1264 LibFunc_strncmp, B.getInt32Ty(),
1265 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1266 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1269 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1270 const TargetLibraryInfo *TLI) {
1271 Type *I8Ptr = B.getInt8PtrTy();
1272 return emitLibCall(LibFunc_strcpy, I8Ptr, {I8Ptr, I8Ptr},
1273 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1276 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B,
1277 const TargetLibraryInfo *TLI) {
1278 Type *I8Ptr = B.getInt8PtrTy();
1279 return emitLibCall(LibFunc_stpcpy, I8Ptr, {I8Ptr, I8Ptr},
1280 {castToCStr(Dst, B), castToCStr(Src, B)}, B, TLI);
1283 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1284 const TargetLibraryInfo *TLI) {
1285 Type *I8Ptr = B.getInt8PtrTy();
1286 return emitLibCall(LibFunc_strncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1287 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1290 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1291 const TargetLibraryInfo *TLI) {
1292 Type *I8Ptr = B.getInt8PtrTy();
1293 return emitLibCall(LibFunc_stpncpy, I8Ptr, {I8Ptr, I8Ptr, Len->getType()},
1294 {castToCStr(Dst, B), castToCStr(Src, B), Len}, B, TLI);
1297 Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
1298 IRBuilderBase &B, const DataLayout &DL,
1299 const TargetLibraryInfo *TLI) {
1300 if (!TLI->has(LibFunc_memcpy_chk))
1301 return nullptr;
1303 Module *M = B.GetInsertBlock()->getModule();
1304 AttributeList AS;
1305 AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex,
1306 Attribute::NoUnwind);
1307 LLVMContext &Context = B.GetInsertBlock()->getContext();
1308 FunctionCallee MemCpy = M->getOrInsertFunction(
1309 "__memcpy_chk", AttributeList::get(M->getContext(), AS), B.getInt8PtrTy(),
1310 B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
1311 DL.getIntPtrType(Context));
1312 Dst = castToCStr(Dst, B);
1313 Src = castToCStr(Src, B);
1314 CallInst *CI = B.CreateCall(MemCpy, {Dst, Src, Len, ObjSize});
1315 if (const Function *F =
1316 dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
1317 CI->setCallingConv(F->getCallingConv());
1318 return CI;
1321 Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B,
1322 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1323 LLVMContext &Context = B.GetInsertBlock()->getContext();
1324 return emitLibCall(
1325 LibFunc_mempcpy, B.getInt8PtrTy(),
1326 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1327 {Dst, Src, Len}, B, TLI);
1330 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B,
1331 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1332 LLVMContext &Context = B.GetInsertBlock()->getContext();
1333 return emitLibCall(
1334 LibFunc_memchr, B.getInt8PtrTy(),
1335 {B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context)},
1336 {castToCStr(Ptr, B), Val, Len}, B, TLI);
1339 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1340 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1341 LLVMContext &Context = B.GetInsertBlock()->getContext();
1342 return emitLibCall(
1343 LibFunc_memcmp, B.getInt32Ty(),
1344 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1345 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1348 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B,
1349 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1350 LLVMContext &Context = B.GetInsertBlock()->getContext();
1351 return emitLibCall(
1352 LibFunc_bcmp, B.getInt32Ty(),
1353 {B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context)},
1354 {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, B, TLI);
1357 Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len,
1358 IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1359 return emitLibCall(
1360 LibFunc_memccpy, B.getInt8PtrTy(),
1361 {B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), Len->getType()},
1362 {Ptr1, Ptr2, Val, Len}, B, TLI);
1365 Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt,
1366 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1367 const TargetLibraryInfo *TLI) {
1368 SmallVector<Value *, 8> Args{castToCStr(Dest, B), Size, castToCStr(Fmt, B)};
1369 llvm::append_range(Args, VariadicArgs);
1370 return emitLibCall(LibFunc_snprintf, B.getInt32Ty(),
1371 {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy()},
1372 Args, B, TLI, /*IsVaArgs=*/true);
1375 Value *llvm::emitSPrintf(Value *Dest, Value *Fmt,
1376 ArrayRef<Value *> VariadicArgs, IRBuilderBase &B,
1377 const TargetLibraryInfo *TLI) {
1378 SmallVector<Value *, 8> Args{castToCStr(Dest, B), castToCStr(Fmt, B)};
1379 llvm::append_range(Args, VariadicArgs);
1380 return emitLibCall(LibFunc_sprintf, B.getInt32Ty(),
1381 {B.getInt8PtrTy(), B.getInt8PtrTy()}, Args, B, TLI,
1382 /*IsVaArgs=*/true);
1385 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B,
1386 const TargetLibraryInfo *TLI) {
1387 return emitLibCall(LibFunc_strcat, B.getInt8PtrTy(),
1388 {B.getInt8PtrTy(), B.getInt8PtrTy()},
1389 {castToCStr(Dest, B), castToCStr(Src, B)}, B, TLI);
1392 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1393 const TargetLibraryInfo *TLI) {
1394 return emitLibCall(LibFunc_strlcpy, Size->getType(),
1395 {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1396 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1399 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1400 const TargetLibraryInfo *TLI) {
1401 return emitLibCall(LibFunc_strlcat, Size->getType(),
1402 {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1403 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1406 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B,
1407 const TargetLibraryInfo *TLI) {
1408 return emitLibCall(LibFunc_strncat, B.getInt8PtrTy(),
1409 {B.getInt8PtrTy(), B.getInt8PtrTy(), Size->getType()},
1410 {castToCStr(Dest, B), castToCStr(Src, B), Size}, B, TLI);
1413 Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList,
1414 IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1415 return emitLibCall(
1416 LibFunc_vsnprintf, B.getInt32Ty(),
1417 {B.getInt8PtrTy(), Size->getType(), B.getInt8PtrTy(), VAList->getType()},
1418 {castToCStr(Dest, B), Size, castToCStr(Fmt, B), VAList}, B, TLI);
1421 Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList,
1422 IRBuilderBase &B, const TargetLibraryInfo *TLI) {
1423 return emitLibCall(LibFunc_vsprintf, B.getInt32Ty(),
1424 {B.getInt8PtrTy(), B.getInt8PtrTy(), VAList->getType()},
1425 {castToCStr(Dest, B), castToCStr(Fmt, B), VAList}, B, TLI);
1428 /// Append a suffix to the function name according to the type of 'Op'.
1429 static void appendTypeSuffix(Value *Op, StringRef &Name,
1430 SmallString<20> &NameBuffer) {
1431 if (!Op->getType()->isDoubleTy()) {
1432 NameBuffer += Name;
1434 if (Op->getType()->isFloatTy())
1435 NameBuffer += 'f';
1436 else
1437 NameBuffer += 'l';
1439 Name = NameBuffer;
1443 static Value *emitUnaryFloatFnCallHelper(Value *Op, StringRef Name,
1444 IRBuilderBase &B,
1445 const AttributeList &Attrs) {
1446 assert((Name != "") && "Must specify Name to emitUnaryFloatFnCall");
1448 Module *M = B.GetInsertBlock()->getModule();
1449 FunctionCallee Callee =
1450 M->getOrInsertFunction(Name, Op->getType(), Op->getType());
1451 CallInst *CI = B.CreateCall(Callee, Op, Name);
1453 // The incoming attribute set may have come from a speculatable intrinsic, but
1454 // is being replaced with a library call which is not allowed to be
1455 // speculatable.
1456 CI->setAttributes(
1457 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable));
1458 if (const Function *F =
1459 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1460 CI->setCallingConv(F->getCallingConv());
1462 return CI;
1465 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilderBase &B,
1466 const AttributeList &Attrs) {
1467 SmallString<20> NameBuffer;
1468 appendTypeSuffix(Op, Name, NameBuffer);
1470 return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1473 Value *llvm::emitUnaryFloatFnCall(Value *Op, const TargetLibraryInfo *TLI,
1474 LibFunc DoubleFn, LibFunc FloatFn,
1475 LibFunc LongDoubleFn, IRBuilderBase &B,
1476 const AttributeList &Attrs) {
1477 // Get the name of the function according to TLI.
1478 StringRef Name = getFloatFnName(TLI, Op->getType(),
1479 DoubleFn, FloatFn, LongDoubleFn);
1481 return emitUnaryFloatFnCallHelper(Op, Name, B, Attrs);
1484 static Value *emitBinaryFloatFnCallHelper(Value *Op1, Value *Op2,
1485 StringRef Name, IRBuilderBase &B,
1486 const AttributeList &Attrs,
1487 const TargetLibraryInfo *TLI = nullptr) {
1488 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1490 Module *M = B.GetInsertBlock()->getModule();
1491 FunctionCallee Callee = M->getOrInsertFunction(Name, Op1->getType(),
1492 Op1->getType(), Op2->getType());
1493 if (TLI != nullptr)
1494 inferLibFuncAttributes(M, Name, *TLI);
1495 CallInst *CI = B.CreateCall(Callee, { Op1, Op2 }, Name);
1497 // The incoming attribute set may have come from a speculatable intrinsic, but
1498 // is being replaced with a library call which is not allowed to be
1499 // speculatable.
1500 CI->setAttributes(
1501 Attrs.removeFnAttribute(B.getContext(), Attribute::Speculatable));
1502 if (const Function *F =
1503 dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
1504 CI->setCallingConv(F->getCallingConv());
1506 return CI;
1509 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
1510 IRBuilderBase &B,
1511 const AttributeList &Attrs) {
1512 assert((Name != "") && "Must specify Name to emitBinaryFloatFnCall");
1514 SmallString<20> NameBuffer;
1515 appendTypeSuffix(Op1, Name, NameBuffer);
1517 return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs);
1520 Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2,
1521 const TargetLibraryInfo *TLI,
1522 LibFunc DoubleFn, LibFunc FloatFn,
1523 LibFunc LongDoubleFn, IRBuilderBase &B,
1524 const AttributeList &Attrs) {
1525 // Get the name of the function according to TLI.
1526 StringRef Name = getFloatFnName(TLI, Op1->getType(),
1527 DoubleFn, FloatFn, LongDoubleFn);
1529 return emitBinaryFloatFnCallHelper(Op1, Op2, Name, B, Attrs, TLI);
1532 Value *llvm::emitPutChar(Value *Char, IRBuilderBase &B,
1533 const TargetLibraryInfo *TLI) {
1534 if (!TLI->has(LibFunc_putchar))
1535 return nullptr;
1537 Module *M = B.GetInsertBlock()->getModule();
1538 StringRef PutCharName = TLI->getName(LibFunc_putchar);
1539 FunctionCallee PutChar =
1540 M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());
1541 inferLibFuncAttributes(M, PutCharName, *TLI);
1542 CallInst *CI = B.CreateCall(PutChar,
1543 B.CreateIntCast(Char,
1544 B.getInt32Ty(),
1545 /*isSigned*/true,
1546 "chari"),
1547 PutCharName);
1549 if (const Function *F =
1550 dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
1551 CI->setCallingConv(F->getCallingConv());
1552 return CI;
1555 Value *llvm::emitPutS(Value *Str, IRBuilderBase &B,
1556 const TargetLibraryInfo *TLI) {
1557 if (!TLI->has(LibFunc_puts))
1558 return nullptr;
1560 Module *M = B.GetInsertBlock()->getModule();
1561 StringRef PutsName = TLI->getName(LibFunc_puts);
1562 FunctionCallee PutS =
1563 M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());
1564 inferLibFuncAttributes(M, PutsName, *TLI);
1565 CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);
1566 if (const Function *F =
1567 dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
1568 CI->setCallingConv(F->getCallingConv());
1569 return CI;
1572 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilderBase &B,
1573 const TargetLibraryInfo *TLI) {
1574 if (!TLI->has(LibFunc_fputc))
1575 return nullptr;
1577 Module *M = B.GetInsertBlock()->getModule();
1578 StringRef FPutcName = TLI->getName(LibFunc_fputc);
1579 FunctionCallee F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(),
1580 B.getInt32Ty(), File->getType());
1581 if (File->getType()->isPointerTy())
1582 inferLibFuncAttributes(M, FPutcName, *TLI);
1583 Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
1584 "chari");
1585 CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);
1587 if (const Function *Fn =
1588 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1589 CI->setCallingConv(Fn->getCallingConv());
1590 return CI;
1593 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B,
1594 const TargetLibraryInfo *TLI) {
1595 if (!TLI->has(LibFunc_fputs))
1596 return nullptr;
1598 Module *M = B.GetInsertBlock()->getModule();
1599 StringRef FPutsName = TLI->getName(LibFunc_fputs);
1600 FunctionCallee F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
1601 B.getInt8PtrTy(), File->getType());
1602 if (File->getType()->isPointerTy())
1603 inferLibFuncAttributes(M, FPutsName, *TLI);
1604 CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);
1606 if (const Function *Fn =
1607 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1608 CI->setCallingConv(Fn->getCallingConv());
1609 return CI;
1612 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B,
1613 const DataLayout &DL, const TargetLibraryInfo *TLI) {
1614 if (!TLI->has(LibFunc_fwrite))
1615 return nullptr;
1617 Module *M = B.GetInsertBlock()->getModule();
1618 LLVMContext &Context = B.GetInsertBlock()->getContext();
1619 StringRef FWriteName = TLI->getName(LibFunc_fwrite);
1620 FunctionCallee F = M->getOrInsertFunction(
1621 FWriteName, DL.getIntPtrType(Context), B.getInt8PtrTy(),
1622 DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());
1624 if (File->getType()->isPointerTy())
1625 inferLibFuncAttributes(M, FWriteName, *TLI);
1626 CallInst *CI =
1627 B.CreateCall(F, {castToCStr(Ptr, B), Size,
1628 ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1630 if (const Function *Fn =
1631 dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
1632 CI->setCallingConv(Fn->getCallingConv());
1633 return CI;
1636 Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL,
1637 const TargetLibraryInfo *TLI) {
1638 if (!TLI->has(LibFunc_malloc))
1639 return nullptr;
1641 Module *M = B.GetInsertBlock()->getModule();
1642 StringRef MallocName = TLI->getName(LibFunc_malloc);
1643 LLVMContext &Context = B.GetInsertBlock()->getContext();
1644 FunctionCallee Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),
1645 DL.getIntPtrType(Context));
1646 inferLibFuncAttributes(M, MallocName, *TLI);
1647 CallInst *CI = B.CreateCall(Malloc, Num, MallocName);
1649 if (const Function *F =
1650 dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
1651 CI->setCallingConv(F->getCallingConv());
1653 return CI;
1656 Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B,
1657 const TargetLibraryInfo &TLI) {
1658 if (!TLI.has(LibFunc_calloc))
1659 return nullptr;
1661 Module *M = B.GetInsertBlock()->getModule();
1662 StringRef CallocName = TLI.getName(LibFunc_calloc);
1663 const DataLayout &DL = M->getDataLayout();
1664 IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));
1665 FunctionCallee Calloc =
1666 M->getOrInsertFunction(CallocName, B.getInt8PtrTy(), PtrType, PtrType);
1667 inferLibFuncAttributes(M, CallocName, TLI);
1668 CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);
1670 if (const auto *F =
1671 dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
1672 CI->setCallingConv(F->getCallingConv());
1674 return CI;