Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/IR/IRBuilder.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/IRBuilder.h - Builder for LLVM Instructions ---------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file defines the IRBuilder class, which is used as a convenient way
10
// to create LLVM instructions with a consistent and simplified interface.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_IR_IRBUILDER_H
15
#define LLVM_IR_IRBUILDER_H
16
17
#include "llvm-c/Types.h"
18
#include "llvm/ADT/ArrayRef.h"
19
#include "llvm/ADT/None.h"
20
#include "llvm/ADT/StringRef.h"
21
#include "llvm/ADT/Twine.h"
22
#include "llvm/IR/BasicBlock.h"
23
#include "llvm/IR/Constant.h"
24
#include "llvm/IR/ConstantFolder.h"
25
#include "llvm/IR/Constants.h"
26
#include "llvm/IR/DataLayout.h"
27
#include "llvm/IR/DebugLoc.h"
28
#include "llvm/IR/DerivedTypes.h"
29
#include "llvm/IR/Function.h"
30
#include "llvm/IR/GlobalVariable.h"
31
#include "llvm/IR/InstrTypes.h"
32
#include "llvm/IR/Instruction.h"
33
#include "llvm/IR/Instructions.h"
34
#include "llvm/IR/IntrinsicInst.h"
35
#include "llvm/IR/LLVMContext.h"
36
#include "llvm/IR/Module.h"
37
#include "llvm/IR/Operator.h"
38
#include "llvm/IR/Type.h"
39
#include "llvm/IR/Value.h"
40
#include "llvm/IR/ValueHandle.h"
41
#include "llvm/Support/AtomicOrdering.h"
42
#include "llvm/Support/CBindingWrapping.h"
43
#include "llvm/Support/Casting.h"
44
#include <cassert>
45
#include <cstddef>
46
#include <cstdint>
47
#include <functional>
48
#include <utility>
49
50
namespace llvm {
51
52
class APInt;
53
class MDNode;
54
class Use;
55
56
/// This provides the default implementation of the IRBuilder
57
/// 'InsertHelper' method that is called whenever an instruction is created by
58
/// IRBuilder and needs to be inserted.
59
///
60
/// By default, this inserts the instruction at the insertion point.
61
class IRBuilderDefaultInserter {
62
protected:
63
  void InsertHelper(Instruction *I, const Twine &Name,
64
20.6M
                    BasicBlock *BB, BasicBlock::iterator InsertPt) const {
65
20.6M
    if (BB) 
BB->getInstList().insert(InsertPt, I)20.6M
;
66
20.6M
    I->setName(Name);
67
20.6M
  }
68
};
69
70
/// Provides an 'InsertHelper' that calls a user-provided callback after
71
/// performing the default insertion.
72
class IRBuilderCallbackInserter : IRBuilderDefaultInserter {
73
  std::function<void(Instruction *)> Callback;
74
75
public:
76
  IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
77
3.18M
      : Callback(std::move(Callback)) {}
78
79
protected:
80
  void InsertHelper(Instruction *I, const Twine &Name,
81
477k
                    BasicBlock *BB, BasicBlock::iterator InsertPt) const {
82
477k
    IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
83
477k
    Callback(I);
84
477k
  }
85
};
86
87
/// Common base class shared among various IRBuilders.
88
class IRBuilderBase {
89
  DebugLoc CurDbgLocation;
90
91
protected:
92
  BasicBlock *BB;
93
  BasicBlock::iterator InsertPt;
94
  LLVMContext &Context;
95
96
  MDNode *DefaultFPMathTag;
97
  FastMathFlags FMF;
98
99
  bool IsFPConstrained;
100
  ConstrainedFPIntrinsic::ExceptionBehavior DefaultConstrainedExcept;
101
  ConstrainedFPIntrinsic::RoundingMode DefaultConstrainedRounding;
102
103
  ArrayRef<OperandBundleDef> DefaultOperandBundles;
104
105
public:
106
  IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr,
107
                ArrayRef<OperandBundleDef> OpBundles = None)
108
      : Context(context), DefaultFPMathTag(FPMathTag), IsFPConstrained(false),
109
        DefaultConstrainedExcept(ConstrainedFPIntrinsic::ebStrict),
110
        DefaultConstrainedRounding(ConstrainedFPIntrinsic::rmDynamic),
111
132M
        DefaultOperandBundles(OpBundles) {
112
132M
    ClearInsertionPoint();
113
132M
  }
114
115
  //===--------------------------------------------------------------------===//
116
  // Builder configuration methods
117
  //===--------------------------------------------------------------------===//
118
119
  /// Clear the insertion point: created instructions will not be
120
  /// inserted into a block.
121
135M
  void ClearInsertionPoint() {
122
135M
    BB = nullptr;
123
135M
    InsertPt = BasicBlock::iterator();
124
135M
  }
125
126
18.8M
  BasicBlock *GetInsertBlock() const { return BB; }
127
11.6M
  BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
128
32.2k
  LLVMContext &getContext() const { return Context; }
129
130
  /// This specifies that created instructions should be appended to the
131
  /// end of the specified block.
132
34.8M
  void SetInsertPoint(BasicBlock *TheBB) {
133
34.8M
    BB = TheBB;
134
34.8M
    InsertPt = BB->end();
135
34.8M
  }
136
137
  /// This specifies that created instructions should be inserted before
138
  /// the specified instruction.
139
301M
  void SetInsertPoint(Instruction *I) {
140
301M
    BB = I->getParent();
141
301M
    InsertPt = I->getIterator();
142
301M
    assert(InsertPt != BB->end() && "Can't read debug loc from end()");
143
301M
    SetCurrentDebugLocation(I->getDebugLoc());
144
301M
  }
145
146
  /// This specifies that created instructions should be inserted at the
147
  /// specified point.
148
3.85M
  void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
149
3.85M
    BB = TheBB;
150
3.85M
    InsertPt = IP;
151
3.85M
    if (IP != TheBB->end())
152
3.78M
      SetCurrentDebugLocation(IP->getDebugLoc());
153
3.85M
  }
154
155
  /// Set location information used by debugging information.
156
489M
  void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); }
157
158
  /// Get location information used by debugging information.
159
8.44M
  const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
160
161
  /// If this builder has a current debug location, set it on the
162
  /// specified instruction.
163
21.4M
  void SetInstDebugLocation(Instruction *I) const {
164
21.4M
    if (CurDbgLocation)
165
5.59M
      I->setDebugLoc(CurDbgLocation);
166
21.4M
  }
167
168
  /// Get the return type of the current function that we're emitting
169
  /// into.
170
  Type *getCurrentFunctionReturnType() const;
171
172
  /// InsertPoint - A saved insertion point.
173
  class InsertPoint {
174
    BasicBlock *Block = nullptr;
175
    BasicBlock::iterator Point;
176
177
  public:
178
    /// Creates a new insertion point which doesn't point to anything.
179
182k
    InsertPoint() = default;
180
181
    /// Creates a new insertion point at the given location.
182
    InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
183
3.54M
        : Block(InsertBlock), Point(InsertPoint) {}
184
185
    /// Returns true if this insert point is set.
186
3.54M
    bool isSet() const { return (Block != nullptr); }
187
188
3.53M
    BasicBlock *getBlock() const { return Block; }
189
3.53M
    BasicBlock::iterator getPoint() const { return Point; }
190
  };
191
192
  /// Returns the current insert point.
193
18.3k
  InsertPoint saveIP() const {
194
18.3k
    return InsertPoint(GetInsertBlock(), GetInsertPoint());
195
18.3k
  }
196
197
  /// Returns the current insert point, clearing it in the process.
198
58.2k
  InsertPoint saveAndClearIP() {
199
58.2k
    InsertPoint IP(GetInsertBlock(), GetInsertPoint());
200
58.2k
    ClearInsertionPoint();
201
58.2k
    return IP;
202
58.2k
  }
203
204
  /// Sets the current insert point to a previously-saved location.
205
3.54M
  void restoreIP(InsertPoint IP) {
206
3.54M
    if (IP.isSet())
207
3.53M
      SetInsertPoint(IP.getBlock(), IP.getPoint());
208
8.45k
    else
209
8.45k
      ClearInsertionPoint();
210
3.54M
  }
211
212
  /// Get the floating point math metadata being used.
213
2
  MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
214
215
  /// Get the flags to be applied to created floating point ops
216
129
  FastMathFlags getFastMathFlags() const { return FMF; }
217
218
  /// Clear the fast-math flags.
219
  void clearFastMathFlags() { FMF.clear(); }
220
221
  /// Set the floating point math metadata to be used.
222
2
  void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
223
224
  /// Set the fast-math flags to be used with generated fp-math operators
225
563k
  void setFastMathFlags(FastMathFlags NewFMF) { FMF = NewFMF; }
226
227
  /// Enable/Disable use of constrained floating point math. When
228
  /// enabled the CreateF<op>() calls instead create constrained
229
  /// floating point intrinsic calls. Fast math flags are unaffected
230
  /// by this setting.
231
  void setIsFPConstrained(bool IsCon) { IsFPConstrained = IsCon; }
232
233
  /// Query for the use of constrained floating point math
234
0
  bool getIsFPConstrained() { return IsFPConstrained; }
235
236
  /// Set the exception handling to be used with constrained floating point
237
  void setDefaultConstrainedExcept(
238
      ConstrainedFPIntrinsic::ExceptionBehavior NewExcept) {
239
    DefaultConstrainedExcept = NewExcept;
240
  }
241
242
  /// Set the rounding mode handling to be used with constrained floating point
243
  void setDefaultConstrainedRounding(
244
      ConstrainedFPIntrinsic::RoundingMode NewRounding) {
245
    DefaultConstrainedRounding = NewRounding;
246
  }
247
248
  /// Get the exception handling used with constrained floating point
249
0
  ConstrainedFPIntrinsic::ExceptionBehavior getDefaultConstrainedExcept() {
250
0
    return DefaultConstrainedExcept;
251
0
  }
252
253
  /// Get the rounding mode handling used with constrained floating point
254
0
  ConstrainedFPIntrinsic::RoundingMode getDefaultConstrainedRounding() {
255
0
    return DefaultConstrainedRounding;
256
0
  }
257
258
  //===--------------------------------------------------------------------===//
259
  // RAII helpers.
260
  //===--------------------------------------------------------------------===//
261
262
  // RAII object that stores the current insertion point and restores it
263
  // when the object is destroyed. This includes the debug location.
264
  class InsertPointGuard {
265
    IRBuilderBase &Builder;
266
    AssertingVH<BasicBlock> Block;
267
    BasicBlock::iterator Point;
268
    DebugLoc DbgLoc;
269
270
  public:
271
    InsertPointGuard(IRBuilderBase &B)
272
        : Builder(B), Block(B.GetInsertBlock()), Point(B.GetInsertPoint()),
273
122k
          DbgLoc(B.getCurrentDebugLocation()) {}
274
275
    InsertPointGuard(const InsertPointGuard &) = delete;
276
    InsertPointGuard &operator=(const InsertPointGuard &) = delete;
277
278
122k
    ~InsertPointGuard() {
279
122k
      Builder.restoreIP(InsertPoint(Block, Point));
280
122k
      Builder.SetCurrentDebugLocation(DbgLoc);
281
122k
    }
282
  };
283
284
  // RAII object that stores the current fast math settings and restores
285
  // them when the object is destroyed.
286
  class FastMathFlagGuard {
287
    IRBuilderBase &Builder;
288
    FastMathFlags FMF;
289
    MDNode *FPMathTag;
290
291
  public:
292
    FastMathFlagGuard(IRBuilderBase &B)
293
169k
        : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag) {}
294
295
    FastMathFlagGuard(const FastMathFlagGuard &) = delete;
296
    FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
297
298
169k
    ~FastMathFlagGuard() {
299
169k
      Builder.FMF = FMF;
300
169k
      Builder.DefaultFPMathTag = FPMathTag;
301
169k
    }
302
  };
303
304
  //===--------------------------------------------------------------------===//
305
  // Miscellaneous creation methods.
306
  //===--------------------------------------------------------------------===//
307
308
  /// Make a new global variable with initializer type i8*
309
  ///
310
  /// Make a new global variable with an initializer that has array of i8 type
311
  /// filled in with the null terminated string value specified.  The new global
312
  /// variable will be marked mergable with any others of the same contents.  If
313
  /// Name is specified, it is the name of the global variable created.
314
  GlobalVariable *CreateGlobalString(StringRef Str, const Twine &Name = "",
315
                                     unsigned AddressSpace = 0);
316
317
  /// Get a constant value representing either true or false.
318
59.1k
  ConstantInt *getInt1(bool V) {
319
59.1k
    return ConstantInt::get(getInt1Ty(), V);
320
59.1k
  }
321
322
  /// Get the constant value for i1 true.
323
21.2k
  ConstantInt *getTrue() {
324
21.2k
    return ConstantInt::getTrue(Context);
325
21.2k
  }
326
327
  /// Get the constant value for i1 false.
328
34.8k
  ConstantInt *getFalse() {
329
34.8k
    return ConstantInt::getFalse(Context);
330
34.8k
  }
331
332
  /// Get a constant 8-bit value.
333
2.31k
  ConstantInt *getInt8(uint8_t C) {
334
2.31k
    return ConstantInt::get(getInt8Ty(), C);
335
2.31k
  }
336
337
  /// Get a constant 16-bit value.
338
2.90k
  ConstantInt *getInt16(uint16_t C) {
339
2.90k
    return ConstantInt::get(getInt16Ty(), C);
340
2.90k
  }
341
342
  /// Get a constant 32-bit value.
343
828k
  ConstantInt *getInt32(uint32_t C) {
344
828k
    return ConstantInt::get(getInt32Ty(), C);
345
828k
  }
346
347
  /// Get a constant 64-bit value.
348
35.0k
  ConstantInt *getInt64(uint64_t C) {
349
35.0k
    return ConstantInt::get(getInt64Ty(), C);
350
35.0k
  }
351
352
  /// Get a constant N-bit value, zero extended or truncated from
353
  /// a 64-bit value.
354
27.1k
  ConstantInt *getIntN(unsigned N, uint64_t C) {
355
27.1k
    return ConstantInt::get(getIntNTy(N), C);
356
27.1k
  }
357
358
  /// Get a constant integer value.
359
1.78M
  ConstantInt *getInt(const APInt &AI) {
360
1.78M
    return ConstantInt::get(Context, AI);
361
1.78M
  }
362
363
  //===--------------------------------------------------------------------===//
364
  // Type creation methods
365
  //===--------------------------------------------------------------------===//
366
367
  /// Fetch the type representing a single bit
368
331k
  IntegerType *getInt1Ty() {
369
331k
    return Type::getInt1Ty(Context);
370
331k
  }
371
372
  /// Fetch the type representing an 8-bit integer.
373
361k
  IntegerType *getInt8Ty() {
374
361k
    return Type::getInt8Ty(Context);
375
361k
  }
376
377
  /// Fetch the type representing a 16-bit integer.
378
3.04k
  IntegerType *getInt16Ty() {
379
3.04k
    return Type::getInt16Ty(Context);
380
3.04k
  }
381
382
  /// Fetch the type representing a 32-bit integer.
383
1.01M
  IntegerType *getInt32Ty() {
384
1.01M
    return Type::getInt32Ty(Context);
385
1.01M
  }
386
387
  /// Fetch the type representing a 64-bit integer.
388
38.7k
  IntegerType *getInt64Ty() {
389
38.7k
    return Type::getInt64Ty(Context);
390
38.7k
  }
391
392
  /// Fetch the type representing a 128-bit integer.
393
3
  IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
394
395
  /// Fetch the type representing an N-bit integer.
396
81.8k
  IntegerType *getIntNTy(unsigned N) {
397
81.8k
    return Type::getIntNTy(Context, N);
398
81.8k
  }
399
400
  /// Fetch the type representing a 16-bit floating point value.
401
6
  Type *getHalfTy() {
402
6
    return Type::getHalfTy(Context);
403
6
  }
404
405
  /// Fetch the type representing a 32-bit floating point value.
406
440
  Type *getFloatTy() {
407
440
    return Type::getFloatTy(Context);
408
440
  }
409
410
  /// Fetch the type representing a 64-bit floating point value.
411
110
  Type *getDoubleTy() {
412
110
    return Type::getDoubleTy(Context);
413
110
  }
414
415
  /// Fetch the type representing void.
416
71.8k
  Type *getVoidTy() {
417
71.8k
    return Type::getVoidTy(Context);
418
71.8k
  }
419
420
  /// Fetch the type representing a pointer to an 8-bit integer value.
421
2.06M
  PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
422
2.06M
    return Type::getInt8PtrTy(Context, AddrSpace);
423
2.06M
  }
424
425
  /// Fetch the type representing a pointer to an integer value.
426
21.3k
  IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
427
21.3k
    return DL.getIntPtrType(Context, AddrSpace);
428
21.3k
  }
429
430
  //===--------------------------------------------------------------------===//
431
  // Intrinsic creation methods
432
  //===--------------------------------------------------------------------===//
433
434
  /// Create and insert a memset to the specified pointer and the
435
  /// specified value.
436
  ///
437
  /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
438
  /// specified, it will be added to the instruction. Likewise with alias.scope
439
  /// and noalias tags.
440
  CallInst *CreateMemSet(Value *Ptr, Value *Val, uint64_t Size, unsigned Align,
441
                         bool isVolatile = false, MDNode *TBAATag = nullptr,
442
                         MDNode *ScopeTag = nullptr,
443
8.86k
                         MDNode *NoAliasTag = nullptr) {
444
8.86k
    return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
445
8.86k
                        TBAATag, ScopeTag, NoAliasTag);
446
8.86k
  }
447
448
  CallInst *CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
449
                         bool isVolatile = false, MDNode *TBAATag = nullptr,
450
                         MDNode *ScopeTag = nullptr,
451
                         MDNode *NoAliasTag = nullptr);
452
453
  /// Create and insert an element unordered-atomic memset of the region of
454
  /// memory starting at the given pointer to the given value.
455
  ///
456
  /// If the pointer isn't an i8*, it will be converted. If a TBAA tag is
457
  /// specified, it will be added to the instruction. Likewise with alias.scope
458
  /// and noalias tags.
459
  CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
460
                                               uint64_t Size, unsigned Align,
461
                                               uint32_t ElementSize,
462
                                               MDNode *TBAATag = nullptr,
463
                                               MDNode *ScopeTag = nullptr,
464
0
                                               MDNode *NoAliasTag = nullptr) {
465
0
    return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size), Align,
466
0
                                              ElementSize, TBAATag, ScopeTag,
467
0
                                              NoAliasTag);
468
0
  }
469
470
  CallInst *CreateElementUnorderedAtomicMemSet(Value *Ptr, Value *Val,
471
                                               Value *Size, unsigned Align,
472
                                               uint32_t ElementSize,
473
                                               MDNode *TBAATag = nullptr,
474
                                               MDNode *ScopeTag = nullptr,
475
                                               MDNode *NoAliasTag = nullptr);
476
477
  /// Create and insert a memcpy between the specified pointers.
478
  ///
479
  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
480
  /// specified, it will be added to the instruction. Likewise with alias.scope
481
  /// and noalias tags.
482
  CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
483
                         unsigned SrcAlign, uint64_t Size,
484
                         bool isVolatile = false, MDNode *TBAATag = nullptr,
485
                         MDNode *TBAAStructTag = nullptr,
486
                         MDNode *ScopeTag = nullptr,
487
472
                         MDNode *NoAliasTag = nullptr) {
488
472
    return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
489
472
                        isVolatile, TBAATag, TBAAStructTag, ScopeTag,
490
472
                        NoAliasTag);
491
472
  }
492
493
  CallInst *CreateMemCpy(Value *Dst, unsigned DstAlign, Value *Src,
494
                         unsigned SrcAlign, Value *Size,
495
                         bool isVolatile = false, MDNode *TBAATag = nullptr,
496
                         MDNode *TBAAStructTag = nullptr,
497
                         MDNode *ScopeTag = nullptr,
498
                         MDNode *NoAliasTag = nullptr);
499
500
  /// Create and insert an element unordered-atomic memcpy between the
501
  /// specified pointers.
502
  ///
503
  /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers, respectively.
504
  ///
505
  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
506
  /// specified, it will be added to the instruction. Likewise with alias.scope
507
  /// and noalias tags.
508
  CallInst *CreateElementUnorderedAtomicMemCpy(
509
      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
510
      uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
511
      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
512
0
      MDNode *NoAliasTag = nullptr) {
513
0
    return CreateElementUnorderedAtomicMemCpy(
514
0
        Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
515
0
        TBAAStructTag, ScopeTag, NoAliasTag);
516
0
  }
517
518
  CallInst *CreateElementUnorderedAtomicMemCpy(
519
      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
520
      uint32_t ElementSize, MDNode *TBAATag = nullptr,
521
      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
522
      MDNode *NoAliasTag = nullptr);
523
524
  /// Create and insert a memmove between the specified
525
  /// pointers.
526
  ///
527
  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
528
  /// specified, it will be added to the instruction. Likewise with alias.scope
529
  /// and noalias tags.
530
  CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
531
                          uint64_t Size, bool isVolatile = false,
532
                          MDNode *TBAATag = nullptr, MDNode *ScopeTag = nullptr,
533
4
                          MDNode *NoAliasTag = nullptr) {
534
4
    return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size), isVolatile,
535
4
                         TBAATag, ScopeTag, NoAliasTag);
536
4
  }
537
538
  CallInst *CreateMemMove(Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
539
                          Value *Size, bool isVolatile = false, MDNode *TBAATag = nullptr,
540
                          MDNode *ScopeTag = nullptr,
541
                          MDNode *NoAliasTag = nullptr);
542
543
  /// \brief Create and insert an element unordered-atomic memmove between the
544
  /// specified pointers.
545
  ///
546
  /// DstAlign/SrcAlign are the alignments of the Dst/Src pointers,
547
  /// respectively.
548
  ///
549
  /// If the pointers aren't i8*, they will be converted.  If a TBAA tag is
550
  /// specified, it will be added to the instruction. Likewise with alias.scope
551
  /// and noalias tags.
552
  CallInst *CreateElementUnorderedAtomicMemMove(
553
      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign,
554
      uint64_t Size, uint32_t ElementSize, MDNode *TBAATag = nullptr,
555
      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
556
0
      MDNode *NoAliasTag = nullptr) {
557
0
    return CreateElementUnorderedAtomicMemMove(
558
0
        Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
559
0
        TBAAStructTag, ScopeTag, NoAliasTag);
560
0
  }
561
562
  CallInst *CreateElementUnorderedAtomicMemMove(
563
      Value *Dst, unsigned DstAlign, Value *Src, unsigned SrcAlign, Value *Size,
564
      uint32_t ElementSize, MDNode *TBAATag = nullptr,
565
      MDNode *TBAAStructTag = nullptr, MDNode *ScopeTag = nullptr,
566
      MDNode *NoAliasTag = nullptr);
567
568
  /// Create a vector fadd reduction intrinsic of the source vector.
569
  /// The first parameter is a scalar accumulator value for ordered reductions.
570
  CallInst *CreateFAddReduce(Value *Acc, Value *Src);
571
572
  /// Create a vector fmul reduction intrinsic of the source vector.
573
  /// The first parameter is a scalar accumulator value for ordered reductions.
574
  CallInst *CreateFMulReduce(Value *Acc, Value *Src);
575
576
  /// Create a vector int add reduction intrinsic of the source vector.
577
  CallInst *CreateAddReduce(Value *Src);
578
579
  /// Create a vector int mul reduction intrinsic of the source vector.
580
  CallInst *CreateMulReduce(Value *Src);
581
582
  /// Create a vector int AND reduction intrinsic of the source vector.
583
  CallInst *CreateAndReduce(Value *Src);
584
585
  /// Create a vector int OR reduction intrinsic of the source vector.
586
  CallInst *CreateOrReduce(Value *Src);
587
588
  /// Create a vector int XOR reduction intrinsic of the source vector.
