lib/Transforms/Utils/BuildLibCalls.cpp

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