From cfa435f79bf39fead32263a8b71c9ae440b55214 Mon Sep 17 00:00:00 2001 From: John Criswell Date: Wed, 2 Nov 2005 18:05:50 +0000 Subject: Mark these as failing on sparc instead of sparcv9. The configure script no longer tells us that we're configuring for SparcV9 specifically. 2004-06-17-UnorderedCompares may work on SparcV8, but it's experiental anyway. 2005-02-20-AggregateSAVEEXPR should fail on any Solaris machine, as Solaris doesn't provide complex number support. git-svn-id: https://llvm.org/svn/llvm-project/llvm/branches/release_16@24155 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/DataStructure/GraphChecker.cpp | 204 ++++++++++++++++++++++++++++ 1 file changed, 204 insertions(+) create mode 100644 lib/Analysis/DataStructure/GraphChecker.cpp (limited to 'lib/Analysis/DataStructure/GraphChecker.cpp') diff --git a/lib/Analysis/DataStructure/GraphChecker.cpp b/lib/Analysis/DataStructure/GraphChecker.cpp new file mode 100644 index 0000000000..6f2befa7d1 --- /dev/null +++ b/lib/Analysis/DataStructure/GraphChecker.cpp @@ -0,0 +1,204 @@ +//===- GraphChecker.cpp - Assert that various graph properties hold -------===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass is used to test DSA with regression tests. It can be used to check +// that certain graph properties hold, such as two nodes being disjoint, whether +// or not a node is collapsed, etc. These are the command line arguments that +// it supports: +// +// --dsgc-dspass={local,bu,td} - Specify what flavor of graph to check +// --dsgc-abort-if-any-collapsed - Abort if any collapsed nodes are found +// --dsgc-abort-if-collapsed= - Abort if a node pointed to by an SSA +// value with name in is collapsed +// --dsgc-check-flags= - Abort if the specified nodes have flags +// that are not specified. +// --dsgc-abort-if-merged= - Abort if any of the named SSA values +// point to the same node. +// +//===----------------------------------------------------------------------===// + +#include "llvm/Analysis/DataStructure/DataStructure.h" +#include "llvm/Analysis/DataStructure/DSGraph.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Value.h" +#include +#include + +using namespace llvm; + +namespace { + enum DSPass { local, bu, td }; + cl::opt + DSPass("dsgc-dspass", cl::Hidden, + cl::desc("Specify which DSA pass the -datastructure-gc pass should use"), + cl::values(clEnumVal(local, "Local pass"), + clEnumVal(bu, "Bottom-up pass"), + clEnumVal(td, "Top-down pass"), + clEnumValEnd), cl::init(local)); + + cl::opt + AbortIfAnyCollapsed("dsgc-abort-if-any-collapsed", cl::Hidden, + cl::desc("Abort if any collapsed nodes are found")); + cl::list + AbortIfCollapsed("dsgc-abort-if-collapsed", cl::Hidden, cl::CommaSeparated, + cl::desc("Abort if any of the named symbols is collapsed")); + cl::list + CheckFlags("dsgc-check-flags", cl::Hidden, cl::CommaSeparated, + cl::desc("Check that flags are specified for nodes")); + cl::list + AbortIfMerged("dsgc-abort-if-merged", cl::Hidden, cl::CommaSeparated, + cl::desc("Abort if any of the named symbols are merged together")); + + struct DSGC : public FunctionPass { + DSGC(); + bool doFinalization(Module &M); + bool runOnFunction(Function &F); + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + switch (DSPass) { + case local: AU.addRequired(); break; + case bu: AU.addRequired(); break; + case td: AU.addRequired(); break; + } + AU.setPreservesAll(); + } + void print(std::ostream &O, const Module *M) const {} + + private: + void verify(const DSGraph &G); + }; + + RegisterAnalysis X("datastructure-gc", "DSA Graph Checking Pass"); +} + +FunctionPass *llvm::createDataStructureGraphCheckerPass() { + return new DSGC(); +} + + +DSGC::DSGC() { + if (!AbortIfAnyCollapsed && AbortIfCollapsed.empty() && + CheckFlags.empty() && AbortIfMerged.empty()) { + std::cerr << "The -datastructure-gc is useless if you don't specify any" + " -dsgc-* options. See the -help-hidden output for a list.\n"; + abort(); + } +} + + +/// doFinalization - Verify that the globals graph is in good shape... +/// +bool DSGC::doFinalization(Module &M) { + switch (DSPass) { + case local:verify(getAnalysis().getGlobalsGraph());break; + case bu: verify(getAnalysis().getGlobalsGraph()); break; + case td: verify(getAnalysis().getGlobalsGraph()); break; + } + return false; +} + +/// runOnFunction - Get the DSGraph for this function and verify that it is ok. +/// +bool DSGC::runOnFunction(Function &F) { + switch (DSPass) { + case local: verify(getAnalysis().getDSGraph(F)); break; + case bu: verify(getAnalysis().getDSGraph(F)); break; + case td: verify(getAnalysis().getDSGraph(F)); break; + } + + return false; +} + +/// verify - This is the function which checks to make sure that all of the +/// invariants established on the command line are true. +/// +void DSGC::verify(const DSGraph &G) { + // Loop over all of the nodes, checking to see if any are collapsed... + if (AbortIfAnyCollapsed) { + for (DSGraph::node_const_iterator I = G.node_begin(), E = G.node_end(); + I != E; ++I) + if (I->isNodeCompletelyFolded()) { + std::cerr << "Node is collapsed: "; + I->print(std::cerr, &G); + abort(); + } + } + + if (!AbortIfCollapsed.empty() || !CheckFlags.empty() || + !AbortIfMerged.empty()) { + // Convert from a list to a set, because we don't have cl::set's yet. FIXME + std::set AbortIfCollapsedS(AbortIfCollapsed.begin(), + AbortIfCollapsed.end()); + std::set AbortIfMergedS(AbortIfMerged.begin(), + AbortIfMerged.end()); + std::map CheckFlagsM; + + for (cl::list::iterator I = CheckFlags.begin(), + E = CheckFlags.end(); I != E; ++I) { + std::string::size_type ColonPos = I->rfind(':'); + if (ColonPos == std::string::npos) { + std::cerr << "Error: '" << *I + << "' is an invalid value for the --dsgc-check-flags option!\n"; + abort(); + } + + unsigned Flags = 0; + for (unsigned C = ColonPos+1; C != I->size(); ++C) + switch ((*I)[C]) { + case 'S': Flags |= DSNode::AllocaNode; break; + case 'H': Flags |= DSNode::HeapNode; break; + case 'G': Flags |= DSNode::GlobalNode; break; + case 'U': Flags |= DSNode::UnknownNode; break; + case 'I': Flags |= DSNode::Incomplete; break; + case 'M': Flags |= DSNode::Modified; break; + case 'R': Flags |= DSNode::Read; break; + case 'A': Flags |= DSNode::Array; break; + default: std::cerr << "Invalid DSNode flag!\n"; abort(); + } + CheckFlagsM[std::string(I->begin(), I->begin()+ColonPos)] = Flags; + } + + // Now we loop over all of the scalars, checking to see if any are collapsed + // that are not supposed to be, or if any are merged together. + const DSGraph::ScalarMapTy &SM = G.getScalarMap(); + std::map AbortIfMergedNodes; + + for (DSGraph::ScalarMapTy::const_iterator I = SM.begin(), E = SM.end(); + I != E; ++I) + if (I->first->hasName() && I->second.getNode()) { + const std::string &Name = I->first->getName(); + DSNode *N = I->second.getNode(); + + // Verify it is not collapsed if it is not supposed to be... + if (N->isNodeCompletelyFolded() && AbortIfCollapsedS.count(Name)) { + std::cerr << "Node for value '%" << Name << "' is collapsed: "; + N->print(std::cerr, &G); + abort(); + } + + if (CheckFlagsM.count(Name) && CheckFlagsM[Name] != N->getNodeFlags()) { + std::cerr << "Node flags are not as expected for node: " << Name + << "\n"; + N->print(std::cerr, &G); + abort(); + } + + // Verify that it is not merged if it is not supposed to be... + if (AbortIfMergedS.count(Name)) { + if (AbortIfMergedNodes.count(N)) { + std::cerr << "Nodes for values '%" << Name << "' and '%" + << AbortIfMergedNodes[N] << "' is merged: "; + N->print(std::cerr, &G); + abort(); + } + AbortIfMergedNodes[N] = Name; + } + } + } +} -- cgit v1.2.3-70-g09d2