Coverage Report

Created: 2019-02-20 00:17

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/MachineConstantPool.h
Line
Count
Source (jump to first uncovered line)
1
//===- CodeGen/MachineConstantPool.h - Abstract Constant Pool ---*- 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
10
/// This file declares the MachineConstantPool class which is an abstract
11
/// constant pool to keep track of constants referenced by a function.
12
//
13
//===----------------------------------------------------------------------===//
14
15
#ifndef LLVM_CODEGEN_MACHINECONSTANTPOOL_H
16
#define LLVM_CODEGEN_MACHINECONSTANTPOOL_H
17
18
#include "llvm/ADT/DenseSet.h"
19
#include "llvm/MC/SectionKind.h"
20
#include <climits>
21
#include <vector>
22
23
namespace llvm {
24
25
class Constant;
26
class DataLayout;
27
class FoldingSetNodeID;
28
class MachineConstantPool;
29
class raw_ostream;
30
class Type;
31
32
/// Abstract base class for all machine specific constantpool value subclasses.
33
///
34
class MachineConstantPoolValue {
35
  virtual void anchor();
36
37
  Type *Ty;
38
39
public:
40
1.52k
  explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
41
1.52k
  virtual ~MachineConstantPoolValue() = default;
42
43
  /// getType - get type of this MachineConstantPoolValue.
44
  ///
45
3.04k
  Type *getType() const { return Ty; }
46
47
  virtual int getExistingMachineCPValue(MachineConstantPool *CP,
48
                                        unsigned Alignment) = 0;
49
50
  virtual void addSelectionDAGCSEId(FoldingSetNodeID &ID) = 0;
51
52
  /// print - Implement operator<<
53
  virtual void print(raw_ostream &O) const = 0;
54
};
55
56
inline raw_ostream &operator<<(raw_ostream &OS,
57
0
                               const MachineConstantPoolValue &V) {
58
0
  V.print(OS);
59
0
  return OS;
60
0
}
61
62
/// This class is a data container for one entry in a MachineConstantPool.
63
/// It contains a pointer to the value and an offset from the start of
64
/// the constant pool.
65
/// An entry in a MachineConstantPool
66
class MachineConstantPoolEntry {
67
public:
68
  /// The constant itself.
69
  union {
70
    const Constant *ConstVal;
71
    MachineConstantPoolValue *MachineCPVal;
72
  } Val;
73
74
  /// The required alignment for this entry. The top bit is set when Val is
75
  /// a target specific MachineConstantPoolValue.
76
  unsigned Alignment;
77
78
  MachineConstantPoolEntry(const Constant *V, unsigned A)
79
54.2k
    : Alignment(A) {
80
54.2k
    Val.ConstVal = V;
81
54.2k
  }
82
83
  MachineConstantPoolEntry(MachineConstantPoolValue *V, unsigned A)
84
1.40k
      : Alignment(A) {
85
1.40k
    Val.MachineCPVal = V;
86
1.40k
    Alignment |= 1U << (sizeof(unsigned) * CHAR_BIT - 1);
87
1.40k
  }
88
89
  /// isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry
90
  /// is indeed a target specific constantpool entry, not a wrapper over a
91
  /// Constant.
92
2.58M
  bool isMachineConstantPoolEntry() const {
93
2.58M
    return (int)Alignment < 0;
94
2.58M
  }
95
96
187k
  int getAlignment() const {
97
187k
    return Alignment & ~(1 << (sizeof(unsigned) * CHAR_BIT - 1));
98
187k
  }
99
100
  Type *getType() const;
101
102
  /// This method classifies the entry according to whether or not it may
103
  /// generate a relocation entry.  This must be conservative, so if it might
104
  /// codegen to a relocatable entry, it should say so.
105
  bool needsRelocation() const;
106
107
  SectionKind getSectionKind(const DataLayout *DL) const;
108
};
109
110
/// The MachineConstantPool class keeps track of constants referenced by a
111
/// function which must be spilled to memory.  This is used for constants which
112
/// are unable to be used directly as operands to instructions, which typically
113
/// include floating point and large integer constants.
114
///
115
/// Instructions reference the address of these constant pool constants through
116
/// the use of MO_ConstantPoolIndex values.  When emitting assembly or machine
117
/// code, these virtual address references are converted to refer to the
118
/// address of the function constant pool values.
119
/// The machine constant pool.
120
class MachineConstantPool {
121
  unsigned PoolAlignment;       ///< The alignment for the pool.
122
  std::vector<MachineConstantPoolEntry> Constants; ///< The pool of constants.
123
  /// MachineConstantPoolValues that use an existing MachineConstantPoolEntry.
124
  DenseSet<MachineConstantPoolValue*> MachineCPVsSharingEntries;
125
  const DataLayout &DL;
126
127
  const DataLayout &getDataLayout() const { return DL; }
128
129
public:
130
  /// The only constructor.
131
  explicit MachineConstantPool(const DataLayout &DL)
132
502k
      : PoolAlignment(1), DL(DL) {}
133
  ~MachineConstantPool();
134
135
  /// getConstantPoolAlignment - Return the alignment required by
136
  /// the whole constant pool, of which the first element must be aligned.
137
2.23k
  unsigned getConstantPoolAlignment() const { return PoolAlignment; }
138
139
  /// getConstantPoolIndex - Create a new entry in the constant pool or return
140
  /// an existing one.  User must specify the minimum required alignment for
141
  /// the object.
142
  unsigned getConstantPoolIndex(const Constant *C, unsigned Alignment);
143
  unsigned getConstantPoolIndex(MachineConstantPoolValue *V,
144
                                unsigned Alignment);
145
146
  /// isEmpty - Return true if this constant pool contains no constants.
147
24.8k
  bool isEmpty() const { return Constants.empty(); }
148
149
491k
  const std::vector<MachineConstantPoolEntry> &getConstants() const {
150
491k
    return Constants;
151
491k
  }
152
153
  /// print - Used by the MachineFunction printer to print information about
154
  /// constant pool objects.  Implemented in MachineFunction.cpp
155
  void print(raw_ostream &OS) const;
156
157
  /// dump - Call print(cerr) to be called from the debugger.
158
  void dump() const;
159
};
160
161
} // end namespace llvm
162
163
#endif // LLVM_CODEGEN_MACHINECONSTANTPOOL_H