589
  CallInst *CreateXorReduce(Value *Src);
590
591
  /// Create a vector integer max reduction intrinsic of the source
592
  /// vector.
593
  CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
594
595
  /// Create a vector integer min reduction intrinsic of the source
596
  /// vector.
597
  CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
598
599
  /// Create a vector float max reduction intrinsic of the source
600
  /// vector.
601
  CallInst *CreateFPMaxReduce(Value *Src, bool NoNaN = false);
602
603
  /// Create a vector float min reduction intrinsic of the source
604
  /// vector.
605
  CallInst *CreateFPMinReduce(Value *Src, bool NoNaN = false);
606
607
  /// Create a lifetime.start intrinsic.
608
  ///
609
  /// If the pointer isn't i8* it will be converted.
610
  CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
611
612
  /// Create a lifetime.end intrinsic.
613
  ///
614
  /// If the pointer isn't i8* it will be converted.
615
  CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
616
617
  /// Create a call to invariant.start intrinsic.
618
  ///
619
  /// If the pointer isn't i8* it will be converted.
620
  CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
621
622
  /// Create a call to Masked Load intrinsic
623
  CallInst *CreateMaskedLoad(Value *Ptr, unsigned Align, Value *Mask,
624
                             Value *PassThru = nullptr, const Twine &Name = "");
625
626
  /// Create a call to Masked Store intrinsic
627
  CallInst *CreateMaskedStore(Value *Val, Value *Ptr, unsigned Align,
628
                              Value *Mask);
629
630
  /// Create a call to Masked Gather intrinsic
631
  CallInst *CreateMaskedGather(Value *Ptrs, unsigned Align,
632
                               Value *Mask = nullptr,
633
                               Value *PassThru = nullptr,
634
                               const Twine& Name = "");
635
636
  /// Create a call to Masked Scatter intrinsic
637
  CallInst *CreateMaskedScatter(Value *Val, Value *Ptrs, unsigned Align,
638
                                Value *Mask = nullptr);
639
640
  /// Create an assume intrinsic call that allows the optimizer to
641
  /// assume that the provided condition will be true.
642
  CallInst *CreateAssumption(Value *Cond);
643
644
  /// Create a call to the experimental.gc.statepoint intrinsic to
645
  /// start a new statepoint sequence.
646
  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
647
                                   Value *ActualCallee,
648
                                   ArrayRef<Value *> CallArgs,
649
                                   ArrayRef<Value *> DeoptArgs,
650
                                   ArrayRef<Value *> GCArgs,
651
                                   const Twine &Name = "");
652
653
  /// Create a call to the experimental.gc.statepoint intrinsic to
654
  /// start a new statepoint sequence.
655
  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
656
                                   Value *ActualCallee, uint32_t Flags,
657
                                   ArrayRef<Use> CallArgs,
658
                                   ArrayRef<Use> TransitionArgs,
659
                                   ArrayRef<Use> DeoptArgs,
660
                                   ArrayRef<Value *> GCArgs,
661
                                   const Twine &Name = "");
662
663
  /// Conveninence function for the common case when CallArgs are filled
664
  /// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
665
  /// .get()'ed to get the Value pointer.
666
  CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
667
                                   Value *ActualCallee, ArrayRef<Use> CallArgs,
668
                                   ArrayRef<Value *> DeoptArgs,
669
                                   ArrayRef<Value *> GCArgs,
670
                                   const Twine &Name = "");
671
672
  /// Create an invoke to the experimental.gc.statepoint intrinsic to
673
  /// start a new statepoint sequence.
674
  InvokeInst *
675
  CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
676
                           Value *ActualInvokee, BasicBlock *NormalDest,
677
                           BasicBlock *UnwindDest, ArrayRef<Value *> InvokeArgs,
678
                           ArrayRef<Value *> DeoptArgs,
679
                           ArrayRef<Value *> GCArgs, const Twine &Name = "");
680
681
  /// Create an invoke to the experimental.gc.statepoint intrinsic to
682
  /// start a new statepoint sequence.
683
  InvokeInst *CreateGCStatepointInvoke(
684
      uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
685
      BasicBlock *NormalDest, BasicBlock *UnwindDest, uint32_t Flags,
686
      ArrayRef<Use> InvokeArgs, ArrayRef<Use> TransitionArgs,
687
      ArrayRef<Use> DeoptArgs, ArrayRef<Value *> GCArgs,
688
      const Twine &Name = "");
689
690
  // Convenience function for the common case when CallArgs are filled in using
691
  // makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
692
  // get the Value *.
693
  InvokeInst *
694
  CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
695
                           Value *ActualInvokee, BasicBlock *NormalDest,
696
                           BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
697
                           ArrayRef<Value *> DeoptArgs,
698
                           ArrayRef<Value *> GCArgs, const Twine &Name = "");
699
700
  /// Create a call to the experimental.gc.result intrinsic to extract
701
  /// the result from a call wrapped in a statepoint.
702
  CallInst *CreateGCResult(Instruction *Statepoint,
703
                           Type *ResultType,
704
                           const Twine &Name = "");
705
706
  /// Create a call to the experimental.gc.relocate intrinsics to
707
  /// project the relocated value of one pointer from the statepoint.
708
  CallInst *CreateGCRelocate(Instruction *Statepoint,
709
                             int BaseOffset,
710
                             int DerivedOffset,
711
                             Type *ResultType,
712
                             const Twine &Name = "");
713
714
  /// Create a call to intrinsic \p ID with 1 operand which is mangled on its
715
  /// type.
716
  CallInst *CreateUnaryIntrinsic(Intrinsic::ID ID, Value *V,
717
                                 Instruction *FMFSource = nullptr,
718
                                 const Twine &Name = "");
719
720
  /// Create a call to intrinsic \p ID with 2 operands which is mangled on the
721
  /// first type.
722
  CallInst *CreateBinaryIntrinsic(Intrinsic::ID ID, Value *LHS, Value *RHS,
723
                                  Instruction *FMFSource = nullptr,
724
                                  const Twine &Name = "");
725
726
  /// Create a call to intrinsic \p ID with \p args, mangled using \p Types. If
727
  /// \p FMFSource is provided, copy fast-math-flags from that instruction to
728
  /// the intrinsic.
729
  CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
730
                            ArrayRef<Value *> Args,
731
                            Instruction *FMFSource = nullptr,
732
                            const Twine &Name = "");
733
734
  /// Create call to the minnum intrinsic.
735
15
  CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
736
15
    return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
737
15
  }
738
739
  /// Create call to the maxnum intrinsic.
740
5
  CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
741
5
    return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
742
5
  }
743
744
  /// Create call to the minimum intrinsic.
745
  CallInst *CreateMinimum(Value *LHS, Value *RHS, const Twine &Name = "") {
746
    return CreateBinaryIntrinsic(Intrinsic::minimum, LHS, RHS, nullptr, Name);
747
  }
748
749
  /// Create call to the maximum intrinsic.
750
  CallInst *CreateMaximum(Value *LHS, Value *RHS, const Twine &Name = "") {
751
    return CreateBinaryIntrinsic(Intrinsic::maximum, LHS, RHS, nullptr, Name);
752
  }
753
754
private:
755
  /// Create a call to a masked intrinsic with given Id.
756
  CallInst *CreateMaskedIntrinsic(Intrinsic::ID Id, ArrayRef<Value *> Ops,
757
                                  ArrayRef<Type *> OverloadedTypes,
758
                                  const Twine &Name = "");
759
760
  Value *getCastedInt8PtrValue(Value *Ptr);
761
};
762
763
/// This provides a uniform API for creating instructions and inserting
764
/// them into a basic block: either at the end of a BasicBlock, or at a specific
765
/// iterator location in a block.
766
///
767
/// Note that the builder does not expose the full generality of LLVM
768
/// instructions.  For access to extra instruction properties, use the mutators
769
/// (e.g. setVolatile) on the instructions after they have been
770
/// created. Convenience state exists to specify fast-math flags and fp-math
771
/// tags.
772
///
773
/// The first template argument specifies a class to use for creating constants.
774
/// This defaults to creating minimally folded constants.  The second template
775
/// argument allows clients to specify custom insertion hooks that are called on
776
/// every newly created insertion.
777
template <typename T = ConstantFolder,
778
          typename Inserter = IRBuilderDefaultInserter>
779
class IRBuilder : public IRBuilderBase, public Inserter {
780
  T Folder;
781
782
public:
783
  IRBuilder(LLVMContext &C, const T &F, Inserter I = Inserter(),
784
            MDNode *FPMathTag = nullptr,
785
            ArrayRef<OperandBundleDef> OpBundles = None)
786
      : IRBuilderBase(C, FPMathTag, OpBundles), Inserter(std::move(I)),
787
5.14M
        Folder(F) {}
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::LLVMContext&, llvm::TargetFolder const&, llvm::IRBuilderDefaultInserter, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
787
632k
        Folder(F) {}
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::IRBuilder(llvm::LLVMContext&, llvm::TargetFolder const&, llvm::IRBuilderCallbackInserter, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
787
3.18M
        Folder(F) {}
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::IRBuilder(llvm::LLVMContext&, llvm::ConstantFolder const&, (anonymous namespace)::IRBuilderPrefixedInserter, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
787
938k
        Folder(F) {}
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::IRBuilder(llvm::LLVMContext&, llvm::ConstantFolder const&, clang::CodeGen::CGBuilderInserter, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
787
388k
        Folder(F) {}
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::IRBuilder(llvm::LLVMContext&, llvm::ConstantFolder const&, polly::IRInserter, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
787
305
        Folder(F) {}
788
789
  explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
790
                     ArrayRef<OperandBundleDef> OpBundles = None)
791
418k
      : IRBuilderBase(C, FPMathTag, OpBundles) {}
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::LLVMContext&, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
791
418k
      : IRBuilderBase(C, FPMathTag, OpBundles) {}
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::IRBuilder(llvm::LLVMContext&, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
791
199
      : IRBuilderBase(C, FPMathTag, OpBundles) {}
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::IRBuilder(llvm::LLVMContext&, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
791
5
      : IRBuilderBase(C, FPMathTag, OpBundles) {}
792
793
  explicit IRBuilder(BasicBlock *TheBB, const T &F, MDNode *FPMathTag = nullptr,
794
                     ArrayRef<OperandBundleDef> OpBundles = None)
795
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
796
    SetInsertPoint(TheBB);
797
  }
798
799
  explicit IRBuilder(BasicBlock *TheBB, MDNode *FPMathTag = nullptr,
800
                     ArrayRef<OperandBundleDef> OpBundles = None)
801
32.8M
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
802
32.8M
    SetInsertPoint(TheBB);
803
32.8M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::BasicBlock*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
801
32.8M
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
802
32.8M
    SetInsertPoint(TheBB);
803
32.8M
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::IRBuilder(llvm::BasicBlock*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
801
1.29k
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
802
1.29k
    SetInsertPoint(TheBB);
803
1.29k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::IRBuilder(llvm::BasicBlock*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
801
305
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
802
305
    SetInsertPoint(TheBB);
803
305
  }
804
805
  explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
806
                     ArrayRef<OperandBundleDef> OpBundles = None)
807
94.4M
      : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
808
94.4M
    SetInsertPoint(IP);
809
94.4M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::Instruction*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
807
94.3M
      : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
808
94.3M
    SetInsertPoint(IP);
809
94.3M
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::Instruction*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
807
50.3k
      : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
808
50.3k
    SetInsertPoint(IP);
809
50.3k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::IRBuilder(llvm::Instruction*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
807
11.8k
      : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
808
11.8k
    SetInsertPoint(IP);
809
11.8k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::IRBuilder(llvm::Instruction*, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
807
130
      : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
808
130
    SetInsertPoint(IP);
809
130
  }
810
811
  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T &F,
812
            MDNode *FPMathTag = nullptr,
813
            ArrayRef<OperandBundleDef> OpBundles = None)
814
567
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
815
567
    SetInsertPoint(TheBB, IP);
816
567
  }
817
818
  IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
819
            MDNode *FPMathTag = nullptr,
820
            ArrayRef<OperandBundleDef> OpBundles = None)
821
5.04k
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
822
5.04k
    SetInsertPoint(TheBB, IP);
823
5.04k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::BasicBlock*, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
821
4.91k
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
822
4.91k
    SetInsertPoint(TheBB, IP);
823
4.91k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::IRBuilder(llvm::BasicBlock*, llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Instruction, false, false, void>, false, false>, llvm::MDNode*, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >)
Line
Count
Source
821
138
      : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
822
138
    SetInsertPoint(TheBB, IP);
823
138
  }
824
825
  /// Get the constant folder being used.
826
  const T &getFolder() { return Folder; }
827
828
  /// Insert and return the specified instruction.
829
  template<typename InstTy>
830
20.6M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
20.6M
    this->InsertHelper(I, Name, BB, InsertPt);
832
20.6M
    this->SetInstDebugLocation(I);
833
20.6M
    return I;
834
20.6M
  }
llvm::FenceInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::FenceInst>(llvm::FenceInst*, llvm::Twine const&) const
Line
Count
Source
830
237
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
237
    this->InsertHelper(I, Name, BB, InsertPt);
832
237
    this->SetInstDebugLocation(I);
833
237
    return I;
834
237
  }
llvm::CastInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
935k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
935k
    this->InsertHelper(I, Name, BB, InsertPt);
832
935k
    this->SetInstDebugLocation(I);
833
935k
    return I;
834
935k
  }
llvm::GetElementPtrInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
411k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
411k
    this->InsertHelper(I, Name, BB, InsertPt);
832
411k
    this->SetInstDebugLocation(I);
833
411k
    return I;
834
411k
  }
llvm::CallInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CallInst>(llvm::CallInst*, llvm::Twine const&) const
Line
Count
Source
830
643k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
643k
    this->InsertHelper(I, Name, BB, InsertPt);
832
643k
    this->SetInstDebugLocation(I);
833
643k
    return I;
834
643k
  }
llvm::ExtractValueInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ExtractValueInst>(llvm::ExtractValueInst*, llvm::Twine const&) const
Line
Count
Source
830
9.34k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
9.34k
    this->InsertHelper(I, Name, BB, InsertPt);
832
9.34k
    this->SetInstDebugLocation(I);
833
9.34k
    return I;
834
9.34k
  }
llvm::ShuffleVectorInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ShuffleVectorInst>(llvm::ShuffleVectorInst*, llvm::Twine const&) const
Line
Count
Source
830
38.0k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
38.0k
    this->InsertHelper(I, Name, BB, InsertPt);
832
38.0k
    this->SetInstDebugLocation(I);
833
38.0k
    return I;
834
38.0k
  }
llvm::BinaryOperator* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
136k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
136k
    this->InsertHelper(I, Name, BB, InsertPt);
832
136k
    this->SetInstDebugLocation(I);
833
136k
    return I;
834
136k
  }
llvm::LoadInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::LoadInst>(llvm::LoadInst*, llvm::Twine const&) const
Line
Count
Source
830
83.4k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
83.4k
    this->InsertHelper(I, Name, BB, InsertPt);
832
83.4k
    this->SetInstDebugLocation(I);
833
83.4k
    return I;
834
83.4k
  }
llvm::InsertValueInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::InsertValueInst>(llvm::InsertValueInst*, llvm::Twine const&) const
Line
Count
Source
830
1.10k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.10k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.10k
    this->SetInstDebugLocation(I);
833
1.10k
    return I;
834
1.10k
  }
llvm::ExtractElementInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ExtractElementInst>(llvm::ExtractElementInst*, llvm::Twine const&) const
Line
Count
Source
830
59.0k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
59.0k
    this->InsertHelper(I, Name, BB, InsertPt);
832
59.0k
    this->SetInstDebugLocation(I);
833
59.0k
    return I;
834
59.0k
  }
llvm::ICmpInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ICmpInst>(llvm::ICmpInst*, llvm::Twine const&) const
Line
Count
Source
830
124k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
124k
    this->InsertHelper(I, Name, BB, InsertPt);
832
124k
    this->SetInstDebugLocation(I);
833
124k
    return I;
834
124k
  }
llvm::InsertElementInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::InsertElementInst>(llvm::InsertElementInst*, llvm::Twine const&) const
Line
Count
Source
830
33.7k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
33.7k
    this->InsertHelper(I, Name, BB, InsertPt);
832
33.7k
    this->SetInstDebugLocation(I);
833
33.7k
    return I;
834
33.7k
  }
llvm::Instruction* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::Instruction>(llvm::Instruction*, llvm::Twine const&) const
Line
Count
Source
830
265k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
265k
    this->InsertHelper(I, Name, BB, InsertPt);
832
265k
    this->SetInstDebugLocation(I);
833
265k
    return I;
834
265k
  }
llvm::PHINode* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::PHINode>(llvm::PHINode*, llvm::Twine const&) const
Line
Count
Source
830
28.1k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
28.1k
    this->InsertHelper(I, Name, BB, InsertPt);
832
28.1k
    this->SetInstDebugLocation(I);
833
28.1k
    return I;
834
28.1k
  }
llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
12.6k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
12.6k
    this->InsertHelper(I, Name, BB, InsertPt);
832
12.6k
    this->SetInstDebugLocation(I);
833
12.6k
    return I;
834
12.6k
  }
llvm::AllocaInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::AllocaInst>(llvm::AllocaInst*, llvm::Twine const&) const
Line
Count
Source
830
3.25k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
3.25k
    this->InsertHelper(I, Name, BB, InsertPt);
832
3.25k
    this->SetInstDebugLocation(I);
833
3.25k
    return I;
834
3.25k
  }
llvm::StoreInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::StoreInst>(llvm::StoreInst*, llvm::Twine const&) const
Line
Count
Source
830
83.8k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
83.8k
    this->InsertHelper(I, Name, BB, InsertPt);
832
83.8k
    this->SetInstDebugLocation(I);
833
83.8k
    return I;
834
83.8k
  }
llvm::ReturnInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ReturnInst>(llvm::ReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
1.80k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.80k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.80k
    this->SetInstDebugLocation(I);
833
1.80k
    return I;
834
1.80k
  }
llvm::Instruction* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::Instruction>(llvm::Instruction*, llvm::Twine const&) const
Line
Count
Source
830
152
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
152
    this->InsertHelper(I, Name, BB, InsertPt);
832
152
    this->SetInstDebugLocation(I);
833
152
    return I;
834
152
  }
llvm::CastInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
276
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
276
    this->InsertHelper(I, Name, BB, InsertPt);
832
276
    this->SetInstDebugLocation(I);
833
276
    return I;
834
276
  }
llvm::LoadInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::LoadInst>(llvm::LoadInst*, llvm::Twine const&) const
Line
Count
Source
830
18.9k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
18.9k
    this->InsertHelper(I, Name, BB, InsertPt);
832
18.9k
    this->SetInstDebugLocation(I);
833
18.9k
    return I;
834
18.9k
  }
llvm::BinaryOperator* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
1.69k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.69k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.69k
    this->SetInstDebugLocation(I);
833
1.69k
    return I;
834
1.69k
  }
llvm::CallInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CallInst>(llvm::CallInst*, llvm::Twine const&) const
Line
Count
Source
830
46
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
46
    this->InsertHelper(I, Name, BB, InsertPt);
832
46
    this->SetInstDebugLocation(I);
833
46
    return I;
834
46
  }
llvm::BranchInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::BranchInst>(llvm::BranchInst*, llvm::Twine const&) const
Line
Count
Source
830
245k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
245k
    this->InsertHelper(I, Name, BB, InsertPt);
832
245k
    this->SetInstDebugLocation(I);
833
245k
    return I;
834
245k
  }
llvm::UnreachableInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::UnreachableInst>(llvm::UnreachableInst*, llvm::Twine const&) const
Line
Count
Source
830
26.5k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
26.5k
    this->InsertHelper(I, Name, BB, InsertPt);
832
26.5k
    this->SetInstDebugLocation(I);
833
26.5k
    return I;
834
26.5k
  }
llvm::SwitchInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::SwitchInst>(llvm::SwitchInst*, llvm::Twine const&) const
Line
Count
Source
830
13.9k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
13.9k
    this->InsertHelper(I, Name, BB, InsertPt);
832
13.9k
    this->SetInstDebugLocation(I);
833
13.9k
    return I;
834
13.9k
  }
llvm::InvokeInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::InvokeInst>(llvm::InvokeInst*, llvm::Twine const&) const
Line
Count
Source
830
9
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
9
    this->InsertHelper(I, Name, BB, InsertPt);
832
9
    this->SetInstDebugLocation(I);
833
9
    return I;
834
9
  }
llvm::GetElementPtrInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
18.5k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
18.5k
    this->InsertHelper(I, Name, BB, InsertPt);
832
18.5k
    this->SetInstDebugLocation(I);
833
18.5k
    return I;
834
18.5k
  }
llvm::BinaryOperator* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
85.4k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
85.4k
    this->InsertHelper(I, Name, BB, InsertPt);
832
85.4k
    this->SetInstDebugLocation(I);
833
85.4k
    return I;
834
85.4k
  }
llvm::ICmpInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ICmpInst>(llvm::ICmpInst*, llvm::Twine const&) const
Line
Count
Source
830
3.00k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
3.00k
    this->InsertHelper(I, Name, BB, InsertPt);
832
3.00k
    this->SetInstDebugLocation(I);
833
3.00k
    return I;
834
3.00k
  }
llvm::SelectInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
2.19k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2.19k
    this->InsertHelper(I, Name, BB, InsertPt);
832
2.19k
    this->SetInstDebugLocation(I);
833
2.19k
    return I;
834
2.19k
  }
llvm::BinaryOperator* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
56.9k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
56.9k
    this->InsertHelper(I, Name, BB, InsertPt);
832
56.9k
    this->SetInstDebugLocation(I);
833
56.9k
    return I;
834
56.9k
  }
llvm::CastInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
159k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
159k
    this->InsertHelper(I, Name, BB, InsertPt);
832
159k
    this->SetInstDebugLocation(I);
833
159k
    return I;
834
159k
  }
llvm::PHINode* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::PHINode>(llvm::PHINode*, llvm::Twine const&) const
Line
Count
Source
830
2.91k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2.91k
    this->InsertHelper(I, Name, BB, InsertPt);
832
2.91k
    this->SetInstDebugLocation(I);
833
2.91k
    return I;
834
2.91k
  }
llvm::SelectInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
3.26k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
3.26k
    this->InsertHelper(I, Name, BB, InsertPt);
832
3.26k
    this->SetInstDebugLocation(I);
833
3.26k
    return I;
834
3.26k
  }
llvm::Instruction* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::Instruction>(llvm::Instruction*, llvm::Twine const&) const
Line
Count
Source
830
81.2k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
81.2k
    this->InsertHelper(I, Name, BB, InsertPt);
832
81.2k
    this->SetInstDebugLocation(I);
833
81.2k
    return I;
834
81.2k
  }
llvm::GetElementPtrInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
424k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
424k
    this->InsertHelper(I, Name, BB, InsertPt);
832
424k
    this->SetInstDebugLocation(I);
833
424k
    return I;
834
424k
  }
llvm::CastInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
27.2k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
27.2k
    this->InsertHelper(I, Name, BB, InsertPt);
832
27.2k
    this->SetInstDebugLocation(I);
833
27.2k
    return I;
834
27.2k
  }
llvm::PHINode* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::PHINode>(llvm::PHINode*, llvm::Twine const&) const
Line
Count
Source
830
135k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
135k
    this->InsertHelper(I, Name, BB, InsertPt);
832
135k
    this->SetInstDebugLocation(I);
833
135k
    return I;
834
135k
  }
llvm::CallInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CallInst>(llvm::CallInst*, llvm::Twine const&) const
Line
Count
Source
830
370
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
370
    this->InsertHelper(I, Name, BB, InsertPt);
832
370
    this->SetInstDebugLocation(I);
833
370
    return I;
834
370
  }
