LCOV - code coverage report
Current view: top level - js/src/jit - C1Spewer.cpp (source / functions) Hit Total Coverage
Test: output.info Lines: 0 114 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 9 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
       2             :  * vim: set ts=8 sts=4 et sw=4 tw=99:
       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/C1Spewer.h"
      10             : 
      11             : #include "mozilla/SizePrintfMacros.h"
      12             : 
      13             : #include <time.h>
      14             : 
      15             : #include "jit/BacktrackingAllocator.h"
      16             : #include "jit/LIR.h"
      17             : #include "jit/MIRGraph.h"
      18             : 
      19             : #include "vm/Printer.h"
      20             : 
      21             : using namespace js;
      22             : using namespace js::jit;
      23             : 
      24             : void
      25           0 : C1Spewer::beginFunction(MIRGraph* graph, JSScript* script)
      26             : {
      27           0 :     this->graph  = graph;
      28             : 
      29           0 :     out_.printf("begin_compilation\n");
      30           0 :     if (script) {
      31           0 :         out_.printf("  name \"%s:%" PRIuSIZE "\"\n", script->filename(), script->lineno());
      32           0 :         out_.printf("  method \"%s:%" PRIuSIZE "\"\n", script->filename(), script->lineno());
      33             :     } else {
      34           0 :         out_.printf("  name \"wasm compilation\"\n");
      35           0 :         out_.printf("  method \"wasm compilation\"\n");
      36             :     }
      37           0 :     out_.printf("  date %d\n", (int)time(nullptr));
      38           0 :     out_.printf("end_compilation\n");
      39           0 : }
      40             : 
      41             : void
      42           0 : C1Spewer::spewPass(const char* pass)
      43             : {
      44           0 :     out_.printf("begin_cfg\n");
      45           0 :     out_.printf("  name \"%s\"\n", pass);
      46             : 
      47           0 :     for (MBasicBlockIterator block(graph->begin()); block != graph->end(); block++)
      48           0 :         spewPass(out_, *block);
      49             : 
      50           0 :     out_.printf("end_cfg\n");
      51           0 : }
      52             : 
      53             : void
      54           0 : C1Spewer::spewRanges(const char* pass, BacktrackingAllocator* regalloc)
      55             : {
      56           0 :     out_.printf("begin_ranges\n");
      57           0 :     out_.printf(" name \"%s\"\n", pass);
      58             : 
      59           0 :     for (MBasicBlockIterator block(graph->begin()); block != graph->end(); block++)
      60           0 :         spewRanges(out_, *block, regalloc);
      61             : 
      62           0 :     out_.printf("end_ranges\n");
      63           0 : }
      64             : 
      65             : void
      66           0 : C1Spewer::endFunction()
      67             : {
      68           0 : }
      69             : 
      70             : static void
      71           0 : DumpDefinition(GenericPrinter& out, MDefinition* def)
      72             : {
      73           0 :     out.printf("      ");
      74           0 :     out.printf("%u %u ", def->id(), unsigned(def->useCount()));
      75           0 :     def->printName(out);
      76           0 :     out.printf(" ");
      77           0 :     def->printOpcode(out);
      78           0 :     out.printf(" <|@\n");
      79           0 : }
      80             : 
      81             : static void
      82           0 : DumpLIR(GenericPrinter& out, LNode* ins)
      83             : {
      84           0 :     out.printf("      ");
      85           0 :     out.printf("%d ", ins->id());
      86           0 :     ins->dump(out);
      87           0 :     out.printf(" <|@\n");
      88           0 : }
      89             : 
      90             : void
      91           0 : C1Spewer::spewRanges(GenericPrinter& out, BacktrackingAllocator* regalloc, LNode* ins)
      92             : {
      93           0 :     for (size_t k = 0; k < ins->numDefs(); k++) {
      94           0 :         uint32_t id = ins->getDef(k)->virtualRegister();
      95           0 :         VirtualRegister* vreg = &regalloc->vregs[id];
      96             : 
      97           0 :         for (LiveRange::RegisterLinkIterator iter = vreg->rangesBegin(); iter; iter++) {
      98           0 :             LiveRange* range = LiveRange::get(*iter);
      99           0 :             out.printf("%d object \"", id);
     100           0 :             out.printf("%s", range->bundle()->allocation().toString().get());
     101           0 :             out.printf("\" %d -1", id);
     102           0 :             out.printf(" [%u, %u[", range->from().bits(), range->to().bits());
     103           0 :             for (UsePositionIterator usePos(range->usesBegin()); usePos; usePos++)
     104           0 :                 out.printf(" %u M", usePos->pos.bits());
     105           0 :             out.printf(" \"\"\n");
     106             :         }
     107             :     }
     108           0 : }
     109             : 
     110             : void
     111           0 : C1Spewer::spewRanges(GenericPrinter& out, MBasicBlock* block, BacktrackingAllocator* regalloc)
     112             : {
     113           0 :     LBlock* lir = block->lir();
     114           0 :     if (!lir)
     115           0 :         return;
     116             : 
     117           0 :     for (size_t i = 0; i < lir->numPhis(); i++)
     118           0 :         spewRanges(out, regalloc, lir->getPhi(i));
     119             : 
     120           0 :     for (LInstructionIterator ins = lir->begin(); ins != lir->end(); ins++)
     121           0 :         spewRanges(out, regalloc, *ins);
     122             : }
     123             : 
     124             : void
     125           0 : C1Spewer::spewPass(GenericPrinter& out, MBasicBlock* block)
     126             : {
     127           0 :     out.printf("  begin_block\n");
     128           0 :     out.printf("    name \"B%d\"\n", block->id());
     129           0 :     out.printf("    from_bci -1\n");
     130           0 :     out.printf("    to_bci -1\n");
     131             : 
     132           0 :     out.printf("    predecessors");
     133           0 :     for (uint32_t i = 0; i < block->numPredecessors(); i++) {
     134           0 :         MBasicBlock* pred = block->getPredecessor(i);
     135           0 :         out.printf(" \"B%d\"", pred->id());
     136             :     }
     137           0 :     out.printf("\n");
     138             : 
     139           0 :     out.printf("    successors");
     140           0 :     if (block->hasLastIns()) {
     141           0 :         for (uint32_t i = 0; i < block->numSuccessors(); i++) {
     142           0 :             MBasicBlock* successor = block->getSuccessor(i);
     143           0 :             out.printf(" \"B%d\"", successor->id());
     144             :         }
     145             :     }
     146           0 :     out.printf("\n");
     147             : 
     148           0 :     out.printf("    xhandlers\n");
     149           0 :     out.printf("    flags\n");
     150             : 
     151           0 :     if (block->lir() && block->lir()->begin() != block->lir()->end()) {
     152           0 :         out.printf("    first_lir_id %d\n", block->lir()->firstId());
     153           0 :         out.printf("    last_lir_id %d\n", block->lir()->lastId());
     154             :     }
     155             : 
     156           0 :     out.printf("    begin_states\n");
     157             : 
     158           0 :     if (block->entryResumePoint()) {
     159           0 :         out.printf("      begin_locals\n");
     160           0 :         out.printf("        size %d\n", (int)block->numEntrySlots());
     161           0 :         out.printf("        method \"None\"\n");
     162           0 :         for (uint32_t i = 0; i < block->numEntrySlots(); i++) {
     163           0 :             MDefinition* ins = block->getEntrySlot(i);
     164           0 :             out.printf("        ");
     165           0 :             out.printf("%d ", i);
     166           0 :             if (ins->isUnused())
     167           0 :                 out.printf("unused");
     168             :             else
     169           0 :                 ins->printName(out);
     170           0 :             out.printf("\n");
     171             :         }
     172           0 :         out.printf("      end_locals\n");
     173             :     }
     174           0 :     out.printf("    end_states\n");
     175             : 
     176           0 :     out.printf("    begin_HIR\n");
     177           0 :     for (MPhiIterator phi(block->phisBegin()); phi != block->phisEnd(); phi++)
     178           0 :         DumpDefinition(out, *phi);
     179           0 :     for (MInstructionIterator i(block->begin()); i != block->end(); i++)
     180           0 :         DumpDefinition(out, *i);
     181           0 :     out.printf("    end_HIR\n");
     182             : 
     183           0 :     if (block->lir()) {
     184           0 :         out.printf("    begin_LIR\n");
     185           0 :         for (size_t i = 0; i < block->lir()->numPhis(); i++)
     186           0 :             DumpLIR(out, block->lir()->getPhi(i));
     187           0 :         for (LInstructionIterator i(block->lir()->begin()); i != block->lir()->end(); i++)
     188           0 :             DumpLIR(out, *i);
     189           0 :         out.printf("    end_LIR\n");
     190             :     }
     191             : 
     192           0 :     out.printf("  end_block\n");
     193           0 : }
     194             : 
     195             : #endif /* JS_JITSPEW */
     196             : 

Generated by: LCOV version 1.13