Details | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
14 | pmbaty | 1 | //===-- Scalar.h - Scalar Transformations -----------------------*- 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 header file defines prototypes for accessor functions that expose passes |
||
10 | // in the Scalar transformations library. |
||
11 | // |
||
12 | //===----------------------------------------------------------------------===// |
||
13 | |||
14 | #ifndef LLVM_TRANSFORMS_SCALAR_H |
||
15 | #define LLVM_TRANSFORMS_SCALAR_H |
||
16 | |||
17 | #include "llvm/Transforms/Utils/SimplifyCFGOptions.h" |
||
18 | #include <functional> |
||
19 | |||
20 | namespace llvm { |
||
21 | |||
22 | class Function; |
||
23 | class FunctionPass; |
||
24 | class ModulePass; |
||
25 | class Pass; |
||
26 | |||
27 | //===----------------------------------------------------------------------===// |
||
28 | // |
||
29 | // AlignmentFromAssumptions - Use assume intrinsics to set load/store |
||
30 | // alignments. |
||
31 | // |
||
32 | FunctionPass *createAlignmentFromAssumptionsPass(); |
||
33 | |||
34 | //===----------------------------------------------------------------------===// |
||
35 | // |
||
36 | // SCCP - Sparse conditional constant propagation. |
||
37 | // |
||
38 | FunctionPass *createSCCPPass(); |
||
39 | |||
40 | //===----------------------------------------------------------------------===// |
||
41 | // |
||
42 | // RedundantDbgInstElimination - This pass removes redundant dbg intrinsics |
||
43 | // without modifying the CFG of the function. It is a FunctionPass. |
||
44 | // |
||
45 | Pass *createRedundantDbgInstEliminationPass(); |
||
46 | |||
47 | //===----------------------------------------------------------------------===// |
||
48 | // |
||
49 | // DeadCodeElimination - This pass is more powerful than DeadInstElimination, |
||
50 | // because it is worklist driven that can potentially revisit instructions when |
||
51 | // their other instructions become dead, to eliminate chains of dead |
||
52 | // computations. |
||
53 | // |
||
54 | FunctionPass *createDeadCodeEliminationPass(); |
||
55 | |||
56 | //===----------------------------------------------------------------------===// |
||
57 | // |
||
58 | // DeadStoreElimination - This pass deletes stores that are post-dominated by |
||
59 | // must-aliased stores and are not loaded used between the stores. |
||
60 | // |
||
61 | FunctionPass *createDeadStoreEliminationPass(); |
||
62 | |||
63 | |||
64 | //===----------------------------------------------------------------------===// |
||
65 | // |
||
66 | // CallSiteSplitting - This pass split call-site based on its known argument |
||
67 | // values. |
||
68 | FunctionPass *createCallSiteSplittingPass(); |
||
69 | |||
70 | //===----------------------------------------------------------------------===// |
||
71 | // |
||
72 | // AggressiveDCE - This pass uses the SSA based Aggressive DCE algorithm. This |
||
73 | // algorithm assumes instructions are dead until proven otherwise, which makes |
||
74 | // it more successful are removing non-obviously dead instructions. |
||
75 | // |
||
76 | FunctionPass *createAggressiveDCEPass(); |
||
77 | |||
78 | //===----------------------------------------------------------------------===// |
||
79 | // |
||
80 | // GuardWidening - An optimization over the @llvm.experimental.guard intrinsic |
||
81 | // that (optimistically) combines multiple guards into one to have fewer checks |
||
82 | // at runtime. |
||
83 | // |
||
84 | FunctionPass *createGuardWideningPass(); |
||
85 | |||
86 | |||
87 | //===----------------------------------------------------------------------===// |
||
88 | // |
||
89 | // LoopGuardWidening - Analogous to the GuardWidening pass, but restricted to a |
||
90 | // single loop at a time for use within a LoopPassManager. Desired effect is |
||
91 | // to widen guards into preheader or a single guard within loop if that's not |
||
92 | // possible. |
||
93 | // |
||
94 | Pass *createLoopGuardWideningPass(); |
||
95 | |||
96 | |||
97 | //===----------------------------------------------------------------------===// |
||
98 | // |
||
99 | // BitTrackingDCE - This pass uses a bit-tracking DCE algorithm in order to |
||
100 | // remove computations of dead bits. |
||
101 | // |
||
102 | FunctionPass *createBitTrackingDCEPass(); |
||
103 | |||
104 | //===----------------------------------------------------------------------===// |
||
105 | // |
||
106 | // SROA - Replace aggregates or pieces of aggregates with scalar SSA values. |
||
107 | // |
||
108 | FunctionPass *createSROAPass(bool PreserveCFG = true); |
||
109 | |||
110 | //===----------------------------------------------------------------------===// |
||
111 | // |
||
112 | // InductiveRangeCheckElimination - Transform loops to elide range checks on |
||
113 | // linear functions of the induction variable. |
||
114 | // |
||
115 | Pass *createInductiveRangeCheckEliminationPass(); |
||
116 | |||
117 | //===----------------------------------------------------------------------===// |
||
118 | // |
||
119 | // InductionVariableSimplify - Transform induction variables in a program to all |
||
120 | // use a single canonical induction variable per loop. |
||
121 | // |
||
122 | Pass *createIndVarSimplifyPass(); |
||
123 | |||
124 | //===----------------------------------------------------------------------===// |
||
125 | // |
||
126 | // LICM - This pass is a loop invariant code motion and memory promotion pass. |
||
127 | // |
||
128 | Pass *createLICMPass(); |
||
129 | Pass *createLICMPass(unsigned LicmMssaOptCap, |
||
130 | unsigned LicmMssaNoAccForPromotionCap, |
||
131 | bool AllowSpeculation); |
||
132 | |||
133 | //===----------------------------------------------------------------------===// |
||
134 | // |
||
135 | // LoopSink - This pass sinks invariants from preheader to loop body where |
||
136 | // frequency is lower than loop preheader. |
||
137 | // |
||
138 | Pass *createLoopSinkPass(); |
||
139 | |||
140 | //===----------------------------------------------------------------------===// |
||
141 | // |
||
142 | // LoopPredication - This pass does loop predication on guards. |
||
143 | // |
||
144 | Pass *createLoopPredicationPass(); |
||
145 | |||
146 | //===----------------------------------------------------------------------===// |
||
147 | // |
||
148 | // LoopInterchange - This pass interchanges loops to provide a more |
||
149 | // cache-friendly memory access patterns. |
||
150 | // |
||
151 | Pass *createLoopInterchangePass(); |
||
152 | |||
153 | //===----------------------------------------------------------------------===// |
||
154 | // |
||
155 | // LoopFlatten - This pass flattens nested loops into a single loop. |
||
156 | // |
||
157 | FunctionPass *createLoopFlattenPass(); |
||
158 | |||
159 | //===----------------------------------------------------------------------===// |
||
160 | // |
||
161 | // LoopStrengthReduce - This pass is strength reduces GEP instructions that use |
||
162 | // a loop's canonical induction variable as one of their indices. |
||
163 | // |
||
164 | Pass *createLoopStrengthReducePass(); |
||
165 | |||
166 | //===----------------------------------------------------------------------===// |
||
167 | // |
||
168 | // LoopInstSimplify - This pass simplifies instructions in a loop's body. |
||
169 | // |
||
170 | Pass *createLoopInstSimplifyPass(); |
||
171 | |||
172 | //===----------------------------------------------------------------------===// |
||
173 | // |
||
174 | // LoopUnroll - This pass is a simple loop unrolling pass. |
||
175 | // |
||
176 | Pass *createLoopUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false, |
||
177 | bool ForgetAllSCEV = false, int Threshold = -1, |
||
178 | int Count = -1, int AllowPartial = -1, |
||
179 | int Runtime = -1, int UpperBound = -1, |
||
180 | int AllowPeeling = -1); |
||
181 | // Create an unrolling pass for full unrolling that uses exact trip count only |
||
182 | // and also does peeling. |
||
183 | Pass *createSimpleLoopUnrollPass(int OptLevel = 2, bool OnlyWhenForced = false, |
||
184 | bool ForgetAllSCEV = false); |
||
185 | |||
186 | //===----------------------------------------------------------------------===// |
||
187 | // |
||
188 | // LoopUnrollAndJam - This pass is a simple loop unroll and jam pass. |
||
189 | // |
||
190 | Pass *createLoopUnrollAndJamPass(int OptLevel = 2); |
||
191 | |||
192 | //===----------------------------------------------------------------------===// |
||
193 | // |
||
194 | // LoopReroll - This pass is a simple loop rerolling pass. |
||
195 | // |
||
196 | Pass *createLoopRerollPass(); |
||
197 | |||
198 | //===----------------------------------------------------------------------===// |
||
199 | // |
||
200 | // LoopRotate - This pass is a simple loop rotating pass. |
||
201 | // |
||
202 | Pass *createLoopRotatePass(int MaxHeaderSize = -1, bool PrepareForLTO = false); |
||
203 | |||
204 | //===----------------------------------------------------------------------===// |
||
205 | // |
||
206 | // LoopIdiom - This pass recognizes and replaces idioms in loops. |
||
207 | // |
||
208 | Pass *createLoopIdiomPass(); |
||
209 | |||
210 | //===----------------------------------------------------------------------===// |
||
211 | // |
||
212 | // LoopVersioningLICM - This pass is a loop versioning pass for LICM. |
||
213 | // |
||
214 | Pass *createLoopVersioningLICMPass(); |
||
215 | |||
216 | //===----------------------------------------------------------------------===// |
||
217 | // |
||
218 | // DemoteRegisterToMemoryPass - This pass is used to demote registers to memory |
||
219 | // references. In basically undoes the PromoteMemoryToRegister pass to make cfg |
||
220 | // hacking easier. |
||
221 | // |
||
222 | FunctionPass *createDemoteRegisterToMemoryPass(); |
||
223 | extern char &DemoteRegisterToMemoryID; |
||
224 | |||
225 | //===----------------------------------------------------------------------===// |
||
226 | // |
||
227 | // Reassociate - This pass reassociates commutative expressions in an order that |
||
228 | // is designed to promote better constant propagation, GCSE, LICM, PRE... |
||
229 | // |
||
230 | // For example: 4 + (x + 5) -> x + (4 + 5) |
||
231 | // |
||
232 | FunctionPass *createReassociatePass(); |
||
233 | |||
234 | //===----------------------------------------------------------------------===// |
||
235 | // |
||
236 | // JumpThreading - Thread control through mult-pred/multi-succ blocks where some |
||
237 | // preds always go to some succ. Thresholds other than minus one |
||
238 | // override the internal BB duplication default threshold. |
||
239 | // |
||
240 | FunctionPass *createJumpThreadingPass(int Threshold = -1); |
||
241 | |||
242 | //===----------------------------------------------------------------------===// |
||
243 | // |
||
244 | // DFAJumpThreading - When a switch statement inside a loop is used to |
||
245 | // implement a deterministic finite automata we can jump thread the switch |
||
246 | // statement reducing number of conditional jumps. |
||
247 | // |
||
248 | FunctionPass *createDFAJumpThreadingPass(); |
||
249 | |||
250 | //===----------------------------------------------------------------------===// |
||
251 | // |
||
252 | // CFGSimplification - Merge basic blocks, eliminate unreachable blocks, |
||
253 | // simplify terminator instructions, convert switches to lookup tables, etc. |
||
254 | // |
||
255 | FunctionPass *createCFGSimplificationPass( |
||
256 | SimplifyCFGOptions Options = SimplifyCFGOptions(), |
||
257 | std::function<bool(const Function &)> Ftor = nullptr); |
||
258 | |||
259 | //===----------------------------------------------------------------------===// |
||
260 | // |
||
261 | // FlattenCFG - flatten CFG, reduce number of conditional branches by using |
||
262 | // parallel-and and parallel-or mode, etc... |
||
263 | // |
||
264 | FunctionPass *createFlattenCFGPass(); |
||
265 | |||
266 | //===----------------------------------------------------------------------===// |
||
267 | // |
||
268 | // CFG Structurization - Remove irreducible control flow |
||
269 | // |
||
270 | /// |
||
271 | /// When \p SkipUniformRegions is true the structizer will not structurize |
||
272 | /// regions that only contain uniform branches. |
||
273 | Pass *createStructurizeCFGPass(bool SkipUniformRegions = false); |
||
274 | |||
275 | //===----------------------------------------------------------------------===// |
||
276 | // |
||
277 | // TailCallElimination - This pass eliminates call instructions to the current |
||
278 | // function which occur immediately before return instructions. |
||
279 | // |
||
280 | FunctionPass *createTailCallEliminationPass(); |
||
281 | |||
282 | //===----------------------------------------------------------------------===// |
||
283 | // |
||
284 | // EarlyCSE - This pass performs a simple and fast CSE pass over the dominator |
||
285 | // tree. |
||
286 | // |
||
287 | FunctionPass *createEarlyCSEPass(bool UseMemorySSA = false); |
||
288 | |||
289 | //===----------------------------------------------------------------------===// |
||
290 | // |
||
291 | // GVNHoist - This pass performs a simple and fast GVN pass over the dominator |
||
292 | // tree to hoist common expressions from sibling branches. |
||
293 | // |
||
294 | FunctionPass *createGVNHoistPass(); |
||
295 | |||
296 | //===----------------------------------------------------------------------===// |
||
297 | // |
||
298 | // GVNSink - This pass uses an "inverted" value numbering to decide the |
||
299 | // similarity of expressions and sinks similar expressions into successors. |
||
300 | // |
||
301 | FunctionPass *createGVNSinkPass(); |
||
302 | |||
303 | //===----------------------------------------------------------------------===// |
||
304 | // |
||
305 | // MergedLoadStoreMotion - This pass merges loads and stores in diamonds. Loads |
||
306 | // are hoisted into the header, while stores sink into the footer. |
||
307 | // |
||
308 | FunctionPass *createMergedLoadStoreMotionPass(bool SplitFooterBB = false); |
||
309 | |||
310 | //===----------------------------------------------------------------------===// |
||
311 | // |
||
312 | // GVN - This pass performs global value numbering and redundant load |
||
313 | // elimination cotemporaneously. |
||
314 | // |
||
315 | FunctionPass *createNewGVNPass(); |
||
316 | |||
317 | //===----------------------------------------------------------------------===// |
||
318 | // |
||
319 | // DivRemPairs - Hoist/decompose integer division and remainder instructions. |
||
320 | // |
||
321 | FunctionPass *createDivRemPairsPass(); |
||
322 | |||
323 | //===----------------------------------------------------------------------===// |
||
324 | // |
||
325 | // MemCpyOpt - This pass performs optimizations related to eliminating memcpy |
||
326 | // calls and/or combining multiple stores into memset's. |
||
327 | // |
||
328 | FunctionPass *createMemCpyOptPass(); |
||
329 | |||
330 | //===----------------------------------------------------------------------===// |
||
331 | // |
||
332 | // LoopDeletion - This pass performs DCE of non-infinite loops that it |
||
333 | // can prove are dead. |
||
334 | // |
||
335 | Pass *createLoopDeletionPass(); |
||
336 | |||
337 | //===----------------------------------------------------------------------===// |
||
338 | // |
||
339 | // ConstantHoisting - This pass prepares a function for expensive constants. |
||
340 | // |
||
341 | FunctionPass *createConstantHoistingPass(); |
||
342 | |||
343 | //===----------------------------------------------------------------------===// |
||
344 | // |
||
345 | // Sink - Code Sinking |
||
346 | // |
||
347 | FunctionPass *createSinkingPass(); |
||
348 | |||
349 | //===----------------------------------------------------------------------===// |
||
350 | // |
||
351 | // LowerAtomic - Lower atomic intrinsics to non-atomic form |
||
352 | // |
||
353 | Pass *createLowerAtomicPass(); |
||
354 | |||
355 | //===----------------------------------------------------------------------===// |
||
356 | // |
||
357 | // LowerGuardIntrinsic - Lower guard intrinsics to normal control flow. |
||
358 | // |
||
359 | Pass *createLowerGuardIntrinsicPass(); |
||
360 | |||
361 | //===----------------------------------------------------------------------===// |
||
362 | // |
||
363 | // LowerMatrixIntrinsics - Lower matrix intrinsics to vector operations. |
||
364 | // |
||
365 | Pass *createLowerMatrixIntrinsicsPass(); |
||
366 | |||
367 | //===----------------------------------------------------------------------===// |
||
368 | // |
||
369 | // LowerMatrixIntrinsicsMinimal - Lower matrix intrinsics to vector operations |
||
370 | // (lightweight, does not require extra analysis) |
||
371 | // |
||
372 | Pass *createLowerMatrixIntrinsicsMinimalPass(); |
||
373 | |||
374 | //===----------------------------------------------------------------------===// |
||
375 | // |
||
376 | // LowerWidenableCondition - Lower widenable condition to i1 true. |
||
377 | // |
||
378 | Pass *createLowerWidenableConditionPass(); |
||
379 | |||
380 | //===----------------------------------------------------------------------===// |
||
381 | // |
||
382 | // MergeICmps - Merge integer comparison chains into a memcmp |
||
383 | // |
||
384 | Pass *createMergeICmpsLegacyPass(); |
||
385 | |||
386 | //===----------------------------------------------------------------------===// |
||
387 | // |
||
388 | // ValuePropagation - Propagate CFG-derived value information |
||
389 | // |
||
390 | Pass *createCorrelatedValuePropagationPass(); |
||
391 | |||
392 | //===----------------------------------------------------------------------===// |
||
393 | // |
||
394 | // InferAddressSpaces - Modify users of addrspacecast instructions with values |
||
395 | // in the source address space if using the destination address space is slower |
||
396 | // on the target. If AddressSpace is left to its default value, it will be |
||
397 | // obtained from the TargetTransformInfo. |
||
398 | // |
||
399 | FunctionPass *createInferAddressSpacesPass(unsigned AddressSpace = ~0u); |
||
400 | extern char &InferAddressSpacesID; |
||
401 | |||
402 | //===----------------------------------------------------------------------===// |
||
403 | // |
||
404 | // LowerExpectIntrinsics - Removes llvm.expect intrinsics and creates |
||
405 | // "block_weights" metadata. |
||
406 | FunctionPass *createLowerExpectIntrinsicPass(); |
||
407 | |||
408 | //===----------------------------------------------------------------------===// |
||
409 | // |
||
410 | // TLSVariableHoist - This pass reduce duplicated TLS address call. |
||
411 | // |
||
412 | FunctionPass *createTLSVariableHoistPass(); |
||
413 | |||
414 | //===----------------------------------------------------------------------===// |
||
415 | // |
||
416 | // LowerConstantIntrinsicss - Expand any remaining llvm.objectsize and |
||
417 | // llvm.is.constant intrinsic calls, even for the unknown cases. |
||
418 | // |
||
419 | FunctionPass *createLowerConstantIntrinsicsPass(); |
||
420 | |||
421 | //===----------------------------------------------------------------------===// |
||
422 | // |
||
423 | // PartiallyInlineLibCalls - Tries to inline the fast path of library |
||
424 | // calls such as sqrt. |
||
425 | // |
||
426 | FunctionPass *createPartiallyInlineLibCallsPass(); |
||
427 | |||
428 | //===----------------------------------------------------------------------===// |
||
429 | // |
||
430 | // SeparateConstOffsetFromGEP - Split GEPs for better CSE |
||
431 | // |
||
432 | FunctionPass *createSeparateConstOffsetFromGEPPass(bool LowerGEP = false); |
||
433 | |||
434 | //===----------------------------------------------------------------------===// |
||
435 | // |
||
436 | // SpeculativeExecution - Aggressively hoist instructions to enable |
||
437 | // speculative execution on targets where branches are expensive. |
||
438 | // |
||
439 | FunctionPass *createSpeculativeExecutionPass(); |
||
440 | |||
441 | // Same as createSpeculativeExecutionPass, but does nothing unless |
||
442 | // TargetTransformInfo::hasBranchDivergence() is true. |
||
443 | FunctionPass *createSpeculativeExecutionIfHasBranchDivergencePass(); |
||
444 | |||
445 | //===----------------------------------------------------------------------===// |
||
446 | // |
||
447 | // StraightLineStrengthReduce - This pass strength-reduces some certain |
||
448 | // instruction patterns in straight-line code. |
||
449 | // |
||
450 | FunctionPass *createStraightLineStrengthReducePass(); |
||
451 | |||
452 | //===----------------------------------------------------------------------===// |
||
453 | // |
||
454 | // PlaceSafepoints - Rewrite any IR calls to gc.statepoints and insert any |
||
455 | // safepoint polls (method entry, backedge) that might be required. This pass |
||
456 | // does not generate explicit relocation sequences - that's handled by |
||
457 | // RewriteStatepointsForGC which can be run at an arbitrary point in the pass |
||
458 | // order following this pass. |
||
459 | // |
||
460 | FunctionPass *createPlaceSafepointsPass(); |
||
461 | |||
462 | //===----------------------------------------------------------------------===// |
||
463 | // |
||
464 | // RewriteStatepointsForGC - Rewrite any gc.statepoints which do not yet have |
||
465 | // explicit relocations to include explicit relocations. |
||
466 | // |
||
467 | ModulePass *createRewriteStatepointsForGCLegacyPass(); |
||
468 | |||
469 | //===----------------------------------------------------------------------===// |
||
470 | // |
||
471 | // Float2Int - Demote floats to ints where possible. |
||
472 | // |
||
473 | FunctionPass *createFloat2IntPass(); |
||
474 | |||
475 | //===----------------------------------------------------------------------===// |
||
476 | // |
||
477 | // NaryReassociate - Simplify n-ary operations by reassociation. |
||
478 | // |
||
479 | FunctionPass *createNaryReassociatePass(); |
||
480 | |||
481 | //===----------------------------------------------------------------------===// |
||
482 | // |
||
483 | // LoopDistribute - Distribute loops. |
||
484 | // |
||
485 | FunctionPass *createLoopDistributePass(); |
||
486 | |||
487 | //===----------------------------------------------------------------------===// |
||
488 | // |
||
489 | // LoopFuse - Fuse loops. |
||
490 | // |
||
491 | FunctionPass *createLoopFusePass(); |
||
492 | |||
493 | //===----------------------------------------------------------------------===// |
||
494 | // |
||
495 | // LoopLoadElimination - Perform loop-aware load elimination. |
||
496 | // |
||
497 | FunctionPass *createLoopLoadEliminationPass(); |
||
498 | |||
499 | //===----------------------------------------------------------------------===// |
||
500 | // |
||
501 | // LoopVersioning - Perform loop multi-versioning. |
||
502 | // |
||
503 | FunctionPass *createLoopVersioningPass(); |
||
504 | |||
505 | //===----------------------------------------------------------------------===// |
||
506 | // |
||
507 | // LoopDataPrefetch - Perform data prefetching in loops. |
||
508 | // |
||
509 | FunctionPass *createLoopDataPrefetchPass(); |
||
510 | |||
511 | //===----------------------------------------------------------------------===// |
||
512 | // |
||
513 | // LibCallsShrinkWrap - Shrink-wraps a call to function if the result is not |
||
514 | // used. |
||
515 | // |
||
516 | FunctionPass *createLibCallsShrinkWrapPass(); |
||
517 | |||
518 | //===----------------------------------------------------------------------===// |
||
519 | // |
||
520 | // LoopSimplifyCFG - This pass performs basic CFG simplification on loops, |
||
521 | // primarily to help other loop passes. |
||
522 | // |
||
523 | Pass *createLoopSimplifyCFGPass(); |
||
524 | |||
525 | //===----------------------------------------------------------------------===// |
||
526 | // |
||
527 | // WarnMissedTransformations - This pass emits warnings for leftover forced |
||
528 | // transformations. |
||
529 | // |
||
530 | Pass *createWarnMissedTransformationsPass(); |
||
531 | |||
532 | //===----------------------------------------------------------------------===// |
||
533 | // |
||
534 | // This pass does instruction simplification on each |
||
535 | // instruction in a function. |
||
536 | // |
||
537 | FunctionPass *createInstSimplifyLegacyPass(); |
||
538 | |||
539 | |||
540 | //===----------------------------------------------------------------------===// |
||
541 | // |
||
542 | // createScalarizeMaskedMemIntrinPass - Replace masked load, store, gather |
||
543 | // and scatter intrinsics with scalar code when target doesn't support them. |
||
544 | // |
||
545 | FunctionPass *createScalarizeMaskedMemIntrinLegacyPass(); |
||
546 | } // End llvm namespace |
||
547 | |||
548 | #endif |