llvm::ExtractValueInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ExtractValueInst>(llvm::ExtractValueInst*, llvm::Twine const&) const
Line
Count
Source
830
654
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
654
    this->InsertHelper(I, Name, BB, InsertPt);
832
654
    this->SetInstDebugLocation(I);
833
654
    return I;
834
654
  }
llvm::AtomicCmpXchgInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::AtomicCmpXchgInst>(llvm::AtomicCmpXchgInst*, llvm::Twine const&) const
Line
Count
Source
830
1.03k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.03k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.03k
    this->SetInstDebugLocation(I);
833
1.03k
    return I;
834
1.03k
  }
llvm::AtomicRMWInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::AtomicRMWInst>(llvm::AtomicRMWInst*, llvm::Twine const&) const
Line
Count
Source
830
148
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
148
    this->InsertHelper(I, Name, BB, InsertPt);
832
148
    this->SetInstDebugLocation(I);
833
148
    return I;
834
148
  }
llvm::Instruction* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::Instruction>(llvm::Instruction*, llvm::Twine const&) const
Line
Count
Source
830
18.3k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
18.3k
    this->InsertHelper(I, Name, BB, InsertPt);
832
18.3k
    this->SetInstDebugLocation(I);
833
18.3k
    return I;
834
18.3k
  }
llvm::ICmpInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::ICmpInst>(llvm::ICmpInst*, llvm::Twine const&) const
Line
Count
Source
830
15.7k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
15.7k
    this->InsertHelper(I, Name, BB, InsertPt);
832
15.7k
    this->SetInstDebugLocation(I);
833
15.7k
    return I;
834
15.7k
  }
llvm::GetElementPtrInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
72.7k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
72.7k
    this->InsertHelper(I, Name, BB, InsertPt);
832
72.7k
    this->SetInstDebugLocation(I);
833
72.7k
    return I;
834
72.7k
  }
llvm::ExtractValueInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::ExtractValueInst>(llvm::ExtractValueInst*, llvm::Twine const&) const
Line
Count
Source
830
7.51k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
7.51k
    this->InsertHelper(I, Name, BB, InsertPt);
832
7.51k
    this->SetInstDebugLocation(I);
833
7.51k
    return I;
834
7.51k
  }
llvm::LoadInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::LoadInst>(llvm::LoadInst*, llvm::Twine const&) const
Line
Count
Source
830
96.0k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
96.0k
    this->InsertHelper(I, Name, BB, InsertPt);
832
96.0k
    this->SetInstDebugLocation(I);
833
96.0k
    return I;
834
96.0k
  }
llvm::CallInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::CallInst>(llvm::CallInst*, llvm::Twine const&) const
Line
Count
Source
830
414
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
414
    this->InsertHelper(I, Name, BB, InsertPt);
832
414
    this->SetInstDebugLocation(I);
833
414
    return I;
834
414
  }
llvm::ShuffleVectorInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::ShuffleVectorInst>(llvm::ShuffleVectorInst*, llvm::Twine const&) const
Line
Count
Source
830
314
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
314
    this->InsertHelper(I, Name, BB, InsertPt);
832
314
    this->SetInstDebugLocation(I);
833
314
    return I;
834
314
  }
llvm::InsertValueInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::InsertValueInst>(llvm::InsertValueInst*, llvm::Twine const&) const
Line
Count
Source
830
63
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
63
    this->InsertHelper(I, Name, BB, InsertPt);
832
63
    this->SetInstDebugLocation(I);
833
63
    return I;
834
63
  }
llvm::StoreInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::StoreInst>(llvm::StoreInst*, llvm::Twine const&) const
Line
Count
Source
830
41.4k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
41.4k
    this->InsertHelper(I, Name, BB, InsertPt);
832
41.4k
    this->SetInstDebugLocation(I);
833
41.4k
    return I;
834
41.4k
  }
llvm::ExtractElementInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::ExtractElementInst>(llvm::ExtractElementInst*, llvm::Twine const&) const
Line
Count
Source
830
188
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
188
    this->InsertHelper(I, Name, BB, InsertPt);
832
188
    this->SetInstDebugLocation(I);
833
188
    return I;
834
188
  }
llvm::InsertElementInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::InsertElementInst>(llvm::InsertElementInst*, llvm::Twine const&) const
Line
Count
Source
830
144
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
144
    this->InsertHelper(I, Name, BB, InsertPt);
832
144
    this->SetInstDebugLocation(I);
833
144
    return I;
834
144
  }
llvm::InvokeInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::InvokeInst>(llvm::InvokeInst*, llvm::Twine const&) const
Line
Count
Source
830
27
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
27
    this->InsertHelper(I, Name, BB, InsertPt);
832
27
    this->SetInstDebugLocation(I);
833
27
    return I;
834
27
  }
Unexecuted instantiation: llvm::CallBrInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::CallBrInst>(llvm::CallBrInst*, llvm::Twine const&) const
llvm::AllocaInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::AllocaInst>(llvm::AllocaInst*, llvm::Twine const&) const
Line
Count
Source
830
1.64k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.64k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.64k
    this->SetInstDebugLocation(I);
833
1.64k
    return I;
834
1.64k
  }
llvm::IntrinsicInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert<llvm::IntrinsicInst>(llvm::IntrinsicInst*, llvm::Twine const&) const
Line
Count
Source
830
34
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
34
    this->InsertHelper(I, Name, BB, InsertPt);
832
34
    this->SetInstDebugLocation(I);
833
34
    return I;
834
34
  }
llvm::UnreachableInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::UnreachableInst>(llvm::UnreachableInst*, llvm::Twine const&) const
Line
Count
Source
830
43
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
43
    this->InsertHelper(I, Name, BB, InsertPt);
832
43
    this->SetInstDebugLocation(I);
833
43
    return I;
834
43
  }
SROA.cpp:llvm::GetElementPtrInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
91.1k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
91.1k
    this->InsertHelper(I, Name, BB, InsertPt);
832
91.1k
    this->SetInstDebugLocation(I);
833
91.1k
    return I;
834
91.1k
  }
SROA.cpp:llvm::CastInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
782k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
782k
    this->InsertHelper(I, Name, BB, InsertPt);
832
782k
    this->SetInstDebugLocation(I);
833
782k
    return I;
834
782k
  }
SROA.cpp:llvm::LoadInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::LoadInst>(llvm::LoadInst*, llvm::Twine const&) const
Line
Count
Source
830
1.92M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.92M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.92M
    this->SetInstDebugLocation(I);
833
1.92M
    return I;
834
1.92M
  }
SROA.cpp:llvm::ExtractElementInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::ExtractElementInst>(llvm::ExtractElementInst*, llvm::Twine const&) const
Line
Count
Source
830
409
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
409
    this->InsertHelper(I, Name, BB, InsertPt);
832
409
    this->SetInstDebugLocation(I);
833
409
    return I;
834
409
  }
SROA.cpp:llvm::ShuffleVectorInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::ShuffleVectorInst>(llvm::ShuffleVectorInst*, llvm::Twine const&) const
Line
Count
Source
830
36
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
36
    this->InsertHelper(I, Name, BB, InsertPt);
832
36
    this->SetInstDebugLocation(I);
833
36
    return I;
834
36
  }
SROA.cpp:llvm::BinaryOperator* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
13.5k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
13.5k
    this->InsertHelper(I, Name, BB, InsertPt);
832
13.5k
    this->SetInstDebugLocation(I);
833
13.5k
    return I;
834
13.5k
  }
SROA.cpp:llvm::InsertElementInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::InsertElementInst>(llvm::InsertElementInst*, llvm::Twine const&) const
Line
Count
Source
830
306
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
306
    this->InsertHelper(I, Name, BB, InsertPt);
832
306
    this->SetInstDebugLocation(I);
833
306
    return I;
834
306
  }
SROA.cpp:llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
1.46k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.46k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.46k
    this->SetInstDebugLocation(I);
833
1.46k
    return I;
834
1.46k
  }
SROA.cpp:llvm::InsertValueInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::InsertValueInst>(llvm::InsertValueInst*, llvm::Twine const&) const
Line
Count
Source
830
11.4k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
11.4k
    this->InsertHelper(I, Name, BB, InsertPt);
832
11.4k
    this->SetInstDebugLocation(I);
833
11.4k
    return I;
834
11.4k
  }
SROA.cpp:llvm::ExtractValueInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::ExtractValueInst>(llvm::ExtractValueInst*, llvm::Twine const&) const
Line
Count
Source
830
17.6k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
17.6k
    this->InsertHelper(I, Name, BB, InsertPt);
832
17.6k
    this->SetInstDebugLocation(I);
833
17.6k
    return I;
834
17.6k
  }
SROA.cpp:llvm::PHINode* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::PHINode>(llvm::PHINode*, llvm::Twine const&) const
Line
Count
Source
830
9
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
9
    this->InsertHelper(I, Name, BB, InsertPt);
832
9
    this->SetInstDebugLocation(I);
833
9
    return I;
834
9
  }
SROA.cpp:llvm::StoreInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert<llvm::StoreInst>(llvm::StoreInst*, llvm::Twine const&) const
Line
Count
Source
830
1.27M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.27M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.27M
    this->SetInstDebugLocation(I);
833
1.27M
    return I;
834
1.27M
  }
llvm::SelectInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
37.8k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
37.8k
    this->InsertHelper(I, Name, BB, InsertPt);
832
37.8k
    this->SetInstDebugLocation(I);
833
37.8k
    return I;
834
37.8k
  }
llvm::BranchInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::BranchInst>(llvm::BranchInst*, llvm::Twine const&) const
Line
Count
Source
830
17.8k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
17.8k
    this->InsertHelper(I, Name, BB, InsertPt);
832
17.8k
    this->SetInstDebugLocation(I);
833
17.8k
    return I;
834
17.8k
  }
llvm::GetElementPtrInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
1.00M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.00M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.00M
    this->SetInstDebugLocation(I);
833
1.00M
    return I;
834
1.00M
  }
llvm::CastInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
1.69M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.69M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.69M
    this->SetInstDebugLocation(I);
833
1.69M
    return I;
834
1.69M
  }
llvm::StoreInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::StoreInst>(llvm::StoreInst*, llvm::Twine const&) const
Line
Count
Source
830
1.91M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.91M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.91M
    this->SetInstDebugLocation(I);
833
1.91M
    return I;
834
1.91M
  }
llvm::AtomicCmpXchgInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::AtomicCmpXchgInst>(llvm::AtomicCmpXchgInst*, llvm::Twine const&) const
Line
Count
Source
830
699
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
699
    this->InsertHelper(I, Name, BB, InsertPt);
832
699
    this->SetInstDebugLocation(I);
833
699
    return I;
834
699
  }
llvm::ExtractValueInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::ExtractValueInst>(llvm::ExtractValueInst*, llvm::Twine const&) const
Line
Count
Source
830
57.6k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
57.6k
    this->InsertHelper(I, Name, BB, InsertPt);
832
57.6k
    this->SetInstDebugLocation(I);
833
57.6k
    return I;
834
57.6k
  }
llvm::BranchInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::BranchInst>(llvm::BranchInst*, llvm::Twine const&) const
Line
Count
Source
830
1.25M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.25M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.25M
    this->SetInstDebugLocation(I);
833
1.25M
    return I;
834
1.25M
  }
llvm::LoadInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::LoadInst>(llvm::LoadInst*, llvm::Twine const&) const
Line
Count
Source
830
2.80M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2.80M
    this->InsertHelper(I, Name, BB, InsertPt);
832
2.80M
    this->SetInstDebugLocation(I);
833
2.80M
    return I;
834
2.80M
  }
llvm::AtomicRMWInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::AtomicRMWInst>(llvm::AtomicRMWInst*, llvm::Twine const&) const
Line
Count
Source
830
2.10k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2.10k
    this->InsertHelper(I, Name, BB, InsertPt);
832
2.10k
    this->SetInstDebugLocation(I);
833
2.10k
    return I;
834
2.10k
  }
llvm::PHINode* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::PHINode>(llvm::PHINode*, llvm::Twine const&) const
Line
Count
Source
830
29.1k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
29.1k
    this->InsertHelper(I, Name, BB, InsertPt);
832
29.1k
    this->SetInstDebugLocation(I);
833
29.1k
    return I;
834
29.1k
  }
llvm::SwitchInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::SwitchInst>(llvm::SwitchInst*, llvm::Twine const&) const
Line
Count
Source
830
4.07k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
4.07k
    this->InsertHelper(I, Name, BB, InsertPt);
832
4.07k
    this->SetInstDebugLocation(I);
833
4.07k
    return I;
834
4.07k
  }
llvm::Instruction* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::Instruction>(llvm::Instruction*, llvm::Twine const&) const
Line
Count
Source
830
70.1k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
70.1k
    this->InsertHelper(I, Name, BB, InsertPt);
832
70.1k
    this->SetInstDebugLocation(I);
833
70.1k
    return I;
834
70.1k
  }
llvm::BinaryOperator* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
461k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
461k
    this->InsertHelper(I, Name, BB, InsertPt);
832
461k
    this->SetInstDebugLocation(I);
833
461k
    return I;
834
461k
  }
llvm::CallInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CallInst>(llvm::CallInst*, llvm::Twine const&) const
Line
Count
Source
830
1.77M
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.77M
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.77M
    this->SetInstDebugLocation(I);
833
1.77M
    return I;
834
1.77M
  }
llvm::UnreachableInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::UnreachableInst>(llvm::UnreachableInst*, llvm::Twine const&) const
Line
Count
Source
830
35.0k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
35.0k
    this->InsertHelper(I, Name, BB, InsertPt);
832
35.0k
    this->SetInstDebugLocation(I);
833
35.0k
    return I;
834
35.0k
  }
llvm::CatchReturnInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CatchReturnInst>(llvm::CatchReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
114
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
114
    this->InsertHelper(I, Name, BB, InsertPt);
832
114
    this->SetInstDebugLocation(I);
833
114
    return I;
834
114
  }
llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
7.13k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
7.13k
    this->InsertHelper(I, Name, BB, InsertPt);
832
7.13k
    this->SetInstDebugLocation(I);
833
7.13k
    return I;
834
7.13k
  }
llvm::AllocaInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::AllocaInst>(llvm::AllocaInst*, llvm::Twine const&) const
Line
Count
Source
830
1.99k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.99k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.99k
    this->SetInstDebugLocation(I);
833
1.99k
    return I;
834
1.99k
  }
llvm::FenceInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::FenceInst>(llvm::FenceInst*, llvm::Twine const&) const
Line
Count
Source
830
3.32k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
3.32k
    this->InsertHelper(I, Name, BB, InsertPt);
832
3.32k
    this->SetInstDebugLocation(I);
833
3.32k
    return I;
834
3.32k
  }
llvm::ShuffleVectorInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::ShuffleVectorInst>(llvm::ShuffleVectorInst*, llvm::Twine const&) const
Line
Count
Source
830
5.02k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
5.02k
    this->InsertHelper(I, Name, BB, InsertPt);
832
5.02k
    this->SetInstDebugLocation(I);
833
5.02k
    return I;
834
5.02k
  }
llvm::InsertElementInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::InsertElementInst>(llvm::InsertElementInst*, llvm::Twine const&) const
Line
Count
Source
830
12.3k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
12.3k
    this->InsertHelper(I, Name, BB, InsertPt);
832
12.3k
    this->SetInstDebugLocation(I);
833
12.3k
    return I;
834
12.3k
  }
llvm::ExtractElementInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::ExtractElementInst>(llvm::ExtractElementInst*, llvm::Twine const&) const
Line
Count
Source
830
12.8k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
12.8k
    this->InsertHelper(I, Name, BB, InsertPt);
832
12.8k
    this->SetInstDebugLocation(I);
833
12.8k
    return I;
834
12.8k
  }
llvm::ICmpInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::ICmpInst>(llvm::ICmpInst*, llvm::Twine const&) const
Line
Count
Source
830
368k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
368k
    this->InsertHelper(I, Name, BB, InsertPt);
832
368k
    this->SetInstDebugLocation(I);
833
368k
    return I;
834
368k
  }
llvm::ReturnInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::ReturnInst>(llvm::ReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
386k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
386k
    this->InsertHelper(I, Name, BB, InsertPt);
832
386k
    this->SetInstDebugLocation(I);
833
386k
    return I;
834
386k
  }
llvm::InsertValueInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::InsertValueInst>(llvm::InsertValueInst*, llvm::Twine const&) const
Line
Count
Source
830
11.9k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
11.9k
    this->InsertHelper(I, Name, BB, InsertPt);
832
11.9k
    this->SetInstDebugLocation(I);
833
11.9k
    return I;
834
11.9k
  }
llvm::InvokeInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::InvokeInst>(llvm::InvokeInst*, llvm::Twine const&) const
Line
Count
Source
830
37.9k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
37.9k
    this->InsertHelper(I, Name, BB, InsertPt);
832
37.9k
    this->SetInstDebugLocation(I);
833
37.9k
    return I;
834
37.9k
  }
llvm::CleanupPadInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CleanupPadInst>(llvm::CleanupPadInst*, llvm::Twine const&) const
Line
Count
Source
830
189
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
189
    this->InsertHelper(I, Name, BB, InsertPt);
832
189
    this->SetInstDebugLocation(I);
833
189
    return I;
834
189
  }
llvm::CleanupReturnInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CleanupReturnInst>(llvm::CleanupReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
172
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
172
    this->InsertHelper(I, Name, BB, InsertPt);
832
172
    this->SetInstDebugLocation(I);
833
172
    return I;
834
172
  }
llvm::CatchSwitchInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CatchSwitchInst>(llvm::CatchSwitchInst*, llvm::Twine const&) const
Line
Count
Source
830
105
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
105
    this->InsertHelper(I, Name, BB, InsertPt);
832
105
    this->SetInstDebugLocation(I);
833
105
    return I;
834
105
  }
llvm::CatchPadInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CatchPadInst>(llvm::CatchPadInst*, llvm::Twine const&) const
Line
Count
Source
830
108
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
108
    this->InsertHelper(I, Name, BB, InsertPt);
832
108
    this->SetInstDebugLocation(I);
833
108
    return I;
834
108
  }
llvm::LandingPadInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::LandingPadInst>(llvm::LandingPadInst*, llvm::Twine const&) const
Line
Count
Source
830
22.2k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
22.2k
    this->InsertHelper(I, Name, BB, InsertPt);
832
22.2k
    this->SetInstDebugLocation(I);
833
22.2k
    return I;
834
22.2k
  }
llvm::ResumeInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::ResumeInst>(llvm::ResumeInst*, llvm::Twine const&) const
Line
Count
Source
830
5.48k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
5.48k
    this->InsertHelper(I, Name, BB, InsertPt);
832
5.48k
    this->SetInstDebugLocation(I);
833
5.48k
    return I;
834
5.48k
  }
llvm::CallBrInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::CallBrInst>(llvm::CallBrInst*, llvm::Twine const&) const
Line
Count
Source
830
10
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
10
    this->InsertHelper(I, Name, BB, InsertPt);
832
10
    this->SetInstDebugLocation(I);
833
10
    return I;
834
10
  }
llvm::IndirectBrInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::IndirectBrInst>(llvm::IndirectBrInst*, llvm::Twine const&) const
Line
Count
Source
830
34
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
34
    this->InsertHelper(I, Name, BB, InsertPt);
832
34
    this->SetInstDebugLocation(I);
833
34
    return I;
834
34
  }
llvm::VAArgInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert<llvm::VAArgInst>(llvm::VAArgInst*, llvm::Twine const&) const
Line
Count
Source
830
148
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
148
    this->InsertHelper(I, Name, BB, InsertPt);
832
148
    this->SetInstDebugLocation(I);
833
148
    return I;
834
148
  }
llvm::CastInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::CastInst>(llvm::CastInst*, llvm::Twine const&) const
Line
Count
Source
830
1.17k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.17k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.17k
    this->SetInstDebugLocation(I);
833
1.17k
    return I;
834
1.17k
  }
llvm::Instruction* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::Instruction>(llvm::Instruction*, llvm::Twine const&) const
Line
Count
Source
830
574
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
574
    this->InsertHelper(I, Name, BB, InsertPt);
832
574
    this->SetInstDebugLocation(I);
833
574
    return I;
834
574
  }
llvm::LoadInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::LoadInst>(llvm::LoadInst*, llvm::Twine const&) const
Line
Count
Source
830
865
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
865
    this->InsertHelper(I, Name, BB, InsertPt);
832
865
    this->SetInstDebugLocation(I);
833
865
    return I;
834
865
  }
llvm::ICmpInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::ICmpInst>(llvm::ICmpInst*, llvm::Twine const&) const
Line
Count
Source
830
1.11k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1.11k
    this->InsertHelper(I, Name, BB, InsertPt);
832
1.11k
    this->SetInstDebugLocation(I);
833
1.11k
    return I;
834
1.11k
  }
llvm::StoreInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::StoreInst>(llvm::StoreInst*, llvm::Twine const&) const
Line
Count
Source
830
871
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
871
    this->InsertHelper(I, Name, BB, InsertPt);
832
871
    this->SetInstDebugLocation(I);
833
871
    return I;
834
871
  }
llvm::InsertElementInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::InsertElementInst>(llvm::InsertElementInst*, llvm::Twine const&) const
Line
Count
Source
830
42
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
42
    this->InsertHelper(I, Name, BB, InsertPt);
832
42
    this->SetInstDebugLocation(I);
833
42
    return I;
834
42
  }
llvm::ShuffleVectorInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::ShuffleVectorInst>(llvm::ShuffleVectorInst*, llvm::Twine const&) const
Line
Count
Source
830
11
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
11
    this->InsertHelper(I, Name, BB, InsertPt);
832
11
    this->SetInstDebugLocation(I);
833
11
    return I;
834
11
  }
llvm::ExtractElementInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::ExtractElementInst>(llvm::ExtractElementInst*, llvm::Twine const&) const
Line
Count
Source
830
103
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
103
    this->InsertHelper(I, Name, BB, InsertPt);
832
103
    this->SetInstDebugLocation(I);
833
103
    return I;
834
103
  }
llvm::PHINode* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::PHINode>(llvm::PHINode*, llvm::Twine const&) const
Line
Count
Source
830
352
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
352
    this->InsertHelper(I, Name, BB, InsertPt);
832
352
    this->SetInstDebugLocation(I);
833
352
    return I;
834
352
  }
llvm::BinaryOperator* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::BinaryOperator>(llvm::BinaryOperator*, llvm::Twine const&) const
Line
Count
Source
830
2.30k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2.30k
    this->InsertHelper(I, Name, BB, InsertPt);
832
2.30k
    this->SetInstDebugLocation(I);
833
2.30k
    return I;
834
2.30k
  }
llvm::CallInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::CallInst>(llvm::CallInst*, llvm::Twine const&) const
Line
Count
Source
830
448
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
448
    this->InsertHelper(I, Name, BB, InsertPt);
832
448
    this->SetInstDebugLocation(I);
833
448
    return I;
834
448
  }
llvm::ExtractValueInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::ExtractValueInst>(llvm::ExtractValueInst*, llvm::Twine const&) const
Line
Count
Source
830
336
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
336
    this->InsertHelper(I, Name, BB, InsertPt);
832
336
    this->SetInstDebugLocation(I);
833
336
    return I;
834
336
  }
llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::SelectInst>(llvm::SelectInst*, llvm::Twine const&) const
Line
Count
Source
830
66
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
66
    this->InsertHelper(I, Name, BB, InsertPt);
832
66
    this->SetInstDebugLocation(I);
833
66
    return I;
834
66
  }
llvm::GetElementPtrInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::GetElementPtrInst>(llvm::GetElementPtrInst*, llvm::Twine const&) const
Line
Count
Source
830
853
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
853
    this->InsertHelper(I, Name, BB, InsertPt);
