Bug Summary

File:lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
Warning:line 877, column 7
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SeparateConstOffsetFromGEP.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar -I /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn374877/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn374877/build-llvm/lib/Transforms/Scalar -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn374877=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-15-233810-7101-1 -x c++ /build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

1//===- SeparateConstOffsetFromGEP.cpp -------------------------------------===//
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// Loop unrolling may create many similar GEPs for array accesses.
10// e.g., a 2-level loop
11//
12// float a[32][32]; // global variable
13//
14// for (int i = 0; i < 2; ++i) {
15// for (int j = 0; j < 2; ++j) {
16// ...
17// ... = a[x + i][y + j];
18// ...
19// }
20// }
21//
22// will probably be unrolled to:
23//
24// gep %a, 0, %x, %y; load
25// gep %a, 0, %x, %y + 1; load
26// gep %a, 0, %x + 1, %y; load
27// gep %a, 0, %x + 1, %y + 1; load
28//
29// LLVM's GVN does not use partial redundancy elimination yet, and is thus
30// unable to reuse (gep %a, 0, %x, %y). As a result, this misoptimization incurs
31// significant slowdown in targets with limited addressing modes. For instance,
32// because the PTX target does not support the reg+reg addressing mode, the
33// NVPTX backend emits PTX code that literally computes the pointer address of
34// each GEP, wasting tons of registers. It emits the following PTX for the
35// first load and similar PTX for other loads.
36//
37// mov.u32 %r1, %x;
38// mov.u32 %r2, %y;
39// mul.wide.u32 %rl2, %r1, 128;
40// mov.u64 %rl3, a;
41// add.s64 %rl4, %rl3, %rl2;
42// mul.wide.u32 %rl5, %r2, 4;
43// add.s64 %rl6, %rl4, %rl5;
44// ld.global.f32 %f1, [%rl6];
45//
46// To reduce the register pressure, the optimization implemented in this file
47// merges the common part of a group of GEPs, so we can compute each pointer
48// address by adding a simple offset to the common part, saving many registers.
49//
50// It works by splitting each GEP into a variadic base and a constant offset.
51// The variadic base can be computed once and reused by multiple GEPs, and the
52// constant offsets can be nicely folded into the reg+immediate addressing mode
53// (supported by most targets) without using any extra register.
54//
55// For instance, we transform the four GEPs and four loads in the above example
56// into:
57//
58// base = gep a, 0, x, y
59// load base
60// laod base + 1 * sizeof(float)
61// load base + 32 * sizeof(float)
62// load base + 33 * sizeof(float)
63//
64// Given the transformed IR, a backend that supports the reg+immediate
65// addressing mode can easily fold the pointer arithmetics into the loads. For
66// example, the NVPTX backend can easily fold the pointer arithmetics into the
67// ld.global.f32 instructions, and the resultant PTX uses much fewer registers.
68//
69// mov.u32 %r1, %tid.x;
70// mov.u32 %r2, %tid.y;
71// mul.wide.u32 %rl2, %r1, 128;
72// mov.u64 %rl3, a;
73// add.s64 %rl4, %rl3, %rl2;
74// mul.wide.u32 %rl5, %r2, 4;
75// add.s64 %rl6, %rl4, %rl5;
76// ld.global.f32 %f1, [%rl6]; // so far the same as unoptimized PTX
77// ld.global.f32 %f2, [%rl6+4]; // much better
78// ld.global.f32 %f3, [%rl6+128]; // much better
79// ld.global.f32 %f4, [%rl6+132]; // much better
80//
81// Another improvement enabled by the LowerGEP flag is to lower a GEP with
82// multiple indices to either multiple GEPs with a single index or arithmetic
83// operations (depending on whether the target uses alias analysis in codegen).
84// Such transformation can have following benefits:
85// (1) It can always extract constants in the indices of structure type.
86// (2) After such Lowering, there are more optimization opportunities such as
87// CSE, LICM and CGP.
88//
89// E.g. The following GEPs have multiple indices:
90// BB1:
91// %p = getelementptr [10 x %struct]* %ptr, i64 %i, i64 %j1, i32 3
92// load %p
93// ...
94// BB2:
95// %p2 = getelementptr [10 x %struct]* %ptr, i64 %i, i64 %j1, i32 2
96// load %p2
97// ...
98//
99// We can not do CSE to the common part related to index "i64 %i". Lowering
100// GEPs can achieve such goals.
101// If the target does not use alias analysis in codegen, this pass will
102// lower a GEP with multiple indices into arithmetic operations:
103// BB1:
104// %1 = ptrtoint [10 x %struct]* %ptr to i64 ; CSE opportunity
105// %2 = mul i64 %i, length_of_10xstruct ; CSE opportunity
106// %3 = add i64 %1, %2 ; CSE opportunity
107// %4 = mul i64 %j1, length_of_struct
108// %5 = add i64 %3, %4
109// %6 = add i64 %3, struct_field_3 ; Constant offset
110// %p = inttoptr i64 %6 to i32*
111// load %p
112// ...
113// BB2:
114// %7 = ptrtoint [10 x %struct]* %ptr to i64 ; CSE opportunity
115// %8 = mul i64 %i, length_of_10xstruct ; CSE opportunity
116// %9 = add i64 %7, %8 ; CSE opportunity
117// %10 = mul i64 %j2, length_of_struct
118// %11 = add i64 %9, %10
119// %12 = add i64 %11, struct_field_2 ; Constant offset
120// %p = inttoptr i64 %12 to i32*
121// load %p2
122// ...
123//
124// If the target uses alias analysis in codegen, this pass will lower a GEP
125// with multiple indices into multiple GEPs with a single index:
126// BB1:
127// %1 = bitcast [10 x %struct]* %ptr to i8* ; CSE opportunity
128// %2 = mul i64 %i, length_of_10xstruct ; CSE opportunity
129// %3 = getelementptr i8* %1, i64 %2 ; CSE opportunity
130// %4 = mul i64 %j1, length_of_struct
131// %5 = getelementptr i8* %3, i64 %4
132// %6 = getelementptr i8* %5, struct_field_3 ; Constant offset
133// %p = bitcast i8* %6 to i32*
134// load %p
135// ...
136// BB2:
137// %7 = bitcast [10 x %struct]* %ptr to i8* ; CSE opportunity
138// %8 = mul i64 %i, length_of_10xstruct ; CSE opportunity
139// %9 = getelementptr i8* %7, i64 %8 ; CSE opportunity
140// %10 = mul i64 %j2, length_of_struct
141// %11 = getelementptr i8* %9, i64 %10
142// %12 = getelementptr i8* %11, struct_field_2 ; Constant offset
143// %p2 = bitcast i8* %12 to i32*
144// load %p2
145// ...
146//
147// Lowering GEPs can also benefit other passes such as LICM and CGP.
148// LICM (Loop Invariant Code Motion) can not hoist/sink a GEP of multiple
149// indices if one of the index is variant. If we lower such GEP into invariant
150// parts and variant parts, LICM can hoist/sink those invariant parts.
151// CGP (CodeGen Prepare) tries to sink address calculations that match the
152// target's addressing modes. A GEP with multiple indices may not match and will
153// not be sunk. If we lower such GEP into smaller parts, CGP may sink some of
154// them. So we end up with a better addressing mode.
155//
156//===----------------------------------------------------------------------===//
157
158#include "llvm/ADT/APInt.h"
159#include "llvm/ADT/DenseMap.h"
160#include "llvm/ADT/DepthFirstIterator.h"
161#include "llvm/ADT/SmallVector.h"
162#include "llvm/Analysis/LoopInfo.h"
163#include "llvm/Analysis/MemoryBuiltins.h"
164#include "llvm/Analysis/ScalarEvolution.h"
165#include "llvm/Analysis/TargetLibraryInfo.h"
166#include "llvm/Analysis/TargetTransformInfo.h"
167#include "llvm/Transforms/Utils/Local.h"
168#include "llvm/Analysis/ValueTracking.h"
169#include "llvm/IR/BasicBlock.h"
170#include "llvm/IR/Constant.h"
171#include "llvm/IR/Constants.h"
172#include "llvm/IR/DataLayout.h"
173#include "llvm/IR/DerivedTypes.h"
174#include "llvm/IR/Dominators.h"
175#include "llvm/IR/Function.h"
176#include "llvm/IR/GetElementPtrTypeIterator.h"
177#include "llvm/IR/IRBuilder.h"
178#include "llvm/IR/Instruction.h"
179#include "llvm/IR/Instructions.h"
180#include "llvm/IR/Module.h"
181#include "llvm/IR/PatternMatch.h"
182#include "llvm/IR/Type.h"
183#include "llvm/IR/User.h"
184#include "llvm/IR/Value.h"
185#include "llvm/Pass.h"
186#include "llvm/Support/Casting.h"
187#include "llvm/Support/CommandLine.h"
188#include "llvm/Support/ErrorHandling.h"
189#include "llvm/Support/raw_ostream.h"
190#include "llvm/Target/TargetMachine.h"
191#include "llvm/Transforms/Scalar.h"
192#include <cassert>
193#include <cstdint>
194#include <string>
195
196using namespace llvm;
197using namespace llvm::PatternMatch;
198
199static cl::opt<bool> DisableSeparateConstOffsetFromGEP(
200 "disable-separate-const-offset-from-gep", cl::init(false),
201 cl::desc("Do not separate the constant offset from a GEP instruction"),
202 cl::Hidden);
203
204// Setting this flag may emit false positives when the input module already
205// contains dead instructions. Therefore, we set it only in unit tests that are
206// free of dead code.
207static cl::opt<bool>
208 VerifyNoDeadCode("reassociate-geps-verify-no-dead-code", cl::init(false),
209 cl::desc("Verify this pass produces no dead code"),
210 cl::Hidden);
211
212namespace {
213
214/// A helper class for separating a constant offset from a GEP index.
215///
216/// In real programs, a GEP index may be more complicated than a simple addition
217/// of something and a constant integer which can be trivially splitted. For
218/// example, to split ((a << 3) | 5) + b, we need to search deeper for the
219/// constant offset, so that we can separate the index to (a << 3) + b and 5.
220///
221/// Therefore, this class looks into the expression that computes a given GEP
222/// index, and tries to find a constant integer that can be hoisted to the
223/// outermost level of the expression as an addition. Not every constant in an
224/// expression can jump out. e.g., we cannot transform (b * (a + 5)) to (b * a +
225/// 5); nor can we transform (3 * (a + 5)) to (3 * a + 5), however in this case,
226/// -instcombine probably already optimized (3 * (a + 5)) to (3 * a + 15).
227class ConstantOffsetExtractor {
228public:
229 /// Extracts a constant offset from the given GEP index. It returns the
230 /// new index representing the remainder (equal to the original index minus
231 /// the constant offset), or nullptr if we cannot extract a constant offset.
232 /// \p Idx The given GEP index
233 /// \p GEP The given GEP
234 /// \p UserChainTail Outputs the tail of UserChain so that we can
235 /// garbage-collect unused instructions in UserChain.
236 static Value *Extract(Value *Idx, GetElementPtrInst *GEP,
237 User *&UserChainTail, const DominatorTree *DT);
238
239 /// Looks for a constant offset from the given GEP index without extracting
240 /// it. It returns the numeric value of the extracted constant offset (0 if
241 /// failed). The meaning of the arguments are the same as Extract.
242 static int64_t Find(Value *Idx, GetElementPtrInst *GEP,
243 const DominatorTree *DT);
244
245private:
246 ConstantOffsetExtractor(Instruction *InsertionPt, const DominatorTree *DT)
247 : IP(InsertionPt), DL(InsertionPt->getModule()->getDataLayout()), DT(DT) {
248 }
249
250 /// Searches the expression that computes V for a non-zero constant C s.t.
251 /// V can be reassociated into the form V' + C. If the searching is
252 /// successful, returns C and update UserChain as a def-use chain from C to V;
253 /// otherwise, UserChain is empty.
254 ///
255 /// \p V The given expression
256 /// \p SignExtended Whether V will be sign-extended in the computation of the
257 /// GEP index
258 /// \p ZeroExtended Whether V will be zero-extended in the computation of the
259 /// GEP index
260 /// \p NonNegative Whether V is guaranteed to be non-negative. For example,
261 /// an index of an inbounds GEP is guaranteed to be
262 /// non-negative. Levaraging this, we can better split
263 /// inbounds GEPs.
264 APInt find(Value *V, bool SignExtended, bool ZeroExtended, bool NonNegative);
265
266 /// A helper function to look into both operands of a binary operator.
267 APInt findInEitherOperand(BinaryOperator *BO, bool SignExtended,
268 bool ZeroExtended);
269
270 /// After finding the constant offset C from the GEP index I, we build a new
271 /// index I' s.t. I' + C = I. This function builds and returns the new
272 /// index I' according to UserChain produced by function "find".
273 ///
274 /// The building conceptually takes two steps:
275 /// 1) iteratively distribute s/zext towards the leaves of the expression tree
276 /// that computes I
277 /// 2) reassociate the expression tree to the form I' + C.
278 ///
279 /// For example, to extract the 5 from sext(a + (b + 5)), we first distribute
280 /// sext to a, b and 5 so that we have
281 /// sext(a) + (sext(b) + 5).
282 /// Then, we reassociate it to
283 /// (sext(a) + sext(b)) + 5.
284 /// Given this form, we know I' is sext(a) + sext(b).
285 Value *rebuildWithoutConstOffset();
286
287 /// After the first step of rebuilding the GEP index without the constant
288 /// offset, distribute s/zext to the operands of all operators in UserChain.
289 /// e.g., zext(sext(a + (b + 5)) (assuming no overflow) =>
290 /// zext(sext(a)) + (zext(sext(b)) + zext(sext(5))).
291 ///
292 /// The function also updates UserChain to point to new subexpressions after
293 /// distributing s/zext. e.g., the old UserChain of the above example is
294 /// 5 -> b + 5 -> a + (b + 5) -> sext(...) -> zext(sext(...)),
295 /// and the new UserChain is
296 /// zext(sext(5)) -> zext(sext(b)) + zext(sext(5)) ->
297 /// zext(sext(a)) + (zext(sext(b)) + zext(sext(5))
298 ///
299 /// \p ChainIndex The index to UserChain. ChainIndex is initially
300 /// UserChain.size() - 1, and is decremented during
301 /// the recursion.
302 Value *distributeExtsAndCloneChain(unsigned ChainIndex);
303
304 /// Reassociates the GEP index to the form I' + C and returns I'.
305 Value *removeConstOffset(unsigned ChainIndex);
306
307 /// A helper function to apply ExtInsts, a list of s/zext, to value V.
308 /// e.g., if ExtInsts = [sext i32 to i64, zext i16 to i32], this function
309 /// returns "sext i32 (zext i16 V to i32) to i64".
310 Value *applyExts(Value *V);
311
312 /// A helper function that returns whether we can trace into the operands
313 /// of binary operator BO for a constant offset.
314 ///
315 /// \p SignExtended Whether BO is surrounded by sext
316 /// \p ZeroExtended Whether BO is surrounded by zext
317 /// \p NonNegative Whether BO is known to be non-negative, e.g., an in-bound
318 /// array index.
319 bool CanTraceInto(bool SignExtended, bool ZeroExtended, BinaryOperator *BO,
320 bool NonNegative);
321
322 /// The path from the constant offset to the old GEP index. e.g., if the GEP
323 /// index is "a * b + (c + 5)". After running function find, UserChain[0] will
324 /// be the constant 5, UserChain[1] will be the subexpression "c + 5", and
325 /// UserChain[2] will be the entire expression "a * b + (c + 5)".
326 ///
327 /// This path helps to rebuild the new GEP index.
328 SmallVector<User *, 8> UserChain;
329
330 /// A data structure used in rebuildWithoutConstOffset. Contains all
331 /// sext/zext instructions along UserChain.
332 SmallVector<CastInst *, 16> ExtInsts;
333
334 /// Insertion position of cloned instructions.
335 Instruction *IP;
336
337 const DataLayout &DL;
338 const DominatorTree *DT;
339};
340
341/// A pass that tries to split every GEP in the function into a variadic
342/// base and a constant offset. It is a FunctionPass because searching for the
343/// constant offset may inspect other basic blocks.
344class SeparateConstOffsetFromGEP : public FunctionPass {
345public:
346 static char ID;
347
348 SeparateConstOffsetFromGEP(bool LowerGEP = false)
349 : FunctionPass(ID), LowerGEP(LowerGEP) {
350 initializeSeparateConstOffsetFromGEPPass(*PassRegistry::getPassRegistry());
351 }
352
353 void getAnalysisUsage(AnalysisUsage &AU) const override {
354 AU.addRequired<DominatorTreeWrapperPass>();
355 AU.addRequired<ScalarEvolutionWrapperPass>();
356 AU.addRequired<TargetTransformInfoWrapperPass>();
357 AU.addRequired<LoopInfoWrapperPass>();
358 AU.setPreservesCFG();
359 AU.addRequired<TargetLibraryInfoWrapperPass>();
360 }
361
362 bool doInitialization(Module &M) override {
363 DL = &M.getDataLayout();
364 return false;
365 }
366
367 bool runOnFunction(Function &F) override;
368
369private:
370 /// Tries to split the given GEP into a variadic base and a constant offset,
371 /// and returns true if the splitting succeeds.
372 bool splitGEP(GetElementPtrInst *GEP);
373
374 /// Lower a GEP with multiple indices into multiple GEPs with a single index.
375 /// Function splitGEP already split the original GEP into a variadic part and
376 /// a constant offset (i.e., AccumulativeByteOffset). This function lowers the
377 /// variadic part into a set of GEPs with a single index and applies
378 /// AccumulativeByteOffset to it.
379 /// \p Variadic The variadic part of the original GEP.
380 /// \p AccumulativeByteOffset The constant offset.
381 void lowerToSingleIndexGEPs(GetElementPtrInst *Variadic,
382 int64_t AccumulativeByteOffset);
383
384 /// Lower a GEP with multiple indices into ptrtoint+arithmetics+inttoptr form.
385 /// Function splitGEP already split the original GEP into a variadic part and
386 /// a constant offset (i.e., AccumulativeByteOffset). This function lowers the
387 /// variadic part into a set of arithmetic operations and applies
388 /// AccumulativeByteOffset to it.
389 /// \p Variadic The variadic part of the original GEP.
390 /// \p AccumulativeByteOffset The constant offset.
391 void lowerToArithmetics(GetElementPtrInst *Variadic,
392 int64_t AccumulativeByteOffset);
393
394 /// Finds the constant offset within each index and accumulates them. If
395 /// LowerGEP is true, it finds in indices of both sequential and structure
396 /// types, otherwise it only finds in sequential indices. The output
397 /// NeedsExtraction indicates whether we successfully find a non-zero constant
398 /// offset.
399 int64_t accumulateByteOffset(GetElementPtrInst *GEP, bool &NeedsExtraction);
400
401 /// Canonicalize array indices to pointer-size integers. This helps to
402 /// simplify the logic of splitting a GEP. For example, if a + b is a
403 /// pointer-size integer, we have
404 /// gep base, a + b = gep (gep base, a), b
405 /// However, this equality may not hold if the size of a + b is smaller than
406 /// the pointer size, because LLVM conceptually sign-extends GEP indices to
407 /// pointer size before computing the address
408 /// (http://llvm.org/docs/LangRef.html#id181).
409 ///
410 /// This canonicalization is very likely already done in clang and
411 /// instcombine. Therefore, the program will probably remain the same.
412 ///
413 /// Returns true if the module changes.
414 ///
415 /// Verified in @i32_add in split-gep.ll
416 bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP);
417
418 /// Optimize sext(a)+sext(b) to sext(a+b) when a+b can't sign overflow.
419 /// SeparateConstOffsetFromGEP distributes a sext to leaves before extracting
420 /// the constant offset. After extraction, it becomes desirable to reunion the
421 /// distributed sexts. For example,
422 ///
423 /// &a[sext(i +nsw (j +nsw 5)]
424 /// => distribute &a[sext(i) +nsw (sext(j) +nsw 5)]
425 /// => constant extraction &a[sext(i) + sext(j)] + 5
426 /// => reunion &a[sext(i +nsw j)] + 5
427 bool reuniteExts(Function &F);
428
429 /// A helper that reunites sexts in an instruction.
430 bool reuniteExts(Instruction *I);
431
432 /// Find the closest dominator of <Dominatee> that is equivalent to <Key>.
433 Instruction *findClosestMatchingDominator(const SCEV *Key,
434 Instruction *Dominatee);
435 /// Verify F is free of dead code.
436 void verifyNoDeadCode(Function &F);
437
438 bool hasMoreThanOneUseInLoop(Value *v, Loop *L);
439
440 // Swap the index operand of two GEP.
441 void swapGEPOperand(GetElementPtrInst *First, GetElementPtrInst *Second);
442
443 // Check if it is safe to swap operand of two GEP.
444 bool isLegalToSwapOperand(GetElementPtrInst *First, GetElementPtrInst *Second,
445 Loop *CurLoop);
446
447 const DataLayout *DL = nullptr;
448 DominatorTree *DT = nullptr;
449 ScalarEvolution *SE;
450
451 LoopInfo *LI;
452 TargetLibraryInfo *TLI;
453
454 /// Whether to lower a GEP with multiple indices into arithmetic operations or
455 /// multiple GEPs with a single index.
456 bool LowerGEP;
457
458 DenseMap<const SCEV *, SmallVector<Instruction *, 2>> DominatingExprs;
459};
460
461} // end anonymous namespace
462
463char SeparateConstOffsetFromGEP::ID = 0;
464
465INITIALIZE_PASS_BEGIN(static void *initializeSeparateConstOffsetFromGEPPassOnce(PassRegistry
&Registry) {
466 SeparateConstOffsetFromGEP, "separate-const-offset-from-gep",static void *initializeSeparateConstOffsetFromGEPPassOnce(PassRegistry
&Registry) {
467 "Split GEPs to a variadic base and a constant offset for better CSE", false,static void *initializeSeparateConstOffsetFromGEPPassOnce(PassRegistry
&Registry) {
468 false)static void *initializeSeparateConstOffsetFromGEPPassOnce(PassRegistry
&Registry) {
469INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)initializeDominatorTreeWrapperPassPass(Registry);
470INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)initializeScalarEvolutionWrapperPassPass(Registry);
471INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)initializeTargetTransformInfoWrapperPassPass(Registry);
472INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)initializeLoopInfoWrapperPassPass(Registry);
473INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)initializeTargetLibraryInfoWrapperPassPass(Registry);
474INITIALIZE_PASS_END(PassInfo *PI = new PassInfo( "Split GEPs to a variadic base and a constant offset for better CSE"
, "separate-const-offset-from-gep", &SeparateConstOffsetFromGEP
::ID, PassInfo::NormalCtor_t(callDefaultCtor<SeparateConstOffsetFromGEP
>), false, false); Registry.registerPass(*PI, true); return
PI; } static llvm::once_flag InitializeSeparateConstOffsetFromGEPPassFlag
; void llvm::initializeSeparateConstOffsetFromGEPPass(PassRegistry
&Registry) { llvm::call_once(InitializeSeparateConstOffsetFromGEPPassFlag
, initializeSeparateConstOffsetFromGEPPassOnce, std::ref(Registry
)); }
475 SeparateConstOffsetFromGEP, "separate-const-offset-from-gep",PassInfo *PI = new PassInfo( "Split GEPs to a variadic base and a constant offset for better CSE"
, "separate-const-offset-from-gep", &SeparateConstOffsetFromGEP
::ID, PassInfo::NormalCtor_t(callDefaultCtor<SeparateConstOffsetFromGEP
>), false, false); Registry.registerPass(*PI, true); return
PI; } static llvm::once_flag InitializeSeparateConstOffsetFromGEPPassFlag
; void llvm::initializeSeparateConstOffsetFromGEPPass(PassRegistry
&Registry) { llvm::call_once(InitializeSeparateConstOffsetFromGEPPassFlag
, initializeSeparateConstOffsetFromGEPPassOnce, std::ref(Registry
)); }
476 "Split GEPs to a variadic base and a constant offset for better CSE", false,PassInfo *PI = new PassInfo( "Split GEPs to a variadic base and a constant offset for better CSE"
, "separate-const-offset-from-gep", &SeparateConstOffsetFromGEP
::ID, PassInfo::NormalCtor_t(callDefaultCtor<SeparateConstOffsetFromGEP
>), false, false); Registry.registerPass(*PI, true); return
PI; } static llvm::once_flag InitializeSeparateConstOffsetFromGEPPassFlag
; void llvm::initializeSeparateConstOffsetFromGEPPass(PassRegistry
&Registry) { llvm::call_once(InitializeSeparateConstOffsetFromGEPPassFlag
, initializeSeparateConstOffsetFromGEPPassOnce, std::ref(Registry
)); }
477 false)PassInfo *PI = new PassInfo( "Split GEPs to a variadic base and a constant offset for better CSE"
, "separate-const-offset-from-gep", &SeparateConstOffsetFromGEP
::ID, PassInfo::NormalCtor_t(callDefaultCtor<SeparateConstOffsetFromGEP
>), false, false); Registry.registerPass(*PI, true); return
PI; } static llvm::once_flag InitializeSeparateConstOffsetFromGEPPassFlag
; void llvm::initializeSeparateConstOffsetFromGEPPass(PassRegistry
&Registry) { llvm::call_once(InitializeSeparateConstOffsetFromGEPPassFlag
, initializeSeparateConstOffsetFromGEPPassOnce, std::ref(Registry
)); }
478
479FunctionPass *llvm::createSeparateConstOffsetFromGEPPass(bool LowerGEP) {
480 return new SeparateConstOffsetFromGEP(LowerGEP);
481}
482
483bool ConstantOffsetExtractor::CanTraceInto(bool SignExtended,
484 bool ZeroExtended,
485 BinaryOperator *BO,
486 bool NonNegative) {
487 // We only consider ADD, SUB and OR, because a non-zero constant found in
488 // expressions composed of these operations can be easily hoisted as a
489 // constant offset by reassociation.
490 if (BO->getOpcode() != Instruction::Add &&
491 BO->getOpcode() != Instruction::Sub &&
492 BO->getOpcode() != Instruction::Or) {
493 return false;
494 }
495
496 Value *LHS = BO->getOperand(0), *RHS = BO->getOperand(1);
497 // Do not trace into "or" unless it is equivalent to "add". If LHS and RHS
498 // don't have common bits, (LHS | RHS) is equivalent to (LHS + RHS).
499 // FIXME: this does not appear to be covered by any tests
500 // (with x86/aarch64 backends at least)
501 if (BO->getOpcode() == Instruction::Or &&
502 !haveNoCommonBitsSet(LHS, RHS, DL, nullptr, BO, DT))
503 return false;
504
505 // In addition, tracing into BO requires that its surrounding s/zext (if
506 // any) is distributable to both operands.
507 //
508 // Suppose BO = A op B.
509 // SignExtended | ZeroExtended | Distributable?
510 // --------------+--------------+----------------------------------
511 // 0 | 0 | true because no s/zext exists
512 // 0 | 1 | zext(BO) == zext(A) op zext(B)
513 // 1 | 0 | sext(BO) == sext(A) op sext(B)
514 // 1 | 1 | zext(sext(BO)) ==
515 // | | zext(sext(A)) op zext(sext(B))
516 if (BO->getOpcode() == Instruction::Add && !ZeroExtended && NonNegative) {
517 // If a + b >= 0 and (a >= 0 or b >= 0), then
518 // sext(a + b) = sext(a) + sext(b)
519 // even if the addition is not marked nsw.
520 //
521 // Leveraging this invarient, we can trace into an sext'ed inbound GEP
522 // index if the constant offset is non-negative.
523 //
524 // Verified in @sext_add in split-gep.ll.
525 if (ConstantInt *ConstLHS = dyn_cast<ConstantInt>(LHS)) {
526 if (!ConstLHS->isNegative())
527 return true;
528 }
529 if (ConstantInt *ConstRHS = dyn_cast<ConstantInt>(RHS)) {
530 if (!ConstRHS->isNegative())
531 return true;
532 }
533 }
534
535 // sext (add/sub nsw A, B) == add/sub nsw (sext A), (sext B)
536 // zext (add/sub nuw A, B) == add/sub nuw (zext A), (zext B)
537 if (BO->getOpcode() == Instruction::Add ||
538 BO->getOpcode() == Instruction::Sub) {
539 if (SignExtended && !BO->hasNoSignedWrap())
540 return false;
541 if (ZeroExtended && !BO->hasNoUnsignedWrap())
542 return false;
543 }
544
545 return true;
546}
547
548APInt ConstantOffsetExtractor::findInEitherOperand(BinaryOperator *BO,
549 bool SignExtended,
550 bool ZeroExtended) {
551 // BO being non-negative does not shed light on whether its operands are
552 // non-negative. Clear the NonNegative flag here.
553 APInt ConstantOffset = find(BO->getOperand(0), SignExtended, ZeroExtended,
554 /* NonNegative */ false);
555 // If we found a constant offset in the left operand, stop and return that.
556 // This shortcut might cause us to miss opportunities of combining the
557 // constant offsets in both operands, e.g., (a + 4) + (b + 5) => (a + b) + 9.
558 // However, such cases are probably already handled by -instcombine,
559 // given this pass runs after the standard optimizations.
560 if (ConstantOffset != 0) return ConstantOffset;
561 ConstantOffset = find(BO->getOperand(1), SignExtended, ZeroExtended,
562 /* NonNegative */ false);
563 // If U is a sub operator, negate the constant offset found in the right
564 // operand.
565 if (BO->getOpcode() == Instruction::Sub)
566 ConstantOffset = -ConstantOffset;
567 return ConstantOffset;
568}
569
570APInt ConstantOffsetExtractor::find(Value *V, bool SignExtended,
571 bool ZeroExtended, bool NonNegative) {
572 // TODO(jingyue): We could trace into integer/pointer casts, such as
573 // inttoptr, ptrtoint, bitcast, and addrspacecast. We choose to handle only
574 // integers because it gives good enough results for our benchmarks.
575 unsigned BitWidth = cast<IntegerType>(V->getType())->getBitWidth();
576
577 // We cannot do much with Values that are not a User, such as an Argument.
578 User *U = dyn_cast<User>(V);
579 if (U == nullptr) return APInt(BitWidth, 0);
580
581 APInt ConstantOffset(BitWidth, 0);
582 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
583 // Hooray, we found it!
584 ConstantOffset = CI->getValue();
585 } else if (BinaryOperator *BO = dyn_cast<BinaryOperator>(V)) {
586 // Trace into subexpressions for more hoisting opportunities.
587 if (CanTraceInto(SignExtended, ZeroExtended, BO, NonNegative))
588 ConstantOffset = findInEitherOperand(BO, SignExtended, ZeroExtended);
589 } else if (isa<TruncInst>(V)) {
590 ConstantOffset =
591 find(U->getOperand(0), SignExtended, ZeroExtended, NonNegative)
592 .trunc(BitWidth);
593 } else if (isa<SExtInst>(V)) {
594 ConstantOffset = find(U->getOperand(0), /* SignExtended */ true,
595 ZeroExtended, NonNegative).sext(BitWidth);
596 } else if (isa<ZExtInst>(V)) {
597 // As an optimization, we can clear the SignExtended flag because
598 // sext(zext(a)) = zext(a). Verified in @sext_zext in split-gep.ll.
599 //
600 // Clear the NonNegative flag, because zext(a) >= 0 does not imply a >= 0.
601 ConstantOffset =
602 find(U->getOperand(0), /* SignExtended */ false,
603 /* ZeroExtended */ true, /* NonNegative */ false).zext(BitWidth);
604 }
605
606 // If we found a non-zero constant offset, add it to the path for
607 // rebuildWithoutConstOffset. Zero is a valid constant offset, but doesn't
608 // help this optimization.
609 if (ConstantOffset != 0)
610 UserChain.push_back(U);
611 return ConstantOffset;
612}
613
614Value *ConstantOffsetExtractor::applyExts(Value *V) {
615 Value *Current = V;
616 // ExtInsts is built in the use-def order. Therefore, we apply them to V
617 // in the reversed order.
618 for (auto I = ExtInsts.rbegin(), E = ExtInsts.rend(); I != E; ++I) {
619 if (Constant *C = dyn_cast<Constant>(Current)) {
620 // If Current is a constant, apply s/zext using ConstantExpr::getCast.
621 // ConstantExpr::getCast emits a ConstantInt if C is a ConstantInt.
622 Current = ConstantExpr::getCast((*I)->getOpcode(), C, (*I)->getType());
623 } else {
624 Instruction *Ext = (*I)->clone();
625 Ext->setOperand(0, Current);
626 Ext->insertBefore(IP);
627 Current = Ext;
628 }
629 }
630 return Current;
631}
632
633Value *ConstantOffsetExtractor::rebuildWithoutConstOffset() {
634 distributeExtsAndCloneChain(UserChain.size() - 1);
635 // Remove all nullptrs (used to be s/zext) from UserChain.
636 unsigned NewSize = 0;
637 for (User *I : UserChain) {
638 if (I != nullptr) {
639 UserChain[NewSize] = I;
640 NewSize++;
641 }
642 }
643 UserChain.resize(NewSize);
644 return removeConstOffset(UserChain.size() - 1);
645}
646
647Value *
648ConstantOffsetExtractor::distributeExtsAndCloneChain(unsigned ChainIndex) {
649 User *U = UserChain[ChainIndex];
650 if (ChainIndex == 0) {
651 assert(isa<ConstantInt>(U))((isa<ConstantInt>(U)) ? static_cast<void> (0) : __assert_fail
("isa<ConstantInt>(U)", "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 651, __PRETTY_FUNCTION__))
;
652 // If U is a ConstantInt, applyExts will return a ConstantInt as well.
653 return UserChain[ChainIndex] = cast<ConstantInt>(applyExts(U));
654 }
655
656 if (CastInst *Cast = dyn_cast<CastInst>(U)) {
657 assert((((isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa
<TruncInst>(Cast)) && "Only following instructions can be traced: sext, zext & trunc"
) ? static_cast<void> (0) : __assert_fail ("(isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa<TruncInst>(Cast)) && \"Only following instructions can be traced: sext, zext & trunc\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 659, __PRETTY_FUNCTION__))
658 (isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa<TruncInst>(Cast)) &&(((isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa
<TruncInst>(Cast)) && "Only following instructions can be traced: sext, zext & trunc"
) ? static_cast<void> (0) : __assert_fail ("(isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa<TruncInst>(Cast)) && \"Only following instructions can be traced: sext, zext & trunc\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 659, __PRETTY_FUNCTION__))
659 "Only following instructions can be traced: sext, zext & trunc")(((isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa
<TruncInst>(Cast)) && "Only following instructions can be traced: sext, zext & trunc"
) ? static_cast<void> (0) : __assert_fail ("(isa<SExtInst>(Cast) || isa<ZExtInst>(Cast) || isa<TruncInst>(Cast)) && \"Only following instructions can be traced: sext, zext & trunc\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 659, __PRETTY_FUNCTION__))
;
660 ExtInsts.push_back(Cast);
661 UserChain[ChainIndex] = nullptr;
662 return distributeExtsAndCloneChain(ChainIndex - 1);
663 }
664
665 // Function find only trace into BinaryOperator and CastInst.
666 BinaryOperator *BO = cast<BinaryOperator>(U);
667 // OpNo = which operand of BO is UserChain[ChainIndex - 1]
668 unsigned OpNo = (BO->getOperand(0) == UserChain[ChainIndex - 1] ? 0 : 1);
669 Value *TheOther = applyExts(BO->getOperand(1 - OpNo));
670 Value *NextInChain = distributeExtsAndCloneChain(ChainIndex - 1);
671
672 BinaryOperator *NewBO = nullptr;
673 if (OpNo == 0) {
674 NewBO = BinaryOperator::Create(BO->getOpcode(), NextInChain, TheOther,
675 BO->getName(), IP);
676 } else {
677 NewBO = BinaryOperator::Create(BO->getOpcode(), TheOther, NextInChain,
678 BO->getName(), IP);
679 }
680 return UserChain[ChainIndex] = NewBO;
681}
682
683Value *ConstantOffsetExtractor::removeConstOffset(unsigned ChainIndex) {
684 if (ChainIndex == 0) {
685 assert(isa<ConstantInt>(UserChain[ChainIndex]))((isa<ConstantInt>(UserChain[ChainIndex])) ? static_cast
<void> (0) : __assert_fail ("isa<ConstantInt>(UserChain[ChainIndex])"
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 685, __PRETTY_FUNCTION__))
;
686 return ConstantInt::getNullValue(UserChain[ChainIndex]->getType());
687 }
688
689 BinaryOperator *BO = cast<BinaryOperator>(UserChain[ChainIndex]);
690 assert(BO->getNumUses() <= 1 &&((BO->getNumUses() <= 1 && "distributeExtsAndCloneChain clones each BinaryOperator in "
"UserChain, so no one should be used more than " "once") ? static_cast
<void> (0) : __assert_fail ("BO->getNumUses() <= 1 && \"distributeExtsAndCloneChain clones each BinaryOperator in \" \"UserChain, so no one should be used more than \" \"once\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 693, __PRETTY_FUNCTION__))
691 "distributeExtsAndCloneChain clones each BinaryOperator in "((BO->getNumUses() <= 1 && "distributeExtsAndCloneChain clones each BinaryOperator in "
"UserChain, so no one should be used more than " "once") ? static_cast
<void> (0) : __assert_fail ("BO->getNumUses() <= 1 && \"distributeExtsAndCloneChain clones each BinaryOperator in \" \"UserChain, so no one should be used more than \" \"once\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 693, __PRETTY_FUNCTION__))
692 "UserChain, so no one should be used more than "((BO->getNumUses() <= 1 && "distributeExtsAndCloneChain clones each BinaryOperator in "
"UserChain, so no one should be used more than " "once") ? static_cast
<void> (0) : __assert_fail ("BO->getNumUses() <= 1 && \"distributeExtsAndCloneChain clones each BinaryOperator in \" \"UserChain, so no one should be used more than \" \"once\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 693, __PRETTY_FUNCTION__))
693 "once")((BO->getNumUses() <= 1 && "distributeExtsAndCloneChain clones each BinaryOperator in "
"UserChain, so no one should be used more than " "once") ? static_cast
<void> (0) : __assert_fail ("BO->getNumUses() <= 1 && \"distributeExtsAndCloneChain clones each BinaryOperator in \" \"UserChain, so no one should be used more than \" \"once\""
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 693, __PRETTY_FUNCTION__))
;
694
695 unsigned OpNo = (BO->getOperand(0) == UserChain[ChainIndex - 1] ? 0 : 1);
696 assert(BO->getOperand(OpNo) == UserChain[ChainIndex - 1])((BO->getOperand(OpNo) == UserChain[ChainIndex - 1]) ? static_cast
<void> (0) : __assert_fail ("BO->getOperand(OpNo) == UserChain[ChainIndex - 1]"
, "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 696, __PRETTY_FUNCTION__))
;
697 Value *NextInChain = removeConstOffset(ChainIndex - 1);
698 Value *TheOther = BO->getOperand(1 - OpNo);
699
700 // If NextInChain is 0 and not the LHS of a sub, we can simplify the
701 // sub-expression to be just TheOther.
702 if (ConstantInt *CI = dyn_cast<ConstantInt>(NextInChain)) {
703 if (CI->isZero() && !(BO->getOpcode() == Instruction::Sub && OpNo == 0))
704 return TheOther;
705 }
706
707 BinaryOperator::BinaryOps NewOp = BO->getOpcode();
708 if (BO->getOpcode() == Instruction::Or) {
709 // Rebuild "or" as "add", because "or" may be invalid for the new
710 // expression.
711 //
712 // For instance, given
713 // a | (b + 5) where a and b + 5 have no common bits,
714 // we can extract 5 as the constant offset.
715 //
716 // However, reusing the "or" in the new index would give us
717 // (a | b) + 5
718 // which does not equal a | (b + 5).
719 //
720 // Replacing the "or" with "add" is fine, because
721 // a | (b + 5) = a + (b + 5) = (a + b) + 5
722 NewOp = Instruction::Add;
723 }
724
725 BinaryOperator *NewBO;
726 if (OpNo == 0) {
727 NewBO = BinaryOperator::Create(NewOp, NextInChain, TheOther, "", IP);
728 } else {
729 NewBO = BinaryOperator::Create(NewOp, TheOther, NextInChain, "", IP);
730 }
731 NewBO->takeName(BO);
732 return NewBO;
733}
734
735Value *ConstantOffsetExtractor::Extract(Value *Idx, GetElementPtrInst *GEP,
736 User *&UserChainTail,
737 const DominatorTree *DT) {
738 ConstantOffsetExtractor Extractor(GEP, DT);
739 // Find a non-zero constant offset first.
740 APInt ConstantOffset =
741 Extractor.find(Idx, /* SignExtended */ false, /* ZeroExtended */ false,
742 GEP->isInBounds());
743 if (ConstantOffset == 0) {
744 UserChainTail = nullptr;
745 return nullptr;
746 }
747 // Separates the constant offset from the GEP index.
748 Value *IdxWithoutConstOffset = Extractor.rebuildWithoutConstOffset();
749 UserChainTail = Extractor.UserChain.back();
750 return IdxWithoutConstOffset;
751}
752
753int64_t ConstantOffsetExtractor::Find(Value *Idx, GetElementPtrInst *GEP,
754 const DominatorTree *DT) {
755 // If Idx is an index of an inbound GEP, Idx is guaranteed to be non-negative.
756 return ConstantOffsetExtractor(GEP, DT)
757 .find(Idx, /* SignExtended */ false, /* ZeroExtended */ false,
758 GEP->isInBounds())
759 .getSExtValue();
760}
761
762bool SeparateConstOffsetFromGEP::canonicalizeArrayIndicesToPointerSize(
763 GetElementPtrInst *GEP) {
764 bool Changed = false;
765 Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
766 gep_type_iterator GTI = gep_type_begin(*GEP);
767 for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end();
768 I != E; ++I, ++GTI) {
769 // Skip struct member indices which must be i32.
770 if (GTI.isSequential()) {
771 if ((*I)->getType() != IntPtrTy) {
772 *I = CastInst::CreateIntegerCast(*I, IntPtrTy, true, "idxprom", GEP);
773 Changed = true;
774 }
775 }
776 }
777 return Changed;
778}
779
780int64_t
781SeparateConstOffsetFromGEP::accumulateByteOffset(GetElementPtrInst *GEP,
782 bool &NeedsExtraction) {
783 NeedsExtraction = false;
784 int64_t AccumulativeByteOffset = 0;
785 gep_type_iterator GTI = gep_type_begin(*GEP);
786 for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
787 if (GTI.isSequential()) {
788 // Tries to extract a constant offset from this GEP index.
789 int64_t ConstantOffset =
790 ConstantOffsetExtractor::Find(GEP->getOperand(I), GEP, DT);
791 if (ConstantOffset != 0) {
792 NeedsExtraction = true;
793 // A GEP may have multiple indices. We accumulate the extracted
794 // constant offset to a byte offset, and later offset the remainder of
795 // the original GEP with this byte offset.
796 AccumulativeByteOffset +=
797 ConstantOffset * DL->getTypeAllocSize(GTI.getIndexedType());
798 }
799 } else if (LowerGEP) {
800 StructType *StTy = GTI.getStructType();
801 uint64_t Field = cast<ConstantInt>(GEP->getOperand(I))->getZExtValue();
802 // Skip field 0 as the offset is always 0.
803 if (Field != 0) {
804 NeedsExtraction = true;
805 AccumulativeByteOffset +=
806 DL->getStructLayout(StTy)->getElementOffset(Field);
807 }
808 }
809 }
810 return AccumulativeByteOffset;
811}
812
813void SeparateConstOffsetFromGEP::lowerToSingleIndexGEPs(
814 GetElementPtrInst *Variadic, int64_t AccumulativeByteOffset) {
815 IRBuilder<> Builder(Variadic);
816 Type *IntPtrTy = DL->getIntPtrType(Variadic->getType());
817
818 Type *I8PtrTy =
819 Builder.getInt8PtrTy(Variadic->getType()->getPointerAddressSpace());
820 Value *ResultPtr = Variadic->getOperand(0);
821 Loop *L = LI->getLoopFor(Variadic->getParent());
822 // Check if the base is not loop invariant or used more than once.
823 bool isSwapCandidate =
824 L && L->isLoopInvariant(ResultPtr) &&
22
Assuming 'L' is null
825 !hasMoreThanOneUseInLoop(ResultPtr, L);
826 Value *FirstResult = nullptr;
827
828 if (ResultPtr->getType() != I8PtrTy)
23
Assuming the condition is false
24
Taking false branch
829 ResultPtr = Builder.CreateBitCast(ResultPtr, I8PtrTy);
830
831 gep_type_iterator GTI = gep_type_begin(*Variadic);
832 // Create an ugly GEP for each sequential index. We don't create GEPs for
833 // structure indices, as they are accumulated in the constant offset index.
834 for (unsigned I = 1, E = Variadic->getNumOperands(); I != E; ++I, ++GTI) {
25
Assuming 'I' is equal to 'E'
26
Loop condition is false. Execution continues on line 862
835 if (GTI.isSequential()) {
836 Value *Idx = Variadic->getOperand(I);
837 // Skip zero indices.
838 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
839 if (CI->isZero())
840 continue;
841
842 APInt ElementSize = APInt(IntPtrTy->getIntegerBitWidth(),
843 DL->getTypeAllocSize(GTI.getIndexedType()));
844 // Scale the index by element size.
845 if (ElementSize != 1) {
846 if (ElementSize.isPowerOf2()) {
847 Idx = Builder.CreateShl(
848 Idx, ConstantInt::get(IntPtrTy, ElementSize.logBase2()));
849 } else {
850 Idx = Builder.CreateMul(Idx, ConstantInt::get(IntPtrTy, ElementSize));
851 }
852 }
853 // Create an ugly GEP with a single index for each index.
854 ResultPtr =
855 Builder.CreateGEP(Builder.getInt8Ty(), ResultPtr, Idx, "uglygep");
856 if (FirstResult == nullptr)
857 FirstResult = ResultPtr;
858 }
859 }
860
861 // Create a GEP with the constant offset index.
862 if (AccumulativeByteOffset != 0) {
27
Assuming 'AccumulativeByteOffset' is not equal to 0
28
Taking true branch
863 Value *Offset = ConstantInt::get(IntPtrTy, AccumulativeByteOffset);
864 ResultPtr =
37
Value assigned to 'ResultPtr'
865 Builder.CreateGEP(Builder.getInt8Ty(), ResultPtr, Offset, "uglygep");
29
Calling 'IRBuilder::CreateGEP'
36
Returning from 'IRBuilder::CreateGEP'
866 } else
867 isSwapCandidate = false;
868
869 // If we created a GEP with constant index, and the base is loop invariant,
870 // then we swap the first one with it, so LICM can move constant GEP out
871 // later.
872 GetElementPtrInst *FirstGEP = dyn_cast_or_null<GetElementPtrInst>(FirstResult);
38
Assuming null pointer is passed into cast
873 GetElementPtrInst *SecondGEP = dyn_cast_or_null<GetElementPtrInst>(ResultPtr);
39
Assuming null pointer is passed into cast
40
Assuming pointer value is null
874 if (isSwapCandidate
40.1
'isSwapCandidate' is false
40.1
'isSwapCandidate' is false
&& isLegalToSwapOperand(FirstGEP, SecondGEP, L))
875 swapGEPOperand(FirstGEP, SecondGEP);
876
877 if (ResultPtr->getType() != Variadic->getType())
41
Called C++ object pointer is null
878 ResultPtr = Builder.CreateBitCast(ResultPtr, Variadic->getType());
879
880 Variadic->replaceAllUsesWith(ResultPtr);
881 Variadic->eraseFromParent();
882}
883
884void
885SeparateConstOffsetFromGEP::lowerToArithmetics(GetElementPtrInst *Variadic,
886 int64_t AccumulativeByteOffset) {
887 IRBuilder<> Builder(Variadic);
888 Type *IntPtrTy = DL->getIntPtrType(Variadic->getType());
889
890 Value *ResultPtr = Builder.CreatePtrToInt(Variadic->getOperand(0), IntPtrTy);
891 gep_type_iterator GTI = gep_type_begin(*Variadic);
892 // Create ADD/SHL/MUL arithmetic operations for each sequential indices. We
893 // don't create arithmetics for structure indices, as they are accumulated
894 // in the constant offset index.
895 for (unsigned I = 1, E = Variadic->getNumOperands(); I != E; ++I, ++GTI) {
896 if (GTI.isSequential()) {
897 Value *Idx = Variadic->getOperand(I);
898 // Skip zero indices.
899 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
900 if (CI->isZero())
901 continue;
902
903 APInt ElementSize = APInt(IntPtrTy->getIntegerBitWidth(),
904 DL->getTypeAllocSize(GTI.getIndexedType()));
905 // Scale the index by element size.
906 if (ElementSize != 1) {
907 if (ElementSize.isPowerOf2()) {
908 Idx = Builder.CreateShl(
909 Idx, ConstantInt::get(IntPtrTy, ElementSize.logBase2()));
910 } else {
911 Idx = Builder.CreateMul(Idx, ConstantInt::get(IntPtrTy, ElementSize));
912 }
913 }
914 // Create an ADD for each index.
915 ResultPtr = Builder.CreateAdd(ResultPtr, Idx);
916 }
917 }
918
919 // Create an ADD for the constant offset index.
920 if (AccumulativeByteOffset != 0) {
921 ResultPtr = Builder.CreateAdd(
922 ResultPtr, ConstantInt::get(IntPtrTy, AccumulativeByteOffset));
923 }
924
925 ResultPtr = Builder.CreateIntToPtr(ResultPtr, Variadic->getType());
926 Variadic->replaceAllUsesWith(ResultPtr);
927 Variadic->eraseFromParent();
928}
929
930bool SeparateConstOffsetFromGEP::splitGEP(GetElementPtrInst *GEP) {
931 // Skip vector GEPs.
932 if (GEP->getType()->isVectorTy())
9
Taking false branch
933 return false;
934
935 // The backend can already nicely handle the case where all indices are
936 // constant.
937 if (GEP->hasAllConstantIndices())
10
Assuming the condition is false
11
Taking false branch
938 return false;
939
940 bool Changed = canonicalizeArrayIndicesToPointerSize(GEP);
941
942 bool NeedsExtraction;
943 int64_t AccumulativeByteOffset = accumulateByteOffset(GEP, NeedsExtraction);
944
945 if (!NeedsExtraction
11.1
'NeedsExtraction' is true
11.1
'NeedsExtraction' is true
)
12
Taking false branch
946 return Changed;
947
948 TargetTransformInfo &TTI =
949 getAnalysis<TargetTransformInfoWrapperPass>().getTTI(*GEP->getFunction());
950
951 // If LowerGEP is disabled, before really splitting the GEP, check whether the
952 // backend supports the addressing mode we are about to produce. If no, this
953 // splitting probably won't be beneficial.
954 // If LowerGEP is enabled, even the extracted constant offset can not match
955 // the addressing mode, we can still do optimizations to other lowered parts
956 // of variable indices. Therefore, we don't check for addressing modes in that
957 // case.
958 if (!LowerGEP
12.1
Field 'LowerGEP' is true
12.1
Field 'LowerGEP' is true
) {
13
Taking false branch
959 unsigned AddrSpace = GEP->getPointerAddressSpace();
960 if (!TTI.isLegalAddressingMode(GEP->getResultElementType(),
961 /*BaseGV=*/nullptr, AccumulativeByteOffset,
962 /*HasBaseReg=*/true, /*Scale=*/0,
963 AddrSpace)) {
964 return Changed;
965 }
966 }
967
968 // Remove the constant offset in each sequential index. The resultant GEP
969 // computes the variadic base.
970 // Notice that we don't remove struct field indices here. If LowerGEP is
971 // disabled, a structure index is not accumulated and we still use the old
972 // one. If LowerGEP is enabled, a structure index is accumulated in the
973 // constant offset. LowerToSingleIndexGEPs or lowerToArithmetics will later
974 // handle the constant offset and won't need a new structure index.
975 gep_type_iterator GTI = gep_type_begin(*GEP);
976 for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
14
Loop condition is true. Entering loop body
17
Loop condition is false. Execution continues on line 1014
977 if (GTI.isSequential()) {
15
Assuming the condition is false
16
Taking false branch
978 // Splits this GEP index into a variadic part and a constant offset, and
979 // uses the variadic part as the new index.
980 Value *OldIdx = GEP->getOperand(I);
981 User *UserChainTail;
982 Value *NewIdx =
983 ConstantOffsetExtractor::Extract(OldIdx, GEP, UserChainTail, DT);
984 if (NewIdx != nullptr) {
985 // Switches to the index with the constant offset removed.
986 GEP->setOperand(I, NewIdx);
987 // After switching to the new index, we can garbage-collect UserChain
988 // and the old index if they are not used.
989 RecursivelyDeleteTriviallyDeadInstructions(UserChainTail);
990 RecursivelyDeleteTriviallyDeadInstructions(OldIdx);
991 }
992 }
993 }
994
995 // Clear the inbounds attribute because the new index may be off-bound.
996 // e.g.,
997 //
998 // b = add i64 a, 5
999 // addr = gep inbounds float, float* p, i64 b
1000 //
1001 // is transformed to:
1002 //
1003 // addr2 = gep float, float* p, i64 a ; inbounds removed
1004 // addr = gep inbounds float, float* addr2, i64 5
1005 //
1006 // If a is -4, although the old index b is in bounds, the new index a is
1007 // off-bound. http://llvm.org/docs/LangRef.html#id181 says "if the
1008 // inbounds keyword is not present, the offsets are added to the base
1009 // address with silently-wrapping two's complement arithmetic".
1010 // Therefore, the final code will be a semantically equivalent.
1011 //
1012 // TODO(jingyue): do some range analysis to keep as many inbounds as
1013 // possible. GEPs with inbounds are more friendly to alias analysis.
1014 bool GEPWasInBounds = GEP->isInBounds();
1015 GEP->setIsInBounds(false);
1016
1017 // Lowers a GEP to either GEPs with a single index or arithmetic operations.
1018 if (LowerGEP
17.1
Field 'LowerGEP' is true
17.1
Field 'LowerGEP' is true
) {
18
Taking true branch
1019 // As currently BasicAA does not analyze ptrtoint/inttoptr, do not lower to
1020 // arithmetic operations if the target uses alias analysis in codegen.
1021 if (TTI.useAA())
19
Assuming the condition is true
20
Taking true branch
1022 lowerToSingleIndexGEPs(GEP, AccumulativeByteOffset);
21
Calling 'SeparateConstOffsetFromGEP::lowerToSingleIndexGEPs'
1023 else
1024 lowerToArithmetics(GEP, AccumulativeByteOffset);
1025 return true;
1026 }
1027
1028 // No need to create another GEP if the accumulative byte offset is 0.
1029 if (AccumulativeByteOffset == 0)
1030 return true;
1031
1032 // Offsets the base with the accumulative byte offset.
1033 //
1034 // %gep ; the base
1035 // ... %gep ...
1036 //
1037 // => add the offset
1038 //
1039 // %gep2 ; clone of %gep
1040 // %new.gep = gep %gep2, <offset / sizeof(*%gep)>
1041 // %gep ; will be removed
1042 // ... %gep ...
1043 //
1044 // => replace all uses of %gep with %new.gep and remove %gep
1045 //
1046 // %gep2 ; clone of %gep
1047 // %new.gep = gep %gep2, <offset / sizeof(*%gep)>
1048 // ... %new.gep ...
1049 //
1050 // If AccumulativeByteOffset is not a multiple of sizeof(*%gep), we emit an
1051 // uglygep (http://llvm.org/docs/GetElementPtr.html#what-s-an-uglygep):
1052 // bitcast %gep2 to i8*, add the offset, and bitcast the result back to the
1053 // type of %gep.
1054 //
1055 // %gep2 ; clone of %gep
1056 // %0 = bitcast %gep2 to i8*
1057 // %uglygep = gep %0, <offset>
1058 // %new.gep = bitcast %uglygep to <type of %gep>
1059 // ... %new.gep ...
1060 Instruction *NewGEP = GEP->clone();
1061 NewGEP->insertBefore(GEP);
1062
1063 // Per ANSI C standard, signed / unsigned = unsigned and signed % unsigned =
1064 // unsigned.. Therefore, we cast ElementTypeSizeOfGEP to signed because it is
1065 // used with unsigned integers later.
1066 int64_t ElementTypeSizeOfGEP = static_cast<int64_t>(
1067 DL->getTypeAllocSize(GEP->getResultElementType()));
1068 Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
1069 if (AccumulativeByteOffset % ElementTypeSizeOfGEP == 0) {
1070 // Very likely. As long as %gep is naturally aligned, the byte offset we
1071 // extracted should be a multiple of sizeof(*%gep).
1072 int64_t Index = AccumulativeByteOffset / ElementTypeSizeOfGEP;
1073 NewGEP = GetElementPtrInst::Create(GEP->getResultElementType(), NewGEP,
1074 ConstantInt::get(IntPtrTy, Index, true),
1075 GEP->getName(), GEP);
1076 NewGEP->copyMetadata(*GEP);
1077 // Inherit the inbounds attribute of the original GEP.
1078 cast<GetElementPtrInst>(NewGEP)->setIsInBounds(GEPWasInBounds);
1079 } else {
1080 // Unlikely but possible. For example,
1081 // #pragma pack(1)
1082 // struct S {
1083 // int a[3];
1084 // int64 b[8];
1085 // };
1086 // #pragma pack()
1087 //
1088 // Suppose the gep before extraction is &s[i + 1].b[j + 3]. After
1089 // extraction, it becomes &s[i].b[j] and AccumulativeByteOffset is
1090 // sizeof(S) + 3 * sizeof(int64) = 100, which is not a multiple of
1091 // sizeof(int64).
1092 //
1093 // Emit an uglygep in this case.
1094 Type *I8PtrTy = Type::getInt8PtrTy(GEP->getContext(),
1095 GEP->getPointerAddressSpace());
1096 NewGEP = new BitCastInst(NewGEP, I8PtrTy, "", GEP);
1097 NewGEP = GetElementPtrInst::Create(
1098 Type::getInt8Ty(GEP->getContext()), NewGEP,
1099 ConstantInt::get(IntPtrTy, AccumulativeByteOffset, true), "uglygep",
1100 GEP);
1101 NewGEP->copyMetadata(*GEP);
1102 // Inherit the inbounds attribute of the original GEP.
1103 cast<GetElementPtrInst>(NewGEP)->setIsInBounds(GEPWasInBounds);
1104 if (GEP->getType() != I8PtrTy)
1105 NewGEP = new BitCastInst(NewGEP, GEP->getType(), GEP->getName(), GEP);
1106 }
1107
1108 GEP->replaceAllUsesWith(NewGEP);
1109 GEP->eraseFromParent();
1110
1111 return true;
1112}
1113
1114bool SeparateConstOffsetFromGEP::runOnFunction(Function &F) {
1115 if (skipFunction(F))
1
Assuming the condition is false
2
Taking false branch
1116 return false;
1117
1118 if (DisableSeparateConstOffsetFromGEP)
3
Assuming the condition is false
4
Taking false branch
1119 return false;
1120
1121 DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
1122 SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
1123 LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
1124 TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
1125 bool Changed = false;
1126 for (BasicBlock &B : F) {
1127 for (BasicBlock::iterator I = B.begin(), IE = B.end(); I != IE;)
5
Loop condition is true. Entering loop body
1128 if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(I++))
6
Assuming 'GEP' is non-null
7
Taking true branch
1129 Changed |= splitGEP(GEP);
8
Calling 'SeparateConstOffsetFromGEP::splitGEP'
1130 // No need to split GEP ConstantExprs because all its indices are constant
1131 // already.
1132 }
1133
1134 Changed |= reuniteExts(F);
1135
1136 if (VerifyNoDeadCode)
1137 verifyNoDeadCode(F);
1138
1139 return Changed;
1140}
1141
1142Instruction *SeparateConstOffsetFromGEP::findClosestMatchingDominator(
1143 const SCEV *Key, Instruction *Dominatee) {
1144 auto Pos = DominatingExprs.find(Key);
1145 if (Pos == DominatingExprs.end())
1146 return nullptr;
1147
1148 auto &Candidates = Pos->second;
1149 // Because we process the basic blocks in pre-order of the dominator tree, a
1150 // candidate that doesn't dominate the current instruction won't dominate any
1151 // future instruction either. Therefore, we pop it out of the stack. This
1152 // optimization makes the algorithm O(n).
1153 while (!Candidates.empty()) {
1154 Instruction *Candidate = Candidates.back();
1155 if (DT->dominates(Candidate, Dominatee))
1156 return Candidate;
1157 Candidates.pop_back();
1158 }
1159 return nullptr;
1160}
1161
1162bool SeparateConstOffsetFromGEP::reuniteExts(Instruction *I) {
1163 if (!SE->isSCEVable(I->getType()))
1164 return false;
1165
1166 // Dom: LHS+RHS
1167 // I: sext(LHS)+sext(RHS)
1168 // If Dom can't sign overflow and Dom dominates I, optimize I to sext(Dom).
1169 // TODO: handle zext
1170 Value *LHS = nullptr, *RHS = nullptr;
1171 if (match(I, m_Add(m_SExt(m_Value(LHS)), m_SExt(m_Value(RHS)))) ||
1172 match(I, m_Sub(m_SExt(m_Value(LHS)), m_SExt(m_Value(RHS))))) {
1173 if (LHS->getType() == RHS->getType()) {
1174 const SCEV *Key =
1175 SE->getAddExpr(SE->getUnknown(LHS), SE->getUnknown(RHS));
1176 if (auto *Dom = findClosestMatchingDominator(Key, I)) {
1177 Instruction *NewSExt = new SExtInst(Dom, I->getType(), "", I);
1178 NewSExt->takeName(I);
1179 I->replaceAllUsesWith(NewSExt);
1180 RecursivelyDeleteTriviallyDeadInstructions(I);
1181 return true;
1182 }
1183 }
1184 }
1185
1186 // Add I to DominatingExprs if it's an add/sub that can't sign overflow.
1187 if (match(I, m_NSWAdd(m_Value(LHS), m_Value(RHS))) ||
1188 match(I, m_NSWSub(m_Value(LHS), m_Value(RHS)))) {
1189 if (programUndefinedIfFullPoison(I)) {
1190 const SCEV *Key =
1191 SE->getAddExpr(SE->getUnknown(LHS), SE->getUnknown(RHS));
1192 DominatingExprs[Key].push_back(I);
1193 }
1194 }
1195 return false;
1196}
1197
1198bool SeparateConstOffsetFromGEP::reuniteExts(Function &F) {
1199 bool Changed = false;
1200 DominatingExprs.clear();
1201 for (const auto Node : depth_first(DT)) {
1202 BasicBlock *BB = Node->getBlock();
1203 for (auto I = BB->begin(); I != BB->end(); ) {
1204 Instruction *Cur = &*I++;
1205 Changed |= reuniteExts(Cur);
1206 }
1207 }
1208 return Changed;
1209}
1210
1211void SeparateConstOffsetFromGEP::verifyNoDeadCode(Function &F) {
1212 for (BasicBlock &B : F) {
1213 for (Instruction &I : B) {
1214 if (isInstructionTriviallyDead(&I)) {
1215 std::string ErrMessage;
1216 raw_string_ostream RSO(ErrMessage);
1217 RSO << "Dead instruction detected!\n" << I << "\n";
1218 llvm_unreachable(RSO.str().c_str())::llvm::llvm_unreachable_internal(RSO.str().c_str(), "/build/llvm-toolchain-snapshot-10~svn374877/lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp"
, 1218)
;
1219 }
1220 }
1221 }
1222}
1223
1224bool SeparateConstOffsetFromGEP::isLegalToSwapOperand(
1225 GetElementPtrInst *FirstGEP, GetElementPtrInst *SecondGEP, Loop *CurLoop) {
1226 if (!FirstGEP || !FirstGEP->hasOneUse())
1227 return false;
1228
1229 if (!SecondGEP || FirstGEP->getParent() != SecondGEP->getParent())
1230 return false;
1231
1232 if (FirstGEP == SecondGEP)
1233 return false;
1234
1235 unsigned FirstNum = FirstGEP->getNumOperands();
1236 unsigned SecondNum = SecondGEP->getNumOperands();
1237 // Give up if the number of operands are not 2.
1238 if (FirstNum != SecondNum || FirstNum != 2)
1239 return false;
1240
1241 Value *FirstBase = FirstGEP->getOperand(0);
1242 Value *SecondBase = SecondGEP->getOperand(0);
1243 Value *FirstOffset = FirstGEP->getOperand(1);
1244 // Give up if the index of the first GEP is loop invariant.
1245 if (CurLoop->isLoopInvariant(FirstOffset))
1246 return false;
1247
1248 // Give up if base doesn't have same type.
1249 if (FirstBase->getType() != SecondBase->getType())
1250 return false;
1251
1252 Instruction *FirstOffsetDef = dyn_cast<Instruction>(FirstOffset);
1253
1254 // Check if the second operand of first GEP has constant coefficient.
1255 // For an example, for the following code, we won't gain anything by
1256 // hoisting the second GEP out because the second GEP can be folded away.
1257 // %scevgep.sum.ur159 = add i64 %idxprom48.ur, 256
1258 // %67 = shl i64 %scevgep.sum.ur159, 2
1259 // %uglygep160 = getelementptr i8* %65, i64 %67
1260 // %uglygep161 = getelementptr i8* %uglygep160, i64 -1024
1261
1262 // Skip constant shift instruction which may be generated by Splitting GEPs.
1263 if (FirstOffsetDef && FirstOffsetDef->isShift() &&
1264 isa<ConstantInt>(FirstOffsetDef->getOperand(1)))
1265 FirstOffsetDef = dyn_cast<Instruction>(FirstOffsetDef->getOperand(0));
1266
1267 // Give up if FirstOffsetDef is an Add or Sub with constant.
1268 // Because it may not profitable at all due to constant folding.
1269 if (FirstOffsetDef)
1270 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(FirstOffsetDef)) {
1271 unsigned opc = BO->getOpcode();
1272 if ((opc == Instruction::Add || opc == Instruction::Sub) &&
1273 (isa<ConstantInt>(BO->getOperand(0)) ||
1274 isa<ConstantInt>(BO->getOperand(1))))
1275 return false;
1276 }
1277 return true;
1278}
1279
1280bool SeparateConstOffsetFromGEP::hasMoreThanOneUseInLoop(Value *V, Loop *L) {
1281 int UsesInLoop = 0;
1282 for (User *U : V->users()) {
1283 if (Instruction *User = dyn_cast<Instruction>(U))
1284 if (L->contains(User))
1285 if (++UsesInLoop > 1)
1286 return true;
1287 }
1288 return false;
1289}
1290
1291void SeparateConstOffsetFromGEP::swapGEPOperand(GetElementPtrInst *First,
1292 GetElementPtrInst *Second) {
1293 Value *Offset1 = First->getOperand(1);
1294 Value *Offset2 = Second->getOperand(1);
1295 First->setOperand(1, Offset2);
1296 Second->setOperand(1, Offset1);
1297
1298 // We changed p+o+c to p+c+o, p+c may not be inbound anymore.
1299 const DataLayout &DAL = First->getModule()->getDataLayout();
1300 APInt Offset(DAL.getIndexSizeInBits(
1301 cast<PointerType>(First->getType())->getAddressSpace()),
1302 0);
1303 Value *NewBase =
1304 First->stripAndAccumulateInBoundsConstantOffsets(DAL, Offset);
1305 uint64_t ObjectSize;
1306 if (!getObjectSize(NewBase, ObjectSize, DAL, TLI) ||
1307 Offset.ugt(ObjectSize)) {
1308 First->setIsInBounds(false);
1309 Second->setIsInBounds(false);
1310 } else
1311 First->setIsInBounds(true);
1312}

/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h

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
50namespace llvm {
51
52class APInt;
53class MDNode;
54class 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.
61class IRBuilderDefaultInserter {
62protected:
63 void InsertHelper(Instruction *I, const Twine &Name,
64 BasicBlock *BB, BasicBlock::iterator InsertPt) const {
65 if (BB) BB->getInstList().insert(InsertPt, I);
66 I->setName(Name);
67 }
68};
69
70/// Provides an 'InsertHelper' that calls a user-provided callback after
71/// performing the default insertion.
72class IRBuilderCallbackInserter : IRBuilderDefaultInserter {
73 std::function<void(Instruction *)> Callback;
74
75public:
76 IRBuilderCallbackInserter(std::function<void(Instruction *)> Callback)
77 : Callback(std::move(Callback)) {}
78
79protected:
80 void InsertHelper(Instruction *I, const Twine &Name,
81 BasicBlock *BB, BasicBlock::iterator InsertPt) const {
82 IRBuilderDefaultInserter::InsertHelper(I, Name, BB, InsertPt);
83 Callback(I);
84 }
85};
86
87/// Common base class shared among various IRBuilders.
88class IRBuilderBase {
89 DebugLoc CurDbgLocation;
90
91protected:
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
105public:
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 DefaultOperandBundles(OpBundles) {
112 ClearInsertionPoint();
113 }
114
115 //===--------------------------------------------------------------------===//
116 // Builder configuration methods
117 //===--------------------------------------------------------------------===//
118
119 /// Clear the insertion point: created instructions will not be
120 /// inserted into a block.
121 void ClearInsertionPoint() {
122 BB = nullptr;
123 InsertPt = BasicBlock::iterator();
124 }
125
126 BasicBlock *GetInsertBlock() const { return BB; }
127 BasicBlock::iterator GetInsertPoint() const { return InsertPt; }
128 LLVMContext &getContext() const { return Context; }
129
130 /// This specifies that created instructions should be appended to the
131 /// end of the specified block.
132 void SetInsertPoint(BasicBlock *TheBB) {
133 BB = TheBB;
134 InsertPt = BB->end();
135 }
136
137 /// This specifies that created instructions should be inserted before
138 /// the specified instruction.
139 void SetInsertPoint(Instruction *I) {
140 BB = I->getParent();
141 InsertPt = I->getIterator();
142 assert(InsertPt != BB->end() && "Can't read debug loc from end()")((InsertPt != BB->end() && "Can't read debug loc from end()"
) ? static_cast<void> (0) : __assert_fail ("InsertPt != BB->end() && \"Can't read debug loc from end()\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 142, __PRETTY_FUNCTION__))
;
143 SetCurrentDebugLocation(I->getDebugLoc());
144 }
145
146 /// This specifies that created instructions should be inserted at the
147 /// specified point.
148 void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
149 BB = TheBB;
150 InsertPt = IP;
151 if (IP != TheBB->end())
152 SetCurrentDebugLocation(IP->getDebugLoc());
153 }
154
155 /// Set location information used by debugging information.
156 void SetCurrentDebugLocation(DebugLoc L) { CurDbgLocation = std::move(L); }
157
158 /// Get location information used by debugging information.
159 const DebugLoc &getCurrentDebugLocation() const { return CurDbgLocation; }
160
161 /// If this builder has a current debug location, set it on the
162 /// specified instruction.
163 void SetInstDebugLocation(Instruction *I) const {
164 if (CurDbgLocation)
165 I->setDebugLoc(CurDbgLocation);
166 }
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 InsertPoint() = default;
180
181 /// Creates a new insertion point at the given location.
182 InsertPoint(BasicBlock *InsertBlock, BasicBlock::iterator InsertPoint)
183 : Block(InsertBlock), Point(InsertPoint) {}
184
185 /// Returns true if this insert point is set.
186 bool isSet() const { return (Block != nullptr); }
187
188 BasicBlock *getBlock() const { return Block; }
189 BasicBlock::iterator getPoint() const { return Point; }
190 };
191
192 /// Returns the current insert point.
193 InsertPoint saveIP() const {
194 return InsertPoint(GetInsertBlock(), GetInsertPoint());
195 }
196
197 /// Returns the current insert point, clearing it in the process.
198 InsertPoint saveAndClearIP() {
199 InsertPoint IP(GetInsertBlock(), GetInsertPoint());
200 ClearInsertionPoint();
201 return IP;
202 }
203
204 /// Sets the current insert point to a previously-saved location.
205 void restoreIP(InsertPoint IP) {
206 if (IP.isSet())
207 SetInsertPoint(IP.getBlock(), IP.getPoint());
208 else
209 ClearInsertionPoint();
210 }
211
212 /// Get the floating point math metadata being used.
213 MDNode *getDefaultFPMathTag() const { return DefaultFPMathTag; }
214
215 /// Get the flags to be applied to created floating point ops
216 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 void setDefaultFPMathTag(MDNode *FPMathTag) { DefaultFPMathTag = FPMathTag; }
223
224 /// Set the fast-math flags to be used with generated fp-math operators
225 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 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 ConstrainedFPIntrinsic::ExceptionBehavior getDefaultConstrainedExcept() {
250 return DefaultConstrainedExcept;
251 }
252
253 /// Get the rounding mode handling used with constrained floating point
254 ConstrainedFPIntrinsic::RoundingMode getDefaultConstrainedRounding() {
255 return DefaultConstrainedRounding;
256 }
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 DbgLoc(B.getCurrentDebugLocation()) {}
274
275 InsertPointGuard(const InsertPointGuard &) = delete;
276 InsertPointGuard &operator=(const InsertPointGuard &) = delete;
277
278 ~InsertPointGuard() {
279 Builder.restoreIP(InsertPoint(Block, Point));
280 Builder.SetCurrentDebugLocation(DbgLoc);
281 }
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 : Builder(B), FMF(B.FMF), FPMathTag(B.DefaultFPMathTag) {}
294
295 FastMathFlagGuard(const FastMathFlagGuard &) = delete;
296 FastMathFlagGuard &operator=(const FastMathFlagGuard &) = delete;
297
298 ~FastMathFlagGuard() {
299 Builder.FMF = FMF;
300 Builder.DefaultFPMathTag = FPMathTag;
301 }
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 ConstantInt *getInt1(bool V) {
319 return ConstantInt::get(getInt1Ty(), V);
320 }
321
322 /// Get the constant value for i1 true.
323 ConstantInt *getTrue() {
324 return ConstantInt::getTrue(Context);
325 }
326
327 /// Get the constant value for i1 false.
328 ConstantInt *getFalse() {
329 return ConstantInt::getFalse(Context);
330 }
331
332 /// Get a constant 8-bit value.
333 ConstantInt *getInt8(uint8_t C) {
334 return ConstantInt::get(getInt8Ty(), C);
335 }
336
337 /// Get a constant 16-bit value.
338 ConstantInt *getInt16(uint16_t C) {
339 return ConstantInt::get(getInt16Ty(), C);
340 }
341
342 /// Get a constant 32-bit value.
343 ConstantInt *getInt32(uint32_t C) {
344 return ConstantInt::get(getInt32Ty(), C);
345 }
346
347 /// Get a constant 64-bit value.
348 ConstantInt *getInt64(uint64_t C) {
349 return ConstantInt::get(getInt64Ty(), C);
350 }
351
352 /// Get a constant N-bit value, zero extended or truncated from
353 /// a 64-bit value.
354 ConstantInt *getIntN(unsigned N, uint64_t C) {
355 return ConstantInt::get(getIntNTy(N), C);
356 }
357
358 /// Get a constant integer value.
359 ConstantInt *getInt(const APInt &AI) {
360 return ConstantInt::get(Context, AI);
361 }
362
363 //===--------------------------------------------------------------------===//
364 // Type creation methods
365 //===--------------------------------------------------------------------===//
366
367 /// Fetch the type representing a single bit
368 IntegerType *getInt1Ty() {
369 return Type::getInt1Ty(Context);
370 }
371
372 /// Fetch the type representing an 8-bit integer.
373 IntegerType *getInt8Ty() {
374 return Type::getInt8Ty(Context);
375 }
376
377 /// Fetch the type representing a 16-bit integer.
378 IntegerType *getInt16Ty() {
379 return Type::getInt16Ty(Context);
380 }
381
382 /// Fetch the type representing a 32-bit integer.
383 IntegerType *getInt32Ty() {
384 return Type::getInt32Ty(Context);
385 }
386
387 /// Fetch the type representing a 64-bit integer.
388 IntegerType *getInt64Ty() {
389 return Type::getInt64Ty(Context);
390 }
391
392 /// Fetch the type representing a 128-bit integer.
393 IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
394
395 /// Fetch the type representing an N-bit integer.
396 IntegerType *getIntNTy(unsigned N) {
397 return Type::getIntNTy(Context, N);
398 }
399
400 /// Fetch the type representing a 16-bit floating point value.
401 Type *getHalfTy() {
402 return Type::getHalfTy(Context);
403 }
404
405 /// Fetch the type representing a 32-bit floating point value.
406 Type *getFloatTy() {
407 return Type::getFloatTy(Context);
408 }
409
410 /// Fetch the type representing a 64-bit floating point value.
411 Type *getDoubleTy() {
412 return Type::getDoubleTy(Context);
413 }
414
415 /// Fetch the type representing void.
416 Type *getVoidTy() {
417 return Type::getVoidTy(Context);
418 }
419
420 /// Fetch the type representing a pointer to an 8-bit integer value.
421 PointerType *getInt8PtrTy(unsigned AddrSpace = 0) {
422 return Type::getInt8PtrTy(Context, AddrSpace);
423 }
424
425 /// Fetch the type representing a pointer to an integer value.
426 IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
427 return DL.getIntPtrType(Context, AddrSpace);
428 }
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 MDNode *NoAliasTag = nullptr) {
444 return CreateMemSet(Ptr, Val, getInt64(Size), Align, isVolatile,
445 TBAATag, ScopeTag, NoAliasTag);
446 }
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 MDNode *NoAliasTag = nullptr) {
465 return CreateElementUnorderedAtomicMemSet(Ptr, Val, getInt64(Size), Align,
466 ElementSize, TBAATag, ScopeTag,
467 NoAliasTag);
468 }
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 MDNode *NoAliasTag = nullptr) {
488 return CreateMemCpy(Dst, DstAlign, Src, SrcAlign, getInt64(Size),
489 isVolatile, TBAATag, TBAAStructTag, ScopeTag,
490 NoAliasTag);
491 }
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 MDNode *NoAliasTag = nullptr) {
513 return CreateElementUnorderedAtomicMemCpy(
514 Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
515 TBAAStructTag, ScopeTag, NoAliasTag);
516 }
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 MDNode *NoAliasTag = nullptr) {
534 return CreateMemMove(Dst, DstAlign, Src, SrcAlign, getInt64(Size), isVolatile,
535 TBAATag, ScopeTag, NoAliasTag);
536 }
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 MDNode *NoAliasTag = nullptr) {
557 return CreateElementUnorderedAtomicMemMove(
558 Dst, DstAlign, Src, SrcAlign, getInt64(Size), ElementSize, TBAATag,
559 TBAAStructTag, ScopeTag, NoAliasTag);
560 }
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 CallInst *CreateMinNum(Value *LHS, Value *RHS, const Twine &Name = "") {
736 return CreateBinaryIntrinsic(Intrinsic::minnum, LHS, RHS, nullptr, Name);
737 }
738
739 /// Create call to the maxnum intrinsic.
740 CallInst *CreateMaxNum(Value *LHS, Value *RHS, const Twine &Name = "") {
741 return CreateBinaryIntrinsic(Intrinsic::maxnum, LHS, RHS, nullptr, Name);
742 }
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
754private:
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.
777template <typename T = ConstantFolder,
778 typename Inserter = IRBuilderDefaultInserter>
779class IRBuilder : public IRBuilderBase, public Inserter {
780 T Folder;
781
782public:
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 Folder(F) {}
788
789 explicit IRBuilder(LLVMContext &C, MDNode *FPMathTag = nullptr,
790 ArrayRef<OperandBundleDef> OpBundles = None)
791 : 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 : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
802 SetInsertPoint(TheBB);
803 }
804
805 explicit IRBuilder(Instruction *IP, MDNode *FPMathTag = nullptr,
806 ArrayRef<OperandBundleDef> OpBundles = None)
807 : IRBuilderBase(IP->getContext(), FPMathTag, OpBundles) {
808 SetInsertPoint(IP);
809 }
810
811 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP, const T &F,
812 MDNode *FPMathTag = nullptr,
813 ArrayRef<OperandBundleDef> OpBundles = None)
814 : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles), Folder(F) {
815 SetInsertPoint(TheBB, IP);
816 }
817
818 IRBuilder(BasicBlock *TheBB, BasicBlock::iterator IP,
819 MDNode *FPMathTag = nullptr,
820 ArrayRef<OperandBundleDef> OpBundles = None)
821 : IRBuilderBase(TheBB->getContext(), FPMathTag, OpBundles) {
822 SetInsertPoint(TheBB, IP);
823 }
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 InstTy *Insert(InstTy *I, const Twine &Name = "") const {
831 this->InsertHelper(I, Name, BB, InsertPt);
832 this->SetInstDebugLocation(I);
833 return I;
834 }
835
836 /// No-op overload to handle constants.
837 Constant *Insert(Constant *C, const Twine& = "") const {
838 return C;
839 }
840
841 //===--------------------------------------------------------------------===//
842 // Instruction creation methods: Terminators
843 //===--------------------------------------------------------------------===//
844
845private:
846 /// Helper to add branch weight and unpredictable metadata onto an
847 /// instruction.
848 /// \returns The annotated instruction.
849 template <typename InstTy>
850 InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
851 if (Weights)
852 I->setMetadata(LLVMContext::MD_prof, Weights);
853 if (Unpredictable)
854 I->setMetadata(LLVMContext::MD_unpredictable, Unpredictable);
855 return I;
856 }
857
858public:
859 /// Create a 'ret void' instruction.
860 ReturnInst *CreateRetVoid() {
861 return Insert(ReturnInst::Create(Context));
862 }
863
864 /// Create a 'ret <val>' instruction.
865 ReturnInst *CreateRet(Value *V) {
866 return Insert(ReturnInst::Create(Context, V));
867 }
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 ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
877 Value *V = UndefValue::get(getCurrentFunctionReturnType());
878 for (unsigned i = 0; i != N; ++i)
879 V = CreateInsertValue(V, retVals[i], i, "mrv");
880 return Insert(ReturnInst::Create(Context, V));
881 }
882
883 /// Create an unconditional 'br label X' instruction.
884 BranchInst *CreateBr(BasicBlock *Dest) {
885 return Insert(BranchInst::Create(Dest));
886 }
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 MDNode *Unpredictable = nullptr) {
893 return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
894 BranchWeights, Unpredictable));
895 }
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 Instruction *MDSrc) {
901 BranchInst *Br = BranchInst::Create(True, False, Cond);
902 if (MDSrc) {
903 unsigned WL[4] = {LLVMContext::MD_prof, LLVMContext::MD_unpredictable,
904 LLVMContext::MD_make_implicit, LLVMContext::MD_dbg};
905 Br->copyMetadata(*MDSrc, makeArrayRef(&WL[0], 4));
906 }
907 return Insert(Br);
908 }
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 MDNode *Unpredictable = nullptr) {
916 return Insert(addBranchMetadata(SwitchInst::Create(V, Dest, NumCases),
917 BranchWeights, Unpredictable));
918 }
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 IndirectBrInst *CreateIndirectBr(Value *Addr, unsigned NumDests = 10) {
924 return Insert(IndirectBrInst::Create(Addr, NumDests));
925 }
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 const Twine &Name = "") {
933 return Insert(
934 InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args, OpBundles),
935 Name);
936 }
937 InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
938 BasicBlock *NormalDest, BasicBlock *UnwindDest,
939 ArrayRef<Value *> Args = None,
940 const Twine &Name = "") {
941 return Insert(InvokeInst::Create(Ty, Callee, NormalDest, UnwindDest, Args),
942 Name);
943 }
944
945 InvokeInst *CreateInvoke(FunctionCallee Callee, BasicBlock *NormalDest,
946 BasicBlock *UnwindDest, ArrayRef<Value *> Args,
947 ArrayRef<OperandBundleDef> OpBundles,
948 const Twine &Name = "") {
949 return CreateInvoke(Callee.getFunctionType(), Callee.getCallee(),
950 NormalDest, UnwindDest, Args, OpBundles, Name);
951 }
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 const Twine &Name = "") {
966 return CreateInvoke(
967 cast<FunctionType>(
968 cast<PointerType>(Callee->getType())->getElementType()),
969 Callee, NormalDest, UnwindDest, Args, OpBundles, Name);
970 }
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 const Twine &Name = "") {
989 return Insert(CallBrInst::Create(Ty, Callee, DefaultDest, IndirectDests,
990 Args), Name);
991 }
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 const Twine &Name = "") {
1007 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1008 DefaultDest, IndirectDests, Args, Name);
1009 }
1010 CallBrInst *CreateCallBr(FunctionCallee Callee, BasicBlock *DefaultDest,
1011 ArrayRef<BasicBlock *> IndirectDests,
1012 ArrayRef<Value *> Args,
1013 ArrayRef<OperandBundleDef> OpBundles,
1014 const Twine &Name = "") {
1015 return CreateCallBr(Callee.getFunctionType(), Callee.getCallee(),
1016 DefaultDest, IndirectDests, Args, Name);
1017 }
1018
1019 ResumeInst *CreateResume(Value *Exn) {
1020 return Insert(ResumeInst::Create(Exn));
1021 }
1022
1023 CleanupReturnInst *CreateCleanupRet(CleanupPadInst *CleanupPad,
1024 BasicBlock *UnwindBB = nullptr) {
1025 return Insert(CleanupReturnInst::Create(CleanupPad, UnwindBB));
1026 }
1027
1028 CatchSwitchInst *CreateCatchSwitch(Value *ParentPad, BasicBlock *UnwindBB,
1029 unsigned NumHandlers,
1030 const Twine &Name = "") {
1031 return Insert(CatchSwitchInst::Create(ParentPad, UnwindBB, NumHandlers),
1032 Name);
1033 }
1034
1035 CatchPadInst *CreateCatchPad(Value *ParentPad, ArrayRef<Value *> Args,
1036 const Twine &Name = "") {
1037 return Insert(CatchPadInst::Create(ParentPad, Args), Name);
1038 }
1039
1040 CleanupPadInst *CreateCleanupPad(Value *ParentPad,
1041 ArrayRef<Value *> Args = None,
1042 const Twine &Name = "") {
1043 return Insert(CleanupPadInst::Create(ParentPad, Args), Name);
1044 }
1045
1046 CatchReturnInst *CreateCatchRet(CatchPadInst *CatchPad, BasicBlock *BB) {
1047 return Insert(CatchReturnInst::Create(CatchPad, BB));
1048 }
1049
1050 UnreachableInst *CreateUnreachable() {
1051 return Insert(new UnreachableInst(Context));
1052 }
1053
1054 //===--------------------------------------------------------------------===//
1055 // Instruction creation methods: Binary Operators
1056 //===--------------------------------------------------------------------===//
1057private:
1058 BinaryOperator *CreateInsertNUWNSWBinOp(BinaryOperator::BinaryOps Opc,
1059 Value *LHS, Value *RHS,
1060 const Twine &Name,
1061 bool HasNUW, bool HasNSW) {
1062 BinaryOperator *BO = Insert(BinaryOperator::Create(Opc, LHS, RHS), Name);
1063 if (HasNUW) BO->setHasNoUnsignedWrap();
1064 if (HasNSW) BO->setHasNoSignedWrap();
1065 return BO;
1066 }
1067
1068 Instruction *setFPAttrs(Instruction *I, MDNode *FPMD,
1069 FastMathFlags FMF) const {
1070 if (!FPMD)
1071 FPMD = DefaultFPMathTag;
1072 if (FPMD)
1073 I->setMetadata(LLVMContext::MD_fpmath, FPMD);
1074 I->setFastMathFlags(FMF);
1075 return I;
1076 }
1077
1078 Value *foldConstant(Instruction::BinaryOps Opc, Value *L,
1079 Value *R, const Twine &Name) const {
1080 auto *LC = dyn_cast<Constant>(L);
1081 auto *RC = dyn_cast<Constant>(R);
1082 return (LC && RC) ? Insert(Folder.CreateBinOp(Opc, LC, RC), Name) : nullptr;
1083 }
1084
1085 Value *getConstrainedFPRounding(
1086 Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding) {
1087 ConstrainedFPIntrinsic::RoundingMode UseRounding =
1088 DefaultConstrainedRounding;
1089
1090 if (Rounding.hasValue())
1091 UseRounding = Rounding.getValue();
1092
1093 Optional<StringRef> RoundingStr =
1094 ConstrainedFPIntrinsic::RoundingModeToStr(UseRounding);
1095 assert(RoundingStr.hasValue() && "Garbage strict rounding mode!")((RoundingStr.hasValue() && "Garbage strict rounding mode!"
) ? static_cast<void> (0) : __assert_fail ("RoundingStr.hasValue() && \"Garbage strict rounding mode!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1095, __PRETTY_FUNCTION__))
;
1096 auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue());
1097
1098 return MetadataAsValue::get(Context, RoundingMDS);
1099 }
1100
1101 Value *getConstrainedFPExcept(
1102 Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except) {
1103 ConstrainedFPIntrinsic::ExceptionBehavior UseExcept =
1104 DefaultConstrainedExcept;
1105
1106 if (Except.hasValue())
1107 UseExcept = Except.getValue();
1108
1109 Optional<StringRef> ExceptStr =
1110 ConstrainedFPIntrinsic::ExceptionBehaviorToStr(UseExcept);
1111 assert(ExceptStr.hasValue() && "Garbage strict exception behavior!")((ExceptStr.hasValue() && "Garbage strict exception behavior!"
) ? static_cast<void> (0) : __assert_fail ("ExceptStr.hasValue() && \"Garbage strict exception behavior!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1111, __PRETTY_FUNCTION__))
;
1112 auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue());
1113
1114 return MetadataAsValue::get(Context, ExceptMDS);
1115 }
1116
1117public:
1118 Value *CreateAdd(Value *LHS, Value *RHS, const Twine &Name = "",
1119 bool HasNUW = false, bool HasNSW = false) {
1120 if (auto *LC = dyn_cast<Constant>(LHS))
1121 if (auto *RC = dyn_cast<Constant>(RHS))
1122 return Insert(Folder.CreateAdd(LC, RC, HasNUW, HasNSW), Name);
1123 return CreateInsertNUWNSWBinOp(Instruction::Add, LHS, RHS, Name,
1124 HasNUW, HasNSW);
1125 }
1126
1127 Value *CreateNSWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1128 return CreateAdd(LHS, RHS, Name, false, true);
1129 }
1130
1131 Value *CreateNUWAdd(Value *LHS, Value *RHS, const Twine &Name = "") {
1132 return CreateAdd(LHS, RHS, Name, true, false);
1133 }
1134
1135 Value *CreateSub(Value *LHS, Value *RHS, const Twine &Name = "",
1136 bool HasNUW = false, bool HasNSW = false) {
1137 if (auto *LC = dyn_cast<Constant>(LHS))
1138 if (auto *RC = dyn_cast<Constant>(RHS))
1139 return Insert(Folder.CreateSub(LC, RC, HasNUW, HasNSW), Name);
1140 return CreateInsertNUWNSWBinOp(Instruction::Sub, LHS, RHS, Name,
1141 HasNUW, HasNSW);
1142 }
1143
1144 Value *CreateNSWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1145 return CreateSub(LHS, RHS, Name, false, true);
1146 }
1147
1148 Value *CreateNUWSub(Value *LHS, Value *RHS, const Twine &Name = "") {
1149 return CreateSub(LHS, RHS, Name, true, false);
1150 }
1151
1152 Value *CreateMul(Value *LHS, Value *RHS, const Twine &Name = "",
1153 bool HasNUW = false, bool HasNSW = false) {
1154 if (auto *LC = dyn_cast<Constant>(LHS))
1155 if (auto *RC = dyn_cast<Constant>(RHS))
1156 return Insert(Folder.CreateMul(LC, RC, HasNUW, HasNSW), Name);
1157 return CreateInsertNUWNSWBinOp(Instruction::Mul, LHS, RHS, Name,
1158 HasNUW, HasNSW);
1159 }
1160
1161 Value *CreateNSWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1162 return CreateMul(LHS, RHS, Name, false, true);
1163 }
1164
1165 Value *CreateNUWMul(Value *LHS, Value *RHS, const Twine &Name = "") {
1166 return CreateMul(LHS, RHS, Name, true, false);
1167 }
1168
1169 Value *CreateUDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1170 bool isExact = false) {
1171 if (auto *LC = dyn_cast<Constant>(LHS))
1172 if (auto *RC = dyn_cast<Constant>(RHS))
1173 return Insert(Folder.CreateUDiv(LC, RC, isExact), Name);
1174 if (!isExact)
1175 return Insert(BinaryOperator::CreateUDiv(LHS, RHS), Name);
1176 return Insert(BinaryOperator::CreateExactUDiv(LHS, RHS), Name);
1177 }
1178
1179 Value *CreateExactUDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1180 return CreateUDiv(LHS, RHS, Name, true);
1181 }
1182
1183 Value *CreateSDiv(Value *LHS, Value *RHS, const Twine &Name = "",
1184 bool isExact = false) {
1185 if (auto *LC = dyn_cast<Constant>(LHS))
1186 if (auto *RC = dyn_cast<Constant>(RHS))
1187 return Insert(Folder.CreateSDiv(LC, RC, isExact), Name);
1188 if (!isExact)
1189 return Insert(BinaryOperator::CreateSDiv(LHS, RHS), Name);
1190 return Insert(BinaryOperator::CreateExactSDiv(LHS, RHS), Name);
1191 }
1192
1193 Value *CreateExactSDiv(Value *LHS, Value *RHS, const Twine &Name = "") {
1194 return CreateSDiv(LHS, RHS, Name, true);
1195 }
1196
1197 Value *CreateURem(Value *LHS, Value *RHS, const Twine &Name = "") {
1198 if (Value *V = foldConstant(Instruction::URem, LHS, RHS, Name)) return V;
1199 return Insert(BinaryOperator::CreateURem(LHS, RHS), Name);
1200 }
1201
1202 Value *CreateSRem(Value *LHS, Value *RHS, const Twine &Name = "") {
1203 if (Value *V = foldConstant(Instruction::SRem, LHS, RHS, Name)) return V;
1204 return Insert(BinaryOperator::CreateSRem(LHS, RHS), Name);
1205 }
1206
1207 Value *CreateShl(Value *LHS, Value *RHS, const Twine &Name = "",
1208 bool HasNUW = false, bool HasNSW = false) {
1209 if (auto *LC = dyn_cast<Constant>(LHS))
1210 if (auto *RC = dyn_cast<Constant>(RHS))
1211 return Insert(Folder.CreateShl(LC, RC, HasNUW, HasNSW), Name);
1212 return CreateInsertNUWNSWBinOp(Instruction::Shl, LHS, RHS, Name,
1213 HasNUW, HasNSW);
1214 }
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 bool HasNUW = false, bool HasNSW = false) {
1224 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1225 HasNUW, HasNSW);
1226 }
1227
1228 Value *CreateLShr(Value *LHS, Value *RHS, const Twine &Name = "",
1229 bool isExact = false) {
1230 if (auto *LC = dyn_cast<Constant>(LHS))
1231 if (auto *RC = dyn_cast<Constant>(RHS))
1232 return Insert(Folder.CreateLShr(LC, RC, isExact), Name);
1233 if (!isExact)
1234 return Insert(BinaryOperator::CreateLShr(LHS, RHS), Name);
1235 return Insert(BinaryOperator::CreateExactLShr(LHS, RHS), Name);
1236 }
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 bool isExact = false) {
1245 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1246 }
1247
1248 Value *CreateAShr(Value *LHS, Value *RHS, const Twine &Name = "",
1249 bool isExact = false) {
1250 if (auto *LC = dyn_cast<Constant>(LHS))
1251 if (auto *RC = dyn_cast<Constant>(RHS))
1252 return Insert(Folder.CreateAShr(LC, RC, isExact), Name);
1253 if (!isExact)
1254 return Insert(BinaryOperator::CreateAShr(LHS, RHS), Name);
1255 return Insert(BinaryOperator::CreateExactAShr(LHS, RHS), Name);
1256 }
1257
1258 Value *CreateAShr(Value *LHS, const APInt &RHS, const Twine &Name = "",
1259 bool isExact = false) {
1260 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1261 }
1262
1263 Value *CreateAShr(Value *LHS, uint64_t RHS, const Twine &Name = "",
1264 bool isExact = false) {
1265 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1266 }
1267
1268 Value *CreateAnd(Value *LHS, Value *RHS, const Twine &Name = "") {
1269 if (auto *RC = dyn_cast<Constant>(RHS)) {
1270 if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1271 return LHS; // LHS & -1 -> LHS
1272 if (auto *LC = dyn_cast<Constant>(LHS))
1273 return Insert(Folder.CreateAnd(LC, RC), Name);
1274 }
1275 return Insert(BinaryOperator::CreateAnd(LHS, RHS), Name);
1276 }
1277
1278 Value *CreateAnd(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1279 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1280 }
1281
1282 Value *CreateAnd(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1283 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1284 }
1285
1286 Value *CreateAnd(ArrayRef<Value*> Ops) {
1287 assert(!Ops.empty())((!Ops.empty()) ? static_cast<void> (0) : __assert_fail
("!Ops.empty()", "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1287, __PRETTY_FUNCTION__))
;
1288 Value *Accum = Ops[0];
1289 for (unsigned i = 1; i < Ops.size(); i++)
1290 Accum = CreateAnd(Accum, Ops[i]);
1291 return Accum;
1292 }
1293
1294 Value *CreateOr(Value *LHS, Value *RHS, const Twine &Name = "") {
1295 if (auto *RC = dyn_cast<Constant>(RHS)) {
1296 if (RC->isNullValue())
1297 return LHS; // LHS | 0 -> LHS
1298 if (auto *LC = dyn_cast<Constant>(LHS))
1299 return Insert(Folder.CreateOr(LC, RC), Name);
1300 }
1301 return Insert(BinaryOperator::CreateOr(LHS, RHS), Name);
1302 }
1303
1304 Value *CreateOr(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1305 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1306 }
1307
1308 Value *CreateOr(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1309 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1310 }
1311
1312 Value *CreateOr(ArrayRef<Value*> Ops) {
1313 assert(!Ops.empty())((!Ops.empty()) ? static_cast<void> (0) : __assert_fail
("!Ops.empty()", "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1313, __PRETTY_FUNCTION__))
;
1314 Value *Accum = Ops[0];
1315 for (unsigned i = 1; i < Ops.size(); i++)
1316 Accum = CreateOr(Accum, Ops[i]);
1317 return Accum;
1318 }
1319
1320 Value *CreateXor(Value *LHS, Value *RHS, const Twine &Name = "") {
1321 if (Value *V = foldConstant(Instruction::Xor, LHS, RHS, Name)) return V;
1322 return Insert(BinaryOperator::CreateXor(LHS, RHS), Name);
1323 }
1324
1325 Value *CreateXor(Value *LHS, const APInt &RHS, const Twine &Name = "") {
1326 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1327 }
1328
1329 Value *CreateXor(Value *LHS, uint64_t RHS, const Twine &Name = "") {
1330 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1331 }
1332
1333 Value *CreateFAdd(Value *L, Value *R, const Twine &Name = "",
1334 MDNode *FPMD = nullptr) {
1335 if (IsFPConstrained)
1336 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1337 L, R, nullptr, Name, FPMD);
1338
1339 if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
1340 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), FPMD, FMF);
1341 return Insert(I, Name);
1342 }
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 const Twine &Name = "") {
1348 if (IsFPConstrained)
1349 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fadd,
1350 L, R, FMFSource, Name);
1351
1352 if (Value *V = foldConstant(Instruction::FAdd, L, R, Name)) return V;
1353 Instruction *I = setFPAttrs(BinaryOperator::CreateFAdd(L, R), nullptr,
1354 FMFSource->getFastMathFlags());
1355 return Insert(I, Name);
1356 }
1357
1358 Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
1359 MDNode *FPMD = nullptr) {
1360 if (IsFPConstrained)
1361 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1362 L, R, nullptr, Name, FPMD);
1363
1364 if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
1365 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), FPMD, FMF);
1366 return Insert(I, Name);
1367 }
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 const Twine &Name = "") {
1373 if (IsFPConstrained)
1374 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
1375 L, R, FMFSource, Name);
1376
1377 if (Value *V = foldConstant(Instruction::FSub, L, R, Name)) return V;
1378 Instruction *I = setFPAttrs(BinaryOperator::CreateFSub(L, R), nullptr,
1379 FMFSource->getFastMathFlags());
1380 return Insert(I, Name);
1381 }
1382
1383 Value *CreateFMul(Value *L, Value *R, const Twine &Name = "",
1384 MDNode *FPMD = nullptr) {
1385 if (IsFPConstrained)
1386 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1387 L, R, nullptr, Name, FPMD);
1388
1389 if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
1390 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), FPMD, FMF);
1391 return Insert(I, Name);
1392 }
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 const Twine &Name = "") {
1398 if (IsFPConstrained)
1399 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fmul,
1400 L, R, FMFSource, Name);
1401
1402 if (Value *V = foldConstant(Instruction::FMul, L, R, Name)) return V;
1403 Instruction *I = setFPAttrs(BinaryOperator::CreateFMul(L, R), nullptr,
1404 FMFSource->getFastMathFlags());
1405 return Insert(I, Name);
1406 }
1407
1408 Value *CreateFDiv(Value *L, Value *R, const Twine &Name = "",
1409 MDNode *FPMD = nullptr) {
1410 if (IsFPConstrained)
1411 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fdiv,
1412 L, R, nullptr, Name, FPMD);
1413
1414 if (Value *V = foldConstant(Instruction::FDiv, L, R, Name)) return V;
1415 Instruction *I = setFPAttrs(BinaryOperator::CreateFDiv(L, R), FPMD, FMF);
1416 return Insert(I, Name);
1417 }
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 MDNode *FPMD = nullptr) {
1435 if (IsFPConstrained)
1436 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1437 L, R, nullptr, Name, FPMD);
1438
1439 if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1440 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), FPMD, FMF);
1441 return Insert(I, Name);
1442 }
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 const Twine &Name = "") {
1448 if (IsFPConstrained)
1449 return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_frem,
1450 L, R, FMFSource, Name);
1451
1452 if (Value *V = foldConstant(Instruction::FRem, L, R, Name)) return V;
1453 Instruction *I = setFPAttrs(BinaryOperator::CreateFRem(L, R), nullptr,
1454 FMFSource->getFastMathFlags());
1455 return Insert(I, Name);
1456 }
1457
1458 Value *CreateBinOp(Instruction::BinaryOps Opc,
1459 Value *LHS, Value *RHS, const Twine &Name = "",
1460 MDNode *FPMathTag = nullptr) {
1461 if (Value *V = foldConstant(Opc, LHS, RHS, Name)) return V;
1462 Instruction *BinOp = BinaryOperator::Create(Opc, LHS, RHS);
1463 if (isa<FPMathOperator>(BinOp))
1464 BinOp = setFPAttrs(BinOp, FPMathTag, FMF);
1465 return Insert(BinOp, Name);
1466 }
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 Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
1473 Value *RoundingV = getConstrainedFPRounding(Rounding);
1474 Value *ExceptV = getConstrainedFPExcept(Except);
1475
1476 FastMathFlags UseFMF = FMF;
1477 if (FMFSource)
1478 UseFMF = FMFSource->getFastMathFlags();
1479
1480 CallInst *C = CreateIntrinsic(ID, {L->getType()},
1481 {L, R, RoundingV, ExceptV}, nullptr, Name);
1482 return cast<CallInst>(setFPAttrs(C, FPMathTag, UseFMF));
1483 }
1484
1485 Value *CreateNeg(Value *V, const Twine &Name = "",
1486 bool HasNUW = false, bool HasNSW = false) {
1487 if (auto *VC = dyn_cast<Constant>(V))
1488 return Insert(Folder.CreateNeg(VC, HasNUW, HasNSW), Name);
1489 BinaryOperator *BO = Insert(BinaryOperator::CreateNeg(V), Name);
1490 if (HasNUW) BO->setHasNoUnsignedWrap();
1491 if (HasNSW) BO->setHasNoSignedWrap();
1492 return BO;
1493 }
1494
1495 Value *CreateNSWNeg(Value *V, const Twine &Name = "") {
1496 return CreateNeg(V, Name, false, true);
1497 }
1498
1499 Value *CreateNUWNeg(Value *V, const Twine &Name = "") {
1500 return CreateNeg(V, Name, true, false);
1501 }
1502
1503 Value *CreateFNeg(Value *V, const Twine &Name = "",
1504 MDNode *FPMathTag = nullptr) {
1505 if (auto *VC = dyn_cast<Constant>(V))
1506 return Insert(Folder.CreateFNeg(VC), Name);
1507 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), FPMathTag, FMF),
1508 Name);
1509 }
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 return Insert(setFPAttrs(UnaryOperator::CreateFNeg(V), nullptr,
1518 FMFSource->getFastMathFlags()),
1519 Name);
1520 }
1521
1522 Value *CreateNot(Value *V, const Twine &Name = "") {
1523 if (auto *VC = dyn_cast<Constant>(V))
1524 return Insert(Folder.CreateNot(VC), Name);
1525 return Insert(BinaryOperator::CreateNot(V), Name);
1526 }
1527
1528 Value *CreateUnOp(Instruction::UnaryOps Opc,
1529 Value *V, const Twine &Name = "",
1530 MDNode *FPMathTag = nullptr) {
1531 if (auto *VC = dyn_cast<Constant>(V))
1532 return Insert(Folder.CreateUnOp(Opc, VC), Name);
1533 Instruction *UnOp = UnaryOperator::Create(Opc, V);
1534 if (isa<FPMathOperator>(UnOp))
1535 UnOp = setFPAttrs(UnOp, FPMathTag, FMF);
1536 return Insert(UnOp, Name);
1537 }
1538
1539 /// Create either a UnaryOperator or BinaryOperator depending on \p Opc.
1540 /// Correct number of operands must be passed accordingly.
1541 Value *CreateNAryOp(unsigned Opc, ArrayRef<Value *> Ops,
1542 const Twine &Name = "",
1543 MDNode *FPMathTag = nullptr) {
1544 if (Instruction::isBinaryOp(Opc)) {
1545 assert(Ops.size() == 2 && "Invalid number of operands!")((Ops.size() == 2 && "Invalid number of operands!") ?
static_cast<void> (0) : __assert_fail ("Ops.size() == 2 && \"Invalid number of operands!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1545, __PRETTY_FUNCTION__))
;
1546 return CreateBinOp(static_cast<Instruction::BinaryOps>(Opc),
1547 Ops[0], Ops[1], Name, FPMathTag);
1548 }
1549 if (Instruction::isUnaryOp(Opc)) {
1550 assert(Ops.size() == 1 && "Invalid number of operands!")((Ops.size() == 1 && "Invalid number of operands!") ?
static_cast<void> (0) : __assert_fail ("Ops.size() == 1 && \"Invalid number of operands!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1550, __PRETTY_FUNCTION__))
;
1551 return CreateUnOp(static_cast<Instruction::UnaryOps>(Opc),
1552 Ops[0], Name, FPMathTag);
1553 }
1554 llvm_unreachable("Unexpected opcode!")::llvm::llvm_unreachable_internal("Unexpected opcode!", "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1554)
;
1555 }
1556
1557 //===--------------------------------------------------------------------===//
1558 // Instruction creation methods: Memory Instructions
1559 //===--------------------------------------------------------------------===//
1560
1561 AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1562 Value *ArraySize = nullptr, const Twine &Name = "") {
1563 return Insert(new AllocaInst(Ty, AddrSpace, ArraySize), Name);
1564 }
1565
1566 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1567 const Twine &Name = "") {
1568 const DataLayout &DL = BB->getParent()->getParent()->getDataLayout();
1569 return Insert(new AllocaInst(Ty, DL.getAllocaAddrSpace(), ArraySize), Name);
1570 }
1571
1572 /// Provided to resolve 'CreateLoad(Ty, Ptr, "...")' correctly, instead of
1573 /// converting the string to 'bool' for the isVolatile parameter.
1574 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1575 return Insert(new LoadInst(Ty, Ptr), Name);
1576 }
1577
1578 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1579 return Insert(new LoadInst(Ty, Ptr), Name);
1580 }
1581
1582 LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1583 const Twine &Name = "") {
1584 return Insert(new LoadInst(Ty, Ptr, Twine(), isVolatile), Name);
1585 }
1586
1587 // Deprecated [opaque pointer types]
1588 LoadInst *CreateLoad(Value *Ptr, const char *Name) {
1589 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1590 }
1591
1592 // Deprecated [opaque pointer types]
1593 LoadInst *CreateLoad(Value *Ptr, const Twine &Name = "") {
1594 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
1595 }
1596
1597 // Deprecated [opaque pointer types]
1598 LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const Twine &Name = "") {
1599 return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, isVolatile,
1600 Name);
1601 }
1602
1603 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
1604 return Insert(new StoreInst(Val, Ptr, isVolatile));
1605 }
1606
1607 /// Provided to resolve 'CreateAlignedLoad(Ptr, Align, "...")'
1608 /// correctly, instead of converting the string to 'bool' for the isVolatile
1609 /// parameter.
1610 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1611 const char *Name) {
1612 LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1613 LI->setAlignment(MaybeAlign(Align));
1614 return LI;
1615 }
1616 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1617 const Twine &Name = "") {
1618 LoadInst *LI = CreateLoad(Ty, Ptr, Name);
1619 LI->setAlignment(MaybeAlign(Align));
1620 return LI;
1621 }
1622 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1623 bool isVolatile, const Twine &Name = "") {
1624 LoadInst *LI = CreateLoad(Ty, Ptr, isVolatile, Name);
1625 LI->setAlignment(MaybeAlign(Align));
1626 return LI;
1627 }
1628
1629 // Deprecated [opaque pointer types]
1630 LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, const char *Name) {
1631 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1632 Align, Name);
1633 }
1634 // Deprecated [opaque pointer types]
1635 LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align,
1636 const Twine &Name = "") {
1637 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1638 Align, Name);
1639 }
1640 // Deprecated [opaque pointer types]
1641 LoadInst *CreateAlignedLoad(Value *Ptr, unsigned Align, bool isVolatile,
1642 const Twine &Name = "") {
1643 return CreateAlignedLoad(Ptr->getType()->getPointerElementType(), Ptr,
1644 Align, isVolatile, Name);
1645 }
1646
1647 StoreInst *CreateAlignedStore(Value *Val, Value *Ptr, unsigned Align,
1648 bool isVolatile = false) {
1649 StoreInst *SI = CreateStore(Val, Ptr, isVolatile);
1650 SI->setAlignment(MaybeAlign(Align));
1651 return SI;
1652 }
1653
1654 FenceInst *CreateFence(AtomicOrdering Ordering,
1655 SyncScope::ID SSID = SyncScope::System,
1656 const Twine &Name = "") {
1657 return Insert(new FenceInst(Context, Ordering, SSID), Name);
1658 }
1659
1660 AtomicCmpXchgInst *
1661 CreateAtomicCmpXchg(Value *Ptr, Value *Cmp, Value *New,
1662 AtomicOrdering SuccessOrdering,
1663 AtomicOrdering FailureOrdering,
1664 SyncScope::ID SSID = SyncScope::System) {
1665 return Insert(new AtomicCmpXchgInst(Ptr, Cmp, New, SuccessOrdering,
1666 FailureOrdering, SSID));
1667 }
1668
1669 AtomicRMWInst *CreateAtomicRMW(AtomicRMWInst::BinOp Op, Value *Ptr, Value *Val,
1670 AtomicOrdering Ordering,
1671 SyncScope::ID SSID = SyncScope::System) {
1672 return Insert(new AtomicRMWInst(Op, Ptr, Val, Ordering, SSID));
1673 }
1674
1675 Value *CreateGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1676 const Twine &Name = "") {
1677 return CreateGEP(nullptr, Ptr, IdxList, Name);
1678 }
1679
1680 Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1681 const Twine &Name = "") {
1682 if (auto *PC = dyn_cast<Constant>(Ptr)) {
1683 // Every index must be constant.
1684 size_t i, e;
1685 for (i = 0, e = IdxList.size(); i != e; ++i)
1686 if (!isa<Constant>(IdxList[i]))
1687 break;
1688 if (i == e)
1689 return Insert(Folder.CreateGetElementPtr(Ty, PC, IdxList), Name);
1690 }
1691 return Insert(GetElementPtrInst::Create(Ty, Ptr, IdxList), Name);
1692 }
1693
1694 Value *CreateInBoundsGEP(Value *Ptr, ArrayRef<Value *> IdxList,
1695 const Twine &Name = "") {
1696 return CreateInBoundsGEP(nullptr, Ptr, IdxList, Name);
1697 }
1698
1699 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1700 const Twine &Name = "") {
1701 if (auto *PC = dyn_cast<Constant>(Ptr)) {
1702 // Every index must be constant.
1703 size_t i, e;
1704 for (i = 0, e = IdxList.size(); i != e; ++i)
1705 if (!isa<Constant>(IdxList[i]))
1706 break;
1707 if (i == e)
1708 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IdxList),
1709 Name);
1710 }
1711 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, IdxList), Name);
1712 }
1713
1714 Value *CreateGEP(Value *Ptr, Value *Idx, const Twine &Name = "") {
1715 return CreateGEP(nullptr, Ptr, Idx, Name);
1716 }
1717
1718 Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1719 if (auto *PC
30.1
'PC' is non-null
30.1
'PC' is non-null
= dyn_cast<Constant>(Ptr))
30
Assuming 'Ptr' is a 'Constant'
31
Taking true branch
1720 if (auto *IC
32.1
'IC' is non-null
32.1
'IC' is non-null
= dyn_cast<Constant>(Idx))
32
Assuming 'Idx' is a 'Constant'
33
Taking true branch
1721 return Insert(Folder.CreateGetElementPtr(Ty, PC, IC), Name);
34
Passing value via 1st parameter 'C'
35
Returning pointer
1722 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1723 }
1724
1725 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
1726 const Twine &Name = "") {
1727 if (auto *PC = dyn_cast<Constant>(Ptr))
1728 if (auto *IC = dyn_cast<Constant>(Idx))
1729 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, IC), Name);
1730 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1731 }
1732
1733 Value *CreateConstGEP1_32(Value *Ptr, unsigned Idx0, const Twine &Name = "") {
1734 return CreateConstGEP1_32(nullptr, Ptr, Idx0, Name);
1735 }
1736
1737 Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1738 const Twine &Name = "") {
1739 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1740
1741 if (auto *PC = dyn_cast<Constant>(Ptr))
1742 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1743
1744 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1745 }
1746
1747 Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1748 const Twine &Name = "") {
1749 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1750
1751 if (auto *PC = dyn_cast<Constant>(Ptr))
1752 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1753
1754 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1755 }
1756
1757 Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1758 const Twine &Name = "") {
1759 Value *Idxs[] = {
1760 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1761 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1762 };
1763
1764 if (auto *PC = dyn_cast<Constant>(Ptr))
1765 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1766
1767 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1768 }
1769
1770 Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1771 unsigned Idx1, const Twine &Name = "") {
1772 Value *Idxs[] = {
1773 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1774 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1775 };
1776
1777 if (auto *PC = dyn_cast<Constant>(Ptr))
1778 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1779
1780 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1781 }
1782
1783 Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1784 const Twine &Name = "") {
1785 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1786
1787 if (auto *PC = dyn_cast<Constant>(Ptr))
1788 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idx), Name);
1789
1790 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idx), Name);
1791 }
1792
1793 Value *CreateConstGEP1_64(Value *Ptr, uint64_t Idx0, const Twine &Name = "") {
1794 return CreateConstGEP1_64(nullptr, Ptr, Idx0, Name);
1795 }
1796
1797 Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1798 const Twine &Name = "") {
1799 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1800
1801 if (auto *PC = dyn_cast<Constant>(Ptr))
1802 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idx), Name);
1803
1804 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idx), Name);
1805 }
1806
1807 Value *CreateConstInBoundsGEP1_64(Value *Ptr, uint64_t Idx0,
1808 const Twine &Name = "") {
1809 return CreateConstInBoundsGEP1_64(nullptr, Ptr, Idx0, Name);
1810 }
1811
1812 Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1813 const Twine &Name = "") {
1814 Value *Idxs[] = {
1815 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1816 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1817 };
1818
1819 if (auto *PC = dyn_cast<Constant>(Ptr))
1820 return Insert(Folder.CreateGetElementPtr(Ty, PC, Idxs), Name);
1821
1822 return Insert(GetElementPtrInst::Create(Ty, Ptr, Idxs), Name);
1823 }
1824
1825 Value *CreateConstGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1826 const Twine &Name = "") {
1827 return CreateConstGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1828 }
1829
1830 Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1831 uint64_t Idx1, const Twine &Name = "") {
1832 Value *Idxs[] = {
1833 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1834 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1835 };
1836
1837 if (auto *PC = dyn_cast<Constant>(Ptr))
1838 return Insert(Folder.CreateInBoundsGetElementPtr(Ty, PC, Idxs), Name);
1839
1840 return Insert(GetElementPtrInst::CreateInBounds(Ty, Ptr, Idxs), Name);
1841 }
1842
1843 Value *CreateConstInBoundsGEP2_64(Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1844 const Twine &Name = "") {
1845 return CreateConstInBoundsGEP2_64(nullptr, Ptr, Idx0, Idx1, Name);
1846 }
1847
1848 Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1849 const Twine &Name = "") {
1850 return CreateConstInBoundsGEP2_32(Ty, Ptr, 0, Idx, Name);
1851 }
1852
1853 Value *CreateStructGEP(Value *Ptr, unsigned Idx, const Twine &Name = "") {
1854 return CreateConstInBoundsGEP2_32(nullptr, Ptr, 0, Idx, Name);
1855 }
1856
1857 /// Same as CreateGlobalString, but return a pointer with "i8*" type
1858 /// instead of a pointer to array of i8.
1859 Constant *CreateGlobalStringPtr(StringRef Str, const Twine &Name = "",
1860 unsigned AddressSpace = 0) {
1861 GlobalVariable *GV = CreateGlobalString(Str, Name, AddressSpace);
1862 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1863 Constant *Indices[] = {Zero, Zero};
1864 return ConstantExpr::getInBoundsGetElementPtr(GV->getValueType(), GV,
1865 Indices);
1866 }
1867
1868 //===--------------------------------------------------------------------===//
1869 // Instruction creation methods: Cast/Conversion Operators
1870 //===--------------------------------------------------------------------===//
1871
1872 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1873 return CreateCast(Instruction::Trunc, V, DestTy, Name);
1874 }
1875
1876 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1877 return CreateCast(Instruction::ZExt, V, DestTy, Name);
1878 }
1879
1880 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
1881 return CreateCast(Instruction::SExt, V, DestTy, Name);
1882 }
1883
1884 /// Create a ZExt or Trunc from the integer value V to DestTy. Return
1885 /// the value untouched if the type of V is already DestTy.
1886 Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
1887 const Twine &Name = "") {
1888 assert(V->getType()->isIntOrIntVectorTy() &&((V->getType()->isIntOrIntVectorTy() && DestTy->
isIntOrIntVectorTy() && "Can only zero extend/truncate integers!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only zero extend/truncate integers!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1890, __PRETTY_FUNCTION__))
1889 DestTy->isIntOrIntVectorTy() &&((V->getType()->isIntOrIntVectorTy() && DestTy->
isIntOrIntVectorTy() && "Can only zero extend/truncate integers!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only zero extend/truncate integers!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1890, __PRETTY_FUNCTION__))
1890 "Can only zero extend/truncate integers!")((V->getType()->isIntOrIntVectorTy() && DestTy->
isIntOrIntVectorTy() && "Can only zero extend/truncate integers!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only zero extend/truncate integers!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1890, __PRETTY_FUNCTION__))
;
1891 Type *VTy = V->getType();
1892 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1893 return CreateZExt(V, DestTy, Name);
1894 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1895 return CreateTrunc(V, DestTy, Name);
1896 return V;
1897 }
1898
1899 /// Create a SExt or Trunc from the integer value V to DestTy. Return
1900 /// the value untouched if the type of V is already DestTy.
1901 Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
1902 const Twine &Name = "") {
1903 assert(V->getType()->isIntOrIntVectorTy() &&((V->getType()->isIntOrIntVectorTy() && DestTy->
isIntOrIntVectorTy() && "Can only sign extend/truncate integers!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only sign extend/truncate integers!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1905, __PRETTY_FUNCTION__))
1904 DestTy->isIntOrIntVectorTy() &&((V->getType()->isIntOrIntVectorTy() && DestTy->
isIntOrIntVectorTy() && "Can only sign extend/truncate integers!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only sign extend/truncate integers!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1905, __PRETTY_FUNCTION__))
1905 "Can only sign extend/truncate integers!")((V->getType()->isIntOrIntVectorTy() && DestTy->
isIntOrIntVectorTy() && "Can only sign extend/truncate integers!"
) ? static_cast<void> (0) : __assert_fail ("V->getType()->isIntOrIntVectorTy() && DestTy->isIntOrIntVectorTy() && \"Can only sign extend/truncate integers!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 1905, __PRETTY_FUNCTION__))
;
1906 Type *VTy = V->getType();
1907 if (VTy->getScalarSizeInBits() < DestTy->getScalarSizeInBits())
1908 return CreateSExt(V, DestTy, Name);
1909 if (VTy->getScalarSizeInBits() > DestTy->getScalarSizeInBits())
1910 return CreateTrunc(V, DestTy, Name);
1911 return V;
1912 }
1913
1914 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
1915 if (IsFPConstrained)
1916 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptoui,
1917 V, DestTy, nullptr, Name);
1918 return CreateCast(Instruction::FPToUI, V, DestTy, Name);
1919 }
1920
1921 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
1922 if (IsFPConstrained)
1923 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fptosi,
1924 V, DestTy, nullptr, Name);
1925 return CreateCast(Instruction::FPToSI, V, DestTy, Name);
1926 }
1927
1928 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1929 return CreateCast(Instruction::UIToFP, V, DestTy, Name);
1930 }
1931
1932 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1933 return CreateCast(Instruction::SIToFP, V, DestTy, Name);
1934 }
1935
1936 Value *CreateFPTrunc(Value *V, Type *DestTy,
1937 const Twine &Name = "") {
1938 if (IsFPConstrained)
1939 return CreateConstrainedFPCast(
1940 Intrinsic::experimental_constrained_fptrunc, V, DestTy, nullptr,
1941 Name);
1942 return CreateCast(Instruction::FPTrunc, V, DestTy, Name);
1943 }
1944
1945 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
1946 if (IsFPConstrained)
1947 return CreateConstrainedFPCast(Intrinsic::experimental_constrained_fpext,
1948 V, DestTy, nullptr, Name);
1949 return CreateCast(Instruction::FPExt, V, DestTy, Name);
1950 }
1951
1952 Value *CreatePtrToInt(Value *V, Type *DestTy,
1953 const Twine &Name = "") {
1954 return CreateCast(Instruction::PtrToInt, V, DestTy, Name);
1955 }
1956
1957 Value *CreateIntToPtr(Value *V, Type *DestTy,
1958 const Twine &Name = "") {
1959 return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
1960 }
1961
1962 Value *CreateBitCast(Value *V, Type *DestTy,
1963 const Twine &Name = "") {
1964 return CreateCast(Instruction::BitCast, V, DestTy, Name);
1965 }
1966
1967 Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
1968 const Twine &Name = "") {
1969 return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
1970 }
1971
1972 Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
1973 const Twine &Name = "") {
1974 if (V->getType() == DestTy)
1975 return V;
1976 if (auto *VC = dyn_cast<Constant>(V))
1977 return Insert(Folder.CreateZExtOrBitCast(VC, DestTy), Name);
1978 return Insert(CastInst::CreateZExtOrBitCast(V, DestTy), Name);
1979 }
1980
1981 Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
1982 const Twine &Name = "") {
1983 if (V->getType() == DestTy)
1984 return V;
1985 if (auto *VC = dyn_cast<Constant>(V))
1986 return Insert(Folder.CreateSExtOrBitCast(VC, DestTy), Name);
1987 return Insert(CastInst::CreateSExtOrBitCast(V, DestTy), Name);
1988 }
1989
1990 Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
1991 const Twine &Name = "") {
1992 if (V->getType() == DestTy)
1993 return V;
1994 if (auto *VC = dyn_cast<Constant>(V))
1995 return Insert(Folder.CreateTruncOrBitCast(VC, DestTy), Name);
1996 return Insert(CastInst::CreateTruncOrBitCast(V, DestTy), Name);
1997 }
1998
1999 Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
2000 const Twine &Name = "") {
2001 if (V->getType() == DestTy)
2002 return V;
2003 if (auto *VC = dyn_cast<Constant>(V))
2004 return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
2005 return Insert(CastInst::Create(Op, V, DestTy), Name);
2006 }
2007
2008 Value *CreatePointerCast(Value *V, Type *DestTy,
2009 const Twine &Name = "") {
2010 if (V->getType() == DestTy)
2011 return V;
2012 if (auto *VC = dyn_cast<Constant>(V))
2013 return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
2014 return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
2015 }
2016
2017 Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
2018 const Twine &Name = "") {
2019 if (V->getType() == DestTy)
2020 return V;
2021
2022 if (auto *VC = dyn_cast<Constant>(V)) {
2023 return Insert(Folder.CreatePointerBitCastOrAddrSpaceCast(VC, DestTy),
2024 Name);
2025 }
2026
2027 return Insert(CastInst::CreatePointerBitCastOrAddrSpaceCast(V, DestTy),
2028 Name);
2029 }
2030
2031 Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
2032 const Twine &Name = "") {
2033 if (V->getType() == DestTy)
2034 return V;
2035 if (auto *VC = dyn_cast<Constant>(V))
2036 return Insert(Folder.CreateIntCast(VC, DestTy, isSigned), Name);
2037 return Insert(CastInst::CreateIntegerCast(V, DestTy, isSigned), Name);
2038 }
2039
2040 Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
2041 const Twine &Name = "") {
2042 if (V->getType() == DestTy)
2043 return V;
2044 if (V->getType()->isPtrOrPtrVectorTy() && DestTy->isIntOrIntVectorTy())
2045 return CreatePtrToInt(V, DestTy, Name);
2046 if (V->getType()->isIntOrIntVectorTy() && DestTy->isPtrOrPtrVectorTy())
2047 return CreateIntToPtr(V, DestTy, Name);
2048
2049 return CreateBitCast(V, DestTy, Name);
2050 }
2051
2052 Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
2053 if (V->getType() == DestTy)
2054 return V;
2055 if (auto *VC = dyn_cast<Constant>(V))
2056 return Insert(Folder.CreateFPCast(VC, DestTy), Name);
2057 return Insert(CastInst::CreateFPCast(V, DestTy), Name);
2058 }
2059
2060 CallInst *CreateConstrainedFPCast(
2061 Intrinsic::ID ID, Value *V, Type *DestTy,
2062 Instruction *FMFSource = nullptr, const Twine &Name = "",
2063 MDNode *FPMathTag = nullptr,
2064 Optional<ConstrainedFPIntrinsic::RoundingMode> Rounding = None,
2065 Optional<ConstrainedFPIntrinsic::ExceptionBehavior> Except = None) {
2066 Value *ExceptV = getConstrainedFPExcept(Except);
2067
2068 FastMathFlags UseFMF = FMF;
2069 if (FMFSource)
2070 UseFMF = FMFSource->getFastMathFlags();
2071
2072 CallInst *C;
2073 switch (ID) {
2074 default: {
2075 Value *RoundingV = getConstrainedFPRounding(Rounding);
2076 C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, RoundingV, ExceptV},
2077 nullptr, Name);
2078 } break;
2079 case Intrinsic::experimental_constrained_fpext:
2080 case Intrinsic::experimental_constrained_fptoui:
2081 case Intrinsic::experimental_constrained_fptosi:
2082 C = CreateIntrinsic(ID, {DestTy, V->getType()}, {V, ExceptV}, nullptr,
2083 Name);
2084 break;
2085 }
2086 if (isa<FPMathOperator>(C))
2087 C = cast<CallInst>(setFPAttrs(C, FPMathTag, UseFMF));
2088 return C;
2089 }
2090
2091 // Provided to resolve 'CreateIntCast(Ptr, Ptr, "...")', giving a
2092 // compile time error, instead of converting the string to bool for the
2093 // isSigned parameter.
2094 Value *CreateIntCast(Value *, Type *, const char *) = delete;
2095
2096 //===--------------------------------------------------------------------===//
2097 // Instruction creation methods: Compare Instructions
2098 //===--------------------------------------------------------------------===//
2099
2100 Value *CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name = "") {
2101 return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
2102 }
2103
2104 Value *CreateICmpNE(Value *LHS, Value *RHS, const Twine &Name = "") {
2105 return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
2106 }
2107
2108 Value *CreateICmpUGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2109 return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
2110 }
2111
2112 Value *CreateICmpUGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2113 return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
2114 }
2115
2116 Value *CreateICmpULT(Value *LHS, Value *RHS, const Twine &Name = "") {
2117 return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
2118 }
2119
2120 Value *CreateICmpULE(Value *LHS, Value *RHS, const Twine &Name = "") {
2121 return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
2122 }
2123
2124 Value *CreateICmpSGT(Value *LHS, Value *RHS, const Twine &Name = "") {
2125 return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
2126 }
2127
2128 Value *CreateICmpSGE(Value *LHS, Value *RHS, const Twine &Name = "") {
2129 return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
2130 }
2131
2132 Value *CreateICmpSLT(Value *LHS, Value *RHS, const Twine &Name = "") {
2133 return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
2134 }
2135
2136 Value *CreateICmpSLE(Value *LHS, Value *RHS, const Twine &Name = "") {
2137 return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
2138 }
2139
2140 Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2141 MDNode *FPMathTag = nullptr) {
2142 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name, FPMathTag);
2143 }
2144
2145 Value *CreateFCmpOGT(Value *LHS, Value *RHS, const Twine &Name = "",
2146 MDNode *FPMathTag = nullptr) {
2147 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name, FPMathTag);
2148 }
2149
2150 Value *CreateFCmpOGE(Value *LHS, Value *RHS, const Twine &Name = "",
2151 MDNode *FPMathTag = nullptr) {
2152 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name, FPMathTag);
2153 }
2154
2155 Value *CreateFCmpOLT(Value *LHS, Value *RHS, const Twine &Name = "",
2156 MDNode *FPMathTag = nullptr) {
2157 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name, FPMathTag);
2158 }
2159
2160 Value *CreateFCmpOLE(Value *LHS, Value *RHS, const Twine &Name = "",
2161 MDNode *FPMathTag = nullptr) {
2162 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name, FPMathTag);
2163 }
2164
2165 Value *CreateFCmpONE(Value *LHS, Value *RHS, const Twine &Name = "",
2166 MDNode *FPMathTag = nullptr) {
2167 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name, FPMathTag);
2168 }
2169
2170 Value *CreateFCmpORD(Value *LHS, Value *RHS, const Twine &Name = "",
2171 MDNode *FPMathTag = nullptr) {
2172 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name, FPMathTag);
2173 }
2174
2175 Value *CreateFCmpUNO(Value *LHS, Value *RHS, const Twine &Name = "",
2176 MDNode *FPMathTag = nullptr) {
2177 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name, FPMathTag);
2178 }
2179
2180 Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const Twine &Name = "",
2181 MDNode *FPMathTag = nullptr) {
2182 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name, FPMathTag);
2183 }
2184
2185 Value *CreateFCmpUGT(Value *LHS, Value *RHS, const Twine &Name = "",
2186 MDNode *FPMathTag = nullptr) {
2187 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name, FPMathTag);
2188 }
2189
2190 Value *CreateFCmpUGE(Value *LHS, Value *RHS, const Twine &Name = "",
2191 MDNode *FPMathTag = nullptr) {
2192 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name, FPMathTag);
2193 }
2194
2195 Value *CreateFCmpULT(Value *LHS, Value *RHS, const Twine &Name = "",
2196 MDNode *FPMathTag = nullptr) {
2197 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name, FPMathTag);
2198 }
2199
2200 Value *CreateFCmpULE(Value *LHS, Value *RHS, const Twine &Name = "",
2201 MDNode *FPMathTag = nullptr) {
2202 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name, FPMathTag);
2203 }
2204
2205 Value *CreateFCmpUNE(Value *LHS, Value *RHS, const Twine &Name = "",
2206 MDNode *FPMathTag = nullptr) {
2207 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name, FPMathTag);
2208 }
2209
2210 Value *CreateICmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
2211 const Twine &Name = "") {
2212 if (auto *LC = dyn_cast<Constant>(LHS))
2213 if (auto *RC = dyn_cast<Constant>(RHS))
2214 return Insert(Folder.CreateICmp(P, LC, RC), Name);
2215 return Insert(new ICmpInst(P, LHS, RHS), Name);
2216 }
2217
2218 Value *CreateFCmp(CmpInst::Predicate P, Value *LHS, Value *RHS,
2219 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2220 if (auto *LC = dyn_cast<Constant>(LHS))
2221 if (auto *RC = dyn_cast<Constant>(RHS))
2222 return Insert(Folder.CreateFCmp(P, LC, RC), Name);
2223 return Insert(setFPAttrs(new FCmpInst(P, LHS, RHS), FPMathTag, FMF), Name);
2224 }
2225
2226 //===--------------------------------------------------------------------===//
2227 // Instruction creation methods: Other Instructions
2228 //===--------------------------------------------------------------------===//
2229
2230 PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
2231 const Twine &Name = "") {
2232 PHINode *Phi = PHINode::Create(Ty, NumReservedValues);
2233 if (isa<FPMathOperator>(Phi))
2234 Phi = cast<PHINode>(setFPAttrs(Phi, nullptr /* MDNode* */, FMF));
2235 return Insert(Phi, Name);
2236 }
2237
2238 CallInst *CreateCall(FunctionType *FTy, Value *Callee,
2239 ArrayRef<Value *> Args = None, const Twine &Name = "",
2240 MDNode *FPMathTag = nullptr) {
2241 CallInst *CI = CallInst::Create(FTy, Callee, Args, DefaultOperandBundles);
2242 if (isa<FPMathOperator>(CI))
2243 CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
2244 return Insert(CI, Name);
2245 }
2246
2247 CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
2248 ArrayRef<OperandBundleDef> OpBundles,
2249 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2250 CallInst *CI = CallInst::Create(FTy, Callee, Args, OpBundles);
2251 if (isa<FPMathOperator>(CI))
2252 CI = cast<CallInst>(setFPAttrs(CI, FPMathTag, FMF));
2253 return Insert(CI, Name);
2254 }
2255
2256 CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args = None,
2257 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2258 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args, Name,
2259 FPMathTag);
2260 }
2261
2262 CallInst *CreateCall(FunctionCallee Callee, ArrayRef<Value *> Args,
2263 ArrayRef<OperandBundleDef> OpBundles,
2264 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2265 return CreateCall(Callee.getFunctionType(), Callee.getCallee(), Args,
2266 OpBundles, Name, FPMathTag);
2267 }
2268
2269 // Deprecated [opaque pointer types]
2270 CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args = None,
2271 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2272 return CreateCall(
2273 cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
2274 Args, Name, FPMathTag);
2275 }
2276
2277 // Deprecated [opaque pointer types]
2278 CallInst *CreateCall(Value *Callee, ArrayRef<Value *> Args,
2279 ArrayRef<OperandBundleDef> OpBundles,
2280 const Twine &Name = "", MDNode *FPMathTag = nullptr) {
2281 return CreateCall(
2282 cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
2283 Args, OpBundles, Name, FPMathTag);
2284 }
2285
2286 Value *CreateSelect(Value *C, Value *True, Value *False,
2287 const Twine &Name = "", Instruction *MDFrom = nullptr) {
2288 if (auto *CC = dyn_cast<Constant>(C))
2289 if (auto *TC = dyn_cast<Constant>(True))
2290 if (auto *FC = dyn_cast<Constant>(False))
2291 return Insert(Folder.CreateSelect(CC, TC, FC), Name);
2292
2293 SelectInst *Sel = SelectInst::Create(C, True, False);
2294 if (MDFrom) {
2295 MDNode *Prof = MDFrom->getMetadata(LLVMContext::MD_prof);
2296 MDNode *Unpred = MDFrom->getMetadata(LLVMContext::MD_unpredictable);
2297 Sel = addBranchMetadata(Sel, Prof, Unpred);
2298 }
2299 if (isa<FPMathOperator>(Sel))
2300 Sel = cast<SelectInst>(setFPAttrs(Sel, nullptr /* MDNode* */, FMF));
2301 return Insert(Sel, Name);
2302 }
2303
2304 VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
2305 return Insert(new VAArgInst(List, Ty), Name);
2306 }
2307
2308 Value *CreateExtractElement(Value *Vec, Value *Idx,
2309 const Twine &Name = "") {
2310 if (auto *VC = dyn_cast<Constant>(Vec))
2311 if (auto *IC = dyn_cast<Constant>(Idx))
2312 return Insert(Folder.CreateExtractElement(VC, IC), Name);
2313 return Insert(ExtractElementInst::Create(Vec, Idx), Name);
2314 }
2315
2316 Value *CreateExtractElement(Value *Vec, uint64_t Idx,
2317 const Twine &Name = "") {
2318 return CreateExtractElement(Vec, getInt64(Idx), Name);
2319 }
2320
2321 Value *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
2322 const Twine &Name = "") {
2323 if (auto *VC = dyn_cast<Constant>(Vec))
2324 if (auto *NC = dyn_cast<Constant>(NewElt))
2325 if (auto *IC = dyn_cast<Constant>(Idx))
2326 return Insert(Folder.CreateInsertElement(VC, NC, IC), Name);
2327 return Insert(InsertElementInst::Create(Vec, NewElt, Idx), Name);
2328 }
2329
2330 Value *CreateInsertElement(Value *Vec, Value *NewElt, uint64_t Idx,
2331 const Twine &Name = "") {
2332 return CreateInsertElement(Vec, NewElt, getInt64(Idx), Name);
2333 }
2334
2335 Value *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
2336 const Twine &Name = "") {
2337 if (auto *V1C = dyn_cast<Constant>(V1))
2338 if (auto *V2C = dyn_cast<Constant>(V2))
2339 if (auto *MC = dyn_cast<Constant>(Mask))
2340 return Insert(Folder.CreateShuffleVector(V1C, V2C, MC), Name);
2341 return Insert(new ShuffleVectorInst(V1, V2, Mask), Name);
2342 }
2343
2344 Value *CreateShuffleVector(Value *V1, Value *V2, ArrayRef<uint32_t> IntMask,
2345 const Twine &Name = "") {
2346 Value *Mask = ConstantDataVector::get(Context, IntMask);
2347 return CreateShuffleVector(V1, V2, Mask, Name);
2348 }
2349
2350 Value *CreateExtractValue(Value *Agg,
2351 ArrayRef<unsigned> Idxs,
2352 const Twine &Name = "") {
2353 if (auto *AggC = dyn_cast<Constant>(Agg))
2354 return Insert(Folder.CreateExtractValue(AggC, Idxs), Name);
2355 return Insert(ExtractValueInst::Create(Agg, Idxs), Name);
2356 }
2357
2358 Value *CreateInsertValue(Value *Agg, Value *Val,
2359 ArrayRef<unsigned> Idxs,
2360 const Twine &Name = "") {
2361 if (auto *AggC = dyn_cast<Constant>(Agg))
2362 if (auto *ValC = dyn_cast<Constant>(Val))
2363 return Insert(Folder.CreateInsertValue(AggC, ValC, Idxs), Name);
2364 return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);
2365 }
2366
2367 LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
2368 const Twine &Name = "") {
2369 return Insert(LandingPadInst::Create(Ty, NumClauses), Name);
2370 }
2371
2372 //===--------------------------------------------------------------------===//
2373 // Utility creation methods
2374 //===--------------------------------------------------------------------===//
2375
2376 /// Return an i1 value testing if \p Arg is null.
2377 Value *CreateIsNull(Value *Arg, const Twine &Name = "") {
2378 return CreateICmpEQ(Arg, Constant::getNullValue(Arg->getType()),
2379 Name);
2380 }
2381
2382 /// Return an i1 value testing if \p Arg is not null.
2383 Value *CreateIsNotNull(Value *Arg, const Twine &Name = "") {
2384 return CreateICmpNE(Arg, Constant::getNullValue(Arg->getType()),
2385 Name);
2386 }
2387
2388 /// Return the i64 difference between two pointer values, dividing out
2389 /// the size of the pointed-to objects.
2390 ///
2391 /// This is intended to implement C-style pointer subtraction. As such, the
2392 /// pointers must be appropriately aligned for their element types and
2393 /// pointing into the same object.
2394 Value *CreatePtrDiff(Value *LHS, Value *RHS, const Twine &Name = "") {
2395 assert(LHS->getType() == RHS->getType() &&((LHS->getType() == RHS->getType() && "Pointer subtraction operand types must match!"
) ? static_cast<void> (0) : __assert_fail ("LHS->getType() == RHS->getType() && \"Pointer subtraction operand types must match!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2396, __PRETTY_FUNCTION__))
2396 "Pointer subtraction operand types must match!")((LHS->getType() == RHS->getType() && "Pointer subtraction operand types must match!"
) ? static_cast<void> (0) : __assert_fail ("LHS->getType() == RHS->getType() && \"Pointer subtraction operand types must match!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2396, __PRETTY_FUNCTION__))
;
2397 auto *ArgType = cast<PointerType>(LHS->getType());
2398 Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
2399 Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
2400 Value *Difference = CreateSub(LHS_int, RHS_int);
2401 return CreateExactSDiv(Difference,
2402 ConstantExpr::getSizeOf(ArgType->getElementType()),
2403 Name);
2404 }
2405
2406 /// Create a launder.invariant.group intrinsic call. If Ptr type is
2407 /// different from pointer to i8, it's casted to pointer to i8 in the same
2408 /// address space before call and casted back to Ptr type after call.
2409 Value *CreateLaunderInvariantGroup(Value *Ptr) {
2410 assert(isa<PointerType>(Ptr->getType()) &&((isa<PointerType>(Ptr->getType()) && "launder.invariant.group only applies to pointers."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Ptr->getType()) && \"launder.invariant.group only applies to pointers.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2411, __PRETTY_FUNCTION__))
2411 "launder.invariant.group only applies to pointers.")((isa<PointerType>(Ptr->getType()) && "launder.invariant.group only applies to pointers."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Ptr->getType()) && \"launder.invariant.group only applies to pointers.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2411, __PRETTY_FUNCTION__))
;
2412 // FIXME: we could potentially avoid casts to/from i8*.
2413 auto *PtrType = Ptr->getType();
2414 auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
2415 if (PtrType != Int8PtrTy)
2416 Ptr = CreateBitCast(Ptr, Int8PtrTy);
2417 Module *M = BB->getParent()->getParent();
2418 Function *FnLaunderInvariantGroup = Intrinsic::getDeclaration(
2419 M, Intrinsic::launder_invariant_group, {Int8PtrTy});
2420
2421 assert(FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&((FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
FnLaunderInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "LaunderInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnLaunderInvariantGroup->getReturnType() == Int8PtrTy && FnLaunderInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"LaunderInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2424, __PRETTY_FUNCTION__))
2422 FnLaunderInvariantGroup->getFunctionType()->getParamType(0) ==((FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
FnLaunderInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "LaunderInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnLaunderInvariantGroup->getReturnType() == Int8PtrTy && FnLaunderInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"LaunderInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2424, __PRETTY_FUNCTION__))
2423 Int8PtrTy &&((FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
FnLaunderInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "LaunderInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnLaunderInvariantGroup->getReturnType() == Int8PtrTy && FnLaunderInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"LaunderInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2424, __PRETTY_FUNCTION__))
2424 "LaunderInvariantGroup should take and return the same type")((FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
FnLaunderInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "LaunderInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnLaunderInvariantGroup->getReturnType() == Int8PtrTy && FnLaunderInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"LaunderInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2424, __PRETTY_FUNCTION__))
;
2425
2426 CallInst *Fn = CreateCall(FnLaunderInvariantGroup, {Ptr});
2427
2428 if (PtrType != Int8PtrTy)
2429 return CreateBitCast(Fn, PtrType);
2430 return Fn;
2431 }
2432
2433 /// \brief Create a strip.invariant.group intrinsic call. If Ptr type is
2434 /// different from pointer to i8, it's casted to pointer to i8 in the same
2435 /// address space before call and casted back to Ptr type after call.
2436 Value *CreateStripInvariantGroup(Value *Ptr) {
2437 assert(isa<PointerType>(Ptr->getType()) &&((isa<PointerType>(Ptr->getType()) && "strip.invariant.group only applies to pointers."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Ptr->getType()) && \"strip.invariant.group only applies to pointers.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2438, __PRETTY_FUNCTION__))
2438 "strip.invariant.group only applies to pointers.")((isa<PointerType>(Ptr->getType()) && "strip.invariant.group only applies to pointers."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Ptr->getType()) && \"strip.invariant.group only applies to pointers.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2438, __PRETTY_FUNCTION__))
;
2439
2440 // FIXME: we could potentially avoid casts to/from i8*.
2441 auto *PtrType = Ptr->getType();
2442 auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
2443 if (PtrType != Int8PtrTy)
2444 Ptr = CreateBitCast(Ptr, Int8PtrTy);
2445 Module *M = BB->getParent()->getParent();
2446 Function *FnStripInvariantGroup = Intrinsic::getDeclaration(
2447 M, Intrinsic::strip_invariant_group, {Int8PtrTy});
2448
2449 assert(FnStripInvariantGroup->getReturnType() == Int8PtrTy &&((FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
FnStripInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "StripInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnStripInvariantGroup->getReturnType() == Int8PtrTy && FnStripInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"StripInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2452, __PRETTY_FUNCTION__))
2450 FnStripInvariantGroup->getFunctionType()->getParamType(0) ==((FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
FnStripInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "StripInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnStripInvariantGroup->getReturnType() == Int8PtrTy && FnStripInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"StripInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2452, __PRETTY_FUNCTION__))
2451 Int8PtrTy &&((FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
FnStripInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "StripInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnStripInvariantGroup->getReturnType() == Int8PtrTy && FnStripInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"StripInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2452, __PRETTY_FUNCTION__))
2452 "StripInvariantGroup should take and return the same type")((FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
FnStripInvariantGroup->getFunctionType()->getParamType
(0) == Int8PtrTy && "StripInvariantGroup should take and return the same type"
) ? static_cast<void> (0) : __assert_fail ("FnStripInvariantGroup->getReturnType() == Int8PtrTy && FnStripInvariantGroup->getFunctionType()->getParamType(0) == Int8PtrTy && \"StripInvariantGroup should take and return the same type\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2452, __PRETTY_FUNCTION__))
;
2453
2454 CallInst *Fn = CreateCall(FnStripInvariantGroup, {Ptr});
2455
2456 if (PtrType != Int8PtrTy)
2457 return CreateBitCast(Fn, PtrType);
2458 return Fn;
2459 }
2460
2461 /// Return a vector value that contains \arg V broadcasted to \p
2462 /// NumElts elements.
2463 Value *CreateVectorSplat(unsigned NumElts, Value *V, const Twine &Name = "") {
2464 assert(NumElts > 0 && "Cannot splat to an empty vector!")((NumElts > 0 && "Cannot splat to an empty vector!"
) ? static_cast<void> (0) : __assert_fail ("NumElts > 0 && \"Cannot splat to an empty vector!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2464, __PRETTY_FUNCTION__))
;
2465
2466 // First insert it into an undef vector so we can shuffle it.
2467 Type *I32Ty = getInt32Ty();
2468 Value *Undef = UndefValue::get(VectorType::get(V->getType(), NumElts));
2469 V = CreateInsertElement(Undef, V, ConstantInt::get(I32Ty, 0),
2470 Name + ".splatinsert");
2471
2472 // Shuffle the value across the desired number of elements.
2473 Value *Zeros = ConstantAggregateZero::get(VectorType::get(I32Ty, NumElts));
2474 return CreateShuffleVector(V, Undef, Zeros, Name + ".splat");
2475 }
2476
2477 /// Return a value that has been extracted from a larger integer type.
2478 Value *CreateExtractInteger(const DataLayout &DL, Value *From,
2479 IntegerType *ExtractedTy, uint64_t Offset,
2480 const Twine &Name) {
2481 auto *IntTy = cast<IntegerType>(From->getType());
2482 assert(DL.getTypeStoreSize(ExtractedTy) + Offset <=((DL.getTypeStoreSize(ExtractedTy) + Offset <= DL.getTypeStoreSize
(IntTy) && "Element extends past full value") ? static_cast
<void> (0) : __assert_fail ("DL.getTypeStoreSize(ExtractedTy) + Offset <= DL.getTypeStoreSize(IntTy) && \"Element extends past full value\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2484, __PRETTY_FUNCTION__))
2483 DL.getTypeStoreSize(IntTy) &&((DL.getTypeStoreSize(ExtractedTy) + Offset <= DL.getTypeStoreSize
(IntTy) && "Element extends past full value") ? static_cast
<void> (0) : __assert_fail ("DL.getTypeStoreSize(ExtractedTy) + Offset <= DL.getTypeStoreSize(IntTy) && \"Element extends past full value\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2484, __PRETTY_FUNCTION__))
2484 "Element extends past full value")((DL.getTypeStoreSize(ExtractedTy) + Offset <= DL.getTypeStoreSize
(IntTy) && "Element extends past full value") ? static_cast
<void> (0) : __assert_fail ("DL.getTypeStoreSize(ExtractedTy) + Offset <= DL.getTypeStoreSize(IntTy) && \"Element extends past full value\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2484, __PRETTY_FUNCTION__))
;
2485 uint64_t ShAmt = 8 * Offset;
2486 Value *V = From;
2487 if (DL.isBigEndian())
2488 ShAmt = 8 * (DL.getTypeStoreSize(IntTy) -
2489 DL.getTypeStoreSize(ExtractedTy) - Offset);
2490 if (ShAmt) {
2491 V = CreateLShr(V, ShAmt, Name + ".shift");
2492 }
2493 assert(ExtractedTy->getBitWidth() <= IntTy->getBitWidth() &&((ExtractedTy->getBitWidth() <= IntTy->getBitWidth()
&& "Cannot extract to a larger integer!") ? static_cast
<void> (0) : __assert_fail ("ExtractedTy->getBitWidth() <= IntTy->getBitWidth() && \"Cannot extract to a larger integer!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2494, __PRETTY_FUNCTION__))
2494 "Cannot extract to a larger integer!")((ExtractedTy->getBitWidth() <= IntTy->getBitWidth()
&& "Cannot extract to a larger integer!") ? static_cast
<void> (0) : __assert_fail ("ExtractedTy->getBitWidth() <= IntTy->getBitWidth() && \"Cannot extract to a larger integer!\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2494, __PRETTY_FUNCTION__))
;
2495 if (ExtractedTy != IntTy) {
2496 V = CreateTrunc(V, ExtractedTy, Name + ".trunc");
2497 }
2498 return V;
2499 }
2500
2501 Value *CreatePreserveArrayAccessIndex(Value *Base, unsigned Dimension,
2502 unsigned LastIndex, MDNode *DbgInfo) {
2503 assert(isa<PointerType>(Base->getType()) &&((isa<PointerType>(Base->getType()) && "Invalid Base ptr type for preserve.array.access.index."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Base->getType()) && \"Invalid Base ptr type for preserve.array.access.index.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2504, __PRETTY_FUNCTION__))
2504 "Invalid Base ptr type for preserve.array.access.index.")((isa<PointerType>(Base->getType()) && "Invalid Base ptr type for preserve.array.access.index."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Base->getType()) && \"Invalid Base ptr type for preserve.array.access.index.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2504, __PRETTY_FUNCTION__))
;
2505 auto *BaseType = Base->getType();
2506
2507 Value *LastIndexV = getInt32(LastIndex);
2508 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2509 SmallVector<Value *, 4> IdxList;
2510 for (unsigned I = 0; I < Dimension; ++I)
2511 IdxList.push_back(Zero);
2512 IdxList.push_back(LastIndexV);
2513
2514 Type *ResultType =
2515 GetElementPtrInst::getGEPReturnType(Base, IdxList);
2516
2517 Module *M = BB->getParent()->getParent();
2518 Function *FnPreserveArrayAccessIndex = Intrinsic::getDeclaration(
2519 M, Intrinsic::preserve_array_access_index, {ResultType, BaseType});
2520
2521 Value *DimV = getInt32(Dimension);
2522 CallInst *Fn =
2523 CreateCall(FnPreserveArrayAccessIndex, {Base, DimV, LastIndexV});
2524 if (DbgInfo)
2525 Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
2526
2527 return Fn;
2528 }
2529
2530 Value *CreatePreserveUnionAccessIndex(Value *Base, unsigned FieldIndex,
2531 MDNode *DbgInfo) {
2532 assert(isa<PointerType>(Base->getType()) &&((isa<PointerType>(Base->getType()) && "Invalid Base ptr type for preserve.union.access.index."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Base->getType()) && \"Invalid Base ptr type for preserve.union.access.index.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2533, __PRETTY_FUNCTION__))
2533 "Invalid Base ptr type for preserve.union.access.index.")((isa<PointerType>(Base->getType()) && "Invalid Base ptr type for preserve.union.access.index."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Base->getType()) && \"Invalid Base ptr type for preserve.union.access.index.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2533, __PRETTY_FUNCTION__))
;
2534 auto *BaseType = Base->getType();
2535
2536 Module *M = BB->getParent()->getParent();
2537 Function *FnPreserveUnionAccessIndex = Intrinsic::getDeclaration(
2538 M, Intrinsic::preserve_union_access_index, {BaseType, BaseType});
2539
2540 Value *DIIndex = getInt32(FieldIndex);
2541 CallInst *Fn =
2542 CreateCall(FnPreserveUnionAccessIndex, {Base, DIIndex});
2543 if (DbgInfo)
2544 Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
2545
2546 return Fn;
2547 }
2548
2549 Value *CreatePreserveStructAccessIndex(Value *Base, unsigned Index,
2550 unsigned FieldIndex, MDNode *DbgInfo) {
2551 assert(isa<PointerType>(Base->getType()) &&((isa<PointerType>(Base->getType()) && "Invalid Base ptr type for preserve.struct.access.index."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Base->getType()) && \"Invalid Base ptr type for preserve.struct.access.index.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2552, __PRETTY_FUNCTION__))
2552 "Invalid Base ptr type for preserve.struct.access.index.")((isa<PointerType>(Base->getType()) && "Invalid Base ptr type for preserve.struct.access.index."
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(Base->getType()) && \"Invalid Base ptr type for preserve.struct.access.index.\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2552, __PRETTY_FUNCTION__))
;
2553 auto *BaseType = Base->getType();
2554
2555 Value *GEPIndex = getInt32(Index);
2556 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2557 Type *ResultType =
2558 GetElementPtrInst::getGEPReturnType(Base, {Zero, GEPIndex});
2559
2560 Module *M = BB->getParent()->getParent();
2561 Function *FnPreserveStructAccessIndex = Intrinsic::getDeclaration(
2562 M, Intrinsic::preserve_struct_access_index, {ResultType, BaseType});
2563
2564 Value *DIIndex = getInt32(FieldIndex);
2565 CallInst *Fn = CreateCall(FnPreserveStructAccessIndex,
2566 {Base, GEPIndex, DIIndex});
2567 if (DbgInfo)
2568 Fn->setMetadata(LLVMContext::MD_preserve_access_index, DbgInfo);
2569
2570 return Fn;
2571 }
2572
2573private:
2574 /// Helper function that creates an assume intrinsic call that
2575 /// represents an alignment assumption on the provided Ptr, Mask, Type
2576 /// and Offset. It may be sometimes useful to do some other logic
2577 /// based on this alignment check, thus it can be stored into 'TheCheck'.
2578 CallInst *CreateAlignmentAssumptionHelper(const DataLayout &DL,
2579 Value *PtrValue, Value *Mask,
2580 Type *IntPtrTy, Value *OffsetValue,
2581 Value **TheCheck) {
2582 Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
2583
2584 if (OffsetValue) {
2585 bool IsOffsetZero = false;
2586 if (const auto *CI = dyn_cast<ConstantInt>(OffsetValue))
2587 IsOffsetZero = CI->isZero();
2588
2589 if (!IsOffsetZero) {
2590 if (OffsetValue->getType() != IntPtrTy)
2591 OffsetValue = CreateIntCast(OffsetValue, IntPtrTy, /*isSigned*/ true,
2592 "offsetcast");
2593 PtrIntValue = CreateSub(PtrIntValue, OffsetValue, "offsetptr");
2594 }
2595 }
2596
2597 Value *Zero = ConstantInt::get(IntPtrTy, 0);
2598 Value *MaskedPtr = CreateAnd(PtrIntValue, Mask, "maskedptr");
2599 Value *InvCond = CreateICmpEQ(MaskedPtr, Zero, "maskcond");
2600 if (TheCheck)
2601 *TheCheck = InvCond;
2602
2603 return CreateAssumption(InvCond);
2604 }
2605
2606public:
2607 /// Create an assume intrinsic call that represents an alignment
2608 /// assumption on the provided pointer.
2609 ///
2610 /// An optional offset can be provided, and if it is provided, the offset
2611 /// must be subtracted from the provided pointer to get the pointer with the
2612 /// specified alignment.
2613 ///
2614 /// It may be sometimes useful to do some other logic
2615 /// based on this alignment check, thus it can be stored into 'TheCheck'.
2616 CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
2617 unsigned Alignment,
2618 Value *OffsetValue = nullptr,
2619 Value **TheCheck = nullptr) {
2620 assert(isa<PointerType>(PtrValue->getType()) &&((isa<PointerType>(PtrValue->getType()) && "trying to create an alignment assumption on a non-pointer?"
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(PtrValue->getType()) && \"trying to create an alignment assumption on a non-pointer?\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2621, __PRETTY_FUNCTION__))
2621 "trying to create an alignment assumption on a non-pointer?")((isa<PointerType>(PtrValue->getType()) && "trying to create an alignment assumption on a non-pointer?"
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(PtrValue->getType()) && \"trying to create an alignment assumption on a non-pointer?\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2621, __PRETTY_FUNCTION__))
;
2622 assert(Alignment != 0 && "Invalid Alignment")((Alignment != 0 && "Invalid Alignment") ? static_cast
<void> (0) : __assert_fail ("Alignment != 0 && \"Invalid Alignment\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2622, __PRETTY_FUNCTION__))
;
2623 auto *PtrTy = cast<PointerType>(PtrValue->getType());
2624 Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
2625
2626 Value *Mask = ConstantInt::get(IntPtrTy, Alignment - 1);
2627 return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
2628 OffsetValue, TheCheck);
2629 }
2630
2631 /// Create an assume intrinsic call that represents an alignment
2632 /// assumption on the provided pointer.
2633 ///
2634 /// An optional offset can be provided, and if it is provided, the offset
2635 /// must be subtracted from the provided pointer to get the pointer with the
2636 /// specified alignment.
2637 ///
2638 /// It may be sometimes useful to do some other logic
2639 /// based on this alignment check, thus it can be stored into 'TheCheck'.
2640 ///
2641 /// This overload handles the condition where the Alignment is dependent
2642 /// on an existing value rather than a static value.
2643 CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue,
2644 Value *Alignment,
2645 Value *OffsetValue = nullptr,
2646 Value **TheCheck = nullptr) {
2647 assert(isa<PointerType>(PtrValue->getType()) &&((isa<PointerType>(PtrValue->getType()) && "trying to create an alignment assumption on a non-pointer?"
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(PtrValue->getType()) && \"trying to create an alignment assumption on a non-pointer?\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2648, __PRETTY_FUNCTION__))
2648 "trying to create an alignment assumption on a non-pointer?")((isa<PointerType>(PtrValue->getType()) && "trying to create an alignment assumption on a non-pointer?"
) ? static_cast<void> (0) : __assert_fail ("isa<PointerType>(PtrValue->getType()) && \"trying to create an alignment assumption on a non-pointer?\""
, "/build/llvm-toolchain-snapshot-10~svn374877/include/llvm/IR/IRBuilder.h"
, 2648, __PRETTY_FUNCTION__))
;
2649 auto *PtrTy = cast<PointerType>(PtrValue->getType());
2650 Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
2651
2652 if (Alignment->getType() != IntPtrTy)
2653 Alignment = CreateIntCast(Alignment, IntPtrTy, /*isSigned*/ false,
2654 "alignmentcast");
2655
2656 Value *Mask = CreateSub(Alignment, ConstantInt::get(IntPtrTy, 1), "mask");
2657
2658 return CreateAlignmentAssumptionHelper(DL, PtrValue, Mask, IntPtrTy,
2659 OffsetValue, TheCheck);
2660 }
2661};
2662
2663// Create wrappers for C Binding types (see CBindingWrapping.h).
2664DEFINE_SIMPLE_CONVERSION_FUNCTIONS(IRBuilder<>, LLVMBuilderRef)inline IRBuilder<> *unwrap(LLVMBuilderRef P) { return reinterpret_cast
<IRBuilder<>*>(P); } inline LLVMBuilderRef wrap(const
IRBuilder<> *P) { return reinterpret_cast<LLVMBuilderRef
>(const_cast<IRBuilder<>*>(P)); }
2665
2666} // end namespace llvm
2667
2668#endif // LLVM_IR_IRBUILDER_H