← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/CodeGen/IntrinsicLowering.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/CodeGen/IntrinsicLowering.cpp
 
1
//===-- IntrinsicLowering.cpp - Intrinsic Lowering default implementation -===//
 
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 the IntrinsicLowering class.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "llvm/Constants.h"
 
15
#include "llvm/DerivedTypes.h"
 
16
#include "llvm/Module.h"
 
17
#include "llvm/Type.h"
 
18
#include "llvm/CodeGen/IntrinsicLowering.h"
 
19
#include "llvm/Support/CallSite.h"
 
20
#include "llvm/Support/ErrorHandling.h"
 
21
#include "llvm/Support/IRBuilder.h"
 
22
#include "llvm/Support/raw_ostream.h"
 
23
#include "llvm/Target/TargetData.h"
 
24
#include "llvm/ADT/SmallVector.h"
 
25
using namespace llvm;
 
26
 
 
27
template <class ArgIt>
 
28
static void EnsureFunctionExists(Module &M, const char *Name,
 
29
                                 ArgIt ArgBegin, ArgIt ArgEnd,
 
30
                                 const Type *RetTy) {
 
31
  // Insert a correctly-typed definition now.
 
32
  std::vector<const Type *> ParamTys;
 
33
  for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
 
34
    ParamTys.push_back(I->getType());
 
35
  M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false));
 
36
}
 
37
 
 
38
static void EnsureFPIntrinsicsExist(Module &M, Function *Fn,
 
39
                                    const char *FName,
 
40
                                    const char *DName, const char *LDName) {
 
41
  // Insert definitions for all the floating point types.
 
42
  switch((int)Fn->arg_begin()->getType()->getTypeID()) {
 
43
  case Type::FloatTyID:
 
44
    EnsureFunctionExists(M, FName, Fn->arg_begin(), Fn->arg_end(),
 
45
                         Type::getFloatTy(M.getContext()));
 
46
    break;
 
47
  case Type::DoubleTyID:
 
48
    EnsureFunctionExists(M, DName, Fn->arg_begin(), Fn->arg_end(),
 
49
                         Type::getDoubleTy(M.getContext()));
 
50
    break;
 
51
  case Type::X86_FP80TyID:
 
52
  case Type::FP128TyID:
 
53
  case Type::PPC_FP128TyID:
 
54
    EnsureFunctionExists(M, LDName, Fn->arg_begin(), Fn->arg_end(),
 
55
                         Fn->arg_begin()->getType());
 
56
    break;
 
57
  }
 
58
}
 
59
 
 
60
/// ReplaceCallWith - This function is used when we want to lower an intrinsic
 
61
/// call to a call of an external function.  This handles hard cases such as
 
62
/// when there was already a prototype for the external function, and if that
 
63
/// prototype doesn't match the arguments we expect to pass in.
 
64
template <class ArgIt>
 
65
static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
 
66
                                 ArgIt ArgBegin, ArgIt ArgEnd,
 
67
                                 const Type *RetTy) {
 
68
  // If we haven't already looked up this function, check to see if the
 
69
  // program already contains a function with this name.
 
70
  Module *M = CI->getParent()->getParent()->getParent();
 
71
  // Get or insert the definition now.
 
72
  std::vector<const Type *> ParamTys;
 
73
  for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
 
74
    ParamTys.push_back((*I)->getType());
 
75
  Constant* FCache = M->getOrInsertFunction(NewFn,
 
76
                                  FunctionType::get(RetTy, ParamTys, false));
 
77
 
 
78
  IRBuilder<> Builder(CI->getParent(), CI);
 
79
  SmallVector<Value *, 8> Args(ArgBegin, ArgEnd);
 
80
  CallInst *NewCI = Builder.CreateCall(FCache, Args.begin(), Args.end());
 
81
  NewCI->setName(CI->getName());
 
82
  if (!CI->use_empty())
 
83
    CI->replaceAllUsesWith(NewCI);
 
84
  return NewCI;
 
85
}
 