832
853
    this->SetInstDebugLocation(I);
833
853
    return I;
834
853
  }
llvm::BranchInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::BranchInst>(llvm::BranchInst*, llvm::Twine const&) const
Line
Count
Source
830
2.11k
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2.11k
    this->InsertHelper(I, Name, BB, InsertPt);
832
2.11k
    this->SetInstDebugLocation(I);
833
2.11k
    return I;
834
2.11k
  }
llvm::UnreachableInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::UnreachableInst>(llvm::UnreachableInst*, llvm::Twine const&) const
Line
Count
Source
830
8
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
8
    this->InsertHelper(I, Name, BB, InsertPt);
832
8
    this->SetInstDebugLocation(I);
833
8
    return I;
834
8
  }
llvm::AllocaInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::AllocaInst>(llvm::AllocaInst*, llvm::Twine const&) const
Line
Count
Source
830
102
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
102
    this->InsertHelper(I, Name, BB, InsertPt);
832
102
    this->SetInstDebugLocation(I);
833
102
    return I;
834
102
  }
llvm::ReturnInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert<llvm::ReturnInst>(llvm::ReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
55
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
55
    this->InsertHelper(I, Name, BB, InsertPt);
832
55
    this->SetInstDebugLocation(I);
833
55
    return I;
834
55
  }
Unexecuted instantiation: llvm::IndirectBrInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::IndirectBrInst>(llvm::IndirectBrInst*, llvm::Twine const&) const
llvm::LandingPadInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::LandingPadInst>(llvm::LandingPadInst*, llvm::Twine const&) const
Line
Count
Source
830
2
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2
    this->InsertHelper(I, Name, BB, InsertPt);
832
2
    this->SetInstDebugLocation(I);
833
2
    return I;
834
2
  }
llvm::CatchPadInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CatchPadInst>(llvm::CatchPadInst*, llvm::Twine const&) const
Line
Count
Source
830
4
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
4
    this->InsertHelper(I, Name, BB, InsertPt);
832
4
    this->SetInstDebugLocation(I);
833
4
    return I;
834
4
  }
llvm::CleanupPadInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CleanupPadInst>(llvm::CleanupPadInst*, llvm::Twine const&) const
Line
Count
Source
830
2
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2
    this->InsertHelper(I, Name, BB, InsertPt);
832
2
    this->SetInstDebugLocation(I);
833
2
    return I;
834
2
  }
llvm::ResumeInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::ResumeInst>(llvm::ResumeInst*, llvm::Twine const&) const
Line
Count
Source
830
1
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
1
    this->InsertHelper(I, Name, BB, InsertPt);
832
1
    this->SetInstDebugLocation(I);
833
1
    return I;
834
1
  }
llvm::CatchSwitchInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CatchSwitchInst>(llvm::CatchSwitchInst*, llvm::Twine const&) const
Line
Count
Source
830
3
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
3
    this->InsertHelper(I, Name, BB, InsertPt);
832
3
    this->SetInstDebugLocation(I);
833
3
    return I;
834
3
  }
llvm::CatchReturnInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CatchReturnInst>(llvm::CatchReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
2
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2
    this->InsertHelper(I, Name, BB, InsertPt);
832
2
    this->SetInstDebugLocation(I);
833
2
    return I;
834
2
  }
llvm::CleanupReturnInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::CleanupReturnInst>(llvm::CleanupReturnInst*, llvm::Twine const&) const
Line
Count
Source
830
2
  InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831
2
    this->InsertHelper(I, Name, BB, InsertPt);
832
2
    this->SetInstDebugLocation(I);
833
2
    return I;
834
2
  }
Unexecuted instantiation: llvm::VAArgInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert<llvm::VAArgInst>(llvm::VAArgInst*, llvm::Twine const&) const
835
836
  /// No-op overload to handle constants.
837
2.11M
  Constant *Insert(Constant *C, const Twine& = "") const {
838
2.11M
    return C;
839
2.11M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::Insert(llvm::Constant*, llvm::Twine const&) const
Line
Count
Source
837
462k
  Constant *Insert(Constant *C, const Twine& = "") const {
838
462k
    return C;
839
462k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::Insert(llvm::Constant*, llvm::Twine const&) const
Line
Count
Source
837
15.7k
  Constant *Insert(Constant *C, const Twine& = "") const {
838
15.7k
    return C;
839
15.7k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::Insert(llvm::Constant*, llvm::Twine const&) const
Line
Count
Source
837
819k
  Constant *Insert(Constant *C, const Twine& = "") const {
838
819k
    return C;
839
819k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::Insert(llvm::Constant*, llvm::Twine const&) const
Line
Count
Source
837
10.8k
  Constant *Insert(Constant *C, const Twine& = "") const {
838
10.8k
    return C;
839
10.8k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::Insert(llvm::Constant*, llvm::Twine const&) const
Line
Count
Source
837
807k
  Constant *Insert(Constant *C, const Twine& = "") const {
838
807k
    return C;
839
807k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::Insert(llvm::Constant*, llvm::Twine const&) const
Line
Count
Source
837
1.01k
  Constant *Insert(Constant *C, const Twine& = "") const {
838
1.01k
    return C;
839
1.01k
  }
840
841
  //===--------------------------------------------------------------------===//
842
  // Instruction creation methods: Terminators
843
  //===--------------------------------------------------------------------===//
844
845
private:
846
  /// Helper to add branch weight and unpredictable metadata onto an
847
  /// instruction.
848
  /// \returns The annotated instruction.
849
  template <typename InstTy>
850
527k
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
527k
    if (Weights)
852
3.38k
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
527k
    if (Unpredictable)
854
3
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
527k
    return I;
856
527k
  }
llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
2
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
2
    if (Weights)
852
0
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
2
    if (Unpredictable)
854
0
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
2
    return I;
856
2
  }
llvm::BranchInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::addBranchMetadata<llvm::BranchInst>(llvm::BranchInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
80.7k
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
80.7k
    if (Weights)
852
2.44k
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
80.7k
    if (Unpredictable)
854
0
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
80.7k
    return I;
856
80.7k
  }
llvm::SwitchInst* llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::addBranchMetadata<llvm::SwitchInst>(llvm::SwitchInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
13.9k
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
13.9k
    if (Weights)
852
0
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
13.9k
    if (Unpredictable)
854
0
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
13.9k
    return I;
856
13.9k
  }
Unexecuted instantiation: llvm::SelectInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
llvm::SelectInst* llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
919
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
919
    if (Weights)
852
20
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
919
    if (Unpredictable)
854
0
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
919
    return I;
856
919
  }
Unexecuted instantiation: SROA.cpp:llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
llvm::SelectInst* llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
37.5k
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
37.5k
    if (Weights)
852
147
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
37.5k
    if (Unpredictable)
854
1
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
37.5k
    return I;
856
37.5k
  }
llvm::BranchInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::addBranchMetadata<llvm::BranchInst>(llvm::BranchInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
389k
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
389k
    if (Weights)
852
776
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
389k
    if (Unpredictable)
854
2
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
389k
    return I;
856
389k
  }
llvm::SwitchInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::addBranchMetadata<llvm::SwitchInst>(llvm::SwitchInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
4.07k
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
4.07k
    if (Weights)
852
0
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
4.07k
    if (Unpredictable)
854
0
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
4.07k
    return I;
856
4.07k
  }
Unexecuted instantiation: llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
Unexecuted instantiation: llvm::SelectInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::addBranchMetadata<llvm::SelectInst>(llvm::SelectInst*, llvm::MDNode*, llvm::MDNode*)
llvm::BranchInst* llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::addBranchMetadata<llvm::BranchInst>(llvm::BranchInst*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
850
920
  InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851
920
    if (Weights)
852
0
      I->setMetadata(LLVMContext::MD_prof, Weights);
853
920
    if (Unpredictable)
854
0
      I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855
920
    return I;
856
920
  }
857
858
public:
859
  /// Create a 'ret void' instruction.
860
161k
  ReturnInst *CreateRetVoid() {
861
161k
    return Insert(ReturnInst::Create(Context));
862
161k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateRetVoid()
Line
Count
Source
860
379
  ReturnInst *CreateRetVoid() {
861
379
    return Insert(ReturnInst::Create(Context));
862
379
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateRetVoid()
Line
Count
Source
860
161k
  ReturnInst *CreateRetVoid() {
861
161k
    return Insert(ReturnInst::Create(Context));
862
161k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateRetVoid()
Line
Count
Source
860
55
  ReturnInst *CreateRetVoid() {
861
55
    return Insert(ReturnInst::Create(Context));
862
55
  }
863
864
  /// Create a 'ret <val>' instruction.
865
227k
  ReturnInst *CreateRet(Value *V) {
866
227k
    return Insert(ReturnInst::Create(Context, V));
867
227k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateRet(llvm::Value*)
Line
Count
Source
865
1.42k
  ReturnInst *CreateRet(Value *V) {
866
1.42k
    return Insert(ReturnInst::Create(Context, V));
867
1.42k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateRet(llvm::Value*)
Line
Count
Source
865
225k
  ReturnInst *CreateRet(Value *V) {
866
225k
    return Insert(ReturnInst::Create(Context, V));
867
225k
  }
868
869
  /// Create a sequence of N insertvalue instructions,
870
  /// with one Value from the retVals array each, that build a aggregate
871
  /// return value one value at a time, and a ret instruction to return
872
  /// the resulting aggregate value.
873
  ///
874
  /// This is a convenience function for code that uses aggregate return values
875
  /// as a vehicle for having multiple return values.
876
0
  ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
877
0
    Value *V = UndefValue::get(getCurrentFunctionReturnType());
878
0
    for (unsigned i = 0; i != N; ++i)
879
0
      V = CreateInsertValue(V, retVals[i], i, "mrv");
880
0
    return Insert(ReturnInst::Create(Context, V));
881
0
  }
882
883
  /// Create an unconditional 'br label X' instruction.
884
1.04M
  BranchInst *CreateBr(BasicBlock *Dest) {
885
1.04M
    return Insert(BranchInst::Create(Dest));
886
1.04M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateBr(llvm::BasicBlock*)
Line
Count
Source
884
160k
  BranchInst *CreateBr(BasicBlock *Dest) {
885
160k
    return Insert(BranchInst::Create(Dest));
886
160k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateBr(llvm::BasicBlock*)
Line
Count
Source
884
17.8k
  BranchInst *CreateBr(BasicBlock *Dest) {
885
17.8k
    return Insert(BranchInst::Create(Dest));
886
17.8k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateBr(llvm::BasicBlock*)
Line
Count
Source
884
861k
  BranchInst *CreateBr(BasicBlock *Dest) {
885
861k
    return Insert(BranchInst::Create(Dest));
886
861k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateBr(llvm::BasicBlock*)
Line
Count
Source
884
1.19k
  BranchInst *CreateBr(BasicBlock *Dest) {
885
1.19k
    return Insert(BranchInst::Create(Dest));
886
1.19k
  }
887
888
  /// Create a conditional 'br Cond, TrueDest, FalseDest'
889
  /// instruction.
890
  BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
891
                           MDNode *BranchWeights = nullptr,
892
471k
                           MDNode *Unpredictable = nullptr) {
893
471k
    return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
894
471k
                                    BranchWeights, Unpredictable));
895
471k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateCondBr(llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
892
80.7k
                           MDNode *Unpredictable = nullptr) {
893
80.7k
    return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
894
80.7k
                                    BranchWeights, Unpredictable));
895
80.7k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCondBr(llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
892
389k
                           MDNode *Unpredictable = nullptr) {
893
389k
    return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
894
389k
                                    BranchWeights, Unpredictable));
895
389k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateCondBr(llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
892
920
                           MDNode *Unpredictable = nullptr) {
893
920
    return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
894
920
                                    BranchWeights, Unpredictable));
895
920
  }
896
897
  /// Create a conditional 'br Cond, TrueDest, FalseDest'
898
  /// instruction. Copy branch meta data if available.
899
  BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
900
4.04k
                           Instruction *MDSrc) {
901
4.04k
    BranchInst *Br = BranchInst::Create(True, False, Cond);
902
4.04k
    if (MDSrc) {
903
3.69k
      unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
904
3.69k
                        LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
905
3.69k
      Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
906
3.69k
    }
907
4.04k
    return Insert(Br);
908
4.04k
  }
909
910
  /// Create a switch instruction with the specified value, default dest,
911
  /// and with a hint for the number of cases that will be added (for efficient
912
  /// allocation).
913
  SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10,
914
                           MDNode *BranchWeights = nullptr,
915
18.0k
                           MDNode *Unpredictable = nullptr) {
916
18.0k
    return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
917
18.0k
                                    BranchWeights, Unpredictable));
918
18.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateSwitch(llvm::Value*, llvm::BasicBlock*, unsigned int, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
915
13.9k
                           MDNode *Unpredictable = nullptr) {
916
13.9k
    return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
917
13.9k
                                    BranchWeights, Unpredictable));
918
13.9k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateSwitch(llvm::Value*, llvm::BasicBlock*, unsigned int, llvm::MDNode*, llvm::MDNode*)
Line
Count
Source
915
4.07k
                           MDNode *Unpredictable = nullptr) {
916
4.07k
    return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
917
4.07k
                                    BranchWeights, Unpredictable));
918
4.07k
  }
919
920
  /// Create an indirect branch instruction with the specified address
921
  /// operand, with an optional hint for the number of destinations that will be
922
  /// added (for efficient allocation).
923
34
  IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
924
34
    return Insert(IndirectBrInst::Create(Addr, NumDests));
925
34
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateIndirectBr(llvm::Value*, unsigned int)
Line
Count
Source
923
34
  IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
924
34
    return Insert(IndirectBrInst::Create(Addr, NumDests));
925
34
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateIndirectBr(llvm::Value*, unsigned int)
926
927
  /// Create an invoke instruction.
928
  InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
929
                           BasicBlock *NormalDest, BasicBlock *UnwindDest,
930
                           ArrayRef<Value *> Args,
931
                           ArrayRef<OperandBundleDef> OpBundles,
932
38.0k
                           const Twine &Name = "") {
933
38.0k
    return Insert(
934
38.0k
        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
935
38.0k
        Name);
936
38.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateInvoke(llvm::FunctionType*, llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::ArrayRef<llvm::Value*>, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >, llvm::Twine const&)
Line
Count
Source
932
2
                           const Twine &Name = "") {
933
2
    return Insert(
934
2
        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
935
2
        Name);
936
2
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateInvoke(llvm::FunctionType*, llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::ArrayRef<llvm::Value*>, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >, llvm::Twine const&)
Line
Count
Source
932
27
                           const Twine &Name = "") {
933
27
    return Insert(
934
27
        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
935
27
        Name);
936
27
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateInvoke(llvm::FunctionType*, llvm::Value*, llvm::BasicBlock*, llvm::BasicBlock*, llvm::ArrayRef<llvm::Value*>, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >, llvm::Twine const&)
Line
Count
Source
932
37.9k
                           const Twine &Name = "") {
933
37.9k
    return Insert(
934
37.9k
        InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
935
37.9k
        Name);
936
37.9k
  }
937
  InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
938
                           BasicBlock *NormalDest, BasicBlock *UnwindDest,
939
                           ArrayRef<Value *> Args = None,
940
7
                           const Twine &Name = "") {
941
7
    return Insert(InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args),
942
7
                  Name);
943
7
  }
944
945
  InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
946
                           BasicBlock *UnwindDest, ArrayRef<Value *> Args,
947
                           ArrayRef<OperandBundleDef> OpBundles,
948
550
                           const Twine &Name = "") {
949
550
    return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
950
550
                        NormalDest, UnwindDest, Args, OpBundles, Name);
951
550
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateInvoke(llvm::FunctionCallee, llvm::BasicBlock*, llvm::BasicBlock*, llvm::ArrayRef<llvm::Value*>, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >, llvm::Twine const&)
Line
Count
Source
948
2
                           const Twine &Name = "") {
949
2
    return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
950
2
                        NormalDest, UnwindDest, Args, OpBundles, Name);
951
2
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateInvoke(llvm::FunctionCallee, llvm::BasicBlock*, llvm::BasicBlock*, llvm::ArrayRef<llvm::Value*>, llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*> >, llvm::Twine const&)
Line
Count
Source
948
548
                           const Twine &Name = "") {
949
548
    return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
950
548
                        NormalDest, UnwindDest, Args, OpBundles, Name);
951
548
  }
952
953
  InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
954
                           BasicBlock *UnwindDest,
955
                           ArrayRef<Value *> Args = None,
956
                           const Twine &Name = "") {
957
    return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
958
                        NormalDest, UnwindDest, Args, Name);
959
  }
960
961
  // Deprecated [opaque pointer types]
962
  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
963
                           BasicBlock *UnwindDest, ArrayRef<Value *> Args,
964
                           ArrayRef<OperandBundleDef> OpBundles,
965
27
                           const Twine &Name = "") {
966
27
    return CreateInvoke(
967
27
        cast<FunctionType>(
968
27
            cast<PointerType>(Callee->getType())->getElementType()),
969
27
        Callee, NormalDest, UnwindDest, Args, OpBundles, Name);
970
27
  }
971
972
  // Deprecated [opaque pointer types]
973
  InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
974
                           BasicBlock *UnwindDest,
975
                           ArrayRef<Value *> Args = None,
976
                           const Twine &Name = "") {
977
    return CreateInvoke(
978
        cast<FunctionType>(
979
            cast<PointerType>(Callee->getType())->getElementType()),
980
        Callee, NormalDest, UnwindDest, Args, Name);
981
  }
982
983
  /// \brief Create a callbr instruction.
984
  CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
985
                           BasicBlock *DefaultDest,
986
                           ArrayRef<BasicBlock *> IndirectDests,
987
                           ArrayRef<Value *> Args = None,
988
10
                           const Twine &Name = "") {
989
10
    return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
990
10
                                     Args), Name);
991
10
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateCallBr(llvm::FunctionType*, llvm::Value*, llvm::BasicBlock*, llvm::ArrayRef<llvm::BasicBlock*>, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCallBr(llvm::FunctionType*, llvm::Value*, llvm::BasicBlock*, llvm::ArrayRef<llvm::BasicBlock*>, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
988
10
                           const Twine &Name = "") {
989
10
    return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
990
10
                                     Args), Name);
991
10
  }
992
  CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
993
                           BasicBlock *DefaultDest,
994
                           ArrayRef<BasicBlock *> IndirectDests,
995
                           ArrayRef<Value *> Args,
996
                           ArrayRef<OperandBundleDef> OpBundles,
997
                           const Twine &Name = "") {
998
    return Insert(
999
        CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests, Args,
1000
                           OpBundles), Name);
1001
  }
1002
1003
  CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
1004
                           ArrayRef<BasicBlock *> IndirectDests,
1005
                           ArrayRef<Value *> Args = None,
1006
10
                           const Twine &Name = "") {
1007
10
    return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1008
10
                        DefaultDest, IndirectDests, Args, Name);
1009
10
  }
1010
  CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
1011
                           ArrayRef<BasicBlock *> IndirectDests,
1012
                           ArrayRef<Value *> Args,
1013
                           ArrayRef<OperandBundleDef> OpBundles,
1014
0
                           const Twine &Name = "") {
1015
0
    return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1016
0
                        DefaultDest, IndirectDests, Args, Name);
1017
0
  }
1018
1019
5.48k
  ResumeInst *CreateResume(Value *Exn) {
1020
5.48k
    return Insert(ResumeInst::Create(Exn));
1021
5.48k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateResume(llvm::Value*)
Line
Count
Source
1019
5.48k
  ResumeInst *CreateResume(Value *Exn) {
1020
5.48k
    return Insert(ResumeInst::Create(Exn));
1021
5.48k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateResume(llvm::Value*)
Line
Count
Source
1019
1
  ResumeInst *CreateResume(Value *Exn) {
1020
1
    return Insert(ResumeInst::Create(Exn));
1021
1
  }
1022
1023
  CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
1024
174
                                      BasicBlock *UnwindBB = nullptr) {
1025
174
    return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1026
174
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCleanupRet(llvm::CleanupPadInst*, llvm::BasicBlock*)
Line
Count
Source
1024
172
                                      BasicBlock *UnwindBB = nullptr) {
1025
172
    return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1026
172
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateCleanupRet(llvm::CleanupPadInst*, llvm::BasicBlock*)
Line
Count
Source
1024
2
                                      BasicBlock *UnwindBB = nullptr) {
1025
2
    return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1026
2
  }
1027
1028
  CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
1029
                                     unsigned NumHandlers,
1030
108
                                     const Twine &Name = "") {
1031
108
    return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1032
108
                  Name);
1033
108
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCatchSwitch(llvm::Value*, llvm::BasicBlock*, unsigned int, llvm::Twine const&)
Line
Count
Source
1030
105
                                     const Twine &Name = "") {
1031
105
    return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1032
105
                  Name);
1033
105
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateCatchSwitch(llvm::Value*, llvm::BasicBlock*, unsigned int, llvm::Twine const&)
Line
Count
Source
1030
3
                                     const Twine &Name = "") {
1031
3
    return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1032
3
                  Name);
1033
3
  }
1034
1035
  CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
