[llvm] r191835 - Remove the very substantial, largely unmaintained legacy PGO
Alexey Samsonov
samsonov at google.com
Fri Oct 4 03:45:41 PDT 2013
FYI, I've restored LLVM_BUILD_RUNTIME CMake option in r191948 - otherwise
this change silently discarded building compiler-rt and libcxx :)
On Wed, Oct 2, 2013 at 7:57 PM, Rafael Espíndola <rafael.espindola at gmail.com
> wrote:
> 61 files changed, 12 insertions(+), 8640 deletions(-)
>
> Nice!
>
> On 2 October 2013 11:42, Chandler Carruth <chandlerc at gmail.com> wrote:
> > Author: chandlerc
> > Date: Wed Oct 2 10:42:23 2013
> > New Revision: 191835
> >
> > URL: http://llvm.org/viewvc/llvm-project?rev=191835&view=rev
> > Log:
> > Remove the very substantial, largely unmaintained legacy PGO
> > infrastructure.
> >
> > This was essentially work toward PGO based on a design that had several
> > flaws, partially dating from a time when LLVM had a different
> > architecture, and with an effort to modernize it abandoned without being
> > completed. Since then, it has bitrotted for several years further. The
> > result is nearly unusable, and isn't helping any of the modern PGO
> > efforts. Instead, it is getting in the way, adding confusion about PGO
> > in LLVM and distracting everyone with maintenance on essentially dead
> > code. Removing it paves the way for modern efforts around PGO.
> >
> > Among other effects, this removes the last of the runtime libraries from
> > LLVM. Those are being developed in the separate 'compiler-rt' project
> > now, with somewhat different licensing specifically more approriate for
> > runtimes.
> >
> > Removed:
> > llvm/trunk/include/llvm/Analysis/PathNumbering.h
> > llvm/trunk/include/llvm/Analysis/PathProfileInfo.h
> > llvm/trunk/include/llvm/Analysis/ProfileDataLoader.h
> > llvm/trunk/include/llvm/Analysis/ProfileDataTypes.h
> > llvm/trunk/include/llvm/Analysis/ProfileInfo.h
> > llvm/trunk/include/llvm/Analysis/ProfileInfoLoader.h
> > llvm/trunk/include/llvm/Analysis/ProfileInfoTypes.h
> > llvm/trunk/lib/Analysis/PathNumbering.cpp
> > llvm/trunk/lib/Analysis/PathProfileInfo.cpp
> > llvm/trunk/lib/Analysis/PathProfileVerifier.cpp
> > llvm/trunk/lib/Analysis/ProfileDataLoader.cpp
> > llvm/trunk/lib/Analysis/ProfileDataLoaderPass.cpp
> > llvm/trunk/lib/Analysis/ProfileEstimatorPass.cpp
> > llvm/trunk/lib/Analysis/ProfileInfo.cpp
> > llvm/trunk/lib/Analysis/ProfileInfoLoader.cpp
> > llvm/trunk/lib/Analysis/ProfileInfoLoaderPass.cpp
> > llvm/trunk/lib/Analysis/ProfileVerifierPass.cpp
> > llvm/trunk/lib/Transforms/Instrumentation/EdgeProfiling.cpp
> > llvm/trunk/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
> > llvm/trunk/lib/Transforms/Instrumentation/PathProfiling.cpp
> > llvm/trunk/runtime/
> > llvm/trunk/test/Analysis/Profiling/
> > llvm/trunk/tools/llvm-prof/
> > Modified:
> > llvm/trunk/CMakeLists.txt
> > llvm/trunk/LLVMBuild.txt
> > llvm/trunk/Makefile
> > llvm/trunk/include/llvm/Analysis/Passes.h
> > llvm/trunk/include/llvm/InitializePasses.h
> > llvm/trunk/include/llvm/LinkAllPasses.h
> > llvm/trunk/include/llvm/Transforms/Instrumentation.h
> > llvm/trunk/lib/Analysis/Analysis.cpp
> > llvm/trunk/lib/Analysis/CMakeLists.txt
> > llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp
> > llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt
> > llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp
> > llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp
> > llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp
> > llvm/trunk/lib/Transforms/Utils/Local.cpp
> > llvm/trunk/test/lit.cfg
> > llvm/trunk/tools/CMakeLists.txt
> > llvm/trunk/tools/LLVMBuild.txt
> > llvm/trunk/tools/Makefile
> >
> > Modified: llvm/trunk/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/CMakeLists.txt?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/CMakeLists.txt (original)
> > +++ llvm/trunk/CMakeLists.txt Wed Oct 2 10:42:23 2013
> > @@ -246,18 +246,13 @@ if( WIN32 AND NOT CYGWIN )
> > endif()
> >
> > # Define options to control the inclusion and default build behavior for
> > -# components which may not strictly be necessary (tools, runtime,
> examples, and
> > -# tests).
> > +# components which may not strictly be necessary (tools, examples, and
> tests).
> > #
> > # This is primarily to support building smaller or faster project files.
> > option(LLVM_INCLUDE_TOOLS "Generate build targets for the LLVM tools."
> ON)
> > option(LLVM_BUILD_TOOLS
> > "Build the LLVM tools. If OFF, just generate build targets." ON)
> >
> > -option(LLVM_INCLUDE_RUNTIME "Generate build targets for the LLVM
> runtimes" ON)
> > -option(LLVM_BUILD_RUNTIME
> > - "Build the LLVM runtime libraries. If OFF, just generate build
> targets." ON)
> > -
> > option(LLVM_BUILD_EXAMPLES
> > "Build the LLVM example programs. If OFF, just generate build
> targets." OFF)
> > option(LLVM_INCLUDE_EXAMPLES "Generate build targets for the LLVM
> examples" ON)
> > @@ -471,10 +466,6 @@ if( LLVM_INCLUDE_TOOLS )
> > add_subdirectory(tools)
> > endif()
> >
> > -if( LLVM_INCLUDE_RUNTIME )
> > - add_subdirectory(runtime)
> > -endif()
> > -
> > if( LLVM_INCLUDE_EXAMPLES )
> > add_subdirectory(examples)
> > endif()
> >
> > Modified: llvm/trunk/LLVMBuild.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/LLVMBuild.txt?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/LLVMBuild.txt (original)
> > +++ llvm/trunk/LLVMBuild.txt Wed Oct 2 10:42:23 2013
> > @@ -16,7 +16,7 @@
> >
> ;===------------------------------------------------------------------------===;
> >
> > [common]
> > -subdirectories = bindings docs examples lib projects runtime tools utils
> > +subdirectories = bindings docs examples lib projects tools utils
> >
> > [component_0]
> > type = Group
> >
> > Modified: llvm/trunk/Makefile
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/Makefile?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/Makefile (original)
> > +++ llvm/trunk/Makefile Wed Oct 2 10:42:23 2013
> > @@ -15,7 +15,7 @@ LEVEL := .
> > # 3. Build IR, which builds the Intrinsics.inc file used by libs.
> > # 4. Build libs, which are needed by llvm-config.
> > # 5. Build llvm-config, which determines inter-lib dependencies for
> tools.
> > -# 6. Build tools, runtime, docs.
> > +# 6. Build tools and docs.
> > #
> > # When cross-compiling, there are some things (tablegen) that need to
> > # be build for the build system first.
> > @@ -31,7 +31,7 @@ ifeq ($(BUILD_DIRS_ONLY),1)
> > OPTIONAL_DIRS := tools/clang/utils/TableGen
> > else
> > DIRS := lib/Support lib/TableGen utils lib/IR lib tools/llvm-shlib \
> > - tools/llvm-config tools runtime docs unittests
> > + tools/llvm-config tools docs unittests
> > OPTIONAL_DIRS := projects bindings
> > endif
> >
> > @@ -52,17 +52,17 @@ ifneq ($(ENABLE_DOCS),1)
> > endif
> >
> > ifeq ($(MAKECMDGOALS),libs-only)
> > - DIRS := $(filter-out tools runtime docs, $(DIRS))
> > + DIRS := $(filter-out tools docs, $(DIRS))
> > OPTIONAL_DIRS :=
> > endif
> >
> > ifeq ($(MAKECMDGOALS),install-libs)
> > - DIRS := $(filter-out tools runtime docs, $(DIRS))
> > + DIRS := $(filter-out tools docs, $(DIRS))
> > OPTIONAL_DIRS := $(filter bindings, $(OPTIONAL_DIRS))
> > endif
> >
> > ifeq ($(MAKECMDGOALS),tools-only)
> > - DIRS := $(filter-out runtime docs, $(DIRS))
> > + DIRS := $(filter-out docs, $(DIRS))
> > OPTIONAL_DIRS :=
> > endif
> >
> > @@ -72,7 +72,7 @@ ifeq ($(MAKECMDGOALS),install-clang)
> > tools/clang/tools/c-index-test \
> > tools/clang/include/clang-c \
> > tools/clang/runtime tools/clang/docs \
> > - tools/lto runtime
> > + tools/lto
> > OPTIONAL_DIRS :=
> > NO_INSTALL = 1
> > endif
> > @@ -84,7 +84,7 @@ ifeq ($(MAKECMDGOALS),clang-only)
> > endif
> >
> > ifeq ($(MAKECMDGOALS),unittests)
> > - DIRS := $(filter-out tools runtime docs, $(DIRS)) utils unittests
> > + DIRS := $(filter-out tools docs, $(DIRS)) utils unittests
> > OPTIONAL_DIRS :=
> > endif
> >
> >
> > Modified: llvm/trunk/include/llvm/Analysis/Passes.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/Passes.h?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/Passes.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/Passes.h Wed Oct 2 10:42:23 2013
> > @@ -95,64 +95,6 @@ namespace llvm {
> >
> >
> //===--------------------------------------------------------------------===//
> > //
> > - // createProfileLoaderPass - This pass loads information from a
> profile dump
> > - // file.
> > - //
> > - ModulePass *createProfileLoaderPass();
> > - extern char &ProfileLoaderPassID;
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createProfileMetadataLoaderPass - This pass loads information from
> a
> > - // profile dump file and sets branch weight metadata.
> > - //
> > - ModulePass *createProfileMetadataLoaderPass();
> > - extern char &ProfileMetadataLoaderPassID;
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createNoProfileInfoPass - This pass implements the default "no
> profile".
> > - //
> > - ImmutablePass *createNoProfileInfoPass();
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createProfileEstimatorPass - This pass estimates profiling
> information
> > - // instead of loading it from a previous run.
> > - //
> > - FunctionPass *createProfileEstimatorPass();
> > - extern char &ProfileEstimatorPassID;
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createProfileVerifierPass - This pass verifies profiling
> information.
> > - //
> > - FunctionPass *createProfileVerifierPass();
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createPathProfileLoaderPass - This pass loads information from a
> path
> > - // profile dump file.
> > - //
> > - ModulePass *createPathProfileLoaderPass();
> > - extern char &PathProfileLoaderPassID;
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createNoPathProfileInfoPass - This pass implements the default
> > - // "no path profile".
> > - //
> > - ImmutablePass *createNoPathProfileInfoPass();
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > - // createPathProfileVerifierPass - This pass verifies path profiling
> > - // information.
> > - //
> > - ModulePass *createPathProfileVerifierPass();
> > -
> > -
> //===--------------------------------------------------------------------===//
> > - //
> > // createDSAAPass - This pass implements simple context sensitive
> alias
> > // analysis.
> > //
> >
> > Removed: llvm/trunk/include/llvm/Analysis/PathNumbering.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/PathNumbering.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/PathNumbering.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/PathNumbering.h (removed)
> > @@ -1,304 +0,0 @@
> > -//===- PathNumbering.h ----------------------------------------*- C++
> -*---===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// Ball-Larus path numbers uniquely identify paths through a directed
> acyclic
> > -// graph (DAG) [Ball96]. For a CFG backedges are removed and replaced
> by phony
> > -// edges to obtain a DAG, and thus the unique path numbers [Ball96].
> > -//
> > -// The purpose of this analysis is to enumerate the edges in a CFG in
> order
> > -// to obtain paths from path numbers in a convenient manner. As
> described in
> > -// [Ball96] edges can be enumerated such that given a path number by
> following
> > -// the CFG and updating the path number, the path is obtained.
> > -//
> > -// [Ball96]
> > -// T. Ball and J. R. Larus. "Efficient Path Profiling."
> > -// International Symposium on Microarchitecture, pages 46-57, 1996.
> > -// http://portal.acm.org/citation.cfm?id=243857
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_ANALYSIS_PATHNUMBERING_H
> > -#define LLVM_ANALYSIS_PATHNUMBERING_H
> > -
> > -#include "llvm/Analysis/ProfileInfoTypes.h"
> > -#include "llvm/IR/BasicBlock.h"
> > -#include "llvm/IR/Instructions.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include <map>
> > -#include <stack>
> > -#include <vector>
> > -
> > -namespace llvm {
> > -class BallLarusNode;
> > -class BallLarusEdge;
> > -class BallLarusDag;
> > -
> > -// typedefs for storage/ interators of various DAG components
> > -typedef std::vector<BallLarusNode*> BLNodeVector;
> > -typedef std::vector<BallLarusNode*>::iterator BLNodeIterator;
> > -typedef std::vector<BallLarusEdge*> BLEdgeVector;
> > -typedef std::vector<BallLarusEdge*>::iterator BLEdgeIterator;
> > -typedef std::map<BasicBlock*, BallLarusNode*> BLBlockNodeMap;
> > -typedef std::stack<BallLarusNode*> BLNodeStack;
> > -
> > -// Represents a basic block with information necessary for the BallLarus
> > -// algorithms.
> > -class BallLarusNode {
> > -public:
> > - enum NodeColor { WHITE, GRAY, BLACK };
> > -
> > - // Constructor: Initializes a new Node for the given BasicBlock
> > - BallLarusNode(BasicBlock* BB) :
> > - _basicBlock(BB), _numberPaths(0), _color(WHITE) {
> > - static unsigned nextUID = 0;
> > - _uid = nextUID++;
> > - }
> > -
> > - // Returns the basic block for the BallLarusNode
> > - BasicBlock* getBlock();
> > -
> > - // Get/set the number of paths to the exit starting at the node.
> > - unsigned getNumberPaths();
> > - void setNumberPaths(unsigned numberPaths);
> > -
> > - // Get/set the NodeColor used in graph algorithms.
> > - NodeColor getColor();
> > - void setColor(NodeColor color);
> > -
> > - // Iterator information for predecessor edges. Includes phony and
> > - // backedges.
> > - BLEdgeIterator predBegin();
> > - BLEdgeIterator predEnd();
> > - unsigned getNumberPredEdges();
> > -
> > - // Iterator information for successor edges. Includes phony and
> > - // backedges.
> > - BLEdgeIterator succBegin();
> > - BLEdgeIterator succEnd();
> > - unsigned getNumberSuccEdges();
> > -
> > - // Add an edge to the predecessor list.
> > - void addPredEdge(BallLarusEdge* edge);
> > -
> > - // Remove an edge from the predecessor list.
> > - void removePredEdge(BallLarusEdge* edge);
> > -
> > - // Add an edge to the successor list.
> > - void addSuccEdge(BallLarusEdge* edge);
> > -
> > - // Remove an edge from the successor list.
> > - void removeSuccEdge(BallLarusEdge* edge);
> > -
> > - // Returns the name of the BasicBlock being represented. If
> BasicBlock
> > - // is null then returns "<null>". If BasicBlock has no name, then
> > - // "<unnamed>" is returned. Intended for use with debug output.
> > - std::string getName();
> > -
> > -private:
> > - // The corresponding underlying BB.
> > - BasicBlock* _basicBlock;
> > -
> > - // Holds the predecessor edges of this node.
> > - BLEdgeVector _predEdges;
> > -
> > - // Holds the successor edges of this node.
> > - BLEdgeVector _succEdges;
> > -
> > - // The number of paths from the node to the exit.
> > - unsigned _numberPaths;
> > -
> > - // 'Color' used by graph algorithms to mark the node.
> > - NodeColor _color;
> > -
> > - // Unique ID to ensure naming difference with dotgraphs
> > - unsigned _uid;
> > -
> > - // Removes an edge from an edgeVector. Used by removePredEdge and
> > - // removeSuccEdge.
> > - void removeEdge(BLEdgeVector& v, BallLarusEdge* e);
> > -};
> > -
> > -// Represents an edge in the Dag. For an edge, v -> w, v is the
> source, and
> > -// w is the target.
> > -class BallLarusEdge {
> > -public:
> > - enum EdgeType { NORMAL, BACKEDGE, SPLITEDGE,
> > - BACKEDGE_PHONY, SPLITEDGE_PHONY, CALLEDGE_PHONY };
> > -
> > - // Constructor: Initializes an BallLarusEdge with a source and target.
> > - BallLarusEdge(BallLarusNode* source, BallLarusNode* target,
> > - unsigned duplicateNumber)
> > - : _source(source), _target(target), _weight(0), _edgeType(NORMAL),
> > - _realEdge(NULL), _duplicateNumber(duplicateNumber) {}
> > -
> > - // Returns the source/ target node of this edge.
> > - BallLarusNode* getSource() const;
> > - BallLarusNode* getTarget() const;
> > -
> > - // Sets the type of the edge.
> > - EdgeType getType() const;
> > -
> > - // Gets the type of the edge.
> > - void setType(EdgeType type);
> > -
> > - // Returns the weight of this edge. Used to decode path numbers to
> > - // sequences of basic blocks.
> > - unsigned getWeight();
> > -
> > - // Sets the weight of the edge. Used during path numbering.
> > - void setWeight(unsigned weight);
> > -
> > - // Gets/sets the phony edge originating at the root.
> > - BallLarusEdge* getPhonyRoot();
> > - void setPhonyRoot(BallLarusEdge* phonyRoot);
> > -
> > - // Gets/sets the phony edge terminating at the exit.
> > - BallLarusEdge* getPhonyExit();
> > - void setPhonyExit(BallLarusEdge* phonyExit);
> > -
> > - // Gets/sets the associated real edge if this is a phony edge.
> > - BallLarusEdge* getRealEdge();
> > - void setRealEdge(BallLarusEdge* realEdge);
> > -
> > - // Returns the duplicate number of the edge.
> > - unsigned getDuplicateNumber();
> > -
> > -protected:
> > - // Source node for this edge.
> > - BallLarusNode* _source;
> > -
> > - // Target node for this edge.
> > - BallLarusNode* _target;
> > -
> > -private:
> > - // Edge weight cooresponding to path number increments before removing
> > - // increments along a spanning tree. The sum over the edge weights
> gives
> > - // the path number.
> > - unsigned _weight;
> > -
> > - // Type to represent for what this edge is intended
> > - EdgeType _edgeType;
> > -
> > - // For backedges and split-edges, the phony edge which is linked to
> the
> > - // root node of the DAG. This contains a path number initialization.
> > - BallLarusEdge* _phonyRoot;
> > -
> > - // For backedges and split-edges, the phony edge which is linked to
> the
> > - // exit node of the DAG. This contains a path counter increment, and
> > - // potentially a path number increment.
> > - BallLarusEdge* _phonyExit;
> > -
> > - // If this is a phony edge, _realEdge is a link to the back or split
> > - // edge. Otherwise, this is null.
> > - BallLarusEdge* _realEdge;
> > -
> > - // An ID to differentiate between those edges which have the same
> source
> > - // and destination blocks.
> > - unsigned _duplicateNumber;
> > -};
> > -
> > -// Represents the Ball Larus DAG for a given Function. Can calculate
> > -// various properties required for instrumentation or analysis. E.g.
> the
> > -// edge weights that determine the path number.
> > -class BallLarusDag {
> > -public:
> > - // Initializes a BallLarusDag from the CFG of a given function. Must
> > - // call init() after creation, since some initialization requires
> > - // virtual functions.
> > - BallLarusDag(Function &F)
> > - : _root(NULL), _exit(NULL), _function(F) {}
> > -
> > - // Initialization that requires virtual functions which are not fully
> > - // functional in the constructor.
> > - void init();
> > -
> > - // Frees all memory associated with the DAG.
> > - virtual ~BallLarusDag();
> > -
> > - // Calculate the path numbers by assigning edge increments as
> prescribed
> > - // in Ball-Larus path profiling.
> > - void calculatePathNumbers();
> > -
> > - // Returns the number of paths for the DAG.
> > - unsigned getNumberOfPaths();
> > -
> > - // Returns the root (i.e. entry) node for the DAG.
> > - BallLarusNode* getRoot();
> > -
> > - // Returns the exit node for the DAG.
> > - BallLarusNode* getExit();
> > -
> > - // Returns the function for the DAG.
> > - Function& getFunction();
> > -
> > - // Clears the node colors.
> > - void clearColors(BallLarusNode::NodeColor color);
> > -
> > -protected:
> > - // All nodes in the DAG.
> > - BLNodeVector _nodes;
> > -
> > - // All edges in the DAG.
> > - BLEdgeVector _edges;
> > -
> > - // All backedges in the DAG.
> > - BLEdgeVector _backEdges;
> > -
> > - // Allows subclasses to determine which type of Node is created.
> > - // Override this method to produce subclasses of BallLarusNode if
> > - // necessary. The destructor of BallLarusDag will call free on each
> pointer
> > - // created.
> > - virtual BallLarusNode* createNode(BasicBlock* BB);
> > -
> > - // Allows subclasses to determine which type of Edge is created.
> > - // Override this method to produce subclasses of BallLarusEdge if
> > - // necessary. Parameters source and target will have been created by
> > - // createNode and can be cast to the subclass of BallLarusNode*
> > - // returned by createNode. The destructor of BallLarusDag will call
> free
> > - // on each pointer created.
> > - virtual BallLarusEdge* createEdge(BallLarusNode* source,
> BallLarusNode*
> > - target, unsigned duplicateNumber);
> > -
> > - // Proxy to node's constructor. Updates the DAG state.
> > - BallLarusNode* addNode(BasicBlock* BB);
> > -
> > - // Proxy to edge's constructor. Updates the DAG state.
> > - BallLarusEdge* addEdge(BallLarusNode* source, BallLarusNode* target,
> > - unsigned duplicateNumber);
> > -
> > -private:
> > - // The root (i.e. entry) node for this DAG.
> > - BallLarusNode* _root;
> > -
> > - // The exit node for this DAG.
> > - BallLarusNode* _exit;
> > -
> > - // The function represented by this DAG.
> > - Function& _function;
> > -
> > - // Processes one node and its imediate edges for building the DAG.
> > - void buildNode(BLBlockNodeMap& inDag, std::stack<BallLarusNode*>&
> dfsStack);
> > -
> > - // Process an edge in the CFG for DAG building.
> > - void buildEdge(BLBlockNodeMap& inDag, std::stack<BallLarusNode*>&
> dfsStack,
> > - BallLarusNode* currentNode, BasicBlock* succBB,
> > - unsigned duplicateNumber);
> > -
> > - // The weight on each edge is the increment required along any path
> that
> > - // contains that edge.
> > - void calculatePathNumbersFrom(BallLarusNode* node);
> > -
> > - // Adds a backedge with its phony edges. Updates the DAG state.
> > - void addBackedge(BallLarusNode* source, BallLarusNode* target,
> > - unsigned duplicateCount);
> > -};
> > -} // end namespace llvm
> > -
> > -#endif
> >
> > Removed: llvm/trunk/include/llvm/Analysis/PathProfileInfo.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/PathProfileInfo.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/PathProfileInfo.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/PathProfileInfo.h (removed)
> > @@ -1,112 +0,0 @@
> > -//===- PathProfileInfo.h --------------------------------------*- C++
> -*---===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file outlines the interface used by optimizers to load path
> profiles.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_ANALYSIS_PATHPROFILEINFO_H
> > -#define LLVM_ANALYSIS_PATHPROFILEINFO_H
> > -
> > -#include "llvm/Analysis/PathNumbering.h"
> > -#include "llvm/IR/BasicBlock.h"
> > -
> > -namespace llvm {
> > -
> > -class ProfilePath;
> > -class ProfilePathEdge;
> > -class PathProfileInfo;
> > -
> > -typedef std::vector<ProfilePathEdge> ProfilePathEdgeVector;
> > -typedef std::vector<ProfilePathEdge>::iterator ProfilePathEdgeIterator;
> > -
> > -typedef std::vector<BasicBlock*> ProfilePathBlockVector;
> > -typedef std::vector<BasicBlock*>::iterator ProfilePathBlockIterator;
> > -
> > -typedef std::map<unsigned int,ProfilePath*> ProfilePathMap;
> > -typedef std::map<unsigned int,ProfilePath*>::iterator
> ProfilePathIterator;
> > -
> > -typedef std::map<Function*,unsigned int> FunctionPathCountMap;
> > -typedef std::map<Function*,ProfilePathMap> FunctionPathMap;
> > -typedef std::map<Function*,ProfilePathMap>::iterator
> FunctionPathIterator;
> > -
> > -class ProfilePathEdge {
> > -public:
> > - ProfilePathEdge(BasicBlock* source, BasicBlock* target,
> > - unsigned duplicateNumber);
> > -
> > - inline unsigned getDuplicateNumber() { return _duplicateNumber; }
> > - inline BasicBlock* getSource() { return _source; }
> > - inline BasicBlock* getTarget() { return _target; }
> > -
> > -protected:
> > - BasicBlock* _source;
> > - BasicBlock* _target;
> > - unsigned _duplicateNumber;
> > -};
> > -
> > -class ProfilePath {
> > -public:
> > - ProfilePath(unsigned int number, unsigned int count,
> > - double countStdDev, PathProfileInfo* ppi);
> > -
> > - double getFrequency() const;
> > -
> > - inline unsigned int getNumber() const { return _number; }
> > - inline unsigned int getCount() const { return _count; }
> > - inline double getCountStdDev() const { return _countStdDev; }
> > -
> > - ProfilePathEdgeVector* getPathEdges() const;
> > - ProfilePathBlockVector* getPathBlocks() const;
> > -
> > - BasicBlock* getFirstBlockInPath() const;
> > -
> > -private:
> > - unsigned int _number;
> > - unsigned int _count;
> > - double _countStdDev;
> > -
> > - // double pointer back to the profiling info
> > - PathProfileInfo* _ppi;
> > -};
> > -
> > -// TODO: overload [] operator for getting path
> > -// Add: getFunctionCallCount()
> > -class PathProfileInfo {
> > - public:
> > - PathProfileInfo();
> > - ~PathProfileInfo();
> > -
> > - void setCurrentFunction(Function* F);
> > - Function* getCurrentFunction() const;
> > - BasicBlock* getCurrentFunctionEntry();
> > -
> > - ProfilePath* getPath(unsigned int number);
> > - unsigned int getPotentialPathCount();
> > -
> > - ProfilePathIterator pathBegin();
> > - ProfilePathIterator pathEnd();
> > - unsigned int pathsRun();
> > -
> > - static char ID; // Pass identification
> > - std::string argList;
> > -
> > -protected:
> > - FunctionPathMap _functionPaths;
> > - FunctionPathCountMap _functionPathCounts;
> > -
> > -private:
> > - BallLarusDag* _currentDag;
> > - Function* _currentFunction;
> > -
> > - friend class ProfilePath;
> > -};
> > -} // end namespace llvm
> > -
> > -#endif
> >
> > Removed: llvm/trunk/include/llvm/Analysis/ProfileDataLoader.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ProfileDataLoader.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/ProfileDataLoader.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/ProfileDataLoader.h (removed)
> > @@ -1,140 +0,0 @@
> > -//===- ProfileDataLoader.h - Load & convert profile info ----*- C++
> -*-===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// The ProfileDataLoader class is used to load profiling data from a
> dump file.
> > -// The ProfileDataT<FType, BType> class is used to store the mapping of
> this
> > -// data to control flow edges.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_ANALYSIS_PROFILEDATALOADER_H
> > -#define LLVM_ANALYSIS_PROFILEDATALOADER_H
> > -
> > -#include "llvm/ADT/ArrayRef.h"
> > -#include "llvm/ADT/DenseMap.h"
> > -#include "llvm/ADT/SmallVector.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/ErrorHandling.h"
> > -#include <string>
> > -
> > -namespace llvm {
> > -
> > -class ModulePass;
> > -class Function;
> > -class BasicBlock;
> > -
> > -// Helper for dumping edges to dbgs().
> > -raw_ostream& operator<<(raw_ostream &O, std::pair<const BasicBlock *,
> > - const BasicBlock *>
> E);
> > -
> > -/// \brief The ProfileDataT<FType, BType> class is used to store the
> mapping of
> > -/// profiling data to control flow edges.
> > -///
> > -/// An edge is defined by its source and sink basic blocks.
> > -template<class FType, class BType>
> > -class ProfileDataT {
> > -public:
> > - // The profiling information defines an Edge by its source and sink
> basic
> > - // blocks.
> > - typedef std::pair<const BType*, const BType*> Edge;
> > -
> > -private:
> > - typedef DenseMap<Edge, unsigned> EdgeWeights;
> > -
> > - /// \brief Count the number of times a transition between two blocks
> is
> > - /// executed.
> > - ///
> > - /// As a special case, we also hold an edge from the null BasicBlock
> to the
> > - /// entry block to indicate how many times the function was entered.
> > - DenseMap<const FType*, EdgeWeights> EdgeInformation;
> > -
> > -public:
> > - /// getFunction() - Returns the Function for an Edge.
> > - static const FType *getFunction(Edge e) {
> > - // e.first may be NULL
> > - assert(((!e.first) || (e.first->getParent() ==
> e.second->getParent()))
> > - && "A ProfileData::Edge can not be between two functions");
> > - assert(e.second && "A ProfileData::Edge must have a real sink");
> > - return e.second->getParent();
> > - }
> > -
> > - /// getEdge() - Creates an Edge between two BasicBlocks.
> > - static Edge getEdge(const BType *Src, const BType *Dest) {
> > - return Edge(Src, Dest);
> > - }
> > -
> > - /// getEdgeWeight - Return the number of times that a given edge was
> > - /// executed.
> > - unsigned getEdgeWeight(Edge e) const {
> > - const FType *f = getFunction(e);
> > - assert((EdgeInformation.find(f) != EdgeInformation.end())
> > - && "No profiling information for function");
> > - EdgeWeights weights = EdgeInformation.find(f)->second;
> > -
> > - assert((weights.find(e) != weights.end())
> > - && "No profiling information for edge");
> > - return weights.find(e)->second;
> > - }
> > -
> > - /// addEdgeWeight - Add 'weight' to the already stored execution
> count for
> > - /// this edge.
> > - void addEdgeWeight(Edge e, unsigned weight) {
> > - EdgeInformation[getFunction(e)][e] += weight;
> > - }
> > -};
> > -
> > -typedef ProfileDataT<Function, BasicBlock> ProfileData;
> > -//typedef ProfileDataT<MachineFunction, MachineBasicBlock>
> MachineProfileData;
> > -
> > -/// The ProfileDataLoader class is used to load raw profiling data from
> the
> > -/// dump file.
> > -class ProfileDataLoader {
> > -private:
> > - /// The name of the file where the raw profiling data is stored.
> > - const std::string &Filename;
> > -
> > - /// A vector of the command line arguments used when the target
> program was
> > - /// run to generate profiling data. One entry per program run.
> > - SmallVector<std::string, 1> CommandLines;
> > -
> > - /// The raw values for how many times each edge was traversed, values
> from
> > - /// multiple program runs are accumulated.
> > - SmallVector<unsigned, 32> EdgeCounts;
> > -
> > -public:
> > - /// ProfileDataLoader ctor - Read the specified profiling data file,
> exiting
> > - /// the program if the file is invalid or broken.
> > - ProfileDataLoader(const char *ToolName, const std::string &Filename);
> > -
> > - /// A special value used to represent the weight of an edge which has
> not
> > - /// been counted yet.
> > - static const unsigned Uncounted;
> > -
> > - /// getNumExecutions - Return the number of times the target program
> was run
> > - /// to generate this profiling data.
> > - unsigned getNumExecutions() const { return CommandLines.size(); }
> > -
> > - /// getExecution - Return the command line parameters used to
> generate the
> > - /// i'th set of profiling data.
> > - const std::string &getExecution(unsigned i) const { return
> CommandLines[i]; }
> > -
> > - const std::string &getFileName() const { return Filename; }
> > -
> > - /// getRawEdgeCounts - Return the raw profiling data, this is just a
> list of
> > - /// numbers with no mappings to edges.
> > - ArrayRef<unsigned> getRawEdgeCounts() const { return EdgeCounts; }
> > -};
> > -
> > -/// createProfileMetadataLoaderPass - This function returns a Pass that
> loads
> > -/// the profiling information for the module from the specified
> filename.
> > -ModulePass *createProfileMetadataLoaderPass(const std::string
> &Filename);
> > -
> > -} // End llvm namespace
> > -
> > -#endif
> >
> > Removed: llvm/trunk/include/llvm/Analysis/ProfileDataTypes.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ProfileDataTypes.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/ProfileDataTypes.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/ProfileDataTypes.h (removed)
> > @@ -1,39 +0,0 @@
> > -/*===-- ProfileDataTypes.h - Profiling info shared constants
> --------------===*\
> > -|*
> > -|* The LLVM Compiler Infrastructure
> > -|*
> > -|* This file is distributed under the University of Illinois Open Source
> > -|* License. See LICENSE.TXT for details.
> > -|*
> >
> -|*===----------------------------------------------------------------------===*|
> > -|*
> > -|* This file defines constants shared by the various different profiling
> > -|* runtime libraries and the LLVM C++ profile metadata loader. It must
> be a
> > -|* C header because, at present, the profiling runtimes are written in
> C.
> > -|*
> >
> -\*===----------------------------------------------------------------------===*/
> > -
> > -#ifndef LLVM_ANALYSIS_PROFILEDATATYPES_H
> > -#define LLVM_ANALYSIS_PROFILEDATATYPES_H
> > -
> > -/* Included by libprofile. */
> > -#if defined(__cplusplus)
> > -extern "C" {
> > -#endif
> > -
> > -/* TODO: Strip out unused entries once ProfileInfo etc has been
> removed. */
> > -enum ProfilingType {
> > - ArgumentInfo = 1, /* The command line argument block */
> > - FunctionInfo = 2, /* Function profiling information */
> > - BlockInfo = 3, /* Block profiling information */
> > - EdgeInfo = 4, /* Edge profiling information */
> > - PathInfo = 5, /* Path profiling information */
> > - BBTraceInfo = 6, /* Basic block trace information */
> > - OptEdgeInfo = 7 /* Edge profiling information, optimal version */
> > -};
> > -
> > -#if defined(__cplusplus)
> > -}
> > -#endif
> > -
> > -#endif /* LLVM_ANALYSIS_PROFILEDATATYPES_H */
> >
> > Removed: llvm/trunk/include/llvm/Analysis/ProfileInfo.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ProfileInfo.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/ProfileInfo.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/ProfileInfo.h (removed)
> > @@ -1,247 +0,0 @@
> > -//===- llvm/Analysis/ProfileInfo.h - Profile Info Interface -----*- C++
> -*-===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file defines the generic ProfileInfo interface, which is used
> as the
> > -// common interface used by all clients of profiling information, and
> > -// implemented either by making static guestimations, or by actually
> reading in
> > -// profiling information gathered by running the program.
> > -//
> > -// Note that to be useful, all profile-based optimizations should
> preserve
> > -// ProfileInfo, which requires that they notify it when changes to the
> CFG are
> > -// made. (This is not implemented yet.)
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_ANALYSIS_PROFILEINFO_H
> > -#define LLVM_ANALYSIS_PROFILEINFO_H
> > -
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/ErrorHandling.h"
> > -#include "llvm/Support/Format.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <cassert>
> > -#include <map>
> > -#include <set>
> > -#include <string>
> > -
> > -namespace llvm {
> > - class Pass;
> > - class raw_ostream;
> > -
> > - class BasicBlock;
> > - class Function;
> > - class MachineBasicBlock;
> > - class MachineFunction;
> > -
> > - // Helper for dumping edges to dbgs().
> > - raw_ostream& operator<<(raw_ostream &O, std::pair<const BasicBlock *,
> const BasicBlock *> E);
> > - raw_ostream& operator<<(raw_ostream &O, std::pair<const
> MachineBasicBlock *, const MachineBasicBlock *> E);
> > -
> > - raw_ostream& operator<<(raw_ostream &O, const BasicBlock *BB);
> > - raw_ostream& operator<<(raw_ostream &O, const MachineBasicBlock *MBB);
> > -
> > - raw_ostream& operator<<(raw_ostream &O, const Function *F);
> > - raw_ostream& operator<<(raw_ostream &O, const MachineFunction *MF);
> > -
> > - /// ProfileInfo Class - This class holds and maintains profiling
> > - /// information for some unit of code.
> > - template<class FType, class BType>
> > - class ProfileInfoT {
> > - public:
> > - // Types for handling profiling information.
> > - typedef std::pair<const BType*, const BType*> Edge;
> > - typedef std::pair<Edge, double> EdgeWeight;
> > - typedef std::map<Edge, double> EdgeWeights;
> > - typedef std::map<const BType*, double> BlockCounts;
> > - typedef std::map<const BType*, const BType*> Path;
> > -
> > - protected:
> > - // EdgeInformation - Count the number of times a transition between
> two
> > - // blocks is executed. As a special case, we also hold an edge from
> the
> > - // null BasicBlock to the entry block to indicate how many times the
> > - // function was entered.
> > - std::map<const FType*, EdgeWeights> EdgeInformation;
> > -
> > - // BlockInformation - Count the number of times a block is executed.
> > - std::map<const FType*, BlockCounts> BlockInformation;
> > -
> > - // FunctionInformation - Count the number of times a function is
> executed.
> > - std::map<const FType*, double> FunctionInformation;
> > -
> > - ProfileInfoT<MachineFunction, MachineBasicBlock> *MachineProfile;
> > - public:
> > - static char ID; // Class identification, replacement for typeinfo
> > - ProfileInfoT();
> > - ~ProfileInfoT(); // We want to be subclassed
> > -
> > - // MissingValue - The value that is returned for execution counts
> in case
> > - // no value is available.
> > - static const double MissingValue;
> > -
> > - // getFunction() - Returns the Function for an Edge, checking for
> validity.
> > - static const FType* getFunction(Edge e) {
> > - if (e.first)
> > - return e.first->getParent();
> > - if (e.second)
> > - return e.second->getParent();
> > - llvm_unreachable("Invalid ProfileInfo::Edge");
> > - }
> > -
> > - // getEdge() - Creates an Edge from two BasicBlocks.
> > - static Edge getEdge(const BType *Src, const BType *Dest) {
> > - return std::make_pair(Src, Dest);
> > - }
> > -
> > -
> //===------------------------------------------------------------------===//
> > - /// Profile Information Queries
> > - ///
> > - double getExecutionCount(const FType *F);
> > -
> > - double getExecutionCount(const BType *BB);
> > -
> > - void setExecutionCount(const BType *BB, double w);
> > -
> > - void addExecutionCount(const BType *BB, double w);
> > -
> > - double getEdgeWeight(Edge e) const {
> > - typename std::map<const FType*, EdgeWeights>::const_iterator J =
> > - EdgeInformation.find(getFunction(e));
> > - if (J == EdgeInformation.end()) return MissingValue;
> > -
> > - typename EdgeWeights::const_iterator I = J->second.find(e);
> > - if (I == J->second.end()) return MissingValue;
> > -
> > - return I->second;
> > - }
> > -
> > - void setEdgeWeight(Edge e, double w) {
> > - DEBUG_WITH_TYPE("profile-info",
> > - dbgs() << "Creating Edge " << e
> > - << " (weight: " << format("%.20g",w) << ")\n");
> > - EdgeInformation[getFunction(e)][e] = w;
> > - }
> > -
> > - void addEdgeWeight(Edge e, double w);
> > -
> > - EdgeWeights &getEdgeWeights (const FType *F) {
> > - return EdgeInformation[F];
> > - }
> > -
> > -
> //===------------------------------------------------------------------===//
> > - /// Analysis Update Methods
> > - ///
> > - void removeBlock(const BType *BB);
> > -
> > - void removeEdge(Edge e);
> > -
> > - void replaceEdge(const Edge &, const Edge &);
> > -
> > - enum GetPathMode {
> > - GetPathToExit = 1,
> > - GetPathToValue = 2,
> > - GetPathToDest = 4,
> > - GetPathWithNewEdges = 8
> > - };
> > -
> > - const BType *GetPath(const BType *Src, const BType *Dest,
> > - Path &P, unsigned Mode);
> > -
> > - void divertFlow(const Edge &, const Edge &);
> > -
> > - void splitEdge(const BType *FirstBB, const BType *SecondBB,
> > - const BType *NewBB, bool MergeIdenticalEdges =
> false);
> > -
> > - void splitBlock(const BType *Old, const BType* New);
> > -
> > - void splitBlock(const BType *BB, const BType* NewBB,
> > - BType *const *Preds, unsigned NumPreds);
> > -
> > - void replaceAllUses(const BType *RmBB, const BType *DestBB);
> > -
> > - void transfer(const FType *Old, const FType *New);
> > -
> > - void repair(const FType *F);
> > -
> > - void dump(FType *F = 0, bool real = true) {
> > - dbgs() << "**** This is ProfileInfo " << this << " speaking:\n";
> > - if (!real) {
> > - typename std::set<const FType*> Functions;
> > -
> > - dbgs() << "Functions: \n";
> > - if (F) {
> > - dbgs() << F << "@" << format("%p", F) << ": " <<
> format("%.20g",getExecutionCount(F)) << "\n";
> > - Functions.insert(F);
> > - } else {
> > - for (typename std::map<const FType*, double>::iterator fi =
> FunctionInformation.begin(),
> > - fe = FunctionInformation.end(); fi != fe; ++fi) {
> > - dbgs() << fi->first << "@" << format("%p",fi->first) << ":
> " << format("%.20g",fi->second) << "\n";
> > - Functions.insert(fi->first);
> > - }
> > - }
> > -
> > - for (typename std::set<const FType*>::iterator FI =
> Functions.begin(), FE = Functions.end();
> > - FI != FE; ++FI) {
> > - const FType *F = *FI;
> > - typename std::map<const FType*, BlockCounts>::iterator bwi =
> BlockInformation.find(F);
> > - dbgs() << "BasicBlocks for Function " << F << ":\n";
> > - for (typename BlockCounts::const_iterator bi =
> bwi->second.begin(), be = bwi->second.end(); bi != be; ++bi) {
> > - dbgs() << bi->first << "@" << format("%p", bi->first) << ":
> " << format("%.20g",bi->second) << "\n";
> > - }
> > - }
> > -
> > - for (typename std::set<const FType*>::iterator FI =
> Functions.begin(), FE = Functions.end();
> > - FI != FE; ++FI) {
> > - typename std::map<const FType*, EdgeWeights>::iterator ei =
> EdgeInformation.find(*FI);
> > - dbgs() << "Edges for Function " << ei->first << ":\n";
> > - for (typename EdgeWeights::iterator ewi = ei->second.begin(),
> ewe = ei->second.end();
> > - ewi != ewe; ++ewi) {
> > - dbgs() << ewi->first << ": " << format("%.20g",ewi->second)
> << "\n";
> > - }
> > - }
> > - } else {
> > - assert(F && "No function given, this is not supported!");
> > - dbgs() << "Functions: \n";
> > - dbgs() << F << "@" << format("%p", F) << ": " <<
> format("%.20g",getExecutionCount(F)) << "\n";
> > -
> > - dbgs() << "BasicBlocks for Function " << F << ":\n";
> > - for (typename FType::const_iterator BI = F->begin(), BE =
> F->end();
> > - BI != BE; ++BI) {
> > - const BType *BB = &(*BI);
> > - dbgs() << BB << "@" << format("%p", BB) << ": " <<
> format("%.20g",getExecutionCount(BB)) << "\n";
> > - }
> > - }
> > - dbgs() << "**** ProfileInfo " << this << ", over and out.\n";
> > - }
> > -
> > - bool CalculateMissingEdge(const BType *BB, Edge &removed, bool
> assumeEmptyExit = false);
> > -
> > - bool EstimateMissingEdges(const BType *BB);
> > -
> > - ProfileInfoT<MachineFunction, MachineBasicBlock> *MI() {
> > - if (MachineProfile == 0)
> > - MachineProfile = new ProfileInfoT<MachineFunction,
> MachineBasicBlock>();
> > - return MachineProfile;
> > - }
> > -
> > - bool hasMI() const {
> > - return (MachineProfile != 0);
> > - }
> > - };
> > -
> > - typedef ProfileInfoT<Function, BasicBlock> ProfileInfo;
> > - typedef ProfileInfoT<MachineFunction, MachineBasicBlock>
> MachineProfileInfo;
> > -
> > - /// createProfileLoaderPass - This function returns a Pass that loads
> the
> > - /// profiling information for the module from the specified filename,
> making
> > - /// it available to the optimizers.
> > - Pass *createProfileLoaderPass(const std::string &Filename);
> > -
> > -} // End llvm namespace
> > -
> > -#endif
> >
> > Removed: llvm/trunk/include/llvm/Analysis/ProfileInfoLoader.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ProfileInfoLoader.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/ProfileInfoLoader.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/ProfileInfoLoader.h (removed)
> > @@ -1,81 +0,0 @@
> > -//===- ProfileInfoLoader.h - Load & convert profile information -*- C++
> -*-===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// The ProfileInfoLoader class is used to load and represent profiling
> > -// information read in from the dump file. If conversions between
> formats are
> > -// needed, it can also do this.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_ANALYSIS_PROFILEINFOLOADER_H
> > -#define LLVM_ANALYSIS_PROFILEINFOLOADER_H
> > -
> > -#include <string>
> > -#include <utility>
> > -#include <vector>
> > -
> > -namespace llvm {
> > -
> > -class Module;
> > -class Function;
> > -class BasicBlock;
> > -
> > -class ProfileInfoLoader {
> > - const std::string &Filename;
> > - std::vector<std::string> CommandLines;
> > - std::vector<unsigned> FunctionCounts;
> > - std::vector<unsigned> BlockCounts;
> > - std::vector<unsigned> EdgeCounts;
> > - std::vector<unsigned> OptimalEdgeCounts;
> > - std::vector<unsigned> BBTrace;
> > -public:
> > - // ProfileInfoLoader ctor - Read the specified profiling data file,
> exiting
> > - // the program if the file is invalid or broken.
> > - ProfileInfoLoader(const char *ToolName, const std::string &Filename);
> > -
> > - static const unsigned Uncounted;
> > -
> > - unsigned getNumExecutions() const { return CommandLines.size(); }
> > - const std::string &getExecution(unsigned i) const { return
> CommandLines[i]; }
> > -
> > - const std::string &getFileName() const { return Filename; }
> > -
> > - // getRawFunctionCounts - This method is used by consumers of function
> > - // counting information.
> > - //
> > - const std::vector<unsigned> &getRawFunctionCounts() const {
> > - return FunctionCounts;
> > - }
> > -
> > - // getRawBlockCounts - This method is used by consumers of block
> counting
> > - // information.
> > - //
> > - const std::vector<unsigned> &getRawBlockCounts() const {
> > - return BlockCounts;
> > - }
> > -
> > - // getEdgeCounts - This method is used by consumers of edge counting
> > - // information.
> > - //
> > - const std::vector<unsigned> &getRawEdgeCounts() const {
> > - return EdgeCounts;
> > - }
> > -
> > - // getEdgeOptimalCounts - This method is used by consumers of optimal
> edge
> > - // counting information.
> > - //
> > - const std::vector<unsigned> &getRawOptimalEdgeCounts() const {
> > - return OptimalEdgeCounts;
> > - }
> > -
> > -};
> > -
> > -} // End llvm namespace
> > -
> > -#endif
> >
> > Removed: llvm/trunk/include/llvm/Analysis/ProfileInfoTypes.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ProfileInfoTypes.h?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Analysis/ProfileInfoTypes.h (original)
> > +++ llvm/trunk/include/llvm/Analysis/ProfileInfoTypes.h (removed)
> > @@ -1,52 +0,0 @@
> > -/*===-- ProfileInfoTypes.h - Profiling info shared constants
> --------------===*\
> > -|*
> > -|* The LLVM Compiler Infrastructure
> > -|*
> > -|* This file is distributed under the University of Illinois Open Source
> > -|* License. See LICENSE.TXT for details.
> > -|*
> >
> -|*===----------------------------------------------------------------------===*|
> > -|*
> > -|* This file defines constants shared by the various different profiling
> > -|* runtime libraries and the LLVM C++ profile info loader. It must be a
> > -|* C header because, at present, the profiling runtimes are written in
> C.
> > -|*
> >
> -\*===----------------------------------------------------------------------===*/
> > -
> > -#ifndef LLVM_ANALYSIS_PROFILEINFOTYPES_H
> > -#define LLVM_ANALYSIS_PROFILEINFOTYPES_H
> > -
> > -/* Included by libprofile. */
> > -#if defined(__cplusplus)
> > -extern "C" {
> > -#endif
> > -
> > -/* IDs to distinguish between those path counters stored in hashses vs
> arrays */
> > -enum ProfilingStorageType {
> > - ProfilingArray = 1,
> > - ProfilingHash = 2
> > -};
> > -
> > -#include "llvm/Analysis/ProfileDataTypes.h"
> > -
> > -/*
> > - * The header for tables that map path numbers to path counters.
> > - */
> > -typedef struct {
> > - unsigned fnNumber; /* function number for these counters */
> > - unsigned numEntries; /* number of entries stored */
> > -} PathProfileHeader;
> > -
> > -/*
> > - * Describes an entry in a tagged table for path counters.
> > - */
> > -typedef struct {
> > - unsigned pathNumber;
> > - unsigned pathCounter;
> > -} PathProfileTableEntry;
> > -
> > -#if defined(__cplusplus)
> > -}
> > -#endif
> > -
> > -#endif /* LLVM_ANALYSIS_PROFILEINFOTYPES_H */
> >
> > Modified: llvm/trunk/include/llvm/InitializePasses.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/InitializePasses.h?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/InitializePasses.h (original)
> > +++ llvm/trunk/include/llvm/InitializePasses.h Wed Oct 2 10:42:23 2013
> > @@ -113,9 +113,7 @@ void initializeDominanceFrontierPass(Pas
> > void initializeDominatorTreePass(PassRegistry&);
> > void initializeEarlyIfConverterPass(PassRegistry&);
> > void initializeEdgeBundlesPass(PassRegistry&);
> > -void initializeEdgeProfilerPass(PassRegistry&);
> > void initializeExpandPostRAPass(PassRegistry&);
> > -void initializePathProfilerPass(PassRegistry&);
> > void initializeGCOVProfilerPass(PassRegistry&);
> > void initializeAddressSanitizerPass(PassRegistry&);
> > void initializeAddressSanitizerModulePass(PassRegistry&);
> > @@ -155,8 +153,6 @@ void initializeLiveRegMatrixPass(PassReg
> > void initializeLiveStacksPass(PassRegistry&);
> > void initializeLiveVariablesPass(PassRegistry&);
> > void initializeLoaderPassPass(PassRegistry&);
> > -void initializeProfileMetadataLoaderPassPass(PassRegistry&);
> > -void initializePathProfileLoaderPassPass(PassRegistry&);
> > void initializeLocalStackSlotPassPass(PassRegistry&);
> > void initializeLoopDeletionPass(PassRegistry&);
> > void initializeLoopExtractorPass(PassRegistry&);
> > @@ -195,14 +191,11 @@ void initializeMetaRenamerPass(PassRegis
> > void initializeMergeFunctionsPass(PassRegistry&);
> > void initializeModuleDebugInfoPrinterPass(PassRegistry&);
> > void initializeNoAAPass(PassRegistry&);
> > -void initializeNoProfileInfoPass(PassRegistry&);
> > -void initializeNoPathProfileInfoPass(PassRegistry&);
> > void initializeObjCARCAliasAnalysisPass(PassRegistry&);
> > void initializeObjCARCAPElimPass(PassRegistry&);
> > void initializeObjCARCExpandPass(PassRegistry&);
> > void initializeObjCARCContractPass(PassRegistry&);
> > void initializeObjCARCOptPass(PassRegistry&);
> > -void initializeOptimalEdgeProfilerPass(PassRegistry&);
> > void initializeOptimizePHIsPass(PassRegistry&);
> > void initializePartiallyInlineLibCallsPass(PassRegistry&);
> > void initializePEIPass(PassRegistry&);
> > @@ -220,11 +213,6 @@ void initializePrintFunctionPassPass(Pas
> > void initializePrintModulePassPass(PassRegistry&);
> > void initializePrintBasicBlockPassPass(PassRegistry&);
> > void initializeProcessImplicitDefsPass(PassRegistry&);
> > -void initializeProfileEstimatorPassPass(PassRegistry&);
> > -void initializeProfileInfoAnalysisGroup(PassRegistry&);
> > -void initializePathProfileInfoAnalysisGroup(PassRegistry&);
> > -void initializePathProfileVerifierPass(PassRegistry&);
> > -void initializeProfileVerifierPassPass(PassRegistry&);
> > void initializePromotePassPass(PassRegistry&);
> > void initializePruneEHPass(PassRegistry&);
> > void initializeReassociatePass(PassRegistry&);
> >
> > Modified: llvm/trunk/include/llvm/LinkAllPasses.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/LinkAllPasses.h?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/LinkAllPasses.h (original)
> > +++ llvm/trunk/include/llvm/LinkAllPasses.h Wed Oct 2 10:42:23 2013
> > @@ -74,9 +74,6 @@ namespace {
> > (void) llvm::createDomPrinterPass();
> > (void) llvm::createDomOnlyViewerPass();
> > (void) llvm::createDomViewerPass();
> > - (void) llvm::createEdgeProfilerPass();
> > - (void) llvm::createOptimalEdgeProfilerPass();
> > - (void) llvm::createPathProfilerPass();
> > (void) llvm::createGCOVProfilerPass();
> > (void) llvm::createFunctionInliningPass();
> > (void) llvm::createAlwaysInlinerPass();
> > @@ -102,18 +99,11 @@ namespace {
> > (void) llvm::createLowerInvokePass();
> > (void) llvm::createLowerSwitchPass();
> > (void) llvm::createNoAAPass();
> > - (void) llvm::createNoProfileInfoPass();
> > (void) llvm::createObjCARCAliasAnalysisPass();
> > (void) llvm::createObjCARCAPElimPass();
> > (void) llvm::createObjCARCExpandPass();
> > (void) llvm::createObjCARCContractPass();
> > (void) llvm::createObjCARCOptPass();
> > - (void) llvm::createProfileEstimatorPass();
> > - (void) llvm::createProfileVerifierPass();
> > - (void) llvm::createPathProfileVerifierPass();
> > - (void) llvm::createProfileLoaderPass();
> > - (void) llvm::createProfileMetadataLoaderPass();
> > - (void) llvm::createPathProfileLoaderPass();
> > (void) llvm::createPromoteMemoryToRegisterPass();
> > (void) llvm::createDemoteRegisterToMemoryPass();
> > (void) llvm::createPruneEHPass();
> >
> > Modified: llvm/trunk/include/llvm/Transforms/Instrumentation.h
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Transforms/Instrumentation.h?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/include/llvm/Transforms/Instrumentation.h (original)
> > +++ llvm/trunk/include/llvm/Transforms/Instrumentation.h Wed Oct 2
> 10:42:23 2013
> > @@ -35,15 +35,6 @@ namespace llvm {
> > class ModulePass;
> > class FunctionPass;
> >
> > -// Insert edge profiling instrumentation
> > -ModulePass *createEdgeProfilerPass();
> > -
> > -// Insert optimal edge profiling instrumentation
> > -ModulePass *createOptimalEdgeProfilerPass();
> > -
> > -// Insert path profiling instrumentation
> > -ModulePass *createPathProfilerPass();
> > -
> > // Insert GCOV profiling instrumentation
> > struct GCOVOptions {
> > static GCOVOptions getDefault();
> >
> > Modified: llvm/trunk/lib/Analysis/Analysis.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/Analysis.cpp?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/Analysis.cpp (original)
> > +++ llvm/trunk/lib/Analysis/Analysis.cpp Wed Oct 2 10:42:23 2013
> > @@ -54,16 +54,6 @@ void llvm::initializeAnalysis(PassRegist
> > initializeMemoryDependenceAnalysisPass(Registry);
> > initializeModuleDebugInfoPrinterPass(Registry);
> > initializePostDominatorTreePass(Registry);
> > - initializeProfileEstimatorPassPass(Registry);
> > - initializeNoProfileInfoPass(Registry);
> > - initializeNoPathProfileInfoPass(Registry);
> > - initializeProfileInfoAnalysisGroup(Registry);
> > - initializePathProfileInfoAnalysisGroup(Registry);
> > - initializeLoaderPassPass(Registry);
> > - initializePathProfileLoaderPassPass(Registry);
> > - initializeProfileVerifierPassPass(Registry);
> > - initializePathProfileVerifierPass(Registry);
> > - initializeProfileMetadataLoaderPassPass(Registry);
> > initializeRegionInfoPass(Registry);
> > initializeRegionViewerPass(Registry);
> > initializeRegionPrinterPass(Registry);
> >
> > Modified: llvm/trunk/lib/Analysis/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/CMakeLists.txt?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/CMakeLists.txt (original)
> > +++ llvm/trunk/lib/Analysis/CMakeLists.txt Wed Oct 2 10:42:23 2013
> > @@ -35,17 +35,7 @@ add_llvm_library(LLVMAnalysis
> > ModuleDebugInfoPrinter.cpp
> > NoAliasAnalysis.cpp
> > PHITransAddr.cpp
> > - PathNumbering.cpp
> > - PathProfileInfo.cpp
> > - PathProfileVerifier.cpp
> > PostDominators.cpp
> > - ProfileEstimatorPass.cpp
> > - ProfileInfo.cpp
> > - ProfileInfoLoader.cpp
> > - ProfileInfoLoaderPass.cpp
> > - ProfileVerifierPass.cpp
> > - ProfileDataLoader.cpp
> > - ProfileDataLoaderPass.cpp
> > PtrUseVisitor.cpp
> > RegionInfo.cpp
> > RegionPass.cpp
> >
> > Removed: llvm/trunk/lib/Analysis/PathNumbering.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/PathNumbering.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/PathNumbering.cpp (original)
> > +++ llvm/trunk/lib/Analysis/PathNumbering.cpp (removed)
> > @@ -1,521 +0,0 @@
> > -//===- PathNumbering.cpp --------------------------------------*- C++
> -*---===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// Ball-Larus path numbers uniquely identify paths through a directed
> acyclic
> > -// graph (DAG) [Ball96]. For a CFG backedges are removed and replaced
> by phony
> > -// edges to obtain a DAG, and thus the unique path numbers [Ball96].
> > -//
> > -// The purpose of this analysis is to enumerate the edges in a CFG in
> order
> > -// to obtain paths from path numbers in a convenient manner. As
> described in
> > -// [Ball96] edges can be enumerated such that given a path number by
> following
> > -// the CFG and updating the path number, the path is obtained.
> > -//
> > -// [Ball96]
> > -// T. Ball and J. R. Larus. "Efficient Path Profiling."
> > -// International Symposium on Microarchitecture, pages 46-57, 1996.
> > -// http://portal.acm.org/citation.cfm?id=243857
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "ball-larus-numbering"
> > -
> > -#include "llvm/Analysis/PathNumbering.h"
> > -#include "llvm/IR/Constants.h"
> > -#include "llvm/IR/DerivedTypes.h"
> > -#include "llvm/IR/InstrTypes.h"
> > -#include "llvm/IR/Instructions.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/IR/TypeBuilder.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Compiler.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <queue>
> > -#include <sstream>
> > -#include <stack>
> > -#include <string>
> > -#include <utility>
> > -
> > -using namespace llvm;
> > -
> > -// Are we enabling early termination
> > -static cl::opt<bool> ProcessEarlyTermination(
> > - "path-profile-early-termination", cl::Hidden,
> > - cl::desc("In path profiling, insert extra instrumentation to account
> for "
> > - "unexpected function termination."));
> > -
> > -// Returns the basic block for the BallLarusNode
> > -BasicBlock* BallLarusNode::getBlock() {
> > - return(_basicBlock);
> > -}
> > -
> > -// Returns the number of paths to the exit starting at the node.
> > -unsigned BallLarusNode::getNumberPaths() {
> > - return(_numberPaths);
> > -}
> > -
> > -// Sets the number of paths to the exit starting at the node.
> > -void BallLarusNode::setNumberPaths(unsigned numberPaths) {
> > - _numberPaths = numberPaths;
> > -}
> > -
> > -// Gets the NodeColor used in graph algorithms.
> > -BallLarusNode::NodeColor BallLarusNode::getColor() {
> > - return(_color);
> > -}
> > -
> > -// Sets the NodeColor used in graph algorithms.
> > -void BallLarusNode::setColor(BallLarusNode::NodeColor color) {
> > - _color = color;
> > -}
> > -
> > -// Returns an iterator over predecessor edges. Includes phony and
> > -// backedges.
> > -BLEdgeIterator BallLarusNode::predBegin() {
> > - return(_predEdges.begin());
> > -}
> > -
> > -// Returns the end sentinel for the predecessor iterator.
> > -BLEdgeIterator BallLarusNode::predEnd() {
> > - return(_predEdges.end());
> > -}
> > -
> > -// Returns the number of predecessor edges. Includes phony and
> > -// backedges.
> > -unsigned BallLarusNode::getNumberPredEdges() {
> > - return(_predEdges.size());
> > -}
> > -
> > -// Returns an iterator over successor edges. Includes phony and
> > -// backedges.
> > -BLEdgeIterator BallLarusNode::succBegin() {
> > - return(_succEdges.begin());
> > -}
> > -
> > -// Returns the end sentinel for the successor iterator.
> > -BLEdgeIterator BallLarusNode::succEnd() {
> > - return(_succEdges.end());
> > -}
> > -
> > -// Returns the number of successor edges. Includes phony and
> > -// backedges.
> > -unsigned BallLarusNode::getNumberSuccEdges() {
> > - return(_succEdges.size());
> > -}
> > -
> > -// Add an edge to the predecessor list.
> > -void BallLarusNode::addPredEdge(BallLarusEdge* edge) {
> > - _predEdges.push_back(edge);
> > -}
> > -
> > -// Remove an edge from the predecessor list.
> > -void BallLarusNode::removePredEdge(BallLarusEdge* edge) {
> > - removeEdge(_predEdges, edge);
> > -}
> > -
> > -// Add an edge to the successor list.
> > -void BallLarusNode::addSuccEdge(BallLarusEdge* edge) {
> > - _succEdges.push_back(edge);
> > -}
> > -
> > -// Remove an edge from the successor list.
> > -void BallLarusNode::removeSuccEdge(BallLarusEdge* edge) {
> > - removeEdge(_succEdges, edge);
> > -}
> > -
> > -// Returns the name of the BasicBlock being represented. If BasicBlock
> > -// is null then returns "<null>". If BasicBlock has no name, then
> > -// "<unnamed>" is returned. Intended for use with debug output.
> > -std::string BallLarusNode::getName() {
> > - std::stringstream name;
> > -
> > - if(getBlock() != NULL) {
> > - if(getBlock()->hasName()) {
> > - std::string tempName(getBlock()->getName());
> > - name << tempName.c_str() << " (" << _uid << ")";
> > - } else
> > - name << "<unnamed> (" << _uid << ")";
> > - } else
> > - name << "<null> (" << _uid << ")";
> > -
> > - return name.str();
> > -}
> > -
> > -// Removes an edge from an edgeVector. Used by removePredEdge and
> > -// removeSuccEdge.
> > -void BallLarusNode::removeEdge(BLEdgeVector& v, BallLarusEdge* e) {
> > - // TODO: Avoid linear scan by using a set instead
> > - for(BLEdgeIterator i = v.begin(),
> > - end = v.end();
> > - i != end;
> > - ++i) {
> > - if((*i) == e) {
> > - v.erase(i);
> > - break;
> > - }
> > - }
> > -}
> > -
> > -// Returns the source node of this edge.
> > -BallLarusNode* BallLarusEdge::getSource() const {
> > - return(_source);
> > -}
> > -
> > -// Returns the target node of this edge.
> > -BallLarusNode* BallLarusEdge::getTarget() const {
> > - return(_target);
> > -}
> > -
> > -// Sets the type of the edge.
> > -BallLarusEdge::EdgeType BallLarusEdge::getType() const {
> > - return _edgeType;
> > -}
> > -
> > -// Gets the type of the edge.
> > -void BallLarusEdge::setType(EdgeType type) {
> > - _edgeType = type;
> > -}
> > -
> > -// Returns the weight of this edge. Used to decode path numbers to
> sequences
> > -// of basic blocks.
> > -unsigned BallLarusEdge::getWeight() {
> > - return(_weight);
> > -}
> > -
> > -// Sets the weight of the edge. Used during path numbering.
> > -void BallLarusEdge::setWeight(unsigned weight) {
> > - _weight = weight;
> > -}
> > -
> > -// Gets the phony edge originating at the root.
> > -BallLarusEdge* BallLarusEdge::getPhonyRoot() {
> > - return _phonyRoot;
> > -}
> > -
> > -// Sets the phony edge originating at the root.
> > -void BallLarusEdge::setPhonyRoot(BallLarusEdge* phonyRoot) {
> > - _phonyRoot = phonyRoot;
> > -}
> > -
> > -// Gets the phony edge terminating at the exit.
> > -BallLarusEdge* BallLarusEdge::getPhonyExit() {
> > - return _phonyExit;
> > -}
> > -
> > -// Sets the phony edge terminating at the exit.
> > -void BallLarusEdge::setPhonyExit(BallLarusEdge* phonyExit) {
> > - _phonyExit = phonyExit;
> > -}
> > -
> > -// Gets the associated real edge if this is a phony edge.
> > -BallLarusEdge* BallLarusEdge::getRealEdge() {
> > - return _realEdge;
> > -}
> > -
> > -// Sets the associated real edge if this is a phony edge.
> > -void BallLarusEdge::setRealEdge(BallLarusEdge* realEdge) {
> > - _realEdge = realEdge;
> > -}
> > -
> > -// Returns the duplicate number of the edge.
> > -unsigned BallLarusEdge::getDuplicateNumber() {
> > - return(_duplicateNumber);
> > -}
> > -
> > -// Initialization that requires virtual functions which are not fully
> > -// functional in the constructor.
> > -void BallLarusDag::init() {
> > - BLBlockNodeMap inDag;
> > - std::stack<BallLarusNode*> dfsStack;
> > -
> > - _root = addNode(&(_function.getEntryBlock()));
> > - _exit = addNode(NULL);
> > -
> > - // start search from root
> > - dfsStack.push(getRoot());
> > -
> > - // dfs to add each bb into the dag
> > - while(dfsStack.size())
> > - buildNode(inDag, dfsStack);
> > -
> > - // put in the final edge
> > - addEdge(getExit(),getRoot(),0);
> > -}
> > -
> > -// Frees all memory associated with the DAG.
> > -BallLarusDag::~BallLarusDag() {
> > - for(BLEdgeIterator edge = _edges.begin(), end = _edges.end(); edge !=
> end;
> > - ++edge)
> > - delete (*edge);
> > -
> > - for(BLNodeIterator node = _nodes.begin(), end = _nodes.end(); node !=
> end;
> > - ++node)
> > - delete (*node);
> > -}
> > -
> > -// Calculate the path numbers by assigning edge increments as prescribed
> > -// in Ball-Larus path profiling.
> > -void BallLarusDag::calculatePathNumbers() {
> > - BallLarusNode* node;
> > - std::queue<BallLarusNode*> bfsQueue;
> > - bfsQueue.push(getExit());
> > -
> > - while(bfsQueue.size() > 0) {
> > - node = bfsQueue.front();
> > -
> > - DEBUG(dbgs() << "calculatePathNumbers on " << node->getName() <<
> "\n");
> > -
> > - bfsQueue.pop();
> > - unsigned prevPathNumber = node->getNumberPaths();
> > - calculatePathNumbersFrom(node);
> > -
> > - // Check for DAG splitting
> > - if( node->getNumberPaths() > 100000000 && node != getRoot() ) {
> > - // Add new phony edge from the split-node to the DAG's exit
> > - BallLarusEdge* exitEdge = addEdge(node, getExit(), 0);
> > - exitEdge->setType(BallLarusEdge::SPLITEDGE_PHONY);
> > -
> > - // Counters to handle the possibility of a multi-graph
> > - BasicBlock* oldTarget = 0;
> > - unsigned duplicateNumber = 0;
> > -
> > - // Iterate through each successor edge, adding phony edges
> > - for( BLEdgeIterator succ = node->succBegin(), end =
> node->succEnd();
> > - succ != end; oldTarget = (*succ)->getTarget()->getBlock(),
> succ++ ) {
> > -
> > - if( (*succ)->getType() == BallLarusEdge::NORMAL ) {
> > - // is this edge a duplicate?
> > - if( oldTarget != (*succ)->getTarget()->getBlock() )
> > - duplicateNumber = 0;
> > -
> > - // create the new phony edge: root -> succ
> > - BallLarusEdge* rootEdge =
> > - addEdge(getRoot(), (*succ)->getTarget(), duplicateNumber++);
> > - rootEdge->setType(BallLarusEdge::SPLITEDGE_PHONY);
> > - rootEdge->setRealEdge(*succ);
> > -
> > - // split on this edge and reference it's exit/root phony edges
> > - (*succ)->setType(BallLarusEdge::SPLITEDGE);
> > - (*succ)->setPhonyRoot(rootEdge);
> > - (*succ)->setPhonyExit(exitEdge);
> > - (*succ)->setWeight(0);
> > - }
> > - }
> > -
> > - calculatePathNumbersFrom(node);
> > - }
> > -
> > - DEBUG(dbgs() << "prev, new number paths " << prevPathNumber << ", "
> > - << node->getNumberPaths() << ".\n");
> > -
> > - if(prevPathNumber == 0 && node->getNumberPaths() != 0) {
> > - DEBUG(dbgs() << "node ready : " << node->getName() << "\n");
> > - for(BLEdgeIterator pred = node->predBegin(), end =
> node->predEnd();
> > - pred != end; pred++) {
> > - if( (*pred)->getType() == BallLarusEdge::BACKEDGE ||
> > - (*pred)->getType() == BallLarusEdge::SPLITEDGE )
> > - continue;
> > -
> > - BallLarusNode* nextNode = (*pred)->getSource();
> > - // not yet visited?
> > - if(nextNode->getNumberPaths() == 0)
> > - bfsQueue.push(nextNode);
> > - }
> > - }
> > - }
> > -
> > - DEBUG(dbgs() << "\tNumber of paths: " << getRoot()->getNumberPaths()
> << "\n");
> > -}
> > -
> > -// Returns the number of paths for the Dag.
> > -unsigned BallLarusDag::getNumberOfPaths() {
> > - return(getRoot()->getNumberPaths());
> > -}
> > -
> > -// Returns the root (i.e. entry) node for the DAG.
> > -BallLarusNode* BallLarusDag::getRoot() {
> > - return _root;
> > -}
> > -
> > -// Returns the exit node for the DAG.
> > -BallLarusNode* BallLarusDag::getExit() {
> > - return _exit;
> > -}
> > -
> > -// Returns the function for the DAG.
> > -Function& BallLarusDag::getFunction() {
> > - return(_function);
> > -}
> > -
> > -// Clears the node colors.
> > -void BallLarusDag::clearColors(BallLarusNode::NodeColor color) {
> > - for (BLNodeIterator nodeIt = _nodes.begin(); nodeIt != _nodes.end();
> nodeIt++)
> > - (*nodeIt)->setColor(color);
> > -}
> > -
> > -// Processes one node and its imediate edges for building the DAG.
> > -void BallLarusDag::buildNode(BLBlockNodeMap& inDag, BLNodeStack&
> dfsStack) {
> > - BallLarusNode* currentNode = dfsStack.top();
> > - BasicBlock* currentBlock = currentNode->getBlock();
> > -
> > - if(currentNode->getColor() != BallLarusNode::WHITE) {
> > - // we have already visited this node
> > - dfsStack.pop();
> > - currentNode->setColor(BallLarusNode::BLACK);
> > - } else {
> > - // are there any external procedure calls?
> > - if( ProcessEarlyTermination ) {
> > - for( BasicBlock::iterator bbCurrent =
> currentNode->getBlock()->begin(),
> > - bbEnd = currentNode->getBlock()->end(); bbCurrent != bbEnd;
> > - bbCurrent++ ) {
> > - Instruction& instr = *bbCurrent;
> > - if( instr.getOpcode() == Instruction::Call ) {
> > - BallLarusEdge* callEdge = addEdge(currentNode, getExit(), 0);
> > - callEdge->setType(BallLarusEdge::CALLEDGE_PHONY);
> > - break;
> > - }
> > - }
> > - }
> > -
> > - TerminatorInst* terminator =
> currentNode->getBlock()->getTerminator();
> > - if(isa<ReturnInst>(terminator) || isa<UnreachableInst>(terminator)
> ||
> > - isa<ResumeInst>(terminator))
> > - addEdge(currentNode, getExit(),0);
> > -
> > - currentNode->setColor(BallLarusNode::GRAY);
> > - inDag[currentBlock] = currentNode;
> > -
> > - BasicBlock* oldSuccessor = 0;
> > - unsigned duplicateNumber = 0;
> > -
> > - // iterate through this node's successors
> > - for(succ_iterator successor = succ_begin(currentBlock),
> > - succEnd = succ_end(currentBlock); successor != succEnd;
> > - oldSuccessor = *successor, ++successor ) {
> > - BasicBlock* succBB = *successor;
> > -
> > - // is this edge a duplicate?
> > - if (oldSuccessor == succBB)
> > - duplicateNumber++;
> > - else
> > - duplicateNumber = 0;
> > -
> > - buildEdge(inDag, dfsStack, currentNode, succBB, duplicateNumber);
> > - }
> > - }
> > -}
> > -
> > -// Process an edge in the CFG for DAG building.
> > -void BallLarusDag::buildEdge(BLBlockNodeMap& inDag,
> std::stack<BallLarusNode*>&
> > - dfsStack, BallLarusNode* currentNode,
> > - BasicBlock* succBB, unsigned
> duplicateCount) {
> > - BallLarusNode* succNode = inDag[succBB];
> > -
> > - if(succNode && succNode->getColor() == BallLarusNode::BLACK) {
> > - // visited node and forward edge
> > - addEdge(currentNode, succNode, duplicateCount);
> > - } else if(succNode && succNode->getColor() == BallLarusNode::GRAY) {
> > - // visited node and back edge
> > - DEBUG(dbgs() << "Backedge detected.\n");
> > - addBackedge(currentNode, succNode, duplicateCount);
> > - } else {
> > - BallLarusNode* childNode;
> > - // not visited node and forward edge
> > - if(succNode) // an unvisited node that is child of a gray node
> > - childNode = succNode;
> > - else { // an unvisited node that is a child of a an unvisted node
> > - childNode = addNode(succBB);
> > - inDag[succBB] = childNode;
> > - }
> > - addEdge(currentNode, childNode, duplicateCount);
> > - dfsStack.push(childNode);
> > - }
> > -}
> > -
> > -// The weight on each edge is the increment required along any path that
> > -// contains that edge.
> > -void BallLarusDag::calculatePathNumbersFrom(BallLarusNode* node) {
> > - if(node == getExit())
> > - // The Exit node must be base case
> > - node->setNumberPaths(1);
> > - else {
> > - unsigned sumPaths = 0;
> > - BallLarusNode* succNode;
> > -
> > - for(BLEdgeIterator succ = node->succBegin(), end = node->succEnd();
> > - succ != end; succ++) {
> > - if( (*succ)->getType() == BallLarusEdge::BACKEDGE ||
> > - (*succ)->getType() == BallLarusEdge::SPLITEDGE )
> > - continue;
> > -
> > - (*succ)->setWeight(sumPaths);
> > - succNode = (*succ)->getTarget();
> > -
> > - if( !succNode->getNumberPaths() )
> > - return;
> > - sumPaths += succNode->getNumberPaths();
> > - }
> > -
> > - node->setNumberPaths(sumPaths);
> > - }
> > -}
> > -
> > -// Allows subclasses to determine which type of Node is created.
> > -// Override this method to produce subclasses of BallLarusNode if
> > -// necessary. The destructor of BallLarusDag will call free on each
> > -// pointer created.
> > -BallLarusNode* BallLarusDag::createNode(BasicBlock* BB) {
> > - return( new BallLarusNode(BB) );
> > -}
> > -
> > -// Allows subclasses to determine which type of Edge is created.
> > -// Override this method to produce subclasses of BallLarusEdge if
> > -// necessary. The destructor of BallLarusDag will call free on each
> > -// pointer created.
> > -BallLarusEdge* BallLarusDag::createEdge(BallLarusNode* source,
> > - BallLarusNode* target,
> > - unsigned duplicateCount) {
> > - return( new BallLarusEdge(source, target, duplicateCount) );
> > -}
> > -
> > -// Proxy to node's constructor. Updates the DAG state.
> > -BallLarusNode* BallLarusDag::addNode(BasicBlock* BB) {
> > - BallLarusNode* newNode = createNode(BB);
> > - _nodes.push_back(newNode);
> > - return( newNode );
> > -}
> > -
> > -// Proxy to edge's constructor. Updates the DAG state.
> > -BallLarusEdge* BallLarusDag::addEdge(BallLarusNode* source,
> > - BallLarusNode* target,
> > - unsigned duplicateCount) {
> > - BallLarusEdge* newEdge = createEdge(source, target, duplicateCount);
> > - _edges.push_back(newEdge);
> > - source->addSuccEdge(newEdge);
> > - target->addPredEdge(newEdge);
> > - return(newEdge);
> > -}
> > -
> > -// Adds a backedge with its phony edges. Updates the DAG state.
> > -void BallLarusDag::addBackedge(BallLarusNode* source, BallLarusNode*
> target,
> > - unsigned duplicateCount) {
> > - BallLarusEdge* childEdge = addEdge(source, target, duplicateCount);
> > - childEdge->setType(BallLarusEdge::BACKEDGE);
> > -
> > - childEdge->setPhonyRoot(addEdge(getRoot(), target,0));
> > - childEdge->setPhonyExit(addEdge(source, getExit(),0));
> > -
> > - childEdge->getPhonyRoot()->setRealEdge(childEdge);
> > - childEdge->getPhonyRoot()->setType(BallLarusEdge::BACKEDGE_PHONY);
> > -
> > - childEdge->getPhonyExit()->setRealEdge(childEdge);
> > - childEdge->getPhonyExit()->setType(BallLarusEdge::BACKEDGE_PHONY);
> > - _backEdges.push_back(childEdge);
> > -}
> >
> > Removed: llvm/trunk/lib/Analysis/PathProfileInfo.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/PathProfileInfo.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/PathProfileInfo.cpp (original)
> > +++ llvm/trunk/lib/Analysis/PathProfileInfo.cpp (removed)
> > @@ -1,433 +0,0 @@
> > -//===- PathProfileInfo.cpp ------------------------------------*- C++
> -*---===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file defines the interface used by optimizers to load path
> profiles,
> > -// and provides a loader pass which reads a path profile file.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "path-profile-info"
> > -
> > -#include "llvm/Analysis/PathProfileInfo.h"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/Analysis/ProfileInfoTypes.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <cstdio>
> > -
> > -using namespace llvm;
> > -
> > -// command line option for loading path profiles
> > -static cl::opt<std::string>
> > -PathProfileInfoFilename("path-profile-loader-file",
> cl::init("llvmprof.out"),
> > - cl::value_desc("filename"),
> > - cl::desc("Path profile file loaded by -path-profile-loader"),
> cl::Hidden);
> > -
> > -namespace {
> > - class PathProfileLoaderPass : public ModulePass, public
> PathProfileInfo {
> > - public:
> > - PathProfileLoaderPass() : ModulePass(ID) { }
> > - ~PathProfileLoaderPass();
> > -
> > - // this pass doesn't change anything (only loads information)
> > - virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > - AU.setPreservesAll();
> > - }
> > -
> > - // the full name of the loader pass
> > - virtual const char* getPassName() const {
> > - return "Path Profiling Information Loader";
> > - }
> > -
> > - // required since this pass implements multiple inheritance
> > - virtual void *getAdjustedAnalysisPointer(AnalysisID PI)
> {
> > - if (PI == &PathProfileInfo::ID)
> > - return (PathProfileInfo*)this;
> > - return this;
> > - }
> > -
> > - // entry point to run the pass
> > - bool runOnModule(Module &M);
> > -
> > - // pass identification
> > - static char ID;
> > -
> > - private:
> > - // make a reference table to refer to function by number
> > - void buildFunctionRefs(Module &M);
> > -
> > - // process argument info of a program from the input file
> > - void handleArgumentInfo();
> > -
> > - // process path number information from the input file
> > - void handlePathInfo();
> > -
> > - // array of references to the functions in the module
> > - std::vector<Function*> _functions;
> > -
> > - // path profile file handle
> > - FILE* _file;
> > -
> > - // path profile file name
> > - std::string _filename;
> > - };
> > -}
> > -
> > -// register PathLoader
> > -char PathProfileLoaderPass::ID = 0;
> > -
> > -INITIALIZE_ANALYSIS_GROUP(PathProfileInfo, "Path Profile Information",
> > - NoPathProfileInfo)
> > -INITIALIZE_AG_PASS(PathProfileLoaderPass, PathProfileInfo,
> > - "path-profile-loader",
> > - "Load path profile information from file",
> > - false, true, false)
> > -
> > -char &llvm::PathProfileLoaderPassID = PathProfileLoaderPass::ID;
> > -
> > -// link PathLoader as a pass, and make it available as an optimisation
> > -ModulePass *llvm::createPathProfileLoaderPass() {
> > - return new PathProfileLoaderPass;
> > -}
> > -
> > -//
> ----------------------------------------------------------------------------
> > -// PathEdge implementation
> > -//
> > -ProfilePathEdge::ProfilePathEdge (BasicBlock* source, BasicBlock*
> target,
> > - unsigned duplicateNumber)
> > - : _source(source), _target(target), _duplicateNumber(duplicateNumber)
> {}
> > -
> > -//
> ----------------------------------------------------------------------------
> > -// Path implementation
> > -//
> > -
> > -ProfilePath::ProfilePath (unsigned int number, unsigned int count,
> > - double countStdDev, PathProfileInfo* ppi)
> > - : _number(number) , _count(count), _countStdDev(countStdDev),
> _ppi(ppi) {}
> > -
> > -double ProfilePath::getFrequency() const {
> > - return 100 * double(_count) /
> > - double(_ppi->_functionPathCounts[_ppi->_currentFunction]);
> > -}
> > -
> > -static BallLarusEdge* getNextEdge (BallLarusNode* node,
> > - unsigned int pathNumber) {
> > - BallLarusEdge* best = 0;
> > -
> > - for( BLEdgeIterator next = node->succBegin(),
> > - end = node->succEnd(); next != end; next++ ) {
> > - if( (*next)->getType() != BallLarusEdge::BACKEDGE && // no backedges
> > - (*next)->getType() != BallLarusEdge::SPLITEDGE && // no split
> edges
> > - (*next)->getWeight() <= pathNumber && // weight must be <=
> pathNumber
> > - (!best || (best->getWeight() < (*next)->getWeight())) ) // best
> one?
> > - best = *next;
> > - }
> > -
> > - return best;
> > -}
> > -
> > -ProfilePathEdgeVector* ProfilePath::getPathEdges() const {
> > - BallLarusNode* currentNode = _ppi->_currentDag->getRoot ();
> > - unsigned int increment = _number;
> > - ProfilePathEdgeVector* pev = new ProfilePathEdgeVector;
> > -
> > - while (currentNode != _ppi->_currentDag->getExit()) {
> > - BallLarusEdge* next = getNextEdge(currentNode, increment);
> > -
> > - increment -= next->getWeight();
> > -
> > - if( next->getType() != BallLarusEdge::BACKEDGE_PHONY &&
> > - next->getType() != BallLarusEdge::SPLITEDGE_PHONY &&
> > - next->getTarget() != _ppi->_currentDag->getExit() )
> > - pev->push_back(ProfilePathEdge(
> > - next->getSource()->getBlock(),
> > - next->getTarget()->getBlock(),
> > - next->getDuplicateNumber()));
> > -
> > - if( next->getType() == BallLarusEdge::BACKEDGE_PHONY &&
> > - next->getTarget() == _ppi->_currentDag->getExit() )
> > - pev->push_back(ProfilePathEdge(
> > - next->getRealEdge()->getSource()->getBlock(),
> > - next->getRealEdge()->getTarget()->getBlock(),
> > - next->getDuplicateNumber()));
> > -
> > - if( next->getType() == BallLarusEdge::SPLITEDGE_PHONY &&
> > - next->getSource() == _ppi->_currentDag->getRoot() )
> > - pev->push_back(ProfilePathEdge(
> > - next->getRealEdge()->getSource()->getBlock(),
> > - next->getRealEdge()->getTarget()->getBlock(),
> > - next->getDuplicateNumber()));
> > -
> > - // set the new node
> > - currentNode = next->getTarget();
> > - }
> > -
> > - return pev;
> > -}
> > -
> > -ProfilePathBlockVector* ProfilePath::getPathBlocks() const {
> > - BallLarusNode* currentNode = _ppi->_currentDag->getRoot ();
> > - unsigned int increment = _number;
> > - ProfilePathBlockVector* pbv = new ProfilePathBlockVector;
> > -
> > - while (currentNode != _ppi->_currentDag->getExit()) {
> > - BallLarusEdge* next = getNextEdge(currentNode, increment);
> > - increment -= next->getWeight();
> > -
> > - // add block to the block list if it is a real edge
> > - if( next->getType() == BallLarusEdge::NORMAL)
> > - pbv->push_back (currentNode->getBlock());
> > - // make the back edge the last edge since we are at the end
> > - else if( next->getTarget() == _ppi->_currentDag->getExit() ) {
> > - pbv->push_back (currentNode->getBlock());
> > - pbv->push_back (next->getRealEdge()->getTarget()->getBlock());
> > - }
> > -
> > - // set the new node
> > - currentNode = next->getTarget();
> > - }
> > -
> > - return pbv;
> > -}
> > -
> > -BasicBlock* ProfilePath::getFirstBlockInPath() const {
> > - BallLarusNode* root = _ppi->_currentDag->getRoot();
> > - BallLarusEdge* edge = getNextEdge(root, _number);
> > -
> > - if( edge && (edge->getType() == BallLarusEdge::BACKEDGE_PHONY ||
> > - edge->getType() == BallLarusEdge::SPLITEDGE_PHONY) )
> > - return edge->getTarget()->getBlock();
> > -
> > - return root->getBlock();
> > -}
> > -
> > -//
> ----------------------------------------------------------------------------
> > -// PathProfileInfo implementation
> > -//
> > -
> > -// Pass identification
> > -char llvm::PathProfileInfo::ID = 0;
> > -
> > -PathProfileInfo::PathProfileInfo () : _currentDag(0) ,
> _currentFunction(0) {
> > -}
> > -
> > -PathProfileInfo::~PathProfileInfo() {
> > - if (_currentDag)
> > - delete _currentDag;
> > -}
> > -
> > -// set the function for which paths are currently begin processed
> > -void PathProfileInfo::setCurrentFunction(Function* F) {
> > - // Make sure it exists
> > - if (!F) return;
> > -
> > - if (_currentDag)
> > - delete _currentDag;
> > -
> > - _currentFunction = F;
> > - _currentDag = new BallLarusDag(*F);
> > - _currentDag->init();
> > - _currentDag->calculatePathNumbers();
> > -}
> > -
> > -// get the function for which paths are currently being processed
> > -Function* PathProfileInfo::getCurrentFunction() const {
> > - return _currentFunction;
> > -}
> > -
> > -// get the entry block of the function
> > -BasicBlock* PathProfileInfo::getCurrentFunctionEntry() {
> > - return _currentDag->getRoot()->getBlock();
> > -}
> > -
> > -// return the path based on its number
> > -ProfilePath* PathProfileInfo::getPath(unsigned int number) {
> > - return _functionPaths[_currentFunction][number];
> > -}
> > -
> > -// return the number of paths which a function may potentially execute
> > -unsigned int PathProfileInfo::getPotentialPathCount() {
> > - return _currentDag ? _currentDag->getNumberOfPaths() : 0;
> > -}
> > -
> > -// return an iterator for the beginning of a functions executed paths
> > -ProfilePathIterator PathProfileInfo::pathBegin() {
> > - return _functionPaths[_currentFunction].begin();
> > -}
> > -
> > -// return an iterator for the end of a functions executed paths
> > -ProfilePathIterator PathProfileInfo::pathEnd() {
> > - return _functionPaths[_currentFunction].end();
> > -}
> > -
> > -// returns the total number of paths run in the function
> > -unsigned int PathProfileInfo::pathsRun() {
> > - return _currentFunction ? _functionPaths[_currentFunction].size() : 0;
> > -}
> > -
> > -//
> ----------------------------------------------------------------------------
> > -// PathLoader implementation
> > -//
> > -
> > -// remove all generated paths
> > -PathProfileLoaderPass::~PathProfileLoaderPass() {
> > - for( FunctionPathIterator funcNext = _functionPaths.begin(),
> > - funcEnd = _functionPaths.end(); funcNext != funcEnd;
> funcNext++)
> > - for( ProfilePathIterator pathNext = funcNext->second.begin(),
> > - pathEnd = funcNext->second.end(); pathNext != pathEnd;
> pathNext++)
> > - delete pathNext->second;
> > -}
> > -
> > -// entry point of the pass; this loads and parses a file
> > -bool PathProfileLoaderPass::runOnModule(Module &M) {
> > - // get the filename and setup the module's function references
> > - _filename = PathProfileInfoFilename;
> > - buildFunctionRefs (M);
> > -
> > - if (!(_file = fopen(_filename.c_str(), "rb"))) {
> > - errs () << "error: input '" << _filename << "' file does not
> exist.\n";
> > - return false;
> > - }
> > -
> > - ProfilingType profType;
> > -
> > - while( fread(&profType, sizeof(ProfilingType), 1, _file) ) {
> > - switch (profType) {
> > - case ArgumentInfo:
> > - handleArgumentInfo ();
> > - break;
> > - case PathInfo:
> > - handlePathInfo ();
> > - break;
> > - default:
> > - errs () << "error: bad path profiling file syntax, " << profType
> << "\n";
> > - fclose (_file);
> > - return false;
> > - }
> > - }
> > -
> > - fclose (_file);
> > -
> > - return true;
> > -}
> > -
> > -// create a reference table for functions defined in the path profile
> file
> > -void PathProfileLoaderPass::buildFunctionRefs (Module &M) {
> > - _functions.push_back(0); // make the 0 index a null pointer
> > -
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; F++) {
> > - if (F->isDeclaration())
> > - continue;
> > - _functions.push_back(F);
> > - }
> > -}
> > -
> > -// handle command like argument infor in the output file
> > -void PathProfileLoaderPass::handleArgumentInfo() {
> > - // get the argument list's length
> > - unsigned savedArgsLength;
> > - if( fread(&savedArgsLength, sizeof(unsigned), 1, _file) != 1 ) {
> > - errs() << "warning: argument info header/data mismatch\n";
> > - return;
> > - }
> > -
> > - // allocate a buffer, and get the arguments
> > - char* args = new char[savedArgsLength+1];
> > - if( fread(args, 1, savedArgsLength, _file) != savedArgsLength )
> > - errs() << "warning: argument info header/data mismatch\n";
> > -
> > - args[savedArgsLength] = '\0';
> > - argList = std::string(args);
> > - delete [] args; // cleanup dynamic string
> > -
> > - // byte alignment
> > - if (savedArgsLength & 3)
> > - fseek(_file, 4-(savedArgsLength&3), SEEK_CUR);
> > -}
> > -
> > -// Handle path profile information in the output file
> > -void PathProfileLoaderPass::handlePathInfo () {
> > - // get the number of functions in this profile
> > - unsigned functionCount;
> > - if( fread(&functionCount, sizeof(functionCount), 1, _file) != 1 ) {
> > - errs() << "warning: path info header/data mismatch\n";
> > - return;
> > - }
> > -
> > - // gather path information for each function
> > - for (unsigned i = 0; i < functionCount; i++) {
> > - PathProfileHeader pathHeader;
> > - if( fread(&pathHeader, sizeof(pathHeader), 1, _file) != 1 ) {
> > - errs() << "warning: bad header for path function info\n";
> > - break;
> > - }
> > -
> > - Function* f = _functions[pathHeader.fnNumber];
> > -
> > - // dynamically allocate a table to store path numbers
> > - PathProfileTableEntry* pathTable =
> > - new PathProfileTableEntry[pathHeader.numEntries];
> > -
> > - if( fread(pathTable, sizeof(PathProfileTableEntry),
> > - pathHeader.numEntries, _file) != pathHeader.numEntries) {
> > - delete [] pathTable;
> > - errs() << "warning: path function info header/data mismatch\n";
> > - return;
> > - }
> > -
> > - // Build a new path for the current function
> > - unsigned int totalPaths = 0;
> > - for (unsigned int j = 0; j < pathHeader.numEntries; j++) {
> > - totalPaths += pathTable[j].pathCounter;
> > - _functionPaths[f][pathTable[j].pathNumber]
> > - = new ProfilePath(pathTable[j].pathNumber,
> pathTable[j].pathCounter,
> > - 0, this);
> > - }
> > -
> > - _functionPathCounts[f] = totalPaths;
> > -
> > - delete [] pathTable;
> > - }
> > -}
> > -
> >
> -//===----------------------------------------------------------------------===//
> > -// NoProfile PathProfileInfo implementation
> > -//
> > -
> > -namespace {
> > - struct NoPathProfileInfo : public ImmutablePass, public
> PathProfileInfo {
> > - static char ID; // Class identification, replacement for typeinfo
> > - NoPathProfileInfo() : ImmutablePass(ID) {
> > - initializeNoPathProfileInfoPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > - /// getAdjustedAnalysisPointer - This method is used when a pass
> implements
> > - /// an analysis interface through multiple inheritance. If needed,
> it
> > - /// should override this to adjust the this pointer as needed for
> the
> > - /// specified pass info.
> > - virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
> > - if (PI == &PathProfileInfo::ID)
> > - return (PathProfileInfo*)this;
> > - return this;
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "NoPathProfileInfo";
> > - }
> > - };
> > -} // End of anonymous namespace
> > -
> > -char NoPathProfileInfo::ID = 0;
> > -// Register this pass...
> > -INITIALIZE_AG_PASS(NoPathProfileInfo, PathProfileInfo,
> "no-path-profile",
> > - "No Path Profile Information", false, true, true)
> > -
> > -ImmutablePass *llvm::createNoPathProfileInfoPass() { return new
> NoPathProfileInfo(); }
> >
> > Removed: llvm/trunk/lib/Analysis/PathProfileVerifier.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/PathProfileVerifier.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/PathProfileVerifier.cpp (original)
> > +++ llvm/trunk/lib/Analysis/PathProfileVerifier.cpp (removed)
> > @@ -1,205 +0,0 @@
> > -//===- PathProfileVerifier.cpp --------------------------------*- C++
> -*---===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This verifier derives an edge profile file from current path profile
> > -// information
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "path-profile-verifier"
> > -
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/Analysis/PathProfileInfo.h"
> > -#include "llvm/Analysis/ProfileInfoTypes.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <stdio.h>
> > -
> > -using namespace llvm;
> > -
> > -namespace {
> > - class PathProfileVerifier : public ModulePass {
> > - private:
> > - bool runOnModule(Module &M);
> > -
> > - public:
> > - static char ID; // Pass identification, replacement for typeid
> > - PathProfileVerifier() : ModulePass(ID) {
> > -
> initializePathProfileVerifierPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > -
> > - virtual const char *getPassName() const {
> > - return "Path Profiler Verifier";
> > - }
> > -
> > - // The verifier requires the path profile and edge profile.
> > - virtual void getAnalysisUsage(AnalysisUsage& AU) const;
> > - };
> > -}
> > -
> > -static cl::opt<std::string>
> > -EdgeProfileFilename("path-profile-verifier-file",
> > - cl::init("edgefrompath.llvmprof.out"),
> > - cl::value_desc("filename"),
> > - cl::desc("Edge profile file generated by -path-profile-verifier"),
> > - cl::Hidden);
> > -
> > -char PathProfileVerifier::ID = 0;
> > -INITIALIZE_PASS(PathProfileVerifier, "path-profile-verifier",
> > - "Compare the path profile derived edge profile against
> the "
> > - "edge profile.", true, true)
> > -
> > -ModulePass *llvm::createPathProfileVerifierPass() {
> > - return new PathProfileVerifier();
> > -}
> > -
> > -// The verifier requires the path profile and edge profile.
> > -void PathProfileVerifier::getAnalysisUsage(AnalysisUsage& AU) const {
> > - AU.addRequired<PathProfileInfo>();
> > - AU.addPreserved<PathProfileInfo>();
> > -}
> > -
> > -typedef std::map<unsigned, unsigned> DuplicateToIndexMap;
> > -typedef std::map<BasicBlock*,DuplicateToIndexMap> BlockToDuplicateMap;
> > -typedef std::map<BasicBlock*,BlockToDuplicateMap> NestedBlockToIndexMap;
> > -
> > -// the verifier iterates through each path to gather the total
> > -// number of edge frequencies
> > -bool PathProfileVerifier::runOnModule (Module &M) {
> > - PathProfileInfo& pathProfileInfo = getAnalysis<PathProfileInfo>();
> > -
> > - // setup a data structure to map path edges which index an
> > - // array of edge counters
> > - NestedBlockToIndexMap arrayMap;
> > - unsigned i = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > -
> > - arrayMap[(BasicBlock*)0][F->begin()][0] = i++;
> > -
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - TerminatorInst *TI = BB->getTerminator();
> > -
> > - unsigned duplicate = 0;
> > - BasicBlock* prev = 0;
> > - for (unsigned s = 0, e = TI->getNumSuccessors(); s != e;
> > - prev = TI->getSuccessor(s), ++s) {
> > - if (prev == TI->getSuccessor(s))
> > - duplicate++;
> > - else duplicate = 0;
> > -
> > - arrayMap[BB][TI->getSuccessor(s)][duplicate] = i++;
> > - }
> > - }
> > - }
> > -
> > - std::vector<unsigned> edgeArray(i);
> > -
> > - // iterate through each path and increment the edge counters as needed
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > -
> > - pathProfileInfo.setCurrentFunction(F);
> > -
> > - DEBUG(dbgs() << "function '" << F->getName() << "' ran "
> > - << pathProfileInfo.pathsRun()
> > - << "/" << pathProfileInfo.getPotentialPathCount()
> > - << " potential paths\n");
> > -
> > - for( ProfilePathIterator nextPath = pathProfileInfo.pathBegin(),
> > - endPath = pathProfileInfo.pathEnd();
> > - nextPath != endPath; nextPath++ ) {
> > - ProfilePath* currentPath = nextPath->second;
> > -
> > - ProfilePathEdgeVector* pev = currentPath->getPathEdges();
> > - DEBUG(dbgs () << "path #" << currentPath->getNumber() << ": "
> > - << currentPath->getCount() << "\n");
> > - // setup the entry edge (normally path profiling doesn't care
> about this)
> > - if (currentPath->getFirstBlockInPath() == &F->getEntryBlock())
> > -
> edgeArray[arrayMap[(BasicBlock*)0][currentPath->getFirstBlockInPath()][0]]
> > - += currentPath->getCount();
> > -
> > - for( ProfilePathEdgeIterator nextEdge = pev->begin(),
> > - endEdge = pev->end(); nextEdge != endEdge; nextEdge++ ) {
> > - if (nextEdge != pev->begin())
> > - DEBUG(dbgs() << " :: ");
> > -
> > - BasicBlock* source = nextEdge->getSource();
> > - BasicBlock* target = nextEdge->getTarget();
> > - unsigned duplicateNumber = nextEdge->getDuplicateNumber();
> > - DEBUG(dbgs() << source->getName() << " --{" << duplicateNumber
> > - << "}--> " << target->getName());
> > -
> > - // Ensure all the referenced edges exist
> > - // TODO: make this a separate function
> > - if( !arrayMap.count(source) ) {
> > - errs() << " error [" << F->getName() << "()]: source '"
> > - << source->getName()
> > - << "' does not exist in the array map.\n";
> > - } else if( !arrayMap[source].count(target) ) {
> > - errs() << " error [" << F->getName() << "()]: target '"
> > - << target->getName()
> > - << "' does not exist in the array map.\n";
> > - } else if( !arrayMap[source][target].count(duplicateNumber) ) {
> > - errs() << " error [" << F->getName() << "()]: edge "
> > - << source->getName() << " -> " << target->getName()
> > - << " duplicate number " << duplicateNumber
> > - << " does not exist in the array map.\n";
> > - } else {
> > - edgeArray[arrayMap[source][target][duplicateNumber]]
> > - += currentPath->getCount();
> > - }
> > - }
> > -
> > - DEBUG(errs() << "\n");
> > -
> > - delete pev;
> > - }
> > - }
> > -
> > - std::string filename = EdgeProfileFilename;
> > -
> > - // Open a handle to the file
> > - FILE* edgeFile = fopen(filename.c_str(),"wb");
> > -
> > - if (!edgeFile) {
> > - errs() << "error: unable to open file '" << filename << "' for
> output.\n";
> > - return false;
> > - }
> > -
> > - errs() << "Generating edge profile '" << filename << "' ...\n";
> > -
> > - // write argument info
> > - unsigned type = ArgumentInfo;
> > - unsigned num = pathProfileInfo.argList.size();
> > - int zeros = 0;
> > -
> > - fwrite(&type,sizeof(unsigned),1,edgeFile);
> > - fwrite(&num,sizeof(unsigned),1,edgeFile);
> > - fwrite(pathProfileInfo.argList.c_str(),1,num,edgeFile);
> > - if (num&3)
> > - fwrite(&zeros, 1, 4-(num&3), edgeFile);
> > -
> > - type = EdgeInfo;
> > - num = edgeArray.size();
> > - fwrite(&type,sizeof(unsigned),1,edgeFile);
> > - fwrite(&num,sizeof(unsigned),1,edgeFile);
> > -
> > - // write each edge to the file
> > - for( std::vector<unsigned>::iterator s = edgeArray.begin(),
> > - e = edgeArray.end(); s != e; s++)
> > - fwrite(&*s, sizeof (unsigned), 1, edgeFile);
> > -
> > - fclose (edgeFile);
> > -
> > - return true;
> > -}
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileDataLoader.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileDataLoader.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileDataLoader.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileDataLoader.cpp (removed)
> > @@ -1,155 +0,0 @@
> > -//===- ProfileDataLoader.cpp - Load profile information from disk
> ---------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// The ProfileDataLoader class is used to load raw profiling data from
> the dump
> > -// file.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#include "llvm/Analysis/ProfileDataLoader.h"
> > -#include "llvm/ADT/ArrayRef.h"
> > -#include "llvm/ADT/OwningPtr.h"
> > -#include "llvm/Analysis/ProfileDataTypes.h"
> > -#include "llvm/IR/InstrTypes.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include "llvm/Support/system_error.h"
> > -#include <cstdio>
> > -#include <cstdlib>
> > -using namespace llvm;
> > -
> > -raw_ostream &llvm::operator<<(raw_ostream &O, std::pair<const
> BasicBlock *,
> > - const
> BasicBlock *> E) {
> > - O << "(";
> > -
> > - if (E.first)
> > - O << E.first->getName();
> > - else
> > - O << "0";
> > -
> > - O << ",";
> > -
> > - if (E.second)
> > - O << E.second->getName();
> > - else
> > - O << "0";
> > -
> > - return O << ")";
> > -}
> > -
> > -/// AddCounts - Add 'A' and 'B', accounting for the fact that the value
> of one
> > -/// (or both) may not be defined.
> > -static unsigned AddCounts(unsigned A, unsigned B) {
> > - // If either value is undefined, use the other.
> > - // Undefined + undefined = undefined.
> > - if (A == ProfileDataLoader::Uncounted) return B;
> > - if (B == ProfileDataLoader::Uncounted) return A;
> > -
> > - return A + B;
> > -}
> > -
> > -/// ReadProfilingData - Load 'NumEntries' items of type 'T' from file
> 'F'
> > -template <typename T>
> > -static void ReadProfilingData(const char *ToolName, FILE *F,
> > - T *Data, size_t NumEntries) {
> > - // Read in the block of data...
> > - if (fread(Data, sizeof(T), NumEntries, F) != NumEntries)
> > - report_fatal_error(Twine(ToolName) + ": Profiling data truncated");
> > -}
> > -
> > -/// ReadProfilingNumEntries - Read how many entries are in this
> profiling data
> > -/// packet.
> > -static unsigned ReadProfilingNumEntries(const char *ToolName, FILE *F,
> > - bool ShouldByteSwap) {
> > - unsigned Entry;
> > - ReadProfilingData<unsigned>(ToolName, F, &Entry, 1);
> > - return ShouldByteSwap ? ByteSwap_32(Entry) : Entry;
> > -}
> > -
> > -/// ReadProfilingBlock - Read the number of entries in the next
> profiling data
> > -/// packet and then accumulate the entries into 'Data'.
> > -static void ReadProfilingBlock(const char *ToolName, FILE *F,
> > - bool ShouldByteSwap,
> > - SmallVectorImpl<unsigned> &Data) {
> > - // Read the number of entries...
> > - unsigned NumEntries = ReadProfilingNumEntries(ToolName, F,
> ShouldByteSwap);
> > -
> > - // Read in the data.
> > - SmallVector<unsigned, 8> TempSpace(NumEntries);
> > - ReadProfilingData<unsigned>(ToolName, F, TempSpace.data(),
> NumEntries);
> > -
> > - // Make sure we have enough space ...
> > - if (Data.size() < NumEntries)
> > - Data.resize(NumEntries, ProfileDataLoader::Uncounted);
> > -
> > - // Accumulate the data we just read into the existing data.
> > - for (unsigned i = 0; i < NumEntries; ++i) {
> > - unsigned Entry = ShouldByteSwap ? ByteSwap_32(TempSpace[i]) :
> TempSpace[i];
> > - Data[i] = AddCounts(Entry, Data[i]);
> > - }
> > -}
> > -
> > -/// ReadProfilingArgBlock - Read the command line arguments that the
> progam was
> > -/// run with when the current profiling data packet(s) were generated.
> > -static void ReadProfilingArgBlock(const char *ToolName, FILE *F,
> > - bool ShouldByteSwap,
> > - SmallVectorImpl<std::string>
> &CommandLines) {
> > - // Read the number of bytes ...
> > - unsigned ArgLength = ReadProfilingNumEntries(ToolName, F,
> ShouldByteSwap);
> > -
> > - // Read in the arguments (if there are any to read). Round up the
> length to
> > - // the nearest 4-byte multiple.
> > - SmallVector<char, 8> Args(ArgLength+4);
> > - if (ArgLength)
> > - ReadProfilingData<char>(ToolName, F, Args.data(), (ArgLength+3) &
> ~3);
> > -
> > - // Store the arguments.
> > - CommandLines.push_back(std::string(&Args[0], &Args[ArgLength]));
> > -}
> > -
> > -const unsigned ProfileDataLoader::Uncounted = ~0U;
> > -
> > -/// ProfileDataLoader ctor - Read the specified profiling data file,
> reporting
> > -/// a fatal error if the file is invalid or broken.
> > -ProfileDataLoader::ProfileDataLoader(const char *ToolName,
> > - const std::string &Filename)
> > - : Filename(Filename) {
> > - FILE *F = fopen(Filename.c_str(), "rb");
> > - if (F == 0)
> > - report_fatal_error(Twine(ToolName) + ": Error opening '" +
> > - Filename + "': ");
> > -
> > - // Keep reading packets until we run out of them.
> > - unsigned PacketType;
> > - while (fread(&PacketType, sizeof(unsigned), 1, F) == 1) {
> > - // If the low eight bits of the packet are zero, we must be dealing
> with an
> > - // endianness mismatch. Byteswap all words read from the profiling
> > - // information. This can happen when the compiler host and target
> have
> > - // different endianness.
> > - bool ShouldByteSwap = (char)PacketType == 0;
> > - PacketType = ShouldByteSwap ? ByteSwap_32(PacketType) : PacketType;
> > -
> > - switch (PacketType) {
> > - case ArgumentInfo:
> > - ReadProfilingArgBlock(ToolName, F, ShouldByteSwap,
> CommandLines);
> > - break;
> > -
> > - case EdgeInfo:
> > - ReadProfilingBlock(ToolName, F, ShouldByteSwap, EdgeCounts);
> > - break;
> > -
> > - default:
> > - report_fatal_error(std::string(ToolName)
> > - + ": Unknown profiling packet type");
> > - break;
> > - }
> > - }
> > -
> > - fclose(F);
> > -}
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileDataLoaderPass.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileDataLoaderPass.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileDataLoaderPass.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileDataLoaderPass.cpp (removed)
> > @@ -1,188 +0,0 @@
> > -//===- ProfileDataLoaderPass.cpp - Set branch weight metadata from prof
> ---===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This pass loads profiling data from a dump file and sets branch
> weight
> > -// metadata.
> > -//
> > -// TODO: Replace all "profile-metadata-loader" strings with
> "profile-loader"
> > -// once ProfileInfo etc. has been removed.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "profile-metadata-loader"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/ADT/ArrayRef.h"
> > -#include "llvm/ADT/Statistic.h"
> > -#include "llvm/Analysis/ProfileDataLoader.h"
> > -#include "llvm/IR/BasicBlock.h"
> > -#include "llvm/IR/InstrTypes.h"
> > -#include "llvm/IR/LLVMContext.h"
> > -#include "llvm/IR/MDBuilder.h"
> > -#include "llvm/IR/Metadata.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Format.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -using namespace llvm;
> > -
> > -STATISTIC(NumEdgesRead, "The # of edges read.");
> > -STATISTIC(NumTermsAnnotated, "The # of terminator instructions
> annotated.");
> > -
> > -static cl::opt<std::string>
> > -ProfileMetadataFilename("profile-file", cl::init("llvmprof.out"),
> > - cl::value_desc("filename"),
> > - cl::desc("Profile file loaded by
> -profile-metadata-loader"));
> > -
> > -namespace {
> > - /// This pass loads profiling data from a dump file and sets branch
> weight
> > - /// metadata.
> > - class ProfileMetadataLoaderPass : public ModulePass {
> > - std::string Filename;
> > - public:
> > - static char ID; // Class identification, replacement for typeinfo
> > - explicit ProfileMetadataLoaderPass(const std::string &filename = "")
> > - : ModulePass(ID), Filename(filename) {
> > -
> initializeProfileMetadataLoaderPassPass(*PassRegistry::getPassRegistry());
> > - if (filename.empty()) Filename = ProfileMetadataFilename;
> > - }
> > -
> > - virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > - AU.setPreservesAll();
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "Profile loader";
> > - }
> > -
> > - virtual void readEdge(unsigned, ProfileData&, ProfileData::Edge,
> > - ArrayRef<unsigned>);
> > - virtual unsigned matchEdges(Module&, ProfileData&,
> ArrayRef<unsigned>);
> > - virtual void setBranchWeightMetadata(Module&, ProfileData&);
> > -
> > - virtual bool runOnModule(Module &M);
> > - };
> > -} // End of anonymous namespace
> > -
> > -char ProfileMetadataLoaderPass::ID = 0;
> > -INITIALIZE_PASS_BEGIN(ProfileMetadataLoaderPass,
> "profile-metadata-loader",
> > - "Load profile information from llvmprof.out", false, true)
> > -INITIALIZE_PASS_END(ProfileMetadataLoaderPass,
> "profile-metadata-loader",
> > - "Load profile information from llvmprof.out", false, true)
> > -
> > -char &llvm::ProfileMetadataLoaderPassID = ProfileMetadataLoaderPass::ID;
> > -
> > -/// createProfileMetadataLoaderPass - This function returns a Pass that
> loads
> > -/// the profiling information for the module from the specified
> filename,
> > -/// making it available to the optimizers.
> > -ModulePass *llvm::createProfileMetadataLoaderPass() {
> > - return new ProfileMetadataLoaderPass();
> > -}
> > -ModulePass *llvm::createProfileMetadataLoaderPass(const std::string
> &Filename) {
> > - return new ProfileMetadataLoaderPass(Filename);
> > -}
> > -
> > -/// readEdge - Take the value from a profile counter and assign it to
> an edge.
> > -void ProfileMetadataLoaderPass::readEdge(unsigned ReadCount,
> > - ProfileData &PB,
> ProfileData::Edge e,
> > - ArrayRef<unsigned> Counters) {
> > - if (ReadCount >= Counters.size()) return;
> > -
> > - unsigned weight = Counters[ReadCount];
> > - assert(weight != ProfileDataLoader::Uncounted);
> > - PB.addEdgeWeight(e, weight);
> > -
> > - DEBUG(dbgs() << "-- Read Edge Counter for " << e
> > - << " (# "<< (ReadCount) << "): "
> > - << PB.getEdgeWeight(e) << "\n");
> > -}
> > -
> > -/// matchEdges - Link every profile counter with an edge.
> > -unsigned ProfileMetadataLoaderPass::matchEdges(Module &M, ProfileData
> &PB,
> > - ArrayRef<unsigned>
> Counters) {
> > - if (Counters.size() == 0) return 0;
> > -
> > - unsigned ReadCount = 0;
> > -
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - DEBUG(dbgs() << "Loading edges in '" << F->getName() << "'\n");
> > - readEdge(ReadCount++, PB, PB.getEdge(0, &F->getEntryBlock()),
> Counters);
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - TerminatorInst *TI = BB->getTerminator();
> > - for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
> > - readEdge(ReadCount++, PB, PB.getEdge(BB,TI->getSuccessor(s)),
> > - Counters);
> > - }
> > - }
> > - }
> > -
> > - return ReadCount;
> > -}
> > -
> > -/// setBranchWeightMetadata - Translate the counter values associated
> with each
> > -/// edge into branch weights for each conditional branch (a branch with
> 2 or
> > -/// more desinations).
> > -void ProfileMetadataLoaderPass::setBranchWeightMetadata(Module &M,
> > - ProfileData
> &PB) {
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - DEBUG(dbgs() << "Setting branch metadata in '" << F->getName() <<
> "'\n");
> > -
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - TerminatorInst *TI = BB->getTerminator();
> > - unsigned NumSuccessors = TI->getNumSuccessors();
> > -
> > - // If there is only one successor then we can not set a branch
> > - // probability as the target is certain.
> > - if (NumSuccessors < 2) continue;
> > -
> > - // Load the weights of all edges leading from this terminator.
> > - DEBUG(dbgs() << "-- Terminator with " << NumSuccessors
> > - << " successors:\n");
> > - SmallVector<uint32_t, 4> Weights(NumSuccessors);
> > - for (unsigned s = 0 ; s < NumSuccessors ; ++s) {
> > - ProfileData::Edge edge = PB.getEdge(BB, TI->getSuccessor(s));
> > - Weights[s] = (uint32_t)PB.getEdgeWeight(edge);
> > - DEBUG(dbgs() << "---- Edge '" << edge << "' has weight "
> > - << Weights[s] << "\n");
> > - }
> > -
> > - // Set branch weight metadata. This will set branch
> probabilities of
> > - // 100%/0% if that is true of the dynamic execution.
> > - // BranchProbabilityInfo can account for this when it loads this
> metadata
> > - // (it gives the unexectuted branch a weight of 1 for the
> purposes of
> > - // probability calculations).
> > - MDBuilder MDB(TI->getContext());
> > - MDNode *Node = MDB.createBranchWeights(Weights);
> > - TI->setMetadata(LLVMContext::MD_prof, Node);
> > - NumTermsAnnotated++;
> > - }
> > - }
> > -}
> > -
> > -bool ProfileMetadataLoaderPass::runOnModule(Module &M) {
> > - ProfileDataLoader PDL("profile-data-loader", Filename);
> > - ProfileData PB;
> > -
> > - ArrayRef<unsigned> Counters = PDL.getRawEdgeCounts();
> > -
> > - unsigned ReadCount = matchEdges(M, PB, Counters);
> > -
> > - if (ReadCount != Counters.size()) {
> > - errs() << "WARNING: profile information is inconsistent with "
> > - << "the current program!\n";
> > - }
> > - NumEdgesRead = ReadCount;
> > -
> > - setBranchWeightMetadata(M, PB);
> > -
> > - return ReadCount > 0;
> > -}
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileEstimatorPass.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileEstimatorPass.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileEstimatorPass.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileEstimatorPass.cpp (removed)
> > @@ -1,426 +0,0 @@
> > -//===- ProfileEstimatorPass.cpp - LLVM Pass to estimate profile info
> ------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file implements a concrete implementation of profiling
> information that
> > -// estimates the profiling information in a very crude and
> unimaginative way.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "profile-estimator"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/Analysis/LoopInfo.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Format.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -using namespace llvm;
> > -
> > -static cl::opt<double>
> > -LoopWeight(
> > - "profile-estimator-loop-weight", cl::init(10),
> > - cl::value_desc("loop-weight"),
> > - cl::desc("Number of loop executions used for profile-estimator")
> > -);
> > -
> > -namespace {
> > - class ProfileEstimatorPass : public FunctionPass, public ProfileInfo {
> > - double ExecCount;
> > - LoopInfo *LI;
> > - std::set<BasicBlock*> BBToVisit;
> > - std::map<Loop*,double> LoopExitWeights;
> > - std::map<Edge,double> MinimalWeight;
> > - public:
> > - static char ID; // Class identification, replacement for typeinfo
> > - explicit ProfileEstimatorPass(const double execcount = 0)
> > - : FunctionPass(ID), ExecCount(execcount) {
> > -
> initializeProfileEstimatorPassPass(*PassRegistry::getPassRegistry());
> > - if (execcount == 0) ExecCount = LoopWeight;
> > - }
> > -
> > - virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > - AU.setPreservesAll();
> > - AU.addRequired<LoopInfo>();
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "Profiling information estimator";
> > - }
> > -
> > - /// run - Estimate the profile information from the specified file.
> > - virtual bool runOnFunction(Function &F);
> > -
> > - /// getAdjustedAnalysisPointer - This method is used when a pass
> implements
> > - /// an analysis interface through multiple inheritance. If needed,
> it
> > - /// should override this to adjust the this pointer as needed for
> the
> > - /// specified pass info.
> > - virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
> > - if (PI == &ProfileInfo::ID)
> > - return (ProfileInfo*)this;
> > - return this;
> > - }
> > -
> > - virtual void recurseBasicBlock(BasicBlock *BB);
> > -
> > - void inline printEdgeWeight(Edge);
> > - };
> > -} // End of anonymous namespace
> > -
> > -char ProfileEstimatorPass::ID = 0;
> > -INITIALIZE_AG_PASS_BEGIN(ProfileEstimatorPass, ProfileInfo,
> "profile-estimator",
> > - "Estimate profiling information", false, true, false)
> > -INITIALIZE_PASS_DEPENDENCY(LoopInfo)
> > -INITIALIZE_AG_PASS_END(ProfileEstimatorPass, ProfileInfo,
> "profile-estimator",
> > - "Estimate profiling information", false, true, false)
> > -
> > -namespace llvm {
> > - char &ProfileEstimatorPassID = ProfileEstimatorPass::ID;
> > -
> > - FunctionPass *createProfileEstimatorPass() {
> > - return new ProfileEstimatorPass();
> > - }
> > -
> > - /// createProfileEstimatorPass - This function returns a Pass that
> estimates
> > - /// profiling information using the given loop execution count.
> > - Pass *createProfileEstimatorPass(const unsigned execcount) {
> > - return new ProfileEstimatorPass(execcount);
> > - }
> > -}
> > -
> > -static double ignoreMissing(double w) {
> > - if (w == ProfileInfo::MissingValue) return 0;
> > - return w;
> > -}
> > -
> > -static void inline printEdgeError(ProfileInfo::Edge e, const char *M) {
> > - DEBUG(dbgs() << "-- Edge " << e << " is not calculated, " << M <<
> "\n");
> > -}
> > -
> > -void inline ProfileEstimatorPass::printEdgeWeight(Edge E) {
> > - DEBUG(dbgs() << "-- Weight of Edge " << E << ":"
> > - << format("%20.20g", getEdgeWeight(E)) << "\n");
> > -}
> > -
> > -// recurseBasicBlock() - This calculates the ProfileInfo estimation for
> a
> > -// single block and then recurses into the successors.
> > -// The algorithm preserves the flow condition, meaning that the sum of
> the
> > -// weight of the incoming edges must be equal the block weight which
> must in
> > -// turn be equal to the sume of the weights of the outgoing edges.
> > -// Since the flow of an block is deterimined from the current state of
> the
> > -// flow, once an edge has a flow assigned this flow is never changed
> again,
> > -// otherwise it would be possible to violate the flow condition in
> another
> > -// block.
> > -void ProfileEstimatorPass::recurseBasicBlock(BasicBlock *BB) {
> > -
> > - // Break the recursion if this BasicBlock was already visited.
> > - if (BBToVisit.find(BB) == BBToVisit.end()) return;
> > -
> > - // Read the LoopInfo for this block.
> > - bool BBisHeader = LI->isLoopHeader(BB);
> > - Loop* BBLoop = LI->getLoopFor(BB);
> > -
> > - // To get the block weight, read all incoming edges.
> > - double BBWeight = 0;
> > - std::set<BasicBlock*> ProcessedPreds;
> > - for ( pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
> > - bbi != bbe; ++bbi ) {
> > - // If this block was not considered already, add weight.
> > - Edge edge = getEdge(*bbi,BB);
> > - double w = getEdgeWeight(edge);
> > - if (ProcessedPreds.insert(*bbi).second) {
> > - BBWeight += ignoreMissing(w);
> > - }
> > - // If this block is a loop header and the predecessor is contained
> in this
> > - // loop, thus the edge is a backedge, continue and do not check if
> the
> > - // value is valid.
> > - if (BBisHeader && BBLoop->contains(*bbi)) {
> > - printEdgeError(edge, "but is backedge, continuing");
> > - continue;
> > - }
> > - // If the edges value is missing (and this is no loop header, and
> this is
> > - // no backedge) return, this block is currently non estimatable.
> > - if (w == MissingValue) {
> > - printEdgeError(edge, "returning");
> > - return;
> > - }
> > - }
> > - if (getExecutionCount(BB) != MissingValue) {
> > - BBWeight = getExecutionCount(BB);
> > - }
> > -
> > - // Fetch all necessary information for current block.
> > - SmallVector<Edge, 8> ExitEdges;
> > - SmallVector<Edge, 8> Edges;
> > - if (BBLoop) {
> > - BBLoop->getExitEdges(ExitEdges);
> > - }
> > -
> > - // If this is a loop header, consider the following:
> > - // Exactly the flow that is entering this block, must exit this block
> too. So
> > - // do the following:
> > - // *) get all the exit edges, read the flow that is already leaving
> this
> > - // loop, remember the edges that do not have any flow on them right
> now.
> > - // (The edges that have already flow on them are most likely exiting
> edges of
> > - // other loops, do not touch those flows because the previously
> caclulated
> > - // loopheaders would not be exact anymore.)
> > - // *) In case there is not a single exiting edge left, create one at
> the loop
> > - // latch to prevent the flow from building up in the loop.
> > - // *) Take the flow that is not leaving the loop already and
> distribute it on
> > - // the remaining exiting edges.
> > - // (This ensures that all flow that enters the loop also leaves it.)
> > - // *) Increase the flow into the loop by increasing the weight of
> this block.
> > - // There is at least one incoming backedge that will bring us this
> flow later
> > - // on. (So that the flow condition in this node is valid again.)
> > - if (BBisHeader) {
> > - double incoming = BBWeight;
> > - // Subtract the flow leaving the loop.
> > - std::set<Edge> ProcessedExits;
> > - for (SmallVectorImpl<Edge>::iterator ei = ExitEdges.begin(),
> > - ee = ExitEdges.end(); ei != ee; ++ei) {
> > - if (ProcessedExits.insert(*ei).second) {
> > - double w = getEdgeWeight(*ei);
> > - if (w == MissingValue) {
> > - Edges.push_back(*ei);
> > - // Check if there is a necessary minimal weight, if yes,
> subtract it
> > - // from weight.
> > - if (MinimalWeight.find(*ei) != MinimalWeight.end()) {
> > - incoming -= MinimalWeight[*ei];
> > - DEBUG(dbgs() << "Reserving " <<
> format("%.20g",MinimalWeight[*ei]) << " at " << (*ei) << "\n");
> > - }
> > - } else {
> > - incoming -= w;
> > - }
> > - }
> > - }
> > - // If no exit edges, create one:
> > - if (Edges.size() == 0) {
> > - BasicBlock *Latch = BBLoop->getLoopLatch();
> > - if (Latch) {
> > - Edge edge = getEdge(Latch,0);
> > - EdgeInformation[BB->getParent()][edge] = BBWeight;
> > - printEdgeWeight(edge);
> > - edge = getEdge(Latch, BB);
> > - EdgeInformation[BB->getParent()][edge] = BBWeight * ExecCount;
> > - printEdgeWeight(edge);
> > - }
> > - }
> > -
> > - // Distribute remaining weight to the exting edges. To prevent
> fractions
> > - // from building up and provoking precision problems the weight
> which is to
> > - // be distributed is split and the rounded, the last edge gets a
> somewhat
> > - // bigger value, but we are close enough for an estimation.
> > - double fraction = floor(incoming/Edges.size());
> > - for (SmallVectorImpl<Edge>::iterator ei = Edges.begin(), ee =
> Edges.end();
> > - ei != ee; ++ei) {
> > - double w = 0;
> > - if (ei != (ee-1)) {
> > - w = fraction;
> > - incoming -= fraction;
> > - } else {
> > - w = incoming;
> > - }
> > - EdgeInformation[BB->getParent()][*ei] += w;
> > - // Read necessary minimal weight.
> > - if (MinimalWeight.find(*ei) != MinimalWeight.end()) {
> > - EdgeInformation[BB->getParent()][*ei] += MinimalWeight[*ei];
> > - DEBUG(dbgs() << "Additionally " <<
> format("%.20g",MinimalWeight[*ei]) << " at " << (*ei) << "\n");
> > - }
> > - printEdgeWeight(*ei);
> > -
> > - // Add minimal weight to paths to all exit edges, this is used to
> ensure
> > - // that enough flow is reaching this edges.
> > - Path p;
> > - const BasicBlock *Dest = GetPath(BB, (*ei).first, p,
> GetPathToDest);
> > - while (Dest != BB) {
> > - const BasicBlock *Parent = p.find(Dest)->second;
> > - Edge e = getEdge(Parent, Dest);
> > - if (MinimalWeight.find(e) == MinimalWeight.end()) {
> > - MinimalWeight[e] = 0;
> > - }
> > - MinimalWeight[e] += w;
> > - DEBUG(dbgs() << "Minimal Weight for " << e << ": " <<
> format("%.20g",MinimalWeight[e]) << "\n");
> > - Dest = Parent;
> > - }
> > - }
> > - // Increase flow into the loop.
> > - BBWeight *= (ExecCount+1);
> > - }
> > -
> > - BlockInformation[BB->getParent()][BB] = BBWeight;
> > - // Up until now we considered only the loop exiting edges, now we
> have a
> > - // definite block weight and must distribute this onto the outgoing
> edges.
> > - // Since there may be already flow attached to some of the edges,
> read this
> > - // flow first and remember the edges that have still now flow
> attached.
> > - Edges.clear();
> > - std::set<BasicBlock*> ProcessedSuccs;
> > -
> > - succ_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - // Also check for (BB,0) edges that may already contain some flow.
> (But only
> > - // in case there are no successors.)
> > - if (bbi == bbe) {
> > - Edge edge = getEdge(BB,0);
> > - EdgeInformation[BB->getParent()][edge] = BBWeight;
> > - printEdgeWeight(edge);
> > - }
> > - for ( ; bbi != bbe; ++bbi ) {
> > - if (ProcessedSuccs.insert(*bbi).second) {
> > - Edge edge = getEdge(BB,*bbi);
> > - double w = getEdgeWeight(edge);
> > - if (w != MissingValue) {
> > - BBWeight -= getEdgeWeight(edge);
> > - } else {
> > - Edges.push_back(edge);
> > - // If minimal weight is necessary, reserve weight by
> subtracting weight
> > - // from block weight, this is readded later on.
> > - if (MinimalWeight.find(edge) != MinimalWeight.end()) {
> > - BBWeight -= MinimalWeight[edge];
> > - DEBUG(dbgs() << "Reserving " <<
> format("%.20g",MinimalWeight[edge]) << " at " << edge << "\n");
> > - }
> > - }
> > - }
> > - }
> > -
> > - double fraction = Edges.size() ? floor(BBWeight/Edges.size()) : 0.0;
> > - // Finally we know what flow is still not leaving the block,
> distribute this
> > - // flow onto the empty edges.
> > - for (SmallVectorImpl<Edge>::iterator ei = Edges.begin(), ee =
> Edges.end();
> > - ei != ee; ++ei) {
> > - if (ei != (ee-1)) {
> > - EdgeInformation[BB->getParent()][*ei] += fraction;
> > - BBWeight -= fraction;
> > - } else {
> > - EdgeInformation[BB->getParent()][*ei] += BBWeight;
> > - }
> > - // Readd minial necessary weight.
> > - if (MinimalWeight.find(*ei) != MinimalWeight.end()) {
> > - EdgeInformation[BB->getParent()][*ei] += MinimalWeight[*ei];
> > - DEBUG(dbgs() << "Additionally " <<
> format("%.20g",MinimalWeight[*ei]) << " at " << (*ei) << "\n");
> > - }
> > - printEdgeWeight(*ei);
> > - }
> > -
> > - // This block is visited, mark this before the recursion.
> > - BBToVisit.erase(BB);
> > -
> > - // Recurse into successors.
> > - for (succ_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - bbi != bbe; ++bbi) {
> > - recurseBasicBlock(*bbi);
> > - }
> > -}
> > -
> > -bool ProfileEstimatorPass::runOnFunction(Function &F) {
> > - if (F.isDeclaration()) return false;
> > -
> > - // Fetch LoopInfo and clear ProfileInfo for this function.
> > - LI = &getAnalysis<LoopInfo>();
> > - FunctionInformation.erase(&F);
> > - BlockInformation[&F].clear();
> > - EdgeInformation[&F].clear();
> > - BBToVisit.clear();
> > -
> > - // Mark all blocks as to visit.
> > - for (Function::iterator bi = F.begin(), be = F.end(); bi != be; ++bi)
> > - BBToVisit.insert(bi);
> > -
> > - // Clear Minimal Edges.
> > - MinimalWeight.clear();
> > -
> > - DEBUG(dbgs() << "Working on function " << F.getName() << "\n");
> > -
> > - // Since the entry block is the first one and has no predecessors,
> the edge
> > - // (0,entry) is inserted with the starting weight of 1.
> > - BasicBlock *entry = &F.getEntryBlock();
> > - BlockInformation[&F][entry] = pow(2.0, 32.0);
> > - Edge edge = getEdge(0,entry);
> > - EdgeInformation[&F][edge] = BlockInformation[&F][entry];
> > - printEdgeWeight(edge);
> > -
> > - // Since recurseBasicBlock() maybe returns with a block which was not
> fully
> > - // estimated, use recurseBasicBlock() until everything is calculated.
> > - bool cleanup = false;
> > - recurseBasicBlock(entry);
> > - while (BBToVisit.size() > 0 && !cleanup) {
> > - // Remember number of open blocks, this is later used to check if
> progress
> > - // was made.
> > - unsigned size = BBToVisit.size();
> > -
> > - // Try to calculate all blocks in turn.
> > - for (std::set<BasicBlock*>::iterator bi = BBToVisit.begin(),
> > - be = BBToVisit.end(); bi != be; ++bi) {
> > - recurseBasicBlock(*bi);
> > - // If at least one block was finished, break because iterator may
> be
> > - // invalid.
> > - if (BBToVisit.size() < size) break;
> > - }
> > -
> > - // If there was not a single block resolved, make some assumptions.
> > - if (BBToVisit.size() == size) {
> > - bool found = false;
> > - for (std::set<BasicBlock*>::iterator BBI = BBToVisit.begin(), BBE
> = BBToVisit.end();
> > - (BBI != BBE) && (!found); ++BBI) {
> > - BasicBlock *BB = *BBI;
> > - // Try each predecessor if it can be assumend.
> > - for (pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
> > - (bbi != bbe) && (!found); ++bbi) {
> > - Edge e = getEdge(*bbi,BB);
> > - double w = getEdgeWeight(e);
> > - // Check that edge from predecessor is still free.
> > - if (w == MissingValue) {
> > - // Check if there is a circle from this block to
> predecessor.
> > - Path P;
> > - const BasicBlock *Dest = GetPath(BB, *bbi, P,
> GetPathToDest);
> > - if (Dest != *bbi) {
> > - // If there is no circle, just set edge weight to 0
> > - EdgeInformation[&F][e] = 0;
> > - DEBUG(dbgs() << "Assuming edge weight: ");
> > - printEdgeWeight(e);
> > - found = true;
> > - }
> > - }
> > - }
> > - }
> > - if (!found) {
> > - cleanup = true;
> > - DEBUG(dbgs() << "No assumption possible in Fuction
> "<<F.getName()<<", setting all to zero\n");
> > - }
> > - }
> > - }
> > - // In case there was no safe way to assume edges, set as a last
> measure,
> > - // set _everything_ to zero.
> > - if (cleanup) {
> > - FunctionInformation[&F] = 0;
> > - BlockInformation[&F].clear();
> > - EdgeInformation[&F].clear();
> > - for (Function::const_iterator FI = F.begin(), FE = F.end(); FI !=
> FE; ++FI) {
> > - const BasicBlock *BB = &(*FI);
> > - BlockInformation[&F][BB] = 0;
> > - const_pred_iterator predi = pred_begin(BB), prede = pred_end(BB);
> > - if (predi == prede) {
> > - Edge e = getEdge(0,BB);
> > - setEdgeWeight(e,0);
> > - }
> > - for (;predi != prede; ++predi) {
> > - Edge e = getEdge(*predi,BB);
> > - setEdgeWeight(e,0);
> > - }
> > - succ_const_iterator succi = succ_begin(BB), succe = succ_end(BB);
> > - if (succi == succe) {
> > - Edge e = getEdge(BB,0);
> > - setEdgeWeight(e,0);
> > - }
> > - for (;succi != succe; ++succi) {
> > - Edge e = getEdge(*succi,BB);
> > - setEdgeWeight(e,0);
> > - }
> > - }
> > - }
> > -
> > - return false;
> > -}
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileInfo.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileInfo.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileInfo.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileInfo.cpp (removed)
> > @@ -1,1079 +0,0 @@
> > -//===- ProfileInfo.cpp - Profile Info Interface
> ---------------------------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file implements the abstract ProfileInfo interface, and the
> default
> > -// "no profile" implementation.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "profile-info"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > -#include "llvm/ADT/SmallSet.h"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/CodeGen/MachineBasicBlock.h"
> > -#include "llvm/CodeGen/MachineFunction.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include <limits>
> > -#include <queue>
> > -#include <set>
> > -using namespace llvm;
> > -
> > -namespace llvm {
> > - template<> char ProfileInfoT<Function,BasicBlock>::ID = 0;
> > -}
> > -
> > -// Register the ProfileInfo interface, providing a nice name to refer
> to.
> > -INITIALIZE_ANALYSIS_GROUP(ProfileInfo, "Profile Information",
> NoProfileInfo)
> > -
> > -namespace llvm {
> > -
> > -template <>
> > -ProfileInfoT<MachineFunction, MachineBasicBlock>::ProfileInfoT() {}
> > -template <>
> > -ProfileInfoT<MachineFunction, MachineBasicBlock>::~ProfileInfoT() {}
> > -
> > -template <>
> > -ProfileInfoT<Function, BasicBlock>::ProfileInfoT() {
> > - MachineProfile = 0;
> > -}
> > -template <>
> > -ProfileInfoT<Function, BasicBlock>::~ProfileInfoT() {
> > - if (MachineProfile) delete MachineProfile;
> > -}
> > -
> > -template<>
> > -char ProfileInfoT<MachineFunction, MachineBasicBlock>::ID = 0;
> > -
> > -template<>
> > -const double ProfileInfoT<Function,BasicBlock>::MissingValue = -1;
> > -
> > -template<> const
> > -double ProfileInfoT<MachineFunction, MachineBasicBlock>::MissingValue =
> -1;
> > -
> > -template<> double
> > -ProfileInfoT<Function,BasicBlock>::getExecutionCount(const BasicBlock
> *BB) {
> > - std::map<const Function*, BlockCounts>::iterator J =
> > - BlockInformation.find(BB->getParent());
> > - if (J != BlockInformation.end()) {
> > - BlockCounts::iterator I = J->second.find(BB);
> > - if (I != J->second.end())
> > - return I->second;
> > - }
> > -
> > - double Count = MissingValue;
> > -
> > - const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
> > -
> > - // Are there zero predecessors of this block?
> > - if (PI == PE) {
> > - Edge e = getEdge(0, BB);
> > - Count = getEdgeWeight(e);
> > - } else {
> > - // Otherwise, if there are predecessors, the execution count of
> this block is
> > - // the sum of the edge frequencies from the incoming edges.
> > - std::set<const BasicBlock*> ProcessedPreds;
> > - Count = 0;
> > - for (; PI != PE; ++PI) {
> > - const BasicBlock *P = *PI;
> > - if (ProcessedPreds.insert(P).second) {
> > - double w = getEdgeWeight(getEdge(P, BB));
> > - if (w == MissingValue) {
> > - Count = MissingValue;
> > - break;
> > - }
> > - Count += w;
> > - }
> > - }
> > - }
> > -
> > - // If the predecessors did not suffice to get block weight, try
> successors.
> > - if (Count == MissingValue) {
> > -
> > - succ_const_iterator SI = succ_begin(BB), SE = succ_end(BB);
> > -
> > - // Are there zero successors of this block?
> > - if (SI == SE) {
> > - Edge e = getEdge(BB,0);
> > - Count = getEdgeWeight(e);
> > - } else {
> > - std::set<const BasicBlock*> ProcessedSuccs;
> > - Count = 0;
> > - for (; SI != SE; ++SI)
> > - if (ProcessedSuccs.insert(*SI).second) {
> > - double w = getEdgeWeight(getEdge(BB, *SI));
> > - if (w == MissingValue) {
> > - Count = MissingValue;
> > - break;
> > - }
> > - Count += w;
> > - }
> > - }
> > - }
> > -
> > - if (Count != MissingValue) BlockInformation[BB->getParent()][BB] =
> Count;
> > - return Count;
> > -}
> > -
> > -template<>
> > -double ProfileInfoT<MachineFunction, MachineBasicBlock>::
> > - getExecutionCount(const MachineBasicBlock *MBB) {
> > - std::map<const MachineFunction*, BlockCounts>::iterator J =
> > - BlockInformation.find(MBB->getParent());
> > - if (J != BlockInformation.end()) {
> > - BlockCounts::iterator I = J->second.find(MBB);
> > - if (I != J->second.end())
> > - return I->second;
> > - }
> > -
> > - return MissingValue;
> > -}
> > -
> > -template<>
> > -double ProfileInfoT<Function,BasicBlock>::getExecutionCount(const
> Function *F) {
> > - std::map<const Function*, double>::iterator J =
> > - FunctionInformation.find(F);
> > - if (J != FunctionInformation.end())
> > - return J->second;
> > -
> > - // isDeclaration() is checked here and not at start of function to
> allow
> > - // functions without a body still to have a execution count.
> > - if (F->isDeclaration()) return MissingValue;
> > -
> > - double Count = getExecutionCount(&F->getEntryBlock());
> > - if (Count != MissingValue) FunctionInformation[F] = Count;
> > - return Count;
> > -}
> > -
> > -template<>
> > -double ProfileInfoT<MachineFunction, MachineBasicBlock>::
> > - getExecutionCount(const MachineFunction *MF) {
> > - std::map<const MachineFunction*, double>::iterator J =
> > - FunctionInformation.find(MF);
> > - if (J != FunctionInformation.end())
> > - return J->second;
> > -
> > - double Count = getExecutionCount(&MF->front());
> > - if (Count != MissingValue) FunctionInformation[MF] = Count;
> > - return Count;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::
> > - setExecutionCount(const BasicBlock *BB, double w) {
> > - DEBUG(dbgs() << "Creating Block " << BB->getName()
> > - << " (weight: " << format("%.20g",w) << ")\n");
> > - BlockInformation[BB->getParent()][BB] = w;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<MachineFunction, MachineBasicBlock>::
> > - setExecutionCount(const MachineBasicBlock *MBB, double w) {
> > - DEBUG(dbgs() << "Creating Block " << MBB->getBasicBlock()->getName()
> > - << " (weight: " << format("%.20g",w) << ")\n");
> > - BlockInformation[MBB->getParent()][MBB] = w;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::addEdgeWeight(Edge e, double w)
> {
> > - double oldw = getEdgeWeight(e);
> > - assert (oldw != MissingValue && "Adding weight to Edge with no
> previous weight");
> > - DEBUG(dbgs() << "Adding to Edge " << e
> > - << " (new weight: " << format("%.20g",oldw + w) <<
> ")\n");
> > - EdgeInformation[getFunction(e)][e] = oldw + w;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::
> > - addExecutionCount(const BasicBlock *BB, double w) {
> > - double oldw = getExecutionCount(BB);
> > - assert (oldw != MissingValue && "Adding weight to Block with no
> previous weight");
> > - DEBUG(dbgs() << "Adding to Block " << BB->getName()
> > - << " (new weight: " << format("%.20g",oldw + w) <<
> ")\n");
> > - BlockInformation[BB->getParent()][BB] = oldw + w;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::removeBlock(const BasicBlock
> *BB) {
> > - std::map<const Function*, BlockCounts>::iterator J =
> > - BlockInformation.find(BB->getParent());
> > - if (J == BlockInformation.end()) return;
> > -
> > - DEBUG(dbgs() << "Deleting " << BB->getName() << "\n");
> > - J->second.erase(BB);
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::removeEdge(Edge e) {
> > - std::map<const Function*, EdgeWeights>::iterator J =
> > - EdgeInformation.find(getFunction(e));
> > - if (J == EdgeInformation.end()) return;
> > -
> > - DEBUG(dbgs() << "Deleting" << e << "\n");
> > - J->second.erase(e);
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::
> > - replaceEdge(const Edge &oldedge, const Edge &newedge) {
> > - double w;
> > - if ((w = getEdgeWeight(newedge)) == MissingValue) {
> > - w = getEdgeWeight(oldedge);
> > - DEBUG(dbgs() << "Replacing " << oldedge << " with " << newedge <<
> "\n");
> > - } else {
> > - w += getEdgeWeight(oldedge);
> > - DEBUG(dbgs() << "Adding " << oldedge << " to " << newedge << "\n");
> > - }
> > - setEdgeWeight(newedge,w);
> > - removeEdge(oldedge);
> > -}
> > -
> > -template<>
> > -const BasicBlock *ProfileInfoT<Function,BasicBlock>::
> > - GetPath(const BasicBlock *Src, const BasicBlock *Dest,
> > - Path &P, unsigned Mode) {
> > - const BasicBlock *BB = 0;
> > - bool hasFoundPath = false;
> > -
> > - std::queue<const BasicBlock *> BFS;
> > - BFS.push(Src);
> > -
> > - while(BFS.size() && !hasFoundPath) {
> > - BB = BFS.front();
> > - BFS.pop();
> > -
> > - succ_const_iterator Succ = succ_begin(BB), End = succ_end(BB);
> > - if (Succ == End) {
> > - P[(const BasicBlock*)0] = BB;
> > - if (Mode & GetPathToExit) {
> > - hasFoundPath = true;
> > - BB = 0;
> > - }
> > - }
> > - for(;Succ != End; ++Succ) {
> > - if (P.find(*Succ) != P.end()) continue;
> > - Edge e = getEdge(BB,*Succ);
> > - if ((Mode & GetPathWithNewEdges) && (getEdgeWeight(e) !=
> MissingValue)) continue;
> > - P[*Succ] = BB;
> > - BFS.push(*Succ);
> > - if ((Mode & GetPathToDest) && *Succ == Dest) {
> > - hasFoundPath = true;
> > - BB = *Succ;
> > - break;
> > - }
> > - if ((Mode & GetPathToValue) && (getExecutionCount(*Succ) !=
> MissingValue)) {
> > - hasFoundPath = true;
> > - BB = *Succ;
> > - break;
> > - }
> > - }
> > - }
> > -
> > - return BB;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::
> > - divertFlow(const Edge &oldedge, const Edge &newedge) {
> > - DEBUG(dbgs() << "Diverting " << oldedge << " via " << newedge );
> > -
> > - // First check if the old edge was taken, if not, just delete it...
> > - if (getEdgeWeight(oldedge) == 0) {
> > - removeEdge(oldedge);
> > - return;
> > - }
> > -
> > - Path P;
> > - P[newedge.first] = 0;
> > - P[newedge.second] = newedge.first;
> > - const BasicBlock *BB =
> GetPath(newedge.second,oldedge.second,P,GetPathToExit | GetPathToDest);
> > -
> > - double w = getEdgeWeight (oldedge);
> > - DEBUG(dbgs() << ", Weight: " << format("%.20g",w) << "\n");
> > - do {
> > - const BasicBlock *Parent = P.find(BB)->second;
> > - Edge e = getEdge(Parent,BB);
> > - double oldw = getEdgeWeight(e);
> > - double oldc = getExecutionCount(e.first);
> > - setEdgeWeight(e, w+oldw);
> > - if (Parent != oldedge.first) {
> > - setExecutionCount(e.first, w+oldc);
> > - }
> > - BB = Parent;
> > - } while (BB != newedge.first);
> > - removeEdge(oldedge);
> > -}
> > -
> > -/// Replaces all occurrences of RmBB in the ProfilingInfo with DestBB.
> > -/// This checks all edges of the function the blocks reside in and
> replaces the
> > -/// occurrences of RmBB with DestBB.
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::
> > - replaceAllUses(const BasicBlock *RmBB, const BasicBlock
> *DestBB) {
> > - DEBUG(dbgs() << "Replacing " << RmBB->getName()
> > - << " with " << DestBB->getName() << "\n");
> > - const Function *F = DestBB->getParent();
> > - std::map<const Function*, EdgeWeights>::iterator J =
> > - EdgeInformation.find(F);
> > - if (J == EdgeInformation.end()) return;
> > -
> > - Edge e, newedge;
> > - bool erasededge = false;
> > - EdgeWeights::iterator I = J->second.begin(), E = J->second.end();
> > - while(I != E) {
> > - e = (I++)->first;
> > - bool foundedge = false; bool eraseedge = false;
> > - if (e.first == RmBB) {
> > - if (e.second == DestBB) {
> > - eraseedge = true;
> > - } else {
> > - newedge = getEdge(DestBB, e.second);
> > - foundedge = true;
> > - }
> > - }
> > - if (e.second == RmBB) {
> > - if (e.first == DestBB) {
> > - eraseedge = true;
> > - } else {
> > - newedge = getEdge(e.first, DestBB);
> > - foundedge = true;
> > - }
> > - }
> > - if (foundedge) {
> > - replaceEdge(e, newedge);
> > - }
> > - if (eraseedge) {
> > - if (erasededge) {
> > - Edge newedge = getEdge(DestBB, DestBB);
> > - replaceEdge(e, newedge);
> > - } else {
> > - removeEdge(e);
> > - erasededge = true;
> > - }
> > - }
> > - }
> > -}
> > -
> > -/// Splits an edge in the ProfileInfo and redirects flow over NewBB.
> > -/// Since its possible that there is more than one edge in the CFG from
> FristBB
> > -/// to SecondBB its necessary to redirect the flow proporionally.
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::splitEdge(const BasicBlock
> *FirstBB,
> > - const BasicBlock
> *SecondBB,
> > - const BasicBlock
> *NewBB,
> > - bool
> MergeIdenticalEdges) {
> > - const Function *F = FirstBB->getParent();
> > - std::map<const Function*, EdgeWeights>::iterator J =
> > - EdgeInformation.find(F);
> > - if (J == EdgeInformation.end()) return;
> > -
> > - // Generate edges and read current weight.
> > - Edge e = getEdge(FirstBB, SecondBB);
> > - Edge n1 = getEdge(FirstBB, NewBB);
> > - Edge n2 = getEdge(NewBB, SecondBB);
> > - EdgeWeights &ECs = J->second;
> > - double w = ECs[e];
> > -
> > - int succ_count = 0;
> > - if (!MergeIdenticalEdges) {
> > - // First count the edges from FristBB to SecondBB, if there is more
> than
> > - // one, only slice out a proporional part for NewBB.
> > - for(succ_const_iterator BBI = succ_begin(FirstBB), BBE =
> succ_end(FirstBB);
> > - BBI != BBE; ++BBI) {
> > - if (*BBI == SecondBB) succ_count++;
> > - }
> > - // When the NewBB is completely new, increment the count by one so
> that
> > - // the counts are properly distributed.
> > - if (getExecutionCount(NewBB) == ProfileInfo::MissingValue)
> succ_count++;
> > - } else {
> > - // When the edges are merged anyway, then redirect all flow.
> > - succ_count = 1;
> > - }
> > -
> > - // We know now how many edges there are from FirstBB to SecondBB,
> reroute a
> > - // proportional part of the edge weight over NewBB.
> > - double neww = floor(w / succ_count);
> > - ECs[n1] += neww;
> > - ECs[n2] += neww;
> > - BlockInformation[F][NewBB] += neww;
> > - if (succ_count == 1) {
> > - ECs.erase(e);
> > - } else {
> > - ECs[e] -= neww;
> > - }
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::splitBlock(const BasicBlock
> *Old,
> > - const BasicBlock*
> New) {
> > - const Function *F = Old->getParent();
> > - std::map<const Function*, EdgeWeights>::iterator J =
> > - EdgeInformation.find(F);
> > - if (J == EdgeInformation.end()) return;
> > -
> > - DEBUG(dbgs() << "Splitting " << Old->getName() << " to " <<
> New->getName() << "\n");
> > -
> > - std::set<Edge> Edges;
> > - for (EdgeWeights::iterator ewi = J->second.begin(), ewe =
> J->second.end();
> > - ewi != ewe; ++ewi) {
> > - Edge old = ewi->first;
> > - if (old.first == Old) {
> > - Edges.insert(old);
> > - }
> > - }
> > - for (std::set<Edge>::iterator EI = Edges.begin(), EE = Edges.end();
> > - EI != EE; ++EI) {
> > - Edge newedge = getEdge(New, EI->second);
> > - replaceEdge(*EI, newedge);
> > - }
> > -
> > - double w = getExecutionCount(Old);
> > - setEdgeWeight(getEdge(Old, New), w);
> > - setExecutionCount(New, w);
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::splitBlock(const BasicBlock *BB,
> > - const BasicBlock*
> NewBB,
> > - BasicBlock *const
> *Preds,
> > - unsigned NumPreds) {
> > - const Function *F = BB->getParent();
> > - std::map<const Function*, EdgeWeights>::iterator J =
> > - EdgeInformation.find(F);
> > - if (J == EdgeInformation.end()) return;
> > -
> > - DEBUG(dbgs() << "Splitting " << NumPreds << " Edges from " <<
> BB->getName()
> > - << " to " << NewBB->getName() << "\n");
> > -
> > - // Collect weight that was redirected over NewBB.
> > - double newweight = 0;
> > -
> > - std::set<const BasicBlock *> ProcessedPreds;
> > - // For all requestes Predecessors.
> > - for (unsigned pred = 0; pred < NumPreds; ++pred) {
> > - const BasicBlock * Pred = Preds[pred];
> > - if (ProcessedPreds.insert(Pred).second) {
> > - // Create edges and read old weight.
> > - Edge oldedge = getEdge(Pred, BB);
> > - Edge newedge = getEdge(Pred, NewBB);
> > -
> > - // Remember how much weight was redirected.
> > - newweight += getEdgeWeight(oldedge);
> > -
> > - replaceEdge(oldedge,newedge);
> > - }
> > - }
> > -
> > - Edge newedge = getEdge(NewBB,BB);
> > - setEdgeWeight(newedge, newweight);
> > - setExecutionCount(NewBB, newweight);
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::transfer(const Function *Old,
> > - const Function *New) {
> > - DEBUG(dbgs() << "Replacing Function " << Old->getName() << " with "
> > - << New->getName() << "\n");
> > - std::map<const Function*, EdgeWeights>::iterator J =
> > - EdgeInformation.find(Old);
> > - if(J != EdgeInformation.end()) {
> > - EdgeInformation[New] = J->second;
> > - }
> > - EdgeInformation.erase(Old);
> > - BlockInformation.erase(Old);
> > - FunctionInformation.erase(Old);
> > -}
> > -
> > -static double readEdgeOrRemember(ProfileInfo::Edge edge, double w,
> > - ProfileInfo::Edge &tocalc, unsigned
> &uncalc) {
> > - if (w == ProfileInfo::MissingValue) {
> > - tocalc = edge;
> > - uncalc++;
> > - return 0;
> > - } else {
> > - return w;
> > - }
> > -}
> > -
> > -template<>
> > -bool ProfileInfoT<Function,BasicBlock>::
> > - CalculateMissingEdge(const BasicBlock *BB, Edge &removed,
> > - bool assumeEmptySelf) {
> > - Edge edgetocalc;
> > - unsigned uncalculated = 0;
> > -
> > - // collect weights of all incoming and outgoing edges, rememer edges
> that
> > - // have no value
> > - double incount = 0;
> > - SmallSet<const BasicBlock*,8> pred_visited;
> > - const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
> > - if (bbi==bbe) {
> > - Edge e = getEdge(0,BB);
> > - incount += readEdgeOrRemember(e, getEdgeWeight(e)
> ,edgetocalc,uncalculated);
> > - }
> > - for (;bbi != bbe; ++bbi) {
> > - if (pred_visited.insert(*bbi)) {
> > - Edge e = getEdge(*bbi,BB);
> > - incount += readEdgeOrRemember(e, getEdgeWeight(e)
> ,edgetocalc,uncalculated);
> > - }
> > - }
> > -
> > - double outcount = 0;
> > - SmallSet<const BasicBlock*,8> succ_visited;
> > - succ_const_iterator sbbi = succ_begin(BB), sbbe = succ_end(BB);
> > - if (sbbi==sbbe) {
> > - Edge e = getEdge(BB,0);
> > - if (getEdgeWeight(e) == MissingValue) {
> > - double w = getExecutionCount(BB);
> > - if (w != MissingValue) {
> > - setEdgeWeight(e,w);
> > - removed = e;
> > - }
> > - }
> > - outcount += readEdgeOrRemember(e, getEdgeWeight(e), edgetocalc,
> uncalculated);
> > - }
> > - for (;sbbi != sbbe; ++sbbi) {
> > - if (succ_visited.insert(*sbbi)) {
> > - Edge e = getEdge(BB,*sbbi);
> > - outcount += readEdgeOrRemember(e, getEdgeWeight(e), edgetocalc,
> uncalculated);
> > - }
> > - }
> > -
> > - // if exactly one edge weight was missing, calculate it and remove it
> from
> > - // spanning tree
> > - if (uncalculated == 0 ) {
> > - return true;
> > - } else
> > - if (uncalculated == 1) {
> > - if (incount < outcount) {
> > - EdgeInformation[BB->getParent()][edgetocalc] = outcount-incount;
> > - } else {
> > - EdgeInformation[BB->getParent()][edgetocalc] = incount-outcount;
> > - }
> > - DEBUG(dbgs() << "--Calc Edge Counter for " << edgetocalc << ": "
> > - << format("%.20g", getEdgeWeight(edgetocalc)) << "\n");
> > - removed = edgetocalc;
> > - return true;
> > - } else
> > - if (uncalculated == 2 && assumeEmptySelf && edgetocalc.first ==
> edgetocalc.second && incount == outcount) {
> > - setEdgeWeight(edgetocalc, incount * 10);
> > - removed = edgetocalc;
> > - return true;
> > - } else {
> > - return false;
> > - }
> > -}
> > -
> > -static void readEdge(ProfileInfo *PI, ProfileInfo::Edge e, double
> &calcw, std::set<ProfileInfo::Edge> &misscount) {
> > - double w = PI->getEdgeWeight(e);
> > - if (w != ProfileInfo::MissingValue) {
> > - calcw += w;
> > - } else {
> > - misscount.insert(e);
> > - }
> > -}
> > -
> > -template<>
> > -bool ProfileInfoT<Function,BasicBlock>::EstimateMissingEdges(const
> BasicBlock *BB) {
> > - double inWeight = 0;
> > - std::set<Edge> inMissing;
> > - std::set<const BasicBlock*> ProcessedPreds;
> > - const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
> > - if (bbi == bbe) {
> > - readEdge(this,getEdge(0,BB),inWeight,inMissing);
> > - }
> > - for( ; bbi != bbe; ++bbi ) {
> > - if (ProcessedPreds.insert(*bbi).second) {
> > - readEdge(this,getEdge(*bbi,BB),inWeight,inMissing);
> > - }
> > - }
> > -
> > - double outWeight = 0;
> > - std::set<Edge> outMissing;
> > - std::set<const BasicBlock*> ProcessedSuccs;
> > - succ_const_iterator sbbi = succ_begin(BB), sbbe = succ_end(BB);
> > - if (sbbi == sbbe)
> > - readEdge(this,getEdge(BB,0),outWeight,outMissing);
> > - for ( ; sbbi != sbbe; ++sbbi ) {
> > - if (ProcessedSuccs.insert(*sbbi).second) {
> > - readEdge(this,getEdge(BB,*sbbi),outWeight,outMissing);
> > - }
> > - }
> > -
> > - double share;
> > - std::set<Edge>::iterator ei,ee;
> > - if (inMissing.size() == 0 && outMissing.size() > 0) {
> > - ei = outMissing.begin();
> > - ee = outMissing.end();
> > - share = inWeight/outMissing.size();
> > - setExecutionCount(BB,inWeight);
> > - } else
> > - if (inMissing.size() > 0 && outMissing.size() == 0 && outWeight == 0)
> {
> > - ei = inMissing.begin();
> > - ee = inMissing.end();
> > - share = 0;
> > - setExecutionCount(BB,0);
> > - } else
> > - if (inMissing.size() == 0 && outMissing.size() == 0) {
> > - setExecutionCount(BB,outWeight);
> > - return true;
> > - } else {
> > - return false;
> > - }
> > - for ( ; ei != ee; ++ei ) {
> > - setEdgeWeight(*ei,share);
> > - }
> > - return true;
> > -}
> > -
> > -template<>
> > -void ProfileInfoT<Function,BasicBlock>::repair(const Function *F) {
> > -// if (getExecutionCount(&(F->getEntryBlock())) == 0) {
> > -// for (Function::const_iterator FI = F->begin(), FE = F->end();
> > -// FI != FE; ++FI) {
> > -// const BasicBlock* BB = &(*FI);
> > -// {
> > -// const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
> > -// if (NBB == End) {
> > -// setEdgeWeight(getEdge(0,BB),0);
> > -// }
> > -// for(;NBB != End; ++NBB) {
> > -// setEdgeWeight(getEdge(*NBB,BB),0);
> > -// }
> > -// }
> > -// {
> > -// succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
> > -// if (NBB == End) {
> > -// setEdgeWeight(getEdge(0,BB),0);
> > -// }
> > -// for(;NBB != End; ++NBB) {
> > -// setEdgeWeight(getEdge(*NBB,BB),0);
> > -// }
> > -// }
> > -// }
> > -// return;
> > -// }
> > - // The set of BasicBlocks that are still unvisited.
> > - std::set<const BasicBlock*> Unvisited;
> > -
> > - // The set of return edges (Edges with no successors).
> > - std::set<Edge> ReturnEdges;
> > - double ReturnWeight = 0;
> > -
> > - // First iterate over the whole function and collect:
> > - // 1) The blocks in this function in the Unvisited set.
> > - // 2) The return edges in the ReturnEdges set.
> > - // 3) The flow that is leaving the function already via return edges.
> > -
> > - // Data structure for searching the function.
> > - std::queue<const BasicBlock *> BFS;
> > - const BasicBlock *BB = &(F->getEntryBlock());
> > - BFS.push(BB);
> > - Unvisited.insert(BB);
> > -
> > - while (BFS.size()) {
> > - BB = BFS.front(); BFS.pop();
> > - succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
> > - if (NBB == End) {
> > - Edge e = getEdge(BB,0);
> > - double w = getEdgeWeight(e);
> > - if (w == MissingValue) {
> > - // If the return edge has no value, try to read value from
> block.
> > - double bw = getExecutionCount(BB);
> > - if (bw != MissingValue) {
> > - setEdgeWeight(e,bw);
> > - ReturnWeight += bw;
> > - } else {
> > - // If both return edge and block provide no value, collect
> edge.
> > - ReturnEdges.insert(e);
> > - }
> > - } else {
> > - // If the return edge has a proper value, collect it.
> > - ReturnWeight += w;
> > - }
> > - }
> > - for (;NBB != End; ++NBB) {
> > - if (Unvisited.insert(*NBB).second) {
> > - BFS.push(*NBB);
> > - }
> > - }
> > - }
> > -
> > - while (Unvisited.size() > 0) {
> > - unsigned oldUnvisitedCount = Unvisited.size();
> > - bool FoundPath = false;
> > -
> > - // If there is only one edge left, calculate it.
> > - if (ReturnEdges.size() == 1) {
> > - ReturnWeight = getExecutionCount(&(F->getEntryBlock())) -
> ReturnWeight;
> > -
> > - Edge e = *ReturnEdges.begin();
> > - setEdgeWeight(e,ReturnWeight);
> > - setExecutionCount(e.first,ReturnWeight);
> > -
> > - Unvisited.erase(e.first);
> > - ReturnEdges.erase(e);
> > - continue;
> > - }
> > -
> > - // Calculate all blocks where only one edge is missing, this may
> also
> > - // resolve furhter return edges.
> > - std::set<const BasicBlock *>::iterator FI = Unvisited.begin(), FE =
> Unvisited.end();
> > - while(FI != FE) {
> > - const BasicBlock *BB = *FI; ++FI;
> > - Edge e;
> > - if(CalculateMissingEdge(BB,e,true)) {
> > - if (BlockInformation[F].find(BB) == BlockInformation[F].end()) {
> > - setExecutionCount(BB,getExecutionCount(BB));
> > - }
> > - Unvisited.erase(BB);
> > - if (e.first != 0 && e.second == 0) {
> > - ReturnEdges.erase(e);
> > - ReturnWeight += getEdgeWeight(e);
> > - }
> > - }
> > - }
> > - if (oldUnvisitedCount > Unvisited.size()) continue;
> > -
> > - // Estimate edge weights by dividing the flow proportionally.
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE) {
> > - const BasicBlock *BB = *FI; ++FI;
> > - const BasicBlock *Dest = 0;
> > - bool AllEdgesHaveSameReturn = true;
> > - // Check each Successor, these must all end up in the same or an
> empty
> > - // return block otherwise its dangerous to do an estimation on
> them.
> > - for (succ_const_iterator Succ = succ_begin(BB), End =
> succ_end(BB);
> > - Succ != End; ++Succ) {
> > - Path P;
> > - GetPath(*Succ, 0, P, GetPathToExit);
> > - if (Dest && Dest != P[(const BasicBlock*)0]) {
> > - AllEdgesHaveSameReturn = false;
> > - }
> > - Dest = P[(const BasicBlock*)0];
> > - }
> > - if (AllEdgesHaveSameReturn) {
> > - if(EstimateMissingEdges(BB)) {
> > - Unvisited.erase(BB);
> > - break;
> > - }
> > - }
> > - }
> > - if (oldUnvisitedCount > Unvisited.size()) continue;
> > -
> > - // Check if there is a path to an block that has a known value and
> redirect
> > - // flow accordingly.
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE && !FoundPath) {
> > - // Fetch path.
> > - const BasicBlock *BB = *FI; ++FI;
> > - Path P;
> > - const BasicBlock *Dest = GetPath(BB, 0, P, GetPathToValue);
> > -
> > - // Calculate incoming flow.
> > - double iw = 0; unsigned inmissing = 0; unsigned incount = 0;
> unsigned invalid = 0;
> > - std::set<const BasicBlock *> Processed;
> > - for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
> > - NBB != End; ++NBB) {
> > - if (Processed.insert(*NBB).second) {
> > - Edge e = getEdge(*NBB, BB);
> > - double ew = getEdgeWeight(e);
> > - if (ew != MissingValue) {
> > - iw += ew;
> > - invalid++;
> > - } else {
> > - // If the path contains the successor, this means its a
> backedge,
> > - // do not count as missing.
> > - if (P.find(*NBB) == P.end())
> > - inmissing++;
> > - }
> > - incount++;
> > - }
> > - }
> > - if (inmissing == incount) continue;
> > - if (invalid == 0) continue;
> > -
> > - // Subtract (already) outgoing flow.
> > - Processed.clear();
> > - for (succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
> > - NBB != End; ++NBB) {
> > - if (Processed.insert(*NBB).second) {
> > - Edge e = getEdge(BB, *NBB);
> > - double ew = getEdgeWeight(e);
> > - if (ew != MissingValue) {
> > - iw -= ew;
> > - }
> > - }
> > - }
> > - if (iw < 0) continue;
> > -
> > - // Check the receiving end of the path if it can handle the flow.
> > - double ow = getExecutionCount(Dest);
> > - Processed.clear();
> > - for (succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
> > - NBB != End; ++NBB) {
> > - if (Processed.insert(*NBB).second) {
> > - Edge e = getEdge(BB, *NBB);
> > - double ew = getEdgeWeight(e);
> > - if (ew != MissingValue) {
> > - ow -= ew;
> > - }
> > - }
> > - }
> > - if (ow < 0) continue;
> > -
> > - // Determine how much flow shall be used.
> > - double ew = getEdgeWeight(getEdge(P[Dest],Dest));
> > - if (ew != MissingValue) {
> > - ew = ew<ow?ew:ow;
> > - ew = ew<iw?ew:iw;
> > - } else {
> > - if (inmissing == 0)
> > - ew = iw;
> > - }
> > -
> > - // Create flow.
> > - if (ew != MissingValue) {
> > - do {
> > - Edge e = getEdge(P[Dest],Dest);
> > - if (getEdgeWeight(e) == MissingValue) {
> > - setEdgeWeight(e,ew);
> > - FoundPath = true;
> > - }
> > - Dest = P[Dest];
> > - } while (Dest != BB);
> > - }
> > - }
> > - if (FoundPath) continue;
> > -
> > - // Calculate a block with self loop.
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE && !FoundPath) {
> > - const BasicBlock *BB = *FI; ++FI;
> > - bool SelfEdgeFound = false;
> > - for (succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
> > - NBB != End; ++NBB) {
> > - if (*NBB == BB) {
> > - SelfEdgeFound = true;
> > - break;
> > - }
> > - }
> > - if (SelfEdgeFound) {
> > - Edge e = getEdge(BB,BB);
> > - if (getEdgeWeight(e) == MissingValue) {
> > - double iw = 0;
> > - std::set<const BasicBlock *> Processed;
> > - for (const_pred_iterator NBB = pred_begin(BB), End =
> pred_end(BB);
> > - NBB != End; ++NBB) {
> > - if (Processed.insert(*NBB).second) {
> > - Edge e = getEdge(*NBB, BB);
> > - double ew = getEdgeWeight(e);
> > - if (ew != MissingValue) {
> > - iw += ew;
> > - }
> > - }
> > - }
> > - setEdgeWeight(e,iw * 10);
> > - FoundPath = true;
> > - }
> > - }
> > - }
> > - if (FoundPath) continue;
> > -
> > - // Determine backedges, set them to zero.
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE && !FoundPath) {
> > - const BasicBlock *BB = *FI; ++FI;
> > - const BasicBlock *Dest = 0;
> > - Path P;
> > - bool BackEdgeFound = false;
> > - for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
> > - NBB != End; ++NBB) {
> > - Dest = GetPath(BB, *NBB, P, GetPathToDest |
> GetPathWithNewEdges);
> > - if (Dest == *NBB) {
> > - BackEdgeFound = true;
> > - break;
> > - }
> > - }
> > - if (BackEdgeFound) {
> > - Edge e = getEdge(Dest,BB);
> > - double w = getEdgeWeight(e);
> > - if (w == MissingValue) {
> > - setEdgeWeight(e,0);
> > - FoundPath = true;
> > - }
> > - do {
> > - Edge e = getEdge(P[Dest], Dest);
> > - double w = getEdgeWeight(e);
> > - if (w == MissingValue) {
> > - setEdgeWeight(e,0);
> > - FoundPath = true;
> > - }
> > - Dest = P[Dest];
> > - } while (Dest != BB);
> > - }
> > - }
> > - if (FoundPath) continue;
> > -
> > - // Channel flow to return block.
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE && !FoundPath) {
> > - const BasicBlock *BB = *FI; ++FI;
> > -
> > - Path P;
> > - const BasicBlock *Dest = GetPath(BB, 0, P, GetPathToExit |
> GetPathWithNewEdges);
> > - Dest = P[(const BasicBlock*)0];
> > - if (!Dest) continue;
> > -
> > - if (getEdgeWeight(getEdge(Dest,0)) == MissingValue) {
> > - // Calculate incoming flow.
> > - double iw = 0;
> > - std::set<const BasicBlock *> Processed;
> > - for (const_pred_iterator NBB = pred_begin(BB), End =
> pred_end(BB);
> > - NBB != End; ++NBB) {
> > - if (Processed.insert(*NBB).second) {
> > - Edge e = getEdge(*NBB, BB);
> > - double ew = getEdgeWeight(e);
> > - if (ew != MissingValue) {
> > - iw += ew;
> > - }
> > - }
> > - }
> > - do {
> > - Edge e = getEdge(P[Dest], Dest);
> > - double w = getEdgeWeight(e);
> > - if (w == MissingValue) {
> > - setEdgeWeight(e,iw);
> > - FoundPath = true;
> > - } else {
> > - assert(0 && "Edge should not have value already!");
> > - }
> > - Dest = P[Dest];
> > - } while (Dest != BB);
> > - }
> > - }
> > - if (FoundPath) continue;
> > -
> > - // Speculatively set edges to zero.
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE && !FoundPath) {
> > - const BasicBlock *BB = *FI; ++FI;
> > -
> > - for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
> > - NBB != End; ++NBB) {
> > - Edge e = getEdge(*NBB,BB);
> > - double w = getEdgeWeight(e);
> > - if (w == MissingValue) {
> > - setEdgeWeight(e,0);
> > - FoundPath = true;
> > - break;
> > - }
> > - }
> > - }
> > - if (FoundPath) continue;
> > -
> > - errs() << "{";
> > - FI = Unvisited.begin(), FE = Unvisited.end();
> > - while(FI != FE) {
> > - const BasicBlock *BB = *FI; ++FI;
> > - dbgs() << BB->getName();
> > - if (FI != FE)
> > - dbgs() << ",";
> > - }
> > - errs() << "}";
> > -
> > - errs() << "ASSERT: could not repair function";
> > - assert(0 && "could not repair function");
> > - }
> > -
> > - EdgeWeights J = EdgeInformation[F];
> > - for (EdgeWeights::iterator EI = J.begin(), EE = J.end(); EI != EE;
> ++EI) {
> > - Edge e = EI->first;
> > -
> > - bool SuccFound = false;
> > - if (e.first != 0) {
> > - succ_const_iterator NBB = succ_begin(e.first), End =
> succ_end(e.first);
> > - if (NBB == End) {
> > - if (0 == e.second) {
> > - SuccFound = true;
> > - }
> > - }
> > - for (;NBB != End; ++NBB) {
> > - if (*NBB == e.second) {
> > - SuccFound = true;
> > - break;
> > - }
> > - }
> > - if (!SuccFound) {
> > - removeEdge(e);
> > - }
> > - }
> > - }
> > -}
> > -
> > -raw_ostream& operator<<(raw_ostream &O, const MachineFunction *MF) {
> > - return O << MF->getFunction()->getName() << "(MF)";
> > -}
> > -
> > -raw_ostream& operator<<(raw_ostream &O, const MachineBasicBlock *MBB) {
> > - return O << MBB->getBasicBlock()->getName() << "(MB)";
> > -}
> > -
> > -raw_ostream& operator<<(raw_ostream &O, std::pair<const
> MachineBasicBlock *, const MachineBasicBlock *> E) {
> > - O << "(";
> > -
> > - if (E.first)
> > - O << E.first;
> > - else
> > - O << "0";
> > -
> > - O << ",";
> > -
> > - if (E.second)
> > - O << E.second;
> > - else
> > - O << "0";
> > -
> > - return O << ")";
> > -}
> > -
> > -} // namespace llvm
> > -
> >
> -//===----------------------------------------------------------------------===//
> > -// NoProfile ProfileInfo implementation
> > -//
> > -
> > -namespace {
> > - struct NoProfileInfo : public ImmutablePass, public ProfileInfo {
> > - static char ID; // Class identification, replacement for typeinfo
> > - NoProfileInfo() : ImmutablePass(ID) {
> > - initializeNoProfileInfoPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > - /// getAdjustedAnalysisPointer - This method is used when a pass
> implements
> > - /// an analysis interface through multiple inheritance. If needed,
> it
> > - /// should override this to adjust the this pointer as needed for
> the
> > - /// specified pass info.
> > - virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
> > - if (PI == &ProfileInfo::ID)
> > - return (ProfileInfo*)this;
> > - return this;
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "NoProfileInfo";
> > - }
> > - };
> > -} // End of anonymous namespace
> > -
> > -char NoProfileInfo::ID = 0;
> > -// Register this pass...
> > -INITIALIZE_AG_PASS(NoProfileInfo, ProfileInfo, "no-profile",
> > - "No Profile Information", false, true, true)
> > -
> > -ImmutablePass *llvm::createNoProfileInfoPass() { return new
> NoProfileInfo(); }
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileInfoLoader.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileInfoLoader.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileInfoLoader.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileInfoLoader.cpp (removed)
> > @@ -1,155 +0,0 @@
> > -//===- ProfileInfoLoad.cpp - Load profile information from disk
> -----------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// The ProfileInfoLoader class is used to load and represent profiling
> > -// information read in from the dump file.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#include "llvm/Analysis/ProfileInfoLoader.h"
> > -#include "llvm/Analysis/ProfileInfoTypes.h"
> > -#include "llvm/IR/InstrTypes.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <cstdio>
> > -#include <cstdlib>
> > -using namespace llvm;
> > -
> > -// ByteSwap - Byteswap 'Var' if 'Really' is true.
> > -//
> > -static inline unsigned ByteSwap(unsigned Var, bool Really) {
> > - if (!Really) return Var;
> > - return ((Var & (255U<< 0U)) << 24U) |
> > - ((Var & (255U<< 8U)) << 8U) |
> > - ((Var & (255U<<16U)) >> 8U) |
> > - ((Var & (255U<<24U)) >> 24U);
> > -}
> > -
> > -static unsigned AddCounts(unsigned A, unsigned B) {
> > - // If either value is undefined, use the other.
> > - if (A == ProfileInfoLoader::Uncounted) return B;
> > - if (B == ProfileInfoLoader::Uncounted) return A;
> > - return A + B;
> > -}
> > -
> > -static void ReadProfilingBlock(const char *ToolName, FILE *F,
> > - bool ShouldByteSwap,
> > - std::vector<unsigned> &Data) {
> > - // Read the number of entries...
> > - unsigned NumEntries;
> > - if (fread(&NumEntries, sizeof(unsigned), 1, F) != 1) {
> > - errs() << ToolName << ": data packet truncated!\n";
> > - perror(0);
> > - exit(1);
> > - }
> > - NumEntries = ByteSwap(NumEntries, ShouldByteSwap);
> > -
> > - // Read the counts...
> > - std::vector<unsigned> TempSpace(NumEntries);
> > -
> > - // Read in the block of data...
> > - if (fread(&TempSpace[0], sizeof(unsigned)*NumEntries, 1, F) != 1) {
> > - errs() << ToolName << ": data packet truncated!\n";
> > - perror(0);
> > - exit(1);
> > - }
> > -
> > - // Make sure we have enough space... The space is initialised to -1 to
> > - // facitiltate the loading of missing values for OptimalEdgeProfiling.
> > - if (Data.size() < NumEntries)
> > - Data.resize(NumEntries, ProfileInfoLoader::Uncounted);
> > -
> > - // Accumulate the data we just read into the data.
> > - if (!ShouldByteSwap) {
> > - for (unsigned i = 0; i != NumEntries; ++i) {
> > - Data[i] = AddCounts(TempSpace[i], Data[i]);
> > - }
> > - } else {
> > - for (unsigned i = 0; i != NumEntries; ++i) {
> > - Data[i] = AddCounts(ByteSwap(TempSpace[i], true), Data[i]);
> > - }
> > - }
> > -}
> > -
> > -const unsigned ProfileInfoLoader::Uncounted = ~0U;
> > -
> > -// ProfileInfoLoader ctor - Read the specified profiling data file,
> exiting the
> > -// program if the file is invalid or broken.
> > -//
> > -ProfileInfoLoader::ProfileInfoLoader(const char *ToolName,
> > - const std::string &Filename)
> > - : Filename(Filename) {
> > - FILE *F = fopen(Filename.c_str(), "rb");
> > - if (F == 0) {
> > - errs() << ToolName << ": Error opening '" << Filename << "': ";
> > - perror(0);
> > - exit(1);
> > - }
> > -
> > - // Keep reading packets until we run out of them.
> > - unsigned PacketType;
> > - while (fread(&PacketType, sizeof(unsigned), 1, F) == 1) {
> > - // If the low eight bits of the packet are zero, we must be dealing
> with an
> > - // endianness mismatch. Byteswap all words read from the profiling
> > - // information.
> > - bool ShouldByteSwap = (char)PacketType == 0;
> > - PacketType = ByteSwap(PacketType, ShouldByteSwap);
> > -
> > - switch (PacketType) {
> > - case ArgumentInfo: {
> > - unsigned ArgLength;
> > - if (fread(&ArgLength, sizeof(unsigned), 1, F) != 1) {
> > - errs() << ToolName << ": arguments packet truncated!\n";
> > - perror(0);
> > - exit(1);
> > - }
> > - ArgLength = ByteSwap(ArgLength, ShouldByteSwap);
> > -
> > - // Read in the arguments...
> > - std::vector<char> Chars(ArgLength+4);
> > -
> > - if (ArgLength)
> > - if (fread(&Chars[0], (ArgLength+3) & ~3, 1, F) != 1) {
> > - errs() << ToolName << ": arguments packet truncated!\n";
> > - perror(0);
> > - exit(1);
> > - }
> > - CommandLines.push_back(std::string(&Chars[0], &Chars[ArgLength]));
> > - break;
> > - }
> > -
> > - case FunctionInfo:
> > - ReadProfilingBlock(ToolName, F, ShouldByteSwap, FunctionCounts);
> > - break;
> > -
> > - case BlockInfo:
> > - ReadProfilingBlock(ToolName, F, ShouldByteSwap, BlockCounts);
> > - break;
> > -
> > - case EdgeInfo:
> > - ReadProfilingBlock(ToolName, F, ShouldByteSwap, EdgeCounts);
> > - break;
> > -
> > - case OptEdgeInfo:
> > - ReadProfilingBlock(ToolName, F, ShouldByteSwap,
> OptimalEdgeCounts);
> > - break;
> > -
> > - case BBTraceInfo:
> > - ReadProfilingBlock(ToolName, F, ShouldByteSwap, BBTrace);
> > - break;
> > -
> > - default:
> > - errs() << ToolName << ": Unknown packet type #" << PacketType <<
> "!\n";
> > - exit(1);
> > - }
> > - }
> > -
> > - fclose(F);
> > -}
> > -
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileInfoLoaderPass.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileInfoLoaderPass.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileInfoLoaderPass.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileInfoLoaderPass.cpp (removed)
> > @@ -1,267 +0,0 @@
> > -//===- ProfileInfoLoaderPass.cpp - LLVM Pass to load profile info
> ---------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file implements a concrete implementation of profiling
> information that
> > -// loads the information from a profile dump file.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "profile-loader"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/ADT/SmallSet.h"
> > -#include "llvm/ADT/Statistic.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > -#include "llvm/Analysis/ProfileInfoLoader.h"
> > -#include "llvm/IR/BasicBlock.h"
> > -#include "llvm/IR/InstrTypes.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Format.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <set>
> > -using namespace llvm;
> > -
> > -STATISTIC(NumEdgesRead, "The # of edges read.");
> > -
> > -static cl::opt<std::string>
> > -ProfileInfoFilename("profile-info-file", cl::init("llvmprof.out"),
> > - cl::value_desc("filename"),
> > - cl::desc("Profile file loaded by -profile-loader"));
> > -
> > -namespace {
> > - class LoaderPass : public ModulePass, public ProfileInfo {
> > - std::string Filename;
> > - std::set<Edge> SpanningTree;
> > - std::set<const BasicBlock*> BBisUnvisited;
> > - unsigned ReadCount;
> > - public:
> > - static char ID; // Class identification, replacement for typeinfo
> > - explicit LoaderPass(const std::string &filename = "")
> > - : ModulePass(ID), Filename(filename) {
> > - initializeLoaderPassPass(*PassRegistry::getPassRegistry());
> > - if (filename.empty()) Filename = ProfileInfoFilename;
> > - }
> > -
> > - virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > - AU.setPreservesAll();
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "Profiling information loader";
> > - }
> > -
> > - // recurseBasicBlock() - Calculates the edge weights for as much
> basic
> > - // blocks as possbile.
> > - virtual void recurseBasicBlock(const BasicBlock *BB);
> > - virtual void readEdgeOrRemember(Edge, Edge&, unsigned &, double &);
> > - virtual void readEdge(ProfileInfo::Edge, std::vector<unsigned>&);
> > -
> > - /// getAdjustedAnalysisPointer - This method is used when a pass
> implements
> > - /// an analysis interface through multiple inheritance. If needed,
> it
> > - /// should override this to adjust the this pointer as needed for
> the
> > - /// specified pass info.
> > - virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
> > - if (PI == &ProfileInfo::ID)
> > - return (ProfileInfo*)this;
> > - return this;
> > - }
> > -
> > - /// run - Load the profile information from the specified file.
> > - virtual bool runOnModule(Module &M);
> > - };
> > -} // End of anonymous namespace
> > -
> > -char LoaderPass::ID = 0;
> > -INITIALIZE_AG_PASS(LoaderPass, ProfileInfo, "profile-loader",
> > - "Load profile information from llvmprof.out", false,
> true, false)
> > -
> > -char &llvm::ProfileLoaderPassID = LoaderPass::ID;
> > -
> > -ModulePass *llvm::createProfileLoaderPass() { return new LoaderPass(); }
> > -
> > -/// createProfileLoaderPass - This function returns a Pass that loads
> the
> > -/// profiling information for the module from the specified filename,
> making it
> > -/// available to the optimizers.
> > -Pass *llvm::createProfileLoaderPass(const std::string &Filename) {
> > - return new LoaderPass(Filename);
> > -}
> > -
> > -void LoaderPass::readEdgeOrRemember(Edge edge, Edge &tocalc,
> > - unsigned &uncalc, double &count) {
> > - double w;
> > - if ((w = getEdgeWeight(edge)) == MissingValue) {
> > - tocalc = edge;
> > - uncalc++;
> > - } else {
> > - count+=w;
> > - }
> > -}
> > -
> > -// recurseBasicBlock - Visits all neighbours of a block and then tries
> to
> > -// calculate the missing edge values.
> > -void LoaderPass::recurseBasicBlock(const BasicBlock *BB) {
> > -
> > - // break recursion if already visited
> > - if (BBisUnvisited.find(BB) == BBisUnvisited.end()) return;
> > - BBisUnvisited.erase(BB);
> > - if (!BB) return;
> > -
> > - for (succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - bbi != bbe; ++bbi) {
> > - recurseBasicBlock(*bbi);
> > - }
> > - for (const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
> > - bbi != bbe; ++bbi) {
> > - recurseBasicBlock(*bbi);
> > - }
> > -
> > - Edge tocalc;
> > - if (CalculateMissingEdge(BB, tocalc)) {
> > - SpanningTree.erase(tocalc);
> > - }
> > -}
> > -
> > -void LoaderPass::readEdge(ProfileInfo::Edge e,
> > - std::vector<unsigned> &ECs) {
> > - if (ReadCount < ECs.size()) {
> > - double weight = ECs[ReadCount++];
> > - if (weight != ProfileInfoLoader::Uncounted) {
> > - // Here the data realm changes from the unsigned of the file to
> the
> > - // double of the ProfileInfo. This conversion is save because we
> know
> > - // that everything thats representable in unsinged is also
> representable
> > - // in double.
> > - EdgeInformation[getFunction(e)][e] += (double)weight;
> > -
> > - DEBUG(dbgs() << "--Read Edge Counter for " << e
> > - << " (# "<< (ReadCount-1) << "): "
> > - << (unsigned)getEdgeWeight(e) << "\n");
> > - } else {
> > - // This happens only if reading optimal profiling information,
> not when
> > - // reading regular profiling information.
> > - SpanningTree.insert(e);
> > - }
> > - }
> > -}
> > -
> > -bool LoaderPass::runOnModule(Module &M) {
> > - ProfileInfoLoader PIL("profile-loader", Filename);
> > -
> > - EdgeInformation.clear();
> > - std::vector<unsigned> Counters = PIL.getRawEdgeCounts();
> > - if (Counters.size() > 0) {
> > - ReadCount = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - DEBUG(dbgs() << "Working on " << F->getName() << "\n");
> > - readEdge(getEdge(0,&F->getEntryBlock()), Counters);
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - TerminatorInst *TI = BB->getTerminator();
> > - for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
> > - readEdge(getEdge(BB,TI->getSuccessor(s)), Counters);
> > - }
> > - }
> > - }
> > - if (ReadCount != Counters.size()) {
> > - errs() << "WARNING: profile information is inconsistent with "
> > - << "the current program!\n";
> > - }
> > - NumEdgesRead = ReadCount;
> > - }
> > -
> > - Counters = PIL.getRawOptimalEdgeCounts();
> > - if (Counters.size() > 0) {
> > - ReadCount = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - DEBUG(dbgs() << "Working on " << F->getName() << "\n");
> > - readEdge(getEdge(0,&F->getEntryBlock()), Counters);
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - TerminatorInst *TI = BB->getTerminator();
> > - if (TI->getNumSuccessors() == 0) {
> > - readEdge(getEdge(BB,0), Counters);
> > - }
> > - for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
> > - readEdge(getEdge(BB,TI->getSuccessor(s)), Counters);
> > - }
> > - }
> > - while (SpanningTree.size() > 0) {
> > -
> > - unsigned size = SpanningTree.size();
> > -
> > - BBisUnvisited.clear();
> > - for (std::set<Edge>::iterator ei = SpanningTree.begin(),
> > - ee = SpanningTree.end(); ei != ee; ++ei) {
> > - BBisUnvisited.insert(ei->first);
> > - BBisUnvisited.insert(ei->second);
> > - }
> > - while (BBisUnvisited.size() > 0) {
> > - recurseBasicBlock(*BBisUnvisited.begin());
> > - }
> > -
> > - if (SpanningTree.size() == size) {
> > - DEBUG(dbgs()<<"{");
> > - for (std::set<Edge>::iterator ei = SpanningTree.begin(),
> > - ee = SpanningTree.end(); ei != ee; ++ei) {
> > - DEBUG(dbgs()<< *ei <<",");
> > - }
> > - assert(0 && "No edge calculated!");
> > - }
> > -
> > - }
> > - }
> > - if (ReadCount != Counters.size()) {
> > - errs() << "WARNING: profile information is inconsistent with "
> > - << "the current program!\n";
> > - }
> > - NumEdgesRead = ReadCount;
> > - }
> > -
> > - BlockInformation.clear();
> > - Counters = PIL.getRawBlockCounts();
> > - if (Counters.size() > 0) {
> > - ReadCount = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB)
> > - if (ReadCount < Counters.size())
> > - // Here the data realm changes from the unsigned of the file
> to the
> > - // double of the ProfileInfo. This conversion is save because
> we know
> > - // that everything thats representable in unsinged is also
> > - // representable in double.
> > - BlockInformation[F][BB] = (double)Counters[ReadCount++];
> > - }
> > - if (ReadCount != Counters.size()) {
> > - errs() << "WARNING: profile information is inconsistent with "
> > - << "the current program!\n";
> > - }
> > - }
> > -
> > - FunctionInformation.clear();
> > - Counters = PIL.getRawFunctionCounts();
> > - if (Counters.size() > 0) {
> > - ReadCount = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - if (ReadCount < Counters.size())
> > - // Here the data realm changes from the unsigned of the file to
> the
> > - // double of the ProfileInfo. This conversion is save because
> we know
> > - // that everything thats representable in unsinged is also
> > - // representable in double.
> > - FunctionInformation[F] = (double)Counters[ReadCount++];
> > - }
> > - if (ReadCount != Counters.size()) {
> > - errs() << "WARNING: profile information is inconsistent with "
> > - << "the current program!\n";
> > - }
> > - }
> > -
> > - return false;
> > -}
> >
> > Removed: llvm/trunk/lib/Analysis/ProfileVerifierPass.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ProfileVerifierPass.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Analysis/ProfileVerifierPass.cpp (original)
> > +++ llvm/trunk/lib/Analysis/ProfileVerifierPass.cpp (removed)
> > @@ -1,383 +0,0 @@
> > -//===- ProfileVerifierPass.cpp - LLVM Pass to estimate profile info
> -------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file implements a pass that checks profiling information for
> > -// plausibility.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "profile-verifier"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > -#include "llvm/IR/Instructions.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include "llvm/Support/CallSite.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Format.h"
> > -#include "llvm/Support/InstIterator.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <set>
> > -using namespace llvm;
> > -
> > -static cl::opt<bool,false>
> > -ProfileVerifierDisableAssertions("profile-verifier-noassert",
> > - cl::desc("Disable assertions"));
> > -
> > -namespace {
> > - template<class FType, class BType>
> > - class ProfileVerifierPassT : public FunctionPass {
> > -
> > - struct DetailedBlockInfo {
> > - const BType *BB;
> > - double BBWeight;
> > - double inWeight;
> > - int inCount;
> > - double outWeight;
> > - int outCount;
> > - };
> > -
> > - ProfileInfoT<FType, BType> *PI;
> > - std::set<const BType*> BBisVisited;
> > - std::set<const FType*> FisVisited;
> > - bool DisableAssertions;
> > -
> > - // When debugging is enabled, the verifier prints a whole slew of
> debug
> > - // information, otherwise its just the assert. These are all the
> helper
> > - // functions.
> > - bool PrintedDebugTree;
> > - std::set<const BType*> BBisPrinted;
> > - void debugEntry(DetailedBlockInfo*);
> > - void printDebugInfo(const BType *BB);
> > -
> > - public:
> > - static char ID; // Class identification, replacement for typeinfo
> > -
> > - explicit ProfileVerifierPassT () : FunctionPass(ID) {
> > -
> initializeProfileVerifierPassPass(*PassRegistry::getPassRegistry());
> > - DisableAssertions = ProfileVerifierDisableAssertions;
> > - }
> > - explicit ProfileVerifierPassT (bool da) : FunctionPass(ID),
> > - DisableAssertions(da) {
> > -
> initializeProfileVerifierPassPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > - void getAnalysisUsage(AnalysisUsage &AU) const {
> > - AU.setPreservesAll();
> > - AU.addRequired<ProfileInfoT<FType, BType> >();
> > - }
> > -
> > - const char *getPassName() const {
> > - return "Profiling information verifier";
> > - }
> > -
> > - /// run - Verify the profile information.
> > - bool runOnFunction(FType &F);
> > - void recurseBasicBlock(const BType*);
> > -
> > - bool exitReachable(const FType*);
> > - double ReadOrAssert(typename ProfileInfoT<FType, BType>::Edge);
> > - void CheckValue(bool, const char*, DetailedBlockInfo*);
> > - };
> > -
> > - typedef ProfileVerifierPassT<Function, BasicBlock>
> ProfileVerifierPass;
> > -
> > - template<class FType, class BType>
> > - void ProfileVerifierPassT<FType, BType>::printDebugInfo(const BType
> *BB) {
> > -
> > - if (BBisPrinted.find(BB) != BBisPrinted.end()) return;
> > -
> > - double BBWeight = PI->getExecutionCount(BB);
> > - if (BBWeight == ProfileInfoT<FType, BType>::MissingValue) {
> BBWeight = 0; }
> > - double inWeight = 0;
> > - int inCount = 0;
> > - std::set<const BType*> ProcessedPreds;
> > - for (const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
> > - bbi != bbe; ++bbi ) {
> > - if (ProcessedPreds.insert(*bbi).second) {
> > - typename ProfileInfoT<FType, BType>::Edge E =
> PI->getEdge(*bbi,BB);
> > - double EdgeWeight = PI->getEdgeWeight(E);
> > - if (EdgeWeight == ProfileInfoT<FType, BType>::MissingValue) {
> EdgeWeight = 0; }
> > - dbgs() << "calculated in-edge " << E << ": "
> > - << format("%20.20g",EdgeWeight) << "\n";
> > - inWeight += EdgeWeight;
> > - inCount++;
> > - }
> > - }
> > - double outWeight = 0;
> > - int outCount = 0;
> > - std::set<const BType*> ProcessedSuccs;
> > - for ( succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - bbi != bbe; ++bbi ) {
> > - if (ProcessedSuccs.insert(*bbi).second) {
> > - typename ProfileInfoT<FType, BType>::Edge E =
> PI->getEdge(BB,*bbi);
> > - double EdgeWeight = PI->getEdgeWeight(E);
> > - if (EdgeWeight == ProfileInfoT<FType, BType>::MissingValue) {
> EdgeWeight = 0; }
> > - dbgs() << "calculated out-edge " << E << ": "
> > - << format("%20.20g",EdgeWeight) << "\n";
> > - outWeight += EdgeWeight;
> > - outCount++;
> > - }
> > - }
> > - dbgs() << "Block " << BB->getName() << " in "
> > - << BB->getParent()->getName() << ":"
> > - << "BBWeight=" << format("%20.20g",BBWeight) << ","
> > - << "inWeight=" << format("%20.20g",inWeight) << ","
> > - << "inCount=" << inCount << ","
> > - << "outWeight=" << format("%20.20g",outWeight) << ","
> > - << "outCount" << outCount << "\n";
> > -
> > - // mark as visited and recurse into subnodes
> > - BBisPrinted.insert(BB);
> > - for ( succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - bbi != bbe; ++bbi ) {
> > - printDebugInfo(*bbi);
> > - }
> > - }
> > -
> > - template<class FType, class BType>
> > - void ProfileVerifierPassT<FType, BType>::debugEntry
> (DetailedBlockInfo *DI) {
> > - dbgs() << "TROUBLE: Block " << DI->BB->getName() << " in "
> > - << DI->BB->getParent()->getName() << ":"
> > - << "BBWeight=" << format("%20.20g",DI->BBWeight) << ","
> > - << "inWeight=" << format("%20.20g",DI->inWeight) << ","
> > - << "inCount=" << DI->inCount << ","
> > - << "outWeight=" << format("%20.20g",DI->outWeight) << ","
> > - << "outCount=" << DI->outCount << "\n";
> > - if (!PrintedDebugTree) {
> > - PrintedDebugTree = true;
> > - printDebugInfo(&(DI->BB->getParent()->getEntryBlock()));
> > - }
> > - }
> > -
> > - // This compares A and B for equality.
> > - static bool Equals(double A, double B) {
> > - return A == B;
> > - }
> > -
> > - // This checks if the function "exit" is reachable from an given
> function
> > - // via calls, this is necessary to check if a profile is valid
> despite the
> > - // counts not fitting exactly.
> > - template<class FType, class BType>
> > - bool ProfileVerifierPassT<FType, BType>::exitReachable(const FType
> *F) {
> > - if (!F) return false;
> > -
> > - if (FisVisited.count(F)) return false;
> > -
> > - FType *Exit = F->getParent()->getFunction("exit");
> > - if (Exit == F) {
> > - return true;
> > - }
> > -
> > - FisVisited.insert(F);
> > - bool exits = false;
> > - for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I !=
> E; ++I) {
> > - if (const CallInst *CI = dyn_cast<CallInst>(&*I)) {
> > - FType *F = CI->getCalledFunction();
> > - if (F) {
> > - exits |= exitReachable(F);
> > - } else {
> > - // This is a call to a pointer, all bets are off...
> > - exits = true;
> > - }
> > - if (exits) break;
> > - }
> > - }
> > - return exits;
> > - }
> > -
> > - #define ASSERTMESSAGE(M) \
> > - { dbgs() << "ASSERT:" << (M) << "\n"; \
> > - if (!DisableAssertions) assert(0 && (M)); }
> > -
> > - template<class FType, class BType>
> > - double ProfileVerifierPassT<FType, BType>::ReadOrAssert(typename
> ProfileInfoT<FType, BType>::Edge E) {
> > - double EdgeWeight = PI->getEdgeWeight(E);
> > - if (EdgeWeight == ProfileInfoT<FType, BType>::MissingValue) {
> > - dbgs() << "Edge " << E << " in Function "
> > - << ProfileInfoT<FType, BType>::getFunction(E)->getName()
> << ": ";
> > - ASSERTMESSAGE("Edge has missing value");
> > - return 0;
> > - } else {
> > - if (EdgeWeight < 0) {
> > - dbgs() << "Edge " << E << " in Function "
> > - << ProfileInfoT<FType, BType>::getFunction(E)->getName()
> << ": ";
> > - ASSERTMESSAGE("Edge has negative value");
> > - }
> > - return EdgeWeight;
> > - }
> > - }
> > -
> > - template<class FType, class BType>
> > - void ProfileVerifierPassT<FType, BType>::CheckValue(bool Error,
> > - const char
> *Message,
> > - DetailedBlockInfo
> *DI) {
> > - if (Error) {
> > - DEBUG(debugEntry(DI));
> > - dbgs() << "Block " << DI->BB->getName() << " in Function "
> > - << DI->BB->getParent()->getName() << ": ";
> > - ASSERTMESSAGE(Message);
> > - }
> > - return;
> > - }
> > -
> > - // This calculates the Information for a block and then recurses into
> the
> > - // successors.
> > - template<class FType, class BType>
> > - void ProfileVerifierPassT<FType, BType>::recurseBasicBlock(const
> BType *BB) {
> > -
> > - // Break the recursion by remembering all visited blocks.
> > - if (BBisVisited.find(BB) != BBisVisited.end()) return;
> > -
> > - // Use a data structure to store all the information, this can then
> be handed
> > - // to debug printers.
> > - DetailedBlockInfo DI;
> > - DI.BB = BB;
> > - DI.outCount = DI.inCount = 0;
> > - DI.inWeight = DI.outWeight = 0;
> > -
> > - // Read predecessors.
> > - std::set<const BType*> ProcessedPreds;
> > - const_pred_iterator bpi = pred_begin(BB), bpe = pred_end(BB);
> > - // If there are none, check for (0,BB) edge.
> > - if (bpi == bpe) {
> > - DI.inWeight += ReadOrAssert(PI->getEdge(0,BB));
> > - DI.inCount++;
> > - }
> > - for (;bpi != bpe; ++bpi) {
> > - if (ProcessedPreds.insert(*bpi).second) {
> > - DI.inWeight += ReadOrAssert(PI->getEdge(*bpi,BB));
> > - DI.inCount++;
> > - }
> > - }
> > -
> > - // Read successors.
> > - std::set<const BType*> ProcessedSuccs;
> > - succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - // If there is an (0,BB) edge, consider it too. (This is done not
> only when
> > - // there are no successors, but every time; not every function
> contains
> > - // return blocks with no successors (think loop latch as return
> block)).
> > - double w = PI->getEdgeWeight(PI->getEdge(BB,0));
> > - if (w != ProfileInfoT<FType, BType>::MissingValue) {
> > - DI.outWeight += w;
> > - DI.outCount++;
> > - }
> > - for (;bbi != bbe; ++bbi) {
> > - if (ProcessedSuccs.insert(*bbi).second) {
> > - DI.outWeight += ReadOrAssert(PI->getEdge(BB,*bbi));
> > - DI.outCount++;
> > - }
> > - }
> > -
> > - // Read block weight.
> > - DI.BBWeight = PI->getExecutionCount(BB);
> > - CheckValue(DI.BBWeight == ProfileInfoT<FType, BType>::MissingValue,
> > - "BasicBlock has missing value", &DI);
> > - CheckValue(DI.BBWeight < 0,
> > - "BasicBlock has negative value", &DI);
> > -
> > - // Check if this block is a setjmp target.
> > - bool isSetJmpTarget = false;
> > - if (DI.outWeight > DI.inWeight) {
> > - for (typename BType::const_iterator i = BB->begin(), ie =
> BB->end();
> > - i != ie; ++i) {
> > - if (const CallInst *CI = dyn_cast<CallInst>(&*i)) {
> > - FType *F = CI->getCalledFunction();
> > - if (F && (F->getName() == "_setjmp")) {
> > - isSetJmpTarget = true; break;
> > - }
> > - }
> > - }
> > - }
> > - // Check if this block is eventually reaching exit.
> > - bool isExitReachable = false;
> > - if (DI.inWeight > DI.outWeight) {
> > - for (typename BType::const_iterator i = BB->begin(), ie =
> BB->end();
> > - i != ie; ++i) {
> > - if (const CallInst *CI = dyn_cast<CallInst>(&*i)) {
> > - FType *F = CI->getCalledFunction();
> > - if (F) {
> > - FisVisited.clear();
> > - isExitReachable |= exitReachable(F);
> > - } else {
> > - // This is a call to a pointer, all bets are off...
> > - isExitReachable = true;
> > - }
> > - if (isExitReachable) break;
> > - }
> > - }
> > - }
> > -
> > - if (DI.inCount > 0 && DI.outCount == 0) {
> > - // If this is a block with no successors.
> > - if (!isSetJmpTarget) {
> > - CheckValue(!Equals(DI.inWeight,DI.BBWeight),
> > - "inWeight and BBWeight do not match", &DI);
> > - }
> > - } else if (DI.inCount == 0 && DI.outCount > 0) {
> > - // If this is a block with no predecessors.
> > - if (!isExitReachable)
> > - CheckValue(!Equals(DI.BBWeight,DI.outWeight),
> > - "BBWeight and outWeight do not match", &DI);
> > - } else {
> > - // If this block has successors and predecessors.
> > - if (DI.inWeight > DI.outWeight && !isExitReachable)
> > - CheckValue(!Equals(DI.inWeight,DI.outWeight),
> > - "inWeight and outWeight do not match", &DI);
> > - if (DI.inWeight < DI.outWeight && !isSetJmpTarget)
> > - CheckValue(!Equals(DI.inWeight,DI.outWeight),
> > - "inWeight and outWeight do not match", &DI);
> > - }
> > -
> > -
> > - // Mark this block as visited, rescurse into successors.
> > - BBisVisited.insert(BB);
> > - for ( succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
> > - bbi != bbe; ++bbi ) {
> > - recurseBasicBlock(*bbi);
> > - }
> > - }
> > -
> > - template<class FType, class BType>
> > - bool ProfileVerifierPassT<FType, BType>::runOnFunction(FType &F) {
> > - PI = getAnalysisIfAvailable<ProfileInfoT<FType, BType> >();
> > - if (!PI)
> > - ASSERTMESSAGE("No ProfileInfo available");
> > -
> > - // Prepare global variables.
> > - PrintedDebugTree = false;
> > - BBisVisited.clear();
> > -
> > - // Fetch entry block and recurse into it.
> > - const BType *entry = &F.getEntryBlock();
> > - recurseBasicBlock(entry);
> > -
> > - if (PI->getExecutionCount(&F) != PI->getExecutionCount(entry))
> > - ASSERTMESSAGE("Function count and entry block count do not
> match");
> > -
> > - return false;
> > - }
> > -
> > - template<class FType, class BType>
> > - char ProfileVerifierPassT<FType, BType>::ID = 0;
> > -}
> > -
> > -INITIALIZE_PASS_BEGIN(ProfileVerifierPass, "profile-verifier",
> > - "Verify profiling information", false, true)
> > -INITIALIZE_AG_DEPENDENCY(ProfileInfo)
> > -INITIALIZE_PASS_END(ProfileVerifierPass, "profile-verifier",
> > - "Verify profiling information", false, true)
> > -
> > -namespace llvm {
> > - FunctionPass *createProfileVerifierPass() {
> > - return new ProfileVerifierPass(ProfileVerifierDisableAssertions);
> > - }
> > -}
> > -
> >
> > Modified: llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp (original)
> > +++ llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp Wed Oct 2 10:42:23
> 2013
> > @@ -24,7 +24,6 @@
> > #include "llvm/ADT/DepthFirstIterator.h"
> > #include "llvm/ADT/SmallPtrSet.h"
> > #include "llvm/Analysis/Dominators.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > #include "llvm/CodeGen/MachineDominators.h"
> > #include "llvm/CodeGen/MachineFunctionPass.h"
> > #include "llvm/CodeGen/MachineLoopInfo.h"
> > @@ -50,7 +49,6 @@ namespace {
> >
> > virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > AU.addPreserved<DominatorTree>();
> > - AU.addPreserved<ProfileInfo>();
> > }
> > };
> > }
> > @@ -87,9 +85,7 @@ bool UnreachableBlockElim::runOnFunction
> > }
> >
> > // Actually remove the blocks now.
> > - ProfileInfo *PI = getAnalysisIfAvailable<ProfileInfo>();
> > for (unsigned i = 0, e = DeadBlocks.size(); i != e; ++i) {
> > - if (PI) PI->removeBlock(DeadBlocks[i]);
> > DeadBlocks[i]->eraseFromParent();
> > }
> >
> >
> > Modified: llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt (original)
> > +++ llvm/trunk/lib/Transforms/Instrumentation/CMakeLists.txt Wed Oct 2
> 10:42:23 2013
> > @@ -3,12 +3,9 @@ add_llvm_library(LLVMInstrumentation
> > BoundsChecking.cpp
> > DataFlowSanitizer.cpp
> > DebugIR.cpp
> > - EdgeProfiling.cpp
> > GCOVProfiling.cpp
> > MemorySanitizer.cpp
> > Instrumentation.cpp
> > - OptimalEdgeProfiling.cpp
> > - PathProfiling.cpp
> > ProfilingUtils.cpp
> > ThreadSanitizer.cpp
> > )
> >
> > Removed: llvm/trunk/lib/Transforms/Instrumentation/EdgeProfiling.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/EdgeProfiling.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Instrumentation/EdgeProfiling.cpp
> (original)
> > +++ llvm/trunk/lib/Transforms/Instrumentation/EdgeProfiling.cpp (removed)
> > @@ -1,117 +0,0 @@
> > -//===- EdgeProfiling.cpp - Insert counters for edge profiling
> -------------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This pass instruments the specified program with counters for edge
> profiling.
> > -// Edge profiling can give a reasonable approximation of the hot paths
> through a
> > -// program, and is used for a wide variety of program transformations.
> > -//
> > -// Note that this implementation is very naive. We insert a counter
> for *every*
> > -// edge in the program, instead of using control flow information to
> prune the
> > -// number of counters inserted.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "insert-edge-profiling"
> > -
> > -#include "llvm/Transforms/Instrumentation.h"
> > -#include "ProfilingUtils.h"
> > -#include "llvm/ADT/Statistic.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include "llvm/Transforms/Utils/BasicBlockUtils.h"
> > -#include <set>
> > -using namespace llvm;
> > -
> > -STATISTIC(NumEdgesInserted, "The # of edges inserted.");
> > -
> > -namespace {
> > - class EdgeProfiler : public ModulePass {
> > - bool runOnModule(Module &M);
> > - public:
> > - static char ID; // Pass identification, replacement for typeid
> > - EdgeProfiler() : ModulePass(ID) {
> > - initializeEdgeProfilerPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "Edge Profiler";
> > - }
> > - };
> > -}
> > -
> > -char EdgeProfiler::ID = 0;
> > -INITIALIZE_PASS(EdgeProfiler, "insert-edge-profiling",
> > - "Insert instrumentation for edge profiling", false,
> false)
> > -
> > -ModulePass *llvm::createEdgeProfilerPass() { return new EdgeProfiler();
> }
> > -
> > -bool EdgeProfiler::runOnModule(Module &M) {
> > - Function *Main = M.getFunction("main");
> > - if (Main == 0) {
> > - errs() << "WARNING: cannot insert edge profiling into a module"
> > - << " with no main function!\n";
> > - return false; // No main, no instrumentation!
> > - }
> > -
> > - std::set<BasicBlock*> BlocksToInstrument;
> > - unsigned NumEdges = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - // Reserve space for (0,entry) edge.
> > - ++NumEdges;
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - // Keep track of which blocks need to be instrumented. We don't
> want to
> > - // instrument blocks that are added as the result of breaking
> critical
> > - // edges!
> > - BlocksToInstrument.insert(BB);
> > - NumEdges += BB->getTerminator()->getNumSuccessors();
> > - }
> > - }
> > -
> > - Type *ATy = ArrayType::get(Type::getInt32Ty(M.getContext()),
> NumEdges);
> > - GlobalVariable *Counters =
> > - new GlobalVariable(M, ATy, false, GlobalValue::InternalLinkage,
> > - Constant::getNullValue(ATy), "EdgeProfCounters");
> > - NumEdgesInserted = NumEdges;
> > -
> > - // Instrument all of the edges...
> > - unsigned i = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - // Create counter for (0,entry) edge.
> > - IncrementCounterInBlock(&F->getEntryBlock(), i++, Counters);
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB)
> > - if (BlocksToInstrument.count(BB)) { // Don't instrument inserted
> blocks
> > - // Okay, we have to add a counter of each outgoing edge. If the
> > - // outgoing edge is not critical don't split it, just insert
> the counter
> > - // in the source or destination of the edge.
> > - TerminatorInst *TI = BB->getTerminator();
> > - for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
> > - // If the edge is critical, split it.
> > - SplitCriticalEdge(TI, s, this);
> > -
> > - // Okay, we are guaranteed that the edge is no longer
> critical. If we
> > - // only have a single successor, insert the counter in this
> block,
> > - // otherwise insert it in the successor block.
> > - if (TI->getNumSuccessors() == 1) {
> > - // Insert counter at the start of the block
> > - IncrementCounterInBlock(BB, i++, Counters, false);
> > - } else {
> > - // Insert counter at the start of the block
> > - IncrementCounterInBlock(TI->getSuccessor(s), i++, Counters);
> > - }
> > - }
> > - }
> > - }
> > -
> > - // Add the initialization call to main.
> > - InsertProfilingInitCall(Main, "llvm_start_edge_profiling", Counters);
> > - return true;
> > -}
> > -
> >
> > Modified: llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp
> (original)
> > +++ llvm/trunk/lib/Transforms/Instrumentation/Instrumentation.cpp Wed
> Oct 2 10:42:23 2013
> > @@ -24,10 +24,7 @@ void llvm::initializeInstrumentation(Pas
> > initializeAddressSanitizerPass(Registry);
> > initializeAddressSanitizerModulePass(Registry);
> > initializeBoundsCheckingPass(Registry);
> > - initializeEdgeProfilerPass(Registry);
> > initializeGCOVProfilerPass(Registry);
> > - initializeOptimalEdgeProfilerPass(Registry);
> > - initializePathProfilerPass(Registry);
> > initializeMemorySanitizerPass(Registry);
> > initializeThreadSanitizerPass(Registry);
> > initializeDataFlowSanitizerPass(Registry);
> >
> > Removed:
> llvm/trunk/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
> (original)
> > +++ llvm/trunk/lib/Transforms/Instrumentation/OptimalEdgeProfiling.cpp
> (removed)
> > @@ -1,225 +0,0 @@
> > -//===- OptimalEdgeProfiling.cpp - Insert counters for opt. edge
> profiling -===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This pass instruments the specified program with counters for edge
> profiling.
> > -// Edge profiling can give a reasonable approximation of the hot paths
> through a
> > -// program, and is used for a wide variety of program transformations.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "insert-optimal-edge-profiling"
> > -#include "llvm/Transforms/Instrumentation.h"
> > -#include "MaximumSpanningTree.h"
> > -#include "ProfilingUtils.h"
> > -#include "llvm/ADT/DenseSet.h"
> > -#include "llvm/ADT/Statistic.h"
> > -#include "llvm/Analysis/Passes.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > -#include "llvm/Analysis/ProfileInfoLoader.h"
> > -#include "llvm/IR/Constants.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include "llvm/Transforms/Utils/BasicBlockUtils.h"
> > -using namespace llvm;
> > -
> > -STATISTIC(NumEdgesInserted, "The # of edges inserted.");
> > -
> > -namespace {
> > - class OptimalEdgeProfiler : public ModulePass {
> > - bool runOnModule(Module &M);
> > - public:
> > - static char ID; // Pass identification, replacement for typeid
> > - OptimalEdgeProfiler() : ModulePass(ID) {
> > -
> initializeOptimalEdgeProfilerPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > - void getAnalysisUsage(AnalysisUsage &AU) const {
> > - AU.addRequiredID(ProfileEstimatorPassID);
> > - AU.addRequired<ProfileInfo>();
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "Optimal Edge Profiler";
> > - }
> > - };
> > -}
> > -
> > -char OptimalEdgeProfiler::ID = 0;
> > -INITIALIZE_PASS_BEGIN(OptimalEdgeProfiler,
> "insert-optimal-edge-profiling",
> > - "Insert optimal instrumentation for edge profiling",
> > - false, false)
> > -INITIALIZE_PASS_DEPENDENCY(ProfileEstimatorPass)
> > -INITIALIZE_AG_DEPENDENCY(ProfileInfo)
> > -INITIALIZE_PASS_END(OptimalEdgeProfiler,
> "insert-optimal-edge-profiling",
> > - "Insert optimal instrumentation for edge profiling",
> > - false, false)
> > -
> > -ModulePass *llvm::createOptimalEdgeProfilerPass() {
> > - return new OptimalEdgeProfiler();
> > -}
> > -
> > -inline static void printEdgeCounter(ProfileInfo::Edge e,
> > - BasicBlock* b,
> > - unsigned i) {
> > - DEBUG(dbgs() << "--Edge Counter for " << (e) << " in " \
> > - << ((b)?(b)->getName():"0") << " (# " << (i) << ")\n");
> > -}
> > -
> > -bool OptimalEdgeProfiler::runOnModule(Module &M) {
> > - Function *Main = M.getFunction("main");
> > - if (Main == 0) {
> > - errs() << "WARNING: cannot insert edge profiling into a module"
> > - << " with no main function!\n";
> > - return false; // No main, no instrumentation!
> > - }
> > -
> > - // NumEdges counts all the edges that may be instrumented. Later on
> its
> > - // decided which edges to actually instrument, to achieve optimal
> profiling.
> > - // For the entry block a virtual edge (0,entry) is reserved, for each
> block
> > - // with no successors an edge (BB,0) is reserved. These edges are
> necessary
> > - // to calculate a truly optimal maximum spanning tree and thus an
> optimal
> > - // instrumentation.
> > - unsigned NumEdges = 0;
> > -
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - // Reserve space for (0,entry) edge.
> > - ++NumEdges;
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - // Keep track of which blocks need to be instrumented. We don't
> want to
> > - // instrument blocks that are added as the result of breaking
> critical
> > - // edges!
> > - if (BB->getTerminator()->getNumSuccessors() == 0) {
> > - // Reserve space for (BB,0) edge.
> > - ++NumEdges;
> > - } else {
> > - NumEdges += BB->getTerminator()->getNumSuccessors();
> > - }
> > - }
> > - }
> > -
> > - // In the profiling output a counter for each edge is reserved, but
> only few
> > - // are used. This is done to be able to read back in the profile
> without
> > - // calulating the maximum spanning tree again, instead each edge
> counter that
> > - // is not used is initialised with -1 to signal that this edge
> counter has to
> > - // be calculated from other edge counters on reading the profile info
> back
> > - // in.
> > -
> > - Type *Int32 = Type::getInt32Ty(M.getContext());
> > - ArrayType *ATy = ArrayType::get(Int32, NumEdges);
> > - GlobalVariable *Counters =
> > - new GlobalVariable(M, ATy, false, GlobalValue::InternalLinkage,
> > - Constant::getNullValue(ATy),
> "OptEdgeProfCounters");
> > - NumEdgesInserted = 0;
> > -
> > - std::vector<Constant*> Initializer(NumEdges);
> > - Constant *Zero = ConstantInt::get(Int32, 0);
> > - Constant *Uncounted = ConstantInt::get(Int32,
> ProfileInfoLoader::Uncounted);
> > -
> > - // Instrument all of the edges not in MST...
> > - unsigned i = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
> > - if (F->isDeclaration()) continue;
> > - DEBUG(dbgs() << "Working on " << F->getName() << "\n");
> > -
> > - // Calculate a Maximum Spanning Tree with the edge weights
> determined by
> > - // ProfileEstimator. ProfileEstimator also assign weights to the
> virtual
> > - // edges (0,entry) and (BB,0) (for blocks with no successors) and
> this
> > - // edges also participate in the maximum spanning tree calculation.
> > - // The third parameter of MaximumSpanningTree() has the effect that
> not the
> > - // actual MST is returned but the edges _not_ in the MST.
> > -
> > - ProfileInfo::EdgeWeights ECs =
> > - getAnalysis<ProfileInfo>(*F).getEdgeWeights(F);
> > - std::vector<ProfileInfo::EdgeWeight> EdgeVector(ECs.begin(),
> ECs.end());
> > - MaximumSpanningTree<BasicBlock> MST(EdgeVector);
> > - std::stable_sort(MST.begin(), MST.end());
> > -
> > - // Check if (0,entry) not in the MST. If not, instrument edge
> > - // (IncrementCounterInBlock()) and set the counter initially to
> zero, if
> > - // the edge is in the MST the counter is initialised to -1.
> > -
> > - BasicBlock *entry = &(F->getEntryBlock());
> > - ProfileInfo::Edge edge = ProfileInfo::getEdge(0, entry);
> > - if (!std::binary_search(MST.begin(), MST.end(), edge)) {
> > - printEdgeCounter(edge, entry, i);
> > - IncrementCounterInBlock(entry, i, Counters); ++NumEdgesInserted;
> > - Initializer[i++] = (Zero);
> > - } else{
> > - Initializer[i++] = (Uncounted);
> > - }
> > -
> > - // InsertedBlocks contains all blocks that were inserted for
> splitting an
> > - // edge, this blocks do not have to be instrumented.
> > - DenseSet<BasicBlock*> InsertedBlocks;
> > - for (Function::iterator BB = F->begin(), E = F->end(); BB != E;
> ++BB) {
> > - // Check if block was not inserted and thus does not have to be
> > - // instrumented.
> > - if (InsertedBlocks.count(BB)) continue;
> > -
> > - // Okay, we have to add a counter of each outgoing edge not in
> MST. If
> > - // the outgoing edge is not critical don't split it, just insert
> the
> > - // counter in the source or destination of the edge. Also, if the
> block
> > - // has no successors, the virtual edge (BB,0) is processed.
> > - TerminatorInst *TI = BB->getTerminator();
> > - if (TI->getNumSuccessors() == 0) {
> > - ProfileInfo::Edge edge = ProfileInfo::getEdge(BB, 0);
> > - if (!std::binary_search(MST.begin(), MST.end(), edge)) {
> > - printEdgeCounter(edge, BB, i);
> > - IncrementCounterInBlock(BB, i, Counters); ++NumEdgesInserted;
> > - Initializer[i++] = (Zero);
> > - } else{
> > - Initializer[i++] = (Uncounted);
> > - }
> > - }
> > - for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
> > - BasicBlock *Succ = TI->getSuccessor(s);
> > - ProfileInfo::Edge edge = ProfileInfo::getEdge(BB,Succ);
> > - if (!std::binary_search(MST.begin(), MST.end(), edge)) {
> > -
> > - // If the edge is critical, split it.
> > - bool wasInserted = SplitCriticalEdge(TI, s, this);
> > - Succ = TI->getSuccessor(s);
> > - if (wasInserted)
> > - InsertedBlocks.insert(Succ);
> > -
> > - // Okay, we are guaranteed that the edge is no longer
> critical. If
> > - // we only have a single successor, insert the counter in
> this block,
> > - // otherwise insert it in the successor block.
> > - if (TI->getNumSuccessors() == 1) {
> > - // Insert counter at the start of the block
> > - printEdgeCounter(edge, BB, i);
> > - IncrementCounterInBlock(BB, i, Counters);
> ++NumEdgesInserted;
> > - } else {
> > - // Insert counter at the start of the block
> > - printEdgeCounter(edge, Succ, i);
> > - IncrementCounterInBlock(Succ, i, Counters);
> ++NumEdgesInserted;
> > - }
> > - Initializer[i++] = (Zero);
> > - } else {
> > - Initializer[i++] = (Uncounted);
> > - }
> > - }
> > - }
> > - }
> > -
> > - // Check if the number of edges counted at first was the number of
> edges we
> > - // considered for instrumentation.
> > - assert(i == NumEdges && "the number of edges in counting array is
> wrong");
> > -
> > - // Assign the now completely defined initialiser to the array.
> > - Constant *init = ConstantArray::get(ATy, Initializer);
> > - Counters->setInitializer(init);
> > -
> > - // Add the initialization call to main.
> > - InsertProfilingInitCall(Main, "llvm_start_opt_edge_profiling",
> Counters);
> > - return true;
> > -}
> > -
> >
> > Removed: llvm/trunk/lib/Transforms/Instrumentation/PathProfiling.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/PathProfiling.cpp?rev=191834&view=auto
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Instrumentation/PathProfiling.cpp
> (original)
> > +++ llvm/trunk/lib/Transforms/Instrumentation/PathProfiling.cpp (removed)
> > @@ -1,1424 +0,0 @@
> > -//===- PathProfiling.cpp - Inserts counters for path profiling
> ------------===//
> > -//
> > -// The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This pass instruments functions for Ball-Larus path profiling.
> Ball-Larus
> > -// profiling converts the CFG into a DAG by replacing backedges with
> edges
> > -// from entry to the start block and from the end block to exit. The
> paths
> > -// along the new DAG are enumrated, i.e. each path is given a path
> number.
> > -// Edges are instrumented to increment the path number register, such
> that the
> > -// path number register will equal the path number of the path taken at
> the
> > -// exit.
> > -//
> > -// This file defines classes for building a CFG for use with different
> stages
> > -// in the Ball-Larus path profiling instrumentation [Ball96]. The
> > -// requirements are formatting the llvm CFG into the Ball-Larus DAG,
> path
> > -// numbering, finding a spanning tree, moving increments from the
> spanning
> > -// tree to chords.
> > -//
> > -// Terms:
> > -// DAG - Directed Acyclic Graph.
> > -// Ball-Larus DAG - A CFG with an entry node, an exit node, and
> backedges
> > -// removed in the following manner. For every backedge
> > -// v->w, insert edge ENTRY->w and edge v->EXIT.
> > -// Path Number - The number corresponding to a specific path through
> a
> > -// Ball-Larus DAG.
> > -// Spanning Tree - A subgraph, S, is a spanning tree if S covers all
> > -// vertices and is a tree.
> > -// Chord - An edge not in the spanning tree.
> > -//
> > -// [Ball96]
> > -// T. Ball and J. R. Larus. "Efficient Path Profiling."
> > -// International Symposium on Microarchitecture, pages 46-57, 1996.
> > -// http://portal.acm.org/citation.cfm?id=243857
> > -//
> > -// [Ball94]
> > -// Thomas Ball. "Efficiently Counting Program Events with Support for
> > -// On-line queries."
> > -// ACM Transactions on Programmmg Languages and Systems, Vol 16, No 5,
> > -// September 1994, Pages 1399-1410.
> >
> -//===----------------------------------------------------------------------===//
> > -#define DEBUG_TYPE "insert-path-profiling"
> > -
> > -#include "llvm/Transforms/Instrumentation.h"
> > -#include "ProfilingUtils.h"
> > -#include "llvm/Analysis/PathNumbering.h"
> > -#include "llvm/IR/Constants.h"
> > -#include "llvm/IR/DerivedTypes.h"
> > -#include "llvm/IR/InstrTypes.h"
> > -#include "llvm/IR/Instructions.h"
> > -#include "llvm/IR/LLVMContext.h"
> > -#include "llvm/IR/Module.h"
> > -#include "llvm/IR/TypeBuilder.h"
> > -#include "llvm/Pass.h"
> > -#include "llvm/Support/CFG.h"
> > -#include "llvm/Support/CommandLine.h"
> > -#include "llvm/Support/Compiler.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include "llvm/Transforms/Utils/BasicBlockUtils.h"
> > -#include <vector>
> > -
> > -#define HASH_THRESHHOLD 100000
> > -
> > -using namespace llvm;
> > -
> > -namespace {
> > -class BLInstrumentationNode;
> > -class BLInstrumentationEdge;
> > -class BLInstrumentationDag;
> > -
> > -//
> ---------------------------------------------------------------------------
> > -// BLInstrumentationNode extends BallLarusNode with member used by the
> > -// instrumentation algortihms.
> > -//
> ---------------------------------------------------------------------------
> > -class BLInstrumentationNode : public BallLarusNode {
> > -public:
> > - // Creates a new BLInstrumentationNode from a BasicBlock.
> > - BLInstrumentationNode(BasicBlock* BB);
> > -
> > - // Get/sets the Value corresponding to the pathNumber register,
> > - // constant or phinode. Used by the instrumentation code to remember
> > - // path number Values.
> > - Value* getStartingPathNumber();
> > - void setStartingPathNumber(Value* pathNumber);
> > -
> > - Value* getEndingPathNumber();
> > - void setEndingPathNumber(Value* pathNumber);
> > -
> > - // Get/set the PHINode Instruction for this node.
> > - PHINode* getPathPHI();
> > - void setPathPHI(PHINode* pathPHI);
> > -
> > -private:
> > -
> > - Value* _startingPathNumber; // The Value for the current pathNumber.
> > - Value* _endingPathNumber; // The Value for the current pathNumber.
> > - PHINode* _pathPHI; // The PHINode for current pathNumber.
> > -};
> > -
> > -//
> --------------------------------------------------------------------------
> > -// BLInstrumentationEdge extends BallLarusEdge with data about the
> > -// instrumentation that will end up on each edge.
> > -//
> --------------------------------------------------------------------------
> > -class BLInstrumentationEdge : public BallLarusEdge {
> > -public:
> > - BLInstrumentationEdge(BLInstrumentationNode* source,
> > - BLInstrumentationNode* target);
> > -
> > - // Sets the target node of this edge. Required to split edges.
> > - void setTarget(BallLarusNode* node);
> > -
> > - // Get/set whether edge is in the spanning tree.
> > - bool isInSpanningTree() const;
> > - void setIsInSpanningTree(bool isInSpanningTree);
> > -
> > - // Get/ set whether this edge will be instrumented with a path number
> > - // initialization.
> > - bool isInitialization() const;
> > - void setIsInitialization(bool isInitialization);
> > -
> > - // Get/set whether this edge will be instrumented with a path counter
> > - // increment. Notice this is incrementing the path counter
> > - // corresponding to the path number register. The path number
> > - // increment is determined by getIncrement().
> > - bool isCounterIncrement() const;
> > - void setIsCounterIncrement(bool isCounterIncrement);
> > -
> > - // Get/set the path number increment that this edge will be
> instrumented
> > - // with. This is distinct from the path counter increment and the
> > - // weight. The counter increment counts the number of executions of
> > - // some path, whereas the path number keeps track of which path number
> > - // the program is on.
> > - long getIncrement() const;
> > - void setIncrement(long increment);
> > -
> > - // Get/set whether the edge has been instrumented.
> > - bool hasInstrumentation();
> > - void setHasInstrumentation(bool hasInstrumentation);
> > -
> > - // Returns the successor number of this edge in the source.
> > - unsigned getSuccessorNumber();
> > -
> > -private:
> > - // The increment that the code will be instrumented with.
> > - long long _increment;
> > -
> > - // Whether this edge is in the spanning tree.
> > - bool _isInSpanningTree;
> > -
> > - // Whether this edge is an initialiation of the path number.
> > - bool _isInitialization;
> > -
> > - // Whether this edge is a path counter increment.
> > - bool _isCounterIncrement;
> > -
> > - // Whether this edge has been instrumented.
> > - bool _hasInstrumentation;
> > -};
> > -
> > -//
> ---------------------------------------------------------------------------
> > -// BLInstrumentationDag extends BallLarusDag with algorithms that
> > -// determine where instrumentation should be placed.
> > -//
> ---------------------------------------------------------------------------
> > -class BLInstrumentationDag : public BallLarusDag {
> > -public:
> > - BLInstrumentationDag(Function &F);
> > -
> > - // Returns the Exit->Root edge. This edge is required for creating
> > - // directed cycles in the algorithm for moving instrumentation off of
> > - // the spanning tree
> > - BallLarusEdge* getExitRootEdge();
> > -
> > - // Returns an array of phony edges which mark those nodes
> > - // with function calls
> > - BLEdgeVector getCallPhonyEdges();
> > -
> > - // Gets/sets the path counter array
> > - GlobalVariable* getCounterArray();
> > - void setCounterArray(GlobalVariable* c);
> > -
> > - // Calculates the increments for the chords, thereby removing
> > - // instrumentation from the spanning tree edges. Implementation is
> based
> > - // on the algorithm in Figure 4 of [Ball94]
> > - void calculateChordIncrements();
> > -
> > - // Updates the state when an edge has been split
> > - void splitUpdate(BLInstrumentationEdge* formerEdge, BasicBlock*
> newBlock);
> > -
> > - // Calculates a spanning tree of the DAG ignoring cycles. Whichever
> > - // edges are in the spanning tree will not be instrumented, but this
> > - // implementation does not try to minimize the instrumentation
> overhead
> > - // by trying to find hot edges.
> > - void calculateSpanningTree();
> > -
> > - // Pushes initialization further down in order to group the first
> > - // increment and initialization.
> > - void pushInitialization();
> > -
> > - // Pushes the path counter increments up in order to group the last
> path
> > - // number increment.
> > - void pushCounters();
> > -
> > - // Removes phony edges from the successor list of the source, and the
> > - // predecessor list of the target.
> > - void unlinkPhony();
> > -
> > - // Generate dot graph for the function
> > - void generateDotGraph();
> > -
> > -protected:
> > - // BLInstrumentationDag creates BLInstrumentationNode objects in this
> > - // method overriding the creation of BallLarusNode objects.
> > - //
> > - // Allows subclasses to determine which type of Node is created.
> > - // Override this method to produce subclasses of BallLarusNode if
> > - // necessary.
> > - virtual BallLarusNode* createNode(BasicBlock* BB);
> > -
> > - // BLInstrumentationDag create BLInstrumentationEdges.
> > - //
> > - // Allows subclasses to determine which type of Edge is created.
> > - // Override this method to produce subclasses of BallLarusEdge if
> > - // necessary. Parameters source and target will have been created by
> > - // createNode and can be cast to the subclass of BallLarusNode*
> > - // returned by createNode.
> > - virtual BallLarusEdge* createEdge(
> > - BallLarusNode* source, BallLarusNode* target, unsigned edgeNumber);
> > -
> > -private:
> > - BLEdgeVector _treeEdges; // All edges in the spanning tree.
> > - BLEdgeVector _chordEdges; // All edges not in the spanning tree.
> > - GlobalVariable* _counterArray; // Array to store path counters
> > -
> > - // Removes the edge from the appropriate predecessor and successor
> lists.
> > - void unlinkEdge(BallLarusEdge* edge);
> > -
> > - // Makes an edge part of the spanning tree.
> > - void makeEdgeSpanning(BLInstrumentationEdge* edge);
> > -
> > - // Pushes initialization and calls itself recursively.
> > - void pushInitializationFromEdge(BLInstrumentationEdge* edge);
> > -
> > - // Pushes path counter increments up recursively.
> > - void pushCountersFromEdge(BLInstrumentationEdge* edge);
> > -
> > - // Depth first algorithm for determining the chord increments.f
> > - void calculateChordIncrementsDfs(
> > - long weight, BallLarusNode* v, BallLarusEdge* e);
> > -
> > - // Determines the relative direction of two edges.
> > - int calculateChordIncrementsDir(BallLarusEdge* e, BallLarusEdge* f);
> > -};
> > -
> > -//
> ---------------------------------------------------------------------------
> > -// PathProfiler is a module pass which instruments path profiling
> instructions
> > -//
> ---------------------------------------------------------------------------
> > -class PathProfiler : public ModulePass {
> > -private:
> > - // Current context for multi threading support.
> > - LLVMContext* Context;
> > -
> > - // Which function are we currently instrumenting
> > - unsigned currentFunctionNumber;
> > -
> > - // The function prototype in the profiling runtime for incrementing a
> > - // single path counter in a hash table.
> > - Constant* llvmIncrementHashFunction;
> > - Constant* llvmDecrementHashFunction;
> > -
> > - // Instruments each function with path profiling. 'main' is
> instrumented
> > - // with code to save the profile to disk.
> > - bool runOnModule(Module &M);
> > -
> > - // Analyzes the function for Ball-Larus path profiling, and inserts
> code.
> > - void runOnFunction(std::vector<Constant*> &ftInit, Function &F,
> Module &M);
> > -
> > - // Creates an increment constant representing incr.
> > - ConstantInt* createIncrementConstant(long incr, int bitsize);
> > -
> > - // Creates an increment constant representing the value in
> > - // edge->getIncrement().
> > - ConstantInt* createIncrementConstant(BLInstrumentationEdge* edge);
> > -
> > - // Finds the insertion point after pathNumber in block. PathNumber
> may
> > - // be NULL.
> > - BasicBlock::iterator getInsertionPoint(
> > - BasicBlock* block, Value* pathNumber);
> > -
> > - // Inserts source's pathNumber Value* into target. Target may or may
> not
> > - // have multiple predecessors, and may or may not have its phiNode
> > - // initalized.
> > - void pushValueIntoNode(
> > - BLInstrumentationNode* source, BLInstrumentationNode* target);
> > -
> > - // Inserts source's pathNumber Value* into the appropriate slot of
> > - // target's phiNode.
> > - void pushValueIntoPHI(
> > - BLInstrumentationNode* target, BLInstrumentationNode* source);
> > -
> > - // The Value* in node, oldVal, is updated with a Value*
> correspodning to
> > - // oldVal + addition.
> > - void insertNumberIncrement(BLInstrumentationNode* node, Value*
> addition,
> > - bool atBeginning);
> > -
> > - // Creates a counter increment in the given node. The Value* in node
> is
> > - // taken as the index into a hash table.
> > - void insertCounterIncrement(
> > - Value* incValue,
> > - BasicBlock::iterator insertPoint,
> > - BLInstrumentationDag* dag,
> > - bool increment = true);
> > -
> > - // A PHINode is created in the node, and its values initialized to
> -1U.
> > - void preparePHI(BLInstrumentationNode* node);
> > -
> > - // Inserts instrumentation for the given edge
> > - //
> > - // Pre: The edge's source node has pathNumber set if edge is non zero
> > - // path number increment.
> > - //
> > - // Post: Edge's target node has a pathNumber set to the path number
> Value
> > - // corresponding to the value of the path register after edge's
> > - // execution.
> > - void insertInstrumentationStartingAt(
> > - BLInstrumentationEdge* edge,
> > - BLInstrumentationDag* dag);
> > -
> > - // If this edge is a critical edge, then inserts a node at this edge.
> > - // This edge becomes the first edge, and a new BallLarusEdge is
> created.
> > - bool splitCritical(BLInstrumentationEdge* edge, BLInstrumentationDag*
> dag);
> > -
> > - // Inserts instrumentation according to the marked edges in dag.
> Phony
> > - // edges must be unlinked from the DAG, but accessible from the
> > - // backedges. Dag must have initializations, path number increments,
> and
> > - // counter increments present.
> > - //
> > - // Counter storage is created here.
> > - void insertInstrumentation( BLInstrumentationDag& dag, Module &M);
> > -
> > -public:
> > - static char ID; // Pass identification, replacement for typeid
> > - PathProfiler() : ModulePass(ID) {
> > - initializePathProfilerPass(*PassRegistry::getPassRegistry());
> > - }
> > -
> > - virtual const char *getPassName() const {
> > - return "Path Profiler";
> > - }
> > -};
> > -} // end anonymous namespace
> > -
> > -// Should we print the dot-graphs
> > -static cl::opt<bool> DotPathDag("path-profile-pathdag", cl::Hidden,
> > - cl::desc("Output the path profiling DAG for each function."));
> > -
> > -// Register the path profiler as a pass
> > -char PathProfiler::ID = 0;
> > -INITIALIZE_PASS(PathProfiler, "insert-path-profiling",
> > - "Insert instrumentation for Ball-Larus path profiling",
> > - false, false)
> > -
> > -ModulePass *llvm::createPathProfilerPass() { return new PathProfiler();
> }
> > -
> > -namespace llvm {
> > - class PathProfilingFunctionTable {};
> > -
> > - // Type for global array storing references to hashes or arrays
> > - template<bool xcompile> class TypeBuilder<PathProfilingFunctionTable,
> > - xcompile> {
> > - public:
> > - static StructType *get(LLVMContext& C) {
> > - return( StructType::get(
> > - TypeBuilder<types::i<32>, xcompile>::get(C), // type
> > - TypeBuilder<types::i<32>, xcompile>::get(C), // array
> size
> > - TypeBuilder<types::i<8>*, xcompile>::get(C), //
> array/hash ptr
> > - NULL));
> > - }
> > - };
> > -
> > - typedef TypeBuilder<PathProfilingFunctionTable, true>
> > - ftEntryTypeBuilder;
> > -
> > - // BallLarusEdge << operator overloading
> > - raw_ostream& operator<<(raw_ostream& os,
> > - const BLInstrumentationEdge& edge)
> > - LLVM_ATTRIBUTE_USED;
> > - raw_ostream& operator<<(raw_ostream& os,
> > - const BLInstrumentationEdge& edge) {
> > - os << "[" << edge.getSource()->getName() << " -> "
> > - << edge.getTarget()->getName() << "] init: "
> > - << (edge.isInitialization() ? "yes" : "no")
> > - << " incr:" << edge.getIncrement() << " cinc: "
> > - << (edge.isCounterIncrement() ? "yes" : "no");
> > - return(os);
> > - }
> > -}
> > -
> > -// Creates a new BLInstrumentationNode from a BasicBlock.
> > -BLInstrumentationNode::BLInstrumentationNode(BasicBlock* BB) :
> > - BallLarusNode(BB),
> > - _startingPathNumber(NULL), _endingPathNumber(NULL), _pathPHI(NULL) {}
> > -
> > -// Constructor for BLInstrumentationEdge.
> > -BLInstrumentationEdge::BLInstrumentationEdge(BLInstrumentationNode*
> source,
> > - BLInstrumentationNode*
> target)
> > - : BallLarusEdge(source, target, 0),
> > - _increment(0), _isInSpanningTree(false), _isInitialization(false),
> > - _isCounterIncrement(false), _hasInstrumentation(false) {}
> > -
> > -// Sets the target node of this edge. Required to split edges.
> > -void BLInstrumentationEdge::setTarget(BallLarusNode* node) {
> > - _target = node;
> > -}
> > -
> > -// Returns whether this edge is in the spanning tree.
> > -bool BLInstrumentationEdge::isInSpanningTree() const {
> > - return(_isInSpanningTree);
> > -}
> > -
> > -// Sets whether this edge is in the spanning tree.
> > -void BLInstrumentationEdge::setIsInSpanningTree(bool isInSpanningTree) {
> > - _isInSpanningTree = isInSpanningTree;
> > -}
> > -
> > -// Returns whether this edge will be instrumented with a path number
> > -// initialization.
> > -bool BLInstrumentationEdge::isInitialization() const {
> > - return(_isInitialization);
> > -}
> > -
> > -// Sets whether this edge will be instrumented with a path number
> > -// initialization.
> > -void BLInstrumentationEdge::setIsInitialization(bool isInitialization) {
> > - _isInitialization = isInitialization;
> > -}
> > -
> > -// Returns whether this edge will be instrumented with a path counter
> > -// increment. Notice this is incrementing the path counter
> > -// corresponding to the path number register. The path number
> > -// increment is determined by getIncrement().
> > -bool BLInstrumentationEdge::isCounterIncrement() const {
> > - return(_isCounterIncrement);
> > -}
> > -
> > -// Sets whether this edge will be instrumented with a path counter
> > -// increment.
> > -void BLInstrumentationEdge::setIsCounterIncrement(bool
> isCounterIncrement) {
> > - _isCounterIncrement = isCounterIncrement;
> > -}
> > -
> > -// Gets the path number increment that this edge will be instrumented
> > -// with. This is distinct from the path counter increment and the
> > -// weight. The counter increment is counts the number of executions of
> > -// some path, whereas the path number keeps track of which path number
> > -// the program is on.
> > -long BLInstrumentationEdge::getIncrement() const {
> > - return(_increment);
> > -}
> > -
> > -// Set whether this edge will be instrumented with a path number
> > -// increment.
> > -void BLInstrumentationEdge::setIncrement(long increment) {
> > - _increment = increment;
> > -}
> > -
> > -// True iff the edge has already been instrumented.
> > -bool BLInstrumentationEdge::hasInstrumentation() {
> > - return(_hasInstrumentation);
> > -}
> > -
> > -// Set whether this edge has been instrumented.
> > -void BLInstrumentationEdge::setHasInstrumentation(bool
> hasInstrumentation) {
> > - _hasInstrumentation = hasInstrumentation;
> > -}
> > -
> > -// Returns the successor number of this edge in the source.
> > -unsigned BLInstrumentationEdge::getSuccessorNumber() {
> > - BallLarusNode* sourceNode = getSource();
> > - BallLarusNode* targetNode = getTarget();
> > - BasicBlock* source = sourceNode->getBlock();
> > - BasicBlock* target = targetNode->getBlock();
> > -
> > - if(source == NULL || target == NULL)
> > - return(0);
> > -
> > - TerminatorInst* terminator = source->getTerminator();
> > -
> > - unsigned i;
> > - for(i=0; i < terminator->getNumSuccessors(); i++) {
> > - if(terminator->getSuccessor(i) == target)
> > - break;
> > - }
> > -
> > - return(i);
> > -}
> > -
> > -// BLInstrumentationDag constructor initializes a DAG for the given
> Function.
> > -BLInstrumentationDag::BLInstrumentationDag(Function &F) :
> BallLarusDag(F),
> > -
> _counterArray(0) {
> > -}
> > -
> > -// Returns the Exit->Root edge. This edge is required for creating
> > -// directed cycles in the algorithm for moving instrumentation off of
> > -// the spanning tree
> > -BallLarusEdge* BLInstrumentationDag::getExitRootEdge() {
> > - BLEdgeIterator erEdge = getExit()->succBegin();
> > - return(*erEdge);
> > -}
> > -
> > -BLEdgeVector BLInstrumentationDag::getCallPhonyEdges () {
> > - BLEdgeVector callEdges;
> > -
> > - for( BLEdgeIterator edge = _edges.begin(), end = _edges.end();
> > - edge != end; edge++ ) {
> > - if( (*edge)->getType() == BallLarusEdge::CALLEDGE_PHONY )
> > - callEdges.push_back(*edge);
> > - }
> > -
> > - return callEdges;
> > -}
> > -
> > -// Gets the path counter array
> > -GlobalVariable* BLInstrumentationDag::getCounterArray() {
> > - return _counterArray;
> > -}
> > -
> > -void BLInstrumentationDag::setCounterArray(GlobalVariable* c) {
> > - _counterArray = c;
> > -}
> > -
> > -// Calculates the increment for the chords, thereby removing
> > -// instrumentation from the spanning tree edges. Implementation is
> based on
> > -// the algorithm in Figure 4 of [Ball94]
> > -void BLInstrumentationDag::calculateChordIncrements() {
> > - calculateChordIncrementsDfs(0, getRoot(), NULL);
> > -
> > - BLInstrumentationEdge* chord;
> > - for(BLEdgeIterator chordEdge = _chordEdges.begin(),
> > - end = _chordEdges.end(); chordEdge != end; chordEdge++) {
> > - chord = (BLInstrumentationEdge*) *chordEdge;
> > - chord->setIncrement(chord->getIncrement() + chord->getWeight());
> > - }
> > -}
> > -
> > -// Updates the state when an edge has been split
> > -void BLInstrumentationDag::splitUpdate(BLInstrumentationEdge*
> formerEdge,
> > - BasicBlock* newBlock) {
> > - BallLarusNode* oldTarget = formerEdge->getTarget();
> > - BallLarusNode* newNode = addNode(newBlock);
> > - formerEdge->setTarget(newNode);
> > - newNode->addPredEdge(formerEdge);
> > -
> > - DEBUG(dbgs() << " Edge split: " << *formerEdge << "\n");
> > -
> > - oldTarget->removePredEdge(formerEdge);
> > - BallLarusEdge* newEdge = addEdge(newNode, oldTarget,0);
> > -
> > - if( formerEdge->getType() == BallLarusEdge::BACKEDGE ||
> > - formerEdge->getType() ==
> BallLarusEdge::SPLITEDGE) {
> > - newEdge->setType(formerEdge->getType());
> > - newEdge->setPhonyRoot(formerEdge->getPhonyRoot());
> > - newEdge->setPhonyExit(formerEdge->getPhonyExit());
> > - formerEdge->setType(BallLarusEdge::NORMAL);
> > - formerEdge->setPhonyRoot(NULL);
> > - formerEdge->setPhonyExit(NULL);
> > - }
> > -}
> > -
> > -// Calculates a spanning tree of the DAG ignoring cycles. Whichever
> > -// edges are in the spanning tree will not be instrumented, but this
> > -// implementation does not try to minimize the instrumentation overhead
> > -// by trying to find hot edges.
> > -void BLInstrumentationDag::calculateSpanningTree() {
> > - std::stack<BallLarusNode*> dfsStack;
> > -
> > - for(BLNodeIterator nodeIt = _nodes.begin(), end = _nodes.end();
> > - nodeIt != end; nodeIt++) {
> > - (*nodeIt)->setColor(BallLarusNode::WHITE);
> > - }
> > -
> > - dfsStack.push(getRoot());
> > - while(dfsStack.size() > 0) {
> > - BallLarusNode* node = dfsStack.top();
> > - dfsStack.pop();
> > -
> > - if(node->getColor() == BallLarusNode::WHITE)
> > - continue;
> > -
> > - BallLarusNode* nextNode;
> > - bool forward = true;
> > - BLEdgeIterator succEnd = node->succEnd();
> > -
> > - node->setColor(BallLarusNode::WHITE);
> > - // first iterate over successors then predecessors
> > - for(BLEdgeIterator edge = node->succBegin(), predEnd =
> node->predEnd();
> > - edge != predEnd; edge++) {
> > - if(edge == succEnd) {
> > - edge = node->predBegin();
> > - forward = false;
> > - }
> > -
> > - // Ignore split edges
> > - if ((*edge)->getType() == BallLarusEdge::SPLITEDGE)
> > - continue;
> > -
> > - nextNode = forward? (*edge)->getTarget(): (*edge)->getSource();
> > - if(nextNode->getColor() != BallLarusNode::WHITE) {
> > - nextNode->setColor(BallLarusNode::WHITE);
> > - makeEdgeSpanning((BLInstrumentationEdge*)(*edge));
> > - }
> > - }
> > - }
> > -
> > - for(BLEdgeIterator edge = _edges.begin(), end = _edges.end();
> > - edge != end; edge++) {
> > - BLInstrumentationEdge* instEdge = (BLInstrumentationEdge*) (*edge);
> > - // safe since createEdge is overriden
> > - if(!instEdge->isInSpanningTree() && (*edge)->getType()
> > - != BallLarusEdge::SPLITEDGE)
> > - _chordEdges.push_back(instEdge);
> > - }
> > -}
> > -
> > -// Pushes initialization further down in order to group the first
> > -// increment and initialization.
> > -void BLInstrumentationDag::pushInitialization() {
> > - BLInstrumentationEdge* exitRootEdge =
> > - (BLInstrumentationEdge*) getExitRootEdge();
> > - exitRootEdge->setIsInitialization(true);
> > - pushInitializationFromEdge(exitRootEdge);
> > -}
> > -
> > -// Pushes the path counter increments up in order to group the last path
> > -// number increment.
> > -void BLInstrumentationDag::pushCounters() {
> > - BLInstrumentationEdge* exitRootEdge =
> > - (BLInstrumentationEdge*) getExitRootEdge();
> > - exitRootEdge->setIsCounterIncrement(true);
> > - pushCountersFromEdge(exitRootEdge);
> > -}
> > -
> > -// Removes phony edges from the successor list of the source, and the
> > -// predecessor list of the target.
> > -void BLInstrumentationDag::unlinkPhony() {
> > - BallLarusEdge* edge;
> > -
> > - for(BLEdgeIterator next = _edges.begin(),
> > - end = _edges.end(); next != end; next++) {
> > - edge = (*next);
> > -
> > - if( edge->getType() == BallLarusEdge::BACKEDGE_PHONY ||
> > - edge->getType() == BallLarusEdge::SPLITEDGE_PHONY ||
> > - edge->getType() == BallLarusEdge::CALLEDGE_PHONY ) {
> > - unlinkEdge(edge);
> > - }
> > - }
> > -}
> > -
> > -// Generate a .dot graph to represent the DAG and pathNumbers
> > -void BLInstrumentationDag::generateDotGraph() {
> > - std::string errorInfo;
> > - std::string functionName = getFunction().getName().str();
> > - std::string filename = "pathdag." + functionName + ".dot";
> > -
> > - DEBUG (dbgs() << "Writing '" << filename << "'...\n");
> > - raw_fd_ostream dotFile(filename.c_str(), errorInfo);
> > -
> > - if (!errorInfo.empty()) {
> > - errs() << "Error opening '" << filename.c_str() <<"' for writing!";
> > - errs() << "\n";
> > - return;
> > - }
> > -
> > - dotFile << "digraph " << functionName << " {\n";
> > -
> > - for( BLEdgeIterator edge = _edges.begin(), end = _edges.end();
> > - edge != end; edge++) {
> > - std::string sourceName = (*edge)->getSource()->getName();
> > - std::string targetName = (*edge)->getTarget()->getName();
> > -
> > - dotFile << "\t\"" << sourceName.c_str() << "\" -> \""
> > - << targetName.c_str() << "\" ";
> > -
> > - long inc = ((BLInstrumentationEdge*)(*edge))->getIncrement();
> > -
> > - switch( (*edge)->getType() ) {
> > - case BallLarusEdge::NORMAL:
> > - dotFile << "[label=" << inc << "] [color=black];\n";
> > - break;
> > -
> > - case BallLarusEdge::BACKEDGE:
> > - dotFile << "[color=cyan];\n";
> > - break;
> > -
> > - case BallLarusEdge::BACKEDGE_PHONY:
> > - dotFile << "[label=" << inc
> > - << "] [color=blue];\n";
> > - break;
> > -
> > - case BallLarusEdge::SPLITEDGE:
> > - dotFile << "[color=violet];\n";
> > - break;
> > -
> > - case BallLarusEdge::SPLITEDGE_PHONY:
> > - dotFile << "[label=" << inc << "] [color=red];\n";
> > - break;
> > -
> > - case BallLarusEdge::CALLEDGE_PHONY:
> > - dotFile << "[label=" << inc << "] [color=green];\n";
> > - break;
> > - }
> > - }
> > -
> > - dotFile << "}\n";
> > -}
> > -
> > -// Allows subclasses to determine which type of Node is created.
> > -// Override this method to produce subclasses of BallLarusNode if
> > -// necessary. The destructor of BallLarusDag will call free on each
> pointer
> > -// created.
> > -BallLarusNode* BLInstrumentationDag::createNode(BasicBlock* BB) {
> > - return( new BLInstrumentationNode(BB) );
> > -}
> > -
> > -// Allows subclasses to determine which type of Edge is created.
> > -// Override this method to produce subclasses of BallLarusEdge if
> > -// necessary. The destructor of BallLarusDag will call free on each
> pointer
> > -// created.
> > -BallLarusEdge* BLInstrumentationDag::createEdge(BallLarusNode* source,
> > - BallLarusNode* target,
> unsigned edgeNumber) {
> > - // One can cast from BallLarusNode to BLInstrumentationNode since
> createNode
> > - // is overriden to produce BLInstrumentationNode.
> > - return( new BLInstrumentationEdge((BLInstrumentationNode*)source,
> > - (BLInstrumentationNode*)target) );
> > -}
> > -
> > -// Sets the Value corresponding to the pathNumber register, constant,
> > -// or phinode. Used by the instrumentation code to remember path
> > -// number Values.
> > -Value* BLInstrumentationNode::getStartingPathNumber(){
> > - return(_startingPathNumber);
> > -}
> > -
> > -// Sets the Value of the pathNumber. Used by the instrumentation code.
> > -void BLInstrumentationNode::setStartingPathNumber(Value* pathNumber) {
> > - DEBUG(dbgs() << " SPN-" << getName() << " <-- " << (pathNumber ?
> > -
> pathNumber->getName() :
> > - "unused") <<
> "\n");
> > - _startingPathNumber = pathNumber;
> > -}
> > -
> > -Value* BLInstrumentationNode::getEndingPathNumber(){
> > - return(_endingPathNumber);
> > -}
> > -
> > -void BLInstrumentationNode::setEndingPathNumber(Value* pathNumber) {
> > - DEBUG(dbgs() << " EPN-" << getName() << " <-- "
> > - << (pathNumber ? pathNumber->getName() : "unused") <<
> "\n");
> > - _endingPathNumber = pathNumber;
> > -}
> > -
> > -// Get the PHINode Instruction for this node. Used by instrumentation
> > -// code.
> > -PHINode* BLInstrumentationNode::getPathPHI() {
> > - return(_pathPHI);
> > -}
> > -
> > -// Set the PHINode Instruction for this node. Used by instrumentation
> > -// code.
> > -void BLInstrumentationNode::setPathPHI(PHINode* pathPHI) {
> > - _pathPHI = pathPHI;
> > -}
> > -
> > -// Removes the edge from the appropriate predecessor and successor
> > -// lists.
> > -void BLInstrumentationDag::unlinkEdge(BallLarusEdge* edge) {
> > - if(edge == getExitRootEdge())
> > - DEBUG(dbgs() << " Removing exit->root edge\n");
> > -
> > - edge->getSource()->removeSuccEdge(edge);
> > - edge->getTarget()->removePredEdge(edge);
> > -}
> > -
> > -// Makes an edge part of the spanning tree.
> > -void BLInstrumentationDag::makeEdgeSpanning(BLInstrumentationEdge*
> edge) {
> > - edge->setIsInSpanningTree(true);
> > - _treeEdges.push_back(edge);
> > -}
> > -
> > -// Pushes initialization and calls itself recursively.
> > -void BLInstrumentationDag::pushInitializationFromEdge(
> > - BLInstrumentationEdge* edge) {
> > - BallLarusNode* target;
> > -
> > - target = edge->getTarget();
> > - if( target->getNumberPredEdges() > 1 || target == getExit() ) {
> > - return;
> > - } else {
> > - for(BLEdgeIterator next = target->succBegin(),
> > - end = target->succEnd(); next != end; next++) {
> > - BLInstrumentationEdge* intoEdge = (BLInstrumentationEdge*) *next;
> > -
> > - // Skip split edges
> > - if (intoEdge->getType() == BallLarusEdge::SPLITEDGE)
> > - continue;
> > -
> > - intoEdge->setIncrement(intoEdge->getIncrement() +
> > - edge->getIncrement());
> > - intoEdge->setIsInitialization(true);
> > - pushInitializationFromEdge(intoEdge);
> > - }
> > -
> > - edge->setIncrement(0);
> > - edge->setIsInitialization(false);
> > - }
> > -}
> > -
> > -// Pushes path counter increments up recursively.
> > -void BLInstrumentationDag::pushCountersFromEdge(BLInstrumentationEdge*
> edge) {
> > - BallLarusNode* source;
> > -
> > - source = edge->getSource();
> > - if(source->getNumberSuccEdges() > 1 || source == getRoot()
> > - || edge->isInitialization()) {
> > - return;
> > - } else {
> > - for(BLEdgeIterator previous = source->predBegin(),
> > - end = source->predEnd(); previous != end; previous++) {
> > - BLInstrumentationEdge* fromEdge = (BLInstrumentationEdge*)
> *previous;
> > -
> > - // Skip split edges
> > - if (fromEdge->getType() == BallLarusEdge::SPLITEDGE)
> > - continue;
> > -
> > - fromEdge->setIncrement(fromEdge->getIncrement() +
> > - edge->getIncrement());
> > - fromEdge->setIsCounterIncrement(true);
> > - pushCountersFromEdge(fromEdge);
> > - }
> > -
> > - edge->setIncrement(0);
> > - edge->setIsCounterIncrement(false);
> > - }
> > -}
> > -
> > -// Depth first algorithm for determining the chord increments.
> > -void BLInstrumentationDag::calculateChordIncrementsDfs(long weight,
> > - BallLarusNode*
> v, BallLarusEdge* e) {
> > - BLInstrumentationEdge* f;
> > -
> > - for(BLEdgeIterator treeEdge = _treeEdges.begin(),
> > - end = _treeEdges.end(); treeEdge != end; treeEdge++) {
> > - f = (BLInstrumentationEdge*) *treeEdge;
> > - if(e != f && v == f->getTarget()) {
> > - calculateChordIncrementsDfs(
> > - calculateChordIncrementsDir(e,f)*(weight) +
> > - f->getWeight(), f->getSource(), f);
> > - }
> > - if(e != f && v == f->getSource()) {
> > - calculateChordIncrementsDfs(
> > - calculateChordIncrementsDir(e,f)*(weight) +
> > - f->getWeight(), f->getTarget(), f);
> > - }
> > - }
> > -
> > - for(BLEdgeIterator chordEdge = _chordEdges.begin(),
> > - end = _chordEdges.end(); chordEdge != end; chordEdge++) {
> > - f = (BLInstrumentationEdge*) *chordEdge;
> > - if(v == f->getSource() || v == f->getTarget()) {
> > - f->setIncrement(f->getIncrement() +
> > - calculateChordIncrementsDir(e,f)*weight);
> > - }
> > - }
> > -}
> > -
> > -// Determines the relative direction of two edges.
> > -int BLInstrumentationDag::calculateChordIncrementsDir(BallLarusEdge* e,
> > - BallLarusEdge* f)
> {
> > - if( e == NULL)
> > - return(1);
> > - else if(e->getSource() == f->getTarget()
> > - || e->getTarget() == f->getSource())
> > - return(1);
> > -
> > - return(-1);
> > -}
> > -
> > -// Creates an increment constant representing incr.
> > -ConstantInt* PathProfiler::createIncrementConstant(long incr,
> > - int bitsize) {
> > - return(ConstantInt::get(IntegerType::get(*Context, 32), incr));
> > -}
> > -
> > -// Creates an increment constant representing the value in
> > -// edge->getIncrement().
> > -ConstantInt* PathProfiler::createIncrementConstant(
> > - BLInstrumentationEdge* edge) {
> > - return(createIncrementConstant(edge->getIncrement(), 32));
> > -}
> > -
> > -// Finds the insertion point after pathNumber in block. PathNumber may
> > -// be NULL.
> > -BasicBlock::iterator PathProfiler::getInsertionPoint(BasicBlock* block,
> Value*
> > - pathNumber) {
> > - if(pathNumber == NULL || isa<ConstantInt>(pathNumber)
> > - || (((Instruction*)(pathNumber))->getParent()) != block) {
> > - return(block->getFirstInsertionPt());
> > - } else {
> > - Instruction* pathNumberInst = (Instruction*) (pathNumber);
> > - BasicBlock::iterator insertPoint;
> > - BasicBlock::iterator end = block->end();
> > -
> > - for(insertPoint = block->begin();
> > - insertPoint != end; insertPoint++) {
> > - Instruction* insertInst = &(*insertPoint);
> > -
> > - if(insertInst == pathNumberInst)
> > - return(++insertPoint);
> > - }
> > -
> > - return(insertPoint);
> > - }
> > -}
> > -
> > -// A PHINode is created in the node, and its values initialized to -1U.
> > -void PathProfiler::preparePHI(BLInstrumentationNode* node) {
> > - BasicBlock* block = node->getBlock();
> > - BasicBlock::iterator insertPoint = block->getFirstInsertionPt();
> > - pred_iterator PB = pred_begin(node->getBlock()),
> > - PE = pred_end(node->getBlock());
> > - PHINode* phi = PHINode::Create(Type::getInt32Ty(*Context),
> > - std::distance(PB, PE), "pathNumber",
> > - insertPoint );
> > - node->setPathPHI(phi);
> > - node->setStartingPathNumber(phi);
> > - node->setEndingPathNumber(phi);
> > -
> > - for(pred_iterator predIt = PB; predIt != PE; predIt++) {
> > - BasicBlock* pred = (*predIt);
> > -
> > - if(pred != NULL)
> > - phi->addIncoming(createIncrementConstant((long)-1, 32), pred);
> > - }
> > -}
> > -
> > -// Inserts source's pathNumber Value* into target. Target may or may
> not
> > -// have multiple predecessors, and may or may not have its phiNode
> > -// initalized.
> > -void PathProfiler::pushValueIntoNode(BLInstrumentationNode* source,
> > - BLInstrumentationNode* target) {
> > - if(target->getBlock() == NULL)
> > - return;
> > -
> > -
> > - if(target->getNumberPredEdges() <= 1) {
> > - assert(target->getStartingPathNumber() == NULL &&
> > - "Target already has path number");
> > - target->setStartingPathNumber(source->getEndingPathNumber());
> > - target->setEndingPathNumber(source->getEndingPathNumber());
> > - DEBUG(dbgs() << " Passing path number"
> > - << (source->getEndingPathNumber() ? "" : " (null)")
> > - << " value through.\n");
> > - } else {
> > - if(target->getPathPHI() == NULL) {
> > - DEBUG(dbgs() << " Initializing PHI node for block '"
> > - << target->getName() << "'\n");
> > - preparePHI(target);
> > - }
> > - pushValueIntoPHI(target, source);
> > - DEBUG(dbgs() << " Passing number value into PHI for block '"
> > - << target->getName() << "'\n");
> > - }
> > -}
> > -
> > -// Inserts source's pathNumber Value* into the appropriate slot of
> > -// target's phiNode.
> > -void PathProfiler::pushValueIntoPHI(BLInstrumentationNode* target,
> > - BLInstrumentationNode* source) {
> > - PHINode* phi = target->getPathPHI();
> > - assert(phi != NULL && " Tried to push value into node with PHI, but
> node"
> > - " actually had no PHI.");
> > - phi->removeIncomingValue(source->getBlock(), false);
> > - phi->addIncoming(source->getEndingPathNumber(), source->getBlock());
> > -}
> > -
> > -// The Value* in node, oldVal, is updated with a Value* correspodning
> to
> > -// oldVal + addition.
> > -void PathProfiler::insertNumberIncrement(BLInstrumentationNode* node,
> > - Value* addition, bool
> atBeginning) {
> > - BasicBlock* block = node->getBlock();
> > - assert(node->getStartingPathNumber() != NULL);
> > - assert(node->getEndingPathNumber() != NULL);
> > -
> > - BasicBlock::iterator insertPoint;
> > -
> > - if( atBeginning )
> > - insertPoint = block->getFirstInsertionPt();
> > - else
> > - insertPoint = block->getTerminator();
> > -
> > - DEBUG(errs() << " Creating addition instruction.\n");
> > - Value* newpn = BinaryOperator::Create(Instruction::Add,
> > - node->getStartingPathNumber(),
> > - addition, "pathNumber",
> insertPoint);
> > -
> > - node->setEndingPathNumber(newpn);
> > -
> > - if( atBeginning )
> > - node->setStartingPathNumber(newpn);
> > -}
> > -
> > -// Creates a counter increment in the given node. The Value* in node is
> > -// taken as the index into an array or hash table. The hash table
> access
> > -// is a call to the runtime.
> > -void PathProfiler::insertCounterIncrement(Value* incValue,
> > - BasicBlock::iterator
> insertPoint,
> > - BLInstrumentationDag* dag,
> > - bool increment) {
> > - // Counter increment for array
> > - if( dag->getNumberOfPaths() <= HASH_THRESHHOLD ) {
> > - // Get pointer to the array location
> > - std::vector<Value*> gepIndices(2);
> > - gepIndices[0] = Constant::getNullValue(Type::getInt32Ty(*Context));
> > - gepIndices[1] = incValue;
> > -
> > - GetElementPtrInst* pcPointer =
> > - GetElementPtrInst::Create(dag->getCounterArray(), gepIndices,
> > - "counterInc", insertPoint);
> > -
> > - // Load from the array - call it oldPC
> > - LoadInst* oldPc = new LoadInst(pcPointer, "oldPC", insertPoint);
> > -
> > - // Test to see whether adding 1 will overflow the counter
> > - ICmpInst* isMax = new ICmpInst(insertPoint, CmpInst::ICMP_ULT,
> oldPc,
> > - createIncrementConstant(0xffffffff,
> 32),
> > - "isMax");
> > -
> > - // Select increment for the path counter based on overflow
> > - SelectInst* inc =
> > - SelectInst::Create( isMax,
> createIncrementConstant(increment?1:-1,32),
> > - createIncrementConstant(0,32),
> > - "pathInc", insertPoint);
> > -
> > - // newPc = oldPc + inc
> > - BinaryOperator* newPc = BinaryOperator::Create(Instruction::Add,
> > - oldPc, inc, "newPC",
> > - insertPoint);
> > -
> > - // Store back in to the array
> > - new StoreInst(newPc, pcPointer, insertPoint);
> > - } else { // Counter increment for hash
> > - std::vector<Value*> args(2);
> > - args[0] = ConstantInt::get(Type::getInt32Ty(*Context),
> > - currentFunctionNumber);
> > - args[1] = incValue;
> > -
> > - CallInst::Create(
> > - increment ? llvmIncrementHashFunction : llvmDecrementHashFunction,
> > - args, "", insertPoint);
> > - }
> > -}
> > -
> > -// Inserts instrumentation for the given edge
> > -//
> > -// Pre: The edge's source node has pathNumber set if edge is non zero
> > -// path number increment.
> > -//
> > -// Post: Edge's target node has a pathNumber set to the path number
> Value
> > -// corresponding to the value of the path register after edge's
> > -// execution.
> > -//
> > -// FIXME: This should be reworked so it's not recursive.
> > -void
> PathProfiler::insertInstrumentationStartingAt(BLInstrumentationEdge* edge,
> > -
> BLInstrumentationDag* dag) {
> > - // Mark the edge as instrumented
> > - edge->setHasInstrumentation(true);
> > - DEBUG(dbgs() << "\nInstrumenting edge: " << (*edge) << "\n");
> > -
> > - // create a new node for this edge's instrumentation
> > - splitCritical(edge, dag);
> > -
> > - BLInstrumentationNode* sourceNode =
> (BLInstrumentationNode*)edge->getSource();
> > - BLInstrumentationNode* targetNode =
> (BLInstrumentationNode*)edge->getTarget();
> > - BLInstrumentationNode* instrumentNode;
> > - BLInstrumentationNode* nextSourceNode;
> > -
> > - bool atBeginning = false;
> > -
> > - // Source node has only 1 successor so any information can be simply
> > - // inserted in to it without splitting
> > - if( sourceNode->getBlock() && sourceNode->getNumberSuccEdges() <= 1) {
> > - DEBUG(dbgs() << " Potential instructions to be placed in: "
> > - << sourceNode->getName() << " (at end)\n");
> > - instrumentNode = sourceNode;
> > - nextSourceNode = targetNode; // ... since we never made any new
> nodes
> > - }
> > -
> > - // The target node only has one predecessor, so we can safely insert
> edge
> > - // instrumentation into it. If there was splitting, it must have been
> > - // successful.
> > - else if( targetNode->getNumberPredEdges() == 1 ) {
> > - DEBUG(dbgs() << " Potential instructions to be placed in: "
> > - << targetNode->getName() << " (at beginning)\n");
> > - pushValueIntoNode(sourceNode, targetNode);
> > - instrumentNode = targetNode;
> > - nextSourceNode = NULL; // ... otherwise we'll just keep splitting
> > - atBeginning = true;
> > - }
> > -
> > - // Somehow, splitting must have failed.
> > - else {
> > - errs() << "Instrumenting could not split a critical edge.\n";
> > - DEBUG(dbgs() << " Couldn't split edge " << (*edge) << ".\n");
> > - return;
> > - }
> > -
> > - // Insert instrumentation if this is a back or split edge
> > - if( edge->getType() == BallLarusEdge::BACKEDGE ||
> > - edge->getType() == BallLarusEdge::SPLITEDGE ) {
> > - BLInstrumentationEdge* top =
> > - (BLInstrumentationEdge*) edge->getPhonyRoot();
> > - BLInstrumentationEdge* bottom =
> > - (BLInstrumentationEdge*) edge->getPhonyExit();
> > -
> > - assert( top->isInitialization() && " Top phony edge did not"
> > - " contain a path number initialization.");
> > - assert( bottom->isCounterIncrement() && " Bottom phony edge"
> > - " did not contain a path counter increment.");
> > -
> > - // split edge has yet to be initialized
> > - if( !instrumentNode->getEndingPathNumber() ) {
> > -
> instrumentNode->setStartingPathNumber(createIncrementConstant(0,32));
> > -
> instrumentNode->setEndingPathNumber(createIncrementConstant(0,32));
> > - }
> > -
> > - BasicBlock::iterator insertPoint = atBeginning ?
> > - instrumentNode->getBlock()->getFirstInsertionPt() :
> > - instrumentNode->getBlock()->getTerminator();
> > -
> > - // add information from the bottom edge, if it exists
> > - if( bottom->getIncrement() ) {
> > - Value* newpn =
> > - BinaryOperator::Create(Instruction::Add,
> > - instrumentNode->getStartingPathNumber(),
> > - createIncrementConstant(bottom),
> > - "pathNumber", insertPoint);
> > - instrumentNode->setEndingPathNumber(newpn);
> > - }
> > -
> > - insertCounterIncrement(instrumentNode->getEndingPathNumber(),
> > - insertPoint, dag);
> > -
> > - if( atBeginning )
> > -
> instrumentNode->setStartingPathNumber(createIncrementConstant(top));
> > -
> > - instrumentNode->setEndingPathNumber(createIncrementConstant(top));
> > -
> > - // Check for path counter increments
> > - if( top->isCounterIncrement() ) {
> > - insertCounterIncrement(instrumentNode->getEndingPathNumber(),
> > -
> instrumentNode->getBlock()->getTerminator(),dag);
> > - instrumentNode->setEndingPathNumber(0);
> > - }
> > - }
> > -
> > - // Insert instrumentation if this is a normal edge
> > - else {
> > - BasicBlock::iterator insertPoint = atBeginning ?
> > - instrumentNode->getBlock()->getFirstInsertionPt() :
> > - instrumentNode->getBlock()->getTerminator();
> > -
> > - if( edge->isInitialization() ) { // initialize path number
> > -
> instrumentNode->setEndingPathNumber(createIncrementConstant(edge));
> > - } else if( edge->getIncrement() ) {// increment path number
> > - Value* newpn =
> > - BinaryOperator::Create(Instruction::Add,
> > - instrumentNode->getStartingPathNumber(),
> > - createIncrementConstant(edge),
> > - "pathNumber", insertPoint);
> > - instrumentNode->setEndingPathNumber(newpn);
> > -
> > - if( atBeginning )
> > - instrumentNode->setStartingPathNumber(newpn);
> > - }
> > -
> > - // Check for path counter increments
> > - if( edge->isCounterIncrement() ) {
> > - insertCounterIncrement(instrumentNode->getEndingPathNumber(),
> > - insertPoint, dag);
> > - instrumentNode->setEndingPathNumber(0);
> > - }
> > - }
> > -
> > - // Push it along
> > - if (nextSourceNode && instrumentNode->getEndingPathNumber())
> > - pushValueIntoNode(instrumentNode, nextSourceNode);
> > -
> > - // Add all the successors
> > - for( BLEdgeIterator next = targetNode->succBegin(),
> > - end = targetNode->succEnd(); next != end; next++ ) {
> > - // So long as it is un-instrumented, add it to the list
> > - if( !((BLInstrumentationEdge*)(*next))->hasInstrumentation() )
> > -
> insertInstrumentationStartingAt((BLInstrumentationEdge*)*next,dag);
> > - else
> > - DEBUG(dbgs() << " Edge " << *(BLInstrumentationEdge*)(*next)
> > - << " already instrumented.\n");
> > - }
> > -}
> > -
> > -// Inserts instrumentation according to the marked edges in dag. Phony
> edges
> > -// must be unlinked from the DAG, but accessible from the backedges.
> Dag
> > -// must have initializations, path number increments, and counter
> increments
> > -// present.
> > -//
> > -// Counter storage is created here.
> > -void PathProfiler::insertInstrumentation(
> > - BLInstrumentationDag& dag, Module &M) {
> > -
> > - BLInstrumentationEdge* exitRootEdge =
> > - (BLInstrumentationEdge*) dag.getExitRootEdge();
> > - insertInstrumentationStartingAt(exitRootEdge, &dag);
> > -
> > - // Iterate through each call edge and apply the appropriate hash
> increment
> > - // and decrement functions
> > - BLEdgeVector callEdges = dag.getCallPhonyEdges();
> > - for( BLEdgeIterator edge = callEdges.begin(),
> > - end = callEdges.end(); edge != end; edge++ ) {
> > - BLInstrumentationNode* node =
> > - (BLInstrumentationNode*)(*edge)->getSource();
> > - BasicBlock::iterator insertPoint =
> node->getBlock()->getFirstInsertionPt();
> > -
> > - // Find the first function call
> > - while( ((Instruction&)(*insertPoint)).getOpcode() !=
> Instruction::Call )
> > - insertPoint++;
> > -
> > - DEBUG(dbgs() << "\nInstrumenting method call block '"
> > - << node->getBlock()->getName() << "'\n");
> > - DEBUG(dbgs() << " Path number initialized: "
> > - << ((node->getStartingPathNumber()) ? "yes" : "no") <<
> "\n");
> > -
> > - Value* newpn;
> > - if( node->getStartingPathNumber() ) {
> > - long inc = ((BLInstrumentationEdge*)(*edge))->getIncrement();
> > - if ( inc )
> > - newpn = BinaryOperator::Create(Instruction::Add,
> > - node->getStartingPathNumber(),
> > - createIncrementConstant(inc,32),
> > - "pathNumber", insertPoint);
> > - else
> > - newpn = node->getStartingPathNumber();
> > - } else {
> > - newpn = (Value*)createIncrementConstant(
> > - ((BLInstrumentationEdge*)(*edge))->getIncrement(), 32);
> > - }
> > -
> > - insertCounterIncrement(newpn, insertPoint, &dag);
> > - insertCounterIncrement(newpn, node->getBlock()->getTerminator(),
> > - &dag, false);
> > - }
> > -}
> > -
> > -// Entry point of the module
> > -void PathProfiler::runOnFunction(std::vector<Constant*> &ftInit,
> > - Function &F, Module &M) {
> > - // Build DAG from CFG
> > - BLInstrumentationDag dag = BLInstrumentationDag(F);
> > - dag.init();
> > -
> > - // give each path a unique integer value
> > - dag.calculatePathNumbers();
> > -
> > - // modify path increments to increase the efficiency
> > - // of instrumentation
> > - dag.calculateSpanningTree();
> > - dag.calculateChordIncrements();
> > - dag.pushInitialization();
> > - dag.pushCounters();
> > - dag.unlinkPhony();
> > -
> > - // potentially generate .dot graph for the dag
> > - if (DotPathDag)
> > - dag.generateDotGraph ();
> > -
> > - // Should we store the information in an array or hash
> > - if( dag.getNumberOfPaths() <= HASH_THRESHHOLD ) {
> > - Type* t = ArrayType::get(Type::getInt32Ty(*Context),
> > - dag.getNumberOfPaths());
> > -
> > - dag.setCounterArray(new GlobalVariable(M, t, false,
> > - GlobalValue::InternalLinkage,
> > - Constant::getNullValue(t),
> ""));
> > - }
> > -
> > - insertInstrumentation(dag, M);
> > -
> > - // Add to global function reference table
> > - unsigned type;
> > - Type* voidPtr = TypeBuilder<types::i<8>*, true>::get(*Context);
> > -
> > - if( dag.getNumberOfPaths() <= HASH_THRESHHOLD )
> > - type = ProfilingArray;
> > - else
> > - type = ProfilingHash;
> > -
> > - std::vector<Constant*> entryArray(3);
> > - entryArray[0] = createIncrementConstant(type,32);
> > - entryArray[1] = createIncrementConstant(dag.getNumberOfPaths(),32);
> > - entryArray[2] = dag.getCounterArray() ?
> > - ConstantExpr::getBitCast(dag.getCounterArray(), voidPtr) :
> > - Constant::getNullValue(voidPtr);
> > -
> > - StructType* at = ftEntryTypeBuilder::get(*Context);
> > - ConstantStruct* functionEntry =
> > - (ConstantStruct*)ConstantStruct::get(at, entryArray);
> > - ftInit.push_back(functionEntry);
> > -}
> > -
> > -// Output the bitcode if we want to observe instrumentation changess
> > -#define PRINT_MODULE dbgs() << \
> > - "\n\n============= MODULE BEGIN ===============\n" << M << \
> > - "\n============== MODULE END ================\n"
> > -
> > -bool PathProfiler::runOnModule(Module &M) {
> > - Context = &M.getContext();
> > -
> > - DEBUG(dbgs()
> > - << "****************************************\n"
> > - << "****************************************\n"
> > - << "** **\n"
> > - << "** PATH PROFILING INSTRUMENTATION **\n"
> > - << "** **\n"
> > - << "****************************************\n"
> > - << "****************************************\n");
> > -
> > - // No main, no instrumentation!
> > - Function *Main = M.getFunction("main");
> > -
> > - // Using fortran? ... this kind of works
> > - if (!Main)
> > - Main = M.getFunction("MAIN__");
> > -
> > - if (!Main) {
> > - errs() << "WARNING: cannot insert path profiling into a module"
> > - << " with no main function!\n";
> > - return false;
> > - }
> > -
> > - llvmIncrementHashFunction = M.getOrInsertFunction(
> > - "llvm_increment_path_count",
> > - Type::getVoidTy(*Context), // return type
> > - Type::getInt32Ty(*Context), // function number
> > - Type::getInt32Ty(*Context), // path number
> > - NULL );
> > -
> > - llvmDecrementHashFunction = M.getOrInsertFunction(
> > - "llvm_decrement_path_count",
> > - Type::getVoidTy(*Context), // return type
> > - Type::getInt32Ty(*Context), // function number
> > - Type::getInt32Ty(*Context), // path number
> > - NULL );
> > -
> > - std::vector<Constant*> ftInit;
> > - unsigned functionNumber = 0;
> > - for (Module::iterator F = M.begin(), E = M.end(); F != E; F++) {
> > - if (F->isDeclaration())
> > - continue;
> > -
> > - DEBUG(dbgs() << "Function: " << F->getName() << "\n");
> > - functionNumber++;
> > -
> > - // set function number
> > - currentFunctionNumber = functionNumber;
> > - runOnFunction(ftInit, *F, M);
> > - }
> > -
> > - Type *t = ftEntryTypeBuilder::get(*Context);
> > - ArrayType* ftArrayType = ArrayType::get(t, ftInit.size());
> > - Constant* ftInitConstant = ConstantArray::get(ftArrayType, ftInit);
> > -
> > - DEBUG(dbgs() << " ftArrayType:" << *ftArrayType << "\n");
> > -
> > - GlobalVariable* functionTable =
> > - new GlobalVariable(M, ftArrayType, false,
> GlobalValue::InternalLinkage,
> > - ftInitConstant, "functionPathTable");
> > - Type *eltType = ftArrayType->getTypeAtIndex((unsigned)0);
> > - InsertProfilingInitCall(Main, "llvm_start_path_profiling",
> functionTable,
> > - PointerType::getUnqual(eltType));
> > -
> > - DEBUG(PRINT_MODULE);
> > -
> > - return true;
> > -}
> > -
> > -// If this edge is a critical edge, then inserts a node at this edge.
> > -// This edge becomes the first edge, and a new BallLarusEdge is created.
> > -// Returns true if the edge was split
> > -bool PathProfiler::splitCritical(BLInstrumentationEdge* edge,
> > - BLInstrumentationDag* dag) {
> > - unsigned succNum = edge->getSuccessorNumber();
> > - BallLarusNode* sourceNode = edge->getSource();
> > - BallLarusNode* targetNode = edge->getTarget();
> > - BasicBlock* sourceBlock = sourceNode->getBlock();
> > - BasicBlock* targetBlock = targetNode->getBlock();
> > -
> > - if(sourceBlock == NULL || targetBlock == NULL
> > - || sourceNode->getNumberSuccEdges() <= 1
> > - || targetNode->getNumberPredEdges() == 1 ) {
> > - return(false);
> > - }
> > -
> > - TerminatorInst* terminator = sourceBlock->getTerminator();
> > -
> > - if( SplitCriticalEdge(terminator, succNum, this, false)) {
> > - BasicBlock* newBlock = terminator->getSuccessor(succNum);
> > - dag->splitUpdate(edge, newBlock);
> > - return(true);
> > - } else
> > - return(false);
> > -}
> >
> > Modified: llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp (original)
> > +++ llvm/trunk/lib/Transforms/Scalar/CodeGenPrepare.cpp Wed Oct 2
> 10:42:23 2013
> > @@ -22,7 +22,6 @@
> > #include "llvm/Analysis/DominatorInternals.h"
> > #include "llvm/Analysis/Dominators.h"
> > #include "llvm/Analysis/InstructionSimplify.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > #include "llvm/Assembly/Writer.h"
> > #include "llvm/IR/Constants.h"
> > #include "llvm/IR/DataLayout.h"
> > @@ -80,7 +79,6 @@ namespace {
> > const TargetLowering *TLI;
> > const TargetLibraryInfo *TLInfo;
> > DominatorTree *DT;
> > - ProfileInfo *PFI;
> >
> > /// CurInstIterator - As we scan instructions optimizing them, this
> is the
> > /// next instruction to optimize. Xforms that can invalidate this
> should
> > @@ -111,7 +109,6 @@ namespace {
> >
> > virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > AU.addPreserved<DominatorTree>();
> > - AU.addPreserved<ProfileInfo>();
> > AU.addRequired<TargetLibraryInfo>();
> > }
> >
> > @@ -151,7 +148,6 @@ bool CodeGenPrepare::runOnFunction(Funct
> > if (TM) TLI = TM->getTargetLowering();
> > TLInfo = &getAnalysis<TargetLibraryInfo>();
> > DT = getAnalysisIfAvailable<DominatorTree>();
> > - PFI = getAnalysisIfAvailable<ProfileInfo>();
> > OptSize = F.getAttributes().hasAttribute(AttributeSet::FunctionIndex,
> > Attribute::OptimizeForSize);
> >
> > @@ -442,10 +438,6 @@ void CodeGenPrepare::EliminateMostlyEmpt
> > DT->changeImmediateDominator(DestBB, NewIDom);
> > DT->eraseNode(BB);
> > }
> > - if (PFI) {
> > - PFI->replaceAllUses(BB, DestBB);
> > - PFI->removeEdge(ProfileInfo::getEdge(BB, DestBB));
> > - }
> > BB->eraseFromParent();
> > ++NumBlocksElim;
> >
> >
> > Modified: llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp (original)
> > +++ llvm/trunk/lib/Transforms/Utils/BreakCriticalEdges.cpp Wed Oct 2
> 10:42:23 2013
> > @@ -22,7 +22,6 @@
> > #include "llvm/Analysis/CFG.h"
> > #include "llvm/Analysis/Dominators.h"
> > #include "llvm/Analysis/LoopInfo.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > #include "llvm/IR/Function.h"
> > #include "llvm/IR/Instructions.h"
> > #include "llvm/IR/Type.h"
> > @@ -45,7 +44,6 @@ namespace {
> > virtual void getAnalysisUsage(AnalysisUsage &AU) const {
> > AU.addPreserved<DominatorTree>();
> > AU.addPreserved<LoopInfo>();
> > - AU.addPreserved<ProfileInfo>();
> >
> > // No loop canonicalization guarantees are broken by this pass.
> > AU.addPreservedID(LoopSimplifyID);
> > @@ -213,10 +211,9 @@ BasicBlock *llvm::SplitCriticalEdge(Term
> >
> > DominatorTree *DT = P->getAnalysisIfAvailable<DominatorTree>();
> > LoopInfo *LI = P->getAnalysisIfAvailable<LoopInfo>();
> > - ProfileInfo *PI = P->getAnalysisIfAvailable<ProfileInfo>();
> >
> > // If we have nothing to update, just return.
> > - if (DT == 0 && LI == 0 && PI == 0)
> > + if (DT == 0 && LI == 0)
> > return NewBB;
> >
> > // Now update analysis information. Since the only predecessor of
> NewBB is
> > @@ -369,9 +366,5 @@ BasicBlock *llvm::SplitCriticalEdge(Term
> > }
> > }
> >
> > - // Update ProfileInfo if it is around.
> > - if (PI)
> > - PI->splitEdge(TIBB, DestBB, NewBB, MergeIdenticalEdges);
> > -
> > return NewBB;
> > }
> >
> > Modified: llvm/trunk/lib/Transforms/Utils/Local.cpp
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Utils/Local.cpp?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/lib/Transforms/Utils/Local.cpp (original)
> > +++ llvm/trunk/lib/Transforms/Utils/Local.cpp Wed Oct 2 10:42:23 2013
> > @@ -20,7 +20,6 @@
> > #include "llvm/Analysis/Dominators.h"
> > #include "llvm/Analysis/InstructionSimplify.h"
> > #include "llvm/Analysis/MemoryBuiltins.h"
> > -#include "llvm/Analysis/ProfileInfo.h"
> > #include "llvm/Analysis/ValueTracking.h"
> > #include "llvm/DIBuilder.h"
> > #include "llvm/DebugInfo.h"
> > @@ -513,11 +512,6 @@ void llvm::MergeBasicBlockIntoOnlyPred(B
> > DT->changeImmediateDominator(DestBB, PredBBIDom);
> > DT->eraseNode(PredBB);
> > }
> > - ProfileInfo *PI = P->getAnalysisIfAvailable<ProfileInfo>();
> > - if (PI) {
> > - PI->replaceAllUses(PredBB, DestBB);
> > - PI->removeEdge(ProfileInfo::getEdge(PredBB, DestBB));
> > - }
> > }
> > // Nuke BB.
> > PredBB->eraseFromParent();
> >
> > Modified: llvm/trunk/test/lit.cfg
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/lit.cfg?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/test/lit.cfg (original)
> > +++ llvm/trunk/test/lit.cfg Wed Oct 2 10:42:23 2013
> > @@ -226,7 +226,6 @@ for pattern in [r"\bbugpoint\b(?!-)",
> > r"\bllvm-mc\b",
> > r"\bllvm-nm\b",
> > r"\bllvm-objdump\b",
> > - r"\bllvm-prof\b",
> > r"\bllvm-ranlib\b",
> > r"\bllvm-readobj\b",
> > r"\bllvm-rtdyld\b",
> >
> > Modified: llvm/trunk/tools/CMakeLists.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/CMakeLists.txt?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/tools/CMakeLists.txt (original)
> > +++ llvm/trunk/tools/CMakeLists.txt Wed Oct 2 10:42:23 2013
> > @@ -15,7 +15,6 @@ add_llvm_tool_subdirectory(llvm-nm)
> > add_llvm_tool_subdirectory(llvm-size)
> >
> > add_llvm_tool_subdirectory(llvm-cov)
> > -add_llvm_tool_subdirectory(llvm-prof)
> > add_llvm_tool_subdirectory(llvm-link)
> > add_llvm_tool_subdirectory(lli)
> >
> >
> > Modified: llvm/trunk/tools/LLVMBuild.txt
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/LLVMBuild.txt?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/tools/LLVMBuild.txt (original)
> > +++ llvm/trunk/tools/LLVMBuild.txt Wed Oct 2 10:42:23 2013
> > @@ -16,7 +16,7 @@
> >
> ;===------------------------------------------------------------------------===;
> >
> > [common]
> > -subdirectories = bugpoint llc lli llvm-ar llvm-as llvm-bcanalyzer
> llvm-cov llvm-diff llvm-dis llvm-dwarfdump llvm-extract llvm-jitlistener
> llvm-link llvm-lto llvm-mc llvm-nm llvm-objdump llvm-prof llvm-rtdyld
> llvm-size macho-dump opt llvm-mcmarkup
> > +subdirectories = bugpoint llc lli llvm-ar llvm-as llvm-bcanalyzer
> llvm-cov llvm-diff llvm-dis llvm-dwarfdump llvm-extract llvm-jitlistener
> llvm-link llvm-lto llvm-mc llvm-nm llvm-objdump llvm-rtdyld llvm-size
> macho-dump opt llvm-mcmarkup
> >
> > [component_0]
> > type = Group
> >
> > Modified: llvm/trunk/tools/Makefile
> > URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/Makefile?rev=191835&r1=191834&r2=191835&view=diff
> >
> ==============================================================================
> > --- llvm/trunk/tools/Makefile (original)
> > +++ llvm/trunk/tools/Makefile Wed Oct 2 10:42:23 2013
> > @@ -27,7 +27,7 @@ OPTIONAL_DIRS := lldb
> > # large and three small executables. This is done to minimize memory
> load
> > # in parallel builds. Please retain this ordering.
> > DIRS := llvm-config
> > -PARALLEL_DIRS := opt llvm-as llvm-dis llc llvm-ar llvm-nm llvm-prof
> llvm-link \
> > +PARALLEL_DIRS := opt llvm-as llvm-dis llc llvm-ar llvm-nm llvm-link \
> > lli llvm-extract llvm-mc bugpoint llvm-bcanalyzer
> llvm-diff \
> > macho-dump llvm-objdump llvm-readobj llvm-rtdyld \
> > llvm-dwarfdump llvm-cov llvm-size llvm-stress
> llvm-mcmarkup \
> >
> >
> > _______________________________________________
> > llvm-commits mailing list
> > llvm-commits at cs.uiuc.edu
> > http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
>
--
Alexey Samsonov, MSK
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20131004/e2adc7ed/attachment.html>
More information about the llvm-commits
mailing list