[llvm] r286484 - Fix some Clang-tidy modernize-use-default and readability-redundant-member-init and Include What You Use warnings; other minor fixes.
Eugene Zelenko via llvm-commits
llvm-commits at lists.llvm.org
Thu Nov 10 10:02:35 PST 2016
Author: eugenezelenko
Date: Thu Nov 10 12:02:34 2016
New Revision: 286484
URL: http://llvm.org/viewvc/llvm-project?rev=286484&view=rev
Log:
Fix some Clang-tidy modernize-use-default and readability-redundant-member-init and Include What You Use warnings; other minor fixes.
Differential revision: https://reviews.llvm.org/D26087
Modified:
llvm/trunk/include/llvm/CodeGen/DIE.h
llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h
llvm/trunk/include/llvm/CodeGen/MachineScheduler.h
llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h
llvm/trunk/include/llvm/Support/Allocator.h
llvm/trunk/include/llvm/Support/GCOV.h
llvm/trunk/include/llvm/Support/RWMutex.h
llvm/trunk/include/llvm/Support/SMLoc.h
Modified: llvm/trunk/include/llvm/CodeGen/DIE.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/DIE.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/DIE.h (original)
+++ llvm/trunk/include/llvm/CodeGen/DIE.h Thu Nov 10 12:02:34 2016
@@ -15,18 +15,28 @@
#define LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
#include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
#include "llvm/ADT/PointerIntPair.h"
-#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/CodeGen/DwarfStringPoolEntry.h"
+#include "llvm/Support/AlignOf.h"
+#include "llvm/Support/Allocator.h"
#include "llvm/Support/Dwarf.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iterator>
+#include <new>
+#include <type_traits>
namespace llvm {
+
class AsmPrinter;
class MCExpr;
class MCSymbol;
class raw_ostream;
-class DwarfTypeUnit;
//===--------------------------------------------------------------------===//
/// DIEAbbrevData - Dwarf abbreviation data, describes one attribute of a
@@ -75,7 +85,7 @@ class DIEAbbrev : public FoldingSetNode
SmallVector<DIEAbbrevData, 12> Data;
public:
- DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C), Data() {}
+ DIEAbbrev(dwarf::Tag T, bool C) : Tag(T), Children(C) {}
// Accessors.
dwarf::Tag getTag() const { return Tag; }
@@ -355,9 +365,11 @@ private:
public:
DIEValue() = default;
+
DIEValue(const DIEValue &X) : Ty(X.Ty), Attribute(X.Attribute), Form(X.Form) {
copyVal(X);
}
+
DIEValue &operator=(const DIEValue &X) {
destroyVal();
Ty = X.Ty;
@@ -366,6 +378,7 @@ public:
copyVal(X);
return *this;
}
+
~DIEValue() { destroyVal(); }
#define HANDLE_DIEVALUE_SMALL(T) \
@@ -413,6 +426,7 @@ public:
struct IntrusiveBackListNode {
PointerIntPair<IntrusiveBackListNode *, 1> Next;
+
IntrusiveBackListNode() : Next(this, true) {}
IntrusiveBackListNode *getNext() const {
@@ -576,12 +590,11 @@ public:
}
value_range values() {
- return llvm::make_range(value_iterator(List.begin()),
- value_iterator(List.end()));
+ return make_range(value_iterator(List.begin()), value_iterator(List.end()));
}
const_value_range values() const {
- return llvm::make_range(const_value_iterator(List.begin()),
- const_value_iterator(List.end()));
+ return make_range(const_value_iterator(List.begin()),
+ const_value_iterator(List.end()));
}
};
@@ -631,10 +644,10 @@ public:
typedef iterator_range<const_child_iterator> const_child_range;
child_range children() {
- return llvm::make_range(Children.begin(), Children.end());
+ return make_range(Children.begin(), Children.end());
}
const_child_range children() const {
- return llvm::make_range(Children.begin(), Children.end());
+ return make_range(Children.begin(), Children.end());
}
DIE *getParent() const { return Parent; }
@@ -740,6 +753,6 @@ public:
void print(raw_ostream &O) const;
};
-} // end llvm namespace
+} // end namespace llvm
-#endif
+#endif // LLVM_LIB_CODEGEN_ASMPRINTER_DIE_H
Modified: llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h (original)
+++ llvm/trunk/include/llvm/CodeGen/LivePhysRegs.h Thu Nov 10 12:02:34 2016
@@ -31,8 +31,10 @@
#include "llvm/ADT/SparseSet.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
+#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/Target/TargetRegisterInfo.h"
#include <cassert>
+#include <utility>
namespace llvm {
@@ -41,14 +43,15 @@ class MachineInstr;
/// \brief A set of live physical registers with functions to track liveness
/// when walking backward/forward through a basic block.
class LivePhysRegs {
- const TargetRegisterInfo *TRI;
+ const TargetRegisterInfo *TRI = nullptr;
SparseSet<unsigned> LiveRegs;
LivePhysRegs(const LivePhysRegs&) = delete;
LivePhysRegs &operator=(const LivePhysRegs&) = delete;
+
public:
/// \brief Constructs a new empty LivePhysRegs set.
- LivePhysRegs() : TRI(nullptr), LiveRegs() {}
+ LivePhysRegs() = default;
/// \brief Constructs and initialize an empty LivePhysRegs set.
LivePhysRegs(const TargetRegisterInfo *TRI) : TRI(TRI) {
@@ -153,6 +156,6 @@ inline raw_ostream &operator<<(raw_ostre
return OS;
}
-} // namespace llvm
+} // end namespace llvm
-#endif
+#endif // LLVM_CODEGEN_LIVEPHYSREGS_H
Modified: llvm/trunk/include/llvm/CodeGen/MachineScheduler.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineScheduler.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/MachineScheduler.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineScheduler.h Thu Nov 10 12:02:34 2016
@@ -75,12 +75,27 @@
#ifndef LLVM_CODEGEN_MACHINESCHEDULER_H
#define LLVM_CODEGEN_MACHINESCHEDULER_H
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
#include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachinePassRegistry.h"
#include "llvm/CodeGen/RegisterPressure.h"
+#include "llvm/CodeGen/ScheduleDAG.h"
#include "llvm/CodeGen/ScheduleDAGInstrs.h"
#include "llvm/CodeGen/ScheduleDAGMutation.h"
+#include "llvm/CodeGen/TargetSchedule.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <algorithm>
+#include <cassert>
#include <memory>
+#include <string>
+#include <vector>
namespace llvm {
@@ -91,7 +106,6 @@ class LiveIntervals;
class MachineDominatorTree;
class MachineLoopInfo;
class RegisterClassInfo;
-class ScheduleDAGInstrs;
class SchedDFSResult;
class ScheduleHazardRecognizer;
@@ -126,6 +140,7 @@ public:
: MachinePassRegistryNode(N, D, (MachinePassCtor)C) {
Registry.Add(this);
}
+
~MachineSchedRegistry() { Registry.Remove(this); }
// Accessors.
@@ -133,9 +148,11 @@ public:
MachineSchedRegistry *getNext() const {
return (MachineSchedRegistry *)MachinePassRegistryNode::getNext();
}
+
static MachineSchedRegistry *getList() {
return (MachineSchedRegistry *)Registry.getList();
}
+
static void setListener(MachinePassRegistryListener *L) {
Registry.setListener(L);
}
@@ -173,8 +190,9 @@ struct MachineSchedPolicy {
/// initPolicy -> shouldTrackPressure -> initialize(DAG) -> registerRoots
class MachineSchedStrategy {
virtual void anchor();
+
public:
- virtual ~MachineSchedStrategy() {}
+ virtual ~MachineSchedStrategy() = default;
/// Optionally override the per-region scheduling policy.
virtual void initPolicy(MachineBasicBlock::iterator Begin,
@@ -256,8 +274,7 @@ public:
bool RemoveKillFlags)
: ScheduleDAGInstrs(*C->MF, C->MLI, RemoveKillFlags), AA(C->AA),
LIS(C->LIS), SchedImpl(std::move(S)), Topo(SUnits, &ExitSU),
- CurrentTop(), CurrentBottom(), NextClusterPred(nullptr),
- NextClusterSucc(nullptr) {
+ NextClusterPred(nullptr), NextClusterSucc(nullptr) {
#ifndef NDEBUG
NumInstrsScheduled = 0;
#endif
@@ -847,7 +864,7 @@ protected:
const TargetRegisterInfo *TRI;
SchedRemainder Rem;
-protected:
+
GenericSchedulerBase(const MachineSchedContext *C):
Context(C), SchedModel(nullptr), TRI(nullptr) {}
@@ -919,7 +936,6 @@ protected:
/// Candidate last picked from Bot boundary.
SchedCandidate BotCand;
-
void checkAcyclicLatency();
void initCandidate(SchedCandidate &Cand, SUnit *SU, bool AtTop,
@@ -949,11 +965,12 @@ class PostGenericScheduler : public Gene
ScheduleDAGMI *DAG;
SchedBoundary Top;
SmallVector<SUnit*, 8> BotRoots;
+
public:
PostGenericScheduler(const MachineSchedContext *C):
GenericSchedulerBase(C), Top(SchedBoundary::TopQID, "TopQ") {}
- ~PostGenericScheduler() override {}
+ ~PostGenericScheduler() override = default;
void initPolicy(MachineBasicBlock::iterator Begin,
MachineBasicBlock::iterator End,
@@ -1009,6 +1026,6 @@ std::unique_ptr<ScheduleDAGMutation>
createCopyConstrainDAGMutation(const TargetInstrInfo *TII,
const TargetRegisterInfo *TRI);
-} // namespace llvm
+} // end namespace llvm
-#endif
+#endif // LLVM_CODEGEN_MACHINESCHEDULER_H
Modified: llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h (original)
+++ llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h Thu Nov 10 12:02:34 2016
@@ -19,23 +19,37 @@
#ifndef LLVM_CODEGEN_SELECTIONDAGNODES_H
#define LLVM_CODEGEN_SELECTIONDAGNODES_H
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/BitVector.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/GraphTraits.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/ilist_node.h"
+#include "llvm/ADT/iterator.h"
#include "llvm/ADT/iterator_range.h"
+#include "llvm/ADT/SmallPtrSet.h"
+#include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/ISDOpcodes.h"
#include "llvm/CodeGen/MachineMemOperand.h"
+#include "llvm/CodeGen/MachineValueType.h"
#include "llvm/CodeGen/ValueTypes.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DebugLoc.h"
+#include "llvm/IR/Instruction.h"
#include "llvm/IR/Instructions.h"
-#include "llvm/Support/DataTypes.h"
-#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/AlignOf.h"
+#include "llvm/Support/AtomicOrdering.h"
+#include "llvm/Support/Casting.h"
+#include "llvm/Support/ErrorHandling.h"
+#include <algorithm>
#include <cassert>
+#include <climits>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <string>
+#include <tuple>
namespace llvm {
@@ -44,11 +58,9 @@ class GlobalValue;
class MachineBasicBlock;
class MachineConstantPoolValue;
class SDNode;
-class HandleSDNode;
class Value;
class MCSymbol;
template <typename T> struct DenseMapInfo;
-template <typename T> struct simplify_type;
void checkForCycles(const SDNode *N, const SelectionDAG *DAG = nullptr,
bool force = false);
@@ -63,6 +75,7 @@ struct SDVTList {
};
namespace ISD {
+
/// Node predicates
/// If N is a BUILD_VECTOR node whose elements are all the same constant or
@@ -88,7 +101,8 @@ namespace ISD {
/// Return true if the node has at least one operand and all operands of the
/// specified node are ISD::UNDEF.
bool allOperandsUndef(const SDNode *N);
-} // end llvm:ISD namespace
+
+} // end namespace ISD
//===----------------------------------------------------------------------===//
/// Unlike LLVM values, Selection DAG nodes may return multiple
@@ -106,6 +120,7 @@ class SDValue {
SDNode *Node; // The node defining the value we are using.
unsigned ResNo; // Which return value of the node we are using.
+
public:
SDValue() : Node(nullptr), ResNo(0) {}
SDValue(SDNode *node, unsigned resno);
@@ -187,29 +202,30 @@ public:
inline bool hasOneUse() const;
};
-
template<> struct DenseMapInfo<SDValue> {
static inline SDValue getEmptyKey() {
SDValue V;
V.ResNo = -1U;
return V;
}
+
static inline SDValue getTombstoneKey() {
SDValue V;
V.ResNo = -2U;
return V;
}
+
static unsigned getHashValue(const SDValue &Val) {
return ((unsigned)((uintptr_t)Val.getNode() >> 4) ^
(unsigned)((uintptr_t)Val.getNode() >> 9)) + Val.getResNo();
}
+
static bool isEqual(const SDValue &LHS, const SDValue &RHS) {
return LHS == RHS;
}
};
template <> struct isPodLike<SDValue> { static const bool value = true; };
-
/// Allow casting operators to work directly on
/// SDValues as if they were SDNode*'s.
template<> struct simplify_type<SDValue> {
@@ -243,7 +259,7 @@ class SDUse {
void operator=(const SDUse &U) = delete;
public:
- SDUse() : Val(), User(nullptr), Prev(nullptr), Next(nullptr) {}
+ SDUse() : User(nullptr), Prev(nullptr), Next(nullptr) {}
/// Normally SDUse will just implicitly convert to an SDValue that it holds.
operator const SDValue&() const { return Val; }
@@ -600,9 +616,11 @@ public:
class use_iterator
: public std::iterator<std::forward_iterator_tag, SDUse, ptrdiff_t> {
SDUse *Op;
- explicit use_iterator(SDUse *op) : Op(op) {
- }
+
friend class SDNode;
+
+ explicit use_iterator(SDUse *op) : Op(op) {}
+
public:
typedef std::iterator<std::forward_iterator_tag,
SDUse, ptrdiff_t>::reference reference;
@@ -730,6 +748,7 @@ public:
}
typedef SDUse* op_iterator;
+
op_iterator op_begin() const { return OperandList; }
op_iterator op_end() const { return OperandList+NumOperands; }
ArrayRef<SDUse> ops() const { return makeArrayRef(op_begin(), op_end()); }
@@ -829,7 +848,6 @@ public:
void printrWithDepth(raw_ostream &O, const SelectionDAG *G = nullptr,
unsigned depth = 100) const;
-
/// Dump this node, for debugging.
void dump() const;
@@ -913,11 +931,11 @@ public:
if (I)
DL = I->getDebugLoc();
}
+
unsigned getIROrder() const { return IROrder; }
const DebugLoc &getDebugLoc() const { return DL; }
};
-
// Define inline functions from the SDValue class.
inline SDValue::SDValue(SDNode *node, unsigned resno)
@@ -933,48 +951,63 @@ inline SDValue::SDValue(SDNode *node, un
inline unsigned SDValue::getOpcode() const {
return Node->getOpcode();
}
+
inline EVT SDValue::getValueType() const {
return Node->getValueType(ResNo);
}
+
inline unsigned SDValue::getNumOperands() const {
return Node->getNumOperands();
}
+
inline const SDValue &SDValue::getOperand(unsigned i) const {
return Node->getOperand(i);
}
+
inline uint64_t SDValue::getConstantOperandVal(unsigned i) const {
return Node->getConstantOperandVal(i);
}
+
inline bool SDValue::isTargetOpcode() const {
return Node->isTargetOpcode();
}
+
inline bool SDValue::isTargetMemoryOpcode() const {
return Node->isTargetMemoryOpcode();
}
+
inline bool SDValue::isMachineOpcode() const {
return Node->isMachineOpcode();
}
+
inline unsigned SDValue::getMachineOpcode() const {
return Node->getMachineOpcode();
}
+
inline bool SDValue::isUndef() const {
return Node->isUndef();
}
+
inline bool SDValue::use_empty() const {
return !Node->hasAnyUseOfValue(ResNo);
}
+
inline bool SDValue::hasOneUse() const {
return Node->hasNUsesOfValue(1, ResNo);
}
+
inline const DebugLoc &SDValue::getDebugLoc() const {
return Node->getDebugLoc();
}
+
inline void SDValue::dump() const {
return Node->dump();
}
+
inline void SDValue::dumpr() const {
return Node->dumpr();
}
+
// Define inline functions from the SDUse class.
inline void SDUse::set(const SDValue &V) {
@@ -1021,9 +1054,11 @@ static bool isBinOpWithFlags(unsigned Op
class BinaryWithFlagsSDNode : public SDNode {
public:
SDNodeFlags Flags;
+
BinaryWithFlagsSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl,
SDVTList VTs, const SDNodeFlags &NodeFlags)
: SDNode(Opc, Order, dl, VTs), Flags(NodeFlags) {}
+
static bool classof(const SDNode *N) {
return isBinOpWithFlags(N->getOpcode());
}
@@ -1035,6 +1070,7 @@ public:
/// the AllNodes list.
class HandleSDNode : public SDNode {
SDUse Op;
+
public:
explicit HandleSDNode(SDValue X)
: SDNode(ISD::HANDLENODE, 0, DebugLoc(), getSDVTList(MVT::Other)) {
@@ -1052,6 +1088,7 @@ public:
OperandList = &Op;
}
~HandleSDNode();
+
const SDValue &getValue() const { return Op; }
};
@@ -1267,8 +1304,10 @@ class ShuffleVectorSDNode : public SDNod
// The memory for Mask is owned by the SelectionDAG's OperandAllocator, and
// is freed when the SelectionDAG object is destroyed.
const int *Mask;
+
protected:
friend class SelectionDAG;
+
ShuffleVectorSDNode(EVT VT, unsigned Order, const DebugLoc &dl, const int *M)
: SDNode(ISD::VECTOR_SHUFFLE, Order, dl, getSDVTList(VT)), Mask(M) {}
@@ -1277,12 +1316,14 @@ public:
EVT VT = getValueType(0);
return makeArrayRef(Mask, VT.getVectorNumElements());
}
+
int getMaskElt(unsigned Idx) const {
assert(Idx < getValueType(0).getVectorNumElements() && "Idx out of range!");
return Mask[Idx];
}
bool isSplat() const { return isSplatMask(Mask, getValueType(0)); }
+
int getSplatIndex() const {
assert(isSplat() && "Cannot get splat index for non-splat!");
EVT VT = getValueType(0);
@@ -1292,6 +1333,7 @@ public:
}
llvm_unreachable("Splat with all undef indices?");
}
+
static bool isSplatMask(const int *Mask, EVT VT);
/// Change values in a shuffle permute mask assuming
@@ -1316,7 +1358,9 @@ public:
class ConstantSDNode : public SDNode {
const ConstantInt *Value;
+
friend class SelectionDAG;
+
ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val,
const DebugLoc &DL, EVT VT)
: SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DL,
@@ -1324,8 +1368,8 @@ class ConstantSDNode : public SDNode {
Value(val) {
ConstantSDNodeBits.IsOpaque = isOpaque;
}
-public:
+public:
const ConstantInt *getConstantIntValue() const { return Value; }
const APInt &getAPIntValue() const { return Value->getValue(); }
uint64_t getZExtValue() const { return Value->getZExtValue(); }
@@ -1345,7 +1389,9 @@ public:
class ConstantFPSDNode : public SDNode {
const ConstantFP *Value;
+
friend class SelectionDAG;
+
ConstantFPSDNode(bool isTarget, const ConstantFP *val, const DebugLoc &DL,
EVT VT)
: SDNode(isTarget ? ISD::TargetConstantFP : ISD::ConstantFP, 0, DL,
@@ -1353,7 +1399,6 @@ class ConstantFPSDNode : public SDNode {
Value(val) {}
public:
-
const APFloat& getValueAPF() const { return Value->getValueAPF(); }
const ConstantFP *getConstantFPValue() const { return Value; }
@@ -1416,7 +1461,6 @@ ConstantSDNode *isConstOrConstSplat(SDVa
/// Returns the SDNode if it is a constant splat BuildVector or constant float.
ConstantFPSDNode *isConstOrConstSplatFP(SDValue V);
-
class GlobalAddressSDNode : public SDNode {
const GlobalValue *TheGlobal;
int64_t Offset;
@@ -1427,7 +1471,6 @@ class GlobalAddressSDNode : public SDNod
unsigned char TargetFlags);
public:
-
const GlobalValue *getGlobal() const { return TheGlobal; }
int64_t getOffset() const { return Offset; }
unsigned char getTargetFlags() const { return TargetFlags; }
@@ -1444,13 +1487,15 @@ public:
class FrameIndexSDNode : public SDNode {
int FI;
+
friend class SelectionDAG;
+
FrameIndexSDNode(int fi, EVT VT, bool isTarg)
: SDNode(isTarg ? ISD::TargetFrameIndex : ISD::FrameIndex,
0, DebugLoc(), getSDVTList(VT)), FI(fi) {
}
-public:
+public:
int getIndex() const { return FI; }
static bool classof(const SDNode *N) {
@@ -1462,13 +1507,15 @@ public:
class JumpTableSDNode : public SDNode {
int JTI;
unsigned char TargetFlags;
+
friend class SelectionDAG;
+
JumpTableSDNode(int jti, EVT VT, bool isTarg, unsigned char TF)
: SDNode(isTarg ? ISD::TargetJumpTable : ISD::JumpTable,
0, DebugLoc(), getSDVTList(VT)), JTI(jti), TargetFlags(TF) {
}
-public:
+public:
int getIndex() const { return JTI; }
unsigned char getTargetFlags() const { return TargetFlags; }
@@ -1486,7 +1533,9 @@ class ConstantPoolSDNode : public SDNode
int Offset; // It's a MachineConstantPoolValue if top bit is set.
unsigned Alignment; // Minimum alignment requirement of CP (not log2 value).
unsigned char TargetFlags;
+
friend class SelectionDAG;
+
ConstantPoolSDNode(bool isTarget, const Constant *c, EVT VT, int o,
unsigned Align, unsigned char TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
@@ -1495,6 +1544,7 @@ class ConstantPoolSDNode : public SDNode
assert(Offset >= 0 && "Offset is too large");
Val.ConstVal = c;
}
+
ConstantPoolSDNode(bool isTarget, MachineConstantPoolValue *v,
EVT VT, int o, unsigned Align, unsigned char TF)
: SDNode(isTarget ? ISD::TargetConstantPool : ISD::ConstantPool, 0,
@@ -1504,8 +1554,8 @@ class ConstantPoolSDNode : public SDNode
Val.MachineCPVal = v;
Offset |= 1 << (sizeof(unsigned)*CHAR_BIT-1);
}
-public:
+public:
bool isMachineConstantPoolEntry() const {
return Offset < 0;
}
@@ -1542,13 +1592,13 @@ class TargetIndexSDNode : public SDNode
unsigned char TargetFlags;
int Index;
int64_t Offset;
+
friend class SelectionDAG;
-public:
+public:
TargetIndexSDNode(int Idx, EVT VT, int64_t Ofs, unsigned char TF)
: SDNode(ISD::TargetIndex, 0, DebugLoc(), getSDVTList(VT)),
TargetFlags(TF), Index(Idx), Offset(Ofs) {}
-public:
unsigned char getTargetFlags() const { return TargetFlags; }
int getIndex() const { return Index; }
@@ -1561,15 +1611,17 @@ public:
class BasicBlockSDNode : public SDNode {
MachineBasicBlock *MBB;
+
friend class SelectionDAG;
+
/// Debug info is meaningful and potentially useful here, but we create
/// blocks out of order when they're jumped to, which makes it a bit
/// harder. Let's see if we need it first.
explicit BasicBlockSDNode(MachineBasicBlock *mbb)
: SDNode(ISD::BasicBlock, 0, DebugLoc(), getSDVTList(MVT::Other)), MBB(mbb)
{}
-public:
+public:
MachineBasicBlock *getBasicBlock() const { return MBB; }
static bool classof(const SDNode *N) {
@@ -1581,6 +1633,7 @@ public:
class BuildVectorSDNode : public SDNode {
// These are constructed as SDNodes and then cast to BuildVectorSDNodes.
explicit BuildVectorSDNode() = delete;
+
public:
/// Check if this is a constant splat, and if so, find the
/// smallest element size that splats the vector. If MinSplatBits is
@@ -1639,7 +1692,9 @@ public:
///
class SrcValueSDNode : public SDNode {
const Value *V;
+
friend class SelectionDAG;
+
/// Create a SrcValue for a general value.
explicit SrcValueSDNode(const Value *v)
: SDNode(ISD::SRCVALUE, 0, DebugLoc(), getSDVTList(MVT::Other)), V(v) {}
@@ -1655,12 +1710,14 @@ public:
class MDNodeSDNode : public SDNode {
const MDNode *MD;
+
friend class SelectionDAG;
+
explicit MDNodeSDNode(const MDNode *md)
: SDNode(ISD::MDNODE_SDNODE, 0, DebugLoc(), getSDVTList(MVT::Other)), MD(md)
{}
-public:
+public:
const MDNode *getMD() const { return MD; }
static bool classof(const SDNode *N) {
@@ -1670,12 +1727,13 @@ public:
class RegisterSDNode : public SDNode {
unsigned Reg;
+
friend class SelectionDAG;
+
RegisterSDNode(unsigned reg, EVT VT)
- : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {
- }
-public:
+ : SDNode(ISD::Register, 0, DebugLoc(), getSDVTList(VT)), Reg(reg) {}
+public:
unsigned getReg() const { return Reg; }
static bool classof(const SDNode *N) {
@@ -1686,12 +1744,14 @@ public:
class RegisterMaskSDNode : public SDNode {
// The memory for RegMask is not owned by the node.
const uint32_t *RegMask;
+
friend class SelectionDAG;
+
RegisterMaskSDNode(const uint32_t *mask)
: SDNode(ISD::RegisterMask, 0, DebugLoc(), getSDVTList(MVT::Untyped)),
RegMask(mask) {}
-public:
+public:
const uint32_t *getRegMask() const { return RegMask; }
static bool classof(const SDNode *N) {
@@ -1703,12 +1763,15 @@ class BlockAddressSDNode : public SDNode
const BlockAddress *BA;
int64_t Offset;
unsigned char TargetFlags;
+
friend class SelectionDAG;
+
BlockAddressSDNode(unsigned NodeTy, EVT VT, const BlockAddress *ba,
int64_t o, unsigned char Flags)
: SDNode(NodeTy, 0, DebugLoc(), getSDVTList(VT)),
BA(ba), Offset(o), TargetFlags(Flags) {
}
+
public:
const BlockAddress *getBlockAddress() const { return BA; }
int64_t getOffset() const { return Offset; }
@@ -1722,7 +1785,9 @@ public:
class EHLabelSDNode : public SDNode {
MCSymbol *Label;
+
friend class SelectionDAG;
+
EHLabelSDNode(unsigned Order, const DebugLoc &dl, MCSymbol *L)
: SDNode(ISD::EH_LABEL, Order, dl, getSDVTList(MVT::Other)), Label(L) {}
@@ -1739,12 +1804,12 @@ class ExternalSymbolSDNode : public SDNo
unsigned char TargetFlags;
friend class SelectionDAG;
+
ExternalSymbolSDNode(bool isTarget, const char *Sym, unsigned char TF, EVT VT)
: SDNode(isTarget ? ISD::TargetExternalSymbol : ISD::ExternalSymbol,
- 0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {
- }
-public:
+ 0, DebugLoc(), getSDVTList(VT)), Symbol(Sym), TargetFlags(TF) {}
+public:
const char *getSymbol() const { return Symbol; }
unsigned char getTargetFlags() const { return TargetFlags; }
@@ -1771,13 +1836,14 @@ public:
class CondCodeSDNode : public SDNode {
ISD::CondCode Condition;
+
friend class SelectionDAG;
+
explicit CondCodeSDNode(ISD::CondCode Cond)
: SDNode(ISD::CONDCODE, 0, DebugLoc(), getSDVTList(MVT::Other)),
- Condition(Cond) {
- }
-public:
+ Condition(Cond) {}
+public:
ISD::CondCode get() const { return Condition; }
static bool classof(const SDNode *N) {
@@ -1789,7 +1855,9 @@ public:
/// future and most targets don't support it.
class CvtRndSatSDNode : public SDNode {
ISD::CvtCode CvtCode;
+
friend class SelectionDAG;
+
explicit CvtRndSatSDNode(EVT VT, unsigned Order, const DebugLoc &dl,
ISD::CvtCode Code)
: SDNode(ISD::CONVERT_RNDSAT, Order, dl, getSDVTList(VT)), CvtCode(Code) {
@@ -1807,13 +1875,14 @@ public:
/// to parameterize some operations.
class VTSDNode : public SDNode {
EVT ValueType;
+
friend class SelectionDAG;
+
explicit VTSDNode(EVT VT)
: SDNode(ISD::VALUETYPE, 0, DebugLoc(), getSDVTList(MVT::Other)),
- ValueType(VT) {
- }
-public:
+ ValueType(VT) {}
+public:
EVT getVT() const { return ValueType; }
static bool classof(const SDNode *N) {
@@ -1857,6 +1926,7 @@ public:
/// This class is used to represent ISD::LOAD nodes.
class LoadSDNode : public LSBaseSDNode {
friend class SelectionDAG;
+
LoadSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
ISD::MemIndexedMode AM, ISD::LoadExtType ETy, EVT MemVT,
MachineMemOperand *MMO)
@@ -1865,8 +1935,8 @@ class LoadSDNode : public LSBaseSDNode {
assert(readMem() && "Load MachineMemOperand is not a load!");
assert(!writeMem() && "Load MachineMemOperand is a store!");
}
-public:
+public:
/// Return whether this is a plain node,
/// or one of the varieties of value-extending loads.
ISD::LoadExtType getExtensionType() const {
@@ -1884,6 +1954,7 @@ public:
/// This class is used to represent ISD::STORE nodes.
class StoreSDNode : public LSBaseSDNode {
friend class SelectionDAG;
+
StoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
ISD::MemIndexedMode AM, bool isTrunc, EVT MemVT,
MachineMemOperand *MMO)
@@ -1892,8 +1963,8 @@ class StoreSDNode : public LSBaseSDNode
assert(!readMem() && "Store MachineMemOperand is a load!");
assert(writeMem() && "Store MachineMemOperand is not a store!");
}
-public:
+public:
/// Return true if the op does a truncation before store.
/// For integers this is the same as doing a TRUNCATE and storing the result.
/// For floats, it is the same as doing an FP_ROUND and storing the result.
@@ -1912,6 +1983,7 @@ public:
class MaskedLoadStoreSDNode : public MemSDNode {
public:
friend class SelectionDAG;
+
MaskedLoadStoreSDNode(ISD::NodeType NodeTy, unsigned Order,
const DebugLoc &dl, SDVTList VTs, EVT MemVT,
MachineMemOperand *MMO)
@@ -1956,9 +2028,9 @@ public:
/// This class is used to represent an MSTORE node
class MaskedStoreSDNode : public MaskedLoadStoreSDNode {
-
public:
friend class SelectionDAG;
+
MaskedStoreSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
bool isTrunc, bool isCompressing, EVT MemVT,
MachineMemOperand *MMO)
@@ -1966,6 +2038,7 @@ public:
StoreSDNodeBits.IsTruncating = isTrunc;
StoreSDNodeBits.IsCompressing = isCompressing;
}
+
/// Return true if the op does a truncation before store.
/// For integers this is the same as doing a TRUNCATE and storing the result.
/// For floats, it is the same as doing an FP_ROUND and storing the result.
@@ -1990,6 +2063,7 @@ public:
class MaskedGatherScatterSDNode : public MemSDNode {
public:
friend class SelectionDAG;
+
MaskedGatherScatterSDNode(ISD::NodeType NodeTy, unsigned Order,
const DebugLoc &dl, SDVTList VTs, EVT MemVT,
MachineMemOperand *MMO)
@@ -2015,6 +2089,7 @@ public:
class MaskedGatherSDNode : public MaskedGatherScatterSDNode {
public:
friend class SelectionDAG;
+
MaskedGatherSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
EVT MemVT, MachineMemOperand *MMO)
: MaskedGatherScatterSDNode(ISD::MGATHER, Order, dl, VTs, MemVT, MMO) {}
@@ -2027,9 +2102,9 @@ public:
/// This class is used to represent an MSCATTER node
///
class MaskedScatterSDNode : public MaskedGatherScatterSDNode {
-
public:
friend class SelectionDAG;
+
MaskedScatterSDNode(unsigned Order, const DebugLoc &dl, SDVTList VTs,
EVT MemVT, MachineMemOperand *MMO)
: MaskedGatherScatterSDNode(ISD::MSCATTER, Order, dl, VTs, MemVT, MMO) {}
@@ -2048,6 +2123,7 @@ public:
private:
friend class SelectionDAG;
+
MachineSDNode(unsigned Opc, unsigned Order, const DebugLoc &DL, SDVTList VTs)
: SDNode(Opc, Order, DL, VTs), MemRefs(nullptr), MemRefsEnd(nullptr) {}
@@ -2080,6 +2156,7 @@ class SDNodeIterator : public std::itera
unsigned Operand;
SDNodeIterator(const SDNode *N, unsigned Op) : Node(N), Operand(Op) {}
+
public:
bool operator==(const SDNodeIterator& x) const {
return Operand == x.Operand;
@@ -2116,6 +2193,7 @@ public:
template <> struct GraphTraits<SDNode*> {
typedef SDNode *NodeRef;
typedef SDNodeIterator ChildIteratorType;
+
static NodeRef getEntryNode(SDNode *N) { return N; }
static ChildIteratorType child_begin(NodeRef N) {
return SDNodeIterator::begin(N);
@@ -2137,6 +2215,7 @@ typedef AlignedCharArrayUnion<AtomicSDNo
typedef GlobalAddressSDNode MostAlignedSDNode;
namespace ISD {
+
/// Returns true if the specified node is a non-extending and unindexed load.
inline bool isNormalLoad(const SDNode *N) {
const LoadSDNode *Ld = dyn_cast<LoadSDNode>(N);
@@ -2197,8 +2276,9 @@ namespace ISD {
return isa<StoreSDNode>(N) &&
cast<StoreSDNode>(N)->getAddressingMode() == ISD::UNINDEXED;
}
-}
-} // end llvm namespace
+} // end namespace ISD
+
+} // end namespace llvm
-#endif
+#endif // LLVM_CODEGEN_SELECTIONDAGNODES_H
Modified: llvm/trunk/include/llvm/Support/Allocator.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/Allocator.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/Allocator.h (original)
+++ llvm/trunk/include/llvm/Support/Allocator.h Thu Nov 10 12:02:34 2016
@@ -22,13 +22,16 @@
#define LLVM_SUPPORT_ALLOCATOR_H
#include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/MathExtras.h"
-#include "llvm/Support/Memory.h"
#include <algorithm>
#include <cassert>
#include <cstddef>
+#include <cstdint>
#include <cstdlib>
+#include <iterator>
+#include <type_traits>
+#include <utility>
namespace llvm {
@@ -113,7 +116,8 @@ namespace detail {
// printing code uses Allocator.h in its implementation.
void printBumpPtrAllocatorStats(unsigned NumSlabs, size_t BytesAllocated,
size_t TotalMemory);
-} // End namespace detail.
+
+} // end namespace detail
/// \brief Allocate memory in an ever growing pool, as if by bump-pointer.
///
@@ -365,7 +369,7 @@ template <typename T> class SpecificBump
BumpPtrAllocator Allocator;
public:
- SpecificBumpPtrAllocator() : Allocator() {}
+ SpecificBumpPtrAllocator() = default;
SpecificBumpPtrAllocator(SpecificBumpPtrAllocator &&Old)
: Allocator(std::move(Old.Allocator)) {}
~SpecificBumpPtrAllocator() { DestroyAll(); }
@@ -409,7 +413,7 @@ public:
T *Allocate(size_t num = 1) { return Allocator.Allocate<T>(num); }
};
-} // end namespace llvm
+} // end namespace llvm
template <typename AllocatorT, size_t SlabSize, size_t SizeThreshold>
void *operator new(size_t Size,
Modified: llvm/trunk/include/llvm/Support/GCOV.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/GCOV.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/GCOV.h (original)
+++ llvm/trunk/include/llvm/Support/GCOV.h Thu Nov 10 12:02:34 2016
@@ -1,4 +1,4 @@
-//===- GCOV.h - LLVM coverage tool ----------------------------------------===//
+//===- GCOV.h - LLVM coverage tool ------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@@ -16,12 +16,20 @@
#define LLVM_SUPPORT_GCOV_H
#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/iterator_range.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringMap.h"
-#include "llvm/ADT/iterator.h"
+#include "llvm/ADT/StringRef.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
namespace llvm {
@@ -30,6 +38,7 @@ class GCOVBlock;
class FileInfo;
namespace GCOV {
+
enum GCOVVersion { V402, V404, V704 };
/// \brief A struct for passing gcov options between functions.
@@ -47,7 +56,8 @@ struct Options {
bool LongFileNames;
bool NoOutput;
};
-} // end GCOV namespace
+
+} // end namespace GCOV
/// GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific
/// read operations.
@@ -232,8 +242,9 @@ private:
class GCOVFile {
public:
GCOVFile()
- : GCNOInitialized(false), Checksum(0), Functions(), RunCount(0),
+ : GCNOInitialized(false), Checksum(0), RunCount(0),
ProgramCount(0) {}
+
bool readGCNO(GCOVBuffer &Buffer);
bool readGCDA(GCOVBuffer &Buffer);
uint32_t getChecksum() const { return Checksum; }
@@ -312,9 +323,9 @@ public:
typedef SmallVectorImpl<GCOVEdge *>::const_iterator EdgeIterator;
GCOVBlock(GCOVFunction &P, uint32_t N)
- : Parent(P), Number(N), Counter(0), DstEdgesAreSorted(true), SrcEdges(),
- DstEdges(), Lines() {}
+ : Parent(P), Number(N), Counter(0), DstEdgesAreSorted(true) {}
~GCOVBlock();
+
const GCOVFunction &getParent() const { return Parent; }
void addLine(uint32_t N) { Lines.push_back(N); }
uint32_t getLastLine() const { return Lines.back(); }
@@ -325,6 +336,7 @@ public:
assert(&Edge->Dst == this); // up to caller to ensure edge is valid
SrcEdges.push_back(Edge);
}
+
void addDstEdge(GCOVEdge *Edge) {
assert(&Edge->Src == this); // up to caller to ensure edge is valid
// Check if adding this edge causes list to become unsorted.
@@ -332,6 +344,7 @@ public:
DstEdgesAreSorted = false;
DstEdges.push_back(Edge);
}
+
size_t getNumSrcEdges() const { return SrcEdges.size(); }
size_t getNumDstEdges() const { return DstEdges.size(); }
void sortDstEdges();
@@ -396,19 +409,21 @@ class FileInfo {
public:
FileInfo(const GCOV::Options &Options)
- : Options(Options), LineInfo(), RunCount(0), ProgramCount(0) {}
+ : Options(Options), RunCount(0), ProgramCount(0) {}
void addBlockLine(StringRef Filename, uint32_t Line, const GCOVBlock *Block) {
if (Line > LineInfo[Filename].LastLine)
LineInfo[Filename].LastLine = Line;
LineInfo[Filename].Blocks[Line - 1].push_back(Block);
}
+
void addFunctionLine(StringRef Filename, uint32_t Line,
const GCOVFunction *Function) {
if (Line > LineInfo[Filename].LastLine)
LineInfo[Filename].LastLine = Line;
LineInfo[Filename].Functions[Line - 1].push_back(Function);
}
+
void setRunCount(uint32_t Runs) { RunCount = Runs; }
void setProgramCount(uint32_t Programs) { ProgramCount = Programs; }
void print(raw_ostream &OS, StringRef MainFilename, StringRef GCNOFile,
@@ -440,6 +455,7 @@ private:
FileCoverageList FileCoverages;
FuncCoverageMap FuncCoverages;
};
-}
-#endif
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_GCOV_H
Modified: llvm/trunk/include/llvm/Support/RWMutex.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/RWMutex.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/RWMutex.h (original)
+++ llvm/trunk/include/llvm/Support/RWMutex.h Thu Nov 10 12:02:34 2016
@@ -18,10 +18,9 @@
#include "llvm/Support/Threading.h"
#include <cassert>
-namespace llvm
-{
- namespace sys
- {
+namespace llvm {
+namespace sys {
+
/// @brief Platform agnostic RWMutex class.
class RWMutexImpl
{
@@ -89,9 +88,11 @@ namespace llvm
template<bool mt_only>
class SmartRWMutex {
RWMutexImpl impl;
- unsigned readers, writers;
+ unsigned readers = 0;
+ unsigned writers = 0;
+
public:
- explicit SmartRWMutex() : impl(), readers(0), writers(0) { }
+ explicit SmartRWMutex() = default;
bool lock_shared() {
if (!mt_only || llvm_is_multithreaded())
@@ -140,6 +141,7 @@ namespace llvm
SmartRWMutex(const SmartRWMutex<mt_only> & original);
void operator=(const SmartRWMutex<mt_only> &);
};
+
typedef SmartRWMutex<false> RWMutex;
/// ScopedReader - RAII acquisition of a reader lock
@@ -155,6 +157,7 @@ namespace llvm
mutex.unlock_shared();
}
};
+
typedef SmartScopedReader<false> ScopedReader;
/// ScopedWriter - RAII acquisition of a writer lock
@@ -170,8 +173,10 @@ namespace llvm
mutex.unlock();
}
};
+
typedef SmartScopedWriter<false> ScopedWriter;
- }
-}
-#endif
+} // end namespace sys
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_RWMUTEX_H
Modified: llvm/trunk/include/llvm/Support/SMLoc.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/SMLoc.h?rev=286484&r1=286483&r2=286484&view=diff
==============================================================================
--- llvm/trunk/include/llvm/Support/SMLoc.h (original)
+++ llvm/trunk/include/llvm/Support/SMLoc.h Thu Nov 10 12:02:34 2016
@@ -50,8 +50,8 @@ class SMRange {
public:
SMLoc Start, End;
- SMRange() {}
- SMRange(NoneType) : Start(), End() {}
+ SMRange() = default;
+ SMRange(NoneType) {}
SMRange(SMLoc St, SMLoc En) : Start(St), End(En) {
assert(Start.isValid() == End.isValid() &&
"Start and end should either both be valid or both be invalid!");
@@ -62,4 +62,4 @@ public:
} // end namespace llvm
-#endif
+#endif // LLVM_SUPPORT_SMLOC_H
More information about the llvm-commits
mailing list