1036
112
                               const Twine &Name = "") {
1037
112
    return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1038
112
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCatchPad(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1036
108
                               const Twine &Name = "") {
1037
108
    return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1038
108
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateCatchPad(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1036
4
                               const Twine &Name = "") {
1037
4
    return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1038
4
  }
1039
1040
  CleanupPadInst *CreateCleanupPad(Value *ParentPad,
1041
                                   ArrayRef<Value *> Args = None,
1042
191
                                   const Twine &Name = "") {
1043
191
    return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1044
191
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCleanupPad(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1042
189
                                   const Twine &Name = "") {
1043
189
    return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1044
189
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateCleanupPad(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1042
2
                                   const Twine &Name = "") {
1043
2
    return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1044
2
  }
1045
1046
116
  CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
1047
116
    return Insert(CatchReturnInst::Create(CatchPad, BB));
1048
116
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateCatchRet(llvm::CatchPadInst*, llvm::BasicBlock*)
Line
Count
Source
1046
114
  CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
1047
114
    return Insert(CatchReturnInst::Create(CatchPad, BB));
1048
114
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateCatchRet(llvm::CatchPadInst*, llvm::BasicBlock*)
Line
Count
Source
1046
2
  CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
1047
2
    return Insert(CatchReturnInst::Create(CatchPad, BB));
1048
2
  }
1049
1050
61.5k
  UnreachableInst *CreateUnreachable() {
1051
61.5k
    return Insert(new UnreachableInst(Context));
1052
61.5k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateUnreachable()
Line
Count
Source
1050
26.5k
  UnreachableInst *CreateUnreachable() {
1051
26.5k
    return Insert(new UnreachableInst(Context));
1052
26.5k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateUnreachable()
Line
Count
Source
1050
43
  UnreachableInst *CreateUnreachable() {
1051
43
    return Insert(new UnreachableInst(Context));
1052
43
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateUnreachable()
Line
Count
Source
1050
35.0k
  UnreachableInst *CreateUnreachable() {
1051
35.0k
    return Insert(new UnreachableInst(Context));
1052
35.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateUnreachable()
Line
Count
Source
1050
8
  UnreachableInst *CreateUnreachable() {
1051
8
    return Insert(new UnreachableInst(Context));
1052
8
  }
1053
1054
  //===--------------------------------------------------------------------===//
1055
  // Instruction creation methods: Binary Operators
1056
  //===--------------------------------------------------------------------===//
1057
private:
1058
  BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1059
                                          Value *LHS, Value *RHS,
1060
                                          const Twine &Name,
1061
478k
                                          bool HasNUW, bool HasNSW) {
1062
478k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
478k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()2.81k
;
1064
478k
    if (HasNSW) 
BO->setHasNoSignedWrap()173k
;
1065
478k
    return BO;
1066
478k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateInsertNUWNSWBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1061
100k
                                          bool HasNUW, bool HasNSW) {
1062
100k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
100k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()353
;
1064
100k
    if (HasNSW) 
BO->setHasNoSignedWrap()631
;
1065
100k
    return BO;
1066
100k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateInsertNUWNSWBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1061
84.3k
                                          bool HasNUW, bool HasNSW) {
1062
84.3k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
84.3k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()0
;
1064
84.3k
    if (HasNSW) 
BO->setHasNoSignedWrap()0
;
1065
84.3k
    return BO;
1066
84.3k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateInsertNUWNSWBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1061
9.34k
                                          bool HasNUW, bool HasNSW) {
1062
9.34k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
9.34k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()129
;
1064
9.34k
    if (HasNSW) 
BO->setHasNoSignedWrap()269
;
1065
9.34k
    return BO;
1066
9.34k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateInsertNUWNSWBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1061
2.22k
                                          bool HasNUW, bool HasNSW) {
1062
2.22k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
2.22k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()0
;
1064
2.22k
    if (HasNSW) 
BO->setHasNoSignedWrap()0
;
1065
2.22k
    return BO;
1066
2.22k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateInsertNUWNSWBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1061
280k
                                          bool HasNUW, bool HasNSW) {
1062
280k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
280k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()2.33k
;
1064
280k
    if (HasNSW) 
BO->setHasNoSignedWrap()171k
;
1065
280k
    return BO;
1066
280k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateInsertNUWNSWBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1061
1.67k
                                          bool HasNUW, bool HasNSW) {
1062
1.67k
    BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063
1.67k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()0
;
1064
1.67k
    if (HasNSW) 
BO->setHasNoSignedWrap()1.59k
;
1065
1.67k
    return BO;
1066
1.67k
  }
1067
1068
  Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1069
166k
                          FastMathFlags FMF) const {
1070
166k
    if (!FPMD)
1071
166k
      FPMD = DefaultFPMathTag;
1072
166k
    if (FPMD)
1073
62
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
166k
    I->setFastMathFlags(FMF);
1075
166k
    return I;
1076
166k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
Line
Count
Source
1069
65.3k
                          FastMathFlags FMF) const {
1070
65.3k
    if (!FPMD)
1071
65.3k
      FPMD = DefaultFPMathTag;
1072
65.3k
    if (FPMD)
1073
62
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
65.3k
    I->setFastMathFlags(FMF);
1075
65.3k
    return I;
1076
65.3k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
Line
Count
Source
1069
1.97k
                          FastMathFlags FMF) const {
1070
1.97k
    if (!FPMD)
1071
1.97k
      FPMD = DefaultFPMathTag;
1072
1.97k
    if (FPMD)
1073
0
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
1.97k
    I->setFastMathFlags(FMF);
1075
1.97k
    return I;
1076
1.97k
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
Line
Count
Source
1069
1.09k
                          FastMathFlags FMF) const {
1070
1.09k
    if (!FPMD)
1071
1.09k
      FPMD = DefaultFPMathTag;
1072
1.09k
    if (FPMD)
1073
0
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
1.09k
    I->setFastMathFlags(FMF);
1075
1.09k
    return I;
1076
1.09k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
Line
Count
Source
1069
55
                          FastMathFlags FMF) const {
1070
55
    if (!FPMD)
1071
55
      FPMD = DefaultFPMathTag;
1072
55
    if (FPMD)
1073
0
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
55
    I->setFastMathFlags(FMF);
1075
55
    return I;
1076
55
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
Line
Count
Source
1069
98.3k
                          FastMathFlags FMF) const {
1070
98.3k
    if (!FPMD)
1071
98.3k
      FPMD = DefaultFPMathTag;
1072
98.3k
    if (FPMD)
1073
0
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
98.3k
    I->setFastMathFlags(FMF);
1075
98.3k
    return I;
1076
98.3k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::setFPAttrs(llvm::Instruction*, llvm::MDNode*, llvm::FastMathFlags) const
Line
Count
Source
1069
6
                          FastMathFlags FMF) const {
1070
6
    if (!FPMD)
1071
6
      FPMD = DefaultFPMathTag;
1072
6
    if (FPMD)
1073
0
      I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074
6
    I->setFastMathFlags(FMF);
1075
6
    return I;
1076
6
  }
1077
1078
  Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
1079
453k
                      Value *R, const Twine &Name) const {
1080
453k
    auto *LC = dyn_cast<Constant>(L);
1081
453k
    auto *RC = dyn_cast<Constant>(R);
1082
453k
    return (LC && 
RC114k
) ?
Insert(Folder.CreateBinOp(Opc, LC, RC), Name)89.2k
:
nullptr364k
;
1083
453k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::foldConstant(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&) const
Line
Count
Source
1079
278k
                      Value *R, const Twine &Name) const {
1080
278k
    auto *LC = dyn_cast<Constant>(L);
1081
278k
    auto *RC = dyn_cast<Constant>(R);
1082
278k
    return (LC && 
RC94.4k
) ?
Insert(Folder.CreateBinOp(Opc, LC, RC), Name)80.4k
:
nullptr198k
;
1083
278k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::foldConstant(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&) const
Line
Count
Source
1079
5
                      Value *R, const Twine &Name) const {
1080
5
    auto *LC = dyn_cast<Constant>(L);
1081
5
    auto *RC = dyn_cast<Constant>(R);
1082
5
    return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : 
nullptr0
;
1083
5
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::foldConstant(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&) const
Line
Count
Source
1079
81.2k
                      Value *R, const Twine &Name) const {
1080
81.2k
    auto *LC = dyn_cast<Constant>(L);
1081
81.2k
    auto *RC = dyn_cast<Constant>(R);
1082
81.2k
    return (LC && 
RC5.22k
) ?
Insert(Folder.CreateBinOp(Opc, LC, RC), Name)0
: nullptr;
1083
81.2k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::foldConstant(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&) const
Line
Count
Source
1079
19.4k
                      Value *R, const Twine &Name) const {
1080
19.4k
    auto *LC = dyn_cast<Constant>(L);
1081
19.4k
    auto *RC = dyn_cast<Constant>(R);
1082
19.4k
    return (LC && 
RC422
) ?
Insert(Folder.CreateBinOp(Opc, LC, RC), Name)183
:
nullptr19.2k
;
1083
19.4k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::foldConstant(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&) const
Line
Count
Source
1079
74.5k
                      Value *R, const Twine &Name) const {
1080
74.5k
    auto *LC = dyn_cast<Constant>(L);
1081
74.5k
    auto *RC = dyn_cast<Constant>(R);
1082
74.5k
    return (LC && 
RC14.1k
) ?
Insert(Folder.CreateBinOp(Opc, LC, RC), Name)8.65k
:
nullptr65.8k
;
1083
74.5k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::foldConstant(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&) const
Line
Count
Source
1079
34
                      Value *R, const Twine &Name) const {
1080
34
    auto *LC = dyn_cast<Constant>(L);
1081
34
    auto *RC = dyn_cast<Constant>(R);
1082
34
    return (LC && 
RC0
) ?
Insert(Folder.CreateBinOp(Opc, LC, RC), Name)0
: nullptr;
1083
34
  }
1084
1085
  Value *getConstrainedFPRounding(
1086
10
      Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding) {
1087
10
    ConstrainedFPIntrinsic::RoundingMode UseRounding =
1088
10
        DefaultConstrainedRounding;
1089
10
1090
10
    if (Rounding.hasValue())
1091
1
      UseRounding = Rounding.getValue();
1092
10
1093
10
    Optional<StringRef> RoundingStr =
1094
10
        ConstrainedFPIntrinsic::RoundingModeToStr(UseRounding);
1095
10
    assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
1096
10
    auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
1097
10
1098
10
    return MetadataAsValue::get(Context, RoundingMDS);
1099
10
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::getConstrainedFPRounding(llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>)
Line
Count
Source
1086
10
      Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding) {
1087
10
    ConstrainedFPIntrinsic::RoundingMode UseRounding =
1088
10
        DefaultConstrainedRounding;
1089
10
1090
10
    if (Rounding.hasValue())
1091
1
      UseRounding = Rounding.getValue();
1092
10
1093
10
    Optional<StringRef> RoundingStr =
1094
10
        ConstrainedFPIntrinsic::RoundingModeToStr(UseRounding);
1095
10
    assert(RoundingStr.hasValue() && "Garbage strict rounding mode!");
1096
10
    auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
1097
10
1098
10
    return MetadataAsValue::get(Context, RoundingMDS);
1099
10
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::getConstrainedFPRounding(llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>)
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::getConstrainedFPRounding(llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>)
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::getConstrainedFPRounding(llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>)
1100
1101
  Value *getConstrainedFPExcept(
1102
10
      Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except) {
1103
10
    ConstrainedFPIntrinsic::ExceptionBehavior UseExcept =
1104
10
        DefaultConstrainedExcept;
1105
10
1106
10
    if (Except.hasValue())
1107
1
      UseExcept = Except.getValue();
1108
10
1109
10
    Optional<StringRef> ExceptStr =
1110
10
        ConstrainedFPIntrinsic::ExceptionBehaviorToStr(UseExcept);
1111
10
    assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
1112
10
    auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
1113
10
1114
10
    return MetadataAsValue::get(Context, ExceptMDS);
1115
10
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::getConstrainedFPExcept(llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
Line
Count
Source
1102
10
      Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except) {
1103
10
    ConstrainedFPIntrinsic::ExceptionBehavior UseExcept =
1104
10
        DefaultConstrainedExcept;
1105
10
1106
10
    if (Except.hasValue())
1107
1
      UseExcept = Except.getValue();
1108
10
1109
10
    Optional<StringRef> ExceptStr =
1110
10
        ConstrainedFPIntrinsic::ExceptionBehaviorToStr(UseExcept);
1111
10
    assert(ExceptStr.hasValue() && "Garbage strict exception behavior!");
1112
10
    auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
1113
10
1114
10
    return MetadataAsValue::get(Context, ExceptMDS);
1115
10
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::getConstrainedFPExcept(llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::getConstrainedFPExcept(llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::getConstrainedFPExcept(llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
1116
1117
public:
1118
  Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
1119
368k
                   bool HasNUW = false, bool HasNSW = false) {
1120
368k
    if (auto *LC = dyn_cast<Constant>(LHS))
1121
75.3k
      if (auto *RC = dyn_cast<Constant>(RHS))
1122
63.8k
        return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123
304k
    return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124
304k
                                   HasNUW, HasNSW);
1125
304k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1119
74.0k
                   bool HasNUW = false, bool HasNSW = false) {
1120
74.0k
    if (auto *LC = dyn_cast<Constant>(LHS))
1121
15.6k
      if (auto *RC = dyn_cast<Constant>(RHS))
1122
14.7k
        return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123
59.3k
    return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124
59.3k
                                   HasNUW, HasNSW);
1125
59.3k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1119
10.5k
                   bool HasNUW = false, bool HasNSW = false) {
1120
10.5k
    if (auto *LC = dyn_cast<Constant>(LHS))
1121
8.96k
      if (auto *RC = dyn_cast<Constant>(RHS))
1122
8.94k
        return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123
1.61k
    return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124
1.61k
                                   HasNUW, HasNSW);
1125
1.61k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1119
83.1k
                   bool HasNUW = false, bool HasNSW = false) {
1120
83.1k
    if (auto *LC = dyn_cast<Constant>(LHS))
1121
115
      if (auto *RC = dyn_cast<Constant>(RHS))
1122
0
        return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123
83.1k
    return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124
83.1k
                                   HasNUW, HasNSW);
1125
83.1k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1119
199k
                   bool HasNUW = false, bool HasNSW = false) {
1120
199k
    if (auto *LC = dyn_cast<Constant>(LHS))
1121
50.5k
      if (auto *RC = dyn_cast<Constant>(RHS))
1122
40.0k
        return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123
159k
    return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124
159k
                                   HasNUW, HasNSW);
1125
159k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1119
1.08k
                   bool HasNUW = false, bool HasNSW = false) {
1120
1.08k
    if (auto *LC = dyn_cast<Constant>(LHS))
1121
130
      if (auto *RC = dyn_cast<Constant>(RHS))
1122
130
        return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123
959
    return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124
959
                                   HasNUW, HasNSW);
1125
959
  }
1126
1127
144k
  Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1128
144k
    return CreateAdd(LHS, RHS, Name, false, true);
1129
144k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateNSWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1127
269
  Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1128
269
    return CreateAdd(LHS, RHS, Name, false, true);
1129
269
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNSWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1127
479
  Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1128
479
    return CreateAdd(LHS, RHS, Name, false, true);
1129
479
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNSWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1127
142k
  Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1128
142k
    return CreateAdd(LHS, RHS, Name, false, true);
1129
142k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateNSWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1127
915
  Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1128
915
    return CreateAdd(LHS, RHS, Name, false, true);
1129
915
  }
1130
1131
123
  Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1132
123
    return CreateAdd(LHS, RHS, Name, true, false);
1133
123
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateNUWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1131
50
  Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1132
50
    return CreateAdd(LHS, RHS, Name, true, false);
1133
50
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNUWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1131
73
  Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1132
73
    return CreateAdd(LHS, RHS, Name, true, false);
1133
73
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNUWAdd(llvm::Value*, llvm::Value*, llvm::Twine const&)
1134
1135
  Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
1136
209k
                   bool HasNUW = false, bool HasNSW = false) {
1137
209k
    if (auto *LC = dyn_cast<Constant>(LHS))
1138
132k
      if (auto *RC = dyn_cast<Constant>(RHS))
1139
124k
        return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140
84.5k
    return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141
84.5k
                                   HasNUW, HasNSW);
1142
84.5k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateSub(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1136
26.5k
                   bool HasNUW = false, bool HasNSW = false) {
1137
26.5k
    if (auto *LC = dyn_cast<Constant>(LHS))
1138
10.8k
      if (auto *RC = dyn_cast<Constant>(RHS))
1139
10.4k
        return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140
16.0k
    return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141
16.0k
                                   HasNUW, HasNSW);
1142
16.0k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateSub(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1136
1.25k
                   bool HasNUW = false, bool HasNSW = false) {
1137
1.25k
    if (auto *LC = dyn_cast<Constant>(LHS))
1138
218
      if (auto *RC = dyn_cast<Constant>(RHS))
1139
43
        return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140
1.20k
    return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141
1.20k
                                   HasNUW, HasNSW);
1142
1.20k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateSub(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1136
3.03k
                   bool HasNUW = false, bool HasNSW = false) {
1137
3.03k
    if (auto *LC = dyn_cast<Constant>(LHS))
1138
8
      if (auto *RC = dyn_cast<Constant>(RHS))
1139
4
        return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140
3.03k
    return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141
3.03k
                                   HasNUW, HasNSW);
1142
3.03k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateSub(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1136
178k
                   bool HasNUW = false, bool HasNSW = false) {
1137
178k
    if (auto *LC = dyn_cast<Constant>(LHS))
1138
121k
      if (auto *RC = dyn_cast<Constant>(RHS))
1139
113k
        return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140
64.0k
    return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141
64.0k
                                   HasNUW, HasNSW);
1142
64.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateSub(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1136
146
                   bool HasNUW = false, bool HasNSW = false) {
1137
146
    if (auto *LC = dyn_cast<Constant>(LHS))
1138
23
      if (auto *RC = dyn_cast<Constant>(RHS))
1139
0
        return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140
146
    return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141
146
                                   HasNUW, HasNSW);
1142
146
  }
1143
1144
131k
  Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1145
131k
    return CreateSub(LHS, RHS, Name, false, true);
1146
131k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNSWSub(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1144
131k
  Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1145
131k
    return CreateSub(LHS, RHS, Name, false, true);
1146
131k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateNSWSub(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1144
107
  Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1145
107
    return CreateSub(LHS, RHS, Name, false, true);
1146
107
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNSWSub(llvm::Value*, llvm::Value*, llvm::Twine const&)
1147
1148
376
  Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1149
376
    return CreateSub(LHS, RHS, Name, true, false);
1150
376
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNUWSub(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1148
376
  Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1149
376
    return CreateSub(LHS, RHS, Name, true, false);
1150
376
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNUWSub(llvm::Value*, llvm::Value*, llvm::Twine const&)
1151
1152
  Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
1153
115k
                   bool HasNUW = false, bool HasNSW = false) {
1154
115k
    if (auto *LC = dyn_cast<Constant>(LHS))
1155
59.3k
      if (auto *RC = dyn_cast<Constant>(RHS))
1156
50.4k
        return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157
64.7k
    return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158
64.7k
                                   HasNUW, HasNSW);
1159
64.7k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateMul(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1153
51.0k
                   bool HasNUW = false, bool HasNSW = false) {
1154
51.0k
    if (auto *LC = dyn_cast<Constant>(LHS))
1155
28.9k
      if (auto *RC = dyn_cast<Constant>(RHS))
1156
28.4k
        return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157
22.6k
    return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158
22.6k
                                   HasNUW, HasNSW);
1159
22.6k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateMul(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1153
1.74k
                   bool HasNUW = false, bool HasNSW = false) {
1154
1.74k
    if (auto *LC = dyn_cast<Constant>(LHS))
1155
1.18k
      if (auto *RC = dyn_cast<Constant>(RHS))
1156
1.16k
        return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157
579
    return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158
579
                                   HasNUW, HasNSW);
1159
579
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateMul(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateMul(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1153
1.72k
                   bool HasNUW = false, bool HasNSW = false) {
1154
1.72k
    if (auto *LC = dyn_cast<Constant>(LHS))
1155
1.72k
      if (auto *RC = dyn_cast<Constant>(RHS))
1156
1.72k
        return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157
0
    return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158
0
                                   HasNUW, HasNSW);
1159
0
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateMul(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1153
60.1k
                   bool HasNUW = false, bool HasNSW = false) {
1154
60.1k
    if (auto *LC = dyn_cast<Constant>(LHS))
1155
27.1k
      if (auto *RC = dyn_cast<Constant>(RHS))
1156
19.1k
        return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157
41.0k
    return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158
41.0k
                                   HasNUW, HasNSW);
1159
41.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateMul(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1153
573
                   bool HasNUW = false, bool HasNSW = false) {
1154
573
    if (auto *LC = dyn_cast<Constant>(LHS))
1155
378
      if (auto *RC = dyn_cast<Constant>(RHS))
1156
0
        return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157
573
    return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158
573
                                   HasNUW, HasNSW);
1159
573
  }
1160
1161
33.6k
  Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1162
33.6k
    return CreateMul(LHS, RHS, Name, false, true);
1163
33.6k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNSWMul(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1161
33.0k
  Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1162
33.0k
    return CreateMul(LHS, RHS, Name, false, true);
1163
33.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateNSWMul(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1161
573
  Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1162
573
    return CreateMul(LHS, RHS, Name, false, true);
1163
573
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNSWMul(llvm::Value*, llvm::Value*, llvm::Twine const&)
1164
1165
2.16k
  Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1166
2.16k
    return CreateMul(LHS, RHS, Name, true, false);
1167
2.16k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNUWMul(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1165
2.16k
  Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1166
2.16k
    return CreateMul(LHS, RHS, Name, true, false);
1167
2.16k
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNUWMul(llvm::Value*, llvm::Value*, llvm::Twine const&)
1168
1169
  Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1170
8.21k
                    bool isExact = false) {
1171
8.21k
    if (auto *LC = dyn_cast<Constant>(LHS))
1172
3.68k
      if (auto *RC = dyn_cast<Constant>(RHS))
1173
3.56k
        return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1174
4.64k
    if (!isExact)
1175
4.61k
      return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1176
33
    return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1177
33
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateUDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1170
451
                    bool isExact = false) {
1171
451
    if (auto *LC = dyn_cast<Constant>(LHS))
1172
8
      if (auto *RC = dyn_cast<Constant>(RHS))
1173
0
        return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1174
451
    if (!isExact)
1175
451
      return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1176
0
    return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1177
0
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateUDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1170
7.74k
                    bool isExact = false) {
1171
7.74k
    if (auto *LC = dyn_cast<Constant>(LHS))
1172
3.67k
      if (auto *RC = dyn_cast<Constant>(RHS))
1173
3.56k
        return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1174
4.18k
    if (!isExact)
1175
4.15k
      return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1176
33
    return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1177
33
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateUDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1170
13
                    bool isExact = false) {
1171
13
    if (auto *LC = dyn_cast<Constant>(LHS))
1172
0
      if (auto *RC = dyn_cast<Constant>(RHS))
1173
0
        return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1174
13
    if (!isExact)
1175
13
      return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1176
0
    return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1177
0
  }
1178
1179
33
  Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1180
33
    return CreateUDiv(LHS, RHS, Name, true);
1181
33
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateExactUDiv(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1179
33
  Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1180
33
    return CreateUDiv(LHS, RHS, Name, true);
1181
33
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateExactUDiv(llvm::Value*, llvm::Value*, llvm::Twine const&)
1182
1183
  Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1184
37.6k
                    bool isExact = false) {
1185
37.6k
    if (auto *LC = dyn_cast<Constant>(LHS))
1186
25.3k
      if (auto *RC = dyn_cast<Constant>(RHS))
1187
25.0k
        return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1188
12.5k
    if (!isExact)
1189
8.57k
      return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1190
4.01k
    return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1191
4.01k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateSDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1184
58
                    bool isExact = false) {
1185
58
    if (auto *LC = dyn_cast<Constant>(LHS))
1186
0
      if (auto *RC = dyn_cast<Constant>(RHS))
1187
0
        return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1188
58
    if (!isExact)
1189
55
      return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1190
3
    return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1191
3
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateSDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1184
39
                    bool isExact = false) {
1185
39
    if (auto *LC = dyn_cast<Constant>(LHS))
1186
3
      if (auto *RC = dyn_cast<Constant>(RHS))
1187
0
        return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1188
39
    if (!isExact)
1189
39
      return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1190
0
    return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1191
0
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateSDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1184
37.5k
                    bool isExact = false) {
1185
37.5k
    if (auto *LC = dyn_cast<Constant>(LHS))
1186
25.3k
      if (auto *RC = dyn_cast<Constant>(RHS))
1187
25.0k
        return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1188
12.4k
    if (!isExact)
1189
8.47k
      return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1190
4.00k
    return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1191
4.00k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateSDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1184
3
                    bool isExact = false) {
1185
3
    if (auto *LC = dyn_cast<Constant>(LHS))
1186
0
      if (auto *RC = dyn_cast<Constant>(RHS))
1187
0
        return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1188
3
    if (!isExact)
1189
0
      return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1190
3
    return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1191
3
  }
1192
1193
4.04k
  Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1194
4.04k
    return CreateSDiv(LHS, RHS, Name, true);
1195
4.04k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateExactSDiv(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1193
4.04k
  Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1194
4.04k
    return CreateSDiv(LHS, RHS, Name, true);
1195
4.04k
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateExactSDiv(llvm::Value*, llvm::Value*, llvm::Twine const&)
1196
1197
19.8k
  Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1198
19.8k
    if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) 
return V10.1k
;
1199
9.73k
    return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1200
9.73k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateURem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1197
180
  Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1198
180
    if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) 
return V0
;
1199
180
    return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1200
180
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateURem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1197
17.5k
  Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1198
17.5k
    if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) 
return V10.1k
;
1199
7.36k
    return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1200
7.36k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateURem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1197
2.17k
  Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1198
2.17k
    if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) 
return V13
;
1199
2.16k
    return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1200
2.16k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateURem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1197
24
  Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1198
24
    if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) 
return V0
;
1199
24
    return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1200
24
  }
1201
1202
1.49k
  Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1203
1.49k
    if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) 
return V19
;
1204
1.47k
    return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1205
1.47k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateSRem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1202
4
  Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1203
4
    if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) 
return V0
;
1204
4
    return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1205
4
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateSRem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1202
40
  Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1203
40
    if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) 
return V0
;
1204
40
    return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1205
