Remove some beta code that no longer has an owner.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@23944 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 0 insertions, 252 deletions

diff --git a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp b/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
deleted file mode 100644
index ce9e328c27..0000000000
--- a/lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
+++ /dev/null
@@ -1,252 +0,0 @@
-//===-- ProfilePaths.cpp - interface to insert instrumentation --*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This inserts instrumentation for counting execution of paths though a given
-// function Its implemented as a "Function" Pass, and called using opt
-//
-// This pass is implemented by using algorithms similar to
-// 1."Efficient Path Profiling": Ball, T. and Larus, J. R.,
-//    Proceedings of Micro-29, Dec 1996, Paris, France.
-// 2."Efficiently Counting Program events with support for on-line
-//   "queries": Ball T., ACM Transactions on Programming Languages
-//    and systems, Sep 1994.
-//
-// The algorithms work on a Graph constructed over the nodes made from Basic
-// Blocks: The transformations then take place on the constructed graph
-// (implementation in Graph.cpp and GraphAuxiliary.cpp) and finally, appropriate
-// instrumentation is placed over suitable edges.  (code inserted through
-// EdgeCode.cpp).
-//
-// The algorithm inserts code such that every acyclic path in the CFG of a
-// function is identified through a unique number. the code insertion is optimal
-// in the sense that its inserted over a minimal set of edges. Also, the
-// algorithm makes sure than initialization, path increment and counter update
-// can be collapsed into minimum number of edges.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Transforms/Instrumentation.h"
-#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
-#include "llvm/Support/CFG.h"
-#include "llvm/Constants.h"
-#include "llvm/DerivedTypes.h"
-#include "llvm/Instructions.h"
-#include "llvm/Module.h"
-#include "Graph.h"
-#include <fstream>
-#include <cstdio>
-
-namespace llvm {
-
-struct ProfilePaths : public FunctionPass {
-  bool runOnFunction(Function &F);
-
-  // Before this pass, make sure that there is only one
-  // entry and only one exit node for the function in the CFG of the function
-  //
-  void getAnalysisUsage(AnalysisUsage &AU) const {
-    AU.addRequired<UnifyFunctionExitNodes>();
-  }
-};
-
-static RegisterOpt<ProfilePaths> X("paths", "Profile Paths");
-
-FunctionPass *createProfilePathsPass() { return new ProfilePaths(); }
-
-static Node *findBB(std::vector<Node *> &st, BasicBlock *BB){
-  for(std::vector<Node *>::iterator si=st.begin(); si!=st.end(); ++si){
-    if(((*si)->getElement())==BB){
-      return *si;
-    }
-  }
-  return NULL;
-}
-
-//Per function pass for inserting counters and trigger code
-bool ProfilePaths::runOnFunction(Function &F){
-
-  static int mn = -1;
-  static int CountCounter = 1;
-  if(F.isExternal()) {
-    return false;
-  }
-
-  //increment counter for instrumented functions. mn is now function#
-  mn++;
-
-  // Transform the cfg s.t. we have just one exit node
-  BasicBlock *ExitNode =
-    getAnalysis<UnifyFunctionExitNodes>().getReturnBlock();
-
-  //iterating over BBs and making graph
-  std::vector<Node *> nodes;
-  std::vector<Edge> edges;
-
-  Node *exitNode = 0, *startNode = 0;
-
-  // The nodes must be uniquely identified:
-  // That is, no two nodes must hav same BB*
-
-  for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE; ++BB) {
-    Node *nd=new Node(BB);
-    nodes.push_back(nd);
-    if(&*BB == ExitNode)
-      exitNode=nd;
-    if(BB==F.begin())
-      startNode=nd;
-  }
-
-  // now do it again to insert edges
-  for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE; ++BB){
-    Node *nd=findBB(nodes, BB);
-    assert(nd && "No node for this edge!");
-
-    for(succ_iterator s=succ_begin(BB), se=succ_end(BB); s!=se; ++s){
-      Node *nd2=findBB(nodes,*s);
-      assert(nd2 && "No node for this edge!");
-      Edge ed(nd,nd2,0);
-      edges.push_back(ed);
-    }
-  }
-
-  Graph g(nodes,edges, startNode, exitNode);
-
-#ifdef DEBUG_PATH_PROFILES
-  std::cerr<<"Original graph\n";
-  printGraph(g);
-#endif
-
-  BasicBlock *fr = &F.front();
-
-  // The graph is made acyclic: this is done
-  // by removing back edges for now, and adding them later on
-  std::vector<Edge> be;
-  std::map<Node *, int> nodePriority; //it ranks nodes in depth first order traversal
-  g.getBackEdges(be, nodePriority);
-
-#ifdef DEBUG_PATH_PROFILES
-  std::cerr<<"BackEdges-------------\n";
-  for (std::vector<Edge>::iterator VI=be.begin(); VI!=be.end(); ++VI){
-    printEdge(*VI);
-    cerr<<"\n";
-  }
-  std::cerr<<"------\n";
-#endif
-
-#ifdef DEBUG_PATH_PROFILES
-  cerr<<"Backedges:"<<be.size()<<endl;
-#endif
-  //Now we need to reflect the effect of back edges
-  //This is done by adding dummy edges
-  //If a->b is a back edge
-  //Then we add 2 back edges for it:
-  //1. from root->b (in vector stDummy)
-  //and 2. from a->exit (in vector exDummy)
-  std::vector<Edge> stDummy;
-  std::vector<Edge> exDummy;
-  addDummyEdges(stDummy, exDummy, g, be);
-
-#ifdef DEBUG_PATH_PROFILES
-  std::cerr<<"After adding dummy edges\n";
-  printGraph(g);
-#endif
-
-  // Now, every edge in the graph is assigned a weight
-  // This weight later adds on to assign path
-  // numbers to different paths in the graph
-  //  All paths for now are acyclic,
-  // since no back edges in the graph now
-  // numPaths is the number of acyclic paths in the graph
-  int numPaths=valueAssignmentToEdges(g, nodePriority, be);
-
-  //if(numPaths<=1) return false;
-
-  static GlobalVariable *threshold = NULL;
-  static bool insertedThreshold = false;
-
-  if(!insertedThreshold){
-    threshold = new GlobalVariable(Type::IntTy, false,
-                                   GlobalValue::ExternalLinkage, 0,
-                                   "reopt_threshold");
-
-    F.getParent()->getGlobalList().push_back(threshold);
-    insertedThreshold = true;
-  }
-
-  assert(threshold && "GlobalVariable threshold not defined!");
-
-
-  if(fr->getParent()->getName() == "main"){
-    //initialize threshold
-
-    // FIXME: THIS IS HORRIBLY BROKEN.  FUNCTION PASSES CANNOT DO THIS, EXCEPT
-    // IN THEIR INITIALIZE METHOD!!
-    Function *initialize =
-      F.getParent()->getOrInsertFunction("reoptimizerInitialize", Type::VoidTy,
-                                         PointerType::get(Type::IntTy),
-                                         (Type *)0);
-
-    std::vector<Value *> trargs;
-    trargs.push_back(threshold);
-    new CallInst(initialize, trargs, "", fr->begin());
-  }
-
-
-  if(numPaths<=1 || numPaths >5000) return false;
-
-#ifdef DEBUG_PATH_PROFILES
-  printGraph(g);
-#endif
-
-  //create instruction allocation r and count
-  //r is the variable that'll act like an accumulator
-  //all along the path, we just add edge values to r
-  //and at the end, r reflects the path number
-  //count is an array: count[x] would store
-  //the number of executions of path numbered x
-
-  Instruction *rVar=new
-    AllocaInst(Type::IntTy,
-               ConstantUInt::get(Type::UIntTy,1),"R");
-
-  //Instruction *countVar=new
-  //AllocaInst(Type::IntTy,
-  //           ConstantUInt::get(Type::UIntTy, numPaths), "Count");
-
-  //initialize counter array!
-  std::vector<Constant*> arrayInitialize;
-  for(int xi=0; xi<numPaths; xi++)
-    arrayInitialize.push_back(ConstantSInt::get(Type::IntTy, 0));
-
-  const ArrayType *ATy = ArrayType::get(Type::IntTy, numPaths);
-  Constant *initializer =  ConstantArray::get(ATy, arrayInitialize);
-  char tempChar[20];
-  sprintf(tempChar, "Count%d", CountCounter);
-  CountCounter++;
-  std::string countStr = tempChar;
-  GlobalVariable *countVar = new GlobalVariable(ATy, false,
-                                                GlobalValue::InternalLinkage,
-                                                initializer, countStr,
-                                                F.getParent());
-
-  // insert initialization code in first (entry) BB
-  // this includes initializing r and count
-  insertInTopBB(&F.getEntryBlock(), numPaths, rVar, threshold);
-
-  //now process the graph: get path numbers,
-  //get increments along different paths,
-  //and assign "increments" and "updates" (to r and count)
-  //"optimally". Finally, insert llvm code along various edges
-  processGraph(g, rVar, countVar, be, stDummy, exDummy, numPaths, mn,
-               threshold);
-
-  return true;  // Always modifies function
-}
-
-} // End llvm namespace