contrib/llvm/lib/CodeGen/RenderMachineFunction.h

   1 //===-- llvm/CodeGen/RenderMachineFunction.h - MF->HTML -*- C++ -*---------===//
   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 //===----------------------------------------------------------------------===//
  11
  12 #ifndef LLVM_CODEGEN_RENDERMACHINEFUNCTION_H
  13 #define LLVM_CODEGEN_RENDERMACHINEFUNCTION_H
  14
  15 #include "llvm/CodeGen/LiveInterval.h"
  16 #include "llvm/CodeGen/MachineFunctionPass.h"
  17 #include "llvm/CodeGen/SlotIndexes.h"
  18 #include "llvm/Target/TargetRegisterInfo.h"
  19
  20 #include <algorithm>
  21 #include <map>
  22 #include <set>
  23 #include <string>
  24
  25 namespace llvm {
  26
  27   class LiveInterval;
  28   class LiveIntervals;
  29   class MachineInstr;
  30   class MachineRegisterInfo;
  31   class RenderMachineFunction;
  32   class TargetRegisterClass;
  33   class TargetRegisterInfo;
  34   class VirtRegMap;
  35   class raw_ostream;
  36
  37   /// \brief Helper class to process rendering options. Tries to be as lazy as
  38   ///        possible.
  39   class MFRenderingOptions {
  40   public:
  41
  42     struct RegClassComp {
  43       bool operator()(const TargetRegisterClass *trc1,
  44                       const TargetRegisterClass *trc2) const {
  45         std::string trc1Name(trc1->getName()), trc2Name(trc2->getName());
  46         return std::lexicographical_compare(trc1Name.begin(), trc1Name.end(),
  47                                             trc2Name.begin(), trc2Name.end());
  48       }
  49     };
  50
  51     typedef std::set<const TargetRegisterClass*, RegClassComp> RegClassSet;
  52
  53     struct IntervalComp {
  54       bool operator()(const LiveInterval *li1, const LiveInterval *li2) const {
  55         return li1->reg < li2->reg;
  56       }
  57     };
  58
  59     typedef std::set<const LiveInterval*, IntervalComp> IntervalSet;
  60
  61     /// Initialise the rendering options.
  62     void setup(MachineFunction *mf, const TargetRegisterInfo *tri,
  63                LiveIntervals *lis, const RenderMachineFunction *rmf);
  64
  65     /// Clear translations of options to the current function.
  66     void clear();
  67
  68     /// Reset any options computed for this specific rendering.
  69     void resetRenderSpecificOptions();
  70
  71     /// Should we render the current function.
  72     bool shouldRenderCurrentMachineFunction() const;
  73
  74     /// Return the set of register classes to render pressure for.
  75     const RegClassSet& regClasses() const;
  76
  77     /// Return the set of live intervals to render liveness for.
  78     const IntervalSet& intervals() const;
  79
  80     /// Render indexes which are not associated with instructions / MBB starts.
  81     bool renderEmptyIndexes() const;
  82
  83     /// Return whether or not to render using SVG for fancy vertical text.
  84     bool fancyVerticals() const;
  85
  86   private:
  87
  88     static bool renderingOptionsProcessed;
  89     static std::set<std::string> mfNamesToRender;
  90     static bool renderAllMFs;
  91
  92     static std::set<std::string> classNamesToRender;
  93     static bool renderAllClasses;
  94
  95
  96     static std::set<std::pair<unsigned, unsigned> > intervalNumsToRender;
  97     typedef enum { ExplicitOnly     = 0,
  98                    AllPhys          = 1,
  99                    VirtNoSpills     = 2,
 100                    VirtSpills       = 4,
 101                    AllVirt          = 6,
 102                    All              = 7 }
 103       IntervalTypesToRender;
 104     static unsigned intervalTypesToRender;
 105
 106     template <typename OutputItr>
 107     static void splitComaSeperatedList(const std::string &s, OutputItr outItr);
 108
 109     static void processOptions();
 110
 111     static void processFuncNames();
 112     static void processRegClassNames();
 113     static void processIntervalNumbers();
 114
 115     static void processIntervalRange(const std::string &intervalRangeStr);
 116
 117     MachineFunction *mf;
 118     const TargetRegisterInfo *tri;
 119     LiveIntervals *lis;
 120     const RenderMachineFunction *rmf;
 121
 122     mutable bool regClassesTranslatedToCurrentFunction;
 123     mutable RegClassSet regClassSet;
 124
 125     mutable bool intervalsTranslatedToCurrentFunction;
 126     mutable IntervalSet intervalSet;
 127
 128     void translateRegClassNamesToCurrentFunction() const;
 129
 130     void translateIntervalNumbersToCurrentFunction() const;
 131   };
 132
 133   /// \brief Provide extra information about the physical and virtual registers
 134   ///        in the function being compiled.
 135   class TargetRegisterExtraInfo {
 136   public:
 137     TargetRegisterExtraInfo();
 138
 139     /// \brief Set up TargetRegisterExtraInfo with pointers to necessary
 140     ///        sources of information.
 141     void setup(MachineFunction *mf, MachineRegisterInfo *mri,
 142                const TargetRegisterInfo *tri, LiveIntervals *lis);
 143
 144     /// \brief Recompute tables for changed function.
 145     void reset();
 146
 147     /// \brief Free all tables in TargetRegisterExtraInfo.
 148     void clear();
 149
 150     /// \brief Maximum number of registers from trc which alias reg.
 151     unsigned getWorst(unsigned reg, const TargetRegisterClass *trc) const;
 152
 153     /// \brief Returns the number of allocable registers in trc.
 154     unsigned getCapacity(const TargetRegisterClass *trc) const;
 155
 156     /// \brief Return the number of registers of class trc that may be
 157     ///        needed at slot i.
 158     unsigned getPressureAtSlot(const TargetRegisterClass *trc,
 159                                SlotIndex i) const;
 160
 161     /// \brief Return true if the number of registers of type trc that may be
 162     ///        needed at slot i is greater than the capacity of trc.
 163     bool classOverCapacityAtSlot(const TargetRegisterClass *trc,
 164                                  SlotIndex i) const;
 165
 166   private:
 167
 168     MachineFunction *mf;
 169     MachineRegisterInfo *mri;
 170     const TargetRegisterInfo *tri;
 171     LiveIntervals *lis;
 172
 173     typedef std::map<const TargetRegisterClass*, unsigned> WorstMapLine;
 174     typedef std::map<const TargetRegisterClass*, WorstMapLine> VRWorstMap;
 175     VRWorstMap vrWorst;
 176
 177     typedef std::map<unsigned, WorstMapLine> PRWorstMap;
 178     PRWorstMap prWorst;
 179
 180     typedef std::map<const TargetRegisterClass*, unsigned> CapacityMap;
 181     CapacityMap capacityMap;
 182
 183     typedef std::map<const TargetRegisterClass*, unsigned> PressureMapLine;
 184     typedef std::map<SlotIndex, PressureMapLine> PressureMap;
 185     PressureMap pressureMap;
 186
 187     bool mapsPopulated;
 188
 189     /// \brief Initialise the 'worst' table.
 190     void initWorst();
 191
 192     /// \brief Initialise the 'capacity' table.
 193     void initCapacity();
 194
 195     /// \brief Initialise/Reset the 'pressure' and live states tables.
 196     void resetPressureAndLiveStates();
 197   };
 198
 199   /// \brief Render MachineFunction objects and related information to a HTML
 200   ///        page.
 201   class RenderMachineFunction : public MachineFunctionPass {
 202   public:
 203     static char ID;
 204
 205     RenderMachineFunction() : MachineFunctionPass(ID) {
 206       initializeRenderMachineFunctionPass(*PassRegistry::getPassRegistry());
 207     }
 208
 209     virtual void getAnalysisUsage(AnalysisUsage &au) const;
 210
 211     virtual bool runOnMachineFunction(MachineFunction &fn);
 212
 213     virtual void releaseMemory();
 214
 215     void rememberUseDefs(const LiveInterval *li);
 216
 217     void rememberSpills(const LiveInterval *li,
 218                         const std::vector<LiveInterval*> &spills);
 219
 220     bool isSpill(const LiveInterval *li) const;
 221
 222     /// \brief Render this machine function to HTML.
 223     ///
 224     /// @param renderContextStr This parameter will be included in the top of
 225     ///                         the html file to explain where (in the
 226     ///                         codegen pipeline) this function was rendered
 227     ///                         from. Set it to something like
 228     ///                         "Pre-register-allocation".
 229     /// @param vrm              If non-null the VRM will be queried to determine
 230     ///                         whether a virtual register was allocated to a
 231     ///                         physical register or spilled.
 232     /// @param renderFilePrefix This string will be appended to the function
 233     ///                         name (before the output file suffix) to enable
 234     ///                         multiple renderings from the same function.
 235     void renderMachineFunction(const char *renderContextStr,
 236                                const VirtRegMap *vrm = 0,
 237                                const char *renderSuffix = 0);
 238
 239   private:
 240     class Spacer;
 241     friend raw_ostream& operator<<(raw_ostream &os, const Spacer &s);
 242
 243     std::string fqn;
 244
 245     MachineFunction *mf;
 246     MachineRegisterInfo *mri;
 247     const TargetRegisterInfo *tri;
 248     LiveIntervals *lis;
 249     SlotIndexes *sis;
 250     const VirtRegMap *vrm;
 251
 252     TargetRegisterExtraInfo trei;
 253     MFRenderingOptions ro;
 254
 255
 256
 257     // Utilities.
 258     typedef enum { Dead, Defined, Used, AliveReg, AliveStack } LiveState;
 259     LiveState getLiveStateAt(const LiveInterval *li, SlotIndex i) const;
 260
 261     typedef enum { Zero, Low, High } PressureState;
 262     PressureState getPressureStateAt(const TargetRegisterClass *trc,
 263                                      SlotIndex i) const;
 264
 265     typedef std::map<const LiveInterval*, std::set<const LiveInterval*> >
 266       SpillIntervals;
 267     SpillIntervals spillIntervals;
 268
 269     typedef std::map<const LiveInterval*, const LiveInterval*> SpillForMap;
 270     SpillForMap spillFor;
 271
 272     typedef std::set<SlotIndex> SlotSet;
 273     typedef std::map<const LiveInterval*, SlotSet> UseDefs;
 274     UseDefs useDefs;
 275
 276     // ---------- Rendering methods ----------
 277
 278     /// For inserting spaces when pretty printing.
 279     class Spacer {
 280     public:
 281       explicit Spacer(unsigned numSpaces) : ns(numSpaces) {}
 282       Spacer operator+(const Spacer &o) const { return Spacer(ns + o.ns); }
 283       void print(raw_ostream &os) const;
 284     private:
 285       unsigned ns;
 286     };
 287
 288     Spacer s(unsigned ns) const;
 289
 290     template <typename Iterator>
 291     std::string escapeChars(Iterator sBegin, Iterator sEnd) const;
 292
 293     /// \brief Render a machine instruction.
 294     void renderMachineInstr(raw_ostream &os,
 295                             const MachineInstr *mi) const;
 296
 297     /// \brief Render vertical text.
 298     template <typename T>
 299     void renderVertical(const Spacer &indent,
 300                         raw_ostream &os,
 301                         const T &t) const;
 302
 303     /// \brief Insert CSS layout info.
 304     void insertCSS(const Spacer &indent,
 305                    raw_ostream &os) const;
 306
 307     /// \brief Render a brief summary of the function (including rendering
 308     ///        context).
 309     void renderFunctionSummary(const Spacer &indent,
 310                                raw_ostream &os,
 311                                const char * const renderContextStr) const;
 312
 313     /// \brief Render a legend for the pressure table.
 314     void renderPressureTableLegend(const Spacer &indent,
 315                                    raw_ostream &os) const;
 316
 317     /// \brief Render a consecutive set of HTML cells of the same class using
 318     /// the colspan attribute for run-length encoding.
 319     template <typename CellType>
 320     void renderCellsWithRLE(
 321                      const Spacer &indent, raw_ostream &os,
 322                      const std::pair<CellType, unsigned> &rleAccumulator,
 323                      const std::map<CellType, std::string> &cellTypeStrs) const;
 324
 325     /// \brief Render code listing, potentially with register pressure
 326     ///        and live intervals shown alongside.
 327     void renderCodeTablePlusPI(const Spacer &indent,
 328                                raw_ostream &os) const;
 329
 330     /// \brief Render the HTML page representing the MachineFunction.
 331     void renderFunctionPage(raw_ostream &os,
 332                             const char * const renderContextStr) const;
 333
 334     std::string escapeChars(const std::string &s) const;
 335   };
 336 }
 337
 338 #endif /* LLVM_CODEGEN_RENDERMACHINEFUNCTION_H */