Rename dataLog() and dataLogV() to dataLogF() and dataLogFV()
authorfpizlo@apple.com <fpizlo@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 22 Nov 2012 04:23:36 +0000 (04:23 +0000)
committerfpizlo@apple.com <fpizlo@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Thu, 22 Nov 2012 04:23:36 +0000 (04:23 +0000)
https://bugs.webkit.org/show_bug.cgi?id=103001

Rubber stamped by Dan Bernstein.

Source/JavaScriptCore:

* JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
* assembler/LinkBuffer.cpp:
(JSC::LinkBuffer::finalizeCodeWithDisassembly):
(JSC::LinkBuffer::dumpLinkStatistics):
(JSC::LinkBuffer::dumpCode):
* assembler/LinkBuffer.h:
(JSC):
* assembler/SH4Assembler.h:
(JSC::SH4Assembler::vprintfStdoutInstr):
* bytecode/CodeBlock.cpp:
(JSC::CodeBlock::dumpBytecodeCommentAndNewLine):
(JSC::CodeBlock::printUnaryOp):
(JSC::CodeBlock::printBinaryOp):
(JSC::CodeBlock::printConditionalJump):
(JSC::CodeBlock::printGetByIdOp):
(JSC::dumpStructure):
(JSC::dumpChain):
(JSC::CodeBlock::printGetByIdCacheStatus):
(JSC::CodeBlock::printCallOp):
(JSC::CodeBlock::printPutByIdOp):
(JSC::CodeBlock::printStructure):
(JSC::CodeBlock::printStructures):
(JSC::CodeBlock::dump):
(JSC::CodeBlock::dumpStatistics):
(JSC::CodeBlock::finalizeUnconditionally):
(JSC::CodeBlock::resetStubInternal):
(JSC::CodeBlock::reoptimize):
(JSC::ProgramCodeBlock::jettison):
(JSC::EvalCodeBlock::jettison):
(JSC::FunctionCodeBlock::jettison):
(JSC::CodeBlock::shouldOptimizeNow):
(JSC::CodeBlock::tallyFrequentExitSites):
(JSC::CodeBlock::dumpValueProfiles):
* bytecode/Opcode.cpp:
(JSC::OpcodeStats::~OpcodeStats):
* bytecode/SamplingTool.cpp:
(JSC::SamplingFlags::stop):
(JSC::SamplingRegion::dumpInternal):
(JSC::SamplingTool::dump):
* dfg/DFGAbstractState.cpp:
(JSC::DFG::AbstractState::initialize):
(JSC::DFG::AbstractState::endBasicBlock):
(JSC::DFG::AbstractState::mergeStateAtTail):
(JSC::DFG::AbstractState::mergeToSuccessors):
* dfg/DFGAbstractValue.h:
(JSC::DFG::AbstractValue::dump):
* dfg/DFGArgumentsSimplificationPhase.cpp:
(JSC::DFG::ArgumentsSimplificationPhase::run):
* dfg/DFGByteCodeParser.cpp:
(JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
(JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
(JSC::DFG::ByteCodeParser::getArrayModeAndEmitChecks):
(JSC::DFG::ByteCodeParser::makeSafe):
(JSC::DFG::ByteCodeParser::makeDivSafe):
(JSC::DFG::ByteCodeParser::handleCall):
(JSC::DFG::ByteCodeParser::handleInlining):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::processPhiStack):
(JSC::DFG::ByteCodeParser::linkBlock):
(JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
(JSC::DFG::ByteCodeParser::parseCodeBlock):
(JSC::DFG::ByteCodeParser::parse):
* dfg/DFGCFAPhase.cpp:
(JSC::DFG::CFAPhase::performBlockCFA):
(JSC::DFG::CFAPhase::performForwardCFA):
* dfg/DFGCFGSimplificationPhase.cpp:
(JSC::DFG::CFGSimplificationPhase::run):
(JSC::DFG::CFGSimplificationPhase::fixPossibleGetLocal):
(JSC::DFG::CFGSimplificationPhase::fixPhis):
(JSC::DFG::CFGSimplificationPhase::fixJettisonedPredecessors):
(JSC::DFG::CFGSimplificationPhase::removePotentiallyDeadPhiReference):
(JSC::DFG::CFGSimplificationPhase::mergeBlocks):
* dfg/DFGCSEPhase.cpp:
(JSC::DFG::CSEPhase::endIndexForPureCSE):
(JSC::DFG::CSEPhase::setReplacement):
(JSC::DFG::CSEPhase::eliminate):
(JSC::DFG::CSEPhase::performNodeCSE):
* dfg/DFGCapabilities.cpp:
(JSC::DFG::debugFail):
* dfg/DFGConstantFoldingPhase.cpp:
(JSC::DFG::ConstantFoldingPhase::foldConstants):
(JSC::DFG::ConstantFoldingPhase::paintUnreachableCode):
* dfg/DFGDisassembler.cpp:
(JSC::DFG::Disassembler::dump):
* dfg/DFGDriver.cpp:
(JSC::DFG::compile):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::fixDoubleEdge):
* dfg/DFGGraph.cpp:
(JSC::DFG::printWhiteSpace):
(JSC::DFG::Graph::dumpCodeOrigin):
(JSC::DFG::Graph::dump):
(JSC::DFG::Graph::dumpBlockHeader):
(JSC::DFG::Graph::predictArgumentTypes):
* dfg/DFGJITCompiler.cpp:
(JSC::DFG::JITCompiler::link):
* dfg/DFGOSREntry.cpp:
(JSC::DFG::prepareOSREntry):
* dfg/DFGOSRExitCompiler.cpp:
* dfg/DFGOSRExitCompiler32_64.cpp:
(JSC::DFG::OSRExitCompiler::compileExit):
* dfg/DFGOSRExitCompiler64.cpp:
(JSC::DFG::OSRExitCompiler::compileExit):
* dfg/DFGOperations.cpp:
* dfg/DFGPhase.cpp:
(JSC::DFG::Phase::beginPhase):
* dfg/DFGPhase.h:
(JSC::DFG::runAndLog):
* dfg/DFGPredictionPropagationPhase.cpp:
(JSC::DFG::PredictionPropagationPhase::propagate):
(JSC::DFG::PredictionPropagationPhase::propagateForward):
(JSC::DFG::PredictionPropagationPhase::propagateBackward):
(JSC::DFG::PredictionPropagationPhase::doRoundOfDoubleVoting):
* dfg/DFGRegisterBank.h:
(JSC::DFG::RegisterBank::dump):
* dfg/DFGScoreBoard.h:
(JSC::DFG::ScoreBoard::use):
(JSC::DFG::ScoreBoard::dump):
* dfg/DFGSlowPathGenerator.h:
(JSC::DFG::SlowPathGenerator::generate):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::terminateSpeculativeExecution):
(JSC::DFG::SpeculativeJIT::terminateSpeculativeExecutionWithConditionalDirection):
(JSC::DFG::SpeculativeJIT::runSlowPathGenerators):
(JSC::DFG::SpeculativeJIT::dump):
(JSC::DFG::SpeculativeJIT::checkConsistency):
(JSC::DFG::SpeculativeJIT::compile):
(JSC::DFG::SpeculativeJIT::checkGeneratedTypeForToInt32):
* dfg/DFGSpeculativeJIT32_64.cpp:
(JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
(JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
(JSC::DFG::SpeculativeJIT::fillSpeculateCell):
(JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
* dfg/DFGSpeculativeJIT64.cpp:
(JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
(JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
(JSC::DFG::SpeculativeJIT::fillSpeculateCell):
(JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
* dfg/DFGStructureCheckHoistingPhase.cpp:
(JSC::DFG::StructureCheckHoistingPhase::run):
* dfg/DFGValidate.cpp:
(Validate):
(JSC::DFG::Validate::reportValidationContext):
(JSC::DFG::Validate::dumpData):
(JSC::DFG::Validate::dumpGraphIfAppropriate):
* dfg/DFGVariableEventStream.cpp:
(JSC::DFG::VariableEventStream::logEvent):
(JSC::DFG::VariableEventStream::reconstruct):
* dfg/DFGVirtualRegisterAllocationPhase.cpp:
(JSC::DFG::VirtualRegisterAllocationPhase::run):
* heap/Heap.cpp:
* heap/HeapStatistics.cpp:
(JSC::HeapStatistics::logStatistics):
(JSC::HeapStatistics::showObjectStatistics):
* heap/MarkStack.h:
* heap/MarkedBlock.h:
* heap/SlotVisitor.cpp:
(JSC::SlotVisitor::validate):
* interpreter/CallFrame.cpp:
(JSC::CallFrame::dumpCaller):
* interpreter/Interpreter.cpp:
(JSC::Interpreter::dumpRegisters):
* jit/JIT.cpp:
(JSC::JIT::privateCompileMainPass):
(JSC::JIT::privateCompileSlowCases):
(JSC::JIT::privateCompile):
* jit/JITDisassembler.cpp:
(JSC::JITDisassembler::dump):
(JSC::JITDisassembler::dumpForInstructions):
* jit/JITStubRoutine.h:
(JSC):
* jit/JITStubs.cpp:
(JSC::DEFINE_STUB_FUNCTION):
* jit/JumpReplacementWatchpoint.cpp:
(JSC::JumpReplacementWatchpoint::fireInternal):
* llint/LLIntExceptions.cpp:
(JSC::LLInt::interpreterThrowInCaller):
(JSC::LLInt::returnToThrow):
(JSC::LLInt::callToThrow):
* llint/LLIntSlowPaths.cpp:
(JSC::LLInt::llint_trace_operand):
(JSC::LLInt::llint_trace_value):
(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(JSC::LLInt::traceFunctionPrologue):
(JSC::LLInt::jitCompileAndSetHeuristics):
(JSC::LLInt::entryOSR):
(JSC::LLInt::handleHostCall):
(JSC::LLInt::setUpCall):
* profiler/Profile.cpp:
(JSC::Profile::debugPrintData):
(JSC::Profile::debugPrintDataSampleStyle):
* profiler/ProfileNode.cpp:
(JSC::ProfileNode::debugPrintData):
(JSC::ProfileNode::debugPrintDataSampleStyle):
* runtime/JSGlobalData.cpp:
(JSC::JSGlobalData::dumpRegExpTrace):
* runtime/RegExp.cpp:
(JSC::RegExp::matchCompareWithInterpreter):
* runtime/SamplingCounter.cpp:
(JSC::AbstractSamplingCounter::dump):
* runtime/Structure.cpp:
(JSC::Structure::dumpStatistics):
(JSC::PropertyMapStatisticsExitLogger::~PropertyMapStatisticsExitLogger):
* tools/CodeProfile.cpp:
(JSC::CodeProfile::report):
* tools/ProfileTreeNode.h:
(JSC::ProfileTreeNode::dumpInternal):
* yarr/YarrInterpreter.cpp:
(JSC::Yarr::ByteCompiler::dumpDisjunction):

Source/WebCore:

No change in behavior, so no new tests.

* platform/KURLWTFURL.cpp:
(WebCore::KURL::print):

Source/WTF:

* wtf/DataLog.cpp:
(WTF::dataLogFV):
(WTF::dataLogF):
(WTF::dataLogFString):
* wtf/DataLog.h:
(WTF):
* wtf/HashTable.cpp:
(WTF::HashTableStats::dumpStats):
* wtf/HashTable.h:
(WTF::HashTable::Stats::dumpStats):
* wtf/MetaAllocator.cpp:
(WTF::MetaAllocator::dumpProfile):
* wtf/StackStats.cpp:
(WTF::StackStats::initialize):
(WTF::StackStats::PerThreadStats::PerThreadStats):
(WTF::StackStats::CheckPoint::CheckPoint):
(WTF::StackStats::CheckPoint::~CheckPoint):
(WTF::StackStats::probe):
(WTF::StackStats::LayoutCheckPoint::LayoutCheckPoint):
* wtf/text/WTFString.cpp:
(String::show):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@135469 268f45cc-cd09-0410-ab3c-d52691b4dbfc

73 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def
Source/JavaScriptCore/assembler/LinkBuffer.cpp
Source/JavaScriptCore/assembler/LinkBuffer.h
Source/JavaScriptCore/assembler/SH4Assembler.h
Source/JavaScriptCore/bytecode/CodeBlock.cpp
Source/JavaScriptCore/bytecode/Opcode.cpp
Source/JavaScriptCore/bytecode/SamplingTool.cpp
Source/JavaScriptCore/dfg/DFGAbstractState.cpp
Source/JavaScriptCore/dfg/DFGAbstractValue.h
Source/JavaScriptCore/dfg/DFGArgumentsSimplificationPhase.cpp
Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
Source/JavaScriptCore/dfg/DFGCFAPhase.cpp
Source/JavaScriptCore/dfg/DFGCFGSimplificationPhase.cpp
Source/JavaScriptCore/dfg/DFGCSEPhase.cpp
Source/JavaScriptCore/dfg/DFGCapabilities.cpp
Source/JavaScriptCore/dfg/DFGConstantFoldingPhase.cpp
Source/JavaScriptCore/dfg/DFGDisassembler.cpp
Source/JavaScriptCore/dfg/DFGDriver.cpp
Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
Source/JavaScriptCore/dfg/DFGGraph.cpp
Source/JavaScriptCore/dfg/DFGJITCompiler.cpp
Source/JavaScriptCore/dfg/DFGOSREntry.cpp
Source/JavaScriptCore/dfg/DFGOSRExitCompiler.cpp
Source/JavaScriptCore/dfg/DFGOSRExitCompiler32_64.cpp
Source/JavaScriptCore/dfg/DFGOSRExitCompiler64.cpp
Source/JavaScriptCore/dfg/DFGOperations.cpp
Source/JavaScriptCore/dfg/DFGPhase.cpp
Source/JavaScriptCore/dfg/DFGPhase.h
Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
Source/JavaScriptCore/dfg/DFGRegisterBank.h
Source/JavaScriptCore/dfg/DFGScoreBoard.h
Source/JavaScriptCore/dfg/DFGSlowPathGenerator.h
Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
Source/JavaScriptCore/dfg/DFGStructureCheckHoistingPhase.cpp
Source/JavaScriptCore/dfg/DFGValidate.cpp
Source/JavaScriptCore/dfg/DFGVariableEventStream.cpp
Source/JavaScriptCore/dfg/DFGVirtualRegisterAllocationPhase.cpp
Source/JavaScriptCore/heap/Heap.cpp
Source/JavaScriptCore/heap/HeapStatistics.cpp
Source/JavaScriptCore/heap/MarkStack.h
Source/JavaScriptCore/heap/MarkedBlock.h
Source/JavaScriptCore/heap/SlotVisitor.cpp
Source/JavaScriptCore/interpreter/CallFrame.cpp
Source/JavaScriptCore/interpreter/Interpreter.cpp
Source/JavaScriptCore/jit/JIT.cpp
Source/JavaScriptCore/jit/JITDisassembler.cpp
Source/JavaScriptCore/jit/JITStubRoutine.h
Source/JavaScriptCore/jit/JITStubs.cpp
Source/JavaScriptCore/jit/JumpReplacementWatchpoint.cpp
Source/JavaScriptCore/llint/LLIntExceptions.cpp
Source/JavaScriptCore/llint/LLIntSlowPaths.cpp
Source/JavaScriptCore/profiler/Profile.cpp
Source/JavaScriptCore/profiler/ProfileNode.cpp
Source/JavaScriptCore/runtime/JSGlobalData.cpp
Source/JavaScriptCore/runtime/RegExp.cpp
Source/JavaScriptCore/runtime/SamplingCounter.cpp
Source/JavaScriptCore/runtime/Structure.cpp
Source/JavaScriptCore/tools/CodeProfile.cpp
Source/JavaScriptCore/tools/ProfileTreeNode.h
Source/JavaScriptCore/yarr/YarrInterpreter.cpp
Source/WTF/ChangeLog
Source/WTF/wtf/DataLog.cpp
Source/WTF/wtf/DataLog.h
Source/WTF/wtf/HashTable.cpp
Source/WTF/wtf/HashTable.h
Source/WTF/wtf/MetaAllocator.cpp
Source/WTF/wtf/StackStats.cpp
Source/WTF/wtf/text/WTFString.cpp
Source/WebCore/ChangeLog
Source/WebCore/platform/KURLWTFURL.cpp

index 95a1011..aa92ead 100644 (file)
@@ -1,5 +1,223 @@
 2012-11-21  Filip Pizlo  <fpizlo@apple.com>
 
+        Rename dataLog() and dataLogV() to dataLogF() and dataLogFV()
+        https://bugs.webkit.org/show_bug.cgi?id=103001
+
+        Rubber stamped by Dan Bernstein.
+
+        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.def:
+        * assembler/LinkBuffer.cpp:
+        (JSC::LinkBuffer::finalizeCodeWithDisassembly):
+        (JSC::LinkBuffer::dumpLinkStatistics):
+        (JSC::LinkBuffer::dumpCode):
+        * assembler/LinkBuffer.h:
+        (JSC):
+        * assembler/SH4Assembler.h:
+        (JSC::SH4Assembler::vprintfStdoutInstr):
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::dumpBytecodeCommentAndNewLine):
+        (JSC::CodeBlock::printUnaryOp):
+        (JSC::CodeBlock::printBinaryOp):
+        (JSC::CodeBlock::printConditionalJump):
+        (JSC::CodeBlock::printGetByIdOp):
+        (JSC::dumpStructure):
+        (JSC::dumpChain):
+        (JSC::CodeBlock::printGetByIdCacheStatus):
+        (JSC::CodeBlock::printCallOp):
+        (JSC::CodeBlock::printPutByIdOp):
+        (JSC::CodeBlock::printStructure):
+        (JSC::CodeBlock::printStructures):
+        (JSC::CodeBlock::dump):
+        (JSC::CodeBlock::dumpStatistics):
+        (JSC::CodeBlock::finalizeUnconditionally):
+        (JSC::CodeBlock::resetStubInternal):
+        (JSC::CodeBlock::reoptimize):
+        (JSC::ProgramCodeBlock::jettison):
+        (JSC::EvalCodeBlock::jettison):
+        (JSC::FunctionCodeBlock::jettison):
+        (JSC::CodeBlock::shouldOptimizeNow):
+        (JSC::CodeBlock::tallyFrequentExitSites):
+        (JSC::CodeBlock::dumpValueProfiles):
+        * bytecode/Opcode.cpp:
+        (JSC::OpcodeStats::~OpcodeStats):
+        * bytecode/SamplingTool.cpp:
+        (JSC::SamplingFlags::stop):
+        (JSC::SamplingRegion::dumpInternal):
+        (JSC::SamplingTool::dump):
+        * dfg/DFGAbstractState.cpp:
+        (JSC::DFG::AbstractState::initialize):
+        (JSC::DFG::AbstractState::endBasicBlock):
+        (JSC::DFG::AbstractState::mergeStateAtTail):
+        (JSC::DFG::AbstractState::mergeToSuccessors):
+        * dfg/DFGAbstractValue.h:
+        (JSC::DFG::AbstractValue::dump):
+        * dfg/DFGArgumentsSimplificationPhase.cpp:
+        (JSC::DFG::ArgumentsSimplificationPhase::run):
+        * dfg/DFGByteCodeParser.cpp:
+        (JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
+        (JSC::DFG::ByteCodeParser::getPredictionWithoutOSRExit):
+        (JSC::DFG::ByteCodeParser::getArrayModeAndEmitChecks):
+        (JSC::DFG::ByteCodeParser::makeSafe):
+        (JSC::DFG::ByteCodeParser::makeDivSafe):
+        (JSC::DFG::ByteCodeParser::handleCall):
+        (JSC::DFG::ByteCodeParser::handleInlining):
+        (JSC::DFG::ByteCodeParser::parseBlock):
+        (JSC::DFG::ByteCodeParser::processPhiStack):
+        (JSC::DFG::ByteCodeParser::linkBlock):
+        (JSC::DFG::ByteCodeParser::InlineStackEntry::InlineStackEntry):
+        (JSC::DFG::ByteCodeParser::parseCodeBlock):
+        (JSC::DFG::ByteCodeParser::parse):
+        * dfg/DFGCFAPhase.cpp:
+        (JSC::DFG::CFAPhase::performBlockCFA):
+        (JSC::DFG::CFAPhase::performForwardCFA):
+        * dfg/DFGCFGSimplificationPhase.cpp:
+        (JSC::DFG::CFGSimplificationPhase::run):
+        (JSC::DFG::CFGSimplificationPhase::fixPossibleGetLocal):
+        (JSC::DFG::CFGSimplificationPhase::fixPhis):
+        (JSC::DFG::CFGSimplificationPhase::fixJettisonedPredecessors):
+        (JSC::DFG::CFGSimplificationPhase::removePotentiallyDeadPhiReference):
+        (JSC::DFG::CFGSimplificationPhase::mergeBlocks):
+        * dfg/DFGCSEPhase.cpp:
+        (JSC::DFG::CSEPhase::endIndexForPureCSE):
+        (JSC::DFG::CSEPhase::setReplacement):
+        (JSC::DFG::CSEPhase::eliminate):
+        (JSC::DFG::CSEPhase::performNodeCSE):
+        * dfg/DFGCapabilities.cpp:
+        (JSC::DFG::debugFail):
+        * dfg/DFGConstantFoldingPhase.cpp:
+        (JSC::DFG::ConstantFoldingPhase::foldConstants):
+        (JSC::DFG::ConstantFoldingPhase::paintUnreachableCode):
+        * dfg/DFGDisassembler.cpp:
+        (JSC::DFG::Disassembler::dump):
+        * dfg/DFGDriver.cpp:
+        (JSC::DFG::compile):
+        * dfg/DFGFixupPhase.cpp:
+        (JSC::DFG::FixupPhase::fixupNode):
+        (JSC::DFG::FixupPhase::fixDoubleEdge):
+        * dfg/DFGGraph.cpp:
+        (JSC::DFG::printWhiteSpace):
+        (JSC::DFG::Graph::dumpCodeOrigin):
+        (JSC::DFG::Graph::dump):
+        (JSC::DFG::Graph::dumpBlockHeader):
+        (JSC::DFG::Graph::predictArgumentTypes):
+        * dfg/DFGJITCompiler.cpp:
+        (JSC::DFG::JITCompiler::link):
+        * dfg/DFGOSREntry.cpp:
+        (JSC::DFG::prepareOSREntry):
+        * dfg/DFGOSRExitCompiler.cpp:
+        * dfg/DFGOSRExitCompiler32_64.cpp:
+        (JSC::DFG::OSRExitCompiler::compileExit):
+        * dfg/DFGOSRExitCompiler64.cpp:
+        (JSC::DFG::OSRExitCompiler::compileExit):
+        * dfg/DFGOperations.cpp:
+        * dfg/DFGPhase.cpp:
+        (JSC::DFG::Phase::beginPhase):
+        * dfg/DFGPhase.h:
+        (JSC::DFG::runAndLog):
+        * dfg/DFGPredictionPropagationPhase.cpp:
+        (JSC::DFG::PredictionPropagationPhase::propagate):
+        (JSC::DFG::PredictionPropagationPhase::propagateForward):
+        (JSC::DFG::PredictionPropagationPhase::propagateBackward):
+        (JSC::DFG::PredictionPropagationPhase::doRoundOfDoubleVoting):
+        * dfg/DFGRegisterBank.h:
+        (JSC::DFG::RegisterBank::dump):
+        * dfg/DFGScoreBoard.h:
+        (JSC::DFG::ScoreBoard::use):
+        (JSC::DFG::ScoreBoard::dump):
+        * dfg/DFGSlowPathGenerator.h:
+        (JSC::DFG::SlowPathGenerator::generate):
+        * dfg/DFGSpeculativeJIT.cpp:
+        (JSC::DFG::SpeculativeJIT::terminateSpeculativeExecution):
+        (JSC::DFG::SpeculativeJIT::terminateSpeculativeExecutionWithConditionalDirection):
+        (JSC::DFG::SpeculativeJIT::runSlowPathGenerators):
+        (JSC::DFG::SpeculativeJIT::dump):
+        (JSC::DFG::SpeculativeJIT::checkConsistency):
+        (JSC::DFG::SpeculativeJIT::compile):
+        (JSC::DFG::SpeculativeJIT::checkGeneratedTypeForToInt32):
+        * dfg/DFGSpeculativeJIT32_64.cpp:
+        (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
+        (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
+        (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
+        (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
+        * dfg/DFGSpeculativeJIT64.cpp:
+        (JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
+        (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
+        (JSC::DFG::SpeculativeJIT::fillSpeculateCell):
+        (JSC::DFG::SpeculativeJIT::fillSpeculateBoolean):
+        * dfg/DFGStructureCheckHoistingPhase.cpp:
+        (JSC::DFG::StructureCheckHoistingPhase::run):
+        * dfg/DFGValidate.cpp:
+        (Validate):
+        (JSC::DFG::Validate::reportValidationContext):
+        (JSC::DFG::Validate::dumpData):
+        (JSC::DFG::Validate::dumpGraphIfAppropriate):
+        * dfg/DFGVariableEventStream.cpp:
+        (JSC::DFG::VariableEventStream::logEvent):
+        (JSC::DFG::VariableEventStream::reconstruct):
+        * dfg/DFGVirtualRegisterAllocationPhase.cpp:
+        (JSC::DFG::VirtualRegisterAllocationPhase::run):
+        * heap/Heap.cpp:
+        * heap/HeapStatistics.cpp:
+        (JSC::HeapStatistics::logStatistics):
+        (JSC::HeapStatistics::showObjectStatistics):
+        * heap/MarkStack.h:
+        * heap/MarkedBlock.h:
+        * heap/SlotVisitor.cpp:
+        (JSC::SlotVisitor::validate):
+        * interpreter/CallFrame.cpp:
+        (JSC::CallFrame::dumpCaller):
+        * interpreter/Interpreter.cpp:
+        (JSC::Interpreter::dumpRegisters):
+        * jit/JIT.cpp:
+        (JSC::JIT::privateCompileMainPass):
+        (JSC::JIT::privateCompileSlowCases):
+        (JSC::JIT::privateCompile):
+        * jit/JITDisassembler.cpp:
+        (JSC::JITDisassembler::dump):
+        (JSC::JITDisassembler::dumpForInstructions):
+        * jit/JITStubRoutine.h:
+        (JSC):
+        * jit/JITStubs.cpp:
+        (JSC::DEFINE_STUB_FUNCTION):
+        * jit/JumpReplacementWatchpoint.cpp:
+        (JSC::JumpReplacementWatchpoint::fireInternal):
+        * llint/LLIntExceptions.cpp:
+        (JSC::LLInt::interpreterThrowInCaller):
+        (JSC::LLInt::returnToThrow):
+        (JSC::LLInt::callToThrow):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::llint_trace_operand):
+        (JSC::LLInt::llint_trace_value):
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        (JSC::LLInt::traceFunctionPrologue):
+        (JSC::LLInt::jitCompileAndSetHeuristics):
+        (JSC::LLInt::entryOSR):
+        (JSC::LLInt::handleHostCall):
+        (JSC::LLInt::setUpCall):
+        * profiler/Profile.cpp:
+        (JSC::Profile::debugPrintData):
+        (JSC::Profile::debugPrintDataSampleStyle):
+        * profiler/ProfileNode.cpp:
+        (JSC::ProfileNode::debugPrintData):
+        (JSC::ProfileNode::debugPrintDataSampleStyle):
+        * runtime/JSGlobalData.cpp:
+        (JSC::JSGlobalData::dumpRegExpTrace):
+        * runtime/RegExp.cpp:
+        (JSC::RegExp::matchCompareWithInterpreter):
+        * runtime/SamplingCounter.cpp:
+        (JSC::AbstractSamplingCounter::dump):
+        * runtime/Structure.cpp:
+        (JSC::Structure::dumpStatistics):
+        (JSC::PropertyMapStatisticsExitLogger::~PropertyMapStatisticsExitLogger):
+        * tools/CodeProfile.cpp:
+        (JSC::CodeProfile::report):
+        * tools/ProfileTreeNode.h:
+        (JSC::ProfileTreeNode::dumpInternal):
+        * yarr/YarrInterpreter.cpp:
+        (JSC::Yarr::ByteCompiler::dumpDisjunction):
+
+2012-11-21  Filip Pizlo  <fpizlo@apple.com>
+
         It should be possible to say disassemble(stuff) instead of having to say if (!tryToDisassemble(stuff)) dataLog("I failed")
         https://bugs.webkit.org/show_bug.cgi?id=103010
 
index 6070ba6..94b8c23 100755 (executable)
@@ -148,7 +148,7 @@ EXPORTS
     ?currentTime@WTF@@YANXZ
     ?customHasInstance@JSCell@JSC@@KA_NPAVJSObject@2@PAVExecState@2@VJSValue@2@@Z
     ?data@CString@WTF@@QBEPBDXZ
-    ?dataLog@WTF@@YAXPBDZZ
+    ?dataLogF@WTF@@YAXPBDZZ
     ?dateToDaysFrom1970@WTF@@YANHHH@Z
     ?dayInMonthFromDayInYear@WTF@@YAHH_N@Z
     ?dayInYear@WTF@@YAHNH@Z
index 27e19cc..c269157 100644 (file)
@@ -45,14 +45,14 @@ LinkBuffer::CodeRef LinkBuffer::finalizeCodeWithDisassembly(const char* format,
     
     CodeRef result = finalizeCodeWithoutDisassembly();
     
-    dataLog("Generated JIT code for ");
+    dataLogF("Generated JIT code for ");
     va_list argList;
     va_start(argList, format);
-    WTF::dataLogV(format, argList);
+    WTF::dataLogFV(format, argList);
     va_end(argList);
-    dataLog(":\n");
+    dataLogF(":\n");
     
-    dataLog("    Code at [%p, %p):\n", result.code().executableAddress(), static_cast<char*>(result.code().executableAddress()) + result.size());
+    dataLogF("    Code at [%p, %p):\n", result.code().executableAddress(), static_cast<char*>(result.code().executableAddress()) + result.size());
     disassemble(result.code(), m_size, "    ", WTF::dataFile());
     
     return result;
@@ -168,11 +168,11 @@ void LinkBuffer::dumpLinkStatistics(void* code, size_t initializeSize, size_t fi
     linkCount++;
     totalInitialSize += initialSize;
     totalFinalSize += finalSize;
-    dataLog("link %p: orig %u, compact %u (delta %u, %.2f%%)\n", 
+    dataLogF("link %p: orig %u, compact %u (delta %u, %.2f%%)\n", 
             code, static_cast<unsigned>(initialSize), static_cast<unsigned>(finalSize),
             static_cast<unsigned>(initialSize - finalSize),
             100.0 * (initialSize - finalSize) / initialSize);
-    dataLog("\ttotal %u: orig %u, compact %u (delta %u, %.2f%%)\n", 
+    dataLogF("\ttotal %u: orig %u, compact %u (delta %u, %.2f%%)\n", 
             linkCount, totalInitialSize, totalFinalSize, totalInitialSize - totalFinalSize,
             100.0 * (totalInitialSize - totalFinalSize) / totalInitialSize);
 }
@@ -191,7 +191,7 @@ void LinkBuffer::dumpCode(void* code, size_t size)
     size_t tsize = size / sizeof(short);
     char nameBuf[128];
     snprintf(nameBuf, sizeof(nameBuf), "_jsc_jit%u", codeCount++);
-    dataLog("\t.syntax unified\n"
+    dataLogF("\t.syntax unified\n"
             "\t.section\t__TEXT,__text,regular,pure_instructions\n"
             "\t.globl\t%s\n"
             "\t.align 2\n"
@@ -201,7 +201,7 @@ void LinkBuffer::dumpCode(void* code, size_t size)
             "%s:\n", nameBuf, nameBuf, code, nameBuf);
         
     for (unsigned i = 0; i < tsize; i++)
-        dataLog("\t.short\t0x%x\n", tcode[i]);
+        dataLogF("\t.short\t0x%x\n", tcode[i]);
 #elif CPU(ARM_TRADITIONAL)
     //   gcc -c jit.s
     //   objdump -D jit.o
@@ -210,7 +210,7 @@ void LinkBuffer::dumpCode(void* code, size_t size)
     size_t tsize = size / sizeof(unsigned int);
     char nameBuf[128];
     snprintf(nameBuf, sizeof(nameBuf), "_jsc_jit%u", codeCount++);
-    dataLog("\t.globl\t%s\n"
+    dataLogF("\t.globl\t%s\n"
             "\t.align 4\n"
             "\t.code 32\n"
             "\t.text\n"
@@ -218,7 +218,7 @@ void LinkBuffer::dumpCode(void* code, size_t size)
             "%s:\n", nameBuf, code, nameBuf);
 
     for (unsigned i = 0; i < tsize; i++)
-        dataLog("\t.long\t0x%x\n", tcode[i]);
+        dataLogF("\t.long\t0x%x\n", tcode[i]);
 #endif
 }
 #endif
index 0c89b93..e188243 100644 (file)
@@ -263,9 +263,9 @@ private:
 #endif
 };
 
-#define FINALIZE_CODE_IF(condition, linkBufferReference, dataLogArgumentsForHeading)  \
+#define FINALIZE_CODE_IF(condition, linkBufferReference, dataLogFArgumentsForHeading)  \
     (UNLIKELY((condition))                                              \
-     ? ((linkBufferReference).finalizeCodeWithDisassembly dataLogArgumentsForHeading) \
+     ? ((linkBufferReference).finalizeCodeWithDisassembly dataLogFArgumentsForHeading) \
      : (linkBufferReference).finalizeCodeWithoutDisassembly())
 
 // Use this to finalize code, like so:
@@ -281,14 +281,14 @@ private:
 //
 // ... and so on.
 //
-// Note that the dataLogArgumentsForHeading are only evaluated when showDisassembly
+// Note that the dataLogFArgumentsForHeading are only evaluated when showDisassembly
 // is true, so you can hide expensive disassembly-only computations inside there.
 
-#define FINALIZE_CODE(linkBufferReference, dataLogArgumentsForHeading)  \
-    FINALIZE_CODE_IF(Options::showDisassembly(), linkBufferReference, dataLogArgumentsForHeading)
+#define FINALIZE_CODE(linkBufferReference, dataLogFArgumentsForHeading)  \
+    FINALIZE_CODE_IF(Options::showDisassembly(), linkBufferReference, dataLogFArgumentsForHeading)
 
-#define FINALIZE_DFG_CODE(linkBufferReference, dataLogArgumentsForHeading)  \
-    FINALIZE_CODE_IF((Options::showDisassembly() || Options::showDFGDisassembly()), linkBufferReference, dataLogArgumentsForHeading)
+#define FINALIZE_DFG_CODE(linkBufferReference, dataLogFArgumentsForHeading)  \
+    FINALIZE_CODE_IF((Options::showDisassembly() || Options::showDFGDisassembly()), linkBufferReference, dataLogFArgumentsForHeading)
 
 } // namespace JSC
 
index 373f469..3dbde2f 100644 (file)
@@ -2070,7 +2070,7 @@ public:
     static void vprintfStdoutInstr(const char* format, va_list args)
     {
         if (getenv("JavaScriptCoreDumpJIT"))
-            WTF::dataLogV(format, args);
+            WTF::dataLogFV(format, args);
     }
 
     static void printBlockInstr(uint16_t* first, unsigned int offset, int nbInstr)
index 161996a..206d281 100644 (file)
@@ -99,11 +99,11 @@ void CodeBlock::dumpBytecodeCommentAndNewLine(int location)
 #if ENABLE(BYTECODE_COMMENTS)
     const char* comment = commentForBytecodeOffset(location);
     if (comment)
-        dataLog("\t\t ; %s", comment);
+        dataLogF("\t\t ; %s", comment);
 #else
     UNUSED_PARAM(location);
 #endif
-    dataLog("\n");
+    dataLogF("\n");
 }
 
 CString CodeBlock::registerName(ExecState* exec, int r) const
@@ -169,7 +169,7 @@ void CodeBlock::printUnaryOp(ExecState* exec, int location, const Instruction*&
     int r0 = (++it)->u.operand;
     int r1 = (++it)->u.operand;
 
-    dataLog("[%4d] %s\t\t %s, %s", location, op, registerName(exec, r0).data(), registerName(exec, r1).data());
+    dataLogF("[%4d] %s\t\t %s, %s", location, op, registerName(exec, r0).data(), registerName(exec, r1).data());
     dumpBytecodeCommentAndNewLine(location);
 }
 
@@ -178,7 +178,7 @@ void CodeBlock::printBinaryOp(ExecState* exec, int location, const Instruction*&
     int r0 = (++it)->u.operand;
     int r1 = (++it)->u.operand;
     int r2 = (++it)->u.operand;
-    dataLog("[%4d] %s\t\t %s, %s, %s", location, op, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+    dataLogF("[%4d] %s\t\t %s, %s, %s", location, op, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
     dumpBytecodeCommentAndNewLine(location);
 }
 
@@ -186,7 +186,7 @@ void CodeBlock::printConditionalJump(ExecState* exec, const Instruction*, const
 {
     int r0 = (++it)->u.operand;
     int offset = (++it)->u.operand;
-    dataLog("[%4d] %s\t\t %s, %d(->%d)", location, op, registerName(exec, r0).data(), offset, location + offset);
+    dataLogF("[%4d] %s\t\t %s, %d(->%d)", location, op, registerName(exec, r0).data(), offset, location + offset);
     dumpBytecodeCommentAndNewLine(location);
 }
 
@@ -243,7 +243,7 @@ void CodeBlock::printGetByIdOp(ExecState* exec, int location, const Instruction*
     int r0 = (++it)->u.operand;
     int r1 = (++it)->u.operand;
     int id0 = (++it)->u.operand;
-    dataLog("[%4d] %s\t %s, %s, %s", location, op, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data());
+    dataLogF("[%4d] %s\t %s, %s, %s", location, op, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data());
     it += 5;
 }
 
@@ -253,18 +253,18 @@ static void dumpStructure(const char* name, ExecState* exec, Structure* structur
     if (!structure)
         return;
     
-    dataLog("%s = %p", name, structure);
+    dataLogF("%s = %p", name, structure);
     
     PropertyOffset offset = structure->get(exec->globalData(), ident);
     if (offset != invalidOffset)
-        dataLog(" (offset = %d)", offset);
+        dataLogF(" (offset = %d)", offset);
 }
 #endif
 
 #if ENABLE(JIT) // unused when not ENABLE(JIT), leading to silly warnings
 static void dumpChain(ExecState* exec, StructureChain* chain, Identifier& ident)
 {
-    dataLog("chain = %p: [", chain);
+    dataLogF("chain = %p: [", chain);
     bool first = true;
     for (WriteBarrier<Structure>* currentStructure = chain->head();
          *currentStructure;
@@ -272,10 +272,10 @@ static void dumpChain(ExecState* exec, StructureChain* chain, Identifier& ident)
         if (first)
             first = false;
         else
-            dataLog(", ");
+            dataLogF(", ");
         dumpStructure("struct", exec, currentStructure->get(), ident);
     }
-    dataLog("]");
+    dataLogF("]");
 }
 #endif
 
@@ -289,21 +289,21 @@ void CodeBlock::printGetByIdCacheStatus(ExecState* exec, int location)
     
 #if ENABLE(LLINT)
     if (exec->interpreter()->getOpcodeID(instruction[0].u.opcode) == op_get_array_length)
-        dataLog(" llint(array_length)");
+        dataLogF(" llint(array_length)");
     else {
         Structure* structure = instruction[4].u.structure.get();
-        dataLog(" llint(");
+        dataLogF(" llint(");
         dumpStructure("struct", exec, structure, ident);
-        dataLog(")");
+        dataLogF(")");
     }
 #endif
 
 #if ENABLE(JIT)
     if (numberOfStructureStubInfos()) {
-        dataLog(" jit(");
+        dataLogF(" jit(");
         StructureStubInfo& stubInfo = getStubInfo(location);
         if (!stubInfo.seen)
-            dataLog("not seen");
+            dataLogF("not seen");
         else {
             Structure* baseStructure = 0;
             Structure* prototypeStructure = 0;
@@ -313,40 +313,40 @@ void CodeBlock::printGetByIdCacheStatus(ExecState* exec, int location)
             
             switch (stubInfo.accessType) {
             case access_get_by_id_self:
-                dataLog("self");
+                dataLogF("self");
                 baseStructure = stubInfo.u.getByIdSelf.baseObjectStructure.get();
                 break;
             case access_get_by_id_proto:
-                dataLog("proto");
+                dataLogF("proto");
                 baseStructure = stubInfo.u.getByIdProto.baseObjectStructure.get();
                 prototypeStructure = stubInfo.u.getByIdProto.prototypeStructure.get();
                 break;
             case access_get_by_id_chain:
-                dataLog("chain");
+                dataLogF("chain");
                 baseStructure = stubInfo.u.getByIdChain.baseObjectStructure.get();
                 chain = stubInfo.u.getByIdChain.chain.get();
                 break;
             case access_get_by_id_self_list:
-                dataLog("self_list");
+                dataLogF("self_list");
                 structureList = stubInfo.u.getByIdSelfList.structureList;
                 listSize = stubInfo.u.getByIdSelfList.listSize;
                 break;
             case access_get_by_id_proto_list:
-                dataLog("proto_list");
+                dataLogF("proto_list");
                 structureList = stubInfo.u.getByIdProtoList.structureList;
                 listSize = stubInfo.u.getByIdProtoList.listSize;
                 break;
             case access_unset:
-                dataLog("unset");
+                dataLogF("unset");
                 break;
             case access_get_by_id_generic:
-                dataLog("generic");
+                dataLogF("generic");
                 break;
             case access_get_array_length:
-                dataLog("array_length");
+                dataLogF("array_length");
                 break;
             case access_get_string_length:
-                dataLog("string_length");
+                dataLogF("string_length");
                 break;
             default:
                 ASSERT_NOT_REACHED();
@@ -354,44 +354,44 @@ void CodeBlock::printGetByIdCacheStatus(ExecState* exec, int location)
             }
             
             if (baseStructure) {
-                dataLog(", ");
+                dataLogF(", ");
                 dumpStructure("struct", exec, baseStructure, ident);
             }
             
             if (prototypeStructure) {
-                dataLog(", ");
+                dataLogF(", ");
                 dumpStructure("prototypeStruct", exec, baseStructure, ident);
             }
             
             if (chain) {
-                dataLog(", ");
+                dataLogF(", ");
                 dumpChain(exec, chain, ident);
             }
             
             if (structureList) {
-                dataLog(", list = %p: [", structureList);
+                dataLogF(", list = %p: [", structureList);
                 for (int i = 0; i < listSize; ++i) {
                     if (i)
-                        dataLog(", ");
-                    dataLog("(");
+                        dataLogF(", ");
+                    dataLogF("(");
                     dumpStructure("base", exec, structureList->list[i].base.get(), ident);
                     if (structureList->list[i].isChain) {
                         if (structureList->list[i].u.chain.get()) {
-                            dataLog(", ");
+                            dataLogF(", ");
                             dumpChain(exec, structureList->list[i].u.chain.get(), ident);
                         }
                     } else {
                         if (structureList->list[i].u.proto.get()) {
-                            dataLog(", ");
+                            dataLogF(", ");
                             dumpStructure("proto", exec, structureList->list[i].u.proto.get(), ident);
                         }
                     }
-                    dataLog(")");
+                    dataLogF(")");
                 }
-                dataLog("]");
+                dataLogF("]");
             }
         }
-        dataLog(")");
+        dataLogF(")");
     }
 #endif
 }
@@ -401,24 +401,24 @@ void CodeBlock::printCallOp(ExecState* exec, int location, const Instruction*& i
     int func = (++it)->u.operand;
     int argCount = (++it)->u.operand;
     int registerOffset = (++it)->u.operand;
-    dataLog("[%4d] %s\t %s, %d, %d", location, op, registerName(exec, func).data(), argCount, registerOffset);
+    dataLogF("[%4d] %s\t %s, %d, %d", location, op, registerName(exec, func).data(), argCount, registerOffset);
     if (cacheDumpMode == DumpCaches) {
 #if ENABLE(LLINT)
         LLIntCallLinkInfo* callLinkInfo = it[1].u.callLinkInfo;
         if (callLinkInfo->lastSeenCallee) {
-            dataLog(" llint(%p, exec %p)",
+            dataLogF(" llint(%p, exec %p)",
                     callLinkInfo->lastSeenCallee.get(),
                     callLinkInfo->lastSeenCallee->executable());
         } else
-            dataLog(" llint(not set)");
+            dataLogF(" llint(not set)");
 #endif
 #if ENABLE(JIT)
         if (numberOfCallLinkInfos()) {
             JSFunction* target = getCallLinkInfo(location).lastSeenCallee.get();
             if (target)
-                dataLog(" jit(%p, exec %p)", target, target->executable());
+                dataLogF(" jit(%p, exec %p)", target, target->executable());
             else
-                dataLog(" jit(not set)");
+                dataLogF(" jit(not set)");
         }
 #endif
     }
@@ -431,7 +431,7 @@ void CodeBlock::printPutByIdOp(ExecState* exec, int location, const Instruction*
     int r0 = (++it)->u.operand;
     int id0 = (++it)->u.operand;
     int r1 = (++it)->u.operand;
-    dataLog("[%4d] %s\t %s, %s, %s", location, op, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data());
+    dataLogF("[%4d] %s\t %s, %s, %s", location, op, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data());
     dumpBytecodeCommentAndNewLine(location);
     it += 5;
 }
@@ -439,7 +439,7 @@ void CodeBlock::printPutByIdOp(ExecState* exec, int location, const Instruction*
 void CodeBlock::printStructure(const char* name, const Instruction* vPC, int operand)
 {
     unsigned instructionOffset = vPC - instructions().begin();
-    dataLog("  [%4d] %s: %s\n", instructionOffset, name, pointerToSourceString(vPC[operand].u.structure).utf8().data());
+    dataLogF("  [%4d] %s: %s\n", instructionOffset, name, pointerToSourceString(vPC[operand].u.structure).utf8().data());
 }
 
 void CodeBlock::printStructures(const Instruction* vPC)
@@ -456,15 +456,15 @@ void CodeBlock::printStructures(const Instruction* vPC)
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
-        dataLog("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structure).utf8().data(), pointerToSourceString(vPC[5].u.structure).utf8().data());
+        dataLogF("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structure).utf8().data(), pointerToSourceString(vPC[5].u.structure).utf8().data());
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
-        dataLog("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_transition", pointerToSourceString(vPC[4].u.structure).utf8().data(), pointerToSourceString(vPC[5].u.structure).utf8().data(), pointerToSourceString(vPC[6].u.structureChain).utf8().data());
+        dataLogF("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_transition", pointerToSourceString(vPC[4].u.structure).utf8().data(), pointerToSourceString(vPC[5].u.structure).utf8().data(), pointerToSourceString(vPC[6].u.structureChain).utf8().data());
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
-        dataLog("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structure).utf8().data(), pointerToSourceString(vPC[5].u.structureChain).utf8().data());
+        dataLogF("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structure).utf8().data(), pointerToSourceString(vPC[5].u.structureChain).utf8().data());
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id)) {
@@ -491,23 +491,23 @@ void CodeBlock::dump()
     for (size_t i = 0; i < instructions().size(); i += opcodeLengths[exec->interpreter()->getOpcodeID(instructions()[i].u.opcode)])
         ++instructionCount;
 
-    dataLog(
+    dataLogF(
         "%lu m_instructions; %lu bytes at %p (%s); %d parameter(s); %d callee register(s); %d variable(s)",
         static_cast<unsigned long>(instructions().size()),
         static_cast<unsigned long>(instructions().size() * sizeof(Instruction)),
         this, codeTypeToString(codeType()), m_numParameters, m_numCalleeRegisters,
         m_numVars);
     if (symbolTable()->captureCount())
-        dataLog("; %d captured var(s)", symbolTable()->captureCount());
+        dataLogF("; %d captured var(s)", symbolTable()->captureCount());
     if (usesArguments()) {
-        dataLog(
+        dataLogF(
             "; uses arguments, in r%d, r%d",
             argumentsRegister(),
             unmodifiedArgumentsRegister(argumentsRegister()));
     }
     if (needsFullScopeChain() && codeType() == FunctionCode)
-        dataLog("; activation in r%d", activationRegister());
-    dataLog("\n\n");
+        dataLogF("; activation in r%d", activationRegister());
+    dataLogF("\n\n");
 
     const Instruction* begin = instructions().begin();
     const Instruction* end = instructions().end();
@@ -515,68 +515,68 @@ void CodeBlock::dump()
         dump(exec, begin, it);
 
     if (!m_identifiers.isEmpty()) {
-        dataLog("\nIdentifiers:\n");
+        dataLogF("\nIdentifiers:\n");
         size_t i = 0;
         do {
-            dataLog("  id%u = %s\n", static_cast<unsigned>(i), m_identifiers[i].string().utf8().data());
+            dataLogF("  id%u = %s\n", static_cast<unsigned>(i), m_identifiers[i].string().utf8().data());
             ++i;
         } while (i != m_identifiers.size());
     }
 
     if (!m_constantRegisters.isEmpty()) {
-        dataLog("\nConstants:\n");
+        dataLogF("\nConstants:\n");
         size_t i = 0;
         do {
-            dataLog("   k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, m_constantRegisters[i].get()).utf8().data());
+            dataLogF("   k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, m_constantRegisters[i].get()).utf8().data());
             ++i;
         } while (i < m_constantRegisters.size());
     }
 
     if (size_t count = m_unlinkedCode->numberOfRegExps()) {
-        dataLog("\nm_regexps:\n");
+        dataLogF("\nm_regexps:\n");
         size_t i = 0;
         do {
-            dataLog("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(m_unlinkedCode->regexp(i)).utf8().data());
+            dataLogF("  re%u = %s\n", static_cast<unsigned>(i), regexpToSourceString(m_unlinkedCode->regexp(i)).utf8().data());
             ++i;
         } while (i < count);
     }
 
 #if ENABLE(JIT)
     if (!m_structureStubInfos.isEmpty())
-        dataLog("\nStructures:\n");
+        dataLogF("\nStructures:\n");
 #endif
 
     if (m_rareData && !m_rareData->m_exceptionHandlers.isEmpty()) {
-        dataLog("\nException Handlers:\n");
+        dataLogF("\nException Handlers:\n");
         unsigned i = 0;
         do {
-            dataLog("\t %d: { start: [%4d] end: [%4d] target: [%4d] }\n", i + 1, m_rareData->m_exceptionHandlers[i].start, m_rareData->m_exceptionHandlers[i].end, m_rareData->m_exceptionHandlers[i].target);
+            dataLogF("\t %d: { start: [%4d] end: [%4d] target: [%4d] }\n", i + 1, m_rareData->m_exceptionHandlers[i].start, m_rareData->m_exceptionHandlers[i].end, m_rareData->m_exceptionHandlers[i].target);
             ++i;
         } while (i < m_rareData->m_exceptionHandlers.size());
     }
     
     if (m_rareData && !m_rareData->m_immediateSwitchJumpTables.isEmpty()) {
-        dataLog("Immediate Switch Jump Tables:\n");
+        dataLogF("Immediate Switch Jump Tables:\n");
         unsigned i = 0;
         do {
-            dataLog("  %1d = {\n", i);
+            dataLogF("  %1d = {\n", i);
             int entry = 0;
             Vector<int32_t>::const_iterator end = m_rareData->m_immediateSwitchJumpTables[i].branchOffsets.end();
             for (Vector<int32_t>::const_iterator iter = m_rareData->m_immediateSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {
                 if (!*iter)
                     continue;
-                dataLog("\t\t%4d => %04d\n", entry + m_rareData->m_immediateSwitchJumpTables[i].min, *iter);
+                dataLogF("\t\t%4d => %04d\n", entry + m_rareData->m_immediateSwitchJumpTables[i].min, *iter);
             }
-            dataLog("      }\n");
+            dataLogF("      }\n");
             ++i;
         } while (i < m_rareData->m_immediateSwitchJumpTables.size());
     }
     
     if (m_rareData && !m_rareData->m_characterSwitchJumpTables.isEmpty()) {
-        dataLog("\nCharacter Switch Jump Tables:\n");
+        dataLogF("\nCharacter Switch Jump Tables:\n");
         unsigned i = 0;
         do {
-            dataLog("  %1d = {\n", i);
+            dataLogF("  %1d = {\n", i);
             int entry = 0;
             Vector<int32_t>::const_iterator end = m_rareData->m_characterSwitchJumpTables[i].branchOffsets.end();
             for (Vector<int32_t>::const_iterator iter = m_rareData->m_characterSwitchJumpTables[i].branchOffsets.begin(); iter != end; ++iter, ++entry) {
@@ -584,27 +584,27 @@ void CodeBlock::dump()
                     continue;
                 ASSERT(!((i + m_rareData->m_characterSwitchJumpTables[i].min) & ~0xFFFF));
                 UChar ch = static_cast<UChar>(entry + m_rareData->m_characterSwitchJumpTables[i].min);
-                dataLog("\t\t\"%s\" => %04d\n", String(&ch, 1).utf8().data(), *iter);
+                dataLogF("\t\t\"%s\" => %04d\n", String(&ch, 1).utf8().data(), *iter);
         }
-            dataLog("      }\n");
+            dataLogF("      }\n");
             ++i;
         } while (i < m_rareData->m_characterSwitchJumpTables.size());
     }
     
     if (m_rareData && !m_rareData->m_stringSwitchJumpTables.isEmpty()) {
-        dataLog("\nString Switch Jump Tables:\n");
+        dataLogF("\nString Switch Jump Tables:\n");
         unsigned i = 0;
         do {
-            dataLog("  %1d = {\n", i);
+            dataLogF("  %1d = {\n", i);
             StringJumpTable::StringOffsetTable::const_iterator end = m_rareData->m_stringSwitchJumpTables[i].offsetTable.end();
             for (StringJumpTable::StringOffsetTable::const_iterator iter = m_rareData->m_stringSwitchJumpTables[i].offsetTable.begin(); iter != end; ++iter)
-                dataLog("\t\t\"%s\" => %04d\n", String(iter->key).utf8().data(), iter->value.branchOffset);
-            dataLog("      }\n");
+                dataLogF("\t\t\"%s\" => %04d\n", String(iter->key).utf8().data(), iter->value.branchOffset);
+            dataLogF("      }\n");
             ++i;
         } while (i < m_rareData->m_stringSwitchJumpTables.size());
     }
 
-    dataLog("\n");
+    dataLogF("\n");
 }
 
 void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instruction*& it)
@@ -612,51 +612,51 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
     int location = it - begin;
     switch (exec->interpreter()->getOpcodeID(it->u.opcode)) {
         case op_enter: {
-            dataLog("[%4d] enter", location);
+            dataLogF("[%4d] enter", location);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_create_activation: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] create_activation %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] create_activation %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_create_arguments: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] create_arguments\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] create_arguments\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_init_lazy_reg: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] init_lazy_reg\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] init_lazy_reg\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_get_callee: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] op_get_callee %s\n", location, registerName(exec, r0).data());
+            dataLogF("[%4d] op_get_callee %s\n", location, registerName(exec, r0).data());
             ++it;
             break;
         }
         case op_create_this: {
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
-            dataLog("[%4d] create_this %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
+            dataLogF("[%4d] create_this %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_convert_this: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] convert_this\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] convert_this\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             ++it; // Skip value profile.
             break;
         }
         case op_new_object: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] new_object\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] new_object\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -664,7 +664,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int dst = (++it)->u.operand;
             int argv = (++it)->u.operand;
             int argc = (++it)->u.operand;
-            dataLog("[%4d] new_array\t %s, %s, %d", location, registerName(exec, dst).data(), registerName(exec, argv).data(), argc);
+            dataLogF("[%4d] new_array\t %s, %s, %d", location, registerName(exec, dst).data(), registerName(exec, argv).data(), argc);
             dumpBytecodeCommentAndNewLine(location);
             ++it; // Skip array allocation profile.
             break;
@@ -672,7 +672,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         case op_new_array_with_size: {
             int dst = (++it)->u.operand;
             int length = (++it)->u.operand;
-            dataLog("[%4d] new_array_with_size\t %s, %s", location, registerName(exec, dst).data(), registerName(exec, length).data());
+            dataLogF("[%4d] new_array_with_size\t %s, %s", location, registerName(exec, dst).data(), registerName(exec, length).data());
             dumpBytecodeCommentAndNewLine(location);
             ++it; // Skip array allocation profile.
             break;
@@ -681,7 +681,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int dst = (++it)->u.operand;
             int argv = (++it)->u.operand;
             int argc = (++it)->u.operand;
-            dataLog("[%4d] new_array_buffer\t %s, %d, %d", location, registerName(exec, dst).data(), argv, argc);
+            dataLogF("[%4d] new_array_buffer\t %s, %d, %d", location, registerName(exec, dst).data(), argv, argc);
             dumpBytecodeCommentAndNewLine(location);
             ++it; // Skip array allocation profile.
             break;
@@ -689,18 +689,18 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         case op_new_regexp: {
             int r0 = (++it)->u.operand;
             int re0 = (++it)->u.operand;
-            dataLog("[%4d] new_regexp\t %s, ", location, registerName(exec, r0).data());
+            dataLogF("[%4d] new_regexp\t %s, ", location, registerName(exec, r0).data());
             if (r0 >=0 && r0 < (int)m_unlinkedCode->numberOfRegExps())
-                dataLog("%s", regexpName(re0, regexp(re0)).data());
+                dataLogF("%s", regexpName(re0, regexp(re0)).data());
             else
-                dataLog("bad_regexp(%d)", re0);
+                dataLogF("bad_regexp(%d)", re0);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_mov: {
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
-            dataLog("[%4d] mov\t\t %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
+            dataLogF("[%4d] mov\t\t %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -750,13 +750,13 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         }
         case op_pre_inc: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] pre_inc\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] pre_inc\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_pre_dec: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] pre_dec\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] pre_dec\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -832,7 +832,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] check_has_instance\t\t %s, %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data(), offset, location + offset);
+            dataLogF("[%4d] check_has_instance\t\t %s, %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -840,7 +840,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
-            dataLog("[%4d] instanceof\t\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+            dataLogF("[%4d] instanceof\t\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -882,7 +882,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int id0 = (++it)->u.operand;
             int value = (++it)->u.operand;
             int resolveInfo = (++it)->u.operand;
-            dataLog("[%4d] put_to_base\t %s, %s, %s, %d", location, registerName(exec, base).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, value).data(), resolveInfo);
+            dataLogF("[%4d] put_to_base\t %s, %s, %s, %d", location, registerName(exec, base).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, value).data(), resolveInfo);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -895,13 +895,13 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int id0 = (++it)->u.operand;
             int resolveInfo = (++it)->u.operand;
-            dataLog("[%4d] resolve\t\t %s, %s, %d", location, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo);
+            dataLogF("[%4d] resolve\t\t %s, %s, %d", location, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo);
             dumpBytecodeCommentAndNewLine(location);
             it++;
             break;
         }
         case op_init_global_const_nop: {
-            dataLog("[%4d] init_global_const_nop\t", location);
+            dataLogF("[%4d] init_global_const_nop\t", location);
             dumpBytecodeCommentAndNewLine(location);
             it++;
             it++;
@@ -912,7 +912,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         case op_init_global_const: {
             WriteBarrier<Unknown>* registerPointer = (++it)->u.registerPointer;
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] init_global_const\t g%d(%p), %s", location, m_globalObject->findRegisterIndex(registerPointer), registerPointer, registerName(exec, r0).data());
+            dataLogF("[%4d] init_global_const\t g%d(%p), %s", location, m_globalObject->findRegisterIndex(registerPointer), registerPointer, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             it++;
             it++;
@@ -921,7 +921,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         case op_init_global_const_check: {
             WriteBarrier<Unknown>* registerPointer = (++it)->u.registerPointer;
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] init_global_const_check\t g%d(%p), %s", location, m_globalObject->findRegisterIndex(registerPointer), registerPointer, registerName(exec, r0).data());
+            dataLogF("[%4d] init_global_const_check\t g%d(%p), %s", location, m_globalObject->findRegisterIndex(registerPointer), registerPointer, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             it++;
             it++;
@@ -937,7 +937,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int isStrict = (++it)->u.operand;
             int resolveInfo = (++it)->u.operand;
             int putToBaseInfo = (++it)->u.operand;
-            dataLog("[%4d] resolve_base%s\t %s, %s, %d, %d", location, isStrict ? "_strict" : "", registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo, putToBaseInfo);
+            dataLogF("[%4d] resolve_base%s\t %s, %s, %d, %d", location, isStrict ? "_strict" : "", registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo, putToBaseInfo);
             dumpBytecodeCommentAndNewLine(location);
             it++;
             break;
@@ -945,7 +945,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         case op_ensure_property_exists: {
             int r0 = (++it)->u.operand;
             int id0 = (++it)->u.operand;
-            dataLog("[%4d] ensure_property_exists\t %s, %s", location, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data());
+            dataLogF("[%4d] ensure_property_exists\t %s, %s", location, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -955,7 +955,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int id0 = (++it)->u.operand;
             int resolveInfo = (++it)->u.operand;
             int putToBaseInfo = (++it)->u.operand;
-            dataLog("[%4d] resolve_with_base %s, %s, %s, %d, %d", location, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo, putToBaseInfo);
+            dataLogF("[%4d] resolve_with_base %s, %s, %s, %d, %d", location, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo, putToBaseInfo);
             dumpBytecodeCommentAndNewLine(location);
             it++;
             break;
@@ -965,7 +965,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r1 = (++it)->u.operand;
             int id0 = (++it)->u.operand;
             int resolveInfo = (++it)->u.operand;
-            dataLog("[%4d] resolve_with_this %s, %s, %s, %d", location, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo);
+            dataLogF("[%4d] resolve_with_this %s, %s, %s, %d", location, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data(), resolveInfo);
             dumpBytecodeCommentAndNewLine(location);
             it++;
             break;
@@ -1035,7 +1035,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int id0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
-            dataLog("[%4d] put_getter_setter\t %s, %s, %s, %s", location, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+            dataLogF("[%4d] put_getter_setter\t %s, %s, %s, %s", location, registerName(exec, r0).data(), idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1043,7 +1043,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int id0 = (++it)->u.operand;
-            dataLog("[%4d] del_by_id\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data());
+            dataLogF("[%4d] del_by_id\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), idName(id0, m_identifiers[id0]).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1051,7 +1051,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
-            dataLog("[%4d] get_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+            dataLogF("[%4d] get_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
             dumpBytecodeCommentAndNewLine(location);
             it++;
             it++;
@@ -1061,7 +1061,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
-            dataLog("[%4d] get_argument_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+            dataLogF("[%4d] get_argument_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
             dumpBytecodeCommentAndNewLine(location);
             ++it;
             ++it;
@@ -1074,7 +1074,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r3 = (++it)->u.operand;
             int r4 = (++it)->u.operand;
             int r5 = (++it)->u.operand;
-            dataLog("[%4d] get_by_pname\t %s, %s, %s, %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data(), registerName(exec, r3).data(), registerName(exec, r4).data(), registerName(exec, r5).data());
+            dataLogF("[%4d] get_by_pname\t %s, %s, %s, %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data(), registerName(exec, r3).data(), registerName(exec, r4).data(), registerName(exec, r5).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1082,7 +1082,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
-            dataLog("[%4d] put_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+            dataLogF("[%4d] put_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
             dumpBytecodeCommentAndNewLine(location);
             ++it;
             break;
@@ -1091,7 +1091,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int r2 = (++it)->u.operand;
-            dataLog("[%4d] del_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
+            dataLogF("[%4d] del_by_val\t %s, %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1099,19 +1099,19 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             unsigned n0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
-            dataLog("[%4d] put_by_index\t %s, %u, %s", location, registerName(exec, r0).data(), n0, registerName(exec, r1).data());
+            dataLogF("[%4d] put_by_index\t %s, %u, %s", location, registerName(exec, r0).data(), n0, registerName(exec, r1).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_jmp: {
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jmp\t\t %d(->%d)", location, offset, location + offset);
+            dataLogF("[%4d] jmp\t\t %d(->%d)", location, offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_loop: {
             int offset = (++it)->u.operand;
-            dataLog("[%4d] loop\t\t %d(->%d)", location, offset, location + offset);
+            dataLogF("[%4d] loop\t\t %d(->%d)", location, offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1143,7 +1143,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             Special::Pointer pointer = (++it)->u.specialPointer;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jneq_ptr\t\t %s, %d (%p), %d(->%d)", location, registerName(exec, r0).data(), pointer, m_globalObject->actualPointerFor(pointer), offset, location + offset);
+            dataLogF("[%4d] jneq_ptr\t\t %s, %d (%p), %d(->%d)", location, registerName(exec, r0).data(), pointer, m_globalObject->actualPointerFor(pointer), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1151,7 +1151,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jless\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jless\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1159,7 +1159,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jlesseq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jlesseq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1167,7 +1167,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jgreater\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jgreater\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1175,7 +1175,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jgreatereq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jgreatereq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1183,7 +1183,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jnless\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jnless\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1191,7 +1191,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jnlesseq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jnlesseq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1199,7 +1199,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jngreater\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jngreater\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1207,7 +1207,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jngreatereq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] jngreatereq\t\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1215,7 +1215,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] loop_if_less\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] loop_if_less\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1223,7 +1223,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] loop_if_lesseq\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] loop_if_lesseq\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1231,7 +1231,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] loop_if_greater\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] loop_if_greater\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1239,12 +1239,12 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] loop_if_greatereq\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
+            dataLogF("[%4d] loop_if_greatereq\t %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_loop_hint: {
-            dataLog("[%4d] loop_hint", location);
+            dataLogF("[%4d] loop_hint", location);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1252,7 +1252,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int tableIndex = (++it)->u.operand;
             int defaultTarget = (++it)->u.operand;
             int scrutineeRegister = (++it)->u.operand;
-            dataLog("[%4d] switch_imm\t %d, %d(->%d), %s", location, tableIndex, defaultTarget, location + defaultTarget, registerName(exec, scrutineeRegister).data());
+            dataLogF("[%4d] switch_imm\t %d, %d(->%d), %s", location, tableIndex, defaultTarget, location + defaultTarget, registerName(exec, scrutineeRegister).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1260,7 +1260,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int tableIndex = (++it)->u.operand;
             int defaultTarget = (++it)->u.operand;
             int scrutineeRegister = (++it)->u.operand;
-            dataLog("[%4d] switch_char\t %d, %d(->%d), %s", location, tableIndex, defaultTarget, location + defaultTarget, registerName(exec, scrutineeRegister).data());
+            dataLogF("[%4d] switch_char\t %d, %d(->%d), %s", location, tableIndex, defaultTarget, location + defaultTarget, registerName(exec, scrutineeRegister).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1268,7 +1268,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int tableIndex = (++it)->u.operand;
             int defaultTarget = (++it)->u.operand;
             int scrutineeRegister = (++it)->u.operand;
-            dataLog("[%4d] switch_string\t %d, %d(->%d), %s", location, tableIndex, defaultTarget, location + defaultTarget, registerName(exec, scrutineeRegister).data());
+            dataLogF("[%4d] switch_string\t %d, %d(->%d), %s", location, tableIndex, defaultTarget, location + defaultTarget, registerName(exec, scrutineeRegister).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1276,14 +1276,14 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int f0 = (++it)->u.operand;
             int shouldCheck = (++it)->u.operand;
-            dataLog("[%4d] new_func\t\t %s, f%d, %s", location, registerName(exec, r0).data(), f0, shouldCheck ? "<Checked>" : "<Unchecked>");
+            dataLogF("[%4d] new_func\t\t %s, f%d, %s", location, registerName(exec, r0).data(), f0, shouldCheck ? "<Checked>" : "<Unchecked>");
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_new_func_exp: {
             int r0 = (++it)->u.operand;
             int f0 = (++it)->u.operand;
-            dataLog("[%4d] new_func_exp\t %s, f%d", location, registerName(exec, r0).data(), f0);
+            dataLogF("[%4d] new_func_exp\t %s, f%d", location, registerName(exec, r0).data(), f0);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1300,32 +1300,32 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int thisValue = (++it)->u.operand;
             int arguments = (++it)->u.operand;
             int firstFreeRegister = (++it)->u.operand;
-            dataLog("[%4d] call_varargs\t %s, %s, %s, %d", location, registerName(exec, callee).data(), registerName(exec, thisValue).data(), registerName(exec, arguments).data(), firstFreeRegister);
+            dataLogF("[%4d] call_varargs\t %s, %s, %s, %d", location, registerName(exec, callee).data(), registerName(exec, thisValue).data(), registerName(exec, arguments).data(), firstFreeRegister);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_tear_off_activation: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] tear_off_activation\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] tear_off_activation\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_tear_off_arguments: {
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
-            dataLog("[%4d] tear_off_arguments %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
+            dataLogF("[%4d] tear_off_arguments %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_ret: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] ret\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] ret\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_call_put_result: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] call_put_result\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] call_put_result\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             it++;
             break;
@@ -1333,7 +1333,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
         case op_ret_object_or_this: {
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
-            dataLog("[%4d] constructor_ret\t\t %s %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
+            dataLogF("[%4d] constructor_ret\t\t %s %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1345,14 +1345,14 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             int count = (++it)->u.operand;
-            dataLog("[%4d] strcat\t\t %s, %s, %d", location, registerName(exec, r0).data(), registerName(exec, r1).data(), count);
+            dataLogF("[%4d] strcat\t\t %s, %s, %d", location, registerName(exec, r0).data(), registerName(exec, r1).data(), count);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_to_primitive: {
             int r0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
-            dataLog("[%4d] to_primitive\t %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
+            dataLogF("[%4d] to_primitive\t %s, %s", location, registerName(exec, r0).data(), registerName(exec, r1).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1362,7 +1362,7 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int r2 = it[3].u.operand;
             int r3 = it[4].u.operand;
             int offset = it[5].u.operand;
-            dataLog("[%4d] get_pnames\t %s, %s, %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data(), registerName(exec, r3).data(), offset, location + offset);
+            dataLogF("[%4d] get_pnames\t %s, %s, %s, %s, %d(->%d)", location, registerName(exec, r0).data(), registerName(exec, r1).data(), registerName(exec, r2).data(), registerName(exec, r3).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             it += OPCODE_LENGTH(op_get_pnames) - 1;
             break;
@@ -1374,19 +1374,19 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int size = it[4].u.operand;
             int iter = it[5].u.operand;
             int offset = it[6].u.operand;
-            dataLog("[%4d] next_pname\t %s, %s, %s, %s, %s, %d(->%d)", location, registerName(exec, dest).data(), registerName(exec, base).data(), registerName(exec, i).data(), registerName(exec, size).data(), registerName(exec, iter).data(), offset, location + offset);
+            dataLogF("[%4d] next_pname\t %s, %s, %s, %s, %s, %d(->%d)", location, registerName(exec, dest).data(), registerName(exec, base).data(), registerName(exec, i).data(), registerName(exec, size).data(), registerName(exec, iter).data(), offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             it += OPCODE_LENGTH(op_next_pname) - 1;
             break;
         }
         case op_push_with_scope: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] push_with_scope\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] push_with_scope\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_pop_scope: {
-            dataLog("[%4d] pop_scope", location);
+            dataLogF("[%4d] pop_scope", location);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1394,33 +1394,33 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int id0 = (++it)->u.operand;
             int r1 = (++it)->u.operand;
             unsigned attributes = (++it)->u.operand;
-            dataLog("[%4d] push_name_scope \t%s, %s, %u", location, idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data(), attributes);
+            dataLogF("[%4d] push_name_scope \t%s, %s, %u", location, idName(id0, m_identifiers[id0]).data(), registerName(exec, r1).data(), attributes);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_jmp_scopes: {
             int scopeDelta = (++it)->u.operand;
             int offset = (++it)->u.operand;
-            dataLog("[%4d] jmp_scopes\t^%d, %d(->%d)", location, scopeDelta, offset, location + offset);
+            dataLogF("[%4d] jmp_scopes\t^%d, %d(->%d)", location, scopeDelta, offset, location + offset);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_catch: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] catch\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] catch\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_throw: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] throw\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] throw\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_throw_static_error: {
             int k0 = (++it)->u.operand;
             int k1 = (++it)->u.operand;
-            dataLog("[%4d] throw_static_error\t %s, %s", location, constantName(exec, k0, getConstant(k0)).data(), k1 ? "true" : "false");
+            dataLogF("[%4d] throw_static_error\t %s, %s", location, constantName(exec, k0, getConstant(k0)).data(), k1 ? "true" : "false");
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1429,25 +1429,25 @@ void CodeBlock::dump(ExecState* exec, const Instruction* begin, const Instructio
             int firstLine = (++it)->u.operand;
             int lastLine = (++it)->u.operand;
             int column = (++it)->u.operand;
-            dataLog("[%4d] debug\t\t %s, %d, %d, %d", location, debugHookName(debugHookID), firstLine, lastLine, column);
+            dataLogF("[%4d] debug\t\t %s, %d, %d, %d", location, debugHookName(debugHookID), firstLine, lastLine, column);
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_profile_will_call: {
             int function = (++it)->u.operand;
-            dataLog("[%4d] profile_will_call %s", location, registerName(exec, function).data());
+            dataLogF("[%4d] profile_will_call %s", location, registerName(exec, function).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_profile_did_call: {
             int function = (++it)->u.operand;
-            dataLog("[%4d] profile_did_call\t %s", location, registerName(exec, function).data());
+            dataLogF("[%4d] profile_did_call\t %s", location, registerName(exec, function).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
         case op_end: {
             int r0 = (++it)->u.operand;
-            dataLog("[%4d] end\t\t %s", location, registerName(exec, r0).data());
+            dataLogF("[%4d] end\t\t %s", location, registerName(exec, r0).data());
             dumpBytecodeCommentAndNewLine(location);
             break;
         }
@@ -1563,29 +1563,29 @@ void CodeBlock::dumpStatistics()
     totalSize += symbolTableTotalSize;
     totalSize += (liveCodeBlockSet.size() * sizeof(CodeBlock));
 
-    dataLog("Number of live CodeBlocks: %d\n", liveCodeBlockSet.size());
-    dataLog("Size of a single CodeBlock [sizeof(CodeBlock)]: %zu\n", sizeof(CodeBlock));
-    dataLog("Size of all CodeBlocks: %zu\n", totalSize);
-    dataLog("Average size of a CodeBlock: %zu\n", totalSize / liveCodeBlockSet.size());
+    dataLogF("Number of live CodeBlocks: %d\n", liveCodeBlockSet.size());
+    dataLogF("Size of a single CodeBlock [sizeof(CodeBlock)]: %zu\n", sizeof(CodeBlock));
+    dataLogF("Size of all CodeBlocks: %zu\n", totalSize);
+    dataLogF("Average size of a CodeBlock: %zu\n", totalSize / liveCodeBlockSet.size());
 
-    dataLog("Number of FunctionCode CodeBlocks: %zu (%.3f%%)\n", isFunctionCode, static_cast<double>(isFunctionCode) * 100.0 / liveCodeBlockSet.size());
-    dataLog("Number of GlobalCode CodeBlocks: %zu (%.3f%%)\n", isGlobalCode, static_cast<double>(isGlobalCode) * 100.0 / liveCodeBlockSet.size());
-    dataLog("Number of EvalCode CodeBlocks: %zu (%.3f%%)\n", isEvalCode, static_cast<double>(isEvalCode) * 100.0 / liveCodeBlockSet.size());
+    dataLogF("Number of FunctionCode CodeBlocks: %zu (%.3f%%)\n", isFunctionCode, static_cast<double>(isFunctionCode) * 100.0 / liveCodeBlockSet.size());
+    dataLogF("Number of GlobalCode CodeBlocks: %zu (%.3f%%)\n", isGlobalCode, static_cast<double>(isGlobalCode) * 100.0 / liveCodeBlockSet.size());
+    dataLogF("Number of EvalCode CodeBlocks: %zu (%.3f%%)\n", isEvalCode, static_cast<double>(isEvalCode) * 100.0 / liveCodeBlockSet.size());
 
-    dataLog("Number of CodeBlocks with rare data: %zu (%.3f%%)\n", hasRareData, static_cast<double>(hasRareData) * 100.0 / liveCodeBlockSet.size());
+    dataLogF("Number of CodeBlocks with rare data: %zu (%.3f%%)\n", hasRareData, static_cast<double>(hasRareData) * 100.0 / liveCodeBlockSet.size());
 
-    #define PRINT_STATS(name) dataLog("Number of CodeBlocks with " #name ": %zu\n", name##IsNotEmpty); dataLog("Size of all " #name ": %zu\n", name##TotalSize); 
+    #define PRINT_STATS(name) dataLogF("Number of CodeBlocks with " #name ": %zu\n", name##IsNotEmpty); dataLogF("Size of all " #name ": %zu\n", name##TotalSize); 
         FOR_EACH_MEMBER_VECTOR(PRINT_STATS)
         FOR_EACH_MEMBER_VECTOR_RARE_DATA(PRINT_STATS)
     #undef PRINT_STATS
 
-    dataLog("Number of CodeBlocks with evalCodeCache: %zu\n", evalCodeCacheIsNotEmpty);
-    dataLog("Number of CodeBlocks with symbolTable: %zu\n", symbolTableIsNotEmpty);
+    dataLogF("Number of CodeBlocks with evalCodeCache: %zu\n", evalCodeCacheIsNotEmpty);
+    dataLogF("Number of CodeBlocks with symbolTable: %zu\n", symbolTableIsNotEmpty);
 
-    dataLog("Size of all symbolTables: %zu\n", symbolTableTotalSize);
+    dataLogF("Size of all symbolTables: %zu\n", symbolTableTotalSize);
 
 #else
-    dataLog("Dumping CodeBlock statistics is not enabled.\n");
+    dataLogF("Dumping CodeBlock statistics is not enabled.\n");
 #endif
 }
 
@@ -2153,7 +2153,7 @@ void CodeBlock::finalizeUnconditionally()
                 if (!curInstruction[4].u.structure || Heap::isMarked(curInstruction[4].u.structure.get()))
                     break;
                 if (verboseUnlinking)
-                    dataLog("Clearing LLInt property access with structure %p.\n", curInstruction[4].u.structure.get());
+                    dataLogF("Clearing LLInt property access with structure %p.\n", curInstruction[4].u.structure.get());
                 curInstruction[4].u.structure.clear();
                 curInstruction[5].u.operand = 0;
                 break;
@@ -2166,7 +2166,7 @@ void CodeBlock::finalizeUnconditionally()
                     && Heap::isMarked(curInstruction[7].u.structureChain.get()))
                     break;
                 if (verboseUnlinking) {
-                    dataLog("Clearing LLInt put transition with structures %p -> %p, chain %p.\n",
+                    dataLogF("Clearing LLInt put transition with structures %p -> %p, chain %p.\n",
                             curInstruction[4].u.structure.get(),
                             curInstruction[6].u.structure.get(),
                             curInstruction[7].u.structureChain.get());
@@ -2186,7 +2186,7 @@ void CodeBlock::finalizeUnconditionally()
         for (unsigned i = 0; i < m_llintCallLinkInfos.size(); ++i) {
             if (m_llintCallLinkInfos[i].isLinked() && !Heap::isMarked(m_llintCallLinkInfos[i].callee.get())) {
                 if (verboseUnlinking)
-                    dataLog("Clearing LLInt call from %p.\n", this);
+                    dataLogF("Clearing LLInt call from %p.\n", this);
                 m_llintCallLinkInfos[i].unlink();
             }
             if (!!m_llintCallLinkInfos[i].lastSeenCallee && !Heap::isMarked(m_llintCallLinkInfos[i].lastSeenCallee.get()))
@@ -2199,14 +2199,14 @@ void CodeBlock::finalizeUnconditionally()
     // Check if we're not live. If we are, then jettison.
     if (!(shouldImmediatelyAssumeLivenessDuringScan() || m_dfgData->livenessHasBeenProved)) {
         if (verboseUnlinking)
-            dataLog("Code block %p (executable %p) has dead weak references, jettisoning during GC.\n", this, ownerExecutable());
+            dataLogF("Code block %p (executable %p) has dead weak references, jettisoning during GC.\n", this, ownerExecutable());
 
         // Make sure that the baseline JIT knows that it should re-warm-up before
         // optimizing.
         alternative()->optimizeAfterWarmUp();
         
         if (DFG::shouldShowDisassembly()) {
-            dataLog("DFG CodeBlock %p will be jettisoned because of the following dead references:\n", this);
+            dataLogF("DFG CodeBlock %p will be jettisoned because of the following dead references:\n", this);
             for (unsigned i = 0; i < m_dfgData->transitions.size(); ++i) {
                 WeakReferenceTransition& transition = m_dfgData->transitions[i];
                 JSCell* origin = transition.m_codeOrigin.get();
@@ -2214,15 +2214,15 @@ void CodeBlock::finalizeUnconditionally()
                 JSCell* to = transition.m_to.get();
                 if ((!origin || Heap::isMarked(origin)) && Heap::isMarked(from))
                     continue;
-                dataLog("    Transition under %s, ", JSValue(origin).description());
-                dataLog("%s -> ", JSValue(from).description());
-                dataLog("%s.\n", JSValue(to).description());
+                dataLogF("    Transition under %s, ", JSValue(origin).description());
+                dataLogF("%s -> ", JSValue(from).description());
+                dataLogF("%s.\n", JSValue(to).description());
             }
             for (unsigned i = 0; i < m_dfgData->weakReferences.size(); ++i) {
                 JSCell* weak = m_dfgData->weakReferences[i].get();
                 if (Heap::isMarked(weak))
                     continue;
-                dataLog("    Weak reference %s.\n", JSValue(weak).description());
+                dataLogF("    Weak reference %s.\n", JSValue(weak).description());
             }
         }
         
@@ -2234,7 +2234,7 @@ void CodeBlock::finalizeUnconditionally()
     for (size_t size = m_putToBaseOperations.size(), i = 0; i < size; ++i) {
         if (m_putToBaseOperations[i].m_structure && !Heap::isMarked(m_putToBaseOperations[i].m_structure.get())) {
             if (verboseUnlinking)
-                dataLog("Clearing putToBase info in %p.\n", this);
+                dataLogF("Clearing putToBase info in %p.\n", this);
             m_putToBaseOperations[i].m_structure.clear();
         }
     }
@@ -2248,7 +2248,7 @@ void CodeBlock::finalizeUnconditionally()
         m_resolveOperations[i].last().m_structure.clear();
         if (m_resolveOperations[i].last().m_structure && !Heap::isMarked(m_resolveOperations[i].last().m_structure.get())) {
             if (verboseUnlinking)
-                dataLog("Clearing resolve info in %p.\n", this);
+                dataLogF("Clearing resolve info in %p.\n", this);
             m_resolveOperations[i].last().m_structure.clear();
         }
     }
@@ -2263,12 +2263,12 @@ void CodeBlock::finalizeUnconditionally()
                     if (!Heap::isMarked(stub->structure())
                         || !Heap::isMarked(stub->executable())) {
                         if (verboseUnlinking)
-                            dataLog("Clearing closure call from %p to %p, stub routine %p.\n", this, stub->executable(), stub);
+                            dataLogF("Clearing closure call from %p to %p, stub routine %p.\n", this, stub->executable(), stub);
                         callLinkInfo(i).unlink(*m_globalData, repatchBuffer);
                     }
                 } else if (!Heap::isMarked(callLinkInfo(i).callee.get())) {
                     if (verboseUnlinking)
-                        dataLog("Clearing call from %p to %p.\n", this, callLinkInfo(i).callee.get());
+                        dataLogF("Clearing call from %p to %p.\n", this, callLinkInfo(i).callee.get());
                     callLinkInfo(i).unlink(*m_globalData, repatchBuffer);
                 }
             }
@@ -2303,7 +2303,7 @@ void CodeBlock::resetStubInternal(RepatchBuffer& repatchBuffer, StructureStubInf
     AccessType accessType = static_cast<AccessType>(stubInfo.accessType);
     
     if (verboseUnlinking)
-        dataLog("Clearing structure cache (kind %d) in %p.\n", stubInfo.accessType, this);
+        dataLogF("Clearing structure cache (kind %d) in %p.\n", stubInfo.accessType, this);
     
     if (isGetByIdAccess(accessType)) {
         if (getJITCode().jitType() == JITCode::DFGJIT)
@@ -2769,7 +2769,7 @@ void CodeBlock::reoptimize()
     ASSERT(replacement()->alternative() == this);
     replacement()->tallyFrequentExitSites();
     if (DFG::shouldShowDisassembly())
-        dataLog("DFG CodeBlock %p will be jettisoned due to reoptimization of %p.\n", replacement(), this);
+        dataLogF("DFG CodeBlock %p will be jettisoned due to reoptimization of %p.\n", replacement(), this);
     replacement()->jettison();
     countReoptimization();
     optimizeAfterWarmUp();
@@ -2836,7 +2836,7 @@ void ProgramCodeBlock::jettison()
     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     ASSERT(this == replacement());
     if (DFG::shouldShowDisassembly())
-        dataLog("Jettisoning DFG CodeBlock %p.\n", this);
+        dataLogF("Jettisoning DFG CodeBlock %p.\n", this);
     static_cast<ProgramExecutable*>(ownerExecutable())->jettisonOptimizedCode(*globalData());
 }
 
@@ -2845,7 +2845,7 @@ void EvalCodeBlock::jettison()
     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     ASSERT(this == replacement());
     if (DFG::shouldShowDisassembly())
-        dataLog("Jettisoning DFG CodeBlock %p.\n", this);
+        dataLogF("Jettisoning DFG CodeBlock %p.\n", this);
     static_cast<EvalExecutable*>(ownerExecutable())->jettisonOptimizedCode(*globalData());
 }
 
@@ -2854,7 +2854,7 @@ void FunctionCodeBlock::jettison()
     ASSERT(JITCode::isOptimizingJIT(getJITType()));
     ASSERT(this == replacement());
     if (DFG::shouldShowDisassembly())
-        dataLog("Jettisoning DFG CodeBlock %p.\n", this);
+        dataLogF("Jettisoning DFG CodeBlock %p.\n", this);
     static_cast<FunctionExecutable*>(ownerExecutable())->jettisonOptimizedCodeFor(*globalData(), m_isConstructor ? CodeForConstruct : CodeForCall);
 }
 
@@ -2948,7 +2948,7 @@ void CodeBlock::updateAllPredictions(OperationInProgress operation)
 bool CodeBlock::shouldOptimizeNow()
 {
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("Considering optimizing %p...\n", this);
+    dataLogF("Considering optimizing %p...\n", this);
 #endif
 
 #if ENABLE(VERBOSE_VALUE_PROFILE)
@@ -2965,7 +2965,7 @@ bool CodeBlock::shouldOptimizeNow()
     updateAllPredictionsAndCountLiveness(NoOperation, numberOfLiveNonArgumentValueProfiles, numberOfSamplesInProfiles);
 
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("Profile hotness: %lf (%u / %u), %lf (%u / %u)\n", (double)numberOfLiveNonArgumentValueProfiles / numberOfValueProfiles(), numberOfLiveNonArgumentValueProfiles, numberOfValueProfiles(), (double)numberOfSamplesInProfiles / ValueProfile::numberOfBuckets / numberOfValueProfiles(), numberOfSamplesInProfiles, ValueProfile::numberOfBuckets * numberOfValueProfiles());
+    dataLogF("Profile hotness: %lf (%u / %u), %lf (%u / %u)\n", (double)numberOfLiveNonArgumentValueProfiles / numberOfValueProfiles(), numberOfLiveNonArgumentValueProfiles, numberOfValueProfiles(), (double)numberOfSamplesInProfiles / ValueProfile::numberOfBuckets / numberOfValueProfiles(), numberOfSamplesInProfiles, ValueProfile::numberOfBuckets * numberOfValueProfiles());
 #endif
 
     if ((!numberOfValueProfiles() || (double)numberOfLiveNonArgumentValueProfiles / numberOfValueProfiles() >= Options::desiredProfileLivenessRate())
@@ -2996,7 +2996,7 @@ void CodeBlock::tallyFrequentExitSites()
             continue;
         
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("OSR exit #%u (bc#%u, @%u, %s) for code block %p occurred frequently; counting as frequent exit site.\n", i, exit.m_codeOrigin.bytecodeIndex, exit.m_nodeIndex, DFG::exitKindToString(exit.m_kind), this);
+        dataLogF("OSR exit #%u (bc#%u, @%u, %s) for code block %p occurred frequently; counting as frequent exit site.\n", i, exit.m_codeOrigin.bytecodeIndex, exit.m_nodeIndex, DFG::exitKindToString(exit.m_kind), this);
 #endif
     }
 }
@@ -3005,30 +3005,30 @@ void CodeBlock::tallyFrequentExitSites()
 #if ENABLE(VERBOSE_VALUE_PROFILE)
 void CodeBlock::dumpValueProfiles()
 {
-    dataLog("ValueProfile for %p:\n", this);
+    dataLogF("ValueProfile for %p:\n", this);
     for (unsigned i = 0; i < totalNumberOfValueProfiles(); ++i) {
         ValueProfile* profile = getFromAllValueProfiles(i);
         if (profile->m_bytecodeOffset < 0) {
             ASSERT(profile->m_bytecodeOffset == -1);
-            dataLog("   arg = %u: ", i);
+            dataLogF("   arg = %u: ", i);
         } else
-            dataLog("   bc = %d: ", profile->m_bytecodeOffset);
+            dataLogF("   bc = %d: ", profile->m_bytecodeOffset);
         if (!profile->numberOfSamples() && profile->m_prediction == SpecNone) {
-            dataLog("<empty>\n");
+            dataLogF("<empty>\n");
             continue;
         }
         profile->dump(WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
     }
-    dataLog("RareCaseProfile for %p:\n", this);
+    dataLogF("RareCaseProfile for %p:\n", this);
     for (unsigned i = 0; i < numberOfRareCaseProfiles(); ++i) {
         RareCaseProfile* profile = rareCaseProfile(i);
-        dataLog("   bc = %d: %u\n", profile->m_bytecodeOffset, profile->m_counter);
+        dataLogF("   bc = %d: %u\n", profile->m_bytecodeOffset, profile->m_counter);
     }
-    dataLog("SpecialFastCaseProfile for %p:\n", this);
+    dataLogF("SpecialFastCaseProfile for %p:\n", this);
     for (unsigned i = 0; i < numberOfSpecialFastCaseProfiles(); ++i) {
         RareCaseProfile* profile = specialFastCaseProfile(i);
-        dataLog("   bc = %d: %u\n", profile->m_bytecodeOffset, profile->m_counter);
+        dataLogF("   bc = %d: %u\n", profile->m_bytecodeOffset, profile->m_counter);
     }
 }
 #endif // ENABLE(VERBOSE_VALUE_PROFILE)
index a277140..0adc76b 100644 (file)
@@ -114,19 +114,19 @@ OpcodeStats::~OpcodeStats()
             *(currentPairIndex++) = make_pair(i, j);
     qsort(sortedPairIndices, numOpcodeIDs * numOpcodeIDs, sizeof(pair<int, int>), compareOpcodePairIndices);
     
-    dataLog("\nExecuted opcode statistics\n"); 
+    dataLogF("\nExecuted opcode statistics\n"); 
     
-    dataLog("Total instructions executed: %lld\n\n", totalInstructions);
+    dataLogF("Total instructions executed: %lld\n\n", totalInstructions);
 
-    dataLog("All opcodes by frequency:\n\n");
+    dataLogF("All opcodes by frequency:\n\n");
 
     for (int i = 0; i < numOpcodeIDs; ++i) {
         int index = sortedIndices[i];
-        dataLog("%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCounts[index], ((double) opcodeCounts[index]) / ((double) totalInstructions) * 100.0);    
+        dataLogF("%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCounts[index], ((double) opcodeCounts[index]) / ((double) totalInstructions) * 100.0);    
     }
     
-    dataLog("\n");
-    dataLog("2-opcode sequences by frequency: %lld\n\n", totalInstructions);
+    dataLogF("\n");
+    dataLogF("2-opcode sequences by frequency: %lld\n\n", totalInstructions);
     
     for (int i = 0; i < numOpcodeIDs * numOpcodeIDs; ++i) {
         pair<int, int> indexPair = sortedPairIndices[i];
@@ -135,11 +135,11 @@ OpcodeStats::~OpcodeStats()
         if (!count)
             break;
         
-        dataLog("%s%s %s:%s %lld %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), count, ((double) count) / ((double) totalInstructionPairs) * 100.0);
+        dataLogF("%s%s %s:%s %lld %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), count, ((double) count) / ((double) totalInstructionPairs) * 100.0);
     }
     
-    dataLog("\n");
-    dataLog("Most common opcodes and sequences:\n");
+    dataLogF("\n");
+    dataLogF("Most common opcodes and sequences:\n");
 
     for (int i = 0; i < numOpcodeIDs; ++i) {
         int index = sortedIndices[i];
@@ -147,7 +147,7 @@ OpcodeStats::~OpcodeStats()
         double opcodeProportion = ((double) opcodeCount) / ((double) totalInstructions);
         if (opcodeProportion < 0.0001)
             break;
-        dataLog("\n%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCount, opcodeProportion * 100.0);
+        dataLogF("\n%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCount, opcodeProportion * 100.0);
 
         for (int j = 0; j < numOpcodeIDs * numOpcodeIDs; ++j) {
             pair<int, int> indexPair = sortedPairIndices[j];
@@ -160,11 +160,11 @@ OpcodeStats::~OpcodeStats()
             if (indexPair.first != index && indexPair.second != index)
                 continue;
 
-            dataLog("    %s%s %s:%s %lld - %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), pairCount, pairProportion * 100.0);
+            dataLogF("    %s%s %s:%s %lld - %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), pairCount, pairProportion * 100.0);
         }
         
     }
-    dataLog("\n");
+    dataLogF("\n");
 }
 
 void OpcodeStats::recordInstruction(int opcode)
index f9b8245..a76fee1 100644 (file)
@@ -67,14 +67,14 @@ void SamplingFlags::stop()
         total += s_flagCounts[i];
 
     if (total) {
-        dataLog("\nSamplingFlags: sample counts with flags set: (%lld total)\n", total);
+        dataLogF("\nSamplingFlags: sample counts with flags set: (%lld total)\n", total);
         for (unsigned i = 0; i <= 32; ++i) {
             if (s_flagCounts[i])
-                dataLog("  [ %02d ] : %lld\t\t(%03.2f%%)\n", i, s_flagCounts[i], (100.0 * s_flagCounts[i]) / total);
+                dataLogF("  [ %02d ] : %lld\t\t(%03.2f%%)\n", i, s_flagCounts[i], (100.0 * s_flagCounts[i]) / total);
         }
-        dataLog("\n");
+        dataLogF("\n");
     } else
-    dataLog("\nSamplingFlags: no samples.\n\n");
+    dataLogF("\nSamplingFlags: no samples.\n\n");
 }
 uint64_t SamplingFlags::s_flagCounts[33];
 
@@ -151,7 +151,7 @@ void SamplingRegion::dump()
 void SamplingRegion::dumpInternal()
 {
     if (!s_spectrum) {
-        dataLog("\nSamplingRegion: was never sampled.\n\n");
+        dataLogF("\nSamplingRegion: was never sampled.\n\n");
         return;
     }
     
@@ -161,10 +161,10 @@ void SamplingRegion::dumpInternal()
     for (unsigned i = list.size(); i--;)
         total += list[i].count;
     
-    dataLog("\nSamplingRegion: sample counts for regions: (%lu samples)\n", total);
+    dataLogF("\nSamplingRegion: sample counts for regions: (%lu samples)\n", total);
 
     for (unsigned i = list.size(); i--;)
-        dataLog("    %3.2lf%%  %s\n", (100.0 * list[i].count) / total, list[i].key);
+        dataLogF("    %3.2lf%%  %s\n", (100.0 * list[i].count) / total, list[i].key);
 }
 #else // ENABLE(SAMPLING_REGIONS)
 void SamplingRegion::dump() { }
@@ -371,10 +371,10 @@ void SamplingTool::dump(ExecState* exec)
 
     // (2) Print Opcode sampling results.
 
-    dataLog("\nBytecode samples [*]\n");
-    dataLog("                             sample   %% of       %% of     |   cti     cti %%\n");
-    dataLog("opcode                       count     VM        total    |  count   of self\n");
-    dataLog("-------------------------------------------------------   |  ----------------\n");
+    dataLogF("\nBytecode samples [*]\n");
+    dataLogF("                             sample   %% of       %% of     |   cti     cti %%\n");
+    dataLogF("opcode                       count     VM        total    |  count   of self\n");
+    dataLogF("-------------------------------------------------------   |  ----------------\n");
 
     for (int i = 0; i < numOpcodeIDs; ++i) {
         long long count = opcodeSampleInfo[i].count;
@@ -392,15 +392,15 @@ void SamplingTool::dump(ExecState* exec)
         debugDebugPrintf("%s:%s%-6lld %.3f%%\t%.3f%%\t  |   %-6lld %.3f%%\n", opcodeName, opcodePadding, count, percentOfVM, percentOfTotal, countInCTIFunctions, percentInCTIFunctions);
     }
     
-    dataLog("\n[*] Samples inside host code are not charged to any Bytecode.\n\n");
-    dataLog("\tSamples inside VM:\t\t%lld / %lld (%.3f%%)\n", m_opcodeSampleCount, m_sampleCount, (static_cast<double>(m_opcodeSampleCount) * 100) / m_sampleCount);
-    dataLog("\tSamples inside host code:\t%lld / %lld (%.3f%%)\n\n", m_sampleCount - m_opcodeSampleCount, m_sampleCount, (static_cast<double>(m_sampleCount - m_opcodeSampleCount) * 100) / m_sampleCount);
-    dataLog("\tsample count:\tsamples inside this opcode\n");
-    dataLog("\t%% of VM:\tsample count / all opcode samples\n");
-    dataLog("\t%% of total:\tsample count / all samples\n");
-    dataLog("\t--------------\n");
-    dataLog("\tcti count:\tsamples inside a CTI function called by this opcode\n");
-    dataLog("\tcti %% of self:\tcti count / sample count\n");
+    dataLogF("\n[*] Samples inside host code are not charged to any Bytecode.\n\n");
+    dataLogF("\tSamples inside VM:\t\t%lld / %lld (%.3f%%)\n", m_opcodeSampleCount, m_sampleCount, (static_cast<double>(m_opcodeSampleCount) * 100) / m_sampleCount);
+    dataLogF("\tSamples inside host code:\t%lld / %lld (%.3f%%)\n\n", m_sampleCount - m_opcodeSampleCount, m_sampleCount, (static_cast<double>(m_sampleCount - m_opcodeSampleCount) * 100) / m_sampleCount);
+    dataLogF("\tsample count:\tsamples inside this opcode\n");
+    dataLogF("\t%% of VM:\tsample count / all opcode samples\n");
+    dataLogF("\t%% of total:\tsample count / all samples\n");
+    dataLogF("\t--------------\n");
+    dataLogF("\tcti count:\tsamples inside a CTI function called by this opcode\n");
+    dataLogF("\tcti %% of self:\tcti count / sample count\n");
     
 #if ENABLE(CODEBLOCK_SAMPLING)
 
@@ -416,7 +416,7 @@ void SamplingTool::dump(ExecState* exec)
 
     // (4) Print data from 'codeBlockSamples' array.
 
-    dataLog("\nCodeBlock samples\n\n"); 
+    dataLogF("\nCodeBlock samples\n\n"); 
 
     for (int i = 0; i < scopeCount; ++i) {
         ScriptSampleRecord* record = codeBlockSamples[i];
@@ -426,21 +426,21 @@ void SamplingTool::dump(ExecState* exec)
 
         if (blockPercent >= 1) {
             //Instruction* code = codeBlock->instructions().begin();
-            dataLog("#%d: %s:%d: %d / %lld (%.3f%%)\n", i + 1, record->m_executable->sourceURL().utf8().data(), codeBlock->lineNumberForBytecodeOffset(0), record->m_sampleCount, m_sampleCount, blockPercent);
+            dataLogF("#%d: %s:%d: %d / %lld (%.3f%%)\n", i + 1, record->m_executable->sourceURL().utf8().data(), codeBlock->lineNumberForBytecodeOffset(0), record->m_sampleCount, m_sampleCount, blockPercent);
             if (i < 10) {
                 HashMap<unsigned,unsigned> lineCounts;
                 codeBlock->dump(exec);
 
-                dataLog("    Opcode and line number samples [*]\n\n");
+                dataLogF("    Opcode and line number samples [*]\n\n");
                 for (unsigned op = 0; op < record->m_size; ++op) {
                     int count = record->m_samples[op];
                     if (count) {
-                        dataLog("    [% 4d] has sample count: % 4d\n", op, count);
+                        dataLogF("    [% 4d] has sample count: % 4d\n", op, count);
                         unsigned line = codeBlock->lineNumberForBytecodeOffset(op);
                         lineCounts.set(line, (lineCounts.contains(line) ? lineCounts.get(line) : 0) + count);
                     }
                 }
-                dataLog("\n");
+                dataLogF("\n");
 
                 int linesCount = lineCounts.size();
                 Vector<LineCountInfo> lineCountInfo(linesCount);
@@ -453,12 +453,12 @@ void SamplingTool::dump(ExecState* exec)
                 qsort(lineCountInfo.begin(), linesCount, sizeof(LineCountInfo), compareLineCountInfoSampling);
 
                 for (lineno = 0; lineno < linesCount; ++lineno) {
-                    dataLog("    Line #%d has sample count %d.\n", lineCountInfo[lineno].line, lineCountInfo[lineno].count);
+                    dataLogF("    Line #%d has sample count %d.\n", lineCountInfo[lineno].line, lineCountInfo[lineno].count);
                 }
-                dataLog("\n");
-                dataLog("    [*] Samples inside host code are charged to the calling Bytecode.\n");
-                dataLog("        Samples on a call / return boundary are not charged to a specific opcode or line.\n\n");
-                dataLog("            Samples on a call / return boundary: %d / %d (%.3f%%)\n\n", record->m_sampleCount - record->m_opcodeSampleCount, record->m_sampleCount, (static_cast<double>(record->m_sampleCount - record->m_opcodeSampleCount) * 100) / record->m_sampleCount);
+                dataLogF("\n");
+                dataLogF("    [*] Samples inside host code are charged to the calling Bytecode.\n");
+                dataLogF("        Samples on a call / return boundary are not charged to a specific opcode or line.\n\n");
+                dataLogF("            Samples on a call / return boundary: %d / %d (%.3f%%)\n\n", record->m_sampleCount - record->m_opcodeSampleCount, record->m_sampleCount, (static_cast<double>(record->m_sampleCount - record->m_opcodeSampleCount) * 100) / record->m_sampleCount);
             }
         }
     }
index 92f2f20..23b84ce 100644 (file)
@@ -152,9 +152,9 @@ void AbstractState::initialize(Graph& graph)
             int operand = graph.m_mustHandleValues.operandForIndex(i);
             block->valuesAtHead.operand(operand).merge(value);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("    Initializing Block #%u, operand r%d, to ", blockIndex, operand);
+            dataLogF("    Initializing Block #%u, operand r%d, to ", blockIndex, operand);
             block->valuesAtHead.operand(operand).dump(WTF::dataFile());
-            dataLog("\n");
+            dataLogF("\n");
 #endif
         }
         block->cfaShouldRevisit = true;
@@ -181,7 +181,7 @@ bool AbstractState::endBasicBlock(MergeMode mergeMode)
     if (mergeMode != DontMerge || !ASSERT_DISABLED) {
         for (size_t argument = 0; argument < block->variablesAtTail.numberOfArguments(); ++argument) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("        Merging state for argument %zu.\n", argument);
+            dataLogF("        Merging state for argument %zu.\n", argument);
 #endif
             AbstractValue& destination = block->valuesAtTail.argument(argument);
             changed |= mergeStateAtTail(destination, m_variables.argument(argument), block->variablesAtTail.argument(argument));
@@ -189,7 +189,7 @@ bool AbstractState::endBasicBlock(MergeMode mergeMode)
         
         for (size_t local = 0; local < block->variablesAtTail.numberOfLocals(); ++local) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("        Merging state for local %zu.\n", local);
+            dataLogF("        Merging state for local %zu.\n", local);
 #endif
             AbstractValue& destination = block->valuesAtTail.local(local);
             changed |= mergeStateAtTail(destination, m_variables.local(local), block->variablesAtTail.local(local));
@@ -199,7 +199,7 @@ bool AbstractState::endBasicBlock(MergeMode mergeMode)
     ASSERT(mergeMode != DontMerge || !changed);
     
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-    dataLog("        Branch direction = %s\n", branchDirectionToString(m_branchDirection));
+    dataLogF("        Branch direction = %s\n", branchDirectionToString(m_branchDirection));
 #endif
     
     reset();
@@ -1787,15 +1787,15 @@ inline bool AbstractState::mergeStateAtTail(AbstractValue& destination, Abstract
         return false;
     
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-    dataLog("          It's live, node @%u.\n", nodeIndex);
+    dataLogF("          It's live, node @%u.\n", nodeIndex);
 #endif
     
     if (node.variableAccessData()->isCaptured()) {
         source = inVariable;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("          Transfering ");
+        dataLogF("          Transfering ");
         source.dump(WTF::dataFile());
-        dataLog(" from last access due to captured variable.\n");
+        dataLogF(" from last access due to captured variable.\n");
 #endif
     } else {
         switch (node.op()) {
@@ -1805,9 +1805,9 @@ inline bool AbstractState::mergeStateAtTail(AbstractValue& destination, Abstract
             // The block transfers the value from head to tail.
             source = inVariable;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("          Transfering ");
+            dataLogF("          Transfering ");
             source.dump(WTF::dataFile());
-            dataLog(" from head to tail.\n");
+            dataLogF(" from head to tail.\n");
 #endif
             break;
             
@@ -1815,9 +1815,9 @@ inline bool AbstractState::mergeStateAtTail(AbstractValue& destination, Abstract
             // The block refines the value with additional speculations.
             source = forNode(nodeIndex);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("          Refining to ");
+            dataLogF("          Refining to ");
             source.dump(WTF::dataFile());
-            dataLog("\n");
+            dataLogF("\n");
 #endif
             break;
             
@@ -1830,9 +1830,9 @@ inline bool AbstractState::mergeStateAtTail(AbstractValue& destination, Abstract
             } else
                 source = forNode(node.child1());
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("          Setting to ");
+            dataLogF("          Setting to ");
             source.dump(WTF::dataFile());
-            dataLog("\n");
+            dataLogF("\n");
 #endif
             break;
         
@@ -1846,7 +1846,7 @@ inline bool AbstractState::mergeStateAtTail(AbstractValue& destination, Abstract
         // Abstract execution did not change the output value of the variable, for this
         // basic block, on this iteration.
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("          Not changed!\n");
+        dataLogF("          Not changed!\n");
 #endif
         return false;
     }
@@ -1856,7 +1856,7 @@ inline bool AbstractState::mergeStateAtTail(AbstractValue& destination, Abstract
     // true to indicate that the fixpoint must go on!
     destination = source;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-    dataLog("          Changed!\n");
+    dataLogF("          Changed!\n");
 #endif
     return true;
 }
@@ -1897,7 +1897,7 @@ inline bool AbstractState::mergeToSuccessors(
     case Jump: {
         ASSERT(basicBlock->cfaBranchDirection == InvalidBranchDirection);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("        Merging to block #%u.\n", terminal.takenBlockIndex());
+        dataLogF("        Merging to block #%u.\n", terminal.takenBlockIndex());
 #endif
         return merge(basicBlock, graph.m_blocks[terminal.takenBlockIndex()].get());
     }
@@ -1906,12 +1906,12 @@ inline bool AbstractState::mergeToSuccessors(
         ASSERT(basicBlock->cfaBranchDirection != InvalidBranchDirection);
         bool changed = false;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("        Merging to block #%u.\n", terminal.takenBlockIndex());
+        dataLogF("        Merging to block #%u.\n", terminal.takenBlockIndex());
 #endif
         if (basicBlock->cfaBranchDirection != TakeFalse)
             changed |= merge(basicBlock, graph.m_blocks[terminal.takenBlockIndex()].get());
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("        Merging to block #%u.\n", terminal.notTakenBlockIndex());
+        dataLogF("        Merging to block #%u.\n", terminal.notTakenBlockIndex());
 #endif
         if (basicBlock->cfaBranchDirection != TakeTrue)
             changed |= merge(basicBlock, graph.m_blocks[terminal.notTakenBlockIndex()].get());
index 0127d58..c60b792 100644 (file)
@@ -375,7 +375,7 @@ struct AbstractValue {
     {
         fprintf(out, "(%s, %s, ", speculationToString(m_type), arrayModesToString(m_arrayModes));
         m_currentKnownStructure.dump(out);
-        dataLog(", ");
+        dataLogF(", ");
         m_futurePossibleStructure.dump(out);
         if (!!m_value)
             fprintf(out, ", %s", m_value.description());
index 00b1109..b02e011 100644 (file)
@@ -359,49 +359,49 @@ public:
         }
         
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Arguments aliasing states:\n");
+        dataLogF("Arguments aliasing states:\n");
         for (unsigned i = 0; i < m_graph.m_variableAccessData.size(); ++i) {
             VariableAccessData* variableAccessData = &m_graph.m_variableAccessData[i];
             if (!variableAccessData->isRoot())
                 continue;
-            dataLog("   r%d(%s): ", variableAccessData->local(), m_graph.nameOfVariableAccessData(variableAccessData));
+            dataLogF("   r%d(%s): ", variableAccessData->local(), m_graph.nameOfVariableAccessData(variableAccessData));
             if (variableAccessData->isCaptured())
-                dataLog("Captured");
+                dataLogF("Captured");
             else {
                 ArgumentsAliasingData& data =
                     m_argumentsAliasing.find(variableAccessData)->value;
                 bool first = true;
                 if (data.callContextIsValid()) {
                     if (!first)
-                        dataLog(", ");
-                    dataLog("Have Call Context: %p", data.callContext);
+                        dataLogF(", ");
+                    dataLogF("Have Call Context: %p", data.callContext);
                     first = false;
                     if (!m_createsArguments.contains(data.callContext))
-                        dataLog(" (Does Not Create Arguments)");
+                        dataLogF(" (Does Not Create Arguments)");
                 }
                 if (data.argumentsAssignmentIsValid()) {
                     if (!first)
-                        dataLog(", ");
-                    dataLog("Arguments Assignment Is Valid");
+                        dataLogF(", ");
+                    dataLogF("Arguments Assignment Is Valid");
                     first = false;
                 }
                 if (!data.escapes) {
                     if (!first)
-                        dataLog(", ");
-                    dataLog("Does Not Escape");
+                        dataLogF(", ");
+                    dataLogF("Does Not Escape");
                     first = false;
                 }
                 if (!first)
-                    dataLog(", ");
+                    dataLogF(", ");
                 if (data.isValid()) {
                     if (m_createsArguments.contains(data.callContext))
-                        dataLog("VALID");
+                        dataLogF("VALID");
                     else
-                        dataLog("INVALID (due to argument creation)");
+                        dataLogF("INVALID (due to argument creation)");
                 } else
-                    dataLog("INVALID (due to bad variable use)");
+                    dataLogF("INVALID (due to bad variable use)");
             }
-            dataLog("\n");
+            dataLogF("\n");
         }
 #endif
         
index c3a917a..9b879b9 100644 (file)
@@ -256,7 +256,7 @@ private:
             m_inlineStackTop->m_lazyOperands.prediction(
                 LazyOperandValueProfileKey(m_currentIndex, node.local()));
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Lazy operand [@%u, bc#%u, r%d] prediction: %s\n",
+        dataLogF("Lazy operand [@%u, bc#%u, r%d] prediction: %s\n",
                 nodeIndex, m_currentIndex, node.local(), speculationToString(prediction));
 #endif
         node.variableAccessData()->predict(prediction);
@@ -876,7 +876,7 @@ private:
         
         SpeculatedType prediction = m_inlineStackTop->m_profiledBlock->valueProfilePredictionForBytecodeOffset(bytecodeIndex);
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Dynamic [@%u, bc#%u] prediction: %s\n", nodeIndex, bytecodeIndex, speculationToString(prediction));
+        dataLogF("Dynamic [@%u, bc#%u] prediction: %s\n", nodeIndex, bytecodeIndex, speculationToString(prediction));
 #endif
         
         return prediction;
@@ -922,8 +922,8 @@ private:
         
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
         if (m_inlineStackTop->m_profiledBlock->numberOfRareCaseProfiles())
-            dataLog("Slow case profile for bc#%u: %u\n", m_currentIndex, m_inlineStackTop->m_profiledBlock->rareCaseProfileForBytecodeOffset(m_currentIndex)->m_counter);
-        dataLog("Array profile for bc#%u: %p%s%s, %u\n", m_currentIndex, profile->expectedStructure(), profile->structureIsPolymorphic() ? " (polymorphic)" : "", profile->mayInterceptIndexedAccesses() ? " (may intercept)" : "", profile->observedArrayModes());
+            dataLogF("Slow case profile for bc#%u: %u\n", m_currentIndex, m_inlineStackTop->m_profiledBlock->rareCaseProfileForBytecodeOffset(m_currentIndex)->m_counter);
+        dataLogF("Array profile for bc#%u: %p%s%s, %u\n", m_currentIndex, profile->expectedStructure(), profile->structureIsPolymorphic() ? " (polymorphic)" : "", profile->mayInterceptIndexedAccesses() ? " (may intercept)" : "", profile->observedArrayModes());
 #endif
         
         bool makeSafe =
@@ -967,13 +967,13 @@ private:
             if (m_inlineStackTop->m_profiledBlock->likelyToTakeDeepestSlowCase(m_currentIndex)
                 || m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow)) {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                dataLog("Making ArithMul @%u take deepest slow case.\n", nodeIndex);
+                dataLogF("Making ArithMul @%u take deepest slow case.\n", nodeIndex);
 #endif
                 m_graph[nodeIndex].mergeFlags(NodeMayOverflow | NodeMayNegZero);
             } else if (m_inlineStackTop->m_profiledBlock->likelyToTakeSlowCase(m_currentIndex)
                        || m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero)) {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                dataLog("Making ArithMul @%u take faster slow case.\n", nodeIndex);
+                dataLogF("Making ArithMul @%u take faster slow case.\n", nodeIndex);
 #endif
                 m_graph[nodeIndex].mergeFlags(NodeMayNegZero);
             }
@@ -1003,7 +1003,7 @@ private:
             return nodeIndex;
         
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Making %s @%u safe at bc#%u because special fast-case counter is at %u and exit profiles say %d, %d\n", Graph::opName(m_graph[nodeIndex].op()), nodeIndex, m_currentIndex, m_inlineStackTop->m_profiledBlock->specialFastCaseProfileForBytecodeOffset(m_currentIndex)->m_counter, m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow), m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero));
+        dataLogF("Making %s @%u safe at bc#%u because special fast-case counter is at %u and exit profiles say %d, %d\n", Graph::opName(m_graph[nodeIndex].op()), nodeIndex, m_currentIndex, m_inlineStackTop->m_profiledBlock->specialFastCaseProfileForBytecodeOffset(m_currentIndex)->m_counter, m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, Overflow), m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, NegativeZero));
 #endif
         
         // FIXME: It might be possible to make this more granular. The DFG certainly can
@@ -1277,19 +1277,19 @@ void ByteCodeParser::handleCall(Interpreter* interpreter, Instruction* currentIn
         m_inlineStackTop->m_profiledBlock, m_currentIndex);
     
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("For call at @%lu bc#%u: ", m_graph.size(), m_currentIndex);
+    dataLogF("For call at @%lu bc#%u: ", m_graph.size(), m_currentIndex);
     if (callLinkStatus.isSet()) {
         if (callLinkStatus.couldTakeSlowPath())
-            dataLog("could take slow path, ");
-        dataLog("target = %p\n", callLinkStatus.callTarget());
+            dataLogF("could take slow path, ");
+        dataLogF("target = %p\n", callLinkStatus.callTarget());
     } else
-        dataLog("not set.\n");
+        dataLogF("not set.\n");
 #endif
     
     if (m_graph.isFunctionConstant(callTarget)) {
         callType = ConstantFunction;
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Call at [@%lu, bc#%u] has a function constant: %p, exec %p.\n",
+        dataLogF("Call at [@%lu, bc#%u] has a function constant: %p, exec %p.\n",
                 m_graph.size(), m_currentIndex,
                 m_graph.valueOfFunctionConstant(callTarget),
                 m_graph.valueOfFunctionConstant(callTarget)->executable());
@@ -1297,7 +1297,7 @@ void ByteCodeParser::handleCall(Interpreter* interpreter, Instruction* currentIn
     } else if (m_graph.isInternalFunctionConstant(callTarget)) {
         callType = ConstantInternalFunction;
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Call at [@%lu, bc#%u] has an internal function constant: %p.\n",
+        dataLogF("Call at [@%lu, bc#%u] has an internal function constant: %p.\n",
                 m_graph.size(), m_currentIndex,
                 m_graph.valueOfInternalFunctionConstant(callTarget));
 #endif
@@ -1305,14 +1305,14 @@ void ByteCodeParser::handleCall(Interpreter* interpreter, Instruction* currentIn
                && !m_inlineStackTop->m_exitProfile.hasExitSite(m_currentIndex, BadCache)) {
         callType = LinkedFunction;
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Call at [@%lu, bc#%u] is linked to: %p, exec %p.\n",
+        dataLogF("Call at [@%lu, bc#%u] is linked to: %p, exec %p.\n",
                 m_graph.size(), m_currentIndex, callLinkStatus.callTarget(),
                 callLinkStatus.callTarget()->executable());
 #endif
     } else {
         callType = UnknownFunction;
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Call at [@%lu, bc#%u] is has an unknown or ambiguous target.\n",
+        dataLogF("Call at [@%lu, bc#%u] is has an unknown or ambiguous target.\n",
                 m_graph.size(), m_currentIndex);
 #endif
     }
@@ -1437,7 +1437,7 @@ bool ByteCodeParser::handleInlining(bool usesResult, int callTarget, NodeIndex c
     ASSERT(canInlineFunctionFor(codeBlock, kind));
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Inlining executable %p.\n", executable);
+    dataLogF("Inlining executable %p.\n", executable);
 #endif
     
     // Now we know without a doubt that we are committed to inlining. So begin the process
@@ -1522,7 +1522,7 @@ bool ByteCodeParser::handleInlining(bool usesResult, int callTarget, NodeIndex c
         // caller. It doesn't need to be linked to, but it needs outgoing links.
         if (!inlineStackEntry.m_unlinkedBlocks.isEmpty()) {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-            dataLog("Reascribing bytecode index of block %p from bc#%u to bc#%u (inline return case).\n", lastBlock, lastBlock->bytecodeBegin, m_currentIndex);
+            dataLogF("Reascribing bytecode index of block %p from bc#%u to bc#%u (inline return case).\n", lastBlock, lastBlock->bytecodeBegin, m_currentIndex);
 #endif
             // For debugging purposes, set the bytecodeBegin. Note that this doesn't matter
             // for release builds because this block will never serve as a potential target
@@ -1534,7 +1534,7 @@ bool ByteCodeParser::handleInlining(bool usesResult, int callTarget, NodeIndex c
         m_currentBlock = m_graph.m_blocks.last().get();
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Done inlining executable %p, continuing code generation at epilogue.\n", executable);
+        dataLogF("Done inlining executable %p, continuing code generation at epilogue.\n", executable);
 #endif
         return true;
     }
@@ -1561,7 +1561,7 @@ bool ByteCodeParser::handleInlining(bool usesResult, int callTarget, NodeIndex c
     // Need to create a new basic block for the continuation at the caller.
     OwnPtr<BasicBlock> block = adoptPtr(new BasicBlock(nextOffset, m_numArguments, m_numLocals));
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Creating inline epilogue basic block %p, #%zu for %p bc#%u at inline depth %u.\n", block.get(), m_graph.m_blocks.size(), m_inlineStackTop->executable(), m_currentIndex, CodeOrigin::inlineDepthForCallFrame(m_inlineStackTop->m_inlineCallFrame));
+    dataLogF("Creating inline epilogue basic block %p, #%zu for %p bc#%u at inline depth %u.\n", block.get(), m_graph.m_blocks.size(), m_inlineStackTop->executable(), m_currentIndex, CodeOrigin::inlineDepthForCallFrame(m_inlineStackTop->m_inlineCallFrame));
 #endif
     m_currentBlock = block.get();
     ASSERT(m_inlineStackTop->m_caller->m_blockLinkingTargets.isEmpty() || m_graph.m_blocks[m_inlineStackTop->m_caller->m_blockLinkingTargets.last()]->bytecodeBegin < nextOffset);
@@ -1573,7 +1573,7 @@ bool ByteCodeParser::handleInlining(bool usesResult, int callTarget, NodeIndex c
     // At this point we return and continue to generate code for the caller, but
     // in the new basic block.
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Done inlining executable %p, continuing code generation in new block.\n", executable);
+    dataLogF("Done inlining executable %p, continuing code generation in new block.\n", executable);
 #endif
     return true;
 }
@@ -2077,7 +2077,7 @@ bool ByteCodeParser::parseBlock(unsigned limit)
                 addToGraph(Jump, OpInfo(m_currentIndex));
             else {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                dataLog("Refusing to plant jump at limit %u because block %p is empty.\n", limit, m_currentBlock);
+                dataLogF("Refusing to plant jump at limit %u because block %p is empty.\n", limit, m_currentBlock);
 #endif
             }
             return shouldContinueParsing;
@@ -2104,9 +2104,9 @@ bool ByteCodeParser::parseBlock(unsigned limit)
                     m_inlineStackTop->m_profiledBlock->valueProfileForBytecodeOffset(m_currentProfilingIndex);
                 profile->computeUpdatedPrediction();
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                dataLog("[@%lu bc#%u]: profile %p: ", m_graph.size(), m_currentProfilingIndex, profile);
+                dataLogF("[@%lu bc#%u]: profile %p: ", m_graph.size(), m_currentProfilingIndex, profile);
                 profile->dump(WTF::dataFile());
-                dataLog("\n");
+                dataLogF("\n");
 #endif
                 if (profile->m_singletonValueIsTop
                     || !profile->m_singletonValue
@@ -3274,12 +3274,12 @@ void ByteCodeParser::processPhiStack()
         VariableAccessData* dataForPhi = m_graph[entry.m_phi].variableAccessData();
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   Handling phi entry for var %u, phi @%u.\n", entry.m_varNo, entry.m_phi);
+        dataLogF("   Handling phi entry for var %u, phi @%u.\n", entry.m_varNo, entry.m_phi);
 #endif
         
         for (size_t i = 0; i < predecessors.size(); ++i) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("     Dealing with predecessor block %u.\n", predecessors[i]);
+            dataLogF("     Dealing with predecessor block %u.\n", predecessors[i]);
 #endif
             
             BasicBlock* predecessorBlock = m_graph.m_blocks[predecessors[i]].get();
@@ -3289,7 +3289,7 @@ void ByteCodeParser::processPhiStack()
             NodeIndex valueInPredecessor = var;
             if (valueInPredecessor == NoNode) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Did not find node, adding phi.\n");
+                dataLogF("      Did not find node, adding phi.\n");
 #endif
 
                 valueInPredecessor = insertPhiNode(OpInfo(newVariableAccessData(stackType == ArgumentPhiStack ? argumentToOperand(varNo) : static_cast<int>(varNo), false)), predecessorBlock);
@@ -3301,7 +3301,7 @@ void ByteCodeParser::processPhiStack()
                 phiStack.append(PhiStackEntry(predecessorBlock, valueInPredecessor, varNo));
             } else if (m_graph[valueInPredecessor].op() == GetLocal) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Found GetLocal @%u.\n", valueInPredecessor);
+                dataLogF("      Found GetLocal @%u.\n", valueInPredecessor);
 #endif
 
                 // We want to ensure that the VariableAccessDatas are identical between the
@@ -3313,7 +3313,7 @@ void ByteCodeParser::processPhiStack()
                 valueInPredecessor = m_graph[valueInPredecessor].child1().index();
             } else {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Found @%u.\n", valueInPredecessor);
+                dataLogF("      Found @%u.\n", valueInPredecessor);
 #endif
             }
             ASSERT(m_graph[valueInPredecessor].op() == SetLocal
@@ -3328,48 +3328,48 @@ void ByteCodeParser::processPhiStack()
 
             Node* phiNode = &m_graph[entry.m_phi];
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("      Ref count of @%u = %u.\n", entry.m_phi, phiNode->refCount());
+            dataLogF("      Ref count of @%u = %u.\n", entry.m_phi, phiNode->refCount());
 #endif
             if (phiNode->refCount()) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Reffing @%u.\n", valueInPredecessor);
+                dataLogF("      Reffing @%u.\n", valueInPredecessor);
 #endif
                 m_graph.ref(valueInPredecessor);
             }
 
             if (!phiNode->child1()) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Setting @%u->child1 = @%u.\n", entry.m_phi, valueInPredecessor);
+                dataLogF("      Setting @%u->child1 = @%u.\n", entry.m_phi, valueInPredecessor);
 #endif
                 phiNode->children.setChild1(Edge(valueInPredecessor));
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Children of @%u: ", entry.m_phi);
+                dataLogF("      Children of @%u: ", entry.m_phi);
                 phiNode->dumpChildren(WTF::dataFile());
-                dataLog(".\n");
+                dataLogF(".\n");
 #endif
                 continue;
             }
             if (!phiNode->child2()) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Setting @%u->child2 = @%u.\n", entry.m_phi, valueInPredecessor);
+                dataLogF("      Setting @%u->child2 = @%u.\n", entry.m_phi, valueInPredecessor);
 #endif
                 phiNode->children.setChild2(Edge(valueInPredecessor));
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Children of @%u: ", entry.m_phi);
+                dataLogF("      Children of @%u: ", entry.m_phi);
                 phiNode->dumpChildren(WTF::dataFile());
-                dataLog(".\n");
+                dataLogF(".\n");
 #endif
                 continue;
             }
             if (!phiNode->child3()) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Setting @%u->child3 = @%u.\n", entry.m_phi, valueInPredecessor);
+                dataLogF("      Setting @%u->child3 = @%u.\n", entry.m_phi, valueInPredecessor);
 #endif
                 phiNode->children.setChild3(Edge(valueInPredecessor));
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("      Children of @%u: ", entry.m_phi);
+                dataLogF("      Children of @%u: ", entry.m_phi);
                 phiNode->dumpChildren(WTF::dataFile());
-                dataLog(".\n");
+                dataLogF(".\n");
 #endif
                 continue;
             }
@@ -3377,7 +3377,7 @@ void ByteCodeParser::processPhiStack()
             NodeIndex newPhi = insertPhiNode(OpInfo(dataForPhi), entry.m_block);
             
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("      Splitting @%u, created @%u.\n", entry.m_phi, newPhi);
+            dataLogF("      Splitting @%u, created @%u.\n", entry.m_phi, newPhi);
 #endif
 
             phiNode = &m_graph[entry.m_phi]; // reload after vector resize
@@ -3388,17 +3388,17 @@ void ByteCodeParser::processPhiStack()
             newPhiNode.children = phiNode->children;
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("      Children of @%u: ", newPhi);
+            dataLogF("      Children of @%u: ", newPhi);
             newPhiNode.dumpChildren(WTF::dataFile());
-            dataLog(".\n");
+            dataLogF(".\n");
 #endif
 
             phiNode->children.initialize(newPhi, valueInPredecessor, NoNode);
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("      Children of @%u: ", entry.m_phi);
+            dataLogF("      Children of @%u: ", entry.m_phi);
             phiNode->dumpChildren(WTF::dataFile());
-            dataLog(".\n");
+            dataLogF(".\n");
 #endif
         }
     }
@@ -3425,7 +3425,7 @@ void ByteCodeParser::linkBlock(BasicBlock* block, Vector<BlockIndex>& possibleTa
     case Jump:
         node.setTakenBlockIndex(m_graph.blockIndexForBytecodeOffset(possibleTargets, node.takenBytecodeOffsetDuringParsing()));
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Linked basic block %p to %p, #%u.\n", block, m_graph.m_blocks[node.takenBlockIndex()].get(), node.takenBlockIndex());
+        dataLogF("Linked basic block %p to %p, #%u.\n", block, m_graph.m_blocks[node.takenBlockIndex()].get(), node.takenBlockIndex());
 #endif
         break;
         
@@ -3433,13 +3433,13 @@ void ByteCodeParser::linkBlock(BasicBlock* block, Vector<BlockIndex>& possibleTa
         node.setTakenBlockIndex(m_graph.blockIndexForBytecodeOffset(possibleTargets, node.takenBytecodeOffsetDuringParsing()));
         node.setNotTakenBlockIndex(m_graph.blockIndexForBytecodeOffset(possibleTargets, node.notTakenBytecodeOffsetDuringParsing()));
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Linked basic block %p to %p, #%u and %p, #%u.\n", block, m_graph.m_blocks[node.takenBlockIndex()].get(), node.takenBlockIndex(), m_graph.m_blocks[node.notTakenBlockIndex()].get(), node.notTakenBlockIndex());
+        dataLogF("Linked basic block %p to %p, #%u and %p, #%u.\n", block, m_graph.m_blocks[node.takenBlockIndex()].get(), node.takenBlockIndex(), m_graph.m_blocks[node.notTakenBlockIndex()].get(), node.notTakenBlockIndex());
 #endif
         break;
         
     default:
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Marking basic block %p as linked.\n", block);
+        dataLogF("Marking basic block %p as linked.\n", block);
 #endif
         break;
     }
@@ -3548,9 +3548,9 @@ ByteCodeParser::InlineStackEntry::InlineStackEntry(
         }
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Current captured variables: ");
+        dataLogF("Current captured variables: ");
         inlineCallFrame.capturedVars.dump(WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
 #endif
         
         byteCodeParser->m_codeBlock->inlineCallFrames().append(inlineCallFrame);
@@ -3657,7 +3657,7 @@ void ByteCodeParser::parseCodeBlock()
     CodeBlock* codeBlock = m_inlineStackTop->m_codeBlock;
     
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Parsing code block %p. codeType = %s, captureCount = %u, needsFullScopeChain = %s, needsActivation = %s, isStrictMode = %s\n",
+    dataLogF("Parsing code block %p. codeType = %s, captureCount = %u, needsFullScopeChain = %s, needsActivation = %s, isStrictMode = %s\n",
             codeBlock,
             codeTypeToString(codeBlock->codeType()),
             codeBlock->symbolTable() ? codeBlock->symbolTable()->captureCount() : 0,
@@ -3671,7 +3671,7 @@ void ByteCodeParser::parseCodeBlock()
         // The maximum bytecode offset to go into the current basicblock is either the next jump target, or the end of the instructions.
         unsigned limit = jumpTargetIndex < codeBlock->numberOfJumpTargets() ? codeBlock->jumpTarget(jumpTargetIndex) : codeBlock->instructions().size();
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Parsing bytecode with limit %p bc#%u at inline depth %u.\n", m_inlineStackTop->executable(), limit, CodeOrigin::inlineDepthForCallFrame(m_inlineStackTop->m_inlineCallFrame));
+        dataLogF("Parsing bytecode with limit %p bc#%u at inline depth %u.\n", m_inlineStackTop->executable(), limit, CodeOrigin::inlineDepthForCallFrame(m_inlineStackTop->m_inlineCallFrame));
 #endif
         ASSERT(m_currentIndex < limit);
 
@@ -3693,13 +3693,13 @@ void ByteCodeParser::parseCodeBlock()
                     // Change its bytecode begin and continue.
                     m_currentBlock = m_graph.m_blocks.last().get();
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                    dataLog("Reascribing bytecode index of block %p from bc#%u to bc#%u (peephole case).\n", m_currentBlock, m_currentBlock->bytecodeBegin, m_currentIndex);
+                    dataLogF("Reascribing bytecode index of block %p from bc#%u to bc#%u (peephole case).\n", m_currentBlock, m_currentBlock->bytecodeBegin, m_currentIndex);
 #endif
                     m_currentBlock->bytecodeBegin = m_currentIndex;
                 } else {
                     OwnPtr<BasicBlock> block = adoptPtr(new BasicBlock(m_currentIndex, m_numArguments, m_numLocals));
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                    dataLog("Creating basic block %p, #%zu for %p bc#%u at inline depth %u.\n", block.get(), m_graph.m_blocks.size(), m_inlineStackTop->executable(), m_currentIndex, CodeOrigin::inlineDepthForCallFrame(m_inlineStackTop->m_inlineCallFrame));
+                    dataLogF("Creating basic block %p, #%zu for %p bc#%u at inline depth %u.\n", block.get(), m_graph.m_blocks.size(), m_inlineStackTop->executable(), m_currentIndex, CodeOrigin::inlineDepthForCallFrame(m_inlineStackTop->m_inlineCallFrame));
 #endif
                     m_currentBlock = block.get();
                     ASSERT(m_inlineStackTop->m_unlinkedBlocks.isEmpty() || m_graph.m_blocks[m_inlineStackTop->m_unlinkedBlocks.last().m_blockIndex]->bytecodeBegin < m_currentIndex);
@@ -3756,14 +3756,14 @@ bool ByteCodeParser::parse()
     linkBlocks(inlineStackEntry.m_unlinkedBlocks, inlineStackEntry.m_blockLinkingTargets);
     m_graph.determineReachability();
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-    dataLog("Processing local variable phis.\n");
+    dataLogF("Processing local variable phis.\n");
 #endif
     
     m_currentProfilingIndex = m_currentIndex;
     
     processPhiStack<LocalPhiStack>();
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-    dataLog("Processing argument phis.\n");
+    dataLogF("Processing argument phis.\n");
 #endif
     processPhiStack<ArgumentPhiStack>();
 
index 24ea0b3..1a88066 100644 (file)
@@ -78,47 +78,47 @@ private:
         if (!block->cfaShouldRevisit)
             return;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   Block #%u (bc#%u):\n", blockIndex, block->bytecodeBegin);
+        dataLogF("   Block #%u (bc#%u):\n", blockIndex, block->bytecodeBegin);
 #endif
         m_state.beginBasicBlock(block);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("      head vars: ");
+        dataLogF("      head vars: ");
         dumpOperands(block->valuesAtHead, WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
 #endif
         for (unsigned i = 0; i < block->size(); ++i) {
             NodeIndex nodeIndex = block->at(i);
             if (!m_graph[nodeIndex].shouldGenerate())
                 continue;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("      %s @%u: ", Graph::opName(m_graph[nodeIndex].op()), nodeIndex);
+            dataLogF("      %s @%u: ", Graph::opName(m_graph[nodeIndex].op()), nodeIndex);
             m_state.dump(WTF::dataFile());
-            dataLog("\n");
+            dataLogF("\n");
 #endif
             if (!m_state.execute(i)) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("         Expect OSR exit.\n");
+                dataLogF("         Expect OSR exit.\n");
 #endif
                 break;
             }
         }
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("      tail regs: ");
+        dataLogF("      tail regs: ");
         m_state.dump(WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
 #endif
         m_changed |= m_state.endBasicBlock(AbstractState::MergeToSuccessors);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("      tail vars: ");
+        dataLogF("      tail vars: ");
         dumpOperands(block->valuesAtTail, WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
 #endif
     }
     
     void performForwardCFA()
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("CFA [%u]\n", ++m_count);
+        dataLogF("CFA [%u]\n", ++m_count);
 #endif
         
         for (BlockIndex block = 0; block < m_graph.m_blocks.size(); ++block)
index e3827d8..d9ae4a2 100644 (file)
@@ -66,7 +66,7 @@ public:
                         ASSERT(m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors[0]
                                == blockIndex);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                        dataLog("CFGSimplify: Jump merge on Block #%u to Block #%u.\n",
+                        dataLogF("CFGSimplify: Jump merge on Block #%u to Block #%u.\n",
                                 blockIndex, m_graph.successor(block, 0));
 #endif
                         if (extremeLogging)
@@ -76,14 +76,14 @@ public:
                         break;
                     } else {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                        dataLog("Not jump merging on Block #%u to Block #%u because predecessors = ",
+                        dataLogF("Not jump merging on Block #%u to Block #%u because predecessors = ",
                                 blockIndex, m_graph.successor(block, 0));
                         for (unsigned i = 0; i < m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors.size(); ++i) {
                             if (i)
-                                dataLog(", ");
-                            dataLog("#%u", m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors[i]);
+                                dataLogF(", ");
+                            dataLogF("#%u", m_graph.m_blocks[m_graph.successor(block, 0)]->m_predecessors[i]);
                         }
-                        dataLog(".\n");
+                        dataLogF(".\n");
 #endif
                     }
                 
@@ -105,7 +105,7 @@ public:
                             m_graph.successorForCondition(block, condition)].get();
                         if (targetBlock->m_predecessors.size() == 1) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                            dataLog("CFGSimplify: Known condition (%s) branch merge on Block #%u to Block #%u, jettisoning Block #%u.\n",
+                            dataLogF("CFGSimplify: Known condition (%s) branch merge on Block #%u to Block #%u, jettisoning Block #%u.\n",
                                     condition ? "true" : "false",
                                     blockIndex, m_graph.successorForCondition(block, condition),
                                     m_graph.successorForCondition(block, !condition));
@@ -118,7 +118,7 @@ public:
                                 m_graph.successorForCondition(block, !condition));
                         } else {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                            dataLog("CFGSimplify: Known condition (%s) branch->jump conversion on Block #%u to Block #%u, jettisoning Block #%u.\n",
+                            dataLogF("CFGSimplify: Known condition (%s) branch->jump conversion on Block #%u to Block #%u, jettisoning Block #%u.\n",
                                     condition ? "true" : "false",
                                     blockIndex, m_graph.successorForCondition(block, condition),
                                     m_graph.successorForCondition(block, !condition));
@@ -152,13 +152,13 @@ public:
                         ASSERT(targetBlock->isReachable);
                         if (targetBlock->m_predecessors.size() == 1) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                            dataLog("CFGSimplify: Branch to same successor merge on Block #%u to Block #%u.\n",
+                            dataLogF("CFGSimplify: Branch to same successor merge on Block #%u to Block #%u.\n",
                                     blockIndex, targetBlockIndex);
 #endif
                             mergeBlocks(blockIndex, targetBlockIndex, NoBlock);
                         } else {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                            dataLog("CFGSimplify: Branch->jump conversion to same successor on Block #%u to Block #%u.\n",
+                            dataLogF("CFGSimplify: Branch->jump conversion to same successor on Block #%u to Block #%u.\n",
                                     blockIndex, targetBlockIndex);
 #endif
                             ASSERT(m_graph[block->last()].isTerminal());
@@ -179,7 +179,7 @@ public:
                     }
                     
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                    dataLog("Not branch simplifying on Block #%u because the successors differ and the condition is not known.\n",
+                    dataLogF("Not branch simplifying on Block #%u because the successors differ and the condition is not known.\n",
                             blockIndex);
 #endif
                 
@@ -287,22 +287,22 @@ private:
         if (child.op() != GetLocal)
             return;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("    Considering GetLocal at @%u, local r%d.\n", edge.index(), child.local());
+        dataLogF("    Considering GetLocal at @%u, local r%d.\n", edge.index(), child.local());
 #endif
         if (child.variableAccessData()->isCaptured()) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("        It's captured.\n");
+            dataLogF("        It's captured.\n");
 #endif
             return;
         }
         NodeIndex originalNodeIndex = block->variablesAtTail.operand(child.local());
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("        Dealing with original @%u.\n", originalNodeIndex);
+        dataLogF("        Dealing with original @%u.\n", originalNodeIndex);
 #endif
         ASSERT(originalNodeIndex != NoNode);
         Node* originalNode = &m_graph[originalNodeIndex];
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("        Original has local r%d.\n", originalNode->local());
+        dataLogF("        Original has local r%d.\n", originalNode->local());
 #endif
         ASSERT(child.local() == originalNode->local());
         if (changeRef)
@@ -327,14 +327,14 @@ private:
         switch (originalNode->op()) {
         case SetLocal: {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("        It's a SetLocal.\n");
+            dataLogF("        It's a SetLocal.\n");
 #endif
             m_graph.changeIndex(edge, originalNode->child1().index(), changeRef);
             break;
         }
         case GetLocal: {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("        It's a GetLocal.\n");
+            dataLogF("        It's a GetLocal.\n");
 #endif
             m_graph.changeIndex(edge, originalNodeIndex, changeRef);
             break;
@@ -342,7 +342,7 @@ private:
         case Phi:
         case SetArgument: {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("        It's Phi/SetArgument.\n");
+            dataLogF("        It's Phi/SetArgument.\n");
 #endif
             // Keep the GetLocal!
             break;
@@ -380,7 +380,7 @@ private:
             Node& phiNode = m_graph[phiNodeIndex];
             NodeIndex myNodeIndex = sourceBlock->variablesAtTail.operand(phiNode.local());
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("Considering removing reference from phi @%u to @%u on local r%d:",
+            dataLogF("Considering removing reference from phi @%u to @%u on local r%d:",
                     phiNodeIndex, myNodeIndex, phiNode.local());
 #endif
             if (myNodeIndex == NoNode) {
@@ -394,7 +394,7 @@ private:
             for (unsigned j = 0; j < AdjacencyList::Size; ++j)
                 removePotentiallyDeadPhiReference(myNodeIndex, phiNode, j, sourceBlock->isReachable);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("\n");
+            dataLogF("\n");
 #endif
         }
     }
@@ -402,7 +402,7 @@ private:
     void fixJettisonedPredecessors(BlockIndex blockIndex, BlockIndex jettisonedBlockIndex)
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Fixing predecessors and phis due to jettison of Block #%u from Block #%u.\n",
+        dataLogF("Fixing predecessors and phis due to jettison of Block #%u from Block #%u.\n",
                 jettisonedBlockIndex, blockIndex);
 #endif
         BasicBlock* jettisonedBlock = m_graph.m_blocks[jettisonedBlockIndex].get();
@@ -422,7 +422,7 @@ private:
         if (phiNode.children.child(edgeIndex).indexUnchecked() != myNodeIndex)
             return;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog(" Removing reference at child %u.", edgeIndex);
+        dataLogF(" Removing reference at child %u.", edgeIndex);
 #endif
         if (changeRef && phiNode.shouldGenerate())
             m_graph.deref(myNodeIndex);
@@ -710,7 +710,7 @@ private:
                 bool changeRef = phiNode.shouldGenerate();
                 OperandSubstitution substitution = substitutions.operand(phiNode.local());
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog("    Performing operand substitution @%u -> @%u.\n",
+                dataLogF("    Performing operand substitution @%u -> @%u.\n",
                         substitution.oldChild, substitution.newChild);
 #endif
                 if (!phiNode.child1())
index 04bcf19..36acb2c 100644 (file)
@@ -79,7 +79,7 @@ private:
             result++;
         ASSERT(result <= m_indexInBlock);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("  limit %u: ", result);
+        dataLogF("  limit %u: ", result);
 #endif
         return result;
     }
@@ -970,7 +970,7 @@ private:
             return false;
         
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   Replacing @%u -> @%u", m_compileIndex, replacement);
+        dataLogF("   Replacing @%u -> @%u", m_compileIndex, replacement);
 #endif
         
         Node& node = m_graph[m_compileIndex];
@@ -988,7 +988,7 @@ private:
     void eliminate()
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   Eliminating @%u", m_compileIndex);
+        dataLogF("   Eliminating @%u", m_compileIndex);
 #endif
         
         Node& node = m_graph[m_compileIndex];
@@ -1029,7 +1029,7 @@ private:
             return;
         
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   %s @%u: ", Graph::opName(m_graph[m_compileIndex].op()), m_compileIndex);
+        dataLogF("   %s @%u: ", Graph::opName(m_graph[m_compileIndex].op()), m_compileIndex);
 #endif
         
         // NOTE: there are some nodes that we deliberately don't CSE even though we
@@ -1317,7 +1317,7 @@ private:
         
         m_lastSeen[node.op()] = m_indexInBlock;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("\n");
+        dataLogF("\n");
 #endif
     }
     
index 910c3d9..8697513 100644 (file)
@@ -38,7 +38,7 @@ static inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, bool resul
 {
     ASSERT_UNUSED(result, !result);
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
+    dataLogF("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
 #else
     UNUSED_PARAM(codeBlock);
     UNUSED_PARAM(opcodeID);
@@ -51,10 +51,10 @@ static inline void debugFail(CodeBlock* codeBlock, OpcodeID opcodeID, Capability
     ASSERT(result != CanCompile);
 #if DFG_ENABLE(DEBUG_VERBOSE)
     if (result == CannotCompile)
-        dataLog("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
+        dataLogF("Cannot handle code block %p because of opcode %s.\n", codeBlock, opcodeNames[opcodeID]);
     else {
         ASSERT(result == ShouldProfile);
-        dataLog("Cannot compile code block %p because of opcode %s, but inlining might be possible.\n", codeBlock, opcodeNames[opcodeID]);
+        dataLogF("Cannot compile code block %p because of opcode %s, but inlining might be possible.\n", codeBlock, opcodeNames[opcodeID]);
     }
 #else
     UNUSED_PARAM(codeBlock);
index 4a7cad5..2221954 100644 (file)
@@ -67,7 +67,7 @@ private:
     bool foldConstants(BlockIndex blockIndex)
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Constant folding considering Block #%u.\n", blockIndex);
+        dataLogF("Constant folding considering Block #%u.\n", blockIndex);
 #endif
         BasicBlock* block = m_graph.m_blocks[blockIndex].get();
         bool changed = false;
@@ -454,7 +454,7 @@ private:
         bool changed = false;
         
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Painting unreachable code in Block #%u.\n", blockIndex);
+        dataLogF("Painting unreachable code in Block #%u.\n", blockIndex);
 #endif
         BasicBlock* block = m_graph.m_blocks[blockIndex].get();
         m_state.beginBasicBlock(block);
index 9829c19..6548241 100644 (file)
@@ -43,8 +43,8 @@ void Disassembler::dump(LinkBuffer& linkBuffer)
 {
     m_graph.m_dominators.computeIfNecessary(m_graph);
     
-    dataLog("Generated JIT code for DFG CodeBlock %p, instruction count = %u:\n", m_graph.m_codeBlock, m_graph.m_codeBlock->instructionCount());
-    dataLog("    Code at [%p, %p):\n", linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize());
+    dataLogF("Generated JIT code for DFG CodeBlock %p, instruction count = %u:\n", m_graph.m_codeBlock, m_graph.m_codeBlock->instructionCount());
+    dataLogF("    Code at [%p, %p):\n", linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize());
     
     const char* prefix = "    ";
     const char* disassemblyPrefix = "        ";
@@ -82,7 +82,7 @@ void Disassembler::dump(LinkBuffer& linkBuffer)
         }
     }
     dumpDisassembly(disassemblyPrefix, linkBuffer, previousLabel, m_endOfMainPath, lastNodeIndex);
-    dataLog("%s(End Of Main Path)\n", prefix);
+    dataLogF("%s(End Of Main Path)\n", prefix);
     dumpDisassembly(disassemblyPrefix, linkBuffer, previousLabel, m_endOfCode, NoNode);
 }
 
index eb68fa3..8645c6d 100644 (file)
@@ -72,7 +72,7 @@ inline bool compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlo
         return false;
     
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("DFG compiling code block %p(%p) for executable %p, number of instructions = %u.\n", codeBlock, codeBlock->alternative(), codeBlock->ownerExecutable(), codeBlock->instructionCount());
+    dataLogF("DFG compiling code block %p(%p) for executable %p, number of instructions = %u.\n", codeBlock, codeBlock->alternative(), codeBlock->ownerExecutable(), codeBlock->instructionCount());
 #endif
     
     // Derive our set of must-handle values. The compilation must be at least conservative
@@ -119,7 +119,7 @@ inline bool compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlo
     dfg.m_fixpointState = FixpointNotConverged;
     for (;; ++cnt) {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("DFG beginning optimization fixpoint iteration #%u.\n", cnt);
+        dataLogF("DFG beginning optimization fixpoint iteration #%u.\n", cnt);
 #endif
         bool changed = false;
         performCFA(dfg);
@@ -135,13 +135,13 @@ inline bool compile(CompileMode compileMode, ExecState* exec, CodeBlock* codeBlo
     dfg.m_fixpointState = FixpointConverged;
     performCSE(dfg);
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("DFG optimization fixpoint converged in %u iterations.\n", cnt);
+    dataLogF("DFG optimization fixpoint converged in %u iterations.\n", cnt);
 #endif
     performVirtualRegisterAllocation(dfg);
 
     GraphDumpMode modeForFinalValidate = DumpGraph;
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Graph after optimization:\n");
+    dataLogF("Graph after optimization:\n");
     dfg.dump();
     modeForFinalValidate = DontDumpGraph;
 #endif
index 7d38ab2..1ba40de 100644 (file)
@@ -69,7 +69,7 @@ private:
         NodeType op = node.op();
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   %s @%u: ", Graph::opName(op), m_compileIndex);
+        dataLogF("   %s @%u: ", Graph::opName(op), m_compileIndex);
 #endif
         
         switch (op) {
@@ -412,10 +412,10 @@ private:
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
         if (!(node.flags() & NodeHasVarArgs)) {
-            dataLog("new children: ");
+            dataLogF("new children: ");
             node.dumpChildren(WTF::dataFile());
         }
-        dataLog("\n");
+        dataLogF("\n");
 #endif
     }
     
@@ -548,7 +548,7 @@ private:
         NodeIndex resultIndex = (NodeIndex)m_graph.size();
         
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("(replacing @%u->@%u with @%u->@%u) ",
+        dataLogF("(replacing @%u->@%u with @%u->@%u) ",
                 m_compileIndex, edge.index(), m_compileIndex, resultIndex);
 #endif
         
index ecbdf83..19587ba 100644 (file)
@@ -98,7 +98,7 @@ const char* Graph::nameOfVariableAccessData(VariableAccessData* variableAccessDa
 static void printWhiteSpace(unsigned amount)
 {
     while (amount-- > 0)
-        dataLog(" ");
+        dataLogF(" ");
 }
 
 void Graph::dumpCodeOrigin(const char* prefix, NodeIndex prevNodeIndex, NodeIndex nodeIndex)
@@ -124,16 +124,16 @@ void Graph::dumpCodeOrigin(const char* prefix, NodeIndex prevNodeIndex, NodeInde
     
     // Print the pops.
     for (unsigned i = previousInlineStack.size(); i-- > indexOfDivergence;) {
-        dataLog("%s", prefix);
+        dataLogF("%s", prefix);
         printWhiteSpace(i * 2);
-        dataLog("<-- %p\n", previousInlineStack[i].inlineCallFrame->executable.get());
+        dataLogF("<-- %p\n", previousInlineStack[i].inlineCallFrame->executable.get());
     }
     
     // Print the pushes.
     for (unsigned i = indexOfDivergence; i < currentInlineStack.size(); ++i) {
-        dataLog("%s", prefix);
+        dataLogF("%s", prefix);
         printWhiteSpace(i * 2);
-        dataLog("--> %p\n", currentInlineStack[i].inlineCallFrame->executable.get());
+        dataLogF("--> %p\n", currentInlineStack[i].inlineCallFrame->executable.get());
     }
 }
 
@@ -158,7 +158,7 @@ void Graph::dump(const char* prefix, NodeIndex nodeIndex)
     if (mustGenerate)
         --refCount;
     
-    dataLog("%s", prefix);
+    dataLogF("%s", prefix);
     printNodeWhiteSpace(node);
 
     // Example/explanation of dataflow dump output
@@ -178,22 +178,22 @@ void Graph::dump(const char* prefix, NodeIndex nodeIndex)
     //         $#   - the index in the CodeBlock of a constant { for numeric constants the value is displayed | for integers, in both decimal and hex }.
     //         id#  - the index in the CodeBlock of an identifier { if codeBlock is passed to dump(), the string representation is displayed }.
     //         var# - the index of a var on the global object, used by GetGlobalVar/PutGlobalVar operations.
-    dataLog("% 4d:%s<%c%u:", (int)nodeIndex, skipped ? "  skipped  " : "           ", mustGenerate ? '!' : ' ', refCount);
+    dataLogF("% 4d:%s<%c%u:", (int)nodeIndex, skipped ? "  skipped  " : "           ", mustGenerate ? '!' : ' ', refCount);
     if (node.hasResult() && !skipped && node.hasVirtualRegister())
-        dataLog("%u", node.virtualRegister());
+        dataLogF("%u", node.virtualRegister());
     else
-        dataLog("-");
-    dataLog(">\t%s(", opName(op));
+        dataLogF("-");
+    dataLogF(">\t%s(", opName(op));
     bool hasPrinted = false;
     if (node.flags() & NodeHasVarArgs) {
         for (unsigned childIdx = node.firstChild(); childIdx < node.firstChild() + node.numChildren(); childIdx++) {
             if (hasPrinted)
-                dataLog(", ");
+                dataLogF(", ");
             else
                 hasPrinted = true;
             if (!m_varArgChildren[childIdx])
                 continue;
-            dataLog("%s@%u%s",
+            dataLogF("%s@%u%s",
                     useKindToString(m_varArgChildren[childIdx].useKind()),
                     m_varArgChildren[childIdx].index(),
                     speculationToAbbreviatedString(
@@ -201,19 +201,19 @@ void Graph::dump(const char* prefix, NodeIndex nodeIndex)
         }
     } else {
         if (!!node.child1()) {
-            dataLog("%s@%u%s",
+            dataLogF("%s@%u%s",
                     useKindToString(node.child1().useKind()),
                     node.child1().index(),
                     speculationToAbbreviatedString(at(node.child1()).prediction()));
         }
         if (!!node.child2()) {
-            dataLog(", %s@%u%s",
+            dataLogF(", %s@%u%s",
                     useKindToString(node.child2().useKind()),
                     node.child2().index(),
                     speculationToAbbreviatedString(at(node.child2()).prediction()));
         }
         if (!!node.child3()) {
-            dataLog(", %s@%u%s",
+            dataLogF(", %s@%u%s",
                     useKindToString(node.child3().useKind()),
                     node.child3().index(),
                     speculationToAbbreviatedString(at(node.child3()).prediction()));
@@ -222,51 +222,51 @@ void Graph::dump(const char* prefix, NodeIndex nodeIndex)
     }
 
     if (strlen(nodeFlagsAsString(node.flags()))) {
-        dataLog("%s%s", hasPrinted ? ", " : "", nodeFlagsAsString(node.flags()));
+        dataLogF("%s%s", hasPrinted ? ", " : "", nodeFlagsAsString(node.flags()));
         hasPrinted = true;
     }
     if (node.hasArrayMode()) {
-        dataLog("%s%s", hasPrinted ? ", " : "", node.arrayMode().toString());
+        dataLogF("%s%s", hasPrinted ? ", " : "", node.arrayMode().toString());
         hasPrinted = true;
     }
     if (node.hasVarNumber()) {
-        dataLog("%svar%u", hasPrinted ? ", " : "", node.varNumber());
+        dataLogF("%svar%u", hasPrinted ? ", " : "", node.varNumber());
         hasPrinted = true;
     }
     if (node.hasRegisterPointer()) {
-        dataLog(
+        dataLogF(
             "%sglobal%u(%p)", hasPrinted ? ", " : "",
             globalObjectFor(node.codeOrigin)->findRegisterIndex(node.registerPointer()),
             node.registerPointer());
         hasPrinted = true;
     }
     if (node.hasIdentifier()) {
-        dataLog("%sid%u{%s}", hasPrinted ? ", " : "", node.identifierNumber(), m_codeBlock->identifier(node.identifierNumber()).string().utf8().data());
+        dataLogF("%sid%u{%s}", hasPrinted ? ", " : "", node.identifierNumber(), m_codeBlock->identifier(node.identifierNumber()).string().utf8().data());
         hasPrinted = true;
     }
     if (node.hasStructureSet()) {
         for (size_t i = 0; i < node.structureSet().size(); ++i) {
-            dataLog("%sstruct(%p: %s)", hasPrinted ? ", " : "", node.structureSet()[i], indexingTypeToString(node.structureSet()[i]->indexingType()));
+            dataLogF("%sstruct(%p: %s)", hasPrinted ? ", " : "", node.structureSet()[i], indexingTypeToString(node.structureSet()[i]->indexingType()));
             hasPrinted = true;
         }
     }
     if (node.hasStructure()) {
-        dataLog("%sstruct(%p: %s)", hasPrinted ? ", " : "", node.structure(), indexingTypeToString(node.structure()->indexingType()));
+        dataLogF("%sstruct(%p: %s)", hasPrinted ? ", " : "", node.structure(), indexingTypeToString(node.structure()->indexingType()));
         hasPrinted = true;
     }
     if (node.hasStructureTransitionData()) {
-        dataLog("%sstruct(%p -> %p)", hasPrinted ? ", " : "", node.structureTransitionData().previousStructure, node.structureTransitionData().newStructure);
+        dataLogF("%sstruct(%p -> %p)", hasPrinted ? ", " : "", node.structureTransitionData().previousStructure, node.structureTransitionData().newStructure);
         hasPrinted = true;
     }
     if (node.hasFunction()) {
-        dataLog("%s%p", hasPrinted ? ", " : "", node.function());
+        dataLogF("%s%p", hasPrinted ? ", " : "", node.function());
         hasPrinted = true;
     }
     if (node.hasStorageAccessData()) {
         StorageAccessData& storageAccessData = m_storageAccessData[node.storageAccessDataIndex()];
-        dataLog("%sid%u{%s}", hasPrinted ? ", " : "", storageAccessData.identifierNumber, m_codeBlock->identifier(storageAccessData.identifierNumber).string().utf8().data());
+        dataLogF("%sid%u{%s}", hasPrinted ? ", " : "", storageAccessData.identifierNumber, m_codeBlock->identifier(storageAccessData.identifierNumber).string().utf8().data());
         
-        dataLog(", %lu", static_cast<unsigned long>(storageAccessData.offset));
+        dataLogF(", %lu", static_cast<unsigned long>(storageAccessData.offset));
         hasPrinted = true;
     }
     ASSERT(node.hasVariableAccessData() == node.hasLocal());
@@ -274,105 +274,105 @@ void Graph::dump(const char* prefix, NodeIndex nodeIndex)
         VariableAccessData* variableAccessData = node.variableAccessData();
         int operand = variableAccessData->operand();
         if (operandIsArgument(operand))
-            dataLog("%sarg%u(%s)", hasPrinted ? ", " : "", operandToArgument(operand), nameOfVariableAccessData(variableAccessData));
+            dataLogF("%sarg%u(%s)", hasPrinted ? ", " : "", operandToArgument(operand), nameOfVariableAccessData(variableAccessData));
         else
-            dataLog("%sr%u(%s)", hasPrinted ? ", " : "", operand, nameOfVariableAccessData(variableAccessData));
+            dataLogF("%sr%u(%s)", hasPrinted ? ", " : "", operand, nameOfVariableAccessData(variableAccessData));
         hasPrinted = true;
     }
     if (node.hasConstantBuffer()) {
         if (hasPrinted)
-            dataLog(", ");
-        dataLog("%u:[", node.startConstant());
+            dataLogF(", ");
+        dataLogF("%u:[", node.startConstant());
         for (unsigned i = 0; i < node.numConstants(); ++i) {
             if (i)
-                dataLog(", ");
-            dataLog("%s", m_codeBlock->constantBuffer(node.startConstant())[i].description());
+                dataLogF(", ");
+            dataLogF("%s", m_codeBlock->constantBuffer(node.startConstant())[i].description());
         }
-        dataLog("]");
+        dataLogF("]");
         hasPrinted = true;
     }
     if (node.hasIndexingType()) {
         if (hasPrinted)
-            dataLog(", ");
-        dataLog("%s", indexingTypeToString(node.indexingType()));
+            dataLogF(", ");
+        dataLogF("%s", indexingTypeToString(node.indexingType()));
     }
     if (op == JSConstant) {
-        dataLog("%s$%u", hasPrinted ? ", " : "", node.constantNumber());
+        dataLogF("%s$%u", hasPrinted ? ", " : "", node.constantNumber());
         JSValue value = valueOfJSConstant(nodeIndex);
-        dataLog(" = %s", value.description());
+        dataLogF(" = %s", value.description());
         hasPrinted = true;
     }
     if (op == WeakJSConstant) {
-        dataLog("%s%p", hasPrinted ? ", " : "", node.weakConstant());
+        dataLogF("%s%p", hasPrinted ? ", " : "", node.weakConstant());
         hasPrinted = true;
     }
     if  (node.isBranch() || node.isJump()) {
-        dataLog("%sT:#%u", hasPrinted ? ", " : "", node.takenBlockIndex());
+        dataLogF("%sT:#%u", hasPrinted ? ", " : "", node.takenBlockIndex());
         hasPrinted = true;
     }
     if  (node.isBranch()) {
-        dataLog("%sF:#%u", hasPrinted ? ", " : "", node.notTakenBlockIndex());
+        dataLogF("%sF:#%u", hasPrinted ? ", " : "", node.notTakenBlockIndex());
         hasPrinted = true;
     }
-    dataLog("%sbc#%u", hasPrinted ? ", " : "", node.codeOrigin.bytecodeIndex);
+    dataLogF("%sbc#%u", hasPrinted ? ", " : "", node.codeOrigin.bytecodeIndex);
     hasPrinted = true;
     (void)hasPrinted;
     
-    dataLog(")");
+    dataLogF(")");
 
     if (!skipped) {
         if (node.hasVariableAccessData())
-            dataLog("  predicting %s%s", speculationToString(node.variableAccessData()->prediction()), node.variableAccessData()->shouldUseDoubleFormat() ? ", forcing double" : "");
+            dataLogF("  predicting %s%s", speculationToString(node.variableAccessData()->prediction()), node.variableAccessData()->shouldUseDoubleFormat() ? ", forcing double" : "");
         else if (node.hasHeapPrediction())
-            dataLog("  predicting %s", speculationToString(node.getHeapPrediction()));
+            dataLogF("  predicting %s", speculationToString(node.getHeapPrediction()));
     }
     
-    dataLog("\n");
+    dataLogF("\n");
 }
 
 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);
+    dataLogF("%sBlock #%u (bc#%u): %s%s\n", prefix, (int)blockIndex, block->bytecodeBegin, block->isReachable ? "" : " (skipped)", block->isOSRTarget ? " (OSR target)" : "");
+    dataLogF("%s  Predecessors:", prefix);
     for (size_t i = 0; i < block->m_predecessors.size(); ++i)
-        dataLog(" #%u", block->m_predecessors[i]);
-    dataLog("\n");
+        dataLogF(" #%u", block->m_predecessors[i]);
+    dataLogF("\n");
     if (m_dominators.isValid()) {
-        dataLog("%s  Dominated by:", prefix);
+        dataLogF("%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));
+            dataLogF(" #%lu", static_cast<unsigned long>(i));
         }
-        dataLog("\n");
-        dataLog("%s  Dominates:", prefix);
+        dataLogF("\n");
+        dataLogF("%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));
+            dataLogF(" #%lu", static_cast<unsigned long>(i));
         }
-        dataLog("\n");
+        dataLogF("\n");
     }
-    dataLog("%s  Phi Nodes:", prefix);
+    dataLogF("%s  Phi Nodes:", prefix);
     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;
-        dataLog(" @%u->(", phiNodeIndex);
+        dataLogF(" @%u->(", phiNodeIndex);
         if (phiNode.child1()) {
-            dataLog("@%u", phiNode.child1().index());
+            dataLogF("@%u", phiNode.child1().index());
             if (phiNode.child2()) {
-                dataLog(", @%u", phiNode.child2().index());
+                dataLogF(", @%u", phiNode.child2().index());
                 if (phiNode.child3())
-                    dataLog(", @%u", phiNode.child3().index());
+                    dataLogF(", @%u", phiNode.child3().index());
             }
         }
-        dataLog(")%s", i + 1 < block->phis.size() ? "," : "");
+        dataLogF(")%s", i + 1 < block->phis.size() ? "," : "");
     }
-    dataLog("\n");
+    dataLogF("\n");
 }
 
 void Graph::dump()
@@ -383,29 +383,29 @@ void Graph::dump()
         if (!block)
             continue;
         dumpBlockHeader("", b, DumpAllPhis);
-        dataLog("  vars before: ");
+        dataLogF("  vars before: ");
         if (block->cfaHasVisited)
             dumpOperands(block->valuesAtHead, WTF::dataFile());
         else
-            dataLog("<empty>");
-        dataLog("\n");
-        dataLog("  var links: ");
+            dataLogF("<empty>");
+        dataLogF("\n");
+        dataLogF("  var links: ");
         dumpOperands(block->variablesAtHead, WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
         for (size_t i = 0; i < block->size(); ++i) {
             dumpCodeOrigin("", lastNodeIndex, block->at(i));
             dump("", block->at(i));
             lastNodeIndex = block->at(i);
         }
-        dataLog("  vars after: ");
+        dataLogF("  vars after: ");
         if (block->cfaHasVisited)
             dumpOperands(block->valuesAtTail, WTF::dataFile());
         else
-            dataLog("<empty>");
-        dataLog("\n");
-        dataLog("  var links: ");
+            dataLogF("<empty>");
+        dataLogF("\n");
+        dataLogF("  var links: ");
         dumpOperands(block->variablesAtTail, WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
     }
 }
 
@@ -460,7 +460,7 @@ void Graph::predictArgumentTypes()
         at(m_arguments[arg]).variableAccessData()->predict(profile->computeUpdatedPrediction());
         
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Argument [%zu] prediction: %s\n", arg, speculationToString(at(m_arguments[arg]).variableAccessData()->prediction()));
+        dataLogF("Argument [%zu] prediction: %s\n", arg, speculationToString(at(m_arguments[arg]).variableAccessData()->prediction()));
 #endif
     }
 }
index 537aafa..191aa7f 100644 (file)
@@ -128,7 +128,7 @@ void JITCompiler::link(LinkBuffer& linkBuffer)
 {
     // Link the code, populate data in CodeBlock data structures.
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("JIT code for %p start at [%p, %p). Size = %zu.\n", m_codeBlock, linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize(), linkBuffer.debugSize());
+    dataLogF("JIT code for %p start at [%p, %p). Size = %zu.\n", m_codeBlock, linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize(), linkBuffer.debugSize());
 #endif
 
     // Link all calls out from the JIT code to their respective functions.
index b838c4f..ed13ed5 100644 (file)
@@ -44,7 +44,7 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     ASSERT(!codeBlock->jitCodeMap());
 
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("OSR in %p(%p) from bc#%u\n", codeBlock, codeBlock->alternative(), bytecodeIndex);
+    dataLogF("OSR in %p(%p) from bc#%u\n", codeBlock, codeBlock->alternative(), bytecodeIndex);
 #endif
     
     JSGlobalData* globalData = &exec->globalData();
@@ -52,7 +52,7 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     
     if (!entry) {
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("    OSR failed because the entrypoint was optimized out.\n");
+        dataLogF("    OSR failed because the entrypoint was optimized out.\n");
 #endif
         return 0;
     }
@@ -86,9 +86,9 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     for (size_t argument = 0; argument < entry->m_expectedValues.numberOfArguments(); ++argument) {
         if (argument >= exec->argumentCountIncludingThis()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("    OSR failed because argument %zu was not passed, expected ", argument);
+            dataLogF("    OSR failed because argument %zu was not passed, expected ", argument);
             entry->m_expectedValues.argument(argument).dump(WTF::dataFile());
-            dataLog(".\n");
+            dataLogF(".\n");
 #endif
             return 0;
         }
@@ -101,9 +101,9 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
         
         if (!entry->m_expectedValues.argument(argument).validate(value)) {
 #if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("    OSR failed because argument %zu is %s, expected ", argument, value.description());
+            dataLogF("    OSR failed because argument %zu is %s, expected ", argument, value.description());
             entry->m_expectedValues.argument(argument).dump(WTF::dataFile());
-            dataLog(".\n");
+            dataLogF(".\n");
 #endif
             return 0;
         }
@@ -113,7 +113,7 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
         if (entry->m_localsForcedDouble.get(local)) {
             if (!exec->registers()[local].jsValue().isNumber()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-                dataLog("    OSR failed because variable %zu is %s, expected number.\n", local, exec->registers()[local].jsValue().description());
+                dataLogF("    OSR failed because variable %zu is %s, expected number.\n", local, exec->registers()[local].jsValue().description());
 #endif
                 return 0;
             }
@@ -121,9 +121,9 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
         }
         if (!entry->m_expectedValues.local(local).validate(exec->registers()[local].jsValue())) {
 #if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("    OSR failed because variable %zu is %s, expected ", local, exec->registers()[local].jsValue().description());
+            dataLogF("    OSR failed because variable %zu is %s, expected ", local, exec->registers()[local].jsValue().description());
             entry->m_expectedValues.local(local).dump(WTF::dataFile());
-            dataLog(".\n");
+            dataLogF(".\n");
 #endif
             return 0;
         }
@@ -138,13 +138,13 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     
     if (!globalData->interpreter->stack().grow(&exec->registers()[codeBlock->m_numCalleeRegisters])) {
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("    OSR failed because stack growth failed.\n");
+        dataLogF("    OSR failed because stack growth failed.\n");
 #endif
         return 0;
     }
     
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("    OSR should succeed.\n");
+    dataLogF("    OSR should succeed.\n");
 #endif
     
     // 3) Perform data format conversions.
@@ -162,7 +162,7 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
     void* result = codeBlock->getJITCode().executableAddressAtOffset(entry->m_machineCodeOffset);
     
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("    OSR returning machine code address %p.\n", result);
+    dataLogF("    OSR returning machine code address %p.\n", result);
 #endif
     
     return result;
index 2ce1c88..c65443e 100644 (file)
@@ -81,7 +81,7 @@ void compileOSRExit(ExecState* exec)
         recovery = &codeBlock->speculationRecovery(exit.m_recoveryIndex - 1);
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Generating OSR exit #%u (seq#%u, bc#%u, @%u, %s) for code block %p.\n", exitIndex, exit.m_streamIndex, exit.m_codeOrigin.bytecodeIndex, exit.m_nodeIndex, exitKindToString(exit.m_kind), codeBlock);
+    dataLogF("Generating OSR exit #%u (seq#%u, bc#%u, @%u, %s) for code block %p.\n", exitIndex, exit.m_streamIndex, exit.m_codeOrigin.bytecodeIndex, exit.m_nodeIndex, exitKindToString(exit.m_kind), codeBlock);
 #endif
 
     {
index df4f3c9..732e67c 100644 (file)
@@ -37,14 +37,14 @@ void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecov
 {
     // 1) Pro-forma stuff.
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("OSR exit for Node @%d (", (int)exit.m_nodeIndex);
+    dataLogF("OSR exit for Node @%d (", (int)exit.m_nodeIndex);
     for (CodeOrigin codeOrigin = exit.m_codeOrigin; ; codeOrigin = codeOrigin.inlineCallFrame->caller) {
-        dataLog("bc#%u", codeOrigin.bytecodeIndex);
+        dataLogF("bc#%u", codeOrigin.bytecodeIndex);
         if (!codeOrigin.inlineCallFrame)
             break;
-        dataLog(" -> %p ", codeOrigin.inlineCallFrame->executable.get());
+        dataLogF(" -> %p ", codeOrigin.inlineCallFrame->executable.get());
     }
-    dataLog(") at JIT offset 0x%x  ", m_jit.debugOffset());
+    dataLogF(") at JIT offset 0x%x  ", m_jit.debugOffset());
     dumpOperands(operands, WTF::dataFile());
 #endif
 #if DFG_ENABLE(VERBOSE_SPECULATION_FAILURE)
@@ -762,7 +762,7 @@ void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecov
     m_jit.jump(GPRInfo::regT2);
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("   -> %p\n", jumpTarget);
+    dataLogF("   -> %p\n", jumpTarget);
 #endif
 }
 
index b278997..b83c0b3 100644 (file)
@@ -37,14 +37,14 @@ void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecov
 {
     // 1) Pro-forma stuff.
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("OSR exit for Node @%d (", (int)exit.m_nodeIndex);
+    dataLogF("OSR exit for Node @%d (", (int)exit.m_nodeIndex);
     for (CodeOrigin codeOrigin = exit.m_codeOrigin; ; codeOrigin = codeOrigin.inlineCallFrame->caller) {
-        dataLog("bc#%u", codeOrigin.bytecodeIndex);
+        dataLogF("bc#%u", codeOrigin.bytecodeIndex);
         if (!codeOrigin.inlineCallFrame)
             break;
-        dataLog(" -> %p ", codeOrigin.inlineCallFrame->executable.get());
+        dataLogF(" -> %p ", codeOrigin.inlineCallFrame->executable.get());
     }
-    dataLog(")  ");
+    dataLogF(")  ");
     dumpOperands(operands, WTF::dataFile());
 #endif
 #if DFG_ENABLE(VERBOSE_SPECULATION_FAILURE)
@@ -138,7 +138,7 @@ void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecov
             EncodedJSValue* bucket = exit.m_valueProfile.getSpecFailBucket(0);
             
 #if DFG_ENABLE(VERBOSE_SPECULATION_FAILURE)
-            dataLog("  (have exit profile, bucket %p)  ", bucket);
+            dataLogF("  (have exit profile, bucket %p)  ", bucket);
 #endif
             
             if (exit.m_jsValueSource.isAddress()) {
@@ -243,24 +243,24 @@ void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecov
     }
     
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("  ");
+    dataLogF("  ");
     if (numberOfPoisonedVirtualRegisters)
-        dataLog("Poisoned=%u ", numberOfPoisonedVirtualRegisters);
+        dataLogF("Poisoned=%u ", numberOfPoisonedVirtualRegisters);
     if (numberOfDisplacedVirtualRegisters)
-        dataLog("Displaced=%u ", numberOfDisplacedVirtualRegisters);
+        dataLogF("Displaced=%u ", numberOfDisplacedVirtualRegisters);
     if (haveUnboxedInt32s)
-        dataLog("UnboxedInt32 ");
+        dataLogF("UnboxedInt32 ");
     if (haveUnboxedDoubles)
-        dataLog("UnboxedDoubles ");
+        dataLogF("UnboxedDoubles ");
     if (haveUInt32s)
-        dataLog("UInt32 ");
+        dataLogF("UInt32 ");
     if (haveFPRs)
-        dataLog("FPR ");
+        dataLogF("FPR ");
     if (haveConstants)
-        dataLog("Constants ");
+        dataLogF("Constants ");
     if (haveUndefined)
-        dataLog("Undefined ");
-    dataLog(" ");
+        dataLogF("Undefined ");
+    dataLogF(" ");
 #endif
     
     ScratchBuffer* scratchBuffer = m_jit.globalData()->scratchBufferForSize(sizeof(EncodedJSValue) * std::max(haveUInt32s ? 2u : 0u, numberOfPoisonedVirtualRegisters + (numberOfDisplacedVirtualRegisters <= GPRInfo::numberOfRegisters ? 0 : numberOfDisplacedVirtualRegisters)));
@@ -710,7 +710,7 @@ void OSRExitCompiler::compileExit(const OSRExit& exit, const Operands<ValueRecov
     m_jit.jump(GPRInfo::regT1);
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("-> %p\n", jumpTarget);
+    dataLogF("-> %p\n", jumpTarget);
 #endif
 }
 
index bc0074f..909c657 100644 (file)
@@ -1522,7 +1522,7 @@ void DFG_OPERATION debugOperationPrintSpeculationFailure(ExecState* exec, void*
     SpeculationFailureDebugInfo* debugInfo = static_cast<SpeculationFailureDebugInfo*>(debugInfoRaw);
     CodeBlock* codeBlock = debugInfo->codeBlock;
     CodeBlock* alternative = codeBlock->alternative();
-    dataLog("Speculation failure in %p at @%u with executeCounter = %s, "
+    dataLogF("Speculation failure in %p at @%u with executeCounter = %s, "
             "reoptimizationRetryCounter = %u, optimizationDelayCounter = %u, "
             "osrExitCounter = %u\n",
             codeBlock,
@@ -1537,7 +1537,7 @@ void DFG_OPERATION debugOperationPrintSpeculationFailure(ExecState* exec, void*
 extern "C" void DFG_OPERATION triggerReoptimizationNow(CodeBlock* codeBlock)
 {
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("%p: Entered reoptimize\n", codeBlock);
+    dataLogF("%p: Entered reoptimize\n", codeBlock);
 #endif
     // We must be called with the baseline code block.
     ASSERT(JITCode::isBaselineCode(codeBlock->getJITType()));
index f97c49e..20301e8 100644 (file)
@@ -35,8 +35,8 @@ namespace JSC { namespace DFG {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
 void Phase::beginPhase()
 {
-    dataLog("Beginning DFG phase %s.\n", m_name);
-    dataLog("Graph before %s:\n", m_name);
+    dataLogF("Beginning DFG phase %s.\n", m_name);
+    dataLogF("Graph before %s:\n", m_name);
     m_graph.dump();
 }
 #endif
index a73d26b..939e199 100644 (file)
@@ -83,7 +83,7 @@ bool runAndLog(PhaseType& phase)
     bool result = phase.run();
 #if DFG_ENABLE(DEBUG_VERBOSE)
     if (result)
-        dataLog("Phase %s changed the IR.\n", phase.name());
+        dataLogF("Phase %s changed the IR.\n", phase.name());
 #endif
     return result;
 }
index 9a6dc0f..4b8a172 100644 (file)
@@ -186,7 +186,7 @@ private:
         NodeFlags flags = node.flags() & NodeBackPropMask;
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("   %s @%u: %s ", Graph::opName(op), m_compileIndex, nodeFlagsAsString(flags));
+        dataLogF("   %s @%u: %s ", Graph::opName(op), m_compileIndex, nodeFlagsAsString(flags));
 #endif
         
         bool changed = false;
@@ -782,7 +782,7 @@ private:
         }
 
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("%s\n", speculationToString(m_graph[m_compileIndex].prediction()));
+        dataLogF("%s\n", speculationToString(m_graph[m_compileIndex].prediction()));
 #endif
         
         m_changed |= changed;
@@ -815,7 +815,7 @@ private:
     void propagateForward()
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Propagating predictions forward [%u]\n", ++m_count);
+        dataLogF("Propagating predictions forward [%u]\n", ++m_count);
 #endif
         for (m_compileIndex = 0; m_compileIndex < m_graph.size(); ++m_compileIndex)
             propagate(m_graph[m_compileIndex]);
@@ -824,7 +824,7 @@ private:
     void propagateBackward()
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Propagating predictions backward [%u]\n", ++m_count);
+        dataLogF("Propagating predictions backward [%u]\n", ++m_count);
 #endif
         for (m_compileIndex = m_graph.size(); m_compileIndex-- > 0;)
             propagate(m_graph[m_compileIndex]);
@@ -833,7 +833,7 @@ private:
     void doRoundOfDoubleVoting()
     {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-        dataLog("Voting on double uses of locals [%u]\n", m_count);
+        dataLogF("Voting on double uses of locals [%u]\n", m_count);
 #endif
         for (unsigned i = 0; i < m_graph.m_variableAccessData.size(); ++i)
             m_graph.m_variableAccessData[i].find()->clearVotes();
index dbcaa5f..3dbd1fe 100644 (file)
@@ -216,11 +216,11 @@ public:
         // For each register, print the VirtualRegister 'name'.
         for (uint32_t i =0; i < NUM_REGS; ++i) {
             if (m_data[i].name != InvalidVirtualRegister)
-                dataLog("[%02d]", m_data[i].name);
+                dataLogF("[%02d]", m_data[i].name);
             else
-                dataLog("[--]");
+                dataLogF("[--]");
         }
-        dataLog("\n");
+        dataLogF("\n");
     }
 #endif
 
index 430bdf5..9b509fe 100644 (file)
@@ -113,7 +113,7 @@ public:
         ASSERT(m_used[index] != max());
         if (node.refCount() == ++m_used[index]) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog(" Freeing virtual register %u.", index);
+            dataLogF(" Freeing virtual register %u.", index);
 #endif
             // If the use count in the scoreboard reaches the use count for the node,
             // then this was its last use; the virtual register is now free.
@@ -122,7 +122,7 @@ public:
             m_free.append(index);
         } else {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog(" Virtual register %u is at %u/%u uses.", index, m_used[index], node.refCount());
+            dataLogF(" Virtual register %u is at %u/%u uses.", index, m_used[index], node.refCount());
 #endif
         }
     }
@@ -148,26 +148,26 @@ public:
 #ifndef NDEBUG
     void dump()
     {
-        dataLog("    USED: [ ");
+        dataLogF("    USED: [ ");
         for (unsigned i = 0; i < m_used.size(); ++i) {
             if (!m_free.contains(i)) {
-                dataLog("%d:", i);
+                dataLogF("%d:", i);
                 if (m_used[i] == max())
-                    dataLog("local ");
+                    dataLogF("local ");
                 else
-                    dataLog("%d ", m_used[i]);
+                    dataLogF("%d ", m_used[i]);
             }
         }
-        dataLog("]\n");
+        dataLogF("]\n");
 
-        dataLog("    FREE: [ ");
+        dataLogF("    FREE: [ ");
         for (unsigned i = 0; i < m_used.size(); ++i) {
             if (m_free.contains(i) && m_used[i] != max()) {
                 ASSERT(!m_used[i]);
-                dataLog("%d ", i);
+                dataLogF("%d ", i);
             }
         }
-        dataLog("]\n");
+        dataLogF("]\n");
     }
 
 #endif
index fa1f888..4acd869 100644 (file)
@@ -49,7 +49,7 @@ public:
     void generate(SpeculativeJIT* jit)
     {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Generating slow path %p at offset 0x%x\n", this, jit->m_jit.debugOffset());
+        dataLogF("Generating slow path %p at offset 0x%x\n", this, jit->m_jit.debugOffset());
 #endif
         m_label = jit->m_jit.label();
         jit->m_compileIndex = m_compileIndex;
index e52a42e..41276d2 100644 (file)
@@ -274,7 +274,7 @@ void SpeculativeJIT::terminateSpeculativeExecution(ExitKind kind, JSValueRegs js
 {
     ASSERT(at(m_compileIndex).canExit() || m_isCheckingArgumentTypes);
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpeculativeJIT was terminated.\n");
+    dataLogF("SpeculativeJIT was terminated.\n");
 #endif
     if (!m_compileOkay)
         return;
@@ -292,7 +292,7 @@ void SpeculativeJIT::terminateSpeculativeExecutionWithConditionalDirection(ExitK
 {
     ASSERT(at(m_compileIndex).canExit() || m_isCheckingArgumentTypes);
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpeculativeJIT was terminated.\n");
+    dataLogF("SpeculativeJIT was terminated.\n");
 #endif
     if (!m_compileOkay)
         return;
@@ -308,7 +308,7 @@ void SpeculativeJIT::addSlowPathGenerator(PassOwnPtr<SlowPathGenerator> slowPath
 void SpeculativeJIT::runSlowPathGenerators()
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Running %lu slow path generators.\n", m_slowPathGenerators.size());
+    dataLogF("Running %lu slow path generators.\n", m_slowPathGenerators.size());
 #endif
     for (unsigned i = 0; i < m_slowPathGenerators.size(); ++i)
         m_slowPathGenerators[i]->generate(this);
@@ -1005,33 +1005,33 @@ static const char* dataFormatString(DataFormat format)
 void SpeculativeJIT::dump(const char* label)
 {
     if (label)
-        dataLog("<%s>\n", label);
+        dataLogF("<%s>\n", label);
 
-    dataLog("  gprs:\n");
+    dataLogF("  gprs:\n");
     m_gprs.dump();
-    dataLog("  fprs:\n");
+    dataLogF("  fprs:\n");
     m_fprs.dump();
-    dataLog("  VirtualRegisters:\n");
+    dataLogF("  VirtualRegisters:\n");
     for (unsigned i = 0; i < m_generationInfo.size(); ++i) {
         GenerationInfo& info = m_generationInfo[i];
         if (info.alive())
-            dataLog("    % 3d:%s%s", i, dataFormatString(info.registerFormat()), dataFormatString(info.spillFormat()));
+            dataLogF("    % 3d:%s%s", i, dataFormatString(info.registerFormat()), dataFormatString(info.spillFormat()));
         else
-            dataLog("    % 3d:[__][__]", i);
+            dataLogF("    % 3d:[__][__]", i);
         if (info.registerFormat() == DataFormatDouble)
-            dataLog(":fpr%d\n", info.fpr());
+            dataLogF(":fpr%d\n", info.fpr());
         else if (info.registerFormat() != DataFormatNone
 #if USE(JSVALUE32_64)
             && !(info.registerFormat() & DataFormatJS)
 #endif
             ) {
             ASSERT(info.gpr() != InvalidGPRReg);
-            dataLog(":%s\n", GPRInfo::debugName(info.gpr()));
+            dataLogF(":%s\n", GPRInfo::debugName(info.gpr()));
         } else
-            dataLog("\n");
+            dataLogF("\n");
     }
     if (label)
-        dataLog("</%s>\n", label);
+        dataLogF("</%s>\n", label);
 }
 #endif
 
@@ -1043,13 +1043,13 @@ void SpeculativeJIT::checkConsistency()
 
     for (gpr_iterator iter = m_gprs.begin(); iter != m_gprs.end(); ++iter) {
         if (iter.isLocked()) {
-            dataLog("DFG_CONSISTENCY_CHECK failed: gpr %s is locked.\n", iter.debugName());
+            dataLogF("DFG_CONSISTENCY_CHECK failed: gpr %s is locked.\n", iter.debugName());
             failed = true;
         }
     }
     for (fpr_iterator iter = m_fprs.begin(); iter != m_fprs.end(); ++iter) {
         if (iter.isLocked()) {
-            dataLog("DFG_CONSISTENCY_CHECK failed: fpr %s is locked.\n", iter.debugName());
+            dataLogF("DFG_CONSISTENCY_CHECK failed: fpr %s is locked.\n", iter.debugName());
             failed = true;
         }
     }
@@ -1077,7 +1077,7 @@ void SpeculativeJIT::checkConsistency()
             GPRReg gpr = info.gpr();
             ASSERT(gpr != InvalidGPRReg);
             if (m_gprs.name(gpr) != virtualRegister) {
-                dataLog("DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (gpr %s).\n", virtualRegister, GPRInfo::debugName(gpr));
+                dataLogF("DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (gpr %s).\n", virtualRegister, GPRInfo::debugName(gpr));
                 failed = true;
             }
             break;
@@ -1086,7 +1086,7 @@ void SpeculativeJIT::checkConsistency()
             FPRReg fpr = info.fpr();
             ASSERT(fpr != InvalidFPRReg);
             if (m_fprs.name(fpr) != virtualRegister) {
-                dataLog("DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (fpr %s).\n", virtualRegister, FPRInfo::debugName(fpr));
+                dataLogF("DFG_CONSISTENCY_CHECK failed: name mismatch for virtual register %d (fpr %s).\n", virtualRegister, FPRInfo::debugName(fpr));
                 failed = true;
             }
             break;
@@ -1102,18 +1102,18 @@ void SpeculativeJIT::checkConsistency()
         GenerationInfo& info = m_generationInfo[virtualRegister];
 #if USE(JSVALUE64)
         if (iter.regID() != info.gpr()) {
-            dataLog("DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
+            dataLogF("DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
             failed = true;
         }
 #else
         if (!(info.registerFormat() & DataFormatJS)) {
             if (iter.regID() != info.gpr()) {
-                dataLog("DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
+                dataLogF("DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
                 failed = true;
             }
         } else {
             if (iter.regID() != info.tagGPR() && iter.regID() != info.payloadGPR()) {
-                dataLog("DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
+                dataLogF("DFG_CONSISTENCY_CHECK failed: name mismatch for gpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
                 failed = true;
             }
         }
@@ -1127,7 +1127,7 @@ void SpeculativeJIT::checkConsistency()
 
         GenerationInfo& info = m_generationInfo[virtualRegister];
         if (iter.regID() != info.fpr()) {
-            dataLog("DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
+            dataLogF("DFG_CONSISTENCY_CHECK failed: name mismatch for fpr %s (virtual register %d).\n", iter.debugName(), virtualRegister);
             failed = true;
         }
     }
@@ -1545,7 +1545,7 @@ void SpeculativeJIT::compile(BasicBlock& block)
 #endif
     
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Setting up state for block #%u: ", m_block);
+    dataLogF("Setting up state for block #%u: ", m_block);
 #endif
     
     m_stream->appendAndLog(VariableEvent::reset());
@@ -1593,7 +1593,7 @@ void SpeculativeJIT::compile(BasicBlock& block)
     }
 
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("\n");
+    dataLogF("\n");
 #endif
 
     for (m_indexInBlock = 0; m_indexInBlock < block.size(); ++m_indexInBlock) {
@@ -1603,7 +1603,7 @@ void SpeculativeJIT::compile(BasicBlock& block)
         m_codeOriginForOSR = node.codeOrigin;
         if (!node.shouldGenerate()) {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-            dataLog("SpeculativeJIT skipping Node @%d (bc#%u) at JIT offset 0x%x     ", (int)m_compileIndex, node.codeOrigin.bytecodeIndex, m_jit.debugOffset());
+            dataLogF("SpeculativeJIT skipping Node @%d (bc#%u) at JIT offset 0x%x     ", (int)m_compileIndex, node.codeOrigin.bytecodeIndex, m_jit.debugOffset());
 #endif
             switch (node.op()) {
             case JSConstant:
@@ -1650,7 +1650,7 @@ void SpeculativeJIT::compile(BasicBlock& block)
                     // The exception is the this argument, which we don't really need to be
                     // able to recover.
 #if DFG_ENABLE(DEBUG_VERBOSE)
-                    dataLog("\nRecovery for argument %d: ", i);
+                    dataLogF("\nRecovery for argument %d: ", i);
                     recovery.dump(WTF::dataFile());
 #endif
                     inlineCallFrame->arguments[i] = recovery;
@@ -1666,7 +1666,7 @@ void SpeculativeJIT::compile(BasicBlock& block)
         } else {
             
 #if DFG_ENABLE(DEBUG_VERBOSE)
-            dataLog("SpeculativeJIT generating Node @%d (bc#%u) at JIT offset 0x%x   ", (int)m_compileIndex, node.codeOrigin.bytecodeIndex, m_jit.debugOffset());
+            dataLogF("SpeculativeJIT generating Node @%d (bc#%u) at JIT offset 0x%x   ", (int)m_compileIndex, node.codeOrigin.bytecodeIndex, m_jit.debugOffset());
 #endif
 #if DFG_ENABLE(JIT_BREAK_ON_EVERY_NODE)
             m_jit.breakpoint();
@@ -1691,25 +1691,25 @@ void SpeculativeJIT::compile(BasicBlock& block)
 #if DFG_ENABLE(DEBUG_VERBOSE)
             if (node.hasResult()) {
                 GenerationInfo& info = m_generationInfo[node.virtualRegister()];
-                dataLog("-> %s, vr#%d", dataFormatToString(info.registerFormat()), (int)node.virtualRegister());
+                dataLogF("-> %s, vr#%d", dataFormatToString(info.registerFormat()), (int)node.virtualRegister());
                 if (info.registerFormat() != DataFormatNone) {
                     if (info.registerFormat() == DataFormatDouble)
-                        dataLog(", %s", FPRInfo::debugName(info.fpr()));
+                        dataLogF(", %s", FPRInfo::debugName(info.fpr()));
 #if USE(JSVALUE32_64)
                     else if (info.registerFormat() & DataFormatJS)
-                        dataLog(", %s %s", GPRInfo::debugName(info.tagGPR()), GPRInfo::debugName(info.payloadGPR()));
+                        dataLogF(", %s %s", GPRInfo::debugName(info.tagGPR()), GPRInfo::debugName(info.payloadGPR()));
 #endif
                     else
-                        dataLog(", %s", GPRInfo::debugName(info.gpr()));
+                        dataLogF(", %s", GPRInfo::debugName(info.gpr()));
                 }
-                dataLog("    ");
+                dataLogF("    ");
             } else
-                dataLog("    ");
+                dataLogF("    ");
 #endif
         }
         
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("\n");
+        dataLogF("\n");
 #endif
         
         // Make sure that the abstract state is rematerialized for the next node.
@@ -2006,7 +2006,7 @@ void SpeculativeJIT::compileGetByValOnString(Node& node)
 GeneratedOperandType SpeculativeJIT::checkGeneratedTypeForToInt32(NodeIndex nodeIndex)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("checkGeneratedTypeForToInt32@%d   ", nodeIndex);
+    dataLogF("checkGeneratedTypeForToInt32@%d   ", nodeIndex);
 #endif
     Node& node = at(nodeIndex);
     VirtualRegister virtualRegister = node.virtualRegister();
index a08e2ce..05af696 100644 (file)
@@ -1090,7 +1090,7 @@ template<bool strict>
 GPRReg SpeculativeJIT::fillSpeculateIntInternal(NodeIndex nodeIndex, DataFormat& returnFormat)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecInt@%d   ", nodeIndex);
+    dataLogF("SpecInt@%d   ", nodeIndex);
 #endif
     if (isKnownNotInteger(nodeIndex)) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), NoNode);
@@ -1188,7 +1188,7 @@ GPRReg SpeculativeJIT::fillSpeculateIntStrict(NodeIndex nodeIndex)
 FPRReg SpeculativeJIT::fillSpeculateDouble(NodeIndex nodeIndex)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecDouble@%d   ", nodeIndex);
+    dataLogF("SpecDouble@%d   ", nodeIndex);
 #endif
     if (isKnownNotNumber(nodeIndex)) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), NoNode);
@@ -1323,7 +1323,7 @@ FPRReg SpeculativeJIT::fillSpeculateDouble(NodeIndex nodeIndex)
 GPRReg SpeculativeJIT::fillSpeculateCell(NodeIndex nodeIndex, bool isForwardSpeculation)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecCell@%d   ", nodeIndex);
+    dataLogF("SpecCell@%d   ", nodeIndex);
 #endif
     if (isKnownNotCell(nodeIndex)) {
         terminateSpeculativeExecutionWithConditionalDirection(Uncountable, JSValueRegs(), NoNode, isForwardSpeculation);
@@ -1398,7 +1398,7 @@ GPRReg SpeculativeJIT::fillSpeculateCell(NodeIndex nodeIndex, bool isForwardSpec
 GPRReg SpeculativeJIT::fillSpeculateBoolean(NodeIndex nodeIndex)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecBool@%d   ", nodeIndex);
+    dataLogF("SpecBool@%d   ", nodeIndex);
 #endif
     SpeculatedType type = m_state.forNode(nodeIndex).m_type;
     Node& node = m_jit.graph()[nodeIndex];
index f26d638..da6583c 100644 (file)
@@ -1065,7 +1065,7 @@ template<bool strict>
 GPRReg SpeculativeJIT::fillSpeculateIntInternal(NodeIndex nodeIndex, DataFormat& returnFormat)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecInt@%d   ", nodeIndex);
+    dataLogF("SpecInt@%d   ", nodeIndex);
 #endif
     SpeculatedType type = m_state.forNode(nodeIndex).m_type;
     Node& node = at(nodeIndex);
@@ -1213,7 +1213,7 @@ GPRReg SpeculativeJIT::fillSpeculateIntStrict(NodeIndex nodeIndex)
 FPRReg SpeculativeJIT::fillSpeculateDouble(NodeIndex nodeIndex)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecDouble@%d   ", nodeIndex);
+    dataLogF("SpecDouble@%d   ", nodeIndex);
 #endif
     SpeculatedType type = m_state.forNode(nodeIndex).m_type;
     Node& node = at(nodeIndex);
@@ -1367,7 +1367,7 @@ FPRReg SpeculativeJIT::fillSpeculateDouble(NodeIndex nodeIndex)
 GPRReg SpeculativeJIT::fillSpeculateCell(NodeIndex nodeIndex, bool isForwardSpeculation)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecCell@%d   ", nodeIndex);
+    dataLogF("SpecCell@%d   ", nodeIndex);
 #endif
     SpeculatedType type = m_state.forNode(nodeIndex).m_type;
     Node& node = at(nodeIndex);
@@ -1443,7 +1443,7 @@ GPRReg SpeculativeJIT::fillSpeculateCell(NodeIndex nodeIndex, bool isForwardSpec
 GPRReg SpeculativeJIT::fillSpeculateBoolean(NodeIndex nodeIndex)
 {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("SpecBool@%d   ", nodeIndex);
+    dataLogF("SpecBool@%d   ", nodeIndex);
 #endif
     SpeculatedType type = m_state.forNode(nodeIndex).m_type;
     Node& node = at(nodeIndex);
index 22b9395..9d6060d 100644 (file)
@@ -167,7 +167,7 @@ public:
             if (iter == m_map.end())
                 continue;
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-            dataLog("Zeroing the structure to hoist for %s because the ratio is %lf.\n",
+            dataLogF("Zeroing the structure to hoist for %s because the ratio is %lf.\n",
                     m_graph.nameOfVariableAccessData(variable), variable->voteRatio());
 #endif
             iter->value.m_structure = 0;
@@ -200,7 +200,7 @@ public:
                 JSValue value = m_graph.m_mustHandleValues[i];
                 if (!value || !value.isCell()) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                    dataLog("Zeroing the structure to hoist for %s because the OSR entry value is not a cell: %s.\n",
+                    dataLogF("Zeroing the structure to hoist for %s because the OSR entry value is not a cell: %s.\n",
                             m_graph.nameOfVariableAccessData(variable), value.description());
 #endif
                     iter->value.m_structure = 0;
@@ -208,7 +208,7 @@ public:
                 }
                 if (value.asCell()->structure() != iter->value.m_structure) {
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                    dataLog("Zeroing the structure to hoist for %s because the OSR entry value has structure %p and we wanted %p.\n",
+                    dataLogF("Zeroing the structure to hoist for %s because the OSR entry value has structure %p and we wanted %p.\n",
                             m_graph.nameOfVariableAccessData(variable), value.asCell()->structure(), iter->value.m_structure);
 #endif
                     iter->value.m_structure = 0;
@@ -223,10 +223,10 @@ public:
         for (HashMap<VariableAccessData*, CheckData>::iterator it = m_map.begin();
              it != m_map.end(); ++it) {
             if (!it->value.m_structure) {
-                dataLog("Not hoisting checks for %s because of heuristics.\n", m_graph.nameOfVariableAccessData(it->key));
+                dataLogF("Not hoisting checks for %s because of heuristics.\n", m_graph.nameOfVariableAccessData(it->key));
                 continue;
             }
-            dataLog("Hoisting checks for %s\n", m_graph.nameOfVariableAccessData(it->key));
+            dataLogF("Hoisting checks for %s\n", m_graph.nameOfVariableAccessData(it->key));
         }
 #endif // DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
         
index 2b26123..274b544 100644 (file)
@@ -45,9 +45,9 @@ public:
     
     #define VALIDATE(context, assertion) do { \
         if (!(assertion)) { \
-            dataLog("\n\n\nAt "); \
+            dataLogF("\n\n\nAt "); \
             reportValidationContext context; \
-            dataLog(": validation %s (%s:%d) failed.\n", #assertion, __FILE__, __LINE__); \
+            dataLogF(": validation %s (%s:%d) failed.\n", #assertion, __FILE__, __LINE__); \
             dumpGraphIfAppropriate(); \
             WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #assertion); \
             CRASH(); \
@@ -56,13 +56,13 @@ public:
     
     #define V_EQUAL(context, left, right) do { \
         if (left != right) { \
-            dataLog("\n\n\nAt "); \
+            dataLogF("\n\n\nAt "); \
             reportValidationContext context; \
-            dataLog(": validation (%s = ", #left); \
+            dataLogF(": validation (%s = ", #left); \
             dumpData(left); \
-            dataLog(") == (%s = ", #right); \
+            dataLogF(") == (%s = ", #right); \
             dumpData(right); \
-            dataLog(") (%s:%d) failed.\n", __FILE__, __LINE__); \
+            dataLogF(") (%s:%d) failed.\n", __FILE__, __LINE__); \
             dumpGraphIfAppropriate(); \
             WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, #left " == " #right); \
             CRASH(); \
@@ -290,60 +290,60 @@ private:
     
     void reportValidationContext(NodeIndex nodeIndex)
     {
-        dataLog("@%u", nodeIndex);
+        dataLogF("@%u", nodeIndex);
     }
     
     enum BlockTag { Block };
     void reportValidationContext(BlockTag, BlockIndex blockIndex)
     {
-        dataLog("Block #%u", blockIndex);
+        dataLogF("Block #%u", blockIndex);
     }
     
     void reportValidationContext(NodeIndex nodeIndex, Edge edge)
     {
-        dataLog("@%u -> %s@%u", nodeIndex, useKindToString(edge.useKind()), edge.index());
+        dataLogF("@%u -> %s@%u", nodeIndex, useKindToString(edge.useKind()), edge.index());
     }
     
     void reportValidationContext(
         VirtualRegister local, BlockIndex sourceBlockIndex, BlockTag, BlockIndex destinationBlockIndex)
     {
-        dataLog("r%d in Block #%u -> #%u", local, sourceBlockIndex, destinationBlockIndex);
+        dataLogF("r%d in Block #%u -> #%u", local, sourceBlockIndex, destinationBlockIndex);
     }
     
     void reportValidationContext(
         VirtualRegister local, BlockIndex sourceBlockIndex, NodeIndex prevNodeIndex)
     {
-        dataLog("@%u for r%d in Block #%u", prevNodeIndex, local, sourceBlockIndex);
+        dataLogF("@%u for r%d in Block #%u", prevNodeIndex, local, sourceBlockIndex);
     }
     
     void reportValidationContext(
         NodeIndex nodeIndex, BlockIndex blockIndex)
     {
-        dataLog("@%u in Block #%u", nodeIndex, blockIndex);
+        dataLogF("@%u in Block #%u", nodeIndex, blockIndex);
     }
     
     void reportValidationContext(
         NodeIndex nodeIndex, NodeIndex nodeIndex2, BlockIndex blockIndex)
     {
-        dataLog("@%u and @%u in Block #%u", nodeIndex, nodeIndex2, blockIndex);
+        dataLogF("@%u and @%u in Block #%u", nodeIndex, nodeIndex2, blockIndex);
     }
     
     void reportValidationContext(
         NodeIndex nodeIndex, BlockIndex blockIndex, NodeIndex expectedNodeIndex, Edge incomingEdge)
     {
-        dataLog("@%u in Block #%u, searching for @%u from @%u", nodeIndex, blockIndex, expectedNodeIndex, incomingEdge.index());
+        dataLogF("@%u in Block #%u, searching for @%u from @%u", nodeIndex, blockIndex, expectedNodeIndex, incomingEdge.index());
     }
     
     void dumpData(unsigned value)
     {
-        dataLog("%u", value);
+        dataLogF("%u", value);
     }
     
     void dumpGraphIfAppropriate()
     {
         if (m_graphDumpMode == DontDumpGraph)
             return;
-        dataLog("Graph at time of failure:\n");
+        dataLogF("Graph at time of failure:\n");
         m_graph.dump();
     }
 };
index fa36ccd..7fa109b 100644 (file)
@@ -36,9 +36,9 @@ namespace JSC { namespace DFG {
 
 void VariableEventStream::logEvent(const VariableEvent& event)
 {
-    dataLog("seq#%u:", static_cast<unsigned>(size()));
+    dataLogF("seq#%u:", static_cast<unsigned>(size()));
     event.dump(WTF::dataFile());
-    dataLog(" ");
+    dataLogF(" ");
 }
 
 struct MinifiedGenerationInfo {
@@ -103,7 +103,7 @@ void VariableEventStream::reconstruct(
         startIndex--;
     
 #if DFG_ENABLE(DEBUG_VERBOSE)
-    dataLog("Computing OSR exit recoveries starting at seq#%u.\n", startIndex);
+    dataLogF("Computing OSR exit recoveries starting at seq#%u.\n", startIndex);
 #endif
 
     // Step 2: Create a mock-up of the DFG's state and execute the events.
index 86b3383..eb3232e 100644 (file)
@@ -43,9 +43,9 @@ public:
     bool run()
     {
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Preserved vars: ");
+        dataLogF("Preserved vars: ");
         m_graph.m_preservedVars.dump(WTF::dataFile());
-        dataLog("\n");
+        dataLogF("\n");
 #endif
         ScoreBoard scoreBoard(m_graph, m_graph.m_preservedVars);
         scoreBoard.assertClear();
@@ -62,8 +62,8 @@ public:
                 NodeIndex nodeIndex = block->at(indexInBlock);
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
                 if (needsNewLine)
-                    dataLog("\n");
-                dataLog("   @%u:", nodeIndex);
+                    dataLogF("\n");
+                dataLogF("   @%u:", nodeIndex);
                 needsNewLine = true;
 #endif
                 Node& node = m_graph[nodeIndex];
@@ -92,7 +92,7 @@ public:
 
                 VirtualRegister virtualRegister = scoreBoard.allocate();
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
-                dataLog(" Assigning virtual register %u to node %u.",
+                dataLogF(" Assigning virtual register %u to node %u.",
                         virtualRegister, nodeIndex);
 #endif
                 node.setVirtualRegister(virtualRegister);
@@ -105,7 +105,7 @@ public:
         }
 #if DFG_ENABLE(DEBUG_PROPAGATION_VERBOSE)
         if (needsNewLine)
-            dataLog("\n");
+            dataLogF("\n");
 #endif
 
         // 'm_numCalleeRegisters' is the number of locals and temporaries allocated
@@ -123,7 +123,7 @@ public:
         if ((unsigned)codeBlock()->m_numCalleeRegisters < calleeRegisters)
             codeBlock()->m_numCalleeRegisters = calleeRegisters;
 #if DFG_ENABLE(DEBUG_VERBOSE)
-        dataLog("Num callee registers: %u\n", calleeRegisters);
+        dataLogF("Num callee registers: %u\n", calleeRegisters);
 #endif
         
         return true;
index 0fb65e2..9ff318b 100644 (file)
@@ -76,7 +76,7 @@ struct GCTimer {
     }
     ~GCTimer()
     {
-        dataLog("%s: %.2lfms (avg. %.2lf, min. %.2lf, max. %.2lf)\n", m_name, m_time * 1000, m_time * 1000 / m_count, m_min*1000, m_max*1000);
+        dataLogF("%s: %.2lfms (avg. %.2lf, min. %.2lf, max. %.2lf)\n", m_name, m_time * 1000, m_time * 1000 / m_count, m_min*1000, m_max*1000);
     }
     double m_time;
     double m_min;
@@ -126,7 +126,7 @@ struct GCCounter {
     }
     ~GCCounter()
     {
-        dataLog("%s: %zu values (avg. %zu, min. %zu, max. %zu)\n", m_name, m_total, m_total / m_count, m_min, m_max);
+        dataLogF("%s: %zu values (avg. %zu, min. %zu, max. %zu)\n", m_name, m_total, m_total / m_count, m_min, m_max);
     }
     const char* m_name;
     size_t m_count;
index 3876215..2b98fe7 100644 (file)
@@ -75,28 +75,28 @@ void HeapStatistics::logStatistics()
 #error "The HeapStatistics module is not supported on this platform."
 #endif
     if (!vmName || !suiteName || !benchmarkName)
-        dataLog("HeapStatistics: {\"max_rss\": %ld", usage.ru_maxrss);
+        dataLogF("HeapStatistics: {\"max_rss\": %ld", usage.ru_maxrss);
     else
-        dataLog("HeapStatistics: {\"max_rss\": %ld, \"vm_name\": \"%s\", \"suite_name\": \"%s\", \"benchmark_name\": \"%s\"", 
+        dataLogF("HeapStatistics: {\"max_rss\": %ld, \"vm_name\": \"%s\", \"suite_name\": \"%s\", \"benchmark_name\": \"%s\"", 
             usage.ru_maxrss, vmName, suiteName, benchmarkName); 
 
     if (Options::recordGCPauseTimes()) {
-        dataLog(", \"pause_times\": [");
+        dataLogF(", \"pause_times\": [");
         Vector<double>::iterator startIt = s_pauseTimeStarts->begin();
         Vector<double>::iterator endIt = s_pauseTimeEnds->begin();
         if (startIt != s_pauseTimeStarts->end() && endIt != s_pauseTimeEnds->end()) {
-            dataLog("[%f, %f]", *startIt, *endIt);
+            dataLogF("[%f, %f]", *startIt, *endIt);
             ++startIt;
             ++endIt;
         }
         while (startIt != s_pauseTimeStarts->end() && endIt != s_pauseTimeEnds->end()) {
-            dataLog(", [%f, %f]", *startIt, *endIt);
+            dataLogF(", [%f, %f]", *startIt, *endIt);
             ++startIt;
             ++endIt;
         }
-        dataLog("], \"start_time\": %f, \"end_time\": %f", s_startTime, s_endTime);
+        dataLogF("], \"start_time\": %f, \"end_time\": %f", s_startTime, s_endTime);
     }
-    dataLog("}\n");
+    dataLogF("}\n");
 }
 
 void HeapStatistics::exitWithFailure()
@@ -228,20 +228,20 @@ inline size_t StorageStatistics::storageCapacity()
 
 void HeapStatistics::showObjectStatistics(Heap* heap)
 {
-    dataLog("\n=== Heap Statistics: ===\n");
-    dataLog("size: %ldkB\n", static_cast<long>(heap->m_sizeAfterLastCollect / KB));
-    dataLog("capacity: %ldkB\n", static_cast<long>(heap->capacity() / KB));
-    dataLog("pause time: %lfms\n\n", heap->m_lastGCLength);
+    dataLogF("\n=== Heap Statistics: ===\n");
+    dataLogF("size: %ldkB\n", static_cast<long>(heap->m_sizeAfterLastCollect / KB));
+    dataLogF("capacity: %ldkB\n", static_cast<long>(heap->capacity() / KB));
+    dataLogF("pause time: %lfms\n\n", heap->m_lastGCLength);
 
     StorageStatistics storageStatistics;
     heap->m_objectSpace.forEachLiveCell(storageStatistics);
-    dataLog("wasted .property storage: %ldkB (%ld%%)\n",
+    dataLogF("wasted .property storage: %ldkB (%ld%%)\n",
         static_cast<long>(
             (storageStatistics.storageCapacity() - storageStatistics.storageSize()) / KB),
         static_cast<long>(
             (storageStatistics.storageCapacity() - storageStatistics.storageSize()) * 100
                 / storageStatistics.storageCapacity()));
-    dataLog("objects with out-of-line .property storage: %ld (%ld%%)\n",
+    dataLogF("objects with out-of-line .property storage: %ld (%ld%%)\n",
         static_cast<long>(
             storageStatistics.objectWithOutOfLineStorageCount()),
         static_cast<long>(
index 35845ed..2a7f044 100644 (file)
 #define MarkStack_h
 
 #if ENABLE(OBJECT_MARK_LOGGING)
-#define MARK_LOG_MESSAGE0(message) dataLog(message)
-#define MARK_LOG_MESSAGE1(message, arg1) dataLog(message, arg1)
-#define MARK_LOG_MESSAGE2(message, arg1, arg2) dataLog(message, arg1, arg2)
+#define MARK_LOG_MESSAGE0(message) dataLogF(message)
+#define MARK_LOG_MESSAGE1(message, arg1) dataLogF(message, arg1)
+#define MARK_LOG_MESSAGE2(message, arg1, arg2) dataLogF(message, arg1, arg2)
 #define MARK_LOG_ROOT(visitor, rootName) \
-    dataLog("\n%s: ", rootName); \
+    dataLogF("\n%s: ", rootName); \
     (visitor).resetChildCount()
 #define MARK_LOG_PARENT(visitor, parent) \
-    dataLog("\n%p (%s): ", parent, parent->className() ? parent->className() : "unknown"); \
+    dataLogF("\n%p (%s): ", parent, parent->className() ? parent->className() : "unknown"); \
     (visitor).resetChildCount()
 #define MARK_LOG_CHILD(visitor, child) \
     if ((visitor).childCount()) \
-    dataLogString(", "); \
-    dataLog("%p", child); \
+    dataLogFString(", "); \
+    dataLogF("%p", child); \
     (visitor).incrementChildCount()
 #else
 #define MARK_LOG_MESSAGE0(message) do { } while (false)
index f2f2a72..9080aae 100644 (file)
@@ -40,7 +40,7 @@
 
 #if HEAP_LOG_BLOCK_STATE_TRANSITIONS
 #define HEAP_LOG_BLOCK_STATE_TRANSITION(block) do {                     \
-        dataLog(                                                    \
+        dataLogF(                                                    \
             "%s:%d %s: block %s = %p, %d\n",                            \
             __FILE__, __LINE__, __FUNCTION__,                           \
             #block, (block), (block)->m_state);                         \
index cff3615..3ff4b48 100644 (file)
@@ -336,12 +336,12 @@ void SlotVisitor::finalizeUnconditionalFinalizers()
 void SlotVisitor::validate(JSCell* cell)
 {
     if (!cell) {
-        dataLog("cell is NULL\n");
+        dataLogF("cell is NULL\n");
         CRASH();
     }
 
     if (!cell->structure()) {
-        dataLog("cell at %p has a null structure\n" , cell);
+        dataLogF("cell at %p has a null structure\n" , cell);
         CRASH();
     }
 
@@ -354,7 +354,7 @@ void SlotVisitor::validate(JSCell* cell)
             parentClassName = cell->structure()->structure()->JSCell::classInfo()->className;
         if (cell->structure()->JSCell::classInfo())
             ourClassName = cell->structure()->JSCell::classInfo()->className;
-        dataLog("parent structure (%p <%s>) of cell at %p doesn't match cell's structure (%p <%s>)\n",
+        dataLogF("parent structure (%p <%s>) of cell at %p doesn't match cell's structure (%p <%s>)\n",
                 cell->structure()->structure(), parentClassName, cell, cell->structure(), ourClassName);
         CRASH();
     }
index 6dcf354..ac286c3 100644 (file)
@@ -40,7 +40,7 @@ void CallFrame::dumpCaller()
     JSValue function;
     
     interpreter()->retrieveLastCaller(this, signedLineNumber, sourceID, urlString, function);
-    dataLog("Callpoint => %s:%d\n", urlString.utf8().data(), signedLineNumber);
+    dataLogF("Callpoint => %s:%d\n", urlString.utf8().data(), signedLineNumber);
 }
 
 JSStack* CallFrame::stack()
index 8228139..ad89505 100644 (file)
@@ -386,10 +386,10 @@ void Interpreter::dumpCallFrame(CallFrame* callFrame)
 
 void Interpreter::dumpRegisters(CallFrame* callFrame)
 {
-    dataLog("Register frame: \n\n");
-    dataLog("-----------------------------------------------------------------------------\n");
-    dataLog("            use            |   address  |                value               \n");
-    dataLog("-----------------------------------------------------------------------------\n");
+    dataLogF("Register frame: \n\n");
+    dataLogF("-----------------------------------------------------------------------------\n");
+    dataLogF("            use            |   address  |                value               \n");
+    dataLogF("-----------------------------------------------------------------------------\n");
 
     CodeBlock* codeBlock = callFrame->codeBlock();
     const Register* it;
@@ -401,32 +401,32 @@ void Interpreter::dumpRegisters(CallFrame* callFrame)
         JSValue v = it->jsValue();
         int registerNumber = it - callFrame->registers();
         String name = codeBlock->nameForRegister(registerNumber);
-        dataLog("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, v.description(), (long long)JSValue::encode(v));
+        dataLogF("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, v.description(), (long long)JSValue::encode(v));
         it++;
     }
     
-    dataLog("-----------------------------------------------------------------------------\n");
-    dataLog("[ArgumentCount]            | %10p | %lu \n", it, (unsigned long) callFrame->argumentCount());
+    dataLogF("-----------------------------------------------------------------------------\n");
+    dataLogF("[ArgumentCount]            | %10p | %lu \n", it, (unsigned long) callFrame->argumentCount());
     ++it;
-    dataLog("[CallerFrame]              | %10p | %p \n", it, callFrame->callerFrame());
+    dataLogF("[CallerFrame]              | %10p | %p \n", it, callFrame->callerFrame());
     ++it;
-    dataLog("[Callee]                   | %10p | %p \n", it, callFrame->callee());
+    dataLogF("[Callee]                   | %10p | %p \n", it, callFrame->callee());
     ++it;
-    dataLog("[ScopeChain]               | %10p | %p \n", it, callFrame->scope());
+    dataLogF("[ScopeChain]               | %10p | %p \n", it, callFrame->scope());
     ++it;
 #if ENABLE(JIT)
     AbstractPC pc = callFrame->abstractReturnPC(callFrame->globalData());
     if (pc.hasJITReturnAddress())
-        dataLog("[ReturnJITPC]              | %10p | %p \n", it, pc.jitReturnAddress().value());
+        dataLogF("[ReturnJITPC]              | %10p | %p \n", it, pc.jitReturnAddress().value());
 #endif
     unsigned bytecodeOffset = 0;
     int line = 0;
     getCallerInfo(&callFrame->globalData(), callFrame, line, bytecodeOffset);
-    dataLog("[ReturnVPC]                | %10p | %d (line %d)\n", it, bytecodeOffset, line);
+    dataLogF("[ReturnVPC]                | %10p | %d (line %d)\n", it, bytecodeOffset, line);
     ++it;
-    dataLog("[CodeBlock]                | %10p | %p \n", it, callFrame->codeBlock());
+    dataLogF("[CodeBlock]                | %10p | %p \n", it, callFrame->codeBlock());
     ++it;
-    dataLog("-----------------------------------------------------------------------------\n");
+    dataLogF("-----------------------------------------------------------------------------\n");
 
     int registerCount = 0;
 
@@ -436,23 +436,23 @@ void Interpreter::dumpRegisters(CallFrame* callFrame)
             JSValue v = it->jsValue();
             int registerNumber = it - callFrame->registers();
             String name = codeBlock->nameForRegister(registerNumber);
-            dataLog("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, v.description(), (long long)JSValue::encode(v));
+            dataLogF("[r% 3d %14s]      | %10p | %-16s 0x%lld \n", registerNumber, name.ascii().data(), it, v.description(), (long long)JSValue::encode(v));
             ++it;
             ++registerCount;
         } while (it != end);
     }
-    dataLog("-----------------------------------------------------------------------------\n");
+    dataLogF("-----------------------------------------------------------------------------\n");
 
     end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars;
     if (it != end) {
         do {
             JSValue v = (*it).jsValue();
-            dataLog("[r% 3d]                     | %10p | %-16s 0x%lld \n", registerCount, it, v.description(), (long long)JSValue::encode(v));
+            dataLogF("[r% 3d]                     | %10p | %-16s 0x%lld \n", registerCount, it, v.description(), (long long)JSValue::encode(v));
             ++it;
             ++registerCount;
         } while (it != end);
     }
-    dataLog("-----------------------------------------------------------------------------\n");
+    dataLogF("-----------------------------------------------------------------------------\n");
 }
 
 #endif
index 8930a0f..cccf33b 100644 (file)
@@ -230,7 +230,7 @@ void JIT::privateCompileMainPass()
         m_labels[m_bytecodeOffset] = label();
 
 #if ENABLE(JIT_VERBOSE)
-        dataLog("Old JIT emitting code for bc#%u at offset 0x%lx.\n", m_bytecodeOffset, (long)debugOffset());
+        dataLogF("Old JIT emitting code for bc#%u at offset 0x%lx.\n", m_bytecodeOffset, (long)debugOffset());
 #endif
 
         switch (m_interpreter->getOpcodeID(currentInstruction->u.opcode)) {
@@ -451,7 +451,7 @@ void JIT::privateCompileSlowCases()
 #endif
 
 #if ENABLE(JIT_VERBOSE)
-        dataLog("Old JIT emitting slow code for bc#%u at offset 0x%lx.\n", m_bytecodeOffset, (long)debugOffset());
+        dataLogF("Old JIT emitting slow code for bc#%u at offset 0x%lx.\n", m_bytecodeOffset, (long)debugOffset());
 #endif
         
         if (m_disassembler)
@@ -835,7 +835,7 @@ JITCode JIT::privateCompile(CodePtr* functionEntryArityCheck, JITCompilationEffo
     m_codeBlock->shrinkToFit(CodeBlock::LateShrink);
     
 #if ENABLE(JIT_VERBOSE)
-    dataLog("JIT generated code for %p at [%p, %p).\n", m_codeBlock, result.executableMemory()->start(), result.executableMemory()->end());
+    dataLogF("JIT generated code for %p at [%p, %p).\n", m_codeBlock, result.executableMemory()->start(), result.executableMemory()->end());
 #endif
     
     return JITCode(result, JITCode::BaselineJIT);
index 748fc26..35b9399 100644 (file)
@@ -46,8 +46,8 @@ JITDisassembler::~JITDisassembler()
 
 void JITDisassembler::dump(LinkBuffer& linkBuffer)
 {
-    dataLog("Baseline JIT code for CodeBlock %p, instruction count = %u:\n", m_codeBlock, m_codeBlock->instructionCount());
-    dataLog("    Code at [%p, %p):\n", linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize());
+    dataLogF("Baseline JIT code for CodeBlock %p, instruction count = %u:\n", m_codeBlock, m_codeBlock->instructionCount());
+    dataLogF("    Code at [%p, %p):\n", linkBuffer.debugAddress(), static_cast<char*>(linkBuffer.debugAddress()) + linkBuffer.debugSize());
     dumpDisassembly(linkBuffer, m_startOfCode, m_labelForBytecodeIndexInMainPath[0]);
     
     MacroAssembler::Label firstSlowLabel;
@@ -58,9 +58,9 @@ void JITDisassembler::dump(LinkBuffer& linkBuffer)
         }
     }
     dumpForInstructions(linkBuffer, "    ", m_labelForBytecodeIndexInMainPath, firstSlowLabel.isSet() ? firstSlowLabel : m_endOfSlowPath);
-    dataLog("    (End Of Main Path)\n");
+    dataLogF("    (End Of Main Path)\n");
     dumpForInstructions(linkBuffer, "    (S) ", m_labelForBytecodeIndexInSlowPath, m_endOfSlowPath);
-    dataLog("    (End Of Slow Path)\n");
+    dataLogF("    (End Of Slow Path)\n");
 
     dumpDisassembly(linkBuffer, m_endOfSlowPath, m_endOfCode);
 }
@@ -72,7 +72,7 @@ void JITDisassembler::dumpForInstructions(LinkBuffer& linkBuffer, const char* pr
             i++;
             continue;
         }
-        dataLog("%s", prefix);
+        dataLogF("%s", prefix);
         m_codeBlock->dump(i);
         for (unsigned nextIndex = i + 1; ; nextIndex++) {
             if (nextIndex >= labels.size()) {
index a46fcfd..020ef69 100644 (file)
@@ -150,11 +150,11 @@ protected:
 };
 
 // Helper for the creation of simple stub routines that need no help from the GC.
-#define FINALIZE_CODE_FOR_STUB(patchBuffer, dataLogArguments) \
-    (adoptRef(new JITStubRoutine(FINALIZE_CODE((patchBuffer), dataLogArguments))))
+#define FINALIZE_CODE_FOR_STUB(patchBuffer, dataLogFArguments) \
+    (adoptRef(new JITStubRoutine(FINALIZE_CODE((patchBuffer), dataLogFArguments))))
 
-#define FINALIZE_CODE_FOR_DFG_STUB(patchBuffer, dataLogArguments) \
-    (adoptRef(new JITStubRoutine(FINALIZE_DFG_CODE((patchBuffer), dataLogArguments))))
+#define FINALIZE_CODE_FOR_DFG_STUB(patchBuffer, dataLogFArguments) \
+    (adoptRef(new JITStubRoutine(FINALIZE_DFG_CODE((patchBuffer), dataLogFArguments))))
 
 } // namespace JSC
 
index 521dfac..760ffd4 100644 (file)
@@ -1808,12 +1808,12 @@ DEFINE_STUB_FUNCTION(void, optimize)
     unsigned bytecodeIndex = stackFrame.args[0].int32();
 
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("%p: Entered optimize with bytecodeIndex = %u, executeCounter = %s, reoptimizationRetryCounter = %u, optimizationDelayCounter = %u, exitCounter = ", codeBlock, bytecodeIndex, codeBlock->jitExecuteCounter().status(), codeBlock->reoptimizationRetryCounter(), codeBlock->optimizationDelayCounter());
+    dataLogF("%p: Entered optimize with bytecodeIndex = %u, executeCounter = %s, reoptimizationRetryCounter = %u, optimizationDelayCounter = %u, exitCounter = ", codeBlock, bytecodeIndex, codeBlock->jitExecuteCounter().status(), codeBlock->reoptimizationRetryCounter(), codeBlock->optimizationDelayCounter());
     if (codeBlock->hasOptimizedReplacement())
-        dataLog("%u", codeBlock->replacement()->osrExitCounter());
+        dataLogF("%u", codeBlock->replacement()->osrExitCounter());
     else
-        dataLog("N/A");
-    dataLog("\n");
+        dataLogF("N/A");
+    dataLogF("\n");
 #endif
 
     if (!codeBlock->checkIfOptimizationThresholdReached()) {
@@ -1823,7 +1823,7 @@ DEFINE_STUB_FUNCTION(void, optimize)
 
     if (codeBlock->hasOptimizedReplacement()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("Considering OSR into %p(%p).\n", codeBlock, codeBlock->replacement());
+        dataLogF("Considering OSR into %p(%p).\n", codeBlock, codeBlock->replacement());
 #endif
         // If we have an optimized replacement, then it must be the case that we entered
         // cti_optimize from a loop. That's because is there's an optimized replacement,
@@ -1840,7 +1840,7 @@ DEFINE_STUB_FUNCTION(void, optimize)
         // additional checking anyway, to reduce the amount of recompilation thrashing.
         if (codeBlock->replacement()->shouldReoptimizeFromLoopNow()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("Triggering reoptimization of %p(%p) (in loop).\n", codeBlock, codeBlock->replacement());
+            dataLogF("Triggering reoptimization of %p(%p) (in loop).\n", codeBlock, codeBlock->replacement());
 #endif
             codeBlock->reoptimize();
             return;
@@ -1848,7 +1848,7 @@ DEFINE_STUB_FUNCTION(void, optimize)
     } else {
         if (!codeBlock->shouldOptimizeNow()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("Delaying optimization for %p (in loop) because of insufficient profiling.\n", codeBlock);
+            dataLogF("Delaying optimization for %p (in loop) because of insufficient profiling.\n", codeBlock);
 #endif
             return;
         }
@@ -1857,14 +1857,14 @@ DEFINE_STUB_FUNCTION(void, optimize)
         JSObject* error = codeBlock->compileOptimized(callFrame, scope, bytecodeIndex);
 #if ENABLE(JIT_VERBOSE_OSR)
         if (error)
-            dataLog("WARNING: optimized compilation failed.\n");
+            dataLogF("WARNING: optimized compilation failed.\n");
 #else
         UNUSED_PARAM(error);
 #endif
         
         if (codeBlock->replacement() == codeBlock) {
 #if ENABLE(JIT_VERBOSE_OSR)
-            dataLog("Optimizing %p failed.\n", codeBlock);
+            dataLogF("Optimizing %p failed.\n", codeBlock);
 #endif
             
             ASSERT(codeBlock->getJITType() == JITCode::BaselineJIT);
@@ -1878,12 +1878,12 @@ DEFINE_STUB_FUNCTION(void, optimize)
     
     if (void* address = DFG::prepareOSREntry(callFrame, optimizedCodeBlock, bytecodeIndex)) {
         if (Options::showDFGDisassembly()) {
-            dataLog(
+            dataLogF(
                 "Performing OSR from code block %p to code block %p, address %p to %p.\n",
                 codeBlock, optimizedCodeBlock, (STUB_RETURN_ADDRESS).value(), address);
         }
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("Optimizing %p succeeded, performing OSR after a delay of %u.\n", codeBlock, codeBlock->optimizationDelayCounter());
+        dataLogF("Optimizing %p succeeded, performing OSR after a delay of %u.\n", codeBlock, codeBlock->optimizationDelayCounter());
 #endif
 
         codeBlock->optimizeSoon();
@@ -1892,7 +1892,7 @@ DEFINE_STUB_FUNCTION(void, optimize)
     }
     
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("Optimizing %p succeeded, OSR failed, after a delay of %u.\n", codeBlock, codeBlock->optimizationDelayCounter());
+    dataLogF("Optimizing %p succeeded, OSR failed, after a delay of %u.\n", codeBlock, codeBlock->optimizationDelayCounter());
 #endif
 
     // Count the OSR failure as a speculation failure. If this happens a lot, then
@@ -1900,7 +1900,7 @@ DEFINE_STUB_FUNCTION(void, optimize)
     optimizedCodeBlock->countOSRExit();
     
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("Encountered OSR failure into %p(%p).\n", codeBlock, codeBlock->replacement());
+    dataLogF("Encountered OSR failure into %p(%p).\n", codeBlock, codeBlock->replacement());
 #endif
 
     // We are a lot more conservative about triggering reoptimization after OSR failure than
@@ -1913,7 +1913,7 @@ DEFINE_STUB_FUNCTION(void, optimize)
     // reoptimization trigger.
     if (optimizedCodeBlock->shouldReoptimizeNow()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("Triggering reoptimization of %p(%p) (after OSR fail).\n", codeBlock, codeBlock->replacement());
+        dataLogF("Triggering reoptimization of %p(%p) (after OSR fail).\n", codeBlock, codeBlock->replacement());
 #endif
         codeBlock->reoptimize();
         return;
index 26eae57..13270d4 100644 (file)
@@ -47,7 +47,7 @@ void JumpReplacementWatchpoint::fireInternal()
     void* source = bitwise_cast<void*>(m_source);
     void* destination = bitwise_cast<void*>(m_destination);
     if (Options::showDisassembly())
-        dataLog("Firing jump replacement watchpoint from %p, to %p.\n", source, destination);
+        dataLogF("Firing jump replacement watchpoint from %p, to %p.\n", source, destination);
     MacroAssembler::replaceWithJump(CodeLocationLabel(source), CodeLocationLabel(destination));
     if (isOnList())
         remove();
index 80ca732..5e6bba3 100644 (file)
@@ -50,7 +50,7 @@ void interpreterThrowInCaller(ExecState* exec, ReturnAddressPtr pc)
     JSGlobalData* globalData = &exec->globalData();
     NativeCallFrameTracer tracer(globalData, exec);
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Throwing exception %s.\n", globalData->exception.description());
+    dataLogF("Throwing exception %s.\n", globalData->exception.description());
 #endif
     fixupPCforExceptionIfNeeded(exec);
     genericThrow(
@@ -69,7 +69,7 @@ Instruction* returnToThrow(ExecState* exec, Instruction* pc)
     JSGlobalData* globalData = &exec->globalData();
     NativeCallFrameTracer tracer(globalData, exec);
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Throwing exception %s (returnToThrow).\n", globalData->exception.description());
+    dataLogF("Throwing exception %s (returnToThrow).\n", globalData->exception.description());
 #endif
     fixupPCforExceptionIfNeeded(exec);
     genericThrow(globalData, exec, globalData->exception, pc - exec->codeBlock()->instructions().begin());
@@ -82,7 +82,7 @@ void* callToThrow(ExecState* exec, Instruction* pc)
     JSGlobalData* globalData = &exec->globalData();
     NativeCallFrameTracer tracer(globalData, exec);
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Throwing exception %s (callToThrow).\n", globalData->exception.description());
+    dataLogF("Throwing exception %s (callToThrow).\n", globalData->exception.description());
 #endif
     fixupPCforExceptionIfNeeded(exec);
     genericThrow(globalData, exec, globalData->exception, pc - exec->codeBlock()->instructions().begin());
index f9929e7..584100e 100644 (file)
@@ -162,7 +162,7 @@ namespace JSC { namespace LLInt {
 extern "C" SlowPathReturnType llint_trace_operand(ExecState* exec, Instruction* pc, int fromWhere, int operand)
 {
     LLINT_BEGIN();
-    dataLog("%p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d\n",
+    dataLogF("%p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d\n",
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
@@ -184,7 +184,7 @@ extern "C" SlowPathReturnType llint_trace_value(ExecState* exec, Instruction* pc
         EncodedJSValue asValue;
     } u;
     u.asValue = JSValue::encode(value);
-    dataLog("%p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d: %08x:%08x: %s\n",
+    dataLogF("%p / %p: executing bc#%zu, op#%u: Trace(%d): %d: %d: %08x:%08x: %s\n",
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
@@ -200,7 +200,7 @@ extern "C" SlowPathReturnType llint_trace_value(ExecState* exec, Instruction* pc
 
 LLINT_SLOW_PATH_DECL(trace_prologue)
 {
-    dataLog("%p / %p: in prologue.\n", exec->codeBlock(), exec);
+    dataLogF("%p / %p: in prologue.\n", exec->codeBlock(), exec);
     LLINT_END_IMPL();
 }
 
@@ -209,7 +209,7 @@ static void traceFunctionPrologue(ExecState* exec, const char* comment, CodeSpec
     JSFunction* callee = jsCast<JSFunction*>(exec->callee());
     FunctionExecutable* executable = callee->jsExecutable();
     CodeBlock* codeBlock = &executable->generatedBytecodeFor(kind);
-    dataLog("%p / %p: in %s of function %p, executable %p; numVars = %u, numParameters = %u, numCalleeRegisters = %u, caller = %p.\n",
+    dataLogF("%p / %p: in %s of function %p, executable %p; numVars = %u, numParameters = %u, numCalleeRegisters = %u, caller = %p.\n",
             codeBlock, exec, comment, callee, executable,
             codeBlock->m_numVars, codeBlock->numParameters(), codeBlock->m_numCalleeRegisters,
             exec->callerFrame());
@@ -241,22 +241,22 @@ LLINT_SLOW_PATH_DECL(trace_arityCheck_for_construct)
 
 LLINT_SLOW_PATH_DECL(trace)
 {
-    dataLog("%p / %p: executing bc#%zu, %s, scope %p\n",
+    dataLogF("%p / %p: executing bc#%zu, %s, scope %p\n",
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
             opcodeNames[exec->globalData().interpreter->getOpcodeID(pc[0].u.opcode)],
             exec->scope());
     if (exec->globalData().interpreter->getOpcodeID(pc[0].u.opcode) == op_ret) {
-        dataLog("Will be returning to %p\n", exec->returnPC().value());
-        dataLog("The new cfr will be %p\n", exec->callerFrame());
+        dataLogF("Will be returning to %p\n", exec->returnPC().value());
+        dataLogF("The new cfr will be %p\n", exec->callerFrame());
     }
     LLINT_END_IMPL();
 }
 
 LLINT_SLOW_PATH_DECL(special_trace)
 {
-    dataLog("%p / %p: executing special case bc#%zu, op#%u, return PC is %p\n",
+    dataLogF("%p / %p: executing special case bc#%zu, op#%u, return PC is %p\n",
             exec->codeBlock(),
             exec,
             static_cast<intptr_t>(pc - exec->codeBlock()->instructions().begin()),
@@ -279,7 +279,7 @@ inline bool jitCompileAndSetHeuristics(CodeBlock* codeBlock, ExecState* exec)
     
     if (!codeBlock->checkIfJITThresholdReached()) {
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("    JIT threshold should be lifted.\n");
+        dataLogF("    JIT threshold should be lifted.\n");
 #endif
         return false;
     }
@@ -288,19 +288,19 @@ inline bool jitCompileAndSetHeuristics(CodeBlock* codeBlock, ExecState* exec)
     switch (result) {
     case CodeBlock::AlreadyCompiled:
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("    Code was already compiled.\n");
+        dataLogF("    Code was already compiled.\n");
 #endif
         codeBlock->jitSoon();
         return true;
     case CodeBlock::CouldNotCompile:
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("    JIT compilation failed.\n");
+        dataLogF("    JIT compilation failed.\n");
 #endif
         codeBlock->dontJITAnytimeSoon();
         return false;
     case CodeBlock::CompiledSuccessfully:
 #if ENABLE(JIT_VERBOSE_OSR)
-        dataLog("    JIT compilation successful.\n");
+        dataLogF("    JIT compilation successful.\n");
 #endif
         codeBlock->jitSoon();
         return true;
@@ -313,7 +313,7 @@ enum EntryKind { Prologue, ArityCheck };
 static SlowPathReturnType entryOSR(ExecState* exec, Instruction*, CodeBlock* codeBlock, const char *name, EntryKind kind)
 {
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("%p: Entered %s with executeCounter = %s\n", codeBlock, name,
+    dataLogF("%p: Entered %s with executeCounter = %s\n", codeBlock, name,
             codeBlock->llintExecuteCounter().status());
 #else
     UNUSED_PARAM(name);
@@ -362,7 +362,7 @@ LLINT_SLOW_PATH_DECL(loop_osr)
     CodeBlock* codeBlock = exec->codeBlock();
     
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("%p: Entered loop_osr with executeCounter = %s\n", codeBlock,
+    dataLogF("%p: Entered loop_osr with executeCounter = %s\n", codeBlock,
             codeBlock->llintExecuteCounter().status());
 #endif
     
@@ -393,7 +393,7 @@ LLINT_SLOW_PATH_DECL(replace)
     CodeBlock* codeBlock = exec->codeBlock();
     
 #if ENABLE(JIT_VERBOSE_OSR)
-    dataLog("%p: Entered replace with executeCounter = %s\n", codeBlock,
+    dataLogF("%p: Entered replace with executeCounter = %s\n", codeBlock,
             codeBlock->llintExecuteCounter().status());
 #endif
     
@@ -409,11 +409,11 @@ LLINT_SLOW_PATH_DECL(stack_check)
 {
     LLINT_BEGIN();
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Checking stack height with exec = %p.\n", exec);
-    dataLog("CodeBlock = %p.\n", exec->codeBlock());
-    dataLog("Num callee registers = %u.\n", exec->codeBlock()->m_numCalleeRegisters);
-    dataLog("Num vars = %u.\n", exec->codeBlock()->m_numVars);
-    dataLog("Current end is at %p.\n", exec->globalData().interpreter->stack().end());
+    dataLogF("Checking stack height with exec = %p.\n", exec);
+    dataLogF("CodeBlock = %p.\n", exec->codeBlock());
+    dataLogF("Num callee registers = %u.\n", exec->codeBlock()->m_numCalleeRegisters);
+    dataLogF("Num vars = %u.\n", exec->codeBlock()->m_numVars);
+    dataLogF("Current end is at %p.\n", exec->globalData().interpreter->stack().end());
 #endif
     ASSERT(&exec->registers()[exec->codeBlock()->m_numCalleeRegisters] > exec->globalData().interpreter->stack().end());
     if (UNLIKELY(!globalData.interpreter->stack().grow(&exec->registers()[exec->codeBlock()->m_numCalleeRegisters]))) {
@@ -458,7 +458,7 @@ LLINT_SLOW_PATH_DECL(slow_path_create_activation)
 {
     LLINT_BEGIN();
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Creating an activation, exec = %p!\n", exec);
+    dataLogF("Creating an activation, exec = %p!\n", exec);
 #endif
     JSActivation* activation = JSActivation::create(globalData, exec, exec->codeBlock());
     exec->setScope(activation);
@@ -635,8 +635,8 @@ LLINT_SLOW_PATH_DECL(slow_path_add)
     JSValue v2 = LLINT_OP_C(3).jsValue();
     
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Trying to add %s", v1.description());
-    dataLog(" to %s.\n", v2.description());
+    dataLogF("Trying to add %s", v1.description());
+    dataLogF(" to %s.\n", v2.description());
 #endif
     
     if (v1.isString() && !v2.isObject())
@@ -1328,7 +1328,7 @@ LLINT_SLOW_PATH_DECL(slow_path_new_func)
            || !codeBlock->needsFullScopeChain()
            || exec->uncheckedR(codeBlock->activationRegister()).jsValue());
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Creating function!\n");
+    dataLogF("Creating function!\n");
 #endif
     LLINT_RETURN(JSFunction::create(exec, codeBlock->functionDecl(pc[2].u.operand), exec->scope()));
 }
@@ -1367,7 +1367,7 @@ static SlowPathReturnType handleHostCall(ExecState* execCallee, Instruction* pc,
         }
         
 #if LLINT_SLOW_PATH_TRACING
-        dataLog("Call callee is not a function: %s\n", callee.description());
+        dataLogF("Call callee is not a function: %s\n", callee.description());
 #endif
 
         ASSERT(callType == CallTypeNone);
@@ -1390,7 +1390,7 @@ static SlowPathReturnType handleHostCall(ExecState* execCallee, Instruction* pc,
     }
     
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Constructor callee is not a function: %s\n", callee.description());
+    dataLogF("Constructor callee is not a function: %s\n", callee.description());
 #endif
 
     ASSERT(constructType == ConstructTypeNone);
@@ -1400,7 +1400,7 @@ static SlowPathReturnType handleHostCall(ExecState* execCallee, Instruction* pc,
 inline SlowPathReturnType setUpCall(ExecState* execCallee, Instruction* pc, CodeSpecializationKind kind, JSValue calleeAsValue, LLIntCallLinkInfo* callLinkInfo = 0)
 {
 #if LLINT_SLOW_PATH_TRACING
-    dataLog("Performing call with recorded PC = %p\n", execCallee->callerFrame()->currentVPC());
+    dataLogF("Performing call with recorded PC = %p\n", execCallee->callerFrame()->currentVPC());
 #endif
 
     JSCell* calleeAsFunctionCell = getJSFunction(calleeAsValue);
index a641580..2274889 100644 (file)
@@ -103,7 +103,7 @@ void Profile::restoreAll()
 #ifndef NDEBUG
 void Profile::debugPrintData() const
 {
-    dataLog("Call graph:\n");
+    dataLogF("Call graph:\n");
     m_head->debugPrintData(0);
 }
 
@@ -119,18 +119,18 @@ void Profile::debugPrintDataSampleStyle() const
     typedef Vector<NameCountPair> NameCountPairVector;
 
     FunctionCallHashCount countedFunctions;
-    dataLog("Call graph:\n");
+    dataLogF("Call graph:\n");
     m_head->debugPrintDataSampleStyle(0, countedFunctions);
 
-    dataLog("\nTotal number in stack:\n");
+    dataLogF("\nTotal number in stack:\n");
     NameCountPairVector sortedFunctions(countedFunctions.size());
     copyToVector(countedFunctions, sortedFunctions);
 
     std::sort(sortedFunctions.begin(), sortedFunctions.end(), functionNameCountPairComparator);
     for (NameCountPairVector::iterator it = sortedFunctions.begin(); it != sortedFunctions.end(); ++it)
-        dataLog("        %-12d%s\n", (*it).value, String((*it).key).utf8().data());
+        dataLogF("        %-12d%s\n", (*it).value, String((*it).key).utf8().data());
 
-    dataLog("\nSort by top of stack, same collapsed (when >= 5):\n");
+    dataLogF("\nSort by top of stack, same collapsed (when >= 5):\n");
 }
 #endif
 
index ab43d15..6c36e47 100644 (file)
@@ -294,9 +294,9 @@ void ProfileNode::debugPrintData(int indentLevel) const
 {
     // Print function names
     for (int i = 0; i < indentLevel; ++i)
-        dataLog("  ");
+        dataLogF("  ");
 
-    dataLog("Function Name %s %d SelfTime %.3fms/%.3f%% TotalTime %.3fms/%.3f%% VSelf %.3fms VTotal %.3fms Visible %s Next Sibling %s\n",
+    dataLogF("Function Name %s %d SelfTime %.3fms/%.3f%% TotalTime %.3fms/%.3f%% VSelf %.3fms VTotal %.3fms Visible %s Next Sibling %s\n",
         functionName().utf8().data(), 
         m_numberOfCalls, m_actualSelfTime, selfPercent(), m_actualTotalTime, totalPercent(),
         m_visibleSelfTime, m_visibleTotalTime, 
@@ -313,20 +313,20 @@ void ProfileNode::debugPrintData(int indentLevel) const
 // print the profiled data in a format that matches the tool sample's output.
 double ProfileNode::debugPrintDataSampleStyle(int indentLevel, FunctionCallHashCount& countedFunctions) const
 {
-    dataLog("    ");
+    dataLogF("    ");
 
     // Print function names
     const char* name = functionName().utf8().data();
     double sampleCount = m_actualTotalTime * 1000;
     if (indentLevel) {
         for (int i = 0; i < indentLevel; ++i)
-            dataLog("  ");
+            dataLogF("  ");
 
          countedFunctions.add(functionName().impl());
 
-        dataLog("%.0f %s\n", sampleCount ? sampleCount : 1, name);
+        dataLogF("%.0f %s\n", sampleCount ? sampleCount : 1, name);
     } else
-        dataLog("%s\n", name);
+        dataLogF("%s\n", name);
 
     ++indentLevel;
 
@@ -338,11 +338,11 @@ double ProfileNode::debugPrintDataSampleStyle(int indentLevel, FunctionCallHashC
     sumOfChildrensCount *= 1000;    //
     // Print remainder of samples to match sample's output
     if (sumOfChildrensCount < sampleCount) {
-        dataLog("    ");
+        dataLogF("    ");
         while (indentLevel--)
-            dataLog("  ");
+            dataLogF("  ");
 
-        dataLog("%.0f %s\n", sampleCount - sumOfChildrensCount, functionName().utf8().data());
+        dataLogF("%.0f %s\n", sampleCount - sumOfChildrensCount, functionName().utf8().data());
     }
 
     return m_actualTotalTime;
index 4dca5b0..74429c7 100644 (file)
@@ -507,17 +507,17 @@ void JSGlobalData::dumpRegExpTrace()
     RTTraceList::iterator iter = ++m_rtTraceList->begin();
     
     if (iter != m_rtTraceList->end()) {
-        dataLog("\nRegExp Tracing\n");
-        dataLog("                                                            match()    matches\n");
-        dataLog("Regular Expression                          JIT Address      calls      found\n");
-        dataLog("----------------------------------------+----------------+----------+----------\n");
+        dataLogF("\nRegExp Tracing\n");
+        dataLogF("                                                            match()    matches\n");
+        dataLogF("Regular Expression                          JIT Address      calls      found\n");
+        dataLogF("----------------------------------------+----------------+----------+----------\n");
     
         unsigned reCount = 0;
     
         for (; iter != m_rtTraceList->end(); ++iter, ++reCount)
             (*iter)->printTraceData();
 
-        dataLog("%d Regular Expressions\n", reCount);
+        dataLogF("%d Regular Expressions\n", reCount);
     }
     
     m_rtTraceList->clear();
index 7757274..3229f52 100644 (file)
@@ -520,24 +520,24 @@ void RegExp::matchCompareWithInterpreter(const String& s, int startOffset, int*
             differences++;
 
     if (differences) {
-        dataLog("RegExp Discrepency for /%s/\n    string input ", pattern().utf8().data());
+        dataLogF("RegExp Discrepency for /%s/\n    string input ", pattern().utf8().data());
         unsigned segmentLen = s.length() - static_cast<unsigned>(startOffset);
 
-        dataLog((segmentLen < 150) ? "\"%s\"\n" : "\"%148s...\"\n", s.utf8().data() + startOffset);
+        dataLogF((segmentLen < 150) ? "\"%s\"\n" : "\"%148s...\"\n", s.utf8().data() + startOffset);
 
         if (jitResult != interpreterResult) {
-            dataLog("    JIT result = %d, blah interpreted result = %d\n", jitResult, interpreterResult);
+            dataLogF("    JIT result = %d, blah interpreted result = %d\n", jitResult, interpreterResult);
             differences--;
         } else {
-            dataLog("    Correct result = %d\n", jitResult);
+            dataLogF("    Correct result = %d\n", jitResult);
         }
 
         if (differences) {
             for (unsigned j = 2, i = 0; i < m_numSubpatterns; j +=2, i++) {
                 if (offsetVector[j] != interpreterOffsetVector[j])
-                    dataLog("    JIT offset[%d] = %d, interpreted offset[%d] = %d\n", j, offsetVector[j], j, interpreterOffsetVector[j]);
+                    dataLogF("    JIT offset[%d] = %d, interpreted offset[%d] = %d\n", j, offsetVector[j], j, interpreterOffsetVector[j]);
                 if ((offsetVector[j] >= 0) && (offsetVector[j+1] != interpreterOffsetVector[j+1]))
-                    dataLog("    JIT offset[%d] = %d, interpreted offset[%d] = %d\n", j+1, offsetVector[j+1], j+1, interpreterOffsetVector[j+1]);
+                    dataLogF("    JIT offset[%d] = %d, interpreted offset[%d] = %d\n", j+1, offsetVector[j+1], j+1, interpreterOffsetVector[j+1]);
             }
         }
     }
index abed763..9826b88 100644 (file)
@@ -35,10 +35,10 @@ void AbstractSamplingCounter::dump()
 {
 #if ENABLE(SAMPLING_COUNTERS)
     if (s_abstractSamplingCounterChain != &s_abstractSamplingCounterChainEnd) {
-        dataLog("\nSampling Counter Values:\n");
+        dataLogF("\nSampling Counter Values:\n");
         for (AbstractSamplingCounter* currCounter = s_abstractSamplingCounterChain; (currCounter != &s_abstractSamplingCounterChainEnd); currCounter = currCounter->m_next)
-            dataLog("\t%s\t: %lld\n", currCounter->m_name, currCounter->m_counter);
-        dataLog("\n\n");
+            dataLogF("\t%s\t: %lld\n", currCounter->m_name, currCounter->m_counter);
+        dataLogF("\n\n");
     }
     s_completed = true;
 #endif
index 616dc87..9ffe3b0 100644 (file)
@@ -135,17 +135,17 @@ void Structure::dumpStatistics()
         }
     }
 
-    dataLog("Number of live Structures: %d\n", liveStructureSet.size());
-    dataLog("Number of Structures using the single item optimization for transition map: %d\n", numberUsingSingleSlot);
-    dataLog("Number of Structures that are leaf nodes: %d\n", numberLeaf);
-    dataLog("Number of Structures that singletons: %d\n", numberSingletons);
-    dataLog("Number of Structures with PropertyMaps: %d\n", numberWithPropertyMaps);
-
-    dataLog("Size of a single Structures: %d\n", static_cast<unsigned>(sizeof(Structure)));
-    dataLog("Size of sum of all property maps: %d\n", totalPropertyMapsSize);
-    dataLog("Size of average of all property maps: %f\n", static_cast<double>(totalPropertyMapsSize) / static_cast<double>(liveStructureSet.size()));
+    dataLogF("Number of live Structures: %d\n", liveStructureSet.size());
+    dataLogF("Number of Structures using the single item optimization for transition map: %d\n", numberUsingSingleSlot);
+    dataLogF("Number of Structures that are leaf nodes: %d\n", numberLeaf);
+    dataLogF("Number of Structures that singletons: %d\n", numberSingletons);
+    dataLogF("Number of Structures with PropertyMaps: %d\n", numberWithPropertyMaps);
+
+    dataLogF("Size of a single Structures: %d\n", static_cast<unsigned>(sizeof(Structure)));
+    dataLogF("Size of sum of all property maps: %d\n", totalPropertyMapsSize);
+    dataLogF("Size of average of all property maps: %f\n", static_cast<double>(totalPropertyMapsSize) / static_cast<double>(liveStructureSet.size()));
 #else
-    dataLog("Dumping Structure statistics is not enabled.\n");
+    dataLogF("Dumping Structure statistics is not enabled.\n");
 #endif
 }
 
@@ -695,11 +695,11 @@ static PropertyMapStatisticsExitLogger logger;
 
 PropertyMapStatisticsExitLogger::~PropertyMapStatisticsExitLogger()
 {
-    dataLog("\nJSC::PropertyMap statistics\n\n");
-    dataLog("%d probes\n", numProbes);
-    dataLog("%d collisions (%.1f%%)\n", numCollisions, 100.0 * numCollisions / numProbes);
-    dataLog("%d rehashes\n", numRehashes);
-    dataLog("%d removes\n", numRemoves);
+    dataLogF("\nJSC::PropertyMap statistics\n\n");
+    dataLogF("%d probes\n", numProbes);
+    dataLogF("%d collisions (%.1f%%)\n", numCollisions, 100.0 * numCollisions / numProbes);
+    dataLogF("%d rehashes\n", numRehashes);
+    dataLogF("%d removes\n", numRemoves);
 }
 
 #endif
index 0020c72..b3c4ff4 100644 (file)
@@ -143,7 +143,7 @@ void CodeProfile::sample(void* pc, void** framePointer)
 
 void CodeProfile::report()
 {
-    dataLog("<CodeProfiling %s:%d>\n", m_file.data(), m_lineNo);
+    dataLogF("<CodeProfiling %s:%d>\n", m_file.data(), m_lineNo);
 
     // How many frames of C-code to print - 0, if not verbose, 1 if verbose, up to 1024 if very verbose.
     unsigned recursionLimit = CodeProfiling::beVeryVerbose() ? 1024 : CodeProfiling::beVerbose();
@@ -180,13 +180,13 @@ void CodeProfile::report()
     }
 
     // Output the profile tree.
-    dataLog("Total samples: %lld\n", static_cast<long long>(profile.childCount()));
+    dataLogF("Total samples: %lld\n", static_cast<long long>(profile.childCount()));
     profile.dump();
     
     for (size_t i = 0 ; i < m_children.size(); ++i)
         m_children[i]->report();
 
-    dataLog("</CodeProfiling %s:%d>\n", m_file.data(), m_lineNo);
+    dataLogF("</CodeProfiling %s:%d>\n", m_file.data(), m_lineNo);
 }
 
 }
index 7b5a95e..4daa7df 100644 (file)
@@ -95,8 +95,8 @@ private:
             // Print the number of samples, the name of this node, and the number of samples that are stack-top
             // in this node (samples directly within this node, excluding samples in children.
             for (unsigned i = 0; i < indent; ++i)
-                dataLog("    ");
-            dataLog("% 8lld: %s (%lld stack top)\n",
+                dataLogF("    ");
+            dataLogF("% 8lld: %s (%lld stack top)\n",
                 static_cast<long long>(entry->value.count()),
                 entry->key.utf8().data(),
                 static_cast<long long>(entry->value.count() - entry->value.childCount()));
index 5c2a287..31603f6 100644 (file)
@@ -1650,10 +1650,10 @@ public:
 #ifndef NDEBUG
     void dumpDisjunction(ByteDisjunction* disjunction)
     {
-        dataLog("ByteDisjunction(%p):\n\t", disjunction);
+        dataLogF("ByteDisjunction(%p):\n\t", disjunction);
         for (unsigned i = 0; i < disjunction->terms.size(); ++i)
-            dataLog("{ %d } ", disjunction->terms[i].type);
-        dataLog("\n");
+            dataLogF("{ %d } ", disjunction->terms[i].type);
+        dataLogF("\n");
     }
 #endif
 
index 450e73b..248a01d 100644 (file)
@@ -1,3 +1,32 @@
+2012-11-21  Filip Pizlo  <fpizlo@apple.com>
+
+        Rename dataLog() and dataLogV() to dataLogF() and dataLogFV()
+        https://bugs.webkit.org/show_bug.cgi?id=103001
+
+        Rubber stamped by Dan Bernstein.
+
+        * wtf/DataLog.cpp:
+        (WTF::dataLogFV):
+        (WTF::dataLogF):
+        (WTF::dataLogFString):
+        * wtf/DataLog.h:
+        (WTF):
+        * wtf/HashTable.cpp:
+        (WTF::HashTableStats::dumpStats):
+        * wtf/HashTable.h:
+        (WTF::HashTable::Stats::dumpStats):
+        * wtf/MetaAllocator.cpp:
+        (WTF::MetaAllocator::dumpProfile):
+        * wtf/StackStats.cpp:
+        (WTF::StackStats::initialize):
+        (WTF::StackStats::PerThreadStats::PerThreadStats):
+        (WTF::StackStats::CheckPoint::CheckPoint):
+        (WTF::StackStats::CheckPoint::~CheckPoint):
+        (WTF::StackStats::probe):
+        (WTF::StackStats::LayoutCheckPoint::LayoutCheckPoint):
+        * wtf/text/WTFString.cpp:
+        (String::show):
+
 2012-11-21  Anthony G. Basile  <blueness@gentoo.org>
 
         Source/WTF/wtf/Assertions.cpp: fix build on a uClibc system
index 74b678d..523567c 100644 (file)
@@ -82,20 +82,20 @@ FILE* dataFile()
 }
 #endif // DATA_LOG_TO_FILE
 
-void dataLogV(const char* format, va_list argList)
+void dataLogFV(const char* format, va_list argList)
 {
     vfprintf(dataFile(), format, argList);
 }
 
-void dataLog(const char* format, ...)
+void dataLogF(const char* format, ...)
 {
     va_list argList;
     va_start(argList, format);
-    dataLogV(format, argList);
+    dataLogFV(format, argList);
     va_end(argList);
 }
 
-void dataLogString(const char* str)
+void dataLogFString(const char* str)
 {
     fputs(str, dataFile());
 }
index 11e1d3e..12dd523 100644 (file)
@@ -35,14 +35,14 @@ namespace WTF {
 
 WTF_EXPORT_PRIVATE FILE* dataFile();
 
-WTF_EXPORT_PRIVATE void dataLogV(const char* format, va_list) WTF_ATTRIBUTE_PRINTF(1, 0);
-WTF_EXPORT_PRIVATE void dataLog(const char* format, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
-WTF_EXPORT_PRIVATE void dataLogString(const char*);
+WTF_EXPORT_PRIVATE void dataLogFV(const char* format, va_list) WTF_ATTRIBUTE_PRINTF(1, 0);
+WTF_EXPORT_PRIVATE void dataLogF(const char* format, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
+WTF_EXPORT_PRIVATE void dataLogFString(const char*);
 
 } // namespace WTF
 
-using WTF::dataLog;
-using WTF::dataLogString;
+using WTF::dataLogF;
+using WTF::dataLogFString;
 
 #endif // DataLog_h
 
index ba65efa..518a4c8 100644 (file)
@@ -52,15 +52,15 @@ void HashTableStats::dumpStats()
 {
     MutexLocker lock(hashTableStatsMutex());
 
-    dataLog("\nWTF::HashTable statistics\n\n");
-    dataLog("%d accesses\n", numAccesses);
-    dataLog("%d total collisions, average %.2f probes per access\n", numCollisions, 1.0 * (numAccesses + numCollisions) / numAccesses);
-    dataLog("longest collision chain: %d\n", maxCollisions);
+    dataLogF("\nWTF::HashTable statistics\n\n");
+    dataLogF("%d accesses\n", numAccesses);
+    dataLogF("%d total collisions, average %.2f probes per access\n", numCollisions, 1.0 * (numAccesses + numCollisions) / numAccesses);
+    dataLogF("longest collision chain: %d\n", maxCollisions);
     for (int i = 1; i <= maxCollisions; i++) {
-        dataLog("  %d lookups with exactly %d collisions (%.2f%% , %.2f%% with this many or more)\n", collisionGraph[i], i, 100.0 * (collisionGraph[i] - collisionGraph[i+1]) / numAccesses, 100.0 * collisionGraph[i] / numAccesses);
+        dataLogF("  %d lookups with exactly %d collisions (%.2f%% , %.2f%% with this many or more)\n", collisionGraph[i], i, 100.0 * (collisionGraph[i] - collisionGraph[i+1]) / numAccesses, 100.0 * collisionGraph[i] / numAccesses);
     }
-    dataLog("%d rehashes\n", numRehashes);
-    dataLog("%d reinserts\n", numReinserts);
+    dataLogF("%d rehashes\n", numRehashes);
+    dataLogF("%d reinserts\n", numReinserts);
 }
 
 #endif
index 16fdd9e..6e51b45 100644 (file)
@@ -350,15 +350,15 @@ namespace WTF {
 
             void dumpStats()
             {
-                dataLog("\nWTF::HashTable::Stats dump\n\n");
-                dataLog("%d accesses\n", numAccesses);
-                dataLog("%d total collisions, average %.2f probes per access\n", numCollisions, 1.0 * (numAccesses + numCollisions) / numAccesses);
-                dataLog("longest collision chain: %d\n", maxCollisions);
+                dataLogF("\nWTF::HashTable::Stats dump\n\n");
+                dataLogF("%d accesses\n", numAccesses);
+                dataLogF("%d total collisions, average %.2f probes per access\n", numCollisions, 1.0 * (numAccesses + numCollisions) / numAccesses);
+                dataLogF("longest collision chain: %d\n", maxCollisions);
                 for (int i = 1; i <= maxCollisions; i++) {
-                    dataLog("  %d lookups with exactly %d collisions (%.2f%% , %.2f%% with this many or more)\n", collisionGraph[i], i, 100.0 * (collisionGraph[i] - collisionGraph[i+1]) / numAccesses, 100.0 * collisionGraph[i] / numAccesses);
+                    dataLogF("  %d lookups with exactly %d collisions (%.2f%% , %.2f%% with this many or more)\n", collisionGraph[i], i, 100.0 * (collisionGraph[i] - collisionGraph[i+1]) / numAccesses, 100.0 * collisionGraph[i] / numAccesses);
                 }
-                dataLog("%d rehashes\n", numRehashes);
-                dataLog("%d reinserts\n", numReinserts);
+                dataLogF("%d rehashes\n", numRehashes);
+                dataLogF("%d reinserts\n", numReinserts);
             }
         };
 #endif
index 73b36aa..068acea 100644 (file)
@@ -449,7 +449,7 @@ void MetaAllocator::freeFreeSpaceNode(FreeSpaceNode* node)
 #if ENABLE(META_ALLOCATOR_PROFILE)
 void MetaAllocator::dumpProfile()
 {
-    dataLog("%d: MetaAllocator(%p): num allocations = %u, num frees = %u, allocated = %lu, reserved = %lu, committed = %lu\n",
+    dataLogF("%d: MetaAllocator(%p): num allocations = %u, num frees = %u, allocated = %lu, reserved = %lu, committed = %lu\n",
             getpid(), this, m_numAllocations, m_numFrees, m_bytesAllocated, m_bytesReserved, m_bytesCommitted);
 }
 #endif
index 0bc11ed..824bf46 100644 (file)
@@ -61,7 +61,7 @@ int StackStats::s_maxLayoutReentryDepth = 0;
 void StackStats::initialize()
 {
     s_sharedLock = new Mutex();
-    dataLog(" === LOG new stack stats ========\n");
+    dataLogF(" === LOG new stack stats ========\n");
 }
 
 StackStats::PerThreadStats::PerThreadStats()
@@ -71,7 +71,7 @@ StackStats::PerThreadStats::PerThreadStats()
     m_stackStart = (char*)stack.origin();
     m_currentCheckPoint = 0;
 
-    dataLog(" === THREAD new stackStart %p ========\n", m_stackStart);
+    dataLogF(" === THREAD new stackStart %p ========\n", m_stackStart);
 }
 
 StackStats::CheckPoint::CheckPoint()
@@ -125,7 +125,7 @@ StackStats::CheckPoint::CheckPoint()
 
     // Log this checkpoint if needed:
     if (needToLog)
-        dataLog(" CHECKPOINT %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
+        dataLogF(" CHECKPOINT %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
             this, diff, diff / 1024.0, StackStats::s_maxCheckPointDiff / 1024.0,
             t.m_reentryDepth, StackStats::s_maxReentryDepth,
             height / 1024.0, StackStats::s_maxStackHeight / 1024.0,
@@ -154,7 +154,7 @@ StackStats::CheckPoint::~CheckPoint()
         if (!isGrowingDownward)
             height = -height;
 
-        dataLog(" POP to %p diff max %.1fk | reentry %d/%d max | height %.1fk/max %.1fk | stack %p size %.1fk)\n",
+        dataLogF(" POP to %p diff max %.1fk | reentry %d/%d max | height %.1fk/max %.1fk | stack %p size %.1fk)\n",
             this, StackStats::s_maxCheckPointDiff / 1024.0,
             t.m_reentryDepth, StackStats::s_maxReentryDepth,
             height / 1024.0, StackStats::s_maxStackHeight / 1024.0,
@@ -208,7 +208,7 @@ void StackStats::probe()
 #endif
 
     if (needToLog)
-        dataLog(" PROBE %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
+        dataLogF(" PROBE %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
             current, diff, diff / 1024.0, StackStats::s_maxCheckPointDiff / 1024.0,
             t.m_reentryDepth, StackStats::s_maxReentryDepth,
             height / 1024.0, StackStats::s_maxStackHeight / 1024.0,
@@ -286,7 +286,7 @@ StackStats::LayoutCheckPoint::LayoutCheckPoint()
 #endif
 
     if (needToLog)
-        dataLog(" LAYOUT %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
+        dataLogF(" LAYOUT %p diff %d/%.1fk/max %.1fk | reentry %d/max %d | height %.1fk/max %.1fk | stack %p size %.1fk\n",
             current, diff, diff / 1024.0, StackStats::s_maxLayoutCheckPointDiff / 1024.0,
             m_depth, StackStats::s_maxLayoutReentryDepth,
             totalDiff / 1024.0, StackStats::s_maxTotalLayoutCheckPointDiff / 1024.0,
index 899a44c..5038bf9 100644 (file)
@@ -1213,7 +1213,7 @@ Vector<char> asciiDebug(String& string);
 
 void String::show() const
 {
-    dataLog("%s\n", asciiDebug(impl()).data());
+    dataLogF("%s\n", asciiDebug(impl()).data());
 }
 
 String* string(const char* s)