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("Comma separated 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 = trc->getRawAllocationOrder(*mf).size();
 438
 439       if (capacity != 0)
 440         capacityMap[trc] = capacity;
 441     }
 442   }
 443
 444   unsigned TargetRegisterExtraInfo::getCapacity(
 445                                          const TargetRegisterClass *trc) const {
 446     CapacityMap::const_iterator cmItr = capacityMap.find(trc);
 447     assert(cmItr != capacityMap.end() &&
 448            "vreg with unallocable register class");
 449     return cmItr->second;
 450   }
 451
 452   void TargetRegisterExtraInfo::resetPressureAndLiveStates() {
 453     pressureMap.clear();
 454     //liveStatesMap.clear();
 455
 456     // Iterate over all slots.
 457
 458
 459     // Iterate over all live intervals.
 460     for (LiveIntervals::iterator liItr = lis->begin(),
 461            liEnd = lis->end();
 462          liItr != liEnd; ++liItr) {
 463       LiveInterval *li = liItr->second;
 464
 465       if (TargetRegisterInfo::isPhysicalRegister(li->reg))
 466         continue;
 467
 468       // For all ranges in the current interal.
 469       for (LiveInterval::iterator lrItr = li->begin(),
 470              lrEnd = li->end();
 471            lrItr != lrEnd; ++lrItr) {
 472         LiveRange *lr = &*lrItr;
 473
 474         // For all slots in the current range.
 475         for (SlotIndex i = lr->start; i != lr->end; i = i.getNextSlot()) {
 476
 477           // Record increased pressure at index for all overlapping classes.
 478           for (TargetRegisterInfo::regclass_iterator
 479                  rcItr = tri->regclass_begin(),
 480                  rcEnd = tri->regclass_end();
 481                rcItr != rcEnd; ++rcItr) {
 482             const TargetRegisterClass *trc = *rcItr;
 483
 484             if (trc->getRawAllocationOrder(*mf).empty())
 485               continue;
 486
 487             unsigned worstAtI = getWorst(li->reg, trc);
 488
 489             if (worstAtI != 0) {
 490               pressureMap[i][trc] += worstAtI;
 491             }
 492           }
 493         }
 494       }
 495     }
 496   }
 497
 498   unsigned TargetRegisterExtraInfo::getPressureAtSlot(
 499                                                  const TargetRegisterClass *trc,
 500                                                  SlotIndex i) const {
 501     PressureMap::const_iterator pmItr = pressureMap.find(i);
 502     if (pmItr == pressureMap.end())
 503       return 0;
 504     const PressureMapLine &pmLine = pmItr->second;
 505     PressureMapLine::const_iterator pmlItr = pmLine.find(trc);
 506     if (pmlItr == pmLine.end())
 507       return 0;
 508     return pmlItr->second;
 509   }
 510
 511   bool TargetRegisterExtraInfo::classOverCapacityAtSlot(
 512                                                  const TargetRegisterClass *trc,
 513                                                  SlotIndex i) const {
 514     return (getPressureAtSlot(trc, i) > getCapacity(trc));
 515   }
 516
 517   // ---------- MachineFunctionRenderer implementation ----------
 518
 519   void RenderMachineFunction::Spacer::print(raw_ostream &os) const {
 520     if (!prettyHTML)
 521       return;
 522     for (unsigned i = 0; i < ns; ++i) {
 523       os << " ";
 524     }
 525   }
 526
 527   RenderMachineFunction::Spacer RenderMachineFunction::s(unsigned ns) const {
 528     return Spacer(ns);
 529   }
 530
 531   raw_ostream& operator<<(raw_ostream &os, const RenderMachineFunction::Spacer &s) {
 532     s.print(os);
 533     return os;
 534   }
 535
 536   template <typename Iterator>
 537   std::string RenderMachineFunction::escapeChars(Iterator sBegin, Iterator sEnd) const {
 538     std::string r;
 539
 540     for (Iterator sItr = sBegin; sItr != sEnd; ++sItr) {
 541       char c = *sItr;
 542
 543       switch (c) {
 544         case '<': r.append("&lt;"); break;
 545         case '>': r.append("&gt;"); break;
 546         case '&': r.append("&amp;"); break;
 547         case ' ': r.append("&nbsp;"); break;
 548         case '\"': r.append("&quot;"); break;
 549         default: r.push_back(c); break;
 550       }
 551     }
 552
 553     return r;
 554   }
 555
 556   RenderMachineFunction::LiveState
 557   RenderMachineFunction::getLiveStateAt(const LiveInterval *li,
 558                                         SlotIndex i) const {
 559     const MachineInstr *mi = sis->getInstructionFromIndex(i);
 560
 561     // For uses/defs recorded use/def indexes override current liveness and
 562     // instruction operands (Only for the interval which records the indexes).
 563     if (i.isUse() || i.isDef()) {
 564       UseDefs::const_iterator udItr = useDefs.find(li);
 565       if (udItr != useDefs.end()) {
 566         const SlotSet &slotSet = udItr->second;
 567         if (slotSet.count(i)) {
 568           if (i.isUse()) {
 569             return Used;
 570           }
 571           // else
 572           return Defined;
 573         }
 574       }
 575     }
 576
 577     // If the slot is a load/store, or there's no info in the use/def set then
 578     // use liveness and instruction operand info.
 579     if (li->liveAt(i)) {
 580
 581       if (mi == 0) {
 582         if (vrm == 0 ||
 583             (vrm->getStackSlot(li->reg) == VirtRegMap::NO_STACK_SLOT)) {
 584           return AliveReg;
 585         } else {
 586           return AliveStack;
 587         }
 588       } else {
 589         if (i.isDef() && mi->definesRegister(li->reg, tri)) {
 590           return Defined;
 591         } else if (i.isUse() && mi->readsRegister(li->reg)) {
 592           return Used;
 593         } else {
 594           if (vrm == 0 ||
 595               (vrm->getStackSlot(li->reg) == VirtRegMap::NO_STACK_SLOT)) {
 596             return AliveReg;
 597           } else {
 598             return AliveStack;
 599           }
 600         }
 601       }
 602     }
 603     return Dead;
 604   }
 605
 606   RenderMachineFunction::PressureState
 607   RenderMachineFunction::getPressureStateAt(const TargetRegisterClass *trc,
 608                                               SlotIndex i) const {
 609     if (trei.getPressureAtSlot(trc, i) == 0) {
 610       return Zero;
 611     } else if (trei.classOverCapacityAtSlot(trc, i)){
 612       return High;
 613     }
 614     return Low;
 615   }
 616
 617   /// \brief Render a machine instruction.
 618   void RenderMachineFunction::renderMachineInstr(raw_ostream &os,
 619                                                  const MachineInstr *mi) const {
 620     std::string s;
 621     raw_string_ostream oss(s);
 622     oss << *mi;
 623
 624     os << escapeChars(oss.str());
 625   }
 626
 627   template <typename T>
 628   void RenderMachineFunction::renderVertical(const Spacer &indent,
 629                                              raw_ostream &os,
 630                                              const T &t) const {
 631     if (ro.fancyVerticals()) {
 632       os << indent << "<object\n"
 633          << indent + s(2) << "class=\"obj\"\n"
 634          << indent + s(2) << "type=\"image/svg+xml\"\n"
 635          << indent + s(2) << "width=\"14px\"\n"
 636          << indent + s(2) << "height=\"55px\"\n"
 637          << indent + s(2) << "data=\"data:image/svg+xml,\n"
 638          << indent + s(4) << "<svg xmlns='http://www.w3.org/2000/svg'>\n"
 639          << indent + s(6) << "<text x='-55' y='10' "
 640                              "font-family='Courier' font-size='12' "
 641                              "transform='rotate(-90)' "
 642                              "text-rendering='optimizeSpeed' "
 643                              "fill='#000'>" << t << "</text>\n"
 644          << indent + s(4) << "</svg>\">\n"
 645          << indent << "</object>\n";
 646     } else {
 647       std::ostringstream oss;
 648       oss << t;
 649       std::string tStr(oss.str());
 650
 651       os << indent;
 652       for (std::string::iterator tStrItr = tStr.begin(), tStrEnd = tStr.end();
 653            tStrItr != tStrEnd; ++tStrItr) {
 654         os << *tStrItr << "<br/>";
 655       }
 656       os << "\n";
 657     }
 658   }
 659
 660   void RenderMachineFunction::insertCSS(const Spacer &indent,
 661                                         raw_ostream &os) const {
 662     os << indent << "<style type=\"text/css\">\n"
 663        << indent + s(2) << "body { font-color: black; }\n"
 664        << indent + s(2) << "table.code td { font-family: monospace; "
 665                     "border-width: 0px; border-style: solid; "
 666                     "border-bottom: 1px solid #dddddd; white-space: nowrap; }\n"
 667        << indent + s(2) << "table.code td.p-z { background-color: #000000; }\n"
 668        << indent + s(2) << "table.code td.p-l { background-color: #00ff00; }\n"
 669        << indent + s(2) << "table.code td.p-h { background-color: #ff0000; }\n"
 670        << indent + s(2) << "table.code td.l-n { background-color: #ffffff; }\n"
 671        << indent + s(2) << "table.code td.l-d { background-color: #ff0000; }\n"
 672        << indent + s(2) << "table.code td.l-u { background-color: #ffff00; }\n"
 673        << indent + s(2) << "table.code td.l-r { background-color: #000000; }\n"
 674        << indent + s(2) << "table.code td.l-s { background-color: #770000; }\n"
 675        << indent + s(2) << "table.code th { border-width: 0px; "
 676                     "border-style: solid; }\n"
 677        << indent << "</style>\n";
 678   }
 679
 680   void RenderMachineFunction::renderFunctionSummary(
 681                                     const Spacer &indent, raw_ostream &os,
 682                                     const char * const renderContextStr) const {
 683     os << indent << "<h1>Function: " << mf->getFunction()->getName()
 684                  << "</h1>\n"
 685        << indent << "<h2>Rendering context: " << renderContextStr << "</h2>\n";
 686   }
 687
 688
 689   void RenderMachineFunction::renderPressureTableLegend(
 690                                                       const Spacer &indent,
 691                                                       raw_ostream &os) const {
 692     os << indent << "<h2>Rendering Pressure Legend:</h2>\n"
 693        << indent << "<table class=\"code\">\n"
 694        << indent + s(2) << "<tr>\n"
 695        << indent + s(4) << "<th>Pressure</th><th>Description</th>"
 696                     "<th>Appearance</th>\n"
 697        << indent + s(2) << "</tr>\n"
 698        << indent + s(2) << "<tr>\n"
 699        << indent + s(4) << "<td>No Pressure</td>"
 700                     "<td>No physical registers of this class requested.</td>"
 701                     "<td class=\"p-z\">&nbsp;&nbsp;</td>\n"
 702        << indent + s(2) << "</tr>\n"
 703        << indent + s(2) << "<tr>\n"
 704        << indent + s(4) << "<td>Low Pressure</td>"
 705                     "<td>Sufficient physical registers to meet demand.</td>"
 706                     "<td class=\"p-l\">&nbsp;&nbsp;</td>\n"
 707        << indent + s(2) << "</tr>\n"
 708        << indent + s(2) << "<tr>\n"
 709        << indent + s(4) << "<td>High Pressure</td>"
 710                     "<td>Potentially insufficient physical registers to meet demand.</td>"
 711                     "<td class=\"p-h\">&nbsp;&nbsp;</td>\n"
 712        << indent + s(2) << "</tr>\n"
 713        << indent << "</table>\n";
 714   }
 715
 716   template <typename CellType>
 717   void RenderMachineFunction::renderCellsWithRLE(
 718                    const Spacer &indent, raw_ostream &os,
 719                    const std::pair<CellType, unsigned> &rleAccumulator,
 720                    const std::map<CellType, std::string> &cellTypeStrs) const {
 721
 722     if (rleAccumulator.second == 0)
 723       return;
 724
 725     typename std::map<CellType, std::string>::const_iterator ctsItr =
 726       cellTypeStrs.find(rleAccumulator.first);
 727
 728     assert(ctsItr != cellTypeStrs.end() && "No string for given cell type.");
 729
 730     os << indent + s(4) << "<td class=\"" << ctsItr->second << "\"";
 731     if (rleAccumulator.second > 1)
 732       os << " colspan=" << rleAccumulator.second;
 733     os << "></td>\n";
 734   }
 735
 736
 737   void RenderMachineFunction::renderCodeTablePlusPI(const Spacer &indent,
 738                                                     raw_ostream &os) const {
 739
 740     std::map<LiveState, std::string> lsStrs;
 741     lsStrs[Dead] = "l-n";
 742     lsStrs[Defined] = "l-d";
 743     lsStrs[Used] = "l-u";
 744     lsStrs[AliveReg] = "l-r";
 745     lsStrs[AliveStack] = "l-s";
 746
 747     std::map<PressureState, std::string> psStrs;
 748     psStrs[Zero] = "p-z";
 749     psStrs[Low] = "p-l";
 750     psStrs[High] = "p-h";
 751
 752     // Open the table...
 753
 754     os << indent << "<table cellpadding=0 cellspacing=0 class=\"code\">\n"
 755        << indent + s(2) << "<tr>\n";
 756
 757     // Render the header row...
 758
 759     os << indent + s(4) << "<th>index</th>\n"
 760        << indent + s(4) << "<th>instr</th>\n";
 761
 762     // Render class names if necessary...
 763     if (!ro.regClasses().empty()) {
 764       for (MFRenderingOptions::RegClassSet::const_iterator
 765              rcItr = ro.regClasses().begin(),
 766              rcEnd = ro.regClasses().end();
 767            rcItr != rcEnd; ++rcItr) {
 768         const TargetRegisterClass *trc = *rcItr;
 769         os << indent + s(4) << "<th>\n";
 770         renderVertical(indent + s(6), os, trc->getName());
 771         os << indent + s(4) << "</th>\n";
 772       }
 773     }
 774
 775     // FIXME: Is there a nicer way to insert space between columns in HTML?
 776     if (!ro.regClasses().empty() && !ro.intervals().empty())
 777       os << indent + s(4) << "<th>&nbsp;&nbsp;</th>\n";
 778
 779     // Render interval numbers if necessary...
 780     if (!ro.intervals().empty()) {
 781       for (MFRenderingOptions::IntervalSet::const_iterator
 782              liItr = ro.intervals().begin(),
 783              liEnd = ro.intervals().end();
 784            liItr != liEnd; ++liItr) {
 785
 786         const LiveInterval *li = *liItr;
 787         os << indent + s(4) << "<th>\n";
 788         renderVertical(indent + s(6), os, li->reg);
 789         os << indent + s(4) << "</th>\n";
 790       }
 791     }
 792
 793     os << indent + s(2) << "</tr>\n";
 794
 795     // End header row, start with the data rows...
 796
 797     MachineInstr *mi = 0;
 798
 799     // Data rows:
 800     for (SlotIndex i = sis->getZeroIndex(); i != sis->getLastIndex();
 801          i = i.getNextSlot()) {
 802
 803       // Render the slot column.
 804       os << indent + s(2) << "<tr height=6ex>\n";
 805
 806       // Render the code column.
 807       if (i.isLoad()) {
 808         MachineBasicBlock *mbb = sis->getMBBFromIndex(i);
 809         mi = sis->getInstructionFromIndex(i);
 810
 811         if (i == sis->getMBBStartIdx(mbb) || mi != 0 ||
 812             ro.renderEmptyIndexes()) {
 813           os << indent + s(4) << "<td rowspan=4>" << i << "&nbsp;</td>\n"
 814              << indent + s(4) << "<td rowspan=4>\n";
 815
 816           if (i == sis->getMBBStartIdx(mbb)) {
 817             os << indent + s(6) << "BB#" << mbb->getNumber() << ":&nbsp;\n";
 818           } else if (mi != 0) {
 819             os << indent + s(6) << "&nbsp;&nbsp;";
 820             renderMachineInstr(os, mi);
 821           } else {
 822             // Empty interval - leave blank.
 823           }
 824           os << indent + s(4) << "</td>\n";
 825         } else {
 826           i = i.getStoreIndex(); // <- Will be incremented to the next index.
 827           continue;
 828         }
 829       }
 830
 831       // Render the class columns.
 832       if (!ro.regClasses().empty()) {
 833         std::pair<PressureState, unsigned> psRLEAccumulator(Zero, 0);
 834         for (MFRenderingOptions::RegClassSet::const_iterator
 835                rcItr = ro.regClasses().begin(),
 836                rcEnd = ro.regClasses().end();
 837              rcItr != rcEnd; ++rcItr) {
 838           const TargetRegisterClass *trc = *rcItr;
 839           PressureState newPressure = getPressureStateAt(trc, i);
 840
 841           if (newPressure == psRLEAccumulator.first) {
 842             ++psRLEAccumulator.second;
 843           } else {
 844             renderCellsWithRLE(indent + s(4), os, psRLEAccumulator, psStrs);
 845             psRLEAccumulator.first = newPressure;
 846             psRLEAccumulator.second = 1;
 847           }
 848         }
 849         renderCellsWithRLE(indent + s(4), os, psRLEAccumulator, psStrs);
 850       }
 851
 852       // FIXME: Is there a nicer way to insert space between columns in HTML?
 853       if (!ro.regClasses().empty() && !ro.intervals().empty())
 854         os << indent + s(4) << "<td width=2em></td>\n";
 855
 856       if (!ro.intervals().empty()) {
 857         std::pair<LiveState, unsigned> lsRLEAccumulator(Dead, 0);
 858         for (MFRenderingOptions::IntervalSet::const_iterator
 859                liItr = ro.intervals().begin(),
 860                liEnd = ro.intervals().end();
 861              liItr != liEnd; ++liItr) {
 862           const LiveInterval *li = *liItr;
 863           LiveState newLiveness = getLiveStateAt(li, i);
 864
 865           if (newLiveness == lsRLEAccumulator.first) {
 866             ++lsRLEAccumulator.second;
 867           } else {
 868             renderCellsWithRLE(indent + s(4), os, lsRLEAccumulator, lsStrs);
 869             lsRLEAccumulator.first = newLiveness;
 870             lsRLEAccumulator.second = 1;
 871           }
 872         }
 873         renderCellsWithRLE(indent + s(4), os, lsRLEAccumulator, lsStrs);
 874       }
 875       os << indent + s(2) << "</tr>\n";
 876     }
 877
 878     os << indent << "</table>\n";
 879
 880     if (!ro.regClasses().empty())
 881       renderPressureTableLegend(indent, os);
 882   }
 883
 884   void RenderMachineFunction::renderFunctionPage(
 885                                     raw_ostream &os,
 886                                     const char * const renderContextStr) const {
 887     os << "<html>\n"
 888        << s(2) << "<head>\n"
 889        << s(4) << "<title>" << fqn << "</title>\n";
 890
 891     insertCSS(s(4), os);
 892
 893     os << s(2) << "<head>\n"
 894        << s(2) << "<body >\n";
 895
 896     renderFunctionSummary(s(4), os, renderContextStr);
 897
 898     os << s(4) << "<br/><br/><br/>\n";
 899
 900     //renderLiveIntervalInfoTable("    ", os);
 901
 902     os << s(4) << "<br/><br/><br/>\n";
 903
 904     renderCodeTablePlusPI(s(4), os);
 905
 906     os << s(2) << "</body>\n"
 907        << "</html>\n";
 908   }
 909
 910   void RenderMachineFunction::getAnalysisUsage(AnalysisUsage &au) const {
 911     au.addRequired<SlotIndexes>();
 912     au.addRequired<LiveIntervals>();
 913     au.setPreservesAll();
 914     MachineFunctionPass::getAnalysisUsage(au);
 915   }
 916
 917   bool RenderMachineFunction::runOnMachineFunction(MachineFunction &fn) {
 918
 919     mf = &fn;
 920     mri = &mf->getRegInfo();
 921     tri = mf->getTarget().getRegisterInfo();
 922     lis = &getAnalysis<LiveIntervals>();
 923     sis = &getAnalysis<SlotIndexes>();
 924
 925     trei.setup(mf, mri, tri, lis);
 926     ro.setup(mf, tri, lis, this);
 927     spillIntervals.clear();
 928     spillFor.clear();
 929     useDefs.clear();
 930
 931     fqn = mf->getFunction()->getParent()->getModuleIdentifier() + "." +
 932           mf->getFunction()->getName().str();
 933
 934     return false;
 935   }
 936
 937   void RenderMachineFunction::releaseMemory() {
 938     trei.clear();
 939     ro.clear();
 940     spillIntervals.clear();
 941     spillFor.clear();
 942     useDefs.clear();
 943   }
 944
 945   void RenderMachineFunction::rememberUseDefs(const LiveInterval *li) {
 946
 947     if (!ro.shouldRenderCurrentMachineFunction())
 948       return;
 949
 950     for (MachineRegisterInfo::reg_iterator rItr = mri->reg_begin(li->reg),
 951                                            rEnd = mri->reg_end();
 952          rItr != rEnd; ++rItr) {
 953       const MachineInstr *mi = &*rItr;
 954       if (mi->readsRegister(li->reg)) {
 955         useDefs[li].insert(lis->getInstructionIndex(mi).getUseIndex());
 956       }
 957       if (mi->definesRegister(li->reg)) {
 958         useDefs[li].insert(lis->getInstructionIndex(mi).getDefIndex());
 959       }
 960     }
 961   }
 962
 963   void RenderMachineFunction::rememberSpills(
 964                                      const LiveInterval *li,
 965                                      const std::vector<LiveInterval*> &spills) {
 966
 967     if (!ro.shouldRenderCurrentMachineFunction())
 968       return;
 969
 970     for (std::vector<LiveInterval*>::const_iterator siItr = spills.begin(),
 971                                                     siEnd = spills.end();
 972          siItr != siEnd; ++siItr) {
 973       const LiveInterval *spill = *siItr;
 974       spillIntervals[li].insert(spill);
 975       spillFor[spill] = li;
 976     }
 977   }
 978
 979   bool RenderMachineFunction::isSpill(const LiveInterval *li) const {
 980     SpillForMap::const_iterator sfItr = spillFor.find(li);
 981     if (sfItr == spillFor.end())
 982       return false;
 983     return true;
 984   }
 985
 986   void RenderMachineFunction::renderMachineFunction(
 987                                                    const char *renderContextStr,
 988                                                    const VirtRegMap *vrm,
 989                                                    const char *renderSuffix) {
 990     if (!ro.shouldRenderCurrentMachineFunction())
 991       return;
 992
 993     this->vrm = vrm;
 994     trei.reset();
 995
 996     std::string rpFileName(mf->getFunction()->getName().str() +
 997                            (renderSuffix ? renderSuffix : "") +
 998                            outputFileSuffix);
 999
1000     std::string errMsg;
1001     raw_fd_ostream outFile(rpFileName.c_str(), errMsg, raw_fd_ostream::F_Binary);
1002
1003     renderFunctionPage(outFile, renderContextStr);
1004
1005     ro.resetRenderSpecificOptions();
1006   }
1007
1008   std::string RenderMachineFunction::escapeChars(const std::string &s) const {
1009     return escapeChars(s.begin(), s.end());
1010   }
1011
1012 }