Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/GlobalISel/Localizer.h
Line
Count
Source
1
//== llvm/CodeGen/GlobalISel/Localizer.h - Localizer -------------*- 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
/// \file This file describes the interface of the Localizer pass.
10
/// This pass moves/duplicates constant-like instructions close to their uses.
11
/// Its primarily goal is to workaround the deficiencies of the fast register
12
/// allocator.
13
/// With GlobalISel constants are all materialized in the entry block of
14
/// a function. However, the fast allocator cannot rematerialize constants and
15
/// has a lot more live-ranges to deal with and will most likely end up
16
/// spilling a lot.
17
/// By pushing the constants close to their use, we only create small
18
/// live-ranges.
19
//===----------------------------------------------------------------------===//
20
21
#ifndef LLVM_CODEGEN_GLOBALISEL_LOCALIZER_H
22
#define LLVM_CODEGEN_GLOBALISEL_LOCALIZER_H
23
24
#include "llvm/ADT/SetVector.h"
25
#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
26
#include "llvm/CodeGen/MachineFunctionPass.h"
27
28
namespace llvm {
29
// Forward declarations.
30
class MachineRegisterInfo;
31
class TargetTransformInfo;
32
33
/// This pass implements the localization mechanism described at the
34
/// top of this file. One specificity of the implementation is that
35
/// it will materialize one and only one instance of a constant per
36
/// basic block, thus enabling reuse of that constant within that block.
37
/// Moreover, it only materializes constants in blocks where they
38
/// are used. PHI uses are considered happening at the end of the
39
/// related predecessor.
40
class Localizer : public MachineFunctionPass {
41
public:
42
  static char ID;
43
44
private:
45
  /// MRI contains all the register class/bank information that this
46
  /// pass uses and updates.
47
  MachineRegisterInfo *MRI;
48
  /// TTI used for getting remat costs for instructions.
49
  TargetTransformInfo *TTI;
50
51
  /// Check whether or not \p MI needs to be moved close to its uses.
52
  bool shouldLocalize(const MachineInstr &MI);
53
54
  /// Check if \p MOUse is used in the same basic block as \p Def.
55
  /// If the use is in the same block, we say it is local.
56
  /// When the use is not local, \p InsertMBB will contain the basic
57
  /// block when to insert \p Def to have a local use.
58
  static bool isLocalUse(MachineOperand &MOUse, const MachineInstr &Def,
59
                         MachineBasicBlock *&InsertMBB);
60
61
  /// Initialize the field members using \p MF.
62
  void init(MachineFunction &MF);
63
64
  typedef SmallSetVector<MachineInstr *, 32> LocalizedSetVecT;
65
66
  /// Do inter-block localization from the entry block.
67
  bool localizeInterBlock(MachineFunction &MF,
68
                          LocalizedSetVecT &LocalizedInstrs);
69
70
  /// Do intra-block localization of already localized instructions.
71
  bool localizeIntraBlock(LocalizedSetVecT &LocalizedInstrs);
72
73
public:
74
  Localizer();
75
76
258
  StringRef getPassName() const override { return "Localizer"; }
77
78
87
  MachineFunctionProperties getRequiredProperties() const override {
79
87
    return MachineFunctionProperties()
80
87
        .set(MachineFunctionProperties::Property::IsSSA)
81
87
        .set(MachineFunctionProperties::Property::Legalized)
82
87
        .set(MachineFunctionProperties::Property::RegBankSelected);
83
87
  }
84
85
  void getAnalysisUsage(AnalysisUsage &AU) const override;
86
87
  bool runOnMachineFunction(MachineFunction &MF) override;
88
};
89
90
} // End namespace llvm.
91
92
#endif