86
 
 
87
// VisualStudio defines setjmp as _setjmp
 
88
#if defined(_MSC_VER) && defined(setjmp)
 
89
#define setjmp_undefined_for_visual_studio
 
90
#undef setjmp
 
91
#endif
 
92
 
 
93
void IntrinsicLowering::AddPrototypes(Module &M) {
 
94
  LLVMContext &Context = M.getContext();
 
95
  for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
 
96
    if (I->isDeclaration() && !I->use_empty())
 
97
      switch (I->getIntrinsicID()) {
 
98
      default: break;
 
99
      case Intrinsic::setjmp:
 
100
        EnsureFunctionExists(M, "setjmp", I->arg_begin(), I->arg_end(),
 
101
                             Type::getInt32Ty(M.getContext()));
 
102
        break;
 
103
      case Intrinsic::longjmp:
 
104
        EnsureFunctionExists(M, "longjmp", I->arg_begin(), I->arg_end(),
 
105
                             Type::getVoidTy(M.getContext()));
 
106
        break;
 
107
      case Intrinsic::siglongjmp:
 
108
        EnsureFunctionExists(M, "abort", I->arg_end(), I->arg_end(),
 
109
                             Type::getVoidTy(M.getContext()));
 
110
        break;
 
111
      case Intrinsic::memcpy:
 
112
        M.getOrInsertFunction("memcpy",
 
113
          Type::getInt8PtrTy(Context),
 
114
                              Type::getInt8PtrTy(Context), 
 
115
                              Type::getInt8PtrTy(Context), 
 
116
                              TD.getIntPtrType(Context), (Type *)0);
 
117
        break;
 
118
      case Intrinsic::memmove:
 
119
        M.getOrInsertFunction("memmove",
 
120
          Type::getInt8PtrTy(Context),
 
121
                              Type::getInt8PtrTy(Context), 
 
122
                              Type::getInt8PtrTy(Context), 
 
123
                              TD.getIntPtrType(Context), (Type *)0);
 
124
        break;
 
125
      case Intrinsic::memset:
 
126
        M.getOrInsertFunction("memset",
 
127
          Type::getInt8PtrTy(Context),
 
128
                              Type::getInt8PtrTy(Context), 
 
129
                              Type::getInt32Ty(M.getContext()), 
 
130
                              TD.getIntPtrType(Context), (Type *)0);
 
131
        break;
 
132
      case Intrinsic::sqrt:
 
133
        EnsureFPIntrinsicsExist(M, I, "sqrtf", "sqrt", "sqrtl");
 
134
        break;
 
135
      case Intrinsic::sin:
 
136
        EnsureFPIntrinsicsExist(M, I, "sinf", "sin", "sinl");
 
137
        break;
 
138
      case Intrinsic::cos:
 
139
        EnsureFPIntrinsicsExist(M, I, "cosf", "cos", "cosl");
 
140
        break;
 
141
      case Intrinsic::pow:
 
142
        EnsureFPIntrinsicsExist(M, I, "powf", "pow", "powl");
 
143
        break;
 
144
      case Intrinsic::log:
 
145
        EnsureFPIntrinsicsExist(M, I, "logf", "log", "logl");
 
146
        break;
 
147
      case Intrinsic::log2:
 
148
        EnsureFPIntrinsicsExist(M, I, "log2f", "log2", "log2l");
 
149
        break;
 
150
      case Intrinsic::log10:
 
151
        EnsureFPIntrinsicsExist(M, I, "log10f", "log10", "log10l");
 
152
        break;
 
153
      case Intrinsic::exp:
 
154
        EnsureFPIntrinsicsExist(M, I, "expf", "exp", "expl");
 
155
        break;
 
156
      case Intrinsic::exp2:
 
157
        EnsureFPIntrinsicsExist(M, I, "exp2f", "exp2", "exp2l");
 
158
        break;
 
159
      }
 
160
}
 
161
 
 
162
/// LowerBSWAP - Emit the code to lower bswap of V before the specified
 
