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/IR/Constants.h"
17 #include "llvm/IR/DataLayout.h"
18 #include "llvm/IR/Function.h"
19 #include "llvm/IR/IRBuilder.h"
20 #include "llvm/IR/Intrinsics.h"
21 #include "llvm/IR/LLVMContext.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/IR/Type.h"
24 #include "llvm/Target/TargetLibraryInfo.h"
25 
26 using namespace llvm;
27 
28 /// CastToCStr - Return V if it is an i8*, otherwise cast it to i8*.
29 Value *llvm::CastToCStr(Value *V, IRBuilder<> &B) {
30   return B.CreateBitCast(V, B.getInt8PtrTy(), "cstr");
31 }
32 
33 /// EmitStrLen - Emit a call to the strlen function to the builder, for the
34 /// specified pointer.  This always returns an integer value of size intptr_t.
35 Value *llvm::EmitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout *TD,
36                         const TargetLibraryInfo *TLI) {
37   if (!TLI->has(LibFunc::strlen))
38     return 0;
39 
40   Module *M = B.GetInsertBlock()->getParent()->getParent();
41   AttributeSet AS[2];
42   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
43   Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
44   AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
45                             ArrayRef<Attribute::AttrKind>(AVs, 2));
46 
47   LLVMContext &Context = B.GetInsertBlock()->getContext();
48   Constant *StrLen = M->getOrInsertFunction("strlen",
49                                             AttributeSet::get(M->getContext(),
50                                                               AS),
51                                             TD->getIntPtrType(Context),
52                                             B.getInt8PtrTy(),
53                                             NULL);
54   CallInst *CI = B.CreateCall(StrLen, CastToCStr(Ptr, B), "strlen");
55   if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
56     CI->setCallingConv(F->getCallingConv());
57 
58   return CI;
59 }
60 
61 /// EmitStrNLen - Emit a call to the strnlen function to the builder, for the
62 /// specified pointer.  Ptr is required to be some pointer type, MaxLen must
63 /// be of size_t type, and the return value has 'intptr_t' type.
64 Value *llvm::EmitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B,
65                          const DataLayout *TD, const TargetLibraryInfo *TLI) {
66   if (!TLI->has(LibFunc::strnlen))
67     return 0;
68 
69   Module *M = B.GetInsertBlock()->getParent()->getParent();
70   AttributeSet AS[2];
71   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
72   Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
73   AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
74                             ArrayRef<Attribute::AttrKind>(AVs, 2));
75 
76   LLVMContext &Context = B.GetInsertBlock()->getContext();
77   Constant *StrNLen = M->getOrInsertFunction("strnlen",
78                                              AttributeSet::get(M->getContext(),
79                                                               AS),
80                                              TD->getIntPtrType(Context),
81                                              B.getInt8PtrTy(),
82                                              TD->getIntPtrType(Context),
83                                              NULL);
84   CallInst *CI = B.CreateCall2(StrNLen, CastToCStr(Ptr, B), MaxLen, "strnlen");
85   if (const Function *F = dyn_cast<Function>(StrNLen->stripPointerCasts()))
86     CI->setCallingConv(F->getCallingConv());
87 
88   return CI;
89 }
90 
91 /// EmitStrChr - Emit a call to the strchr function to the builder, for the
92 /// specified pointer and character.  Ptr is required to be some pointer type,
93 /// and the return value has 'i8*' type.
94 Value *llvm::EmitStrChr(Value *Ptr, char C, IRBuilder<> &B,
95                         const DataLayout *TD, const TargetLibraryInfo *TLI) {
96   if (!TLI->has(LibFunc::strchr))
97     return 0;
98 
99   Module *M = B.GetInsertBlock()->getParent()->getParent();
100   Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
101   AttributeSet AS =
102     AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
103                       ArrayRef<Attribute::AttrKind>(AVs, 2));
104 
105   Type *I8Ptr = B.getInt8PtrTy();
106   Type *I32Ty = B.getInt32Ty();
107   Constant *StrChr = M->getOrInsertFunction("strchr",
108                                             AttributeSet::get(M->getContext(),
109                                                              AS),
110                                             I8Ptr, I8Ptr, I32Ty, NULL);
111   CallInst *CI = B.CreateCall2(StrChr, CastToCStr(Ptr, B),
112                                ConstantInt::get(I32Ty, C), "strchr");
113   if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))
114     CI->setCallingConv(F->getCallingConv());
115   return CI;
116 }
117 
118 /// EmitStrNCmp - Emit a call to the strncmp function to the builder.
119 Value *llvm::EmitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len,
120                          IRBuilder<> &B, const DataLayout *TD,
121                          const TargetLibraryInfo *TLI) {
122   if (!TLI->has(LibFunc::strncmp))
123     return 0;
124 
125   Module *M = B.GetInsertBlock()->getParent()->getParent();
126   AttributeSet AS[3];
127   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
128   AS[1] = AttributeSet::get(M->getContext(), 2, Attribute::NoCapture);
129   Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
130   AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
131                             ArrayRef<Attribute::AttrKind>(AVs, 2));
132 
133   LLVMContext &Context = B.GetInsertBlock()->getContext();
134   Value *StrNCmp = M->getOrInsertFunction("strncmp",
135                                           AttributeSet::get(M->getContext(),
136                                                            AS),
137                                           B.getInt32Ty(),
138                                           B.getInt8PtrTy(),
139                                           B.getInt8PtrTy(),
140                                           TD->getIntPtrType(Context), NULL);
141   CallInst *CI = B.CreateCall3(StrNCmp, CastToCStr(Ptr1, B),
142                                CastToCStr(Ptr2, B), Len, "strncmp");
143 
144   if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))
145     CI->setCallingConv(F->getCallingConv());
146 
147   return CI;
148 }
149 
150 /// EmitStrCpy - Emit a call to the strcpy function to the builder, for the
151 /// specified pointer arguments.
152 Value *llvm::EmitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
153                         const DataLayout *TD, const TargetLibraryInfo *TLI,
154                         StringRef Name) {
155   if (!TLI->has(LibFunc::strcpy))
156     return 0;
157 
158   Module *M = B.GetInsertBlock()->getParent()->getParent();
159   AttributeSet AS[2];
160   AS[0] = AttributeSet::get(M->getContext(), 2, Attribute::NoCapture);
161   AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
162                             Attribute::NoUnwind);
163   Type *I8Ptr = B.getInt8PtrTy();
164   Value *StrCpy = M->getOrInsertFunction(Name,
165                                          AttributeSet::get(M->getContext(), AS),
166                                          I8Ptr, I8Ptr, I8Ptr, NULL);
167   CallInst *CI = B.CreateCall2(StrCpy, CastToCStr(Dst, B), CastToCStr(Src, B),
168                                Name);
169   if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
170     CI->setCallingConv(F->getCallingConv());
171   return CI;
172 }
173 
174 /// EmitStrNCpy - Emit a call to the strncpy function to the builder, for the
175 /// specified pointer arguments.
176 Value *llvm::EmitStrNCpy(Value *Dst, Value *Src, Value *Len,
177                          IRBuilder<> &B, const DataLayout *TD,
178                          const TargetLibraryInfo *TLI, StringRef Name) {
179   if (!TLI->has(LibFunc::strncpy))
180     return 0;
181 
182   Module *M = B.GetInsertBlock()->getParent()->getParent();
183   AttributeSet AS[2];
184   AS[0] = AttributeSet::get(M->getContext(), 2, Attribute::NoCapture);
185   AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
186                             Attribute::NoUnwind);
187   Type *I8Ptr = B.getInt8PtrTy();
188   Value *StrNCpy = M->getOrInsertFunction(Name,
189                                           AttributeSet::get(M->getContext(),
190                                                             AS),
191                                           I8Ptr, I8Ptr, I8Ptr,
192                                           Len->getType(), NULL);
193   CallInst *CI = B.CreateCall3(StrNCpy, CastToCStr(Dst, B), CastToCStr(Src, B),
194                                Len, "strncpy");
195   if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))
196     CI->setCallingConv(F->getCallingConv());
197   return CI;
198 }
199 
200 /// EmitMemCpyChk - Emit a call to the __memcpy_chk function to the builder.
201 /// This expects that the Len and ObjSize have type 'intptr_t' and Dst/Src
202 /// are pointers.
203 Value *llvm::EmitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
204                            IRBuilder<> &B, const DataLayout *TD,
205                            const TargetLibraryInfo *TLI) {
206   if (!TLI->has(LibFunc::memcpy_chk))
207     return 0;
208 
209   Module *M = B.GetInsertBlock()->getParent()->getParent();
210   AttributeSet AS;
211   AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
212                          Attribute::NoUnwind);
213   LLVMContext &Context = B.GetInsertBlock()->getContext();
214   Value *MemCpy = M->getOrInsertFunction("__memcpy_chk",
215                                          AttributeSet::get(M->getContext(), AS),
216                                          B.getInt8PtrTy(),
217                                          B.getInt8PtrTy(),
218                                          B.getInt8PtrTy(),
219                                          TD->getIntPtrType(Context),
220                                          TD->getIntPtrType(Context), NULL);
221   Dst = CastToCStr(Dst, B);
222   Src = CastToCStr(Src, B);
223   CallInst *CI = B.CreateCall4(MemCpy, Dst, Src, Len, ObjSize);
224   if (const Function *F = dyn_cast<Function>(MemCpy->stripPointerCasts()))
225     CI->setCallingConv(F->getCallingConv());
226   return CI;
227 }
228 
229 /// EmitMemChr - Emit a call to the memchr function.  This assumes that Ptr is
230 /// a pointer, Val is an i32 value, and Len is an 'intptr_t' value.
231 Value *llvm::EmitMemChr(Value *Ptr, Value *Val,
232                         Value *Len, IRBuilder<> &B, const DataLayout *TD,
233                         const TargetLibraryInfo *TLI) {
234   if (!TLI->has(LibFunc::memchr))
235     return 0;
236 
237   Module *M = B.GetInsertBlock()->getParent()->getParent();
238   AttributeSet AS;
239   Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
240   AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
241                          ArrayRef<Attribute::AttrKind>(AVs, 2));
242   LLVMContext &Context = B.GetInsertBlock()->getContext();
243   Value *MemChr = M->getOrInsertFunction("memchr",
244                                          AttributeSet::get(M->getContext(), AS),
245                                          B.getInt8PtrTy(),
246                                          B.getInt8PtrTy(),
247                                          B.getInt32Ty(),
248                                          TD->getIntPtrType(Context),
249                                          NULL);
250   CallInst *CI = B.CreateCall3(MemChr, CastToCStr(Ptr, B), Val, Len, "memchr");
251 
252   if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
253     CI->setCallingConv(F->getCallingConv());
254 
255   return CI;
256 }
257 
258 /// EmitMemCmp - Emit a call to the memcmp function.
259 Value *llvm::EmitMemCmp(Value *Ptr1, Value *Ptr2,
260                         Value *Len, IRBuilder<> &B, const DataLayout *TD,
261                         const TargetLibraryInfo *TLI) {
262   if (!TLI->has(LibFunc::memcmp))
263     return 0;
264 
265   Module *M = B.GetInsertBlock()->getParent()->getParent();
266   AttributeSet AS[3];
267   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
268   AS[1] = AttributeSet::get(M->getContext(), 2, Attribute::NoCapture);
269   Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
270   AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
271                             ArrayRef<Attribute::AttrKind>(AVs, 2));
272 
273   LLVMContext &Context = B.GetInsertBlock()->getContext();
274   Value *MemCmp = M->getOrInsertFunction("memcmp",
275                                          AttributeSet::get(M->getContext(), AS),
276                                          B.getInt32Ty(),
277                                          B.getInt8PtrTy(),
278                                          B.getInt8PtrTy(),
279                                          TD->getIntPtrType(Context), NULL);
280   CallInst *CI = B.CreateCall3(MemCmp, CastToCStr(Ptr1, B), CastToCStr(Ptr2, B),
281                                Len, "memcmp");
282 
283   if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))
284     CI->setCallingConv(F->getCallingConv());
285 
286   return CI;
287 }
288 
289 /// Append a suffix to the function name according to the type of 'Op'.
290 static void AppendTypeSuffix(Value *Op, StringRef &Name, SmallString<20> &NameBuffer) {
291   if (!Op->getType()->isDoubleTy()) {
292       NameBuffer += Name;
293 
294     if (Op->getType()->isFloatTy())
295       NameBuffer += 'f';
296     else
297       NameBuffer += 'l';
298 
299     Name = NameBuffer;
300   }
301   return;
302 }
303 
304 /// EmitUnaryFloatFnCall - Emit a call to the unary function named 'Name' (e.g.
305 /// 'floor').  This function is known to take a single of type matching 'Op' and
306 /// returns one value with the same type.  If 'Op' is a long double, 'l' is
307 /// added as the suffix of name, if 'Op' is a float, we add a 'f' suffix.
308 Value *llvm::EmitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
309                                   const AttributeSet &Attrs) {
310   SmallString<20> NameBuffer;
311   AppendTypeSuffix(Op, Name, NameBuffer);
312 
313   Module *M = B.GetInsertBlock()->getParent()->getParent();
314   Value *Callee = M->getOrInsertFunction(Name, Op->getType(),
315                                          Op->getType(), NULL);
316   CallInst *CI = B.CreateCall(Callee, Op, Name);
317   CI->setAttributes(Attrs);
318   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
319     CI->setCallingConv(F->getCallingConv());
320 
321   return CI;
322 }
323 
324 /// EmitBinaryFloatFnCall - Emit a call to the binary function named 'Name'
325 /// (e.g. 'fmin').  This function is known to take type matching 'Op1' and 'Op2'
326 /// and return one value with the same type.  If 'Op1/Op2' are long double, 'l'
327 /// is added as the suffix of name, if 'Op1/Op2' is a float, we add a 'f'
328 /// suffix.
329 Value *llvm::EmitBinaryFloatFnCall(Value *Op1, Value *Op2, StringRef Name,
330                                   IRBuilder<> &B, const AttributeSet &Attrs) {
331   SmallString<20> NameBuffer;
332   AppendTypeSuffix(Op1, Name, NameBuffer);
333 
334   Module *M = B.GetInsertBlock()->getParent()->getParent();
335   Value *Callee = M->getOrInsertFunction(Name, Op1->getType(),
336                                          Op1->getType(), Op2->getType(), NULL);
337   CallInst *CI = B.CreateCall2(Callee, Op1, Op2, Name);
338   CI->setAttributes(Attrs);
339   if (const Function *F = dyn_cast<Function>(Callee->stripPointerCasts()))
340     CI->setCallingConv(F->getCallingConv());
341 
342   return CI;
343 }
344 
345 /// EmitPutChar - Emit a call to the putchar function.  This assumes that Char
346 /// is an integer.
347 Value *llvm::EmitPutChar(Value *Char, IRBuilder<> &B, const DataLayout *TD,
348                          const TargetLibraryInfo *TLI) {
349   if (!TLI->has(LibFunc::putchar))
350     return 0;
351 
352   Module *M = B.GetInsertBlock()->getParent()->getParent();
353   Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(),
354                                           B.getInt32Ty(), NULL);
355   CallInst *CI = B.CreateCall(PutChar,
356                               B.CreateIntCast(Char,
357                               B.getInt32Ty(),
358                               /*isSigned*/true,
359                               "chari"),
360                               "putchar");
361 
362   if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))
363     CI->setCallingConv(F->getCallingConv());
364   return CI;
365 }
366 
367 /// EmitPutS - Emit a call to the puts function.  This assumes that Str is
368 /// some pointer.
369 Value *llvm::EmitPutS(Value *Str, IRBuilder<> &B, const DataLayout *TD,
370                       const TargetLibraryInfo *TLI) {
371   if (!TLI->has(LibFunc::puts))
372     return 0;
373 
374   Module *M = B.GetInsertBlock()->getParent()->getParent();
375   AttributeSet AS[2];
376   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
377   AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
378                             Attribute::NoUnwind);
379 
380   Value *PutS = M->getOrInsertFunction("puts",
381                                        AttributeSet::get(M->getContext(), AS),
382                                        B.getInt32Ty(),
383                                        B.getInt8PtrTy(),
384                                        NULL);
385   CallInst *CI = B.CreateCall(PutS, CastToCStr(Str, B), "puts");
386   if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))
387     CI->setCallingConv(F->getCallingConv());
388   return CI;
389 }
390 
391 /// EmitFPutC - Emit a call to the fputc function.  This assumes that Char is
392 /// an integer and File is a pointer to FILE.
393 Value *llvm::EmitFPutC(Value *Char, Value *File, IRBuilder<> &B,
394                        const DataLayout *TD, const TargetLibraryInfo *TLI) {
395   if (!TLI->has(LibFunc::fputc))
396     return 0;
397 
398   Module *M = B.GetInsertBlock()->getParent()->getParent();
399   AttributeSet AS[2];
400   AS[0] = AttributeSet::get(M->getContext(), 2, Attribute::NoCapture);
401   AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
402                             Attribute::NoUnwind);
403   Constant *F;
404   if (File->getType()->isPointerTy())
405     F = M->getOrInsertFunction("fputc",
406                                AttributeSet::get(M->getContext(), AS),
407                                B.getInt32Ty(),
408                                B.getInt32Ty(), File->getType(),
409                                NULL);
410   else
411     F = M->getOrInsertFunction("fputc",
412                                B.getInt32Ty(),
413                                B.getInt32Ty(),
414                                File->getType(), NULL);
415   Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,
416                          "chari");
417   CallInst *CI = B.CreateCall2(F, Char, File, "fputc");
418 
419   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
420     CI->setCallingConv(Fn->getCallingConv());
421   return CI;
422 }
423 
424 /// EmitFPutS - Emit a call to the puts function.  Str is required to be a
425 /// pointer and File is a pointer to FILE.
426 Value *llvm::EmitFPutS(Value *Str, Value *File, IRBuilder<> &B,
427                        const DataLayout *TD, const TargetLibraryInfo *TLI) {
428   if (!TLI->has(LibFunc::fputs))
429     return 0;
430 
431   Module *M = B.GetInsertBlock()->getParent()->getParent();
432   AttributeSet AS[3];
433   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
434   AS[1] = AttributeSet::get(M->getContext(), 2, Attribute::NoCapture);
435   AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
436                             Attribute::NoUnwind);
437   StringRef FPutsName = TLI->getName(LibFunc::fputs);
438   Constant *F;
439   if (File->getType()->isPointerTy())
440     F = M->getOrInsertFunction(FPutsName,
441                                AttributeSet::get(M->getContext(), AS),
442                                B.getInt32Ty(),
443                                B.getInt8PtrTy(),
444                                File->getType(), NULL);
445   else
446     F = M->getOrInsertFunction(FPutsName, B.getInt32Ty(),
447                                B.getInt8PtrTy(),
448                                File->getType(), NULL);
449   CallInst *CI = B.CreateCall2(F, CastToCStr(Str, B), File, "fputs");
450 
451   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
452     CI->setCallingConv(Fn->getCallingConv());
453   return CI;
454 }
455 
456 /// EmitFWrite - Emit a call to the fwrite function.  This assumes that Ptr is
457 /// a pointer, Size is an 'intptr_t', and File is a pointer to FILE.
458 Value *llvm::EmitFWrite(Value *Ptr, Value *Size, Value *File,
459                         IRBuilder<> &B, const DataLayout *TD,
460                         const TargetLibraryInfo *TLI) {
461   if (!TLI->has(LibFunc::fwrite))
462     return 0;
463 
464   Module *M = B.GetInsertBlock()->getParent()->getParent();
465   AttributeSet AS[3];
466   AS[0] = AttributeSet::get(M->getContext(), 1, Attribute::NoCapture);
467   AS[1] = AttributeSet::get(M->getContext(), 4, Attribute::NoCapture);
468   AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
469                             Attribute::NoUnwind);
470   LLVMContext &Context = B.GetInsertBlock()->getContext();
471   StringRef FWriteName = TLI->getName(LibFunc::fwrite);
472   Constant *F;
473   if (File->getType()->isPointerTy())
474     F = M->getOrInsertFunction(FWriteName,
475                                AttributeSet::get(M->getContext(), AS),
476                                TD->getIntPtrType(Context),
477                                B.getInt8PtrTy(),
478                                TD->getIntPtrType(Context),
479                                TD->getIntPtrType(Context),
480                                File->getType(), NULL);
481   else
482     F = M->getOrInsertFunction(FWriteName, TD->getIntPtrType(Context),
483                                B.getInt8PtrTy(),
484                                TD->getIntPtrType(Context),
485                                TD->getIntPtrType(Context),
486                                File->getType(), NULL);
487   CallInst *CI = B.CreateCall4(F, CastToCStr(Ptr, B), Size,
488                         ConstantInt::get(TD->getIntPtrType(Context), 1), File);
489 
490   if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
491     CI->setCallingConv(Fn->getCallingConv());
492   return CI;
493 }
494 
495 SimplifyFortifiedLibCalls::~SimplifyFortifiedLibCalls() { }
496 
497 bool SimplifyFortifiedLibCalls::fold(CallInst *CI, const DataLayout *TD,
498                                      const TargetLibraryInfo *TLI) {
499   // We really need DataLayout for later.
500   if (!TD) return false;
501 
502   this->CI = CI;
503   Function *Callee = CI->getCalledFunction();
504   StringRef Name = Callee->getName();
505   FunctionType *FT = Callee->getFunctionType();
506   LLVMContext &Context = CI->getParent()->getContext();
507   IRBuilder<> B(CI);
508 
509   if (Name == "__memcpy_chk") {
510     // Check if this has the right signature.
511     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
512         !FT->getParamType(0)->isPointerTy() ||
513         !FT->getParamType(1)->isPointerTy() ||
514         FT->getParamType(2) != TD->getIntPtrType(Context) ||
515         FT->getParamType(3) != TD->getIntPtrType(Context))
516       return false;
517 
518     if (isFoldable(3, 2, false)) {
519       B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
520                      CI->getArgOperand(2), 1);
521       replaceCall(CI->getArgOperand(0));
522       return true;
523     }
524     return false;
525   }
526 
527   // Should be similar to memcpy.
528   if (Name == "__mempcpy_chk") {
529     return false;
530   }
531 
532   if (Name == "__memmove_chk") {
533     // Check if this has the right signature.
534     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
535         !FT->getParamType(0)->isPointerTy() ||
536         !FT->getParamType(1)->isPointerTy() ||
537         FT->getParamType(2) != TD->getIntPtrType(Context) ||
538         FT->getParamType(3) != TD->getIntPtrType(Context))
539       return false;
540 
541     if (isFoldable(3, 2, false)) {
542       B.CreateMemMove(CI->getArgOperand(0), CI->getArgOperand(1),
543                       CI->getArgOperand(2), 1);
544       replaceCall(CI->getArgOperand(0));
545       return true;
546     }
547     return false;
548   }
549 
550   if (Name == "__memset_chk") {
551     // Check if this has the right signature.
552     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
553         !FT->getParamType(0)->isPointerTy() ||
554         !FT->getParamType(1)->isIntegerTy() ||
555         FT->getParamType(2) != TD->getIntPtrType(Context) ||
556         FT->getParamType(3) != TD->getIntPtrType(Context))
557       return false;
558 
559     if (isFoldable(3, 2, false)) {
560       Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(),
561                                    false);
562       B.CreateMemSet(CI->getArgOperand(0), Val, CI->getArgOperand(2), 1);
563       replaceCall(CI->getArgOperand(0));
564       return true;
565     }
566     return false;
567   }
568 
569   if (Name == "__strcpy_chk" || Name == "__stpcpy_chk") {
570     // Check if this has the right signature.
571     if (FT->getNumParams() != 3 ||
572         FT->getReturnType() != FT->getParamType(0) ||
573         FT->getParamType(0) != FT->getParamType(1) ||
574         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
575         FT->getParamType(2) != TD->getIntPtrType(Context))
576       return 0;
577 
578 
579     // If a) we don't have any length information, or b) we know this will
580     // fit then just lower to a plain st[rp]cpy. Otherwise we'll keep our
581     // st[rp]cpy_chk call which may fail at runtime if the size is too long.
582     // TODO: It might be nice to get a maximum length out of the possible
583     // string lengths for varying.
584     if (isFoldable(2, 1, true)) {
585       Value *Ret = EmitStrCpy(CI->getArgOperand(0), CI->getArgOperand(1), B, TD,
586                               TLI, Name.substr(2, 6));
587       if (!Ret)
588         return false;
589       replaceCall(Ret);
590       return true;
591     }
592     return false;
593   }
594 
595   if (Name == "__strncpy_chk" || Name == "__stpncpy_chk") {
596     // Check if this has the right signature.
597     if (FT->getNumParams() != 4 || FT->getReturnType() != FT->getParamType(0) ||
598         FT->getParamType(0) != FT->getParamType(1) ||
599         FT->getParamType(0) != Type::getInt8PtrTy(Context) ||
600         !FT->getParamType(2)->isIntegerTy() ||
601         FT->getParamType(3) != TD->getIntPtrType(Context))
602       return false;
603 
604     if (isFoldable(3, 2, false)) {
605       Value *Ret = EmitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
606                                CI->getArgOperand(2), B, TD, TLI,
607                                Name.substr(2, 7));
608       if (!Ret)
609         return false;
610       replaceCall(Ret);
611       return true;
612     }
613     return false;
614   }
615 
616   if (Name == "__strcat_chk") {
617     return false;
618   }
619 
620   if (Name == "__strncat_chk") {
621     return false;
622   }
623 
624   return false;
625 }
626