40
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateSRem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1202
1.45k
  Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1203
1.45k
    if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) 
return V19
;
1204
1.43k
    return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1205
1.43k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateSRem(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1202
3
  Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1203
3
    if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) 
return V0
;
1204
3
    return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1205
3
  }
1206
1207
  Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
1208
48.1k
                   bool HasNUW = false, bool HasNSW = false) {
1209
48.1k
    if (auto *LC = dyn_cast<Constant>(LHS))
1210
27.1k
      if (auto *RC = dyn_cast<Constant>(RHS))
1211
24.0k
        return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1212
24.1k
    return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1213
24.1k
                                   HasNUW, HasNSW);
1214
24.1k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateShl(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1208
7.67k
                   bool HasNUW = false, bool HasNSW = false) {
1209
7.67k
    if (auto *LC = dyn_cast<Constant>(LHS))
1210
5.80k
      if (auto *RC = dyn_cast<Constant>(RHS))
1211
5.48k
        return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1212
2.19k
    return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1213
2.19k
                                   HasNUW, HasNSW);
1214
2.19k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateShl(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1208
4.93k
                   bool HasNUW = false, bool HasNSW = false) {
1209
4.93k
    if (auto *LC = dyn_cast<Constant>(LHS))
1210
1.18k
      if (auto *RC = dyn_cast<Constant>(RHS))
1211
813
        return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1212
4.12k
    return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1213
4.12k
                                   HasNUW, HasNSW);
1214
4.12k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateShl(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1208
2.23k
                   bool HasNUW = false, bool HasNSW = false) {
1209
2.23k
    if (auto *LC = dyn_cast<Constant>(LHS))
1210
9
      if (auto *RC = dyn_cast<Constant>(RHS))
1211
9
        return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1212
2.22k
    return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1213
2.22k
                                   HasNUW, HasNSW);
1214
2.22k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateShl(llvm::Value*, llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1208
33.3k
                   bool HasNUW = false, bool HasNSW = false) {
1209
33.3k
    if (auto *LC = dyn_cast<Constant>(LHS))
1210
20.1k
      if (auto *RC = dyn_cast<Constant>(RHS))
1211
17.7k
        return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1212
15.6k
    return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1213
15.6k
                                   HasNUW, HasNSW);
1214
15.6k
  }
1215
1216
  Value *CreateShl(Value *LHS, const APInt &RHS, const Twine &Name = "",
1217
                   bool HasNUW = false, bool HasNSW = false) {
1218
    return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1219
                     HasNUW, HasNSW);
1220
  }
1221
1222
  Value *CreateShl(Value *LHS, uint64_t RHS, const Twine &Name = "",
1223
7.43k
                   bool HasNUW = false, bool HasNSW = false) {
1224
7.43k
    return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1225
7.43k
                     HasNUW, HasNSW);
1226
7.43k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateShl(llvm::Value*, unsigned long long, llvm::Twine const&, bool, bool)
Line
Count
Source
1223
496
                   bool HasNUW = false, bool HasNSW = false) {
1224
496
    return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1225
496
                     HasNUW, HasNSW);
1226
496
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateShl(llvm::Value*, unsigned long long, llvm::Twine const&, bool, bool)
Line
Count
Source
1223
1.42k
                   bool HasNUW = false, bool HasNSW = false) {
1224
1.42k
    return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1225
1.42k
                     HasNUW, HasNSW);
1226
1.42k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateShl(llvm::Value*, unsigned long long, llvm::Twine const&, bool, bool)
Line
Count
Source
1223
2.23k
                   bool HasNUW = false, bool HasNSW = false) {
1224
2.23k
    return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1225
2.23k
                     HasNUW, HasNSW);
1226
2.23k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateShl(llvm::Value*, unsigned long long, llvm::Twine const&, bool, bool)
Line
Count
Source
1223
3.27k
                   bool HasNUW = false, bool HasNSW = false) {
1224
3.27k
    return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1225
3.27k
                     HasNUW, HasNSW);
1226
3.27k
  }
1227
1228
  Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
1229
23.5k
                    bool isExact = false) {
1230
23.5k
    if (auto *LC = dyn_cast<Constant>(LHS))
1231
1.49k
      if (auto *RC = dyn_cast<Constant>(RHS))
1232
1.04k
        return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233
22.4k
    if (!isExact)
1234
22.4k
      return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235
3
    return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236
3
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateLShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1229
2.17k
                    bool isExact = false) {
1230
2.17k
    if (auto *LC = dyn_cast<Constant>(LHS))
1231
195
      if (auto *RC = dyn_cast<Constant>(RHS))
1232
98
        return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233
2.07k
    if (!isExact)
1234
2.07k
      return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235
0
    return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236
0
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateLShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1229
93
                    bool isExact = false) {
1230
93
    if (auto *LC = dyn_cast<Constant>(LHS))
1231
0
      if (auto *RC = dyn_cast<Constant>(RHS))
1232
0
        return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233
93
    if (!isExact)
1234
92
      return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235
1
    return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236
1
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateLShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1229
2.51k
                    bool isExact = false) {
1230
2.51k
    if (auto *LC = dyn_cast<Constant>(LHS))
1231
112
      if (auto *RC = dyn_cast<Constant>(RHS))
1232
39
        return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233
2.47k
    if (!isExact)
1234
2.47k
      return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235
2
    return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236
2
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateLShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1229
2.47k
                    bool isExact = false) {
1230
2.47k
    if (auto *LC = dyn_cast<Constant>(LHS))
1231
150
      if (auto *RC = dyn_cast<Constant>(RHS))
1232
150
        return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233
2.32k
    if (!isExact)
1234
2.32k
      return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235
0
    return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236
0
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateLShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1229
16.2k
                    bool isExact = false) {
1230
16.2k
    if (auto *LC = dyn_cast<Constant>(LHS))
1231
1.03k
      if (auto *RC = dyn_cast<Constant>(RHS))
1232
762
        return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233
15.5k
    if (!isExact)
1234
15.5k
      return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235
0
    return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236
0
  }
1237
1238
  Value *CreateLShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1239
                    bool isExact = false) {
1240
    return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1241
  }
1242
1243
  Value *CreateLShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1244
6.37k
                    bool isExact = false) {
1245
6.37k
    return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1246
6.37k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateLShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1244
977
                    bool isExact = false) {
1245
977
    return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1246
977
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateLShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1244
1.10k
                    bool isExact = false) {
1245
1.10k
    return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1246
1.10k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateLShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1244
2.47k
                    bool isExact = false) {
1245
2.47k
    return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1246
2.47k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateLShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1244
1.81k
                    bool isExact = false) {
1245
1.81k
    return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1246
1.81k
  }
1247
1248
  Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
1249
10.0k
                    bool isExact = false) {
1250
10.0k
    if (auto *LC = dyn_cast<Constant>(LHS))
1251
1.81k
      if (auto *RC = dyn_cast<Constant>(RHS))
1252
1.75k
        return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1253
8.25k
    if (!isExact)
1254
8.22k
      return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1255
26
    return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1256
26
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1249
437
                    bool isExact = false) {
1250
437
    if (auto *LC = dyn_cast<Constant>(LHS))
1251
18
      if (auto *RC = dyn_cast<Constant>(RHS))
1252
18
        return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1253
419
    if (!isExact)
1254
419
      return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1255
0
    return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1256
0
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1249
522
                    bool isExact = false) {
1250
522
    if (auto *LC = dyn_cast<Constant>(LHS))
1251
19
      if (auto *RC = dyn_cast<Constant>(RHS))
1252
19
        return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1253
503
    if (!isExact)
1254
499
      return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1255
4
    return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1256
4
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1249
9.03k
                    bool isExact = false) {
1250
9.03k
    if (auto *LC = dyn_cast<Constant>(LHS))
1251
1.77k
      if (auto *RC = dyn_cast<Constant>(RHS))
1252
1.71k
        return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1253
7.31k
    if (!isExact)
1254
7.29k
      return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1255
22
    return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1256
22
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAShr(llvm::Value*, llvm::Value*, llvm::Twine const&, bool)
Line
Count
Source
1249
12
                    bool isExact = false) {
1250
12
    if (auto *LC = dyn_cast<Constant>(LHS))
1251
0
      if (auto *RC = dyn_cast<Constant>(RHS))
1252
0
        return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1253
12
    if (!isExact)
1254
12
      return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1255
0
    return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1256
0
  }
1257
1258
  Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1259
7
                    bool isExact = false) {
1260
7
    return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1261
7
  }
1262
1263
  Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1264
828
                    bool isExact = false) {
1265
828
    return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1266
828
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1264
16
                    bool isExact = false) {
1265
16
    return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1266
16
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1264
14
                    bool isExact = false) {
1265
14
    return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1266
14
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1264
786
                    bool isExact = false) {
1265
786
    return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1266
786
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAShr(llvm::Value*, unsigned long long, llvm::Twine const&, bool)
Line
Count
Source
1264
12
                    bool isExact = false) {
1265
12
    return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1266
12
  }
1267
1268
86.3k
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
86.3k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
71.1k
      if (isa<ConstantInt>(RC) && 
cast<ConstantInt>(RC)->isMinusOne()70.7k
)
1271
1.13k
        return LHS;  // LHS & -1 -> LHS
1272
70.0k
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
2.75k
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
82.4k
    }
1275
82.4k
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
82.4k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAnd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1268
10.5k
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
10.5k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
5.21k
      if (isa<ConstantInt>(RC) && 
cast<ConstantInt>(RC)->isMinusOne()4.93k
)
1271
20
        return LHS;  // LHS & -1 -> LHS
1272
5.19k
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
99
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
10.4k
    }
1275
10.4k
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
10.4k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateAnd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1268
238
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
238
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
229
      if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1271
229
        return LHS;  // LHS & -1 -> LHS
1272
0
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
0
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
9
    }
1275
9
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
9
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAnd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1268
30.1k
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
30.1k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
28.7k
      if (isa<ConstantInt>(RC) && 
cast<ConstantInt>(RC)->isMinusOne()28.6k
)
1271
8
        return LHS;  // LHS & -1 -> LHS
1272
28.7k
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
4
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
30.1k
    }
1275
30.1k
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
30.1k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateAnd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1268
4.51k
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
4.51k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
4.51k
      if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1271
0
        return LHS;  // LHS & -1 -> LHS
1272
4.51k
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
0
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
4.51k
    }
1275
4.51k
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
4.51k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAnd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1268
40.3k
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
40.3k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
32.1k
      if (isa<ConstantInt>(RC) && 
cast<ConstantInt>(RC)->isMinusOne()32.1k
)
1271
594
        return LHS;  // LHS & -1 -> LHS
1272
31.5k
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
2.65k
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
37.0k
    }
1275
37.0k
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
37.0k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAnd(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1268
525
  Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269
525
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1270
284
      if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1271
284
        return LHS;  // LHS & -1 -> LHS
1272
0
      if (auto *LC = dyn_cast<Constant>(LHS))
1273
0
        return Insert(Folder.CreateAnd(LC, RC), Name);
1274
241
    }
1275
241
    return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276
241
  }
1277
1278
14.2k
  Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1279
14.2k
    return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1280
14.2k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAnd(llvm::Value*, llvm::APInt const&, llvm::Twine const&)
Line
Count
Source
1278
8
  Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1279
8
    return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1280
8
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAnd(llvm::Value*, llvm::APInt const&, llvm::Twine const&)
Line
Count
Source
1278
356
  Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1279
356
    return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1280
356
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateAnd(llvm::Value*, llvm::APInt const&, llvm::Twine const&)
Line
Count
Source
1278
4.51k
  Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1279
4.51k
    return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1280
4.51k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAnd(llvm::Value*, llvm::APInt const&, llvm::Twine const&)
Line
Count
Source
1278
9.36k
  Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1279
9.36k
    return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1280
9.36k
  }
1281
1282
2.35k
  Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1283
2.35k
    return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1284
2.35k
  }
1285
1286
158
  Value *CreateAnd(ArrayRef<Value*> Ops) {
1287
158
    assert(!Ops.empty());
1288
158
    Value *Accum = Ops[0];
1289
251
    for (unsigned i = 1; i < Ops.size(); 
i++93
)
1290
93
      Accum = CreateAnd(Accum, Ops[i]);
1291
158
    return Accum;
1292
158
  }
1293
1294
37.9k
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
37.9k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
15.4k
      if (RC->isNullValue())
1297
6.70k
        return LHS;  // LHS | 0 -> LHS
1298
8.75k
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
3.91k
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
27.3k
    }
1301
27.3k
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
27.3k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
8.40k
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
8.40k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
6.23k
      if (RC->isNullValue())
1297
5.82k
        return LHS;  // LHS | 0 -> LHS
1298
417
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
25
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
2.55k
    }
1301
2.55k
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
2.55k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
1.16k
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
1.16k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
48
      if (RC->isNullValue())
1297
39
        return LHS;  // LHS | 0 -> LHS
1298
9
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
9
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
1.11k
    }
1301
1.11k
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
1.11k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
2.93k
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
2.93k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
1.26k
      if (RC->isNullValue())
1297
0
        return LHS;  // LHS | 0 -> LHS
1298
1.26k
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
345
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
2.58k
    }
1301
2.58k
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
2.58k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
4.51k
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
4.51k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
16
      if (RC->isNullValue())
1297
12
        return LHS;  // LHS | 0 -> LHS
1298
4
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
0
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
4.50k
    }
1301
4.50k
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
4.50k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
857
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
857
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
5
      if (RC->isNullValue())
1297
0
        return LHS;  // LHS | 0 -> LHS
1298
5
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
0
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
857
    }
1301
857
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
857
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
19.8k
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
19.8k
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
7.88k
      if (RC->isNullValue())
1297
832
        return LHS;  // LHS | 0 -> LHS
1298
7.05k
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
3.53k
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
15.4k
    }
1301
15.4k
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
15.4k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateOr(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1294
303
  Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295
303
    if (auto *RC = dyn_cast<Constant>(RHS)) {
1296
2
      if (RC->isNullValue())
1297
2
        return LHS;  // LHS | 0 -> LHS
1298
0
      if (auto *LC = dyn_cast<Constant>(LHS))
1299
0
        return Insert(Folder.CreateOr(LC, RC), Name);
1300
301
    }
1301
301
    return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302
301
  }
1303
1304
33
  Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1305
33
    return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1306
33
  }
1307
1308
86
  Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1309
86
    return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1310
86
  }
1311
1312
44
  Value *CreateOr(ArrayRef<Value*> Ops) {
1313
44
    assert(!Ops.empty());
1314
44
    Value *Accum = Ops[0];
1315
125
    for (unsigned i = 1; i < Ops.size(); 
i++81
)
1316
81
      Accum = CreateOr(Accum, Ops[i]);
1317
44
    return Accum;
1318
44
  }
1319
1320
11.0k
  Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1321
11.0k
    if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) 
return V1.80k
;
1322
9.25k
    return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1323
9.25k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateXor(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1320
1.75k
  Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1321
1.75k
    if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) 
return V34
;
1322
1.72k
    return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1323
1.72k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateXor(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1320
946
  Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1321
946
    if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) 
return V0
;
1322
946
    return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1323
946
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateXor(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1320
8.35k
  Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1321
8.35k
    if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) 
return V1.77k
;
1322
6.58k
    return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1323
6.58k
  }
1324
1325
14
  Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1326
14
    return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1327
14
  }
1328
1329
13
  Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1330
13
    return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1331
13
  }
1332
1333
  Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
1334
19.8k
                    MDNode *FPMD = nullptr) {
1335
19.8k
    if (IsFPConstrained)
1336
3
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1337
3
                                      L, R, nullptr, Name, FPMD);
1338
19.8k
1339
19.8k
    if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) 
return V100
;
1340
19.7k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1341
19.7k
    return Insert(I, Name);
1342
19.7k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1334
103
                    MDNode *FPMD = nullptr) {
1335
103
    if (IsFPConstrained)
1336
3
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1337
3
                                      L, R, nullptr, Name, FPMD);
1338
100
1339
100
    if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) 
return V0
;
1340
100
    Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1341
100
    return Insert(I, Name);
1342
100
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateFAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1334
19
                    MDNode *FPMD = nullptr) {
1335
19
    if (IsFPConstrained)
1336
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1337
0
                                      L, R, nullptr, Name, FPMD);
1338
19
1339
19
    if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) 
return V0
;
1340
19
    Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1341
19
    return Insert(I, Name);
1342
19
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFAdd(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1334
19.7k
                    MDNode *FPMD = nullptr) {
1335
19.7k
    if (IsFPConstrained)
1336
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1337
0
                                      L, R, nullptr, Name, FPMD);
1338
19.7k
1339
19.7k
    if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) 
return V100
;
1340
19.6k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1341
19.6k
    return Insert(I, Name);
1342
19.6k
  }
1343
1344
  /// Copy fast-math-flags from an instruction rather than using the builder's
1345
  /// default FMF.
1346
  Value *CreateFAddFMF(Value *L, Value *R, Instruction *FMFSource,
1347
20
                       const Twine &Name = "") {
1348
20
    if (IsFPConstrained)
1349
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1350
0
                                      L, R, FMFSource, Name);
1351
20
1352
20
    if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) 
return V3
;
1353
17
    Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
1354
17
                                FMFSource->getFastMathFlags());
1355
17
    return Insert(I, Name);
1356
17
  }
1357
1358
  Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
1359
16.9k
                    MDNode *FPMD = nullptr) {
1360
16.9k
    if (IsFPConstrained)
1361
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1362
1
                                      L, R, nullptr, Name, FPMD);
1363
16.9k
1364
16.9k
    if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) 
return V6.14k
;
1365
10.8k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1366
10.8k
    return Insert(I, Name);
1367
10.8k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFSub(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1359
74
                    MDNode *FPMD = nullptr) {
1360
74
    if (IsFPConstrained)
1361
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1362
1
                                      L, R, nullptr, Name, FPMD);
1363
73
1364
73
    if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) 
return V0
;
1365
73
    Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1366
73
    return Insert(I, Name);
1367
73
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateFSub(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1359
15
                    MDNode *FPMD = nullptr) {
1360
15
    if (IsFPConstrained)
1361
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1362
0
                                      L, R, nullptr, Name, FPMD);
1363
15
1364
15
    if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) 
return V0
;
1365
15
    Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1366
15
    return Insert(I, Name);
1367
15
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFSub(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1359
16.8k
                    MDNode *FPMD = nullptr) {
1360
16.8k
    if (IsFPConstrained)
1361
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1362
0
                                      L, R, nullptr, Name, FPMD);
1363
16.8k
1364
16.8k
    if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) 
return V6.14k
;
1365
10.7k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1366
10.7k
    return Insert(I, Name);
1367
10.7k
  }
1368
1369
  /// Copy fast-math-flags from an instruction rather than using the builder's
1370
  /// default FMF.
1371
  Value *CreateFSubFMF(Value *L, Value *R, Instruction *FMFSource,
1372
12
                       const Twine &Name = "") {
1373
12
    if (IsFPConstrained)
1374
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1375
0
                                      L, R, FMFSource, Name);
1376
12
1377
12
    if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) 
return V1
;
1378
11
    Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
1379
11
                                FMFSource->getFastMathFlags());
1380
11
    return Insert(I, Name);
1381
11
  }
1382
1383
  Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
1384
19.0k
                    MDNode *FPMD = nullptr) {
1385
19.0k
    if (IsFPConstrained)
1386
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1387
1
                                      L, R, nullptr, Name, FPMD);
1388
19.0k
1389
19.0k
    if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) 
return V411
;
1390
18.6k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1391
18.6k
    return Insert(I, Name);
1392
18.6k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFMul(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1384
792
                    MDNode *FPMD = nullptr) {
1385
792
    if (IsFPConstrained)
1386
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1387
1
                                      L, R, nullptr, Name, FPMD);
1388
791
1389
791
    if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) 
return V22
;
1390
769
    Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1391
769
    return Insert(I, Name);
1392
769
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateFMul(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1384
31
                    MDNode *FPMD = nullptr) {
1385
31
    if (IsFPConstrained)
1386
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1387
0
                                      L, R, nullptr, Name, FPMD);
1388
31
1389
31
    if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) 
return V0
;
1390
31
    Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1391
31
    return Insert(I, Name);
1392
31
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFMul(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1384
18.2k
                    MDNode *FPMD = nullptr) {
1385
18.2k
    if (IsFPConstrained)
1386
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1387
0
                                      L, R, nullptr, Name, FPMD);
1388
18.2k
1389
18.2k
    if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) 
return V389
;
1390
17.8k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1391
17.8k
    return Insert(I, Name);
1392
17.8k
  }
1393
1394
  /// Copy fast-math-flags from an instruction rather than using the builder's
1395
  /// default FMF.
1396
  Value *CreateFMulFMF(Value *L, Value *R, Instruction *FMFSource,
1397
227
                       const Twine &Name = "") {
1398
227
    if (IsFPConstrained)
1399
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1400
0
                                      L, R, FMFSource, Name);
1401
227
1402
227
    if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) 
return V2
;
1403
225
    Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
1404
225
                                FMFSource->getFastMathFlags());
1405
225
    return Insert(I, Name);
1406
225
  }
1407
1408
  Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
1409
7.97k
                    MDNode *FPMD = nullptr) {
1410
7.97k
    if (IsFPConstrained)
1411
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1412
1
                                      L, R, nullptr, Name, FPMD);
1413
7.97k
1414
7.97k
    if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) 
return V229
;
1415
7.74k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1416
7.74k
    return Insert(I, Name);
1417
7.74k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1409
423
                    MDNode *FPMD = nullptr) {
1410
423
    if (IsFPConstrained)
1411
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1412
1
                                      L, R, nullptr, Name, FPMD);
1413
422
1414
422
    if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) 
return V6
;
1415
416
    Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1416
416
    return Insert(I, Name);
1417
416
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateFDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1409
8
                    MDNode *FPMD = nullptr) {
1410
8
    if (IsFPConstrained)
1411
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1412
0
                                      L, R, nullptr, Name, FPMD);
1413
8
1414
8
    if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) 
return V0
;
1415
8
    Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1416
8
    return Insert(I, Name);
1417
8
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFDiv(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1409
7.54k
                    MDNode *FPMD = nullptr) {
1410
7.54k
    if (IsFPConstrained)
1411
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1412
0
                                      L, R, nullptr, Name, FPMD);
1413
7.54k
1414
7.54k
    if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) 
return V223
;
1415
7.32k
    Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1416
7.32k
    return Insert(I, Name);
1417
7.32k
  }
1418
1419
  /// Copy fast-math-flags from an instruction rather than using the builder's
1420
  /// default FMF.
1421
  Value *CreateFDivFMF(Value *L, Value *R, Instruction *FMFSource,
1422
                       const Twine &Name = "") {
1423
    if (IsFPConstrained)
1424
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1425
                                      L, R, FMFSource, Name);
1426
1427
    if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
1428
    Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), nullptr,
1429
                                FMFSource->getFastMathFlags());
1430
    return Insert(I, Name);
1431
  }
1432
1433
  Value *CreateFRem(Value *L, Value *R, const Twine &Name = "",
1434
33
                    MDNode *FPMD = nullptr) {
1435
33
    if (IsFPConstrained)
1436
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1437
1
                                      L, R, nullptr, Name, FPMD);
1438
32
1439
32
    if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) 
return V0
;
1440
32
    Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1441
32
    return Insert(I, Name);
1442
32
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFRem(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1434
32
                    MDNode *FPMD = nullptr) {
1435
32
    if (IsFPConstrained)
1436
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1437
0
                                      L, R, nullptr, Name, FPMD);
1438
32
1439
32
    if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) 
return V0
;
1440
32
    Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1441
32
    return Insert(I, Name);
1442
32
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFRem(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1434
1
                    MDNode *FPMD = nullptr) {
1435
1
    if (IsFPConstrained)
1436
1
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1437
1
                                      L, R, nullptr, Name, FPMD);
1438
0
1439
0
    if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1440
0
    Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1441
0
    return Insert(I, Name);
1442
0
  }
