1//===- BuildLibCalls.cpp - Utility builder for libcalls -------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements some functions that will create standard C libcalls.
11//
12//===----------------------------------------------------------------------===//
13
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"
26
27using namespace llvm;
28
29#define DEBUG_TYPE "build-libcalls"
30
31//- Infer Attributes ---------------------------------------------------------//
32
33STATISTIC(NumReadNone, "Number of functions inferred as readnone");
34STATISTIC(NumReadOnly, "Number of functions inferred as readonly");
35STATISTIC(NumArgMemOnly, "Number of functions inferred as argmemonly");
36STATISTIC(NumNoUnwind, "Number of functions inferred as nounwind");
37STATISTIC(NumNoCapture, "Number of arguments inferred as nocapture");
38STATISTIC(NumReadOnlyArg, "Number of arguments inferred as readonly");
39STATISTIC(NumNoAlias, "Number of function returns inferred as noalias");
40STATISTIC(NumNonNull, "Number of function returns inferred as nonnull returns");
41
42static bool setDoesNotAccessMemory(Function &F) {
43  if (F.doesNotAccessMemory())
44    return false;
45  F.setDoesNotAccessMemory();
46  ++NumReadNone;
47  return true;
48}
49
50static bool setOnlyReadsMemory(Function &F) {
51  if (F.onlyReadsMemory())
52    return false;
53  F.setOnlyReadsMemory();
54  ++NumReadOnly;
55  return true;
56}
57
58static bool setOnlyAccessesArgMemory(Function &F) {
59  if (F.onlyAccessesArgMemory())
60    return false;
61  F.setOnlyAccessesArgMemory ();
62  ++NumArgMemOnly;
63  return true;
64}
65
66static bool setDoesNotThrow(Function &F) {
67  if (F.doesNotThrow())
68    return false;
69  F.setDoesNotThrow();
70  ++NumNoUnwind;
71  return true;
72}
73
74static bool setDoesNotCapture(Function &F, unsigned n) {
75  if (F.doesNotCapture(n))
76    return false;
77  F.setDoesNotCapture(n);
78  ++NumNoCapture;
79  return true;
80}
81
82static bool setOnlyReadsMemory(Function &F, unsigned n) {
83  if (F.onlyReadsMemory(n))
84    return false;
85  F.setOnlyReadsMemory(n);
86  ++NumReadOnlyArg;
87  return true;
88}
89
90static bool setDoesNotAlias(Function &F, unsigned n) {
91  if (F.doesNotAlias(n))
92    return false;
93  F.setDoesNotAlias(n);
94  ++NumNoAlias;
95  return true;
96}
97
98static 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))
103    return false;
104  F.addAttribute(n, Attribute::NonNull);
105  ++NumNonNull;
106  return true;
107}
108
109bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
110  LibFunc::Func TheLibFunc;
111  if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
112    return false;
113
114  bool Changed = false;
115  switch (TheLibFunc) {
116  case LibFunc::strlen:
117    Changed |= setOnlyReadsMemory(F);
118    Changed |= setDoesNotThrow(F);
119    Changed |= setDoesNotCapture(F, 1);
120    return Changed;
121  case LibFunc::strchr:
122  case LibFunc::strrchr:
123    Changed |= setOnlyReadsMemory(F);
124    Changed |= setDoesNotThrow(F);
125    return Changed;
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);
136    return Changed;
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);
146    return Changed;
147  case LibFunc::strxfrm:
148    Changed |= setDoesNotThrow(F);
149    Changed |= setDoesNotCapture(F, 1);
150    Changed |= setDoesNotCapture(F, 2);
151    Changed |= setOnlyReadsMemory(F, 2);
152    return Changed;
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);
164    return Changed;
165  case LibFunc::strstr:
166  case LibFunc::strpbrk:
167    Changed |= setOnlyReadsMemory(F);
168    Changed |= setDoesNotThrow(F);
169    Changed |= setDoesNotCapture(F, 2);
170    return Changed;
171  case LibFunc::strtok:
172  case LibFunc::strtok_r:
173    Changed |= setDoesNotThrow(F);
174    Changed |= setDoesNotCapture(F, 2);
175    Changed |= setOnlyReadsMemory(F, 2);
176    return Changed;
177  case LibFunc::scanf:
178    Changed |= setDoesNotThrow(F);
179    Changed |= setDoesNotCapture(F, 1);
180    Changed |= setOnlyReadsMemory(F, 1);
181    return Changed;
182  case LibFunc::setbuf:
183  case LibFunc::setvbuf:
184    Changed |= setDoesNotThrow(F);
185    Changed |= setDoesNotCapture(F, 1);
186    return Changed;
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);
193    return Changed;
194  case LibFunc::stat:
195  case LibFunc::statvfs:
196    Changed |= setDoesNotThrow(F);
197    Changed |= setDoesNotCapture(F, 1);
198    Changed |= setDoesNotCapture(F, 2);
199    Changed |= setOnlyReadsMemory(F, 1);
200    return Changed;
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);
207    return Changed;
208  case LibFunc::sprintf:
209    Changed |= setDoesNotThrow(F);
210    Changed |= setDoesNotCapture(F, 1);
211    Changed |= setDoesNotCapture(F, 2);
212    Changed |= setOnlyReadsMemory(F, 2);
213    return Changed;
214  case LibFunc::snprintf:
215    Changed |= setDoesNotThrow(F);
216    Changed |= setDoesNotCapture(F, 1);
217    Changed |= setDoesNotCapture(F, 3);
218    Changed |= setOnlyReadsMemory(F, 3);
219    return Changed;
220  case LibFunc::setitimer:
221    Changed |= setDoesNotThrow(F);
222    Changed |= setDoesNotCapture(F, 2);
223    Changed |= setDoesNotCapture(F, 3);
224    Changed |= setOnlyReadsMemory(F, 2);
225    return Changed;
226  case LibFunc::system:
227    // May throw; "system" is a valid pthread cancellation point.
228    Changed |= setDoesNotCapture(F, 1);
229    Changed |= setOnlyReadsMemory(F, 1);
230    return Changed;
231  case LibFunc::malloc:
232    Changed |= setDoesNotThrow(F);
233    Changed |= setDoesNotAlias(F, 0);
234    return Changed;
235  case LibFunc::memcmp:
236    Changed |= setOnlyReadsMemory(F);
237    Changed |= setDoesNotThrow(F);
238    Changed |= setDoesNotCapture(F, 1);
239    Changed |= setDoesNotCapture(F, 2);
240    return Changed;
241  case LibFunc::memchr:
242  case LibFunc::memrchr:
243    Changed |= setOnlyReadsMemory(F);
244    Changed |= setDoesNotThrow(F);
245    return Changed;
246  case LibFunc::modf:
247  case LibFunc::modff:
248  case LibFunc::modfl:
249    Changed |= setDoesNotThrow(F);
250    Changed |= setDoesNotCapture(F, 2);
251    return Changed;
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);
258    return Changed;
259  case LibFunc::memcpy_chk:
260    Changed |= setDoesNotThrow(F);
261    return Changed;
262  case LibFunc::memalign:
263    Changed |= setDoesNotAlias(F, 0);
264    return Changed;
265  case LibFunc::mkdir:
266    Changed |= setDoesNotThrow(F);
267    Changed |= setDoesNotCapture(F, 1);
268    Changed |= setOnlyReadsMemory(F, 1);
269    return Changed;
270  case LibFunc::mktime:
271    Changed |= setDoesNotThrow(F);
272    Changed |= setDoesNotCapture(F, 1);
273    return Changed;
274  case LibFunc::realloc:
275    Changed |= setDoesNotThrow(F);
276    Changed |= setDoesNotAlias(F, 0);
277    Changed |= setDoesNotCapture(F, 1);
278    return Changed;
279  case LibFunc::read:
280    // May throw; "read" is a valid pthread cancellation point.
281    Changed |= setDoesNotCapture(F, 2);
282    return Changed;
283  case LibFunc::rewind:
284    Changed |= setDoesNotThrow(F);
285    Changed |= setDoesNotCapture(F, 1);
286    return Changed;
287  case LibFunc::rmdir:
288  case LibFunc::remove:
289  case LibFunc::realpath:
290    Changed |= setDoesNotThrow(F);
291    Changed |= setDoesNotCapture(F, 1);
292    Changed |= setOnlyReadsMemory(F, 1);
293    return Changed;
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);
300    return Changed;
301  case LibFunc::readlink:
302    Changed |= setDoesNotThrow(F);
303    Changed |= setDoesNotCapture(F, 1);
304    Changed |= setDoesNotCapture(F, 2);
305    Changed |= setOnlyReadsMemory(F, 1);
306    return Changed;
307  case LibFunc::write:
308    // May throw; "write" is a valid pthread cancellation point.
309    Changed |= setDoesNotCapture(F, 2);
310    Changed |= setOnlyReadsMemory(F, 2);
311    return Changed;
312  case LibFunc::bcopy:
313    Changed |= setDoesNotThrow(F);
314    Changed |= setDoesNotCapture(F, 1);
315    Changed |= setDoesNotCapture(F, 2);
316    Changed |= setOnlyReadsMemory(F, 1);
317    return Changed;
318  case LibFunc::bcmp:
319    Changed |= setDoesNotThrow(F);
320    Changed |= setOnlyReadsMemory(F);
321    Changed |= setDoesNotCapture(F, 1);
322    Changed |= setDoesNotCapture(F, 2);
323    return Changed;
324  case LibFunc::bzero:
325    Changed |= setDoesNotThrow(F);
326    Changed |= setDoesNotCapture(F, 1);
327    return Changed;
328  case LibFunc::calloc:
329    Changed |= setDoesNotThrow(F);
330    Changed |= setDoesNotAlias(F, 0);
331    return Changed;
332  case LibFunc::chmod:
333  case LibFunc::chown:
334    Changed |= setDoesNotThrow(F);
335    Changed |= setDoesNotCapture(F, 1);
336    Changed |= setOnlyReadsMemory(F, 1);
337    return Changed;
338  case LibFunc::ctermid:
339  case LibFunc::clearerr:
340  case LibFunc::closedir:
341    Changed |= setDoesNotThrow(F);
342    Changed |= setDoesNotCapture(F, 1);
343    return Changed;
344  case LibFunc::atoi:
345  case LibFunc::atol:
346  case LibFunc::atof:
347  case LibFunc::atoll:
348    Changed |= setDoesNotThrow(F);
349    Changed |= setOnlyReadsMemory(F);
350    Changed |= setDoesNotCapture(F, 1);
351    return Changed;
352  case LibFunc::access:
353    Changed |= setDoesNotThrow(F);
354    Changed |= setDoesNotCapture(F, 1);
355    Changed |= setOnlyReadsMemory(F, 1);
356    return Changed;
357  case LibFunc::fopen:
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);
364    return Changed;
365  case LibFunc::fdopen:
366    Changed |= setDoesNotThrow(F);
367    Changed |= setDoesNotAlias(F, 0);
368    Changed |= setDoesNotCapture(F, 2);
369    Changed |= setOnlyReadsMemory(F, 2);
370    return Changed;
371  case LibFunc::feof:
372  case LibFunc::free:
373  case LibFunc::fseek:
374  case LibFunc::ftell:
375  case LibFunc::fgetc:
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);
387    return Changed;
388  case LibFunc::ferror:
389    Changed |= setDoesNotThrow(F);
390    Changed |= setDoesNotCapture(F, 1);
391    Changed |= setOnlyReadsMemory(F);
392    return Changed;
393  case LibFunc::fputc:
394  case LibFunc::fstat:
395  case LibFunc::frexp:
396  case LibFunc::frexpf:
397  case LibFunc::frexpl:
398  case LibFunc::fstatvfs:
399    Changed |= setDoesNotThrow(F);
400    Changed |= setDoesNotCapture(F, 2);
401    return Changed;
402  case LibFunc::fgets:
403    Changed |= setDoesNotThrow(F);
404    Changed |= setDoesNotCapture(F, 3);
405    return Changed;
406  case LibFunc::fread:
407    Changed |= setDoesNotThrow(F);
408    Changed |= setDoesNotCapture(F, 1);
409    Changed |= setDoesNotCapture(F, 4);
410    return Changed;
411  case LibFunc::fwrite:
412    Changed |= setDoesNotThrow(F);
413    Changed |= setDoesNotCapture(F, 1);
414    Changed |= setDoesNotCapture(F, 4);
415    // FIXME: readonly #1?
416    return Changed;
417  case LibFunc::fputs:
418    Changed |= setDoesNotThrow(F);
419    Changed |= setDoesNotCapture(F, 1);
420    Changed |= setDoesNotCapture(F, 2);
421    Changed |= setOnlyReadsMemory(F, 1);
422    return Changed;
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);
429    return Changed;
430  case LibFunc::fgetpos:
431    Changed |= setDoesNotThrow(F);
432    Changed |= setDoesNotCapture(F, 1);
433    Changed |= setDoesNotCapture(F, 2);
434    return Changed;
435  case LibFunc::getc:
436  case LibFunc::getlogin_r:
437  case LibFunc::getc_unlocked:
438    Changed |= setDoesNotThrow(F);
439    Changed |= setDoesNotCapture(F, 1);
440    return Changed;
441  case LibFunc::getenv:
442    Changed |= setDoesNotThrow(F);
443    Changed |= setOnlyReadsMemory(F);
444    Changed |= setDoesNotCapture(F, 1);
445    return Changed;
446  case LibFunc::gets:
447  case LibFunc::getchar:
448    Changed |= setDoesNotThrow(F);
449    return Changed;
450  case LibFunc::getitimer:
451    Changed |= setDoesNotThrow(F);
452    Changed |= setDoesNotCapture(F, 2);
453    return Changed;
454  case LibFunc::getpwnam:
455    Changed |= setDoesNotThrow(F);
456    Changed |= setDoesNotCapture(F, 1);
457    Changed |= setOnlyReadsMemory(F, 1);
458    return Changed;
459  case LibFunc::ungetc:
460    Changed |= setDoesNotThrow(F);
461    Changed |= setDoesNotCapture(F, 2);
462    return Changed;
463  case LibFunc::uname:
464    Changed |= setDoesNotThrow(F);
465    Changed |= setDoesNotCapture(F, 1);
466    return Changed;
467  case LibFunc::unlink:
468    Changed |= setDoesNotThrow(F);
469    Changed |= setDoesNotCapture(F, 1);
470    Changed |= setOnlyReadsMemory(F, 1);
471    return Changed;
472  case LibFunc::unsetenv:
473    Changed |= setDoesNotThrow(F);
474    Changed |= setDoesNotCapture(F, 1);
475    Changed |= setOnlyReadsMemory(F, 1);
476    return Changed;
477  case LibFunc::utime:
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);
484    return Changed;
485  case LibFunc::putc:
486    Changed |= setDoesNotThrow(F);
487    Changed |= setDoesNotCapture(F, 2);
488    return Changed;
489  case LibFunc::puts:
490  case LibFunc::printf:
491  case LibFunc::perror:
492    Changed |= setDoesNotThrow(F);
493    Changed |= setDoesNotCapture(F, 1);
494    Changed |= setOnlyReadsMemory(F, 1);
495    return Changed;
496  case LibFunc::pread:
497    // May throw; "pread" is a valid pthread cancellation point.
498    Changed |= setDoesNotCapture(F, 2);
499    return Changed;
500  case LibFunc::pwrite:
501    // May throw; "pwrite" is a valid pthread cancellation point.
502    Changed |= setDoesNotCapture(F, 2);
503    Changed |= setOnlyReadsMemory(F, 2);
504    return Changed;
505  case LibFunc::putchar:
506    Changed |= setDoesNotThrow(F);
507    return Changed;
508  case LibFunc::popen:
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);
515    return Changed;
516  case LibFunc::pclose:
517    Changed |= setDoesNotThrow(F);
518    Changed |= setDoesNotCapture(F, 1);
519    return Changed;
520  case LibFunc::vscanf:
521    Changed |= setDoesNotThrow(F);
522    Changed |= setDoesNotCapture(F, 1);
523    Changed |= setOnlyReadsMemory(F, 1);
524    return Changed;
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);
531    return Changed;
532  case LibFunc::vfscanf:
533    Changed |= setDoesNotThrow(F);
534    Changed |= setDoesNotCapture(F, 1);
535    Changed |= setDoesNotCapture(F, 2);
536    Changed |= setOnlyReadsMemory(F, 2);
537    return Changed;
538  case LibFunc::valloc:
539    Changed |= setDoesNotThrow(F);
540    Changed |= setDoesNotAlias(F, 0);
541    return Changed;
542  case LibFunc::vprintf:
543    Changed |= setDoesNotThrow(F);
544    Changed |= setDoesNotCapture(F, 1);
545    Changed |= setOnlyReadsMemory(F, 1);
546    return Changed;
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);
553    return Changed;
554  case LibFunc::vsnprintf:
555    Changed |= setDoesNotThrow(F);
556    Changed |= setDoesNotCapture(F, 1);
557    Changed |= setDoesNotCapture(F, 3);
558    Changed |= setOnlyReadsMemory(F, 3);
559    return Changed;
560  case LibFunc::open:
561    // May throw; "open" is a valid pthread cancellation point.
562    Changed |= setDoesNotCapture(F, 1);
563    Changed |= setOnlyReadsMemory(F, 1);
564    return Changed;
565  case LibFunc::opendir:
566    Changed |= setDoesNotThrow(F);
567    Changed |= setDoesNotAlias(F, 0);
568    Changed |= setDoesNotCapture(F, 1);
569    Changed |= setOnlyReadsMemory(F, 1);
570    return Changed;
571  case LibFunc::tmpfile:
572    Changed |= setDoesNotThrow(F);
573    Changed |= setDoesNotAlias(F, 0);
574    return Changed;
575  case LibFunc::times:
576    Changed |= setDoesNotThrow(F);
577    Changed |= setDoesNotCapture(F, 1);
578    return Changed;
579  case LibFunc::htonl:
580  case LibFunc::htons:
581  case LibFunc::ntohl:
582  case LibFunc::ntohs:
583    Changed |= setDoesNotThrow(F);
584    Changed |= setDoesNotAccessMemory(F);
585    return Changed;
586  case LibFunc::lstat:
587    Changed |= setDoesNotThrow(F);
588    Changed |= setDoesNotCapture(F, 1);
589    Changed |= setDoesNotCapture(F, 2);
590    Changed |= setOnlyReadsMemory(F, 1);
591    return Changed;
592  case LibFunc::lchown:
593    Changed |= setDoesNotThrow(F);
594    Changed |= setDoesNotCapture(F, 1);
595    Changed |= setOnlyReadsMemory(F, 1);
596    return Changed;
597  case LibFunc::qsort:
598    // May throw; places call through function pointer.
599    Changed |= setDoesNotCapture(F, 4);
600    return Changed;
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);
607    return Changed;
608  case LibFunc::dunder_strtok_r:
609    Changed |= setDoesNotThrow(F);
610    Changed |= setDoesNotCapture(F, 2);
611    Changed |= setOnlyReadsMemory(F, 2);
612    return Changed;
613  case LibFunc::under_IO_getc:
614    Changed |= setDoesNotThrow(F);
615    Changed |= setDoesNotCapture(F, 1);
616    return Changed;
617  case LibFunc::under_IO_putc:
618    Changed |= setDoesNotThrow(F);
619    Changed |= setDoesNotCapture(F, 2);
620    return Changed;
621  case LibFunc::dunder_isoc99_scanf:
622    Changed |= setDoesNotThrow(F);
623    Changed |= setDoesNotCapture(F, 1);
624    Changed |= setOnlyReadsMemory(F, 1);
625    return Changed;
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);
633    return Changed;
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);
640    return Changed;
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);
648    return Changed;
649  case LibFunc::fseeko64:
650  case LibFunc::ftello64:
651    Changed |= setDoesNotThrow(F);
652    Changed |= setDoesNotCapture(F, 1);
653    return Changed;
654  case LibFunc::tmpfile64:
655    Changed |= setDoesNotThrow(F);
656    Changed |= setDoesNotAlias(F, 0);
657    return Changed;
658  case LibFunc::fstat64:
659  case LibFunc::fstatvfs64:
660    Changed |= setDoesNotThrow(F);
661    Changed |= setDoesNotCapture(F, 2);
662    return Changed;
663  case LibFunc::open64:
664    // May throw; "open" is a valid pthread cancellation point.
665    Changed |= setDoesNotCapture(F, 1);
666    Changed |= setOnlyReadsMemory(F, 1);
667    return Changed;
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
671    // arguments.
672    Changed |= setDoesNotThrow(F);
673    Changed |= setDoesNotCapture(F, 1);
674    Changed |= setDoesNotCapture(F, 2);
675    return Changed;
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);
687    return Changed;
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);
696    return Changed;
697  // int __nvvm_reflect(const char *)
698  case LibFunc::nvvm_reflect:
699    Changed |= setDoesNotAccessMemory(F);
700    Changed |= setDoesNotThrow(F);
701    return Changed;
702
703  default:
704    // FIXME: It'd be really nice to cover all the library functions we're
705    // aware of here.
706    return false;
707  }
708}
709
710//- Emit LibCalls ------------------------------------------------------------//
711
712Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
713  unsigned AS = V->getType()->getPointerAddressSpace();
714  return B.CreateBitCast(V, B.getInt8PtrTy(AS), "cstr");
715}
716
717Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
718                        const TargetLibraryInfo *TLI) {
719  if (!TLI->has(LibFunc::strlen))
720    return nullptr;
721
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());
730
731  return CI;
732}
733
734Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
735                        const TargetLibraryInfo *TLI) {
736  if (!TLI->has(LibFunc::strchr))
737    return nullptr;
738
739  Module *M = B.GetInsertBlock()->getModule();
740  Type *I8Ptr = B.getInt8PtrTy();
741  Type *I32Ty = B.getInt32Ty();
742  Constant *StrChr =
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());
749  return CI;
750}
751
752Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
753                         const DataLayout &DL, const TargetLibraryInfo *TLI) {
754  if (!TLI->has(LibFunc::strncmp))
755    return nullptr;
756
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");
765
766  if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
767    CI->setCallingConv(F->getCallingConv());
768
769  return CI;
770}
771
772Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
773                        const TargetLibraryInfo *TLI, StringRef Name) {
774  if (!TLI->has(LibFunc::strcpy))
775    return nullptr;
776
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);
781  CallInst *CI =
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());
785  return CI;
786}
787
788Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
789                         const TargetLibraryInfo *TLI, StringRef Name) {
790  if (!TLI->has(LibFunc::strncpy))
791    return nullptr;
792
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());
802  return CI;
803}
804
805Value *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))
809    return nullptr;
810
811  Module *M = B.GetInsertBlock()->getModule();
812  AttributeSet AS;
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());
825  return CI;
826}
827
828Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
829                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
830  if (!TLI->has(LibFunc::memchr))
831    return nullptr;
832
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");
840
841  if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
842    CI->setCallingConv(F->getCallingConv());
843
844  return CI;
845}
846
847Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
848                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
849  if (!TLI->has(LibFunc::memcmp))
850    return nullptr;
851
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");
860
861  if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
862    CI->setCallingConv(F->getCallingConv());
863
864  return CI;
865}
866
867/// Append a suffix to the function name according to the type of 'Op'.
868static void appendTypeSuffix(Value *Op, StringRef &Name,
869                             SmallString<20> &NameBuffer) {
870  if (!Op->getType()->isDoubleTy()) {
871      NameBuffer += Name;
872
873    if (Op->getType()->isFloatTy())
874      NameBuffer += 'f';
875    else
876      NameBuffer += 'l';
877
878    Name = NameBuffer;
879  }
880}
881
882Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
883                                  const AttributeSet &Attrs) {
884  SmallString<20> NameBuffer;
885  appendTypeSuffix(Op, Name, NameBuffer);
886
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());
894
895  return CI;
896}
897
898Value *llvm::emitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
899                                  IRBuilder<> &B, const AttributeSet &Attrs) {
900  SmallString<20> NameBuffer;
901  appendTypeSuffix(Op1, Name, NameBuffer);
902
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());
910
911  return CI;
912}
913
914Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
915                         const TargetLibraryInfo *TLI) {
916  if (!TLI->has(LibFunc::putchar))
917    return nullptr;
918
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,
924                              B.getInt32Ty(),
925                              /*isSigned*/true,
926                              "chari"),
927                              "putchar");
928
929  if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
930    CI->setCallingConv(F->getCallingConv());
931  return CI;
932}
933
934Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
935                      const TargetLibraryInfo *TLI) {
936  if (!TLI->has(LibFunc::puts))
937    return nullptr;
938
939  Module *M = B.GetInsertBlock()->getModule();
940  Value *PutS =
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());
946  return CI;
947}
948
949Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
950                       const TargetLibraryInfo *TLI) {
951  if (!TLI->has(LibFunc::fputc))
952    return nullptr;
953
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,
960                         "chari");
961  CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");
962
963  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
964    CI->setCallingConv(Fn->getCallingConv());
965  return CI;
966}
967
968Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
969                       const TargetLibraryInfo *TLI) {
970  if (!TLI->has(LibFunc::fputs))
971    return nullptr;
972
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");
980
981  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
982    CI->setCallingConv(Fn->getCallingConv());
983  return CI;
984}
985
986Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
987                        const DataLayout &DL, const TargetLibraryInfo *TLI) {
988  if (!TLI->has(LibFunc::fwrite))
989    return nullptr;
990
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(),
997      nullptr);
998  if (File->getType()->isPointerTy())
999    inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);
1000  CallInst *CI =
1001      B.CreateCall(F, {castToCStr(Ptr, B), Size,
1002                       ConstantInt::get(DL.getIntPtrType(Context), 1), File});
1003
1004  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
1005    CI->setCallingConv(Fn->getCallingConv());
1006  return CI;
1007}
1008