Skip to content
Snippets Groups Projects
Commit f576b42b authored by Jim Laskey's avatar Jim Laskey
Browse files

Switch over from SelectionNodeCSEMap to FoldingSet. 

llvm-svn: 31240
parent 2e13bf24
No related branches found
No related tags found
No related merge requests found
Expand all Hide whitespace changes
Inline Side-by-side
Showing
with 224 additions and 548 deletions
llvm/include/llvm/CodeGen/MachineConstantPool.h
+ 3
− 2
View file @ f576b42b
......@@ -15,7 +15,8 @@
#ifndef LLVM_CODEGEN_MACHINECONSTANTPOOL_H
#define LLVM_CODEGEN_MACHINECONSTANTPOOL_H
#include "llvm/CodeGen/SelectionDAGCSEMap.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/CodeGen/SelectionDAGNodes.h"
#include <vector>
#include <iosfwd>
......@@ -43,7 +44,7 @@ public:
virtual int getExistingMachineCPValue(MachineConstantPool *CP,
unsigned Alignment) = 0;
virtual void AddSelectionDAGCSEId(SelectionDAGCSEMap::NodeID *Id) = 0;
virtual void AddSelectionDAGCSEId(FoldingSetNodeID &ID) = 0;
/// print - Implement operator<<...
///
......
llvm/include/llvm/CodeGen/SelectionDAG.h
+ 4
− 2
View file @ f576b42b
......@@ -15,8 +15,9 @@
#ifndef LLVM_CODEGEN_SELECTIONDAG_H
#define LLVM_CODEGEN_SELECTIONDAG_H
#include "llvm/CodeGen/SelectionDAGCSEMap.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/ilist"
#include "llvm/CodeGen/SelectionDAGNodes.h"
#include <list>
#include <vector>
......@@ -31,6 +32,7 @@ namespace llvm {
class MachineDebugInfo;
class MachineFunction;
class MachineConstantPoolValue;
class SDOperand;
/// SelectionDAG class - This is used to represent a portion of an LLVM function
/// in a low-level Data Dependence DAG representation suitable for instruction
......@@ -56,7 +58,7 @@ class SelectionDAG {
/// CSEMap - This structure is used to memoize nodes, automatically performing
/// CSE with existing nodes with a duplicate is requested.
SelectionDAGCSEMap CSEMap;
FoldingSet<SDNode> CSEMap;
public:
SelectionDAG(TargetLowering &tli, MachineFunction &mf, MachineDebugInfo *di)
......
llvm/include/llvm/CodeGen/SelectionDAGCSEMap.h deleted 100644 → 0
+ 0
− 129
View file @ 2e13bf24
//===-- llvm/CodeGen/SelectionDAGCSEMap.h - CSE Map for SD ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Chris Lattner and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file declares the SelectionDAG class, and transitively defines the
// SDNode class and subclasses.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_SELECTIONDAGCSEMAP_H
#define LLVM_CODEGEN_SELECTIONDAGCSEMAP_H
#include "llvm/ADT/SmallVector.h"
#include "llvm/CodeGen/SelectionDAGNodes.h"
namespace llvm {
class SDNode;
class SDOperand;
struct SDVTList;
/// SelectionDAGCSEMap - This class is used for two purposes:
/// 1. Given information (e.g. opcode and operand info) about a node we want
/// to create, look up the unique instance of the node in the map. If
/// the node already exists, return it, otherwise return the bucket it
/// should be inserted into.
/// 2. Given a node that has already been created, remove it from the CSE
/// map.
///
/// This class is implemented as a chained hash table, where the "buckets" are
/// actually the SDNodes themselves (the next pointer is in the SDNode).
///
class SelectionDAGCSEMap {
void **Buckets;
unsigned NumBuckets; // Always a power of 2.
unsigned NumNodes;
public:
class NodeID;
SelectionDAGCSEMap();
~SelectionDAGCSEMap();
/// RemoveNode - Remove a node from the CSE map, returning true if one was
/// removed or false if the node was not in the CSE map.
bool RemoveNode(SDNode *N);
/// GetOrInsertSimpleNode - If there is an existing simple SDNode exactly
/// equal to the specified node, return it. Otherwise, insert 'N' and it
/// instead. This only works on *simple* SDNodes, not ConstantSDNode or any
/// other classes derived from SDNode.
SDNode *GetOrInsertNode(SDNode *N);
/// FindNodeOrInsertPos - Look up the node specified by ID. If it exists,
/// return it. If not, return the insertion token that will make insertion
/// faster.
SDNode *FindNodeOrInsertPos(const NodeID &ID, void *&InsertPos);
/// InsertNode - Insert the specified node into the CSE Map, knowing that it
/// is not already in the map. InsertPos must be obtained from
/// FindNodeOrInsertPos.
void InsertNode(SDNode *N, void *InsertPos);
class NodeID {
/// Use a SmallVector to avoid a heap allocation in the common case.
///
SmallVector<unsigned, 32> Bits;
public:
NodeID() {}
NodeID(SDNode *N);
NodeID(unsigned short ID, SDVTList VTList);
NodeID(unsigned short ID, SDVTList VTList, SDOperand Op);
NodeID(unsigned short ID, SDVTList VTList,
SDOperand Op1, SDOperand Op2);
NodeID(unsigned short ID, SDVTList VTList,
SDOperand Op1, SDOperand Op2, SDOperand Op3);
NodeID(unsigned short ID, SDVTList VTList,
const SDOperand *OpList, unsigned N);
void SetOpcode(unsigned short ID) {
Bits.push_back(ID);
}
/// getOpcode - Return the opcode that has been set for this NodeID.
///
unsigned getOpcode() const {
return Bits[0];
}
void SetValueTypes(SDVTList VTList);
void SetOperands() {}
void SetOperands(SDOperand Op) { AddOperand(Op); }
void SetOperands(SDOperand Op1, SDOperand Op2) {
AddOperand(Op1); AddOperand(Op2);
}
void SetOperands(SDOperand Op1, SDOperand Op2, SDOperand Op3) {
AddOperand(Op1); AddOperand(Op2); AddOperand(Op3);
}
void SetOperands(const SDOperand *Ops, unsigned NumOps);
void AddOperand(SDOperand Op);
void AddPointer(const void *Ptr);
void AddInteger(signed I) {
Bits.push_back(I);
}
void AddInteger(unsigned I) {
Bits.push_back(I);
}
void AddInteger(uint64_t I) {
Bits.push_back(unsigned(I));
Bits.push_back(unsigned(I >> 32));
}
unsigned ComputeHash() const;
bool operator==(const NodeID &RHS) const;
};
private:
SDNode *GetNextPtr(void *NextInBucketPtr);
SDNode *GetNextPtr(void *NextInBucketPtr, void **Buckets, unsigned NumBuck);
void **GetBucketPtr(void *NextInBucketPtr);
void **GetBucketFor(const NodeID &ID) const;
void GrowHashTable();
};
} // end namespace llvm
#endif
llvm/include/llvm/CodeGen/SelectionDAGNodes.h
+ 6
− 16
View file @ f576b42b
......@@ -20,6 +20,7 @@
#define LLVM_CODEGEN_SELECTIONDAGNODES_H
#include "llvm/Value.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/GraphTraits.h"
#include "llvm/ADT/iterator"
#include "llvm/ADT/SmallVector.h"
......@@ -742,7 +743,7 @@ template<> struct simplify_type<const SDOperand> {
/// SDNode - Represents one node in the SelectionDAG.
///
class SDNode {
class SDNode : public FoldingSetNode {
/// NodeType - The operation that this node performs.
///
unsigned short NodeType;
......@@ -766,9 +767,6 @@ class SDNode {
SDNode *Prev, *Next;
friend struct ilist_traits<SDNode>;
/// NextInBucket - This is used by the SelectionDAGCSEMap.
void *NextInBucket;
/// Uses - These are all of the SDNode's that use a value produced by this
/// node.
SmallVector<SDNode*,3> Uses;
......@@ -778,7 +776,6 @@ class SDNode {
public:
virtual ~SDNode() {
assert(NumOperands == 0 && "Operand list not cleared before deletion");
assert(NextInBucket == 0 && "Still in CSEMap?");
NodeType = ISD::DELETED_NODE;
}
......@@ -863,11 +860,10 @@ public:
static bool classof(const SDNode *) { return true; }
/// NextInBucket accessors, these are private to SelectionDAGCSEMap.
void *getNextInBucket() const { return NextInBucket; }
void SetNextInBucket(void *N) { NextInBucket = N; }
/// Profile - Gather unique data for the node.
///
void Profile(FoldingSetNodeID &ID);
protected:
friend class SelectionDAG;
......@@ -880,7 +876,6 @@ protected:
ValueList = getValueTypeList(VT);
NumValues = 1;
Prev = 0; Next = 0;
NextInBucket = 0;
}
SDNode(unsigned NT, SDOperand Op)
: NodeType(NT), NodeId(-1) {
......@@ -891,7 +886,6 @@ protected:
ValueList = 0;
NumValues = 0;
Prev = 0; Next = 0;
NextInBucket = 0;
}
SDNode(unsigned NT, SDOperand N1, SDOperand N2)
: NodeType(NT), NodeId(-1) {
......@@ -903,7 +897,6 @@ protected:
ValueList = 0;
NumValues = 0;
Prev = 0; Next = 0;
NextInBucket = 0;
}
SDNode(unsigned NT, SDOperand N1, SDOperand N2, SDOperand N3)
: NodeType(NT), NodeId(-1) {
......@@ -918,7 +911,6 @@ protected:
ValueList = 0;
NumValues = 0;
Prev = 0; Next = 0;
NextInBucket = 0;
}
SDNode(unsigned NT, SDOperand N1, SDOperand N2, SDOperand N3, SDOperand N4)
: NodeType(NT), NodeId(-1) {
......@@ -934,7 +926,6 @@ protected:
ValueList = 0;
NumValues = 0;
Prev = 0; Next = 0;
NextInBucket = 0;
}
SDNode(unsigned Opc, const SDOperand *Ops, unsigned NumOps)
: NodeType(Opc), NodeId(-1) {
......@@ -949,7 +940,6 @@ protected:
ValueList = 0;
NumValues = 0;
Prev = 0; Next = 0;
NextInBucket = 0;
}
/// MorphNodeTo - This clears the return value and operands list, and sets the
......
llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+ 211
− 49
View file @ f576b42b
This diff is collapsed.
llvm/lib/CodeGen/SelectionDAG/SelectionDAGCSEMap.cpp deleted 100644 → 0
+ 0
− 350
View file @ 2e13bf24
//===-- SelectionDAGCSEMap.cpp - Implement the SelectionDAG CSE Map -------===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by Chris Lattner and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This implements the SelectionDAGCSEMap class.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/SelectionDAG.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/Support/MathExtras.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
// SelectionDAGCSEMap::NodeID Implementation
/// SetValueTypes - Value type lists are intern'd so we can represent them
/// solely with their pointer.
void SelectionDAGCSEMap::NodeID::SetValueTypes(SDVTList VTList) {
AddPointer(VTList.VTs);
}
SelectionDAGCSEMap::NodeID::NodeID(SDNode *N) {
SetOpcode(N->getOpcode());
// Add the return value info.
SetValueTypes(N->getVTList());
// Add the operand info.
SetOperands(N->op_begin(), N->getNumOperands());
// Handle SDNode leafs with special info.
if (N->getNumOperands() == 0) {
switch (N->getOpcode()) {
default: break; // Normal nodes don't need extra info.
case ISD::TargetConstant:
case ISD::Constant:
AddInteger(cast<ConstantSDNode>(N)->getValue());
break;
case ISD::TargetConstantFP:
case ISD::ConstantFP:
AddInteger(DoubleToBits(cast<ConstantFPSDNode>(N)->getValue()));
break;
case ISD::TargetGlobalAddress:
case ISD::GlobalAddress:
AddPointer(cast<GlobalAddressSDNode>(N)->getGlobal());
AddInteger(cast<GlobalAddressSDNode>(N)->getOffset());
break;
case ISD::BasicBlock:
AddPointer(cast<BasicBlockSDNode>(N)->getBasicBlock());
break;
case ISD::Register:
AddInteger(cast<RegisterSDNode>(N)->getReg());
break;
case ISD::SRCVALUE:
AddPointer(cast<SrcValueSDNode>(N)->getValue());
AddInteger(cast<SrcValueSDNode>(N)->getOffset());
break;
case ISD::FrameIndex:
case ISD::TargetFrameIndex:
AddInteger(cast<FrameIndexSDNode>(N)->getIndex());
break;
case ISD::JumpTable:
case ISD::TargetJumpTable:
AddInteger(cast<JumpTableSDNode>(N)->getIndex());
break;
case ISD::ConstantPool:
case ISD::TargetConstantPool:
AddInteger(cast<ConstantPoolSDNode>(N)->getAlignment());
AddInteger(cast<ConstantPoolSDNode>(N)->getOffset());
if (cast<ConstantPoolSDNode>(N)->isMachineConstantPoolEntry())
cast<ConstantPoolSDNode>(N)->getMachineCPVal()->
AddSelectionDAGCSEId(this);
else
AddPointer(cast<ConstantPoolSDNode>(N)->getConstVal());
break;
}
}
}
SelectionDAGCSEMap::NodeID::NodeID(unsigned short ID, SDVTList VTList) {
SetOpcode(ID);
SetValueTypes(VTList);
SetOperands();
}
SelectionDAGCSEMap::NodeID::NodeID(unsigned short ID, SDVTList VTList,
SDOperand Op) {
SetOpcode(ID);
SetValueTypes(VTList);
SetOperands(Op);
}
SelectionDAGCSEMap::NodeID::NodeID(unsigned short ID, SDVTList VTList,
SDOperand Op1, SDOperand Op2) {
SetOpcode(ID);
SetValueTypes(VTList);
SetOperands(Op1, Op2);
}
SelectionDAGCSEMap::NodeID::NodeID(unsigned short ID, SDVTList VTList,
SDOperand Op1, SDOperand Op2,
SDOperand Op3) {
SetOpcode(ID);
SetValueTypes(VTList);
SetOperands(Op1, Op2, Op3);
}
SelectionDAGCSEMap::NodeID::NodeID(unsigned short ID, SDVTList VTList,
const SDOperand *OpList, unsigned N) {
SetOpcode(ID);
SetValueTypes(VTList);
SetOperands(OpList, N);
}
void SelectionDAGCSEMap::NodeID::AddPointer(const void *Ptr) {
// Note: this adds pointers to the hash using sizes and endianness that depend
// on the host. It doesn't matter however, because hashing on pointer values
// in inherently unstable. Nothing in the SelectionDAG should depend on the
// ordering of nodes in the CSEMap.
intptr_t PtrI = (intptr_t)Ptr;
Bits.push_back(unsigned(PtrI));
if (sizeof(intptr_t) > sizeof(unsigned))
Bits.push_back(unsigned(uint64_t(PtrI) >> 32));
}
void SelectionDAGCSEMap::NodeID::AddOperand(SDOperand Op) {
AddPointer(Op.Val);
Bits.push_back(Op.ResNo);
}
void SelectionDAGCSEMap::NodeID::SetOperands(const SDOperand *Ops,
unsigned NumOps) {
for (; NumOps; --NumOps, ++Ops)
AddOperand(*Ops);
}
/// ComputeHash - Compute a strong hash value for this NodeID, for lookup in
/// the SelectionDAGCSEMap.
unsigned SelectionDAGCSEMap::NodeID::ComputeHash() const {
// This is adapted from SuperFastHash by Paul Hsieh.
unsigned Hash = Bits.size();
for (const unsigned *BP = &Bits[0], *E = BP+Bits.size(); BP != E; ++BP) {
unsigned Data = *BP;
Hash += Data & 0xFFFF;
unsigned Tmp = ((Data >> 16) << 11) ^ Hash;
Hash = (Hash << 16) ^ Tmp;
Hash += Hash >> 11;
}
// Force "avalanching" of final 127 bits.
Hash ^= Hash << 3;
Hash += Hash >> 5;
Hash ^= Hash << 4;
Hash += Hash >> 17;
Hash ^= Hash << 25;
Hash += Hash >> 6;
return Hash;
}
bool SelectionDAGCSEMap::NodeID::operator==(const NodeID &RHS) const {
if (Bits.size() != RHS.Bits.size()) return false;
return memcmp(&Bits[0], &RHS.Bits[0], Bits.size()*sizeof(Bits[0])) == 0;
}
//===----------------------------------------------------------------------===//
// SelectionDAGCSEMap Implementation
SelectionDAGCSEMap::SelectionDAGCSEMap() : NumNodes(0) {
NumBuckets = 64;
Buckets = new void*[NumBuckets];
memset(Buckets, 0, NumBuckets*sizeof(void*));
}
SelectionDAGCSEMap::~SelectionDAGCSEMap() {
delete [] Buckets;
}
/// GetNextPtr - In order to save space, each bucket is a singly-linked-list. In
/// order to make deletion more efficient, we make the list circular, so we can
/// delete a node without computing its hash. The problem with this is that the
/// start of the hash buckets are not SDNodes. If NextInBucketPtr is a bucket
/// pointer, this method returns null: use GetBucketPtr when this happens.
SDNode *SelectionDAGCSEMap::GetNextPtr(void *NextInBucketPtr) {
if (NextInBucketPtr >= Buckets && NextInBucketPtr < Buckets+NumBuckets)
return 0;
return static_cast<SDNode*>(NextInBucketPtr);
}
/// GetNextPtr - This is just like the previous GetNextPtr implementation, but
/// allows a bucket array to be specified.
SDNode *SelectionDAGCSEMap::GetNextPtr(void *NextInBucketPtr, void **Bucks,
unsigned NumBuck) {
if (NextInBucketPtr >= Bucks && NextInBucketPtr < Bucks+NumBuck)
return 0;
return static_cast<SDNode*>(NextInBucketPtr);
}
void **SelectionDAGCSEMap::GetBucketPtr(void *NextInBucketPtr) {
//assert(NextInBucketPtr >= Buckets && NextInBucketPtr < Buckets+NumBuckets &&
// "NextInBucketPtr is not a bucket ptr");
return static_cast<void**>(NextInBucketPtr);
}
/// GetBucketFor - Hash the specified node ID and return the hash bucket for the
/// specified ID.
void **SelectionDAGCSEMap::GetBucketFor(const NodeID &ID) const {
// NumBuckets is always a power of 2.
unsigned BucketNum = ID.ComputeHash() & (NumBuckets-1);
return Buckets+BucketNum;
}
/// GrowHashTable - Double the size of the hash table and rehash everything.
///
void SelectionDAGCSEMap::GrowHashTable() {
void **OldBuckets = Buckets;
unsigned OldNumBuckets = NumBuckets;
NumBuckets <<= 1;
// Reset the node count to zero: we're going to reinsert everything.
NumNodes = 0;
// Clear out new buckets.
Buckets = new void*[NumBuckets];
memset(Buckets, 0, NumBuckets*sizeof(void*));
// Walk the old buckets, rehashing nodes into their new place.
for (unsigned i = 0; i != OldNumBuckets; ++i) {
void *Probe = OldBuckets[i];
if (!Probe) continue;
while (SDNode *NodeInBucket = GetNextPtr(Probe, OldBuckets, OldNumBuckets)){
// Figure out the next link, remove NodeInBucket from the old link.
Probe = NodeInBucket->getNextInBucket();
NodeInBucket->SetNextInBucket(0);
// Insert the node into the new bucket, after recomputing the hash.
InsertNode(NodeInBucket, GetBucketFor(NodeID(NodeInBucket)));
}
}
delete[] OldBuckets;
}
/// FindNodeOrInsertPos - Look up the node specified by ID. If it exists,
/// return it. If not, return the insertion token that will make insertion
/// faster.
SDNode *SelectionDAGCSEMap::FindNodeOrInsertPos(const NodeID &ID,
void *&InsertPos) {
void **Bucket = GetBucketFor(ID);
void *Probe = *Bucket;
InsertPos = 0;
unsigned Opc = ID.getOpcode();
while (SDNode *NodeInBucket = GetNextPtr(Probe)) {
// If we found a node with the same opcode, it might be a matching node.
// Because it is in the same bucket as this one, we know the hash values
// match. Compute the NodeID for the possible match and do a final compare.
if (NodeInBucket->getOpcode() == Opc) {
NodeID OtherID(NodeInBucket);
if (OtherID == ID)
return NodeInBucket;
}
Probe = NodeInBucket->getNextInBucket();
}
// Didn't find the node, return null with the bucket as the InsertPos.
InsertPos = Bucket;
return 0;
}
/// InsertNode - Insert the specified node into the CSE Map, knowing that it
/// is not already in the map. InsertPos must be obtained from
/// FindNodeOrInsertPos.
void SelectionDAGCSEMap::InsertNode(SDNode *N, void *InsertPos) {
++NumNodes;
// Do we need to grow the hashtable?
if (NumNodes > NumBuckets*2) {
GrowHashTable();
InsertPos = GetBucketFor(NodeID(N));
}
/// The insert position is actually a bucket pointer.
void **Bucket = static_cast<void**>(InsertPos);
void *Next = *Bucket;
// If this is the first insertion into this bucket, its next pointer will be
// null. Pretend as if it pointed to itself.
if (Next == 0)
Next = Bucket;
// Set the nodes next pointer, and make the bucket point to the node.
N->SetNextInBucket(Next);
*Bucket = N;
}
/// RemoveNode - Remove a node from the CSE map, returning true if one was
/// removed or false if the node was not in the CSE map.
bool SelectionDAGCSEMap::RemoveNode(SDNode *N) {
// Because each bucket is a circular list, we don't need to compute N's hash
// to remove it. Chase around the list until we find the node (or bucket)
// which points to N.
void *Ptr = N->getNextInBucket();
if (Ptr == 0) return false; // Not in CSEMap.
--NumNodes;
void *NodeNextPtr = Ptr;
N->SetNextInBucket(0);
while (1) {
if (SDNode *NodeInBucket = GetNextPtr(Ptr)) {
// Advance pointer.
Ptr = NodeInBucket->getNextInBucket();
// We found a node that points to N, change it to point to N's next node,
// removing N from the list.
if (Ptr == N) {
NodeInBucket->SetNextInBucket(NodeNextPtr);
return true;
}
} else {
void **Bucket = GetBucketPtr(Ptr);
Ptr = *Bucket;
// If we found that the bucket points to N, update the bucket to point to
// whatever is next.
if (Ptr == N) {
*Bucket = NodeNextPtr;
return true;
}
}
}
}
/// GetOrInsertSimpleNode - If there is an existing simple SDNode exactly
/// equal to the specified node, return it. Otherwise, insert 'N' and it
/// instead. This only works on *simple* SDNodes, not ConstantSDNode or any
/// other classes derived from SDNode.
SDNode *SelectionDAGCSEMap::GetOrInsertNode(SDNode *N) {
SelectionDAGCSEMap::NodeID ID(N);
void *IP;
if (SDNode *E = FindNodeOrInsertPos(ID, IP))
return E;
InsertNode(N, IP);
return N;
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment