111 lines
3.7 KiB
C++
111 lines
3.7 KiB
C++
//===- SpeculateAroundPHIs.h - Speculate around PHIs ------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_TRANSFORMS_SCALAR_SPECULATEAROUNDPHIS_H
|
|
#define LLVM_TRANSFORMS_SCALAR_SPECULATEAROUNDPHIS_H
|
|
|
|
#include "llvm/ADT/SetVector.h"
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
|
#include "llvm/IR/Dominators.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/PassManager.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include <vector>
|
|
|
|
namespace llvm {
|
|
|
|
/// This pass handles simple speculating of instructions around PHIs when
|
|
/// doing so is profitable for a particular target despite duplicated
|
|
/// instructions.
|
|
///
|
|
/// The motivating example are PHIs of constants which will require
|
|
/// materializing the constants along each edge. If the PHI is used by an
|
|
/// instruction where the target can materialize the constant as part of the
|
|
/// instruction, it is profitable to speculate those instructions around the
|
|
/// PHI node. This can reduce dynamic instruction count as well as decrease
|
|
/// register pressure.
|
|
///
|
|
/// Consider this IR for example:
|
|
/// ```
|
|
/// entry:
|
|
/// br i1 %flag, label %a, label %b
|
|
///
|
|
/// a:
|
|
/// br label %exit
|
|
///
|
|
/// b:
|
|
/// br label %exit
|
|
///
|
|
/// exit:
|
|
/// %p = phi i32 [ 7, %a ], [ 11, %b ]
|
|
/// %sum = add i32 %arg, %p
|
|
/// ret i32 %sum
|
|
/// ```
|
|
/// To materialize the inputs to this PHI node may require an explicit
|
|
/// instruction. For example, on x86 this would turn into something like
|
|
/// ```
|
|
/// testq %eax, %eax
|
|
/// movl $7, %rNN
|
|
/// jne .L
|
|
/// movl $11, %rNN
|
|
/// .L:
|
|
/// addl %edi, %rNN
|
|
/// movl %rNN, %eax
|
|
/// retq
|
|
/// ```
|
|
/// When these constants can be folded directly into another instruction, it
|
|
/// would be preferable to avoid the potential for register pressure (above we
|
|
/// can easily avoid it, but that isn't always true) and simply duplicate the
|
|
/// instruction using the PHI:
|
|
/// ```
|
|
/// entry:
|
|
/// br i1 %flag, label %a, label %b
|
|
///
|
|
/// a:
|
|
/// %sum.1 = add i32 %arg, 7
|
|
/// br label %exit
|
|
///
|
|
/// b:
|
|
/// %sum.2 = add i32 %arg, 11
|
|
/// br label %exit
|
|
///
|
|
/// exit:
|
|
/// %p = phi i32 [ %sum.1, %a ], [ %sum.2, %b ]
|
|
/// ret i32 %p
|
|
/// ```
|
|
/// Which will generate something like the following on x86:
|
|
/// ```
|
|
/// testq %eax, %eax
|
|
/// addl $7, %edi
|
|
/// jne .L
|
|
/// addl $11, %edi
|
|
/// .L:
|
|
/// movl %edi, %eax
|
|
/// retq
|
|
/// ```
|
|
///
|
|
/// It is important to note that this pass is never intended to handle more
|
|
/// complex cases where speculating around PHIs allows simplifications of the
|
|
/// IR itself or other subsequent optimizations. Those can and should already
|
|
/// be handled before this pass is ever run by a more powerful analysis that
|
|
/// can reason about equivalences and common subexpressions. Classically, those
|
|
/// cases would be handled by a GVN-powered PRE or similar transform. This
|
|
/// pass, in contrast, is *only* interested in cases where despite no
|
|
/// simplifications to the IR itself, speculation is *faster* to execute. The
|
|
/// result of this is that the cost models which are appropriate to consider
|
|
/// here are relatively simple ones around execution and codesize cost, without
|
|
/// any need to consider simplifications or other transformations.
|
|
struct SpeculateAroundPHIsPass : PassInfoMixin<SpeculateAroundPHIsPass> {
|
|
/// Run the pass over the function.
|
|
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif // LLVM_TRANSFORMS_SCALAR_SPECULATEAROUNDPHIS_H
|