lib/CodeGen/RenderMachineFunction.cpp

   1 //===-- llvm/CodeGen/RenderMachineFunction.cpp - MF->HTML -----s-----------===//
   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 #define DEBUG_TYPE "rendermf"
  11
  12 #include "RenderMachineFunction.h"
  13
  14 #include "VirtRegMap.h"
  15
  16 #include "llvm/Function.h"
  17 #include "llvm/Module.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/CodeGen/LiveIntervalAnalysis.h"
  20 #include "llvm/CodeGen/MachineFunction.h"
  21 #include "llvm/CodeGen/MachineInstr.h"
  22 #include "llvm/CodeGen/MachineRegisterInfo.h"
  23 #include "llvm/Support/CommandLine.h"
  24 #include "llvm/Support/Debug.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include "llvm/Target/TargetMachine.h"
  27
  28 #include <sstream>
  29
  30 using namespace llvm;
  31
  32 char RenderMachineFunction::ID = 0;
  33 INITIALIZE_PASS_BEGIN(RenderMachineFunction, "rendermf",
  34                 "Render machine functions (and related info) to HTML pages",
  35                 false, false)
  36 INITIALIZE_PASS_DEPENDENCY(SlotIndexes)
  37 INITIALIZE_PASS_DEPENDENCY(LiveIntervals)
  38 INITIALIZE_PASS_END(RenderMachineFunction, "rendermf",
  39                 "Render machine functions (and related info) to HTML pages",
  40                 false, false)
  41
  42 static cl::opt<std::string>
  43 outputFileSuffix("rmf-file-suffix",
  44                  cl::desc("Appended to function name to get output file name "
  45                           "(default: \".html\")"),
  46                  cl::init(".html"), cl::Hidden);
  47
  48 static cl::opt<std::string>
  49 machineFuncsToRender("rmf-funcs",
  50                      cl::desc("Coma seperated list of functions to render"
  51                               ", or \"*\"."),
  52                      cl::init(""), cl::Hidden);
  53
  54 static cl::opt<std::string>
  55 pressureClasses("rmf-classes",
  56                 cl::desc("Register classes to render pressure for."),
  57                 cl::init(""), cl::Hidden);
  58
  59 static cl::opt<std::string>
  60 showIntervals("rmf-intervals",
  61               cl::desc("Live intervals to show alongside code."),
  62               cl::init(""), cl::Hidden);
  63
  64 static cl::opt<bool>
  65 filterEmpty("rmf-filter-empty-intervals",
  66             cl::desc("Don't display empty intervals."),
  67             cl::init(true), cl::Hidden);
  68
  69 static cl::opt<bool>
  70 showEmptyIndexes("rmf-empty-indexes",
  71                  cl::desc("Render indexes not associated with instructions or "
  72                           "MBB starts."),
  73                  cl::init(false), cl::Hidden);
  74
  75 static cl::opt<bool>
  76 useFancyVerticals("rmf-fancy-verts",
  77                   cl::desc("Use SVG for vertical text."),
  78                   cl::init(true), cl::Hidden);
  79
  80 static cl::opt<bool>
  81 prettyHTML("rmf-pretty-html",
  82            cl::desc("Pretty print HTML. For debugging the renderer only.."),
  83            cl::init(false), cl::Hidden);
  84
  85
  86 namespace llvm {
  87
  88   bool MFRenderingOptions::renderingOptionsProcessed;
  89   std::set<std::string> MFRenderingOptions::mfNamesToRender;
  90   bool MFRenderingOptions::renderAllMFs = false;
  91
  92   std::set<std::string> MFRenderingOptions::classNamesToRender;
  93   bool MFRenderingOptions::renderAllClasses = false;
  94
  95   std::set<std::pair<unsigned, unsigned> >
  96     MFRenderingOptions::intervalNumsToRender;
  97   unsigned MFRenderingOptions::intervalTypesToRender = ExplicitOnly;
  98
  99   template <typename OutputItr>
 100   void MFRenderingOptions::splitComaSeperatedList(const std::string &s,
 101                                                          OutputItr outItr) {
 102     std::string::const_iterator curPos = s.begin();
 103     std::string::const_iterator nextComa = std::find(curPos, s.end(), ',');
 104     while (nextComa != s.end()) {
 105       std::string elem;
 106       std::copy(curPos, nextComa, std::back_inserter(elem));
 107       *outItr = elem;
 108       ++outItr;
 109       curPos = llvm::next(nextComa);
 110       nextComa = std::find(curPos, s.end(), ',');
 111     }
 112
 113     if (curPos != s.end()) {
 114       std::string elem;
 115       std::copy(curPos, s.end(), std::back_inserter(elem));
 116       *outItr = elem;
 117       ++outItr;
 118     }
 119   }
 120
 121   void MFRenderingOptions::processOptions() {
 122     if (!renderingOptionsProcessed) {
 123       processFuncNames();
 124       processRegClassNames();
 125       processIntervalNumbers();
 126       renderingOptionsProcessed = true;
 127     }
 128   }
 129
 130   void MFRenderingOptions::processFuncNames() {
 131     if (machineFuncsToRender == "*") {
 132       renderAllMFs = true;
 133     } else {
 134       splitComaSeperatedList(machineFuncsToRender,
 135                              std::inserter(mfNamesToRender,
 136                                            mfNamesToRender.begin()));
 137     }
 138   }
 139
 140   void MFRenderingOptions::processRegClassNames() {
 141     if (pressureClasses == "*") {
 142       renderAllClasses = true;
 143     } else {
 144       splitComaSeperatedList(pressureClasses,
 145                              std::inserter(classNamesToRender,
 146                                            classNamesToRender.begin()));
 147     }
 148   }
 149
 150   void MFRenderingOptions::processIntervalNumbers() {
 151     std::set<std::string> intervalRanges;
 152     splitComaSeperatedList(showIntervals,
 153                            std::inserter(intervalRanges,
 154                                          intervalRanges.begin()));
 155     std::for_each(intervalRanges.begin(), intervalRanges.end(),
 156                   processIntervalRange);
 157   }
 158
 159   void MFRenderingOptions::processIntervalRange(
 160                                           const std::string &intervalRangeStr) {
 161     if (intervalRangeStr == "*") {
 162       intervalTypesToRender |= All;
 163     } else if (intervalRangeStr == "virt-nospills*") {
 164       intervalTypesToRender |= VirtNoSpills;
 165     } else if (intervalRangeStr == "spills*") {
 166       intervalTypesToRender |= VirtSpills;
 167     } else if (intervalRangeStr == "virt*") {
 168       intervalTypesToRender |= AllVirt;
 169     } else if (intervalRangeStr == "phys*") {
 170       intervalTypesToRender |= AllPhys;
 171     } else {
 172       std::istringstream iss(intervalRangeStr);
 173       unsigned reg1, reg2;
 174       if ((iss >> reg1 >> std::ws)) {
 175         if (iss.eof()) {
 176           intervalNumsToRender.insert(std::make_pair(reg1, reg1 + 1));
 177         } else {
 178           char c;
 179           iss >> c;
 180           if (c == '-' && (iss >> reg2)) {
 181             intervalNumsToRender.insert(std::make_pair(reg1, reg2 + 1));
 182           } else {
 183             dbgs() << "Warning: Invalid interval range \""
 184                    << intervalRangeStr << "\" in -rmf-intervals. Skipping.\n";
 185           }
 186         }
 187       } else {
 188         dbgs() << "Warning: Invalid interval number \""
 189                << intervalRangeStr << "\" in -rmf-intervals. Skipping.\n";
 190       }
 191     }
 192   }
 193
 194   void MFRenderingOptions::setup(MachineFunction *mf,
 195                                  const TargetRegisterInfo *tri,
 196                                  LiveIntervals *lis,
 197                                  const RenderMachineFunction *rmf) {
 198     this->mf = mf;
 199     this->tri = tri;
 200     this->lis = lis;
 201     this->rmf = rmf;
 202
 203     clear();
 204   }
 205
 206   void MFRenderingOptions::clear() {
 207     regClassesTranslatedToCurrentFunction = false;
 208     regClassSet.clear();
 209
 210     intervalsTranslatedToCurrentFunction = false;
 211     intervalSet.clear();
 212   }
 213
 214   void MFRenderingOptions::resetRenderSpecificOptions() {
 215     intervalSet.clear();
 216     intervalsTranslatedToCurrentFunction = false;
 217   }
 218
 219   bool MFRenderingOptions::shouldRenderCurrentMachineFunction() const {
 220     processOptions();
 221
 222     return (renderAllMFs ||
 223             mfNamesToRender.find(mf->getFunction()->getName()) !=
 224               mfNamesToRender.end());
 225   }
 226
 227   const MFRenderingOptions::RegClassSet& MFRenderingOptions::regClasses() const{
 228     translateRegClassNamesToCurrentFunction();
 229     return regClassSet;
 230   }
 231
 232   const MFRenderingOptions::IntervalSet& MFRenderingOptions::intervals() const {
 233     translateIntervalNumbersToCurrentFunction();
 234     return intervalSet;
 235   }
 236
 237   bool MFRenderingOptions::renderEmptyIndexes() const {
 238     return showEmptyIndexes;
 239   }
 240
 241   bool MFRenderingOptions::fancyVerticals() const {
 242     return useFancyVerticals;
 243   }
 244
 245   void MFRenderingOptions::translateRegClassNamesToCurrentFunction() const {
 246     if (!regClassesTranslatedToCurrentFunction) {
 247       processOptions();
 248       for (TargetRegisterInfo::regclass_iterator rcItr = tri->regclass_begin(),
 249                                                  rcEnd = tri->regclass_end();
 250            rcItr != rcEnd; ++rcItr) {
 251         const TargetRegisterClass *trc = *rcItr;
 252         if (renderAllClasses ||
 253             classNamesToRender.find(trc->getName()) !=
 254               classNamesToRender.end()) {
 255           regClassSet.insert(trc);
 256         }
 257       }
 258       regClassesTranslatedToCurrentFunction = true;
 259     }
 260   }
 261
 262   void MFRenderingOptions::translateIntervalNumbersToCurrentFunction() const {
 263     if (!intervalsTranslatedToCurrentFunction) {
 264       processOptions();
 265
 266       // If we're not just doing explicit then do a copy over all matching
 267       // types.
 268       if (intervalTypesToRender != ExplicitOnly) {
 269         for (LiveIntervals::iterator liItr = lis->begin(), liEnd = lis->end();
 270              liItr != liEnd; ++liItr) {
 271           LiveInterval *li = liItr->second;
 272
 273           if (filterEmpty && li->empty())
 274             continue;
 275
 276           if ((TargetRegisterInfo::isPhysicalRegister(li->reg) &&
 277                (intervalTypesToRender & AllPhys))) {
 278             intervalSet.insert(li);
 279           } else if (TargetRegisterInfo::isVirtualRegister(li->reg)) {
 280             if (((intervalTypesToRender & VirtNoSpills) && !rmf->isSpill(li)) ||
 281                 ((intervalTypesToRender & VirtSpills) && rmf->isSpill(li))) {
 282               intervalSet.insert(li);
 283             }
 284           }
 285         }
 286       }
 287
 288       // If we need to process the explicit list...
 289       if (intervalTypesToRender != All) {
 290         for (std::set<std::pair<unsigned, unsigned> >::const_iterator
 291                regRangeItr = intervalNumsToRender.begin(),
 292                regRangeEnd = intervalNumsToRender.end();
 293              regRangeItr != regRangeEnd; ++regRangeItr) {
 294           const std::pair<unsigned, unsigned> &range = *regRangeItr;
 295           for (unsigned reg = range.first; reg != range.second; ++reg) {
 296             if (lis->hasInterval(reg)) {
 297               intervalSet.insert(&lis->getInterval(reg));
 298             }
 299           }
 300         }
 301       }
 302
 303       intervalsTranslatedToCurrentFunction = true;
 304     }
 305   }
 306
 307   // ---------- TargetRegisterExtraInformation implementation ----------
 308
 309   TargetRegisterExtraInfo::TargetRegisterExtraInfo()
 310     : mapsPopulated(false) {
 311   }
 312
 313   void TargetRegisterExtraInfo::setup(MachineFunction *mf,
 314                                       MachineRegisterInfo *mri,
 315                                       const TargetRegisterInfo *tri,
 316                                       LiveIntervals *lis) {
 317     this->mf = mf;
 318     this->mri = mri;
 319     this->tri = tri;
 320     this->lis = lis;
 321   }
 322
 323   void TargetRegisterExtraInfo::reset() {
 324     if (!mapsPopulated) {
 325       initWorst();
 326       //initBounds();
 327       initCapacity();
 328       mapsPopulated = true;
 329     }
 330
 331     resetPressureAndLiveStates();
 332   }
 333
 334   void TargetRegisterExtraInfo::clear() {
 335     prWorst.clear();
 336     vrWorst.clear();
 337     capacityMap.clear();
 338     pressureMap.clear();
 339     //liveStatesMap.clear();
 340     mapsPopulated = false;
 341   }
 342
 343   void TargetRegisterExtraInfo::initWorst() {
 344     assert(!mapsPopulated && prWorst.empty() && vrWorst.empty() &&
 345            "Worst map already initialised?");
 346
 347     // Start with the physical registers.
 348     for (unsigned preg = 1; preg < tri->getNumRegs(); ++preg) {
 349       WorstMapLine &pregLine = prWorst[preg];
 350
 351       for (TargetRegisterInfo::regclass_iterator rcItr = tri->regclass_begin(),
 352                                                  rcEnd = tri->regclass_end();
 353            rcItr != rcEnd; ++rcItr) {
 354         const TargetRegisterClass *trc = *rcItr;
 355
 356         unsigned numOverlaps = 0;
 357         for (TargetRegisterClass::iterator rItr = trc->begin(),
 358                                            rEnd = trc->end();
 359              rItr != rEnd; ++rItr) {
 360           unsigned trcPReg = *rItr;
 361           if (tri->regsOverlap(preg, trcPReg))
 362             ++numOverlaps;
 363         }
 364
 365         pregLine[trc] = numOverlaps;
 366       }
 367     }
 368
 369     // Now the register classes.
 370     for (TargetRegisterInfo::regclass_iterator rc1Itr = tri->regclass_begin(),
 371                                                rcEnd = tri->regclass_end();
 372          rc1Itr != rcEnd; ++rc1Itr) {
 373       const TargetRegisterClass *trc1 = *rc1Itr;
 374       WorstMapLine &classLine = vrWorst[trc1];
 375
 376       for (TargetRegisterInfo::regclass_iterator rc2Itr = tri->regclass_begin();
 377            rc2Itr != rcEnd; ++rc2Itr) {
 378         const TargetRegisterClass *trc2 = *rc2Itr;
 379
 380         unsigned worst = 0;
 381
 382         for (TargetRegisterClass::iterator trc1Itr = trc1->begin(),
 383                                            trc1End = trc1->end();
 384              trc1Itr != trc1End; ++trc1Itr) {
 385           unsigned trc1Reg = *trc1Itr;
 386           unsigned trc1RegWorst = 0;
 387
 388           for (TargetRegisterClass::iterator trc2Itr = trc2->begin(),
 389                                              trc2End = trc2->end();
 390                trc2Itr != trc2End; ++trc2Itr) {
 391             unsigned trc2Reg = *trc2Itr;
 392             if (tri->regsOverlap(trc1Reg, trc2Reg))
 393               ++trc1RegWorst;
 394           }
 395           if (trc1RegWorst > worst) {
 396             worst = trc1RegWorst;
 397           }
 398         }
 399
 400         if (worst != 0) {
 401           classLine[trc2] = worst;
 402         }
 403       }
 404     }
 405   }
 406
 407   unsigned TargetRegisterExtraInfo::getWorst(
 408                                         unsigned reg,
 409                                         const TargetRegisterClass *trc) const {
 410     const WorstMapLine *wml = 0;
 411     if (TargetRegisterInfo::isPhysicalRegister(reg)) {
 412       PRWorstMap::const_iterator prwItr = prWorst.find(reg);
 413       assert(prwItr != prWorst.end() && "Missing prWorst entry.");
 414       wml = &prwItr->second;
 415     } else {
 416       const TargetRegisterClass *regTRC = mri->getRegClass(reg);
 417       VRWorstMap::const_iterator vrwItr = vrWorst.find(regTRC);
 418       assert(vrwItr != vrWorst.end() && "Missing vrWorst entry.");
 419       wml = &vrwItr->second;
 420     }
 421
 422     WorstMapLine::const_iterator wmlItr = wml->find(trc);
 423     if (wmlItr == wml->end())
 424       return 0;
 425
 426     return wmlItr->second;
 427   }
 428
 429   void TargetRegisterExtraInfo::initCapacity() {
 430     assert(!mapsPopulated && capacityMap.empty() &&
 431            "Capacity map already initialised?");
 432
 433     for (TargetRegisterInfo::regclass_iterator rcItr = tri->regclass_begin(),
 434            rcEnd = tri->regclass_end();
 435          rcItr != rcEnd; ++rcItr) {
 436       const TargetRegisterClass *trc = *rcItr;
 437       unsigned capacity = std::distance(trc->allocation_order_begin(*mf),
 438                                         trc->allocation_order_end(*mf));
 439
 440       if (capacity != 0)
 441         capacityMap[trc] = capacity;
 442     }
 443   }
 444
 445   unsigned TargetRegisterExtraInfo::getCapacity(
 446                                          const TargetRegisterClass *trc) const {
 447     CapacityMap::const_iterator cmItr = capacityMap.find(trc);
 448     assert(cmItr != capacityMap.end() &&
 449            "vreg with unallocable register class");
 450     return cmItr->second;
 451   }
 452
 453   void TargetRegisterExtraInfo::resetPressureAndLiveStates() {
 454     pressureMap.clear();
 455     //liveStatesMap.clear();
 456
 457     // Iterate over all slots.
 458
 459
 460     // Iterate over all live intervals.
 461     for (LiveIntervals::iterator liItr = lis->begin(),
 462            liEnd = lis->end();
 463          liItr != liEnd; ++liItr) {
 464       LiveInterval *li = liItr->second;
 465
 466       const TargetRegisterClass *liTRC;
 467
 468       if (TargetRegisterInfo::isPhysicalRegister(li->reg))
 469         continue;
 470
 471       liTRC = mri->getRegClass(li->reg);
 472
 473
 474       // For all ranges in the current interal.
 475       for (LiveInterval::iterator lrItr = li->begin(),
 476              lrEnd = li->end();
 477            lrItr != lrEnd; ++lrItr) {
 478         LiveRange *lr = &*lrItr;
 479
 480         // For all slots in the current range.
 481         for (SlotIndex i = lr->start; i != lr->end; i = i.getNextSlot()) {
 482
 483           // Record increased pressure at index for all overlapping classes.
 484           for (TargetRegisterInfo::regclass_iterator
 485                  rcItr = tri->regclass_begin(),
 486                  rcEnd = tri->regclass_end();
 487                rcItr != rcEnd; ++rcItr) {
 488             const TargetRegisterClass *trc = *rcItr;
 489
 490             if (trc->allocation_order_begin(*mf) ==
 491                 trc->allocation_order_end(*mf))
 492               continue;
 493
 494             unsigned worstAtI = getWorst(li->reg, trc);
 495
 496             if (worstAtI != 0) {
 497               pressureMap[i][trc] += worstAtI;
 498             }
 499           }
 500         }
 501       }
 502     }
 503   }
 504
 505   unsigned TargetRegisterExtraInfo::getPressureAtSlot(
 506                                                  const TargetRegisterClass *trc,
 507                                                  SlotIndex i) const {
 508     PressureMap::const_iterator pmItr = pressureMap.find(i);
 509     if (pmItr == pressureMap.end())
 510       return 0;
 511     const PressureMapLine &pmLine = pmItr->second;
 512     PressureMapLine::const_iterator pmlItr = pmLine.find(trc);
 513     if (pmlItr == pmLine.end())
 514       return 0;
 515     return pmlItr->second;
 516   }
 517
 518   bool TargetRegisterExtraInfo::classOverCapacityAtSlot(
 519                                                  const TargetRegisterClass *trc,
 520                                                  SlotIndex i) const {
 521     return (getPressureAtSlot(trc, i) > getCapacity(trc));
 522   }
 523
 524   // ---------- MachineFunctionRenderer implementation ----------
 525
 526   void RenderMachineFunction::Spacer::print(raw_ostream &os) const {
 527     if (!prettyHTML)
 528       return;
 529     for (unsigned i = 0; i < ns; ++i) {
 530       os << " ";
 531     }
 532   }
 533
 534   RenderMachineFunction::Spacer RenderMachineFunction::s(unsigned ns) const {
 535     return Spacer(ns);
 536   }
 537
 538   raw_ostream& operator<<(raw_ostream &os, const RenderMachineFunction::Spacer &s) {
 539     s.print(os);
 540     return os;
 541   }
 542
 543   template <typename Iterator>
 544   std::string RenderMachineFunction::escapeChars(Iterator sBegin, Iterator sEnd) const {
 545     std::string r;
 546
 547     for (Iterator sItr = sBegin; sItr != sEnd; ++sItr) {
 548       char c = *sItr;
 549
 550       switch (c) {
 551         case '<': r.append("&lt;"); break;
 552         case '>': r.append("&gt;"); break;
 553         case '&': r.append("&amp;"); break;
 554         case ' ': r.append("&nbsp;"); break;
 555         case '\"': r.append("&quot;"); break;
 556         default: r.push_back(c); break;
 557       }
 558     }
 559
 560     return r;
 561   }
 562
 563   RenderMachineFunction::LiveState
 564   RenderMachineFunction::getLiveStateAt(const LiveInterval *li,
 565                                         SlotIndex i) const {
 566     const MachineInstr *mi = sis->getInstructionFromIndex(i);
 567
 568     // For uses/defs recorded use/def indexes override current liveness and
 569     // instruction operands (Only for the interval which records the indexes).
 570     if (i.isUse() || i.isDef()) {
 571       UseDefs::const_iterator udItr = useDefs.find(li);
 572       if (udItr != useDefs.end()) {
 573         const SlotSet &slotSet = udItr->second;
 574         if (slotSet.count(i)) {
 575           if (i.isUse()) {
 576             return Used;
 577           }
 578           // else
 579           return Defined;
 580         }
 581       }
 582     }
 583
 584     // If the slot is a load/store, or there's no info in the use/def set then
 585     // use liveness and instruction operand info.
 586     if (li->liveAt(i)) {
 587
 588       if (mi == 0) {
 589         if (vrm == 0 ||
 590             (vrm->getStackSlot(li->reg) == VirtRegMap::NO_STACK_SLOT)) {
 591           return AliveReg;
 592         } else {
 593           return AliveStack;
 594         }
 595       } else {
 596         if (i.isDef() && mi->definesRegister(li->reg, tri)) {
 597           return Defined;
 598         } else if (i.isUse() && mi->readsRegister(li->reg)) {
 599           return Used;
 600         } else {
 601           if (vrm == 0 ||
 602               (vrm->getStackSlot(li->reg) == VirtRegMap::NO_STACK_SLOT)) {
 603             return AliveReg;
 604           } else {
 605             return AliveStack;
 606           }
 607         }
 608       }
 609     }
 610     return Dead;
 611   }
 612
 613   RenderMachineFunction::PressureState
 614   RenderMachineFunction::getPressureStateAt(const TargetRegisterClass *trc,
 615                                               SlotIndex i) const {
 616     if (trei.getPressureAtSlot(trc, i) == 0) {
 617       return Zero;
 618     } else if (trei.classOverCapacityAtSlot(trc, i)){
 619       return High;
 620     }
 621     return Low;
 622   }
 623
 624   /// \brief Render a machine instruction.
 625   void RenderMachineFunction::renderMachineInstr(raw_ostream &os,
 626                                                  const MachineInstr *mi) const {
 627     std::string s;
 628     raw_string_ostream oss(s);
 629     oss << *mi;
 630
 631     os << escapeChars(oss.str());
 632   }
 633
 634   template <typename T>
 635   void RenderMachineFunction::renderVertical(const Spacer &indent,
 636                                              raw_ostream &os,
 637                                              const T &t) const {
 638     if (ro.fancyVerticals()) {
 639       os << indent << "<object\n"
 640          << indent + s(2) << "class=\"obj\"\n"
 641          << indent + s(2) << "type=\"image/svg+xml\"\n"
 642          << indent + s(2) << "width=\"14px\"\n"
 643          << indent + s(2) << "height=\"55px\"\n"
 644          << indent + s(2) << "data=\"data:image/svg+xml,\n"
 645          << indent + s(4) << "<svg xmlns='http://www.w3.org/2000/svg'>\n"
 646          << indent + s(6) << "<text x='-55' y='10' "
 647                              "font-family='Courier' font-size='12' "
 648                              "transform='rotate(-90)' "
 649                              "text-rendering='optimizeSpeed' "
 650                              "fill='#000'>" << t << "</text>\n"
 651          << indent + s(4) << "</svg>\">\n"
 652          << indent << "</object>\n";
 653     } else {
 654       std::ostringstream oss;
 655       oss << t;
 656       std::string tStr(oss.str());
 657
 658       os << indent;
 659       for (std::string::iterator tStrItr = tStr.begin(), tStrEnd = tStr.end();
 660            tStrItr != tStrEnd; ++tStrItr) {
 661         os << *tStrItr << "<br/>";
 662       }
 663       os << "\n";
 664     }
 665   }
 666
 667   void RenderMachineFunction::insertCSS(const Spacer &indent,
 668                                         raw_ostream &os) const {
 669     os << indent << "<style type=\"text/css\">\n"
 670        << indent + s(2) << "body { font-color: black; }\n"
 671        << indent + s(2) << "table.code td { font-family: monospace; "
 672                     "border-width: 0px; border-style: solid; "
 673                     "border-bottom: 1px solid #dddddd; white-space: nowrap; }\n"
 674        << indent + s(2) << "table.code td.p-z { background-color: #000000; }\n"
 675        << indent + s(2) << "table.code td.p-l { background-color: #00ff00; }\n"
 676        << indent + s(2) << "table.code td.p-h { background-color: #ff0000; }\n"
 677        << indent + s(2) << "table.code td.l-n { background-color: #ffffff; }\n"
 678        << indent + s(2) << "table.code td.l-d { background-color: #ff0000; }\n"
 679        << indent + s(2) << "table.code td.l-u { background-color: #ffff00; }\n"
 680        << indent + s(2) << "table.code td.l-r { background-color: #000000; }\n"
 681        << indent + s(2) << "table.code td.l-s { background-color: #770000; }\n"
 682        << indent + s(2) << "table.code th { border-width: 0px; "
 683                     "border-style: solid; }\n"
 684        << indent << "</style>\n";
 685   }
 686
 687   void RenderMachineFunction::renderFunctionSummary(
 688                                     const Spacer &indent, raw_ostream &os,
 689                                     const char * const renderContextStr) const {
 690     os << indent << "<h1>Function: " << mf->getFunction()->getName()
 691                  << "</h1>\n"
 692        << indent << "<h2>Rendering context: " << renderContextStr << "</h2>\n";
 693   }
 694
 695
 696   void RenderMachineFunction::renderPressureTableLegend(
 697                                                       const Spacer &indent,
 698                                                       raw_ostream &os) const {
 699     os << indent << "<h2>Rendering Pressure Legend:</h2>\n"
 700        << indent << "<table class=\"code\">\n"
 701        << indent + s(2) << "<tr>\n"
 702        << indent + s(4) << "<th>Pressure</th><th>Description</th>"
 703                     "<th>Appearance</th>\n"
 704        << indent + s(2) << "</tr>\n"
 705        << indent + s(2) << "<tr>\n"
 706        << indent + s(4) << "<td>No Pressure</td>"
 707                     "<td>No physical registers of this class requested.</td>"
 708                     "<td class=\"p-z\">&nbsp;&nbsp;</td>\n"
 709        << indent + s(2) << "</tr>\n"
 710        << indent + s(2) << "<tr>\n"
 711        << indent + s(4) << "<td>Low Pressure</td>"
 712                     "<td>Sufficient physical registers to meet demand.</td>"
 713                     "<td class=\"p-l\">&nbsp;&nbsp;</td>\n"
 714        << indent + s(2) << "</tr>\n"
 715        << indent + s(2) << "<tr>\n"
 716        << indent + s(4) << "<td>High Pressure</td>"
 717                     "<td>Potentially insufficient physical registers to meet demand.</td>"
 718                     "<td class=\"p-h\">&nbsp;&nbsp;</td>\n"
 719        << indent + s(2) << "</tr>\n"
 720        << indent << "</table>\n";
 721   }
 722
 723   template <typename CellType>
 724   void RenderMachineFunction::renderCellsWithRLE(
 725                    const Spacer &indent, raw_ostream &os,
 726                    const std::pair<CellType, unsigned> &rleAccumulator,
 727                    const std::map<CellType, std::string> &cellTypeStrs) const {
 728
 729     if (rleAccumulator.second == 0)
 730       return;
 731
 732     typename std::map<CellType, std::string>::const_iterator ctsItr =
 733       cellTypeStrs.find(rleAccumulator.first);
 734
 735     assert(ctsItr != cellTypeStrs.end() && "No string for given cell type.");
 736
 737     os << indent + s(4) << "<td class=\"" << ctsItr->second << "\"";
 738     if (rleAccumulator.second > 1)
 739       os << " colspan=" << rleAccumulator.second;
 740     os << "></td>\n";
 741   }
 742
 743
 744   void RenderMachineFunction::renderCodeTablePlusPI(const Spacer &indent,
 745                                                     raw_ostream &os) const {
 746
 747     std::map<LiveState, std::string> lsStrs;
 748     lsStrs[Dead] = "l-n";
 749     lsStrs[Defined] = "l-d";
 750     lsStrs[Used] = "l-u";
 751     lsStrs[AliveReg] = "l-r";
 752     lsStrs[AliveStack] = "l-s";
 753
 754     std::map<PressureState, std::string> psStrs;
 755     psStrs[Zero] = "p-z";
 756     psStrs[Low] = "p-l";
 757     psStrs[High] = "p-h";
 758
 759     // Open the table...
 760
 761     os << indent << "<table cellpadding=0 cellspacing=0 class=\"code\">\n"
 762        << indent + s(2) << "<tr>\n";
 763
 764     // Render the header row...
 765
 766     os << indent + s(4) << "<th>index</th>\n"
 767        << indent + s(4) << "<th>instr</th>\n";
 768
 769     // Render class names if necessary...
 770     if (!ro.regClasses().empty()) {
 771       for (MFRenderingOptions::RegClassSet::const_iterator
 772              rcItr = ro.regClasses().begin(),
 773              rcEnd = ro.regClasses().end();
 774            rcItr != rcEnd; ++rcItr) {
 775         const TargetRegisterClass *trc = *rcItr;
 776         os << indent + s(4) << "<th>\n";
 777         renderVertical(indent + s(6), os, trc->getName());
 778         os << indent + s(4) << "</th>\n";
 779       }
 780     }
 781
 782     // FIXME: Is there a nicer way to insert space between columns in HTML?
 783     if (!ro.regClasses().empty() && !ro.intervals().empty())
 784       os << indent + s(4) << "<th>&nbsp;&nbsp;</th>\n";
 785
 786     // Render interval numbers if necessary...
 787     if (!ro.intervals().empty()) {
 788       for (MFRenderingOptions::IntervalSet::const_iterator
 789              liItr = ro.intervals().begin(),
 790              liEnd = ro.intervals().end();
 791            liItr != liEnd; ++liItr) {
 792
 793         const LiveInterval *li = *liItr;
 794         os << indent + s(4) << "<th>\n";
 795         renderVertical(indent + s(6), os, li->reg);
 796         os << indent + s(4) << "</th>\n";
 797       }
 798     }
 799
 800     os << indent + s(2) << "</tr>\n";
 801
 802     // End header row, start with the data rows...
 803
 804     MachineInstr *mi = 0;
 805
 806     // Data rows:
 807     for (SlotIndex i = sis->getZeroIndex(); i != sis->getLastIndex();
 808          i = i.getNextSlot()) {
 809
 810       // Render the slot column.
 811       os << indent + s(2) << "<tr height=6ex>\n";
 812
 813       // Render the code column.
 814       if (i.isLoad()) {
 815         MachineBasicBlock *mbb = sis->getMBBFromIndex(i);
 816         mi = sis->getInstructionFromIndex(i);
 817
 818         if (i == sis->getMBBStartIdx(mbb) || mi != 0 ||
 819             ro.renderEmptyIndexes()) {
 820           os << indent + s(4) << "<td rowspan=4>" << i << "&nbsp;</td>\n"
 821              << indent + s(4) << "<td rowspan=4>\n";
 822
 823           if (i == sis->getMBBStartIdx(mbb)) {
 824             os << indent + s(6) << "BB#" << mbb->getNumber() << ":&nbsp;\n";
 825           } else if (mi != 0) {
 826             os << indent + s(6) << "&nbsp;&nbsp;";
 827             renderMachineInstr(os, mi);
 828           } else {
 829             // Empty interval - leave blank.
 830           }
 831           os << indent + s(4) << "</td>\n";
 832         } else {
 833           i = i.getStoreIndex(); // <- Will be incremented to the next index.
 834           continue;
 835         }
 836       }
 837
 838       // Render the class columns.
 839       if (!ro.regClasses().empty()) {
 840         std::pair<PressureState, unsigned> psRLEAccumulator(Zero, 0);
 841         for (MFRenderingOptions::RegClassSet::const_iterator
 842                rcItr = ro.regClasses().begin(),
 843                rcEnd = ro.regClasses().end();
 844              rcItr != rcEnd; ++rcItr) {
 845           const TargetRegisterClass *trc = *rcItr;
 846           PressureState newPressure = getPressureStateAt(trc, i);
 847
 848           if (newPressure == psRLEAccumulator.first) {
 849             ++psRLEAccumulator.second;
 850           } else {
 851             renderCellsWithRLE(indent + s(4), os, psRLEAccumulator, psStrs);
 852             psRLEAccumulator.first = newPressure;
 853             psRLEAccumulator.second = 1;
 854           }
 855         }
 856         renderCellsWithRLE(indent + s(4), os, psRLEAccumulator, psStrs);
 857       }
 858
 859       // FIXME: Is there a nicer way to insert space between columns in HTML?
 860       if (!ro.regClasses().empty() && !ro.intervals().empty())
 861         os << indent + s(4) << "<td width=2em></td>\n";
 862
 863       if (!ro.intervals().empty()) {
 864         std::pair<LiveState, unsigned> lsRLEAccumulator(Dead, 0);
 865         for (MFRenderingOptions::IntervalSet::const_iterator
 866                liItr = ro.intervals().begin(),
 867                liEnd = ro.intervals().end();
 868              liItr != liEnd; ++liItr) {
 869           const LiveInterval *li = *liItr;
 870           LiveState newLiveness = getLiveStateAt(li, i);
 871
 872           if (newLiveness == lsRLEAccumulator.first) {
 873             ++lsRLEAccumulator.second;
 874           } else {
 875             renderCellsWithRLE(indent + s(4), os, lsRLEAccumulator, lsStrs);
 876             lsRLEAccumulator.first = newLiveness;
 877             lsRLEAccumulator.second = 1;
 878           }
 879         }
 880         renderCellsWithRLE(indent + s(4), os, lsRLEAccumulator, lsStrs);
 881       }
 882       os << indent + s(2) << "</tr>\n";
 883     }
 884
 885     os << indent << "</table>\n";
 886
 887     if (!ro.regClasses().empty())
 888       renderPressureTableLegend(indent, os);
 889   }
 890
 891   void RenderMachineFunction::renderFunctionPage(
 892                                     raw_ostream &os,
 893                                     const char * const renderContextStr) const {
 894     os << "<html>\n"
 895        << s(2) << "<head>\n"
 896        << s(4) << "<title>" << fqn << "</title>\n";
 897
 898     insertCSS(s(4), os);
 899
 900     os << s(2) << "<head>\n"
 901        << s(2) << "<body >\n";
 902
 903     renderFunctionSummary(s(4), os, renderContextStr);
 904
 905     os << s(4) << "<br/><br/><br/>\n";
 906
 907     //renderLiveIntervalInfoTable("    ", os);
 908
 909     os << s(4) << "<br/><br/><br/>\n";
 910
 911     renderCodeTablePlusPI(s(4), os);
 912
 913     os << s(2) << "</body>\n"
 914        << "</html>\n";
 915   }
 916
 917   void RenderMachineFunction::getAnalysisUsage(AnalysisUsage &au) const {
 918     au.addRequired<SlotIndexes>();
 919     au.addRequired<LiveIntervals>();
 920     au.setPreservesAll();
 921     MachineFunctionPass::getAnalysisUsage(au);
 922   }
 923
 924   bool RenderMachineFunction::runOnMachineFunction(MachineFunction &fn) {
 925
 926     mf = &fn;
 927     mri = &mf->getRegInfo();
 928     tri = mf->getTarget().getRegisterInfo();
 929     lis = &getAnalysis<LiveIntervals>();
 930     sis = &getAnalysis<SlotIndexes>();
 931
 932     trei.setup(mf, mri, tri, lis);
 933     ro.setup(mf, tri, lis, this);
 934     spillIntervals.clear();
 935     spillFor.clear();
 936     useDefs.clear();
 937
 938     fqn = mf->getFunction()->getParent()->getModuleIdentifier() + "." +
 939           mf->getFunction()->getName().str();
 940
 941     return false;
 942   }
 943
 944   void RenderMachineFunction::releaseMemory() {
 945     trei.clear();
 946     ro.clear();
 947     spillIntervals.clear();
 948     spillFor.clear();
 949     useDefs.clear();
 950   }
 951
 952   void RenderMachineFunction::rememberUseDefs(const LiveInterval *li) {
 953
 954     if (!ro.shouldRenderCurrentMachineFunction())
 955       return;
 956
 957     for (MachineRegisterInfo::reg_iterator rItr = mri->reg_begin(li->reg),
 958                                            rEnd = mri->reg_end();
 959          rItr != rEnd; ++rItr) {
 960       const MachineInstr *mi = &*rItr;
 961       if (mi->readsRegister(li->reg)) {
 962         useDefs[li].insert(lis->getInstructionIndex(mi).getUseIndex());
 963       }
 964       if (mi->definesRegister(li->reg)) {
 965         useDefs[li].insert(lis->getInstructionIndex(mi).getDefIndex());
 966       }
 967     }
 968   }
 969
 970   void RenderMachineFunction::rememberSpills(
 971                                      const LiveInterval *li,
 972                                      const std::vector<LiveInterval*> &spills) {
 973
 974     if (!ro.shouldRenderCurrentMachineFunction())
 975       return;
 976
 977     for (std::vector<LiveInterval*>::const_iterator siItr = spills.begin(),
 978                                                     siEnd = spills.end();
 979          siItr != siEnd; ++siItr) {
 980       const LiveInterval *spill = *siItr;
 981       spillIntervals[li].insert(spill);
 982       spillFor[spill] = li;
 983     }
 984   }
 985
 986   bool RenderMachineFunction::isSpill(const LiveInterval *li) const {
 987     SpillForMap::const_iterator sfItr = spillFor.find(li);
 988     if (sfItr == spillFor.end())
 989       return false;
 990     return true;
 991   }
 992
 993   void RenderMachineFunction::renderMachineFunction(
 994                                                    const char *renderContextStr,
 995                                                    const VirtRegMap *vrm,
 996                                                    const char *renderSuffix) {
 997     if (!ro.shouldRenderCurrentMachineFunction())
 998       return;
 999
1000     this->vrm = vrm;
1001     trei.reset();
1002
1003     std::string rpFileName(mf->getFunction()->getName().str() +
1004                            (renderSuffix ? renderSuffix : "") +
1005                            outputFileSuffix);
1006
1007     std::string errMsg;
1008     raw_fd_ostream outFile(rpFileName.c_str(), errMsg, raw_fd_ostream::F_Binary);
1009
1010     renderFunctionPage(outFile, renderContextStr);
1011
1012     ro.resetRenderSpecificOptions();
1013   }
1014
1015   std::string RenderMachineFunction::escapeChars(const std::string &s) const {
1016     return escapeChars(s.begin(), s.end());
1017   }
1018
1019 }