1443
1444
  /// Copy fast-math-flags from an instruction rather than using the builder's
1445
  /// default FMF.
1446
  Value *CreateFRemFMF(Value *L, Value *R, Instruction *FMFSource,
1447
3
                       const Twine &Name = "") {
1448
3
    if (IsFPConstrained)
1449
0
      return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1450
0
                                      L, R, FMFSource, Name);
1451
3
1452
3
    if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) 
return V0
;
1453
3
    Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
1454
3
                                FMFSource->getFastMathFlags());
1455
3
    return Insert(I, Name);
1456
3
  }
1457
1458
  Value *CreateBinOp(Instruction::BinaryOps Opc,
1459
                     Value *LHS, Value *RHS, const Twine &Name = "",
1460
357k
                     MDNode *FPMathTag = nullptr) {
1461
357k
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) 
return V70.3k
;
1462
286k
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
286k
    if (isa<FPMathOperator>(BinOp))
1464
43.6k
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
286k
    return Insert(BinOp, Name);
1466
286k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1460
257k
                     MDNode *FPMathTag = nullptr) {
1461
257k
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) 
return V70.2k
;
1462
187k
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
187k
    if (isa<FPMathOperator>(BinOp))
1464
43.3k
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
187k
    return Insert(BinOp, Name);
1466
187k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1460
2
                     MDNode *FPMathTag = nullptr) {
1461
2
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
1462
0
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
0
    if (isa<FPMathOperator>(BinOp))
1464
0
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
0
    return Insert(BinOp, Name);
1466
0
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1460
81.2k
                     MDNode *FPMathTag = nullptr) {
1461
81.2k
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) 
return V0
;
1462
81.2k
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
81.2k
    if (isa<FPMathOperator>(BinOp))
1464
0
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
81.2k
    return Insert(BinOp, Name);
1466
81.2k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1460
17.9k
                     MDNode *FPMathTag = nullptr) {
1461
17.9k
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) 
return V177
;
1462
17.7k
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
17.7k
    if (isa<FPMathOperator>(BinOp))
1464
213
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
17.7k
    return Insert(BinOp, Name);
1466
17.7k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1460
215
                     MDNode *FPMathTag = nullptr) {
1461
215
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) 
return V0
;
1462
215
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
215
    if (isa<FPMathOperator>(BinOp))
1464
0
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
215
    return Insert(BinOp, Name);
1466
215
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateBinOp(llvm::Instruction::BinaryOps, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1460
7
                     MDNode *FPMathTag = nullptr) {
1461
7
    if (Value *V = foldConstant(Opc, LHS, RHS, Name)) 
return V0
;
1462
7
    Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463
7
    if (isa<FPMathOperator>(BinOp))
1464
6
      BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465
7
    return Insert(BinOp, Name);
1466
7
  }
1467
1468
  CallInst *CreateConstrainedFPBinOp(
1469
      Intrinsic::ID ID, Value *L, Value *R, Instruction *FMFSource = nullptr,
1470
      const Twine &Name = "", MDNode *FPMathTag = nullptr,
1471
      Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
1472
8
      Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
1473
8
    Value *RoundingV = getConstrainedFPRounding(Rounding);
1474
8
    Value *ExceptV = getConstrainedFPExcept(Except);
1475
8
1476
8
    FastMathFlags UseFMF = FMF;
1477
8
    if (FMFSource)
1478
0
      UseFMF = FMFSource->getFastMathFlags();
1479
8
1480
8
    CallInst *C = CreateIntrinsic(ID, {L->getType()},
1481
8
                                  {L, R, RoundingV, ExceptV}, nullptr, Name);
1482
8
    return cast<CallInst>(setFPAttrs(C, FPMathTag, UseFMF));
1483
8
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstrainedFPBinOp(llvm::Intrinsic::ID, llvm::Value*, llvm::Value*, llvm::Instruction*, llvm::Twine const&, llvm::MDNode*, llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>, llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
Line
Count
Source
1472
8
      Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
1473
8
    Value *RoundingV = getConstrainedFPRounding(Rounding);
1474
8
    Value *ExceptV = getConstrainedFPExcept(Except);
1475
8
1476
8
    FastMathFlags UseFMF = FMF;
1477
8
    if (FMFSource)
1478
0
      UseFMF = FMFSource->getFastMathFlags();
1479
8
1480
8
    CallInst *C = CreateIntrinsic(ID, {L->getType()},
1481
8
                                  {L, R, RoundingV, ExceptV}, nullptr, Name);
1482
8
    return cast<CallInst>(setFPAttrs(C, FPMathTag, UseFMF));
1483
8
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateConstrainedFPBinOp(llvm::Intrinsic::ID, llvm::Value*, llvm::Value*, llvm::Instruction*, llvm::Twine const&, llvm::MDNode*, llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>, llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstrainedFPBinOp(llvm::Intrinsic::ID, llvm::Value*, llvm::Value*, llvm::Instruction*, llvm::Twine const&, llvm::MDNode*, llvm::Optional<llvm::ConstrainedFPIntrinsic::RoundingMode>, llvm::Optional<llvm::ConstrainedFPIntrinsic::ExceptionBehavior>)
1484
1485
  Value *CreateNeg(Value *V, const Twine &Name = "",
1486
4.53k
                   bool HasNUW = false, bool HasNSW = false) {
1487
4.53k
    if (auto *VC = dyn_cast<Constant>(V))
1488
2.41k
      return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1489
2.11k
    BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1490
2.11k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()3
;
1491
2.11k
    if (HasNSW) 
BO->setHasNoSignedWrap()158
;
1492
2.11k
    return BO;
1493
2.11k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNeg(llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1486
358
                   bool HasNUW = false, bool HasNSW = false) {
1487
358
    if (auto *VC = dyn_cast<Constant>(V))
1488
6
      return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1489
352
    BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1490
352
    if (HasNUW) 
BO->setHasNoUnsignedWrap()0
;
1491
352
    if (HasNSW) 
BO->setHasNoSignedWrap()64
;
1492
352
    return BO;
1493
352
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateNeg(llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1486
360
                   bool HasNUW = false, bool HasNSW = false) {
1487
360
    if (auto *VC = dyn_cast<Constant>(V))
1488
4
      return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1489
356
    BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1490
356
    if (HasNUW) 
BO->setHasNoUnsignedWrap()3
;
1491
356
    if (HasNSW) 
BO->setHasNoSignedWrap()89
;
1492
356
    return BO;
1493
356
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNeg(llvm::Value*, llvm::Twine const&, bool, bool)
Line
Count
Source
1486
3.81k
                   bool HasNUW = false, bool HasNSW = false) {
1487
3.81k
    if (auto *VC = dyn_cast<Constant>(V))
1488
2.40k
      return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1489
1.40k
    BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1490
1.40k
    if (HasNUW) 
BO->setHasNoUnsignedWrap()0
;
1491
1.40k
    if (HasNSW) 
BO->setHasNoSignedWrap()5
;
1492
1.40k
    return BO;
1493
1.40k
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateNeg(llvm::Value*, llvm::Twine const&, bool, bool)
1494
1495
70
  Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1496
70
    return CreateNeg(V, Name, false, true);
1497
70
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNSWNeg(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1495
64
  Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1496
64
    return CreateNeg(V, Name, false, true);
1497
64
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNSWNeg(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1495
6
  Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1496
6
    return CreateNeg(V, Name, false, true);
1497
6
  }
1498
1499
0
  Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
1500
0
    return CreateNeg(V, Name, true, false);
1501
0
  }
1502
1503
  Value *CreateFNeg(Value *V, const Twine &Name = "",
1504
1.04k
                    MDNode *FPMathTag = nullptr) {
1505
1.04k
    if (auto *VC = dyn_cast<Constant>(V))
1506
15
      return Insert(Folder.CreateFNeg(VC), Name);
1507
1.03k
    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
1508
1.03k
                  Name);
1509
1.03k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFNeg(llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1504
878
                    MDNode *FPMathTag = nullptr) {
1505
878
    if (auto *VC = dyn_cast<Constant>(V))
1506
0
      return Insert(Folder.CreateFNeg(VC), Name);
1507
878
    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
1508
878
                  Name);
1509
878
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateFNeg(llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1504
9
                    MDNode *FPMathTag = nullptr) {
1505
9
    if (auto *VC = dyn_cast<Constant>(V))
1506
0
      return Insert(Folder.CreateFNeg(VC), Name);
1507
9
    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
1508
9
                  Name);
1509
9
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFNeg(llvm::Value*, llvm::Twine const&, llvm::MDNode*)
Line
Count
Source
1504
161
                    MDNode *FPMathTag = nullptr) {
1505
161
    if (auto *VC = dyn_cast<Constant>(V))
1506
15
      return Insert(Folder.CreateFNeg(VC), Name);
1507
146
    return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), FPMathTag, FMF),
1508
146
                  Name);
1509
146
  }
1510
1511
  /// Copy fast-math-flags from an instruction rather than using the builder's
1512
  /// default FMF.
1513
  Value *CreateFNegFMF(Value *V, Instruction *FMFSource,
1514
                       const Twine &Name = "") {
1515
   if (auto *VC = dyn_cast<Constant>(V))
1516
     return Insert(Folder.CreateFNeg(VC), Name);
1517
   // TODO: This should return UnaryOperator::CreateFNeg(...) once we are
1518
   // confident that they are optimized sufficiently.
1519
   return Insert(setFPAttrs(BinaryOperator::CreateFNeg(V), nullptr,
1520
                            FMFSource->getFastMathFlags()),
1521
                 Name);
1522
  }
1523
1524
101k
  Value *CreateNot(Value *V, const Twine &Name = "") {
1525
101k
    if (auto *VC = dyn_cast<Constant>(V))
1526
10.4k
      return Insert(Folder.CreateNot(VC), Name);
1527
90.7k
    return Insert(BinaryOperator::CreateNot(V), Name);
1528
90.7k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateNot(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1524
2.16k
  Value *CreateNot(Value *V, const Twine &Name = "") {
1525
2.16k
    if (auto *VC = dyn_cast<Constant>(V))
1526
62
      return Insert(Folder.CreateNot(VC), Name);
1527
2.10k
    return Insert(BinaryOperator::CreateNot(V), Name);
1528
2.10k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateNot(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1524
16.9k
  Value *CreateNot(Value *V, const Twine &Name = "") {
1525
16.9k
    if (auto *VC = dyn_cast<Constant>(V))
1526
6.60k
      return Insert(Folder.CreateNot(VC), Name);
1527
10.3k
    return Insert(BinaryOperator::CreateNot(V), Name);
1528
10.3k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateNot(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1524
743
  Value *CreateNot(Value *V, const Twine &Name = "") {
1525
743
    if (auto *VC = dyn_cast<Constant>(V))
1526
16
      return Insert(Folder.CreateNot(VC), Name);
1527
727
    return Insert(BinaryOperator::CreateNot(V), Name);
1528
727
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateNot(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1524
81.0k
  Value *CreateNot(Value *V, const Twine &Name = "") {
1525
81.0k
    if (auto *VC = dyn_cast<Constant>(V))
1526
3.48k
      return Insert(Folder.CreateNot(VC), Name);
1527
77.5k
    return Insert(BinaryOperator::CreateNot(V), Name);
1528
77.5k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateNot(llvm::Value*, llvm::Twine const&)
Line
Count
Source
1524
315
  Value *CreateNot(Value *V, const Twine &Name = "") {
1525
315
    if (auto *VC = dyn_cast<Constant>(V))
1526
283
      return Insert(Folder.CreateNot(VC), Name);
1527
32
    return Insert(BinaryOperator::CreateNot(V), Name);
1528
32
  }
1529
1530
  Value *CreateUnOp(Instruction::UnaryOps Opc,
1531
                    Value *V, const Twine &Name = "",
1532
16
                    MDNode *FPMathTag = nullptr) {
1533
16
    if (auto *VC = dyn_cast<Constant>(V))
1534
0
      return Insert(Folder.CreateUnOp(Opc, VC), Name);
1535
16
    Instruction *UnOp = UnaryOperator::Create(Opc, V);
1536
16
    if (isa<FPMathOperator>(UnOp))
1537
16
      UnOp = setFPAttrs(UnOp, FPMathTag, FMF);
1538
16
    return Insert(UnOp, Name);
1539
16
  }
1540
1541
  /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1542
  /// Correct number of operands must be passed accordingly.
1543
  Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1544
                      const Twine &Name = "",
1545
56.5k
                      MDNode *FPMathTag = nullptr) {
1546
56.5k
    if (Instruction::isBinaryOp(Opc)) {
1547
56.5k
      assert(Ops.size() == 2 && "Invalid number of operands!");
1548
56.5k
      return CreateBinOp(static_cast<Instruction::BinaryOps>(Opc),
1549
56.5k
                         Ops[0], Ops[1], Name, FPMathTag);
1550
56.5k
    }
1551
1
    if (Instruction::isUnaryOp(Opc)) {
1552
1
      assert(Ops.size() == 1 && "Invalid number of operands!");
1553
1
      return CreateUnOp(static_cast<Instruction::UnaryOps>(Opc),
1554
1
                        Ops[0], Name, FPMathTag);
1555
1
    }
1556
0
    llvm_unreachable("Unexpected opcode!");
1557
0
  }
1558
1559
  //===--------------------------------------------------------------------===//
1560
  // Instruction creation methods: Memory Instructions
1561
  //===--------------------------------------------------------------------===//
1562
1563
  AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1564
                           Value *ArraySize = nullptr, const Twine &Name = "") {
1565
    return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
1566
  }
1567
1568
  AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1569
7.00k
                           const Twine &Name = "") {
1570
7.00k
    const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1571
7.00k
    return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1572
7.00k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAlloca(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1569
3.25k
                           const Twine &Name = "") {
1570
3.25k
    const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1571
3.25k
    return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1572
3.25k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAlloca(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1569
1.64k
                           const Twine &Name = "") {
1570
1.64k
    const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1571
1.64k
    return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1572
1.64k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlloca(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1569
1.99k
                           const Twine &Name = "") {
1570
1.99k
    const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1571
1.99k
    return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1572
1.99k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAlloca(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1569
102
                           const Twine &Name = "") {
1570
102
    const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1571
102
    return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1572
102
  }
1573
1574
  /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1575
  /// converting the string to 'bool' for the isVolatile parameter.
1576
1.09M
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577
1.09M
    return Insert(new LoadInst(Ty, Ptr), Name);
1578
1.09M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateLoad(llvm::Type*, llvm::Value*, char const*)
Line
Count
Source
1576
15.2k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577
15.2k
    return Insert(new LoadInst(Ty, Ptr), Name);
1578
15.2k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateLoad(llvm::Type*, llvm::Value*, char const*)
Line
Count
Source
1576
4
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577
4
    return Insert(new LoadInst(Ty, Ptr), Name);
1578
4
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateLoad(llvm::Type*, llvm::Value*, char const*)
Line
Count
Source
1576
864k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577
864k
    return Insert(new LoadInst(Ty, Ptr), Name);
1578
864k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateLoad(llvm::Type*, llvm::Value*, char const*)
Line
Count
Source
1576
210k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577
210k
    return Insert(new LoadInst(Ty, Ptr), Name);
1578
210k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateLoad(llvm::Type*, llvm::Value*, char const*)
Line
Count
Source
1576
92
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1577
92
    return Insert(new LoadInst(Ty, Ptr), Name);
1578
92
  }
1579
1580
214k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
214k
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
214k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateLoad(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1580
64.7k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
64.7k
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
64.7k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateLoad(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1580
18.9k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
18.9k
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
18.9k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateLoad(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1580
2.77k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
2.77k
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
2.77k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateLoad(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1580
14.3k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
14.3k
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
14.3k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateLoad(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1580
113k
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
113k
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
113k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateLoad(llvm::Type*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1580
737
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1581
737
    return Insert(new LoadInst(Ty, Ptr), Name);
1582
737
  }
1583
1584
  LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1585
3.62M
                       const Twine &Name = "") {
1586
3.62M
    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587
3.62M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateLoad(llvm::Type*, llvm::Value*, bool, llvm::Twine const&)
Line
Count
Source
1585
3.51k
                       const Twine &Name = "") {
1586
3.51k
    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587
3.51k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateLoad(llvm::Type*, llvm::Value*, bool, llvm::Twine const&)
Line
Count
Source
1585
93.3k
                       const Twine &Name = "") {
1586
93.3k
    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587
93.3k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateLoad(llvm::Type*, llvm::Value*, bool, llvm::Twine const&)
Line
Count
Source
1585
1.04M
                       const Twine &Name = "") {
1586
1.04M
    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587
1.04M
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateLoad(llvm::Type*, llvm::Value*, bool, llvm::Twine const&)
Line
Count
Source
1585
2.48M
                       const Twine &Name = "") {
1586
2.48M
    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587
2.48M
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateLoad(llvm::Type*, llvm::Value*, bool, llvm::Twine const&)
Line
Count
Source
1585
36
                       const Twine &Name = "") {
1586
36
    return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1587
36
  }
1588
1589
  // Deprecated [opaque pointer types]
1590
62
  LoadInst *CreateLoad(Value *Ptr, const char *Name) {
1591
62
    return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1592
62
  }
1593
1594
  // Deprecated [opaque pointer types]
1595
383
  LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") {
1596
383
    return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1597
383
  }
1598
1599
  // Deprecated [opaque pointer types]
1600
36
  LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") {
1601
36
    return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile,
1602
36
                      Name);
1603
36
  }
1604
1605
3.31M
  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606
3.31M
    return Insert(new StoreInst(Val, Ptr, isVolatile));
1607
3.31M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateStore(llvm::Value*, llvm::Value*, bool)
Line
Count
Source
1605
83.8k
  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606
83.8k
    return Insert(new StoreInst(Val, Ptr, isVolatile));
1607
83.8k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateStore(llvm::Value*, llvm::Value*, bool)
Line
Count
Source
1605
41.4k
  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606
41.4k
    return Insert(new StoreInst(Val, Ptr, isVolatile));
1607
41.4k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateStore(llvm::Value*, llvm::Value*, bool)
Line
Count
Source
1605
1.27M
  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606
1.27M
    return Insert(new StoreInst(Val, Ptr, isVolatile));
1607
1.27M
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateStore(llvm::Value*, llvm::Value*, bool)
Line
Count
Source
1605
1.91M
  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606
1.91M
    return Insert(new StoreInst(Val, Ptr, isVolatile));
1607
1.91M
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateStore(llvm::Value*, llvm::Value*, bool)
Line
Count
Source
1605
871
  StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1606
871
    return Insert(new StoreInst(Val, Ptr, isVolatile));
1607
871
  }
1608
1609
  /// Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")'
1610
  /// correctly, instead of converting the string to 'bool' for the isVolatile
1611
  /// parameter.
1612
  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1613
1.08M
                              const char *Name) {
1614
1.08M
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615
1.08M
    LI->setAlignment(Align);
1616
1.08M
    return LI;
1617
1.08M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, char const*)
Line
Count
Source
1613
13.2k
                              const char *Name) {
1614
13.2k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615
13.2k
    LI->setAlignment(Align);
1616
13.2k
    return LI;
1617
13.2k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, char const*)
Line
Count
Source
1613
4
                              const char *Name) {
1614
4
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615
4
    LI->setAlignment(Align);
1616
4
    return LI;
1617
4
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, char const*)
Line
Count
Source
1613
864k
                              const char *Name) {
1614
864k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615
864k
    LI->setAlignment(Align);
1616
864k
    return LI;
1617
864k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, char const*)
Line
Count
Source
1613
210k
                              const char *Name) {
1614
210k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615
210k
    LI->setAlignment(Align);
1616
210k
    return LI;
1617
210k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, char const*)
Line
Count
Source
1613
30
                              const char *Name) {
1614
30
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1615
30
    LI->setAlignment(Align);
1616
30
    return LI;
1617
30
  }
1618
  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1619
176k
                              const Twine &Name = "") {
1620
176k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
176k
    LI->setAlignment(Align);
1622
176k
    return LI;
1623
176k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1619
51.2k
                              const Twine &Name = "") {
1620
51.2k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
51.2k
    LI->setAlignment(Align);
1622
51.2k
    return LI;
1623
51.2k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1619
92
                              const Twine &Name = "") {
1620
92
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
92
    LI->setAlignment(Align);
1622
92
    return LI;
1623
92
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1619
57
                              const Twine &Name = "") {
1620
57
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
57
    LI->setAlignment(Align);
1622
57
    return LI;
1623
57
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1619
11.4k
                              const Twine &Name = "") {
1620
11.4k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
11.4k
    LI->setAlignment(Align);
1622
11.4k
    return LI;
1623
11.4k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1619
113k
                              const Twine &Name = "") {
1620
113k
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
113k
    LI->setAlignment(Align);
1622
113k
    return LI;
1623
113k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1619
354
                              const Twine &Name = "") {
1620
354
    LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1621
354
    LI->setAlignment(Align);
1622
354
    return LI;
1623
354
  }
1624
  LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1625
3.61M
                              bool isVolatile, const Twine &Name = "") {
1626
3.61M
    LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
1627
3.61M
    LI->setAlignment(Align);
1628
3.61M
    return LI;
1629
3.61M
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, bool, llvm::Twine const&)
Line
Count
Source
1625
93.3k
                              bool isVolatile, const Twine &Name = "") {
1626
93.3k
    LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
1627
93.3k
    LI->setAlignment(Align);
1628
93.3k
    return LI;
1629
93.3k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, bool, llvm::Twine const&)
Line
Count
Source
1625
1.04M
                              bool isVolatile, const Twine &Name = "") {
1626
1.04M
    LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
1627
1.04M
    LI->setAlignment(Align);
1628
1.04M
    return LI;
1629
1.04M
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlignedLoad(llvm::Type*, llvm::Value*, unsigned int, bool, llvm::Twine const&)
Line
Count
Source
1625
2.48M
                              bool isVolatile, const Twine &Name = "") {
1626
2.48M
    LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
1627
2.48M
    LI->setAlignment(Align);
1628
2.48M
    return LI;
1629
2.48M
  }
1630
1631
  // Deprecated [opaque pointer types]
1632
210k
  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
1633
210k
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1634
210k
                             Align, Name);
1635
210k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlignedLoad(llvm::Value*, unsigned int, char const*)
Line
Count
Source
1632
210k
  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
1633
210k
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1634
210k
                             Align, Name);
1635
210k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAlignedLoad(llvm::Value*, unsigned int, char const*)
Line
Count
Source
1632
30
  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
1633
30
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1634
30
                             Align, Name);
1635
30
  }
1636
  // Deprecated [opaque pointer types]
1637
  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align,
1638
113k
                              const Twine &Name = "") {
1639
113k
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1640
113k
                             Align, Name);
1641
113k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlignedLoad(llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1638
113k
                              const Twine &Name = "") {
1639
113k
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1640
113k
                             Align, Name);
1641
113k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAlignedLoad(llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1638
354
                              const Twine &Name = "") {
1639
354
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1640
354
                             Align, Name);
1641
354
  }
1642
  // Deprecated [opaque pointer types]
1643
  LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, bool isVolatile,
1644
2.48M
                              const Twine &Name = "") {
1645
2.48M
    return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1646
2.48M
                             Align, isVolatile, Name);
1647
2.48M
  }
1648
1649
  StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
