lib/Analysis/ProfileInfo.cpp

   1 //===- ProfileInfo.cpp - Profile Info Interface ---------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the abstract ProfileInfo interface, and the default
  11 // "no profile" implementation.
  12 //
  13 //===----------------------------------------------------------------------===//
  14 #define DEBUG_TYPE "profile-info"
  15 #include "llvm/Analysis/Passes.h"
  16 #include "llvm/Analysis/ProfileInfo.h"
  17 #include "llvm/CodeGen/MachineBasicBlock.h"
  18 #include "llvm/CodeGen/MachineFunction.h"
  19 #include "llvm/Pass.h"
  20 #include "llvm/Support/CFG.h"
  21 #include "llvm/ADT/SmallSet.h"
  22 #include <set>
  23 #include <queue>
  24 #include <limits>
  25 using namespace llvm;
  26
  27 namespace llvm {
  28   template<> char ProfileInfoT<Function,BasicBlock>::ID = 0;
  29 }
  30
  31 // Register the ProfileInfo interface, providing a nice name to refer to.
  32 INITIALIZE_ANALYSIS_GROUP(ProfileInfo, "Profile Information", NoProfileInfo)
  33
  34 namespace llvm {
  35
  36 template <>
  37 ProfileInfoT<MachineFunction, MachineBasicBlock>::ProfileInfoT() {}
  38 template <>
  39 ProfileInfoT<MachineFunction, MachineBasicBlock>::~ProfileInfoT() {}
  40
  41 template <>
  42 ProfileInfoT<Function, BasicBlock>::ProfileInfoT() {
  43   MachineProfile = 0;
  44 }
  45 template <>
  46 ProfileInfoT<Function, BasicBlock>::~ProfileInfoT() {
  47   if (MachineProfile) delete MachineProfile;
  48 }
  49
  50 template<>
  51 char ProfileInfoT<MachineFunction, MachineBasicBlock>::ID = 0;
  52
  53 template<>
  54 const double ProfileInfoT<Function,BasicBlock>::MissingValue = -1;
  55
  56 template<> const
  57 double ProfileInfoT<MachineFunction, MachineBasicBlock>::MissingValue = -1;
  58
  59 template<> double
  60 ProfileInfoT<Function,BasicBlock>::getExecutionCount(const BasicBlock *BB) {
  61   std::map<const Function*, BlockCounts>::iterator J =
  62     BlockInformation.find(BB->getParent());
  63   if (J != BlockInformation.end()) {
  64     BlockCounts::iterator I = J->second.find(BB);
  65     if (I != J->second.end())
  66       return I->second;
  67   }
  68
  69   double Count = MissingValue;
  70
  71   const_pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
  72
  73   // Are there zero predecessors of this block?
  74   if (PI == PE) {
  75     Edge e = getEdge(0, BB);
  76     Count = getEdgeWeight(e);
  77   } else {
  78     // Otherwise, if there are predecessors, the execution count of this block is
  79     // the sum of the edge frequencies from the incoming edges.
  80     std::set<const BasicBlock*> ProcessedPreds;
  81     Count = 0;
  82     for (; PI != PE; ++PI) {
  83       const BasicBlock *P = *PI;
  84       if (ProcessedPreds.insert(P).second) {
  85         double w = getEdgeWeight(getEdge(P, BB));
  86         if (w == MissingValue) {
  87           Count = MissingValue;
  88           break;
  89         }
  90         Count += w;
  91       }
  92     }
  93   }
  94
  95   // If the predecessors did not suffice to get block weight, try successors.
  96   if (Count == MissingValue) {
  97
  98     succ_const_iterator SI = succ_begin(BB), SE = succ_end(BB);
  99
 100     // Are there zero successors of this block?
 101     if (SI == SE) {
 102       Edge e = getEdge(BB,0);
 103       Count = getEdgeWeight(e);
 104     } else {
 105       std::set<const BasicBlock*> ProcessedSuccs;
 106       Count = 0;
 107       for (; SI != SE; ++SI)
 108         if (ProcessedSuccs.insert(*SI).second) {
 109           double w = getEdgeWeight(getEdge(BB, *SI));
 110           if (w == MissingValue) {
 111             Count = MissingValue;
 112             break;
 113           }
 114           Count += w;
 115         }
 116     }
 117   }
 118
 119   if (Count != MissingValue) BlockInformation[BB->getParent()][BB] = Count;
 120   return Count;
 121 }
 122
 123 template<>
 124 double ProfileInfoT<MachineFunction, MachineBasicBlock>::
 125         getExecutionCount(const MachineBasicBlock *MBB) {
 126   std::map<const MachineFunction*, BlockCounts>::iterator J =
 127     BlockInformation.find(MBB->getParent());
 128   if (J != BlockInformation.end()) {
 129     BlockCounts::iterator I = J->second.find(MBB);
 130     if (I != J->second.end())
 131       return I->second;
 132   }
 133
 134   return MissingValue;
 135 }
 136
 137 template<>
 138 double ProfileInfoT<Function,BasicBlock>::getExecutionCount(const Function *F) {
 139   std::map<const Function*, double>::iterator J =
 140     FunctionInformation.find(F);
 141   if (J != FunctionInformation.end())
 142     return J->second;
 143
 144   // isDeclaration() is checked here and not at start of function to allow
 145   // functions without a body still to have a execution count.
 146   if (F->isDeclaration()) return MissingValue;
 147
 148   double Count = getExecutionCount(&F->getEntryBlock());
 149   if (Count != MissingValue) FunctionInformation[F] = Count;
 150   return Count;
 151 }
 152
 153 template<>
 154 double ProfileInfoT<MachineFunction, MachineBasicBlock>::
 155         getExecutionCount(const MachineFunction *MF) {
 156   std::map<const MachineFunction*, double>::iterator J =
 157     FunctionInformation.find(MF);
 158   if (J != FunctionInformation.end())
 159     return J->second;
 160
 161   double Count = getExecutionCount(&MF->front());
 162   if (Count != MissingValue) FunctionInformation[MF] = Count;
 163   return Count;
 164 }
 165
 166 template<>
 167 void ProfileInfoT<Function,BasicBlock>::
 168         setExecutionCount(const BasicBlock *BB, double w) {
 169   DEBUG(dbgs() << "Creating Block " << BB->getName()
 170                << " (weight: " << format("%.20g",w) << ")\n");
 171   BlockInformation[BB->getParent()][BB] = w;
 172 }
 173
 174 template<>
 175 void ProfileInfoT<MachineFunction, MachineBasicBlock>::
 176         setExecutionCount(const MachineBasicBlock *MBB, double w) {
 177   DEBUG(dbgs() << "Creating Block " << MBB->getBasicBlock()->getName()
 178                << " (weight: " << format("%.20g",w) << ")\n");
 179   BlockInformation[MBB->getParent()][MBB] = w;
 180 }
 181
 182 template<>
 183 void ProfileInfoT<Function,BasicBlock>::addEdgeWeight(Edge e, double w) {
 184   double oldw = getEdgeWeight(e);
 185   assert (oldw != MissingValue && "Adding weight to Edge with no previous weight");
 186   DEBUG(dbgs() << "Adding to Edge " << e
 187                << " (new weight: " << format("%.20g",oldw + w) << ")\n");
 188   EdgeInformation[getFunction(e)][e] = oldw + w;
 189 }
 190
 191 template<>
 192 void ProfileInfoT<Function,BasicBlock>::
 193         addExecutionCount(const BasicBlock *BB, double w) {
 194   double oldw = getExecutionCount(BB);
 195   assert (oldw != MissingValue && "Adding weight to Block with no previous weight");
 196   DEBUG(dbgs() << "Adding to Block " << BB->getName()
 197                << " (new weight: " << format("%.20g",oldw + w) << ")\n");
 198   BlockInformation[BB->getParent()][BB] = oldw + w;
 199 }
 200
 201 template<>
 202 void ProfileInfoT<Function,BasicBlock>::removeBlock(const BasicBlock *BB) {
 203   std::map<const Function*, BlockCounts>::iterator J =
 204     BlockInformation.find(BB->getParent());
 205   if (J == BlockInformation.end()) return;
 206
 207   DEBUG(dbgs() << "Deleting " << BB->getName() << "\n");
 208   J->second.erase(BB);
 209 }
 210
 211 template<>
 212 void ProfileInfoT<Function,BasicBlock>::removeEdge(Edge e) {
 213   std::map<const Function*, EdgeWeights>::iterator J =
 214     EdgeInformation.find(getFunction(e));
 215   if (J == EdgeInformation.end()) return;
 216
 217   DEBUG(dbgs() << "Deleting" << e << "\n");
 218   J->second.erase(e);
 219 }
 220
 221 template<>
 222 void ProfileInfoT<Function,BasicBlock>::
 223         replaceEdge(const Edge &oldedge, const Edge &newedge) {
 224   double w;
 225   if ((w = getEdgeWeight(newedge)) == MissingValue) {
 226     w = getEdgeWeight(oldedge);
 227     DEBUG(dbgs() << "Replacing " << oldedge << " with " << newedge  << "\n");
 228   } else {
 229     w += getEdgeWeight(oldedge);
 230     DEBUG(dbgs() << "Adding " << oldedge << " to " << newedge  << "\n");
 231   }
 232   setEdgeWeight(newedge,w);
 233   removeEdge(oldedge);
 234 }
 235
 236 template<>
 237 const BasicBlock *ProfileInfoT<Function,BasicBlock>::
 238         GetPath(const BasicBlock *Src, const BasicBlock *Dest,
 239                 Path &P, unsigned Mode) {
 240   const BasicBlock *BB = 0;
 241   bool hasFoundPath = false;
 242
 243   std::queue<const BasicBlock *> BFS;
 244   BFS.push(Src);
 245
 246   while(BFS.size() && !hasFoundPath) {
 247     BB = BFS.front();
 248     BFS.pop();
 249
 250     succ_const_iterator Succ = succ_begin(BB), End = succ_end(BB);
 251     if (Succ == End) {
 252       P[0] = BB;
 253       if (Mode & GetPathToExit) {
 254         hasFoundPath = true;
 255         BB = 0;
 256       }
 257     }
 258     for(;Succ != End; ++Succ) {
 259       if (P.find(*Succ) != P.end()) continue;
 260       Edge e = getEdge(BB,*Succ);
 261       if ((Mode & GetPathWithNewEdges) && (getEdgeWeight(e) != MissingValue)) continue;
 262       P[*Succ] = BB;
 263       BFS.push(*Succ);
 264       if ((Mode & GetPathToDest) && *Succ == Dest) {
 265         hasFoundPath = true;
 266         BB = *Succ;
 267         break;
 268       }
 269       if ((Mode & GetPathToValue) && (getExecutionCount(*Succ) != MissingValue)) {
 270         hasFoundPath = true;
 271         BB = *Succ;
 272         break;
 273       }
 274     }
 275   }
 276
 277   return BB;
 278 }
 279
 280 template<>
 281 void ProfileInfoT<Function,BasicBlock>::
 282         divertFlow(const Edge &oldedge, const Edge &newedge) {
 283   DEBUG(dbgs() << "Diverting " << oldedge << " via " << newedge );
 284
 285   // First check if the old edge was taken, if not, just delete it...
 286   if (getEdgeWeight(oldedge) == 0) {
 287     removeEdge(oldedge);
 288     return;
 289   }
 290
 291   Path P;
 292   P[newedge.first] = 0;
 293   P[newedge.second] = newedge.first;
 294   const BasicBlock *BB = GetPath(newedge.second,oldedge.second,P,GetPathToExit | GetPathToDest);
 295
 296   double w = getEdgeWeight (oldedge);
 297   DEBUG(dbgs() << ", Weight: " << format("%.20g",w) << "\n");
 298   do {
 299     const BasicBlock *Parent = P.find(BB)->second;
 300     Edge e = getEdge(Parent,BB);
 301     double oldw = getEdgeWeight(e);
 302     double oldc = getExecutionCount(e.first);
 303     setEdgeWeight(e, w+oldw);
 304     if (Parent != oldedge.first) {
 305       setExecutionCount(e.first, w+oldc);
 306     }
 307     BB = Parent;
 308   } while (BB != newedge.first);
 309   removeEdge(oldedge);
 310 }
 311
 312 /// Replaces all occurences of RmBB in the ProfilingInfo with DestBB.
 313 /// This checks all edges of the function the blocks reside in and replaces the
 314 /// occurences of RmBB with DestBB.
 315 template<>
 316 void ProfileInfoT<Function,BasicBlock>::
 317         replaceAllUses(const BasicBlock *RmBB, const BasicBlock *DestBB) {
 318   DEBUG(dbgs() << "Replacing " << RmBB->getName()
 319                << " with " << DestBB->getName() << "\n");
 320   const Function *F = DestBB->getParent();
 321   std::map<const Function*, EdgeWeights>::iterator J =
 322     EdgeInformation.find(F);
 323   if (J == EdgeInformation.end()) return;
 324
 325   Edge e, newedge;
 326   bool erasededge = false;
 327   EdgeWeights::iterator I = J->second.begin(), E = J->second.end();
 328   while(I != E) {
 329     e = (I++)->first;
 330     bool foundedge = false; bool eraseedge = false;
 331     if (e.first == RmBB) {
 332       if (e.second == DestBB) {
 333         eraseedge = true;
 334       } else {
 335         newedge = getEdge(DestBB, e.second);
 336         foundedge = true;
 337       }
 338     }
 339     if (e.second == RmBB) {
 340       if (e.first == DestBB) {
 341         eraseedge = true;
 342       } else {
 343         newedge = getEdge(e.first, DestBB);
 344         foundedge = true;
 345       }
 346     }
 347     if (foundedge) {
 348       replaceEdge(e, newedge);
 349     }
 350     if (eraseedge) {
 351       if (erasededge) {
 352         Edge newedge = getEdge(DestBB, DestBB);
 353         replaceEdge(e, newedge);
 354       } else {
 355         removeEdge(e);
 356         erasededge = true;
 357       }
 358     }
 359   }
 360 }
 361
 362 /// Splits an edge in the ProfileInfo and redirects flow over NewBB.
 363 /// Since its possible that there is more than one edge in the CFG from FristBB
 364 /// to SecondBB its necessary to redirect the flow proporionally.
 365 template<>
 366 void ProfileInfoT<Function,BasicBlock>::splitEdge(const BasicBlock *FirstBB,
 367                                                   const BasicBlock *SecondBB,
 368                                                   const BasicBlock *NewBB,
 369                                                   bool MergeIdenticalEdges) {
 370   const Function *F = FirstBB->getParent();
 371   std::map<const Function*, EdgeWeights>::iterator J =
 372     EdgeInformation.find(F);
 373   if (J == EdgeInformation.end()) return;
 374
 375   // Generate edges and read current weight.
 376   Edge e  = getEdge(FirstBB, SecondBB);
 377   Edge n1 = getEdge(FirstBB, NewBB);
 378   Edge n2 = getEdge(NewBB, SecondBB);
 379   EdgeWeights &ECs = J->second;
 380   double w = ECs[e];
 381
 382   int succ_count = 0;
 383   if (!MergeIdenticalEdges) {
 384     // First count the edges from FristBB to SecondBB, if there is more than
 385     // one, only slice out a proporional part for NewBB.
 386     for(succ_const_iterator BBI = succ_begin(FirstBB), BBE = succ_end(FirstBB);
 387         BBI != BBE; ++BBI) {
 388       if (*BBI == SecondBB) succ_count++;
 389     }
 390     // When the NewBB is completely new, increment the count by one so that
 391     // the counts are properly distributed.
 392     if (getExecutionCount(NewBB) == ProfileInfo::MissingValue) succ_count++;
 393   } else {
 394     // When the edges are merged anyway, then redirect all flow.
 395     succ_count = 1;
 396   }
 397
 398   // We know now how many edges there are from FirstBB to SecondBB, reroute a
 399   // proportional part of the edge weight over NewBB.
 400   double neww = floor(w / succ_count);
 401   ECs[n1] += neww;
 402   ECs[n2] += neww;
 403   BlockInformation[F][NewBB] += neww;
 404   if (succ_count == 1) {
 405     ECs.erase(e);
 406   } else {
 407     ECs[e] -= neww;
 408   }
 409 }
 410
 411 template<>
 412 void ProfileInfoT<Function,BasicBlock>::splitBlock(const BasicBlock *Old,
 413                                                    const BasicBlock* New) {
 414   const Function *F = Old->getParent();
 415   std::map<const Function*, EdgeWeights>::iterator J =
 416     EdgeInformation.find(F);
 417   if (J == EdgeInformation.end()) return;
 418
 419   DEBUG(dbgs() << "Splitting " << Old->getName() << " to " << New->getName() << "\n");
 420
 421   std::set<Edge> Edges;
 422   for (EdgeWeights::iterator ewi = J->second.begin(), ewe = J->second.end();
 423        ewi != ewe; ++ewi) {
 424     Edge old = ewi->first;
 425     if (old.first == Old) {
 426       Edges.insert(old);
 427     }
 428   }
 429   for (std::set<Edge>::iterator EI = Edges.begin(), EE = Edges.end();
 430        EI != EE; ++EI) {
 431     Edge newedge = getEdge(New, EI->second);
 432     replaceEdge(*EI, newedge);
 433   }
 434
 435   double w = getExecutionCount(Old);
 436   setEdgeWeight(getEdge(Old, New), w);
 437   setExecutionCount(New, w);
 438 }
 439
 440 template<>
 441 void ProfileInfoT<Function,BasicBlock>::splitBlock(const BasicBlock *BB,
 442                                                    const BasicBlock* NewBB,
 443                                                    BasicBlock *const *Preds,
 444                                                    unsigned NumPreds) {
 445   const Function *F = BB->getParent();
 446   std::map<const Function*, EdgeWeights>::iterator J =
 447     EdgeInformation.find(F);
 448   if (J == EdgeInformation.end()) return;
 449
 450   DEBUG(dbgs() << "Splitting " << NumPreds << " Edges from " << BB->getName()
 451                << " to " << NewBB->getName() << "\n");
 452
 453   // Collect weight that was redirected over NewBB.
 454   double newweight = 0;
 455
 456   std::set<const BasicBlock *> ProcessedPreds;
 457   // For all requestes Predecessors.
 458   for (unsigned pred = 0; pred < NumPreds; ++pred) {
 459     const BasicBlock * Pred = Preds[pred];
 460     if (ProcessedPreds.insert(Pred).second) {
 461       // Create edges and read old weight.
 462       Edge oldedge = getEdge(Pred, BB);
 463       Edge newedge = getEdge(Pred, NewBB);
 464
 465       // Remember how much weight was redirected.
 466       newweight += getEdgeWeight(oldedge);
 467
 468       replaceEdge(oldedge,newedge);
 469     }
 470   }
 471
 472   Edge newedge = getEdge(NewBB,BB);
 473   setEdgeWeight(newedge, newweight);
 474   setExecutionCount(NewBB, newweight);
 475 }
 476
 477 template<>
 478 void ProfileInfoT<Function,BasicBlock>::transfer(const Function *Old,
 479                                                  const Function *New) {
 480   DEBUG(dbgs() << "Replacing Function " << Old->getName() << " with "
 481                << New->getName() << "\n");
 482   std::map<const Function*, EdgeWeights>::iterator J =
 483     EdgeInformation.find(Old);
 484   if(J != EdgeInformation.end()) {
 485     EdgeInformation[New] = J->second;
 486   }
 487   EdgeInformation.erase(Old);
 488   BlockInformation.erase(Old);
 489   FunctionInformation.erase(Old);
 490 }
 491
 492 static double readEdgeOrRemember(ProfileInfo::Edge edge, double w,
 493                                  ProfileInfo::Edge &tocalc, unsigned &uncalc) {
 494   if (w == ProfileInfo::MissingValue) {
 495     tocalc = edge;
 496     uncalc++;
 497     return 0;
 498   } else {
 499     return w;
 500   }
 501 }
 502
 503 template<>
 504 bool ProfileInfoT<Function,BasicBlock>::
 505         CalculateMissingEdge(const BasicBlock *BB, Edge &removed,
 506                              bool assumeEmptySelf) {
 507   Edge edgetocalc;
 508   unsigned uncalculated = 0;
 509
 510   // collect weights of all incoming and outgoing edges, rememer edges that
 511   // have no value
 512   double incount = 0;
 513   SmallSet<const BasicBlock*,8> pred_visited;
 514   const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
 515   if (bbi==bbe) {
 516     Edge e = getEdge(0,BB);
 517     incount += readEdgeOrRemember(e, getEdgeWeight(e) ,edgetocalc,uncalculated);
 518   }
 519   for (;bbi != bbe; ++bbi) {
 520     if (pred_visited.insert(*bbi)) {
 521       Edge e = getEdge(*bbi,BB);
 522       incount += readEdgeOrRemember(e, getEdgeWeight(e) ,edgetocalc,uncalculated);
 523     }
 524   }
 525
 526   double outcount = 0;
 527   SmallSet<const BasicBlock*,8> succ_visited;
 528   succ_const_iterator sbbi = succ_begin(BB), sbbe = succ_end(BB);
 529   if (sbbi==sbbe) {
 530     Edge e = getEdge(BB,0);
 531     if (getEdgeWeight(e) == MissingValue) {
 532       double w = getExecutionCount(BB);
 533       if (w != MissingValue) {
 534         setEdgeWeight(e,w);
 535         removed = e;
 536       }
 537     }
 538     outcount += readEdgeOrRemember(e, getEdgeWeight(e), edgetocalc, uncalculated);
 539   }
 540   for (;sbbi != sbbe; ++sbbi) {
 541     if (succ_visited.insert(*sbbi)) {
 542       Edge e = getEdge(BB,*sbbi);
 543       outcount += readEdgeOrRemember(e, getEdgeWeight(e), edgetocalc, uncalculated);
 544     }
 545   }
 546
 547   // if exactly one edge weight was missing, calculate it and remove it from
 548   // spanning tree
 549   if (uncalculated == 0 ) {
 550     return true;
 551   } else
 552   if (uncalculated == 1) {
 553     if (incount < outcount) {
 554       EdgeInformation[BB->getParent()][edgetocalc] = outcount-incount;
 555     } else {
 556       EdgeInformation[BB->getParent()][edgetocalc] = incount-outcount;
 557     }
 558     DEBUG(dbgs() << "--Calc Edge Counter for " << edgetocalc << ": "
 559                  << format("%.20g", getEdgeWeight(edgetocalc)) << "\n");
 560     removed = edgetocalc;
 561     return true;
 562   } else
 563   if (uncalculated == 2 && assumeEmptySelf && edgetocalc.first == edgetocalc.second && incount == outcount) {
 564     setEdgeWeight(edgetocalc, incount * 10);
 565     removed = edgetocalc;
 566     return true;
 567   } else {
 568     return false;
 569   }
 570 }
 571
 572 static void readEdge(ProfileInfo *PI, ProfileInfo::Edge e, double &calcw, std::set<ProfileInfo::Edge> &misscount) {
 573   double w = PI->getEdgeWeight(e);
 574   if (w != ProfileInfo::MissingValue) {
 575     calcw += w;
 576   } else {
 577     misscount.insert(e);
 578   }
 579 }
 580
 581 template<>
 582 bool ProfileInfoT<Function,BasicBlock>::EstimateMissingEdges(const BasicBlock *BB) {
 583   double inWeight = 0;
 584   std::set<Edge> inMissing;
 585   std::set<const BasicBlock*> ProcessedPreds;
 586   const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
 587   if (bbi == bbe) {
 588     readEdge(this,getEdge(0,BB),inWeight,inMissing);
 589   }
 590   for( ; bbi != bbe; ++bbi ) {
 591     if (ProcessedPreds.insert(*bbi).second) {
 592       readEdge(this,getEdge(*bbi,BB),inWeight,inMissing);
 593     }
 594   }
 595
 596   double outWeight = 0;
 597   std::set<Edge> outMissing;
 598   std::set<const BasicBlock*> ProcessedSuccs;
 599   succ_const_iterator sbbi = succ_begin(BB), sbbe = succ_end(BB);
 600   if (sbbi == sbbe)
 601     readEdge(this,getEdge(BB,0),outWeight,outMissing);
 602   for ( ; sbbi != sbbe; ++sbbi ) {
 603     if (ProcessedSuccs.insert(*sbbi).second) {
 604       readEdge(this,getEdge(BB,*sbbi),outWeight,outMissing);
 605     }
 606   }
 607
 608   double share;
 609   std::set<Edge>::iterator ei,ee;
 610   if (inMissing.size() == 0 && outMissing.size() > 0) {
 611     ei = outMissing.begin();
 612     ee = outMissing.end();
 613     share = inWeight/outMissing.size();
 614     setExecutionCount(BB,inWeight);
 615   } else
 616   if (inMissing.size() > 0 && outMissing.size() == 0 && outWeight == 0) {
 617     ei = inMissing.begin();
 618     ee = inMissing.end();
 619     share = 0;
 620     setExecutionCount(BB,0);
 621   } else
 622   if (inMissing.size() == 0 && outMissing.size() == 0) {
 623     setExecutionCount(BB,outWeight);
 624     return true;
 625   } else {
 626     return false;
 627   }
 628   for ( ; ei != ee; ++ei ) {
 629     setEdgeWeight(*ei,share);
 630   }
 631   return true;
 632 }
 633
 634 template<>
 635 void ProfileInfoT<Function,BasicBlock>::repair(const Function *F) {
 636 //  if (getExecutionCount(&(F->getEntryBlock())) == 0) {
 637 //    for (Function::const_iterator FI = F->begin(), FE = F->end();
 638 //         FI != FE; ++FI) {
 639 //      const BasicBlock* BB = &(*FI);
 640 //      {
 641 //        const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
 642 //        if (NBB == End) {
 643 //          setEdgeWeight(getEdge(0,BB),0);
 644 //        }
 645 //        for(;NBB != End; ++NBB) {
 646 //          setEdgeWeight(getEdge(*NBB,BB),0);
 647 //        }
 648 //      }
 649 //      {
 650 //        succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
 651 //        if (NBB == End) {
 652 //          setEdgeWeight(getEdge(0,BB),0);
 653 //        }
 654 //        for(;NBB != End; ++NBB) {
 655 //          setEdgeWeight(getEdge(*NBB,BB),0);
 656 //        }
 657 //      }
 658 //    }
 659 //    return;
 660 //  }
 661   // The set of BasicBlocks that are still unvisited.
 662   std::set<const BasicBlock*> Unvisited;
 663
 664   // The set of return edges (Edges with no successors).
 665   std::set<Edge> ReturnEdges;
 666   double ReturnWeight = 0;
 667
 668   // First iterate over the whole function and collect:
 669   // 1) The blocks in this function in the Unvisited set.
 670   // 2) The return edges in the ReturnEdges set.
 671   // 3) The flow that is leaving the function already via return edges.
 672
 673   // Data structure for searching the function.
 674   std::queue<const BasicBlock *> BFS;
 675   const BasicBlock *BB = &(F->getEntryBlock());
 676   BFS.push(BB);
 677   Unvisited.insert(BB);
 678
 679   while (BFS.size()) {
 680     BB = BFS.front(); BFS.pop();
 681     succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
 682     if (NBB == End) {
 683       Edge e = getEdge(BB,0);
 684       double w = getEdgeWeight(e);
 685       if (w == MissingValue) {
 686         // If the return edge has no value, try to read value from block.
 687         double bw = getExecutionCount(BB);
 688         if (bw != MissingValue) {
 689           setEdgeWeight(e,bw);
 690           ReturnWeight += bw;
 691         } else {
 692           // If both return edge and block provide no value, collect edge.
 693           ReturnEdges.insert(e);
 694         }
 695       } else {
 696         // If the return edge has a proper value, collect it.
 697         ReturnWeight += w;
 698       }
 699     }
 700     for (;NBB != End; ++NBB) {
 701       if (Unvisited.insert(*NBB).second) {
 702         BFS.push(*NBB);
 703       }
 704     }
 705   }
 706
 707   while (Unvisited.size() > 0) {
 708     unsigned oldUnvisitedCount = Unvisited.size();
 709     bool FoundPath = false;
 710
 711     // If there is only one edge left, calculate it.
 712     if (ReturnEdges.size() == 1) {
 713       ReturnWeight = getExecutionCount(&(F->getEntryBlock())) - ReturnWeight;
 714
 715       Edge e = *ReturnEdges.begin();
 716       setEdgeWeight(e,ReturnWeight);
 717       setExecutionCount(e.first,ReturnWeight);
 718
 719       Unvisited.erase(e.first);
 720       ReturnEdges.erase(e);
 721       continue;
 722     }
 723
 724     // Calculate all blocks where only one edge is missing, this may also
 725     // resolve furhter return edges.
 726     std::set<const BasicBlock *>::iterator FI = Unvisited.begin(), FE = Unvisited.end();
 727     while(FI != FE) {
 728       const BasicBlock *BB = *FI; ++FI;
 729       Edge e;
 730       if(CalculateMissingEdge(BB,e,true)) {
 731         if (BlockInformation[F].find(BB) == BlockInformation[F].end()) {
 732           setExecutionCount(BB,getExecutionCount(BB));
 733         }
 734         Unvisited.erase(BB);
 735         if (e.first != 0 && e.second == 0) {
 736           ReturnEdges.erase(e);
 737           ReturnWeight += getEdgeWeight(e);
 738         }
 739       }
 740     }
 741     if (oldUnvisitedCount > Unvisited.size()) continue;
 742
 743     // Estimate edge weights by dividing the flow proportionally.
 744     FI = Unvisited.begin(), FE = Unvisited.end();
 745     while(FI != FE) {
 746       const BasicBlock *BB = *FI; ++FI;
 747       const BasicBlock *Dest = 0;
 748       bool AllEdgesHaveSameReturn = true;
 749       // Check each Successor, these must all end up in the same or an empty
 750       // return block otherwise its dangerous to do an estimation on them.
 751       for (succ_const_iterator Succ = succ_begin(BB), End = succ_end(BB);
 752            Succ != End; ++Succ) {
 753         Path P;
 754         GetPath(*Succ, 0, P, GetPathToExit);
 755         if (Dest && Dest != P[0]) {
 756           AllEdgesHaveSameReturn = false;
 757         }
 758         Dest = P[0];
 759       }
 760       if (AllEdgesHaveSameReturn) {
 761         if(EstimateMissingEdges(BB)) {
 762           Unvisited.erase(BB);
 763           break;
 764         }
 765       }
 766     }
 767     if (oldUnvisitedCount > Unvisited.size()) continue;
 768
 769     // Check if there is a path to an block that has a known value and redirect
 770     // flow accordingly.
 771     FI = Unvisited.begin(), FE = Unvisited.end();
 772     while(FI != FE && !FoundPath) {
 773       // Fetch path.
 774       const BasicBlock *BB = *FI; ++FI;
 775       Path P;
 776       const BasicBlock *Dest = GetPath(BB, 0, P, GetPathToValue);
 777
 778       // Calculate incoming flow.
 779       double iw = 0; unsigned inmissing = 0; unsigned incount = 0; unsigned invalid = 0;
 780       std::set<const BasicBlock *> Processed;
 781       for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
 782            NBB != End; ++NBB) {
 783         if (Processed.insert(*NBB).second) {
 784           Edge e = getEdge(*NBB, BB);
 785           double ew = getEdgeWeight(e);
 786           if (ew != MissingValue) {
 787             iw += ew;
 788             invalid++;
 789           } else {
 790             // If the path contains the successor, this means its a backedge,
 791             // do not count as missing.
 792             if (P.find(*NBB) == P.end())
 793               inmissing++;
 794           }
 795           incount++;
 796         }
 797       }
 798       if (inmissing == incount) continue;
 799       if (invalid == 0) continue;
 800
 801       // Subtract (already) outgoing flow.
 802       Processed.clear();
 803       for (succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
 804            NBB != End; ++NBB) {
 805         if (Processed.insert(*NBB).second) {
 806           Edge e = getEdge(BB, *NBB);
 807           double ew = getEdgeWeight(e);
 808           if (ew != MissingValue) {
 809             iw -= ew;
 810           }
 811         }
 812       }
 813       if (iw < 0) continue;
 814
 815       // Check the recieving end of the path if it can handle the flow.
 816       double ow = getExecutionCount(Dest);
 817       Processed.clear();
 818       for (succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
 819            NBB != End; ++NBB) {
 820         if (Processed.insert(*NBB).second) {
 821           Edge e = getEdge(BB, *NBB);
 822           double ew = getEdgeWeight(e);
 823           if (ew != MissingValue) {
 824             ow -= ew;
 825           }
 826         }
 827       }
 828       if (ow < 0) continue;
 829
 830       // Determine how much flow shall be used.
 831       double ew = getEdgeWeight(getEdge(P[Dest],Dest));
 832       if (ew != MissingValue) {
 833         ew = ew<ow?ew:ow;
 834         ew = ew<iw?ew:iw;
 835       } else {
 836         if (inmissing == 0)
 837           ew = iw;
 838       }
 839
 840       // Create flow.
 841       if (ew != MissingValue) {
 842         do {
 843           Edge e = getEdge(P[Dest],Dest);
 844           if (getEdgeWeight(e) == MissingValue) {
 845             setEdgeWeight(e,ew);
 846             FoundPath = true;
 847           }
 848           Dest = P[Dest];
 849         } while (Dest != BB);
 850       }
 851     }
 852     if (FoundPath) continue;
 853
 854     // Calculate a block with self loop.
 855     FI = Unvisited.begin(), FE = Unvisited.end();
 856     while(FI != FE && !FoundPath) {
 857       const BasicBlock *BB = *FI; ++FI;
 858       bool SelfEdgeFound = false;
 859       for (succ_const_iterator NBB = succ_begin(BB), End = succ_end(BB);
 860            NBB != End; ++NBB) {
 861         if (*NBB == BB) {
 862           SelfEdgeFound = true;
 863           break;
 864         }
 865       }
 866       if (SelfEdgeFound) {
 867         Edge e = getEdge(BB,BB);
 868         if (getEdgeWeight(e) == MissingValue) {
 869           double iw = 0;
 870           std::set<const BasicBlock *> Processed;
 871           for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
 872                NBB != End; ++NBB) {
 873             if (Processed.insert(*NBB).second) {
 874               Edge e = getEdge(*NBB, BB);
 875               double ew = getEdgeWeight(e);
 876               if (ew != MissingValue) {
 877                 iw += ew;
 878               }
 879             }
 880           }
 881           setEdgeWeight(e,iw * 10);
 882           FoundPath = true;
 883         }
 884       }
 885     }
 886     if (FoundPath) continue;
 887
 888     // Determine backedges, set them to zero.
 889     FI = Unvisited.begin(), FE = Unvisited.end();
 890     while(FI != FE && !FoundPath) {
 891       const BasicBlock *BB = *FI; ++FI;
 892       const BasicBlock *Dest = 0;
 893       Path P;
 894       bool BackEdgeFound = false;
 895       for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
 896            NBB != End; ++NBB) {
 897         Dest = GetPath(BB, *NBB, P, GetPathToDest | GetPathWithNewEdges);
 898         if (Dest == *NBB) {
 899           BackEdgeFound = true;
 900           break;
 901         }
 902       }
 903       if (BackEdgeFound) {
 904         Edge e = getEdge(Dest,BB);
 905         double w = getEdgeWeight(e);
 906         if (w == MissingValue) {
 907           setEdgeWeight(e,0);
 908           FoundPath = true;
 909         }
 910         do {
 911           Edge e = getEdge(P[Dest], Dest);
 912           double w = getEdgeWeight(e);
 913           if (w == MissingValue) {
 914             setEdgeWeight(e,0);
 915             FoundPath = true;
 916           }
 917           Dest = P[Dest];
 918         } while (Dest != BB);
 919       }
 920     }
 921     if (FoundPath) continue;
 922
 923     // Channel flow to return block.
 924     FI = Unvisited.begin(), FE = Unvisited.end();
 925     while(FI != FE && !FoundPath) {
 926       const BasicBlock *BB = *FI; ++FI;
 927
 928       Path P;
 929       const BasicBlock *Dest = GetPath(BB, 0, P, GetPathToExit | GetPathWithNewEdges);
 930       Dest = P[0];
 931       if (!Dest) continue;
 932
 933       if (getEdgeWeight(getEdge(Dest,0)) == MissingValue) {
 934         // Calculate incoming flow.
 935         double iw = 0;
 936         std::set<const BasicBlock *> Processed;
 937         for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
 938              NBB != End; ++NBB) {
 939           if (Processed.insert(*NBB).second) {
 940             Edge e = getEdge(*NBB, BB);
 941             double ew = getEdgeWeight(e);
 942             if (ew != MissingValue) {
 943               iw += ew;
 944             }
 945           }
 946         }
 947         do {
 948           Edge e = getEdge(P[Dest], Dest);
 949           double w = getEdgeWeight(e);
 950           if (w == MissingValue) {
 951             setEdgeWeight(e,iw);
 952             FoundPath = true;
 953           } else {
 954             assert(0 && "Edge should not have value already!");
 955           }
 956           Dest = P[Dest];
 957         } while (Dest != BB);
 958       }
 959     }
 960     if (FoundPath) continue;
 961
 962     // Speculatively set edges to zero.
 963     FI = Unvisited.begin(), FE = Unvisited.end();
 964     while(FI != FE && !FoundPath) {
 965       const BasicBlock *BB = *FI; ++FI;
 966
 967       for (const_pred_iterator NBB = pred_begin(BB), End = pred_end(BB);
 968            NBB != End; ++NBB) {
 969         Edge e = getEdge(*NBB,BB);
 970         double w = getEdgeWeight(e);
 971         if (w == MissingValue) {
 972           setEdgeWeight(e,0);
 973           FoundPath = true;
 974           break;
 975         }
 976       }
 977     }
 978     if (FoundPath) continue;
 979
 980     errs() << "{";
 981     FI = Unvisited.begin(), FE = Unvisited.end();
 982     while(FI != FE) {
 983       const BasicBlock *BB = *FI; ++FI;
 984       dbgs() << BB->getName();
 985       if (FI != FE)
 986         dbgs() << ",";
 987     }
 988     errs() << "}";
 989
 990     errs() << "ASSERT: could not repair function";
 991     assert(0 && "could not repair function");
 992   }
 993
 994   EdgeWeights J = EdgeInformation[F];
 995   for (EdgeWeights::iterator EI = J.begin(), EE = J.end(); EI != EE; ++EI) {
 996     Edge e = EI->first;
 997
 998     bool SuccFound = false;
 999     if (e.first != 0) {
1000       succ_const_iterator NBB = succ_begin(e.first), End = succ_end(e.first);
1001       if (NBB == End) {
1002         if (0 == e.second) {
1003           SuccFound = true;
1004         }
1005       }
1006       for (;NBB != End; ++NBB) {
1007         if (*NBB == e.second) {
1008           SuccFound = true;
1009           break;
1010         }
1011       }
1012       if (!SuccFound) {
1013         removeEdge(e);
1014       }
1015     }
1016   }
1017 }
1018
1019 raw_ostream& operator<<(raw_ostream &O, const Function *F) {
1020   return O << F->getName();
1021 }
1022
1023 raw_ostream& operator<<(raw_ostream &O, const MachineFunction *MF) {
1024   return O << MF->getFunction()->getName() << "(MF)";
1025 }
1026
1027 raw_ostream& operator<<(raw_ostream &O, const BasicBlock *BB) {
1028   return O << BB->getName();
1029 }
1030
1031 raw_ostream& operator<<(raw_ostream &O, const MachineBasicBlock *MBB) {
1032   return O << MBB->getBasicBlock()->getName() << "(MB)";
1033 }
1034
1035 raw_ostream& operator<<(raw_ostream &O, std::pair<const BasicBlock *, const BasicBlock *> E) {
1036   O << "(";
1037
1038   if (E.first)
1039     O << E.first;
1040   else
1041     O << "0";
1042
1043   O << ",";
1044
1045   if (E.second)
1046     O << E.second;
1047   else
1048     O << "0";
1049
1050   return O << ")";
1051 }
1052
1053 raw_ostream& operator<<(raw_ostream &O, std::pair<const MachineBasicBlock *, const MachineBasicBlock *> E) {
1054   O << "(";
1055
1056   if (E.first)
1057     O << E.first;
1058   else
1059     O << "0";
1060
1061   O << ",";
1062
1063   if (E.second)
1064     O << E.second;
1065   else
1066     O << "0";
1067
1068   return O << ")";
1069 }
1070
1071 } // namespace llvm
1072
1073 //===----------------------------------------------------------------------===//
1074 //  NoProfile ProfileInfo implementation
1075 //
1076
1077 namespace {
1078   struct NoProfileInfo : public ImmutablePass, public ProfileInfo {
1079     static char ID; // Class identification, replacement for typeinfo
1080     NoProfileInfo() : ImmutablePass(ID) {
1081       initializeNoProfileInfoPass(*PassRegistry::getPassRegistry());
1082     }
1083
1084     /// getAdjustedAnalysisPointer - This method is used when a pass implements
1085     /// an analysis interface through multiple inheritance.  If needed, it
1086     /// should override this to adjust the this pointer as needed for the
1087     /// specified pass info.
1088     virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
1089       if (PI == &ProfileInfo::ID)
1090         return (ProfileInfo*)this;
1091       return this;
1092     }
1093
1094     virtual const char *getPassName() const {
1095       return "NoProfileInfo";
1096     }
1097   };
1098 }  // End of anonymous namespace
1099
1100 char NoProfileInfo::ID = 0;
1101 // Register this pass...
1102 INITIALIZE_AG_PASS(NoProfileInfo, ProfileInfo, "no-profile",
1103                    "No Profile Information", false, true, true)
1104
1105 ImmutablePass *llvm::createNoProfileInfoPass() { return new NoProfileInfo(); }