js/src/jit/JSONSpewer.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifdef JS_JITSPEW
   8
   9 #  include "jit/JSONSpewer.h"
  10
  11 #  include "jit/BacktrackingAllocator.h"
  12 #  include "jit/LIR.h"
  13 #  include "jit/MIR.h"
  14 #  include "jit/MIRGraph.h"
  15 #  include "jit/RangeAnalysis.h"
  16
  17 using namespace js;
  18 using namespace js::jit;
  19
  20 void JSONSpewer::beginFunction(JSScript* script) {
  21   beginObject();
  22   formatProperty("name", "%s:%u", script->filename(), script->lineno());
  23   beginListProperty("passes");
  24 }
  25
  26 void JSONSpewer::beginWasmFunction(unsigned funcIndex) {
  27   beginObject();
  28   formatProperty("name", "wasm-func%u", funcIndex);
  29   beginListProperty("passes");
  30 }
  31
  32 void JSONSpewer::beginPass(const char* pass) {
  33   beginObject();
  34   property("name", pass);
  35 }
  36
  37 void JSONSpewer::spewMResumePoint(MResumePoint* rp) {
  38   if (!rp) {
  39     return;
  40   }
  41
  42   beginObjectProperty("resumePoint");
  43
  44   if (rp->caller()) {
  45     property("caller", rp->caller()->block()->id());
  46   }
  47
  48   property("mode", ResumeModeToString(rp->mode()));
  49
  50   beginListProperty("operands");
  51   for (MResumePoint* iter = rp; iter; iter = iter->caller()) {
  52     for (int i = iter->numOperands() - 1; i >= 0; i--) {
  53       value(iter->getOperand(i)->id());
  54     }
  55     if (iter->caller()) {
  56       value("|");
  57     }
  58   }
  59   endList();
  60
  61   endObject();
  62 }
  63
  64 void JSONSpewer::spewMDef(MDefinition* def) {
  65   beginObject();
  66
  67   property("id", def->id());
  68
  69   propertyName("opcode");
  70   out_.printf("\"");
  71   def->printOpcode(out_);
  72   out_.printf("\"");
  73
  74   beginListProperty("attributes");
  75 #  define OUTPUT_ATTRIBUTE(X)      \
  76     do {                           \
  77       if (def->is##X()) value(#X); \
  78     } while (0);
  79   MIR_FLAG_LIST(OUTPUT_ATTRIBUTE);
  80 #  undef OUTPUT_ATTRIBUTE
  81   endList();
  82
  83   beginListProperty("inputs");
  84   for (size_t i = 0, e = def->numOperands(); i < e; i++) {
  85     value(def->getOperand(i)->id());
  86   }
  87   endList();
  88
  89   beginListProperty("uses");
  90   for (MUseDefIterator use(def); use; use++) {
  91     value(use.def()->id());
  92   }
  93   endList();
  94
  95   if (!def->isLowered()) {
  96     beginListProperty("memInputs");
  97     if (def->dependency()) {
  98       value(def->dependency()->id());
  99     }
 100     endList();
 101   }
 102
 103   bool isTruncated = false;
 104   if (def->isAdd() || def->isSub() || def->isMod() || def->isMul() ||
 105       def->isDiv()) {
 106     isTruncated = static_cast<MBinaryArithInstruction*>(def)->isTruncated();
 107   }
 108
 109   if (def->type() != MIRType::None && def->range()) {
 110     beginStringProperty("type");
 111     def->range()->dump(out_);
 112     out_.printf(" : %s%s", StringFromMIRType(def->type()),
 113                 (isTruncated ? " (t)" : ""));
 114     endStringProperty();
 115   } else {
 116     formatProperty("type", "%s%s", StringFromMIRType(def->type()),
 117                    (isTruncated ? " (t)" : ""));
 118   }
 119
 120   if (def->isInstruction()) {
 121     if (MResumePoint* rp = def->toInstruction()->resumePoint()) {
 122       spewMResumePoint(rp);
 123     }
 124   }
 125
 126   endObject();
 127 }
 128
 129 void JSONSpewer::spewMIR(MIRGraph* mir) {
 130   beginObjectProperty("mir");
 131   beginListProperty("blocks");
 132
 133   for (MBasicBlockIterator block(mir->begin()); block != mir->end(); block++) {
 134     beginObject();
 135
 136     property("number", block->id());
 137
 138     beginListProperty("attributes");
 139     if (block->hasLastIns()) {
 140       if (block->isLoopBackedge()) {
 141         value("backedge");
 142       }
 143       if (block->isLoopHeader()) {
 144         value("loopheader");
 145       }
 146       if (block->isSplitEdge()) {
 147         value("splitedge");
 148       }
 149     }
 150     endList();
 151
 152     beginListProperty("predecessors");
 153     for (size_t i = 0; i < block->numPredecessors(); i++) {
 154       value(block->getPredecessor(i)->id());
 155     }
 156     endList();
 157
 158     beginListProperty("successors");
 159     if (block->hasLastIns()) {
 160       for (size_t i = 0; i < block->numSuccessors(); i++) {
 161         value(block->getSuccessor(i)->id());
 162       }
 163     }
 164     endList();
 165
 166     beginListProperty("instructions");
 167     for (MPhiIterator phi(block->phisBegin()); phi != block->phisEnd(); phi++) {
 168       spewMDef(*phi);
 169     }
 170     for (MInstructionIterator i(block->begin()); i != block->end(); i++) {
 171       spewMDef(*i);
 172     }
 173     endList();
 174
 175     spewMResumePoint(block->entryResumePoint());
 176
 177     endObject();
 178   }
 179
 180   endList();
 181   endObject();
 182 }
 183
 184 void JSONSpewer::spewLIns(LNode* ins) {
 185   beginObject();
 186
 187   property("id", ins->id());
 188
 189   propertyName("opcode");
 190   out_.printf("\"");
 191   ins->dump(out_);
 192   out_.printf("\"");
 193
 194   beginListProperty("defs");
 195   for (size_t i = 0; i < ins->numDefs(); i++) {
 196     if (ins->isPhi()) {
 197       value(ins->toPhi()->getDef(i)->virtualRegister());
 198     } else {
 199       value(ins->toInstruction()->getDef(i)->virtualRegister());
 200     }
 201   }
 202   endList();
 203
 204   endObject();
 205 }
 206
 207 void JSONSpewer::spewLIR(MIRGraph* mir) {
 208   beginObjectProperty("lir");
 209   beginListProperty("blocks");
 210
 211   for (MBasicBlockIterator i(mir->begin()); i != mir->end(); i++) {
 212     LBlock* block = i->lir();
 213     if (!block) {
 214       continue;
 215     }
 216
 217     beginObject();
 218     property("number", i->id());
 219
 220     beginListProperty("instructions");
 221     for (size_t p = 0; p < block->numPhis(); p++) {
 222       spewLIns(block->getPhi(p));
 223     }
 224     for (LInstructionIterator ins(block->begin()); ins != block->end(); ins++) {
 225       spewLIns(*ins);
 226     }
 227     endList();
 228
 229     endObject();
 230   }
 231
 232   endList();
 233   endObject();
 234 }
 235
 236 void JSONSpewer::spewRanges(BacktrackingAllocator* regalloc) {
 237   beginObjectProperty("ranges");
 238   beginListProperty("blocks");
 239
 240   for (size_t bno = 0; bno < regalloc->graph.numBlocks(); bno++) {
 241     beginObject();
 242     property("number", bno);
 243     beginListProperty("vregs");
 244
 245     LBlock* lir = regalloc->graph.getBlock(bno);
 246     for (LInstructionIterator ins = lir->begin(); ins != lir->end(); ins++) {
 247       for (size_t k = 0; k < ins->numDefs(); k++) {
 248         uint32_t id = ins->getDef(k)->virtualRegister();
 249         VirtualRegister* vreg = &regalloc->vregs[id];
 250
 251         beginObject();
 252         property("vreg", id);
 253         beginListProperty("ranges");
 254
 255         for (LiveRange::RegisterLinkIterator iter = vreg->rangesBegin(); iter;
 256              iter++) {
 257           LiveRange* range = LiveRange::get(*iter);
 258
 259           beginObject();
 260           property("allocation",
 261                    range->bundle()->allocation().toString().get());
 262           property("start", range->from().bits());
 263           property("end", range->to().bits());
 264           endObject();
 265         }
 266
 267         endList();
 268         endObject();
 269       }
 270     }
 271
 272     endList();
 273     endObject();
 274   }
 275
 276   endList();
 277   endObject();
 278 }
 279
 280 void JSONSpewer::endPass() { endObject(); }
 281
 282 void JSONSpewer::endFunction() {
 283   endList();
 284   endObject();
 285 }
 286
 287 #endif /* JS_JITSPEW */