1650
3.26M
                                bool isVolatile = false) {
1651
3.26M
    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652
3.26M
    SI->setAlignment(Align);
1653
3.26M
    return SI;
1654
3.26M
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAlignedStore(llvm::Value*, llvm::Value*, unsigned int, bool)
Line
Count
Source
1650
37.9k
                                bool isVolatile = false) {
1651
37.9k
    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652
37.9k
    SI->setAlignment(Align);
1653
37.9k
    return SI;
1654
37.9k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateAlignedStore(llvm::Value*, llvm::Value*, unsigned int, bool)
Line
Count
Source
1650
38.5k
                                bool isVolatile = false) {
1651
38.5k
    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652
38.5k
    SI->setAlignment(Align);
1653
38.5k
    return SI;
1654
38.5k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateAlignedStore(llvm::Value*, llvm::Value*, unsigned int, bool)
Line
Count
Source
1650
1.27M
                                bool isVolatile = false) {
1651
1.27M
    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652
1.27M
    SI->setAlignment(Align);
1653
1.27M
    return SI;
1654
1.27M
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAlignedStore(llvm::Value*, llvm::Value*, unsigned int, bool)
Line
Count
Source
1650
1.91M
                                bool isVolatile = false) {
1651
1.91M
    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652
1.91M
    SI->setAlignment(Align);
1653
1.91M
    return SI;
1654
1.91M
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateAlignedStore(llvm::Value*, llvm::Value*, unsigned int, bool)
Line
Count
Source
1650
452
                                bool isVolatile = false) {
1651
452
    StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1652
452
    SI->setAlignment(Align);
1653
452
    return SI;
1654
452
  }
1655
1656
  FenceInst *CreateFence(AtomicOrdering Ordering,
1657
                         SyncScope::ID SSID = SyncScope::System,
1658
3.56k
                         const Twine &Name = "") {
1659
3.56k
    return Insert(new FenceInst(Context, Ordering, SSID), Name);
1660
3.56k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateFence(llvm::AtomicOrdering, unsigned char, llvm::Twine const&)
Line
Count
Source
1658
237
                         const Twine &Name = "") {
1659
237
    return Insert(new FenceInst(Context, Ordering, SSID), Name);
1660
237
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateFence(llvm::AtomicOrdering, unsigned char, llvm::Twine const&)
Line
Count
Source
1658
3.32k
                         const Twine &Name = "") {
1659
3.32k
    return Insert(new FenceInst(Context, Ordering, SSID), Name);
1660
3.32k
  }
1661
1662
  AtomicCmpXchgInst *
1663
  CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New,
1664
                      AtomicOrdering SuccessOrdering,
1665
                      AtomicOrdering FailureOrdering,
1666
1.73k
                      SyncScope::ID SSID = SyncScope::System) {
1667
1.73k
    return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
1668
1.73k
                                        FailureOrdering, SSID));
1669
1.73k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAtomicCmpXchg(llvm::Value*, llvm::Value*, llvm::Value*, llvm::AtomicOrdering, llvm::AtomicOrdering, unsigned char)
Line
Count
Source
1666
1.03k
                      SyncScope::ID SSID = SyncScope::System) {
1667
1.03k
    return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
1668
1.03k
                                        FailureOrdering, SSID));
1669
1.03k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAtomicCmpXchg(llvm::Value*, llvm::Value*, llvm::Value*, llvm::AtomicOrdering, llvm::AtomicOrdering, unsigned char)
Line
Count
Source
1666
699
                      SyncScope::ID SSID = SyncScope::System) {
1667
699
    return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
1668
699
                                        FailureOrdering, SSID));
1669
699
  }
1670
1671
  AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val,
1672
                                 AtomicOrdering Ordering,
1673
2.25k
                                 SyncScope::ID SSID = SyncScope::System) {
1674
2.25k
    return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
1675
2.25k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateAtomicRMW(llvm::AtomicRMWInst::BinOp, llvm::Value*, llvm::Value*, llvm::AtomicOrdering, unsigned char)
Line
Count
Source
1673
148
                                 SyncScope::ID SSID = SyncScope::System) {
1674
148
    return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
1675
148
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateAtomicRMW(llvm::AtomicRMWInst::BinOp, llvm::Value*, llvm::Value*, llvm::AtomicOrdering, unsigned char)
Line
Count
Source
1673
2.10k
                                 SyncScope::ID SSID = SyncScope::System) {
1674
2.10k
    return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
1675
2.10k
  }
1676
1677
  Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1678
37
                   const Twine &Name = "") {
1679
37
    return CreateGEP(nullptr, Ptr, IdxList, Name);
1680
37
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateGEP(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1678
37
                   const Twine &Name = "") {
1679
37
    return CreateGEP(nullptr, Ptr, IdxList, Name);
1680
37
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateGEP(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
1681
1682
  Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1683
454k
                   const Twine &Name = "") {
1684
454k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685
18.4k
      // Every index must be constant.
1686
18.4k
      size_t i, e;
1687
67.8k
      for (i = 0, e = IdxList.size(); i != e; 
++i49.3k
)
1688
52.8k
        if (!isa<Constant>(IdxList[i]))
1689
3.51k
          break;
1690
18.4k
      if (i == e)
1691
14.9k
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692
439k
    }
1693
439k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694
439k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1683
1.91k
                   const Twine &Name = "") {
1684
1.91k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685
20
      // Every index must be constant.
1686
20
      size_t i, e;
1687
57
      for (i = 0, e = IdxList.size(); i != e; 
++i37
)
1688
40
        if (!isa<Constant>(IdxList[i]))
1689
3
          break;
1690
20
      if (i == e)
1691
17
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692
1.89k
    }
1693
1.89k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694
1.89k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1683
417k
                   const Twine &Name = "") {
1684
417k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685
18.1k
      // Every index must be constant.
1686
18.1k
      size_t i, e;
1687
66.8k
      for (i = 0, e = IdxList.size(); i != e; 
++i48.6k
)
1688
52.1k
        if (!isa<Constant>(IdxList[i]))
1689
3.51k
          break;
1690
18.1k
      if (i == e)
1691
14.6k
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692
402k
    }
1693
402k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694
402k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1683
18.5k
                   const Twine &Name = "") {
1684
18.5k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685
25
      // Every index must be constant.
1686
25
      size_t i, e;
1687
90
      for (i = 0, e = IdxList.size(); i != e; 
++i65
)
1688
65
        if (!isa<Constant>(IdxList[i]))
1689
0
          break;
1690
25
      if (i == e)
1691
25
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692
18.5k
    }
1693
18.5k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694
18.5k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1683
16.1k
                   const Twine &Name = "") {
1684
16.1k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685
2
      // Every index must be constant.
1686
2
      size_t i, e;
1687
4
      for (i = 0, e = IdxList.size(); i != e; 
++i2
)
1688
4
        if (!isa<Constant>(IdxList[i]))
1689
2
          break;
1690
2
      if (i == e)
1691
0
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692
16.1k
    }
1693
16.1k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694
16.1k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1683
317
                   const Twine &Name = "") {
1684
317
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1685
239
      // Every index must be constant.
1686
239
      size_t i, e;
1687
843
      for (i = 0, e = IdxList.size(); i != e; 
++i604
)
1688
604
        if (!isa<Constant>(IdxList[i]))
1689
0
          break;
1690
239
      if (i == e)
1691
239
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1692
78
    }
1693
78
    return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1694
78
  }
Unexecuted instantiation: llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
1695
1696
  Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1697
456k
                           const Twine &Name = "") {
1698
456k
    return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1699
456k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateInBoundsGEP(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1697
456k
                           const Twine &Name = "") {
1698
456k
    return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1699
456k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateInBoundsGEP(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1697
4
                           const Twine &Name = "") {
1698
4
    return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1699
4
  }
1700
1701
  Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1702
601k
                           const Twine &Name = "") {
1703
601k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
180k
      // Every index must be constant.
1705
180k
      size_t i, e;
1706
517k
      for (i = 0, e = IdxList.size(); i != e; 
++i336k
)
1707
356k
        if (!isa<Constant>(IdxList[i]))
1708
19.7k
          break;
1709
180k
      if (i == e)
1710
160k
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
160k
                      Name);
1712
441k
    }
1713
441k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
441k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1702
2.32k
                           const Twine &Name = "") {
1703
2.32k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
745
      // Every index must be constant.
1705
745
      size_t i, e;
1706
1.40k
      for (i = 0, e = IdxList.size(); i != e; 
++i662
)
1707
1.40k
        if (!isa<Constant>(IdxList[i]))
1708
745
          break;
1709
745
      if (i == e)
1710
0
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
0
                      Name);
1712
2.32k
    }
1713
2.32k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
2.32k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1702
8
                           const Twine &Name = "") {
1703
8
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
8
      // Every index must be constant.
1705
8
      size_t i, e;
1706
24
      for (i = 0, e = IdxList.size(); i != e; 
++i16
)
1707
16
        if (!isa<Constant>(IdxList[i]))
1708
0
          break;
1709
8
      if (i == e)
1710
8
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
8
                      Name);
1712
0
    }
1713
0
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
0
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1702
51.8k
                           const Twine &Name = "") {
1703
51.8k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
12
      // Every index must be constant.
1705
12
      size_t i, e;
1706
36
      for (i = 0, e = IdxList.size(); i != e; 
++i24
)
1707
24
        if (!isa<Constant>(IdxList[i]))
1708
0
          break;
1709
12
      if (i == e)
1710
12
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
12
                      Name);
1712
51.8k
    }
1713
51.8k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
51.8k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1702
90.9k
                           const Twine &Name = "") {
1703
90.9k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
972
      // Every index must be constant.
1705
972
      size_t i, e;
1706
2.90k
      for (i = 0, e = IdxList.size(); i != e; 
++i1.93k
)
1707
1.93k
        if (!isa<Constant>(IdxList[i]))
1708
0
          break;
1709
972
      if (i == e)
1710
972
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
972
                      Name);
1712
89.9k
    }
1713
89.9k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
89.9k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1702
456k
                           const Twine &Name = "") {
1703
456k
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
178k
      // Every index must be constant.
1705
178k
      size_t i, e;
1706
512k
      for (i = 0, e = IdxList.size(); i != e; 
++i334k
)
1707
353k
        if (!isa<Constant>(IdxList[i]))
1708
19.0k
          break;
1709
178k
      if (i == e)
1710
159k
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
159k
                      Name);
1712
297k
    }
1713
297k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
297k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&)
Line
Count
Source
1702
14
                           const Twine &Name = "") {
1703
14
    if (auto *PC = dyn_cast<Constant>(Ptr)) {
1704
14
      // Every index must be constant.
1705
14
      size_t i, e;
1706
50
      for (i = 0, e = IdxList.size(); i != e; 
++i36
)
1707
36
        if (!isa<Constant>(IdxList[i]))
1708
0
          break;
1709
14
      if (i == e)
1710
14
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1711
14
                      Name);
1712
0
    }
1713
0
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1714
0
  }
1715
1716
20.5k
  Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1717
20.5k
    return CreateGEP(nullptr, Ptr, Idx, Name);
1718
20.5k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateGEP(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1716
19.6k
  Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1717
19.6k
    return CreateGEP(nullptr, Ptr, Idx, Name);
1718
19.6k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateGEP(llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1716
848
  Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1717
848
    return CreateGEP(nullptr, Ptr, Idx, Name);
1718
848
  }
1719
1720
133k
  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721
133k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1722
3.73k
      if (auto *IC = dyn_cast<Constant>(Idx))
1723
265
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724
133k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725
133k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1720
87.1k
  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721
87.1k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1722
415
      if (auto *IC = dyn_cast<Constant>(Idx))
1723
97
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724
87.0k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725
87.0k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1720
21.8k
  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721
21.8k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1722
3.14k
      if (auto *IC = dyn_cast<Constant>(Idx))
1723
0
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724
21.8k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725
21.8k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1720
3.55k
  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721
3.55k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1722
0
      if (auto *IC = dyn_cast<Constant>(Idx))
1723
0
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724
3.55k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725
3.55k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1720
19.8k
  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721
19.8k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1722
13
      if (auto *IC = dyn_cast<Constant>(Idx))
1723
11
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724
19.8k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725
19.8k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1720
848
  Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1721
848
    if (auto *PC = dyn_cast<Constant>(Ptr))
1722
161
      if (auto *IC = dyn_cast<Constant>(Idx))
1723
157
        return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
1724
691
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1725
691
  }
1726
1727
  Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
1728
278k
                           const Twine &Name = "") {
1729
278k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1730
5.27k
      if (auto *IC = dyn_cast<Constant>(Idx))
1731
1
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1732
278k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1733
278k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1728
275k
                           const Twine &Name = "") {
1729
275k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1730
5.27k
      if (auto *IC = dyn_cast<Constant>(Idx))
1731
1
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1732
275k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1733
275k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1728
1.24k
                           const Twine &Name = "") {
1729
1.24k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1730
0
      if (auto *IC = dyn_cast<Constant>(Idx))
1731
0
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1732
1.24k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1733
1.24k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1728
1.17k
                           const Twine &Name = "") {
1729
1.17k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1730
0
      if (auto *IC = dyn_cast<Constant>(Idx))
1731
0
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1732
1.17k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1733
1.17k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateInBoundsGEP(llvm::Type*, llvm::Value*, llvm::Value*, llvm::Twine const&)
Line
Count
Source
1728
383
                           const Twine &Name = "") {
1729
383
    if (auto *PC = dyn_cast<Constant>(Ptr))
1730
0
      if (auto *IC = dyn_cast<Constant>(Idx))
1731
0
        return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1732
383
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1733
383
  }
1734
1735
2.45k
  Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
1736
2.45k
    return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
1737
2.45k
  }
1738
1739
  Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1740
2.80k
                            const Twine &Name = "") {
1741
2.80k
    Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1742
2.80k
1743
2.80k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1744
59
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1745
2.74k
1746
2.74k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1747
2.74k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstGEP1_32(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1740
343
                            const Twine &Name = "") {
1741
343
    Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1742
343
1743
343
    if (auto *PC = dyn_cast<Constant>(Ptr))
1744
31
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1745
312
1746
312
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1747
312
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstGEP1_32(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1740
2.45k
                            const Twine &Name = "") {
1741
2.45k
    Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1742
2.45k
1743
2.45k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1744
28
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1745
2.43k
1746
2.43k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1747
2.43k
  }
1748
1749
  Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1750
5.80k
                                    const Twine &Name = "") {
1751
5.80k
    Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1752
5.80k
1753
5.80k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1754
205
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1755
5.59k
1756
5.59k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1757
5.59k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstInBoundsGEP1_32(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1750
5.06k
                                    const Twine &Name = "") {
1751
5.06k
    Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1752
5.06k
1753
5.06k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1754
0
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1755
5.06k
1756
5.06k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1757
5.06k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstInBoundsGEP1_32(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1750
732
                                    const Twine &Name = "") {
1751
732
    Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1752
732
1753
732
    if (auto *PC = dyn_cast<Constant>(Ptr))
1754
205
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1755
527
1756
527
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1757
527
  }
1758
1759
  Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1760
785
                            const Twine &Name = "") {
1761
785
    Value *Idxs[] = {
1762
785
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1763
785
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1764
785
    };
1765
785
1766
785
    if (auto *PC = dyn_cast<Constant>(Ptr))
1767
138
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1768
647
1769
647
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1770
647
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstGEP2_32(llvm::Type*, llvm::Value*, unsigned int, unsigned int, llvm::Twine const&)
Line
Count
Source
1760
726
                            const Twine &Name = "") {
1761
726
    Value *Idxs[] = {
1762
726
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1763
726
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1764
726
    };
1765
726
1766
726
    if (auto *PC = dyn_cast<Constant>(Ptr))
1767
138
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1768
588
1769
588
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1770
588
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstGEP2_32(llvm::Type*, llvm::Value*, unsigned int, unsigned int, llvm::Twine const&)
Line
Count
Source
1760
59
                            const Twine &Name = "") {
1761
59
    Value *Idxs[] = {
1762
59
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1763
59
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1764
59
    };
1765
59
1766
59
    if (auto *PC = dyn_cast<Constant>(Ptr))
1767
0
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1768
59
1769
59
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1770
59
  }
1771
1772
  Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1773
692k
                                    unsigned Idx1, const Twine &Name = "") {
1774
692k
    Value *Idxs[] = {
1775
692k
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1776
692k
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1777
692k
    };
1778
692k
1779
692k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1780
16.2k
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1781
676k
1782
676k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1783
676k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstInBoundsGEP2_32(llvm::Type*, llvm::Value*, unsigned int, unsigned int, llvm::Twine const&)
Line
Count
Source
1773
1.02k
                                    unsigned Idx1, const Twine &Name = "") {
1774
1.02k
    Value *Idxs[] = {
1775
1.02k
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1776
1.02k
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1777
1.02k
    };
1778
1.02k
1779
1.02k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1780
44
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1781
984
1782
984
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1783
984
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstInBoundsGEP2_32(llvm::Type*, llvm::Value*, unsigned int, unsigned int, llvm::Twine const&)
Line
Count
Source
1773
691k
                                    unsigned Idx1, const Twine &Name = "") {
1774
691k
    Value *Idxs[] = {
1775
691k
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1776
691k
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1777
691k
    };
1778
691k
1779
691k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1780
16.2k
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1781
674k
1782
674k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1783
674k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateConstInBoundsGEP2_32(llvm::Type*, llvm::Value*, unsigned int, unsigned int, llvm::Twine const&)
Line
Count
Source
1773
162
                                    unsigned Idx1, const Twine &Name = "") {
1774
162
    Value *Idxs[] = {
1775
162
      ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1776
162
      ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1777
162
    };
1778
162
1779
162
    if (auto *PC = dyn_cast<Constant>(Ptr))
1780
0
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1781
162
1782
162
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1783
162
  }
1784
1785
  Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1786
1.79k
                            const Twine &Name = "") {
1787
1.79k
    Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1788
1.79k
1789
1.79k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1790
80
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1791
1.71k
1792
1.71k
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1793
1.71k
  }
1794
1795
1.79k
  Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
1796
1.79k
    return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name);
1797
1.79k
  }
1798
1799
  Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1800
49.4k
                                    const Twine &Name = "") {
1801
49.4k
    Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1802
49.4k
1803
49.4k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1804
15
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1805
49.4k
1806
49.4k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1807
49.4k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstInBoundsGEP1_64(llvm::Type*, llvm::Value*, unsigned long long, llvm::Twine const&)
Line
Count
Source
1800
37.4k
                                    const Twine &Name = "") {
1801
37.4k
    Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1802
37.4k
1803
37.4k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1804
1
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1805
37.4k
1806
37.4k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1807
37.4k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstInBoundsGEP1_64(llvm::Type*, llvm::Value*, unsigned long long, llvm::Twine const&)
Line
Count
Source
1800
12.0k
                                    const Twine &Name = "") {
1801
12.0k
    Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1802
12.0k
1803
12.0k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1804
14
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1805
12.0k
1806
12.0k
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1807
12.0k
  }
1808
1809
  Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
1810
12.0k
                                    const Twine &Name = "") {
1811
12.0k
    return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name);
1812
12.0k
  }
1813
1814
  Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1815
57
                            const Twine &Name = "") {
1816
57
    Value *Idxs[] = {
1817
57
      ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1818
57
      ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1819
57
    };
1820
57
1821
57
    if (auto *PC = dyn_cast<Constant>(Ptr))
1822
57
      return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1823
0
1824
0
    return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1825
0
  }
1826
1827
  Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1828
                            const Twine &Name = "") {
1829
    return CreateConstGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1830
  }
1831
1832
  Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1833
1.43k
                                    uint64_t Idx1, const Twine &Name = "") {
1834
1.43k
    Value *Idxs[] = {
1835
1.43k
      ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1836
1.43k
      ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1837
1.43k
    };
1838
1.43k
1839
1.43k
    if (auto *PC = dyn_cast<Constant>(Ptr))
1840
1.43k
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1841
0
1842
0
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1843
0
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateConstInBoundsGEP2_64(llvm::Type*, llvm::Value*, unsigned long long, unsigned long long, llvm::Twine const&)
Line
Count
Source
1833
986
                                    uint64_t Idx1, const Twine &Name = "") {
1834
986
    Value *Idxs[] = {
1835
986
      ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1836
986
      ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1837
986
    };
1838
986
1839
986
    if (auto *PC = dyn_cast<Constant>(Ptr))
1840
986
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1841
0
1842
0
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1843
0
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateConstInBoundsGEP2_64(llvm::Type*, llvm::Value*, unsigned long long, unsigned long long, llvm::Twine const&)
Line
Count
Source
1833
446
                                    uint64_t Idx1, const Twine &Name = "") {
1834
446
    Value *Idxs[] = {
1835
446
      ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1836
446
      ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1837
446
    };
1838
446
1839
446
    if (auto *PC = dyn_cast<Constant>(Ptr))
1840
446
      return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1841
0
1842
0
    return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1843
0
  }
1844
1845
  Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1846
446
                                    const Twine &Name = "") {
1847
446
    return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1848
446
  }
1849
1850
  Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1851
655k
                         const Twine &Name = "") {
1852
655k
    return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1853
655k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateStructGEP(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1851
816
                         const Twine &Name = "") {
1852
816
    return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1853
816
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateStructGEP(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1851
654k
                         const Twine &Name = "") {
1852
654k
    return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1853
654k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateStructGEP(llvm::Type*, llvm::Value*, unsigned int, llvm::Twine const&)
Line
Count
Source
1851
162
                         const Twine &Name = "") {
1852
162
    return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1853
162
  }
1854
1855
44
  Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") {
1856
44
    return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name);
1857
44
  }
1858
1859
  /// Same as CreateGlobalString, but return a pointer with "i8*" type
1860
  /// instead of a pointer to array of i8.
1861
  Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
1862
665
                                  unsigned AddressSpace = 0) {
1863
665
    GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
1864
665
    Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1865
665
    Constant *Indices[] = {Zero, Zero};
1866
665
    return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1867
665
                                                  Indices);
1868
665
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateGlobalStringPtr(llvm::StringRef, llvm::Twine const&, unsigned int)
Line
Count
Source
1862
180
                                  unsigned AddressSpace = 0) {
1863
180
    GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
1864
180
    Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1865
180
    Constant *Indices[] = {Zero, Zero};
1866
180
    return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1867
180
                                                  Indices);
1868
180
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateGlobalStringPtr(llvm::StringRef, llvm::Twine const&, unsigned int)
Line
Count
Source
1862
357
                                  unsigned AddressSpace = 0) {
1863
357
    GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
1864
357
    Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1865
357
    Constant *Indices[] = {Zero, Zero};
1866
357
    return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1867
357
                                                  Indices);
1868
357
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateGlobalStringPtr(llvm::StringRef, llvm::Twine const&, unsigned int)
Line
Count
Source
1862
128
                                  unsigned AddressSpace = 0) {
1863
128
    GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
1864
128
    Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1865
128
    Constant *Indices[] = {Zero, Zero};
1866
128
    return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1867
128
                                                  Indices);
1868
128
  }
1869
1870
  //===--------------------------------------------------------------------===//
1871
  // Instruction creation methods: Cast/Conversion Operators
1872
  //===--------------------------------------------------------------------===//
1873
1874
143k
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
143k
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
143k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
66.4k
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
66.4k
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
66.4k
  }
llvm::IRBuilder<llvm::NoFolder, llvm::IRBuilderDefaultInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
184
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
184
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
184
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderDefaultInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
1.30k
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
1.30k
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
1.30k
  }
llvm::IRBuilder<llvm::TargetFolder, llvm::IRBuilderCallbackInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
29.7k
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
29.7k
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
29.7k
  }
SROA.cpp:llvm::IRBuilder<llvm::ConstantFolder, (anonymous namespace)::IRBuilderPrefixedInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
4.81k
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
4.81k
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
4.81k
  }
llvm::IRBuilder<llvm::ConstantFolder, clang::CodeGen::CGBuilderInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
41.1k
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
41.1k
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
41.1k
  }
llvm::IRBuilder<llvm::ConstantFolder, polly::IRInserter>::CreateTrunc(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1874
31
  Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1875
31
    return CreateCast(Instruction::Trunc, V, DestTy, Name);
1876
31
  }
1877
1878
157k
  Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1879
157k
    return CreateCast(Instruction::ZExt, V, DestTy, Name);
1880
157k
  }
llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>::CreateZExt(llvm::Value*, llvm::Type*, llvm::Twine const&)
Line
Count
Source
1878
39.5k
  Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1879
39.5k
    return CreateCast(Instruction::ZExt, V, DestTy, Name);
1