163
/// instruction IP.
 
164
static Value *LowerBSWAP(LLVMContext &Context, Value *V, Instruction *IP) {
 
165
  assert(V->getType()->isIntegerTy() && "Can't bswap a non-integer type!");
 
166
 
 
167
  unsigned BitSize = V->getType()->getPrimitiveSizeInBits();
 
168
  
 
169
  IRBuilder<> Builder(IP->getParent(), IP);
 
170
 
 
171
  switch(BitSize) {
 
172
  default: llvm_unreachable("Unhandled type size of value to byteswap!");
 
173
  case 16: {
 
174
    Value *Tmp1 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 8),
 
175
                                    "bswap.2");
 
176
    Value *Tmp2 = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 8),
 
177
                                     "bswap.1");
 
178
    V = Builder.CreateOr(Tmp1, Tmp2, "bswap.i16");
 
179
    break;
 
180
  }
 
181
  case 32: {
 
182
    Value *Tmp4 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 24),
 
183
                                    "bswap.4");
 
184
    Value *Tmp3 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 8),
 
185
                                    "bswap.3");
 
186
    Value *Tmp2 = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 8),
 
187
                                     "bswap.2");
 
188
    Value *Tmp1 = Builder.CreateLShr(V,ConstantInt::get(V->getType(), 24),
 
189
                                     "bswap.1");
 
190
    Tmp3 = Builder.CreateAnd(Tmp3,
 
191
                         ConstantInt::get(Type::getInt32Ty(Context), 0xFF0000),
 
192
                             "bswap.and3");
 
193
    Tmp2 = Builder.CreateAnd(Tmp2,
 
194
                           ConstantInt::get(Type::getInt32Ty(Context), 0xFF00),
 
195
                             "bswap.and2");
 
196
    Tmp4 = Builder.CreateOr(Tmp4, Tmp3, "bswap.or1");
 
197
    Tmp2 = Builder.CreateOr(Tmp2, Tmp1, "bswap.or2");
 
198
    V = Builder.CreateOr(Tmp4, Tmp2, "bswap.i32");
 
199
    break;
 
200
  }
 
201
  case 64: {
 
202
    Value *Tmp8 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 56),
 
203
                                    "bswap.8");
 
204
    Value *Tmp7 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 40),
 
205
                                    "bswap.7");
 
206
    Value *Tmp6 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 24),
 
207
                                    "bswap.6");
 
208
    Value *Tmp5 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 8),
 
209
                                    "bswap.5");
 
210
    Value* Tmp4 = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 8),
 
211
                                     "bswap.4");
 
212
    Value* Tmp3 = Builder.CreateLShr(V, 
 
213
                                     ConstantInt::get(V->getType(), 24),
 
214
                                     "bswap.3");
 
215
    Value* Tmp2 = Builder.CreateLShr(V, 
 
216
                                     ConstantInt::get(V->getType(), 40),
 
217
                                     "bswap.2");
 
218
    Value* Tmp1 = Builder.CreateLShr(V, 
 
219
                                     ConstantInt::get(V->getType(), 56),
 
220
                                     "bswap.1");
 
221
    Tmp7 = Builder.CreateAnd(Tmp7,
 
222
                             ConstantInt::get(Type::getInt64Ty(Context),
 
223
                                              0xFF000000000000ULL),
 
224
                             "bswap.and7");
 
225
    Tmp6 = Builder.CreateAnd(Tmp6,
 
226
                             ConstantInt::get(Type::getInt64Ty(Context),
 
227
                                              0xFF0000000000ULL),
 
228
                             "bswap.and6");
 
229
    Tmp5 = Builder.CreateAnd(Tmp5,
 
230
                        ConstantInt::get(Type::getInt64Ty(Context),
 
231
                             0xFF00000000ULL),
 
232
                             "bswap.and5");
 
233
    Tmp4 = Builder.CreateAnd(Tmp4,
 
234
                        ConstantInt::get(Type::getInt64Ty(Context),
 
235
                             0xFF000000ULL),
 
236
                             "bswap.and4");
 
