Changeset 120834 in webkit for trunk/Source/JavaScriptCore/dfg/DFGGraph.cpp

Timestamp:

Jun 20, 2012, 10:48:23 AM (13 years ago)

Author:

[email protected]

Message:

DFG should be able to print disassembly interleaved with the IR
​https://bugs.webkit.org/show_bug.cgi?id=89551

Reviewed by Geoffrey Garen.

• CMakeLists.txt:
• GNUmakefile.list.am:
• JavaScriptCore.xcodeproj/project.pbxproj:
• Target.pri:
• assembler/ARMv7Assembler.h:

(JSC::ARMv7Assembler::labelIgnoringWatchpoints):
(ARMv7Assembler):

• assembler/AbstractMacroAssembler.h:

(AbstractMacroAssembler):
(JSC::AbstractMacroAssembler::labelIgnoringWatchpoints):

• assembler/X86Assembler.h:

(X86Assembler):
(JSC::X86Assembler::labelIgnoringWatchpoints):

• dfg/DFGCommon.h:

(JSC::DFG::shouldShowDisassembly):
(DFG):

• dfg/DFGDisassembler.cpp: Added.

(DFG):
(JSC::DFG::Disassembler::Disassembler):
(JSC::DFG::Disassembler::dump):
(JSC::DFG::Disassembler::dumpDisassembly):

• dfg/DFGDisassembler.h: Added.

(DFG):
(Disassembler):
(JSC::DFG::Disassembler::setStartOfCode):
(JSC::DFG::Disassembler::setForBlock):
(JSC::DFG::Disassembler::setForNode):
(JSC::DFG::Disassembler::setEndOfMainPath):
(JSC::DFG::Disassembler::setEndOfCode):

• dfg/DFGDriver.cpp:

(JSC::DFG::compile):

• dfg/DFGGraph.cpp:

(JSC::DFG::Graph::dumpCodeOrigin):
(JSC::DFG::Graph::amountOfNodeWhiteSpace):
(DFG):
(JSC::DFG::Graph::printNodeWhiteSpace):
(JSC::DFG::Graph::dump):
(JSC::DFG::Graph::dumpBlockHeader):

• dfg/DFGGraph.h:
• dfg/DFGJITCompiler.cpp:

(JSC::DFG::JITCompiler::JITCompiler):
(DFG):
(JSC::DFG::JITCompiler::compile):
(JSC::DFG::JITCompiler::compileFunction):

• dfg/DFGJITCompiler.h:

(JITCompiler):
(JSC::DFG::JITCompiler::setStartOfCode):
(JSC::DFG::JITCompiler::setForBlock):
(JSC::DFG::JITCompiler::setForNode):
(JSC::DFG::JITCompiler::setEndOfMainPath):
(JSC::DFG::JITCompiler::setEndOfCode):

• dfg/DFGNode.h:

(Node):
(JSC::DFG::Node::willHaveCodeGen):

• dfg/DFGNodeFlags.cpp:

(JSC::DFG::nodeFlagsAsString):

• dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::compile):

• dfg/DFGSpeculativeJIT.h:

(SpeculativeJIT):

• runtime/Options.cpp:

(Options):
(JSC::Options::initializeOptions):

• runtime/Options.h:

(Options):

File:

• trunk/Source/JavaScriptCore/dfg/DFGGraph.cpp (modified) (8 diffs)

trunk/Source/JavaScriptCore/dfg/DFGGraph.cpp

@@ -90 +90 @@
 }
 