237
    Tmp3 = Builder.CreateAnd(Tmp3,
 
238
                             ConstantInt::get(Type::getInt64Ty(Context),
 
239
                             0xFF0000ULL),
 
240
                             "bswap.and3");
 
241
    Tmp2 = Builder.CreateAnd(Tmp2,
 
242
                             ConstantInt::get(Type::getInt64Ty(Context),
 
243
                             0xFF00ULL),
 
244
                             "bswap.and2");
 
245
    Tmp8 = Builder.CreateOr(Tmp8, Tmp7, "bswap.or1");
 
246
    Tmp6 = Builder.CreateOr(Tmp6, Tmp5, "bswap.or2");
 
247
    Tmp4 = Builder.CreateOr(Tmp4, Tmp3, "bswap.or3");
 
248
    Tmp2 = Builder.CreateOr(Tmp2, Tmp1, "bswap.or4");
 
249
    Tmp8 = Builder.CreateOr(Tmp8, Tmp6, "bswap.or5");
 
250
    Tmp4 = Builder.CreateOr(Tmp4, Tmp2, "bswap.or6");
 
251
    V = Builder.CreateOr(Tmp8, Tmp4, "bswap.i64");
 
252
    break;
 
253
  }
 
254
  }
 
255
  return V;
 
256
}
 
257
 
 
258
/// LowerCTPOP - Emit the code to lower ctpop of V before the specified
 
259
/// instruction IP.
 
260
static Value *LowerCTPOP(LLVMContext &Context, Value *V, Instruction *IP) {
 
261
  assert(V->getType()->isIntegerTy() && "Can't ctpop a non-integer type!");
 
262
 
 
263
  static const uint64_t MaskValues[6] = {
 
264
    0x5555555555555555ULL, 0x3333333333333333ULL,
 
265
    0x0F0F0F0F0F0F0F0FULL, 0x00FF00FF00FF00FFULL,
 
266
    0x0000FFFF0000FFFFULL, 0x00000000FFFFFFFFULL
 
267
  };
 
268
 
 
269
  IRBuilder<> Builder(IP->getParent(), IP);
 
270
 
 
271
  unsigned BitSize = V->getType()->getPrimitiveSizeInBits();
 
272
  unsigned WordSize = (BitSize + 63) / 64;
 
273
  Value *Count = ConstantInt::get(V->getType(), 0);
 
274
 
 
275
  for (unsigned n = 0; n < WordSize; ++n) {
 
276
    Value *PartValue = V;
 
277
    for (unsigned i = 1, ct = 0; i < (BitSize>64 ? 64 : BitSize); 
 
278
         i <<= 1, ++ct) {
 
279
      Value *MaskCst = ConstantInt::get(V->getType(), MaskValues[ct]);
 
280
      Value *LHS = Builder.CreateAnd(PartValue, MaskCst, "cppop.and1");
 
281
      Value *VShift = Builder.CreateLShr(PartValue,
 
282
                                        ConstantInt::get(V->getType(), i),
 
283
                                         "ctpop.sh");
 
284
      Value *RHS = Builder.CreateAnd(VShift, MaskCst, "cppop.and2");
 
285
      PartValue = Builder.CreateAdd(LHS, RHS, "ctpop.step");
 
286
    }
 
287
    Count = Builder.CreateAdd(PartValue, Count, "ctpop.part");
 
288
    if (BitSize > 64) {
 
289
      V = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 64),
 
290
                             "ctpop.part.sh");
 
291
      BitSize -= 64;
 
292
    }
 
293
  }
 
294
 
 
295
  return Count;
 
296
}
 
297
 
 
298
/// LowerCTLZ - Emit the code to lower ctlz of V before the specified
 
299
/// instruction IP.
 
300
static Value *LowerCTLZ(LLVMContext &Context, Value *V, Instruction *IP) {
 
301
 
 
302
  IRBuilder<> Builder(IP->getParent(), IP);
 
303
 
 
304
  unsigned BitSize = V->getType()->getPrimitiveSizeInBits();
 
305
  for (unsigned i = 1; i < BitSize; i <<= 1) {
 
306
    Value *ShVal = ConstantInt::get(V->getType(), i);
 
307
    ShVal = Builder.CreateLShr(V, ShVal, "ctlz.sh");
 
308
    V = Builder.CreateOr(V, ShVal, "ctlz.step");
 
309
  }
 
310
 
 
311
  V = Builder.CreateNot(V);
 
312
  return LowerCTPOP(Context, V, IP);
 
313
}
 
314
 
 
315
static void ReplaceFPIntrinsicWithCall(CallInst *CI, const char *Fname,
 
316
                                       const char *Dname,
 
317
                                       const char *LDname) {
 
318
  CallSite CS(CI);
 
319
  switch (CI->getArgOperand(0)->getType()->getTypeID()) {
 
320
  default: llvm_unreachable("Invalid type in intrinsic");
 
321
  case Type::FloatTyID:
 
322
    ReplaceCallWith(Fname, CI, CS.arg_begin(), CS.arg_end(),
 
323
                  Type::getFloatTy(CI->getContext()));
 
324
    break;
 
325
  case Type::DoubleTyID:
 
326
    ReplaceCallWith(Dname, CI, CS.arg_begin(), CS.arg_end(),
 
327
                  Type::getDoubleTy(CI->getContext()));
 
328
    break;
 
329
  case Type::X86_FP80TyID:
 
330
  case Type::FP128TyID:
 
331
  case Type::PPC_FP128TyID:
 
332
    ReplaceCallWith(LDname, CI, CS.arg_begin(), CS.arg_end(),
 
333
                  CI->getArgOperand(0)->getType());
 
334
    break;
 
335
  }
 
336
}
 
337
 
 
338
void IntrinsicLowering::LowerIntrinsicCall(CallInst *CI) {
 
339
  IRBuilder<> Builder(CI->getParent(), CI);
 
340
  LLVMContext &Context = CI->getContext();
 
341
 
 
342
  const Function *Callee = CI->getCalledFunction();
 
343
  assert(Callee && "Cannot lower an indirect call!");
 
344
 
 
345
  CallSite CS(CI);
 
346
  switch (Callee->getIntrinsicID()) {
 
347
  case Intrinsic::not_intrinsic:
 
348
    report_fatal_error("Cannot lower a call to a non-intrinsic function '"+
 
349
                      Callee->getName() + "'!");
 
350
  default:
 
351
    report_fatal_error("Code generator does not support intrinsic function '"+
 
352
                      Callee->getName()+"'!");
 
353
 
 
354
    // The setjmp/longjmp intrinsics should only exist in the code if it was
 
355
    // never optimized (ie, right out of the CFE), or if it has been hacked on
 
356
    // by the lowerinvoke pass.  In both cases, the right thing to do is to
 
357
    // convert the call to an explicit setjmp or longjmp call.
 
358
  case Intrinsic::setjmp: {
 
359
    Value *V = ReplaceCallWith("setjmp", CI, CS.arg_begin(), CS.arg_end(),
 
360
                               Type::getInt32Ty(Context));
 
361
    if (!CI->getType()->isVoidTy())
 
362
      CI->replaceAllUsesWith(V);
 
363
    break;
 
364
  }
 
365
  case Intrinsic::sigsetjmp:
 
366
     if (!CI->getType()->isVoidTy())
 
367
       CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
 
368
     break;
 
369
 
 
370
  case Intrinsic::longjmp: {
 
371
    ReplaceCallWith("longjmp", CI, CS.arg_begin(), CS.arg_end(),
 
372
                    Type::getVoidTy(Context));
 
373
    break;
 
374
  }
 
375
 
 
376
  case Intrinsic::siglongjmp: {
 
377
    // Insert the call to abort
 
378
    ReplaceCallWith("abort", CI, CS.arg_end(), CS.arg_end(), 
 
379
                    Type::getVoidTy(Context));
 
380
    break;
 
381
  }
 
382
  case Intrinsic::ctpop:
 
383
    CI->replaceAllUsesWith(LowerCTPOP(Context, CI->getArgOperand(0), CI));
 
384
    break;
 
385
 
 
386
  case Intrinsic::bswap:
 
387
    CI->replaceAllUsesWith(LowerBSWAP(Context, CI->getArgOperand(0), CI));
 
388
    break;
 
389
    
 
390
  case Intrinsic::ctlz:
 
391
    CI->replaceAllUsesWith(LowerCTLZ(Context, CI->getArgOperand(0), CI));
 
392
    break;
 
393
 
 
394
  case Intrinsic::cttz: {
 
395
    // cttz(x) -> ctpop(~X & (X-1))
 
396
    Value *Src = CI->getArgOperand(0);
 
397
    Value *NotSrc = Builder.CreateNot(Src);
 
398
    NotSrc->setName(Src->getName() + ".not");
 
399
    Value *SrcM1 = ConstantInt::get(Src->getType(), 1);
 
400
    SrcM1 = Builder.CreateSub(Src, SrcM1);
 
401
    Src = LowerCTPOP(Context, Builder.CreateAnd(NotSrc, SrcM1), CI);
 
402
    CI->replaceAllUsesWith(Src);
 
403
    break;
 
404
  }
 
405
 
 
406
  case Intrinsic::stacksave:
 
407
  case Intrinsic::stackrestore: {
 
408
    if (!Warned)
 
409
      errs() << "WARNING: this target does not support the llvm.stack"
 
410
             << (Callee->getIntrinsicID() == Intrinsic::stacksave ?
 
411
               "save" : "restore") << " intrinsic.\n";
 
412
    Warned = true;
 
413
    if (Callee->getIntrinsicID() == Intrinsic::stacksave)
 
414
      CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
 
415
    break;
 
416
  }
 
417
    
 
418
  case Intrinsic::returnaddress:
 
419
  case Intrinsic::frameaddress:
 
420
    errs() << "WARNING: this target does not support the llvm."
 
421
           << (Callee->getIntrinsicID() == Intrinsic::returnaddress ?
 
422
             "return" : "frame") << "address intrinsic.\n";
 
423
    CI->replaceAllUsesWith(ConstantPointerNull::get(
 
424
                                            cast<PointerType>(CI->getType())));
 
425
    break;
 
426
 
 
427
  case Intrinsic::prefetch:
 
428
    break;    // Simply strip out prefetches on unsupported architectures
 
429
 
 
430
  case Intrinsic::pcmarker:
 
431
    break;    // Simply strip out pcmarker on unsupported architectures
 
432
  case Intrinsic::readcyclecounter: {
 
433
    errs() << "WARNING: this target does not support the llvm.readcyclecoun"
 
434
           << "ter intrinsic.  It is being lowered to a constant 0\n";
 
435
    CI->replaceAllUsesWith(ConstantInt::get(Type::getInt64Ty(Context), 0));
 
436
    break;
 
437
  }
 
438
 
 
439
  case Intrinsic::dbg_declare:
 
440
    break;    // Simply strip out debugging intrinsics
 
441
 
 
442
  case Intrinsic::eh_exception:
 
443
  case Intrinsic::eh_selector:
 
444
    CI->replaceAllUsesWith(Constant::getNullValue(CI->getType()));
 
445
    break;
 
446
 
 
447
  case Intrinsic::eh_typeid_for:
 
448
    // Return something different to eh_selector.
 
449
    CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1));
 
450
    break;
 
451
 
 
452
  case Intrinsic::var_annotation:
 
453
    break;   // Strip out annotate intrinsic
 
454
    
 
455
  case Intrinsic::memcpy: {
 
456
    const IntegerType *IntPtr = TD.getIntPtrType(Context);
 
457
    Value *Size = Builder.CreateIntCast(CI->getArgOperand(2), IntPtr,
 
458
                                        /* isSigned */ false);
 
459
    Value *Ops[3];
 
460
    Ops[0] = CI->getArgOperand(0);
 
461
    Ops[1] = CI->getArgOperand(1);
 
462
    Ops[2] = Size;
 
463
    ReplaceCallWith("memcpy", CI, Ops, Ops+3, CI->getArgOperand(0)->getType());
 
464
    break;
 
465
  }
 
466
  case Intrinsic::memmove: {
 
467
    const IntegerType *IntPtr = TD.getIntPtrType(Context);
 
468
    Value *Size = Builder.CreateIntCast(CI->getArgOperand(2), IntPtr,
 
469
                                        /* isSigned */ false);
 
470
    Value *Ops[3];
 
471
    Ops[0] = CI->getArgOperand(0);
 
472
    Ops[1] = CI->getArgOperand(1);
 
473
    Ops[2] = Size;
 
474
    ReplaceCallWith("memmove", CI, Ops, Ops+3, CI->getArgOperand(0)->getType());
 
475
    break;
 
476
  }
 
477
  case Intrinsic::memset: {
 
478
    const IntegerType *IntPtr = TD.getIntPtrType(Context);
 
479
    Value *Size = Builder.CreateIntCast(CI->getArgOperand(2), IntPtr,
 
480
                                        /* isSigned */ false);
 
481
    Value *Ops[3];
 
482
    Ops[0] = CI->getArgOperand(0);
 
483
    // Extend the amount to i32.
 
484
    Ops[1] = Builder.CreateIntCast(CI->getArgOperand(1),
 
485
                                   Type::getInt32Ty(Context),
 
486
                                   /* isSigned */ false);
 
487
    Ops[2] = Size;
 
488
    ReplaceCallWith("memset", CI, Ops, Ops+3, CI->getArgOperand(0)->getType());
 
489
    break;
 
490
  }
 
491
  case Intrinsic::sqrt: {
 
492
    ReplaceFPIntrinsicWithCall(CI, "sqrtf", "sqrt", "sqrtl");
 
493
    break;
 
494
  }
 
495
  case Intrinsic::log: {
 
496
    ReplaceFPIntrinsicWithCall(CI, "logf", "log", "logl");
 
497
    break;
 
498
  }
 
499
  case Intrinsic::log2: {
 
500
    ReplaceFPIntrinsicWithCall(CI, "log2f", "log2", "log2l");
 
501
    break;
 
502
  }
 
503
  case Intrinsic::log10: {
 
504
    ReplaceFPIntrinsicWithCall(CI, "log10f", "log10", "log10l");
 
505
    break;
 
506
  }
 
507
  case Intrinsic::exp: {
 
508
    ReplaceFPIntrinsicWithCall(CI, "expf", "exp", "expl");
 
509
    break;
 
510
  }
 
511
  case Intrinsic::exp2: {
 
512
    ReplaceFPIntrinsicWithCall(CI, "exp2f", "exp2", "exp2l");
 
513
    break;
 
514
  }
 
515
  case Intrinsic::pow: {
 
516
    ReplaceFPIntrinsicWithCall(CI, "powf", "pow", "powl");
 
517
    break;
 
518
  }
 
519
  case Intrinsic::flt_rounds:
 
520
     // Lower to "round to the nearest"
 
521
     if (!CI->getType()->isVoidTy())
 
522
       CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1));
 
523
     break;
 
524
  case Intrinsic::invariant_start:
 
525
  case Intrinsic::lifetime_start:
 
526
    // Discard region information.
 
527
    CI->replaceAllUsesWith(UndefValue::get(CI->getType()));
 
528
    break;
 
529
  case Intrinsic::invariant_end:
 
530
  case Intrinsic::lifetime_end:
 
531
    // Discard region information.
 
532
    break;
 
533
  }
 
534
 
 
535
  assert(CI->use_empty() &&
 
536
         "Lowering should have eliminated any uses of the intrinsic call!");
 
537
  CI->eraseFromParent();
 
538
}