-void Graph::dumpCodeOrigin(NodeIndex prevNodeIndex, NodeIndex nodeIndex)
+void Graph::dumpCodeOrigin(const char* prefix, NodeIndex prevNodeIndex, NodeIndex nodeIndex)
 {
     if (prevNodeIndex == NoNode)
@@ -113 +113 @@
     // Print the pops.
     for (unsigned i = previousInlineStack.size(); i-- > indexOfDivergence;) {
+        dataLog("%s", prefix);
         printWhiteSpace(i * 2);
         dataLog("<-- %p\n", previousInlineStack[i].inlineCallFrame->executable.get());
@@ -119 +120 @@
     // Print the pushes.
     for (unsigned i = indexOfDivergence; i < currentInlineStack.size(); ++i) {
+        dataLog("%s", prefix);
         printWhiteSpace(i * 2);
         dataLog("--> %p\n", currentInlineStack[i].inlineCallFrame->executable.get());
@@ -124 +126 @@
 }
 
-void Graph::dump(NodeIndex nodeIndex)
+int Graph::amountOfNodeWhiteSpace(Node& node)
+{
+    return (node.codeOrigin.inlineDepth() - 1) * 2;
+}
+
+void Graph::printNodeWhiteSpace(Node& node)
+{
+    printWhiteSpace(amountOfNodeWhiteSpace(node));
+}
+
+void Graph::dump(const char* prefix, NodeIndex nodeIndex)
 {
     Node& node = at(nodeIndex);
@@ -135 +147 @@
         --refCount;
     
-    printWhiteSpace((node.codeOrigin.inlineDepth() - 1) * 2);
+    dataLog("%s", prefix);
+    printNodeWhiteSpace(node);
 
     // Example/explanation of dataflow dump output
@@ -289 +302 @@
 }
 
+void Graph::dumpBlockHeader(const char* prefix, BlockIndex blockIndex, PhiNodeDumpMode phiNodeDumpMode)
+{
+    BasicBlock* block = m_blocks[blockIndex].get();
+
+    dataLog("%sBlock #%u (bc#%u): %s%s\n", prefix, (int)blockIndex, block->bytecodeBegin, block->isReachable ? "" : " (skipped)", block->isOSRTarget ? " (OSR target)" : "");
+    dataLog("%s  Predecessors:", prefix);
+    for (size_t i = 0; i < block->m_predecessors.size(); ++i)
+        dataLog(" #%u", block->m_predecessors[i]);
+    dataLog("\n");
+    if (m_dominators.isValid()) {
+        dataLog("%s  Dominated by:", prefix);
+        for (size_t i = 0; i < m_blocks.size(); ++i) {
+            if (!m_dominators.dominates(i, blockIndex))
+                continue;
+            dataLog(" #%lu", static_cast<unsigned long>(i));
+        }
+        dataLog("\n");
+        dataLog("%s  Dominates:", prefix);
+        for (size_t i = 0; i < m_blocks.size(); ++i) {
+            if (!m_dominators.dominates(blockIndex, i))
+                continue;
+            dataLog(" #%lu", static_cast<unsigned long>(i));
+        }
+        dataLog("\n");
+    }
+    dataLog("%s  Phi Nodes:", prefix);
+    unsigned count = 0;
+    for (size_t i = 0; i < block->phis.size(); ++i) {
+        NodeIndex phiNodeIndex = block->phis[i];
+        Node& phiNode = at(phiNodeIndex);
+        if (!phiNode.shouldGenerate() && phiNodeDumpMode == DumpLivePhisOnly)
+            continue;
+        if (!((++count) % 4))
+            dataLog("\n%s      ", prefix);
+        dataLog(" @%u->(", phiNodeIndex);
+        if (phiNode.child1()) {
+            dataLog("@%u", phiNode.child1().index());
+            if (phiNode.child2()) {
+                dataLog(", @%u", phiNode.child2().index());
+                if (phiNode.child3())
+                    dataLog(", @%u", phiNode.child3().index());
+            }
+        }
+        dataLog(")%s", i + 1 < block->phis.size() ? "," : "");
+    }
+    dataLog("\n");
+}
+
 void Graph::dump()
 {
@@ -296 +357 @@
         if (!block)
             continue;
-        dataLog("Block #%u (bc#%u): %s%s\n", (int)b, block->bytecodeBegin, block->isReachable ? "" : " (skipped)", block->isOSRTarget ? " (OSR target)" : "");
-        dataLog("  Predecessors:");
-        for (size_t i = 0; i < block->m_predecessors.size(); ++i)
-            dataLog(" #%u", block->m_predecessors[i]);
-        dataLog("\n");
-        if (m_dominators.isValid()) {
-            dataLog("  Dominated by:");
-            for (size_t i = 0; i < m_blocks.size(); ++i) {
-                if (!m_dominators.dominates(i, b))
-                    continue;
-                dataLog(" #%lu", static_cast<unsigned long>(i));
-            }
-            dataLog("\n");
-            dataLog("  Dominates:");
-            for (size_t i = 0; i < m_blocks.size(); ++i) {
-                if (!m_dominators.dominates(b, i))
-                    continue;
-                dataLog(" #%lu", static_cast<unsigned long>(i));
-            }
-            dataLog("\n");
-        }
-        dataLog("  Phi Nodes:\n");
-        for (size_t i = 0; i < block->phis.size(); ++i) {
-            dumpCodeOrigin(lastNodeIndex, block->phis[i]);
-            dump(block->phis[i]);
-            lastNodeIndex = block->phis[i];
-        }
+        dumpBlockHeader("", b, DumpAllPhis);
         dataLog("  vars before: ");
         if (block->cfaHasVisited)
@@ -333 +368 @@
         dataLog("\n");
         for (size_t i = 0; i < block->size(); ++i) {
-            dumpCodeOrigin(lastNodeIndex, block->at(i));
-            dump(block->at(i));
+            dumpCodeOrigin("", lastNodeIndex, block->at(i));
+            dump("", block->at(i));
             lastNodeIndex = block->at(i);
         }