Changeset 37891 in webkit for trunk/JavaScriptCore

Timestamp:

Oct 25, 2008, 12:59:47 PM (17 years ago)

Author:

[email protected]

Message:

2008-10-25 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig, with Gavin Barraclough's help.

Fixed Sampling Tool:

• Made CodeBlock sampling work with CTI
• Improved accuracy by unifying most sampling data into a single 32bit word, which can be written / read atomically.
• Split out three different #ifdefs for modularity: OPCODE_SAMPLING; CODEBLOCK_SAMPLING; OPCODE_STATS.
• Improved reporting clarity
• Refactored for code clarity

• JavaScriptCore.exp: Exported another symbol.

• VM/CTI.cpp: (JSC::CTI::emitCTICall): (JSC::CTI::compileOpCall): (JSC::CTI::emitSlowScriptCheck): (JSC::CTI::compileBinaryArithOpSlowCase): (JSC::CTI::privateCompileMainPass): (JSC::CTI::privateCompileSlowCases): (JSC::CTI::privateCompile):
• VM/CTI.h: Updated CTI codegen to use the unified SamplingTool interface for encoding samples. (This required passing the current vPC to a lot more functions, since the unified interface samples the current vPC.) Added hooks for writing the current CodeBlock* on function entry and after a function call, for the sake of the CodeBlock sampler. Removed obsolete hook for clearing the current sample inside op_end. Also removed the custom enum used to differentiate flavors of op_call, since the OpcodeID enum works just as well. (This was important in an earlier version of the patch, but now it's just cleanup.)

• VM/CodeBlock.cpp: (JSC::CodeBlock::lineNumberForVPC):
• VM/CodeBlock.h: Upated for refactored #ifdefs. Changed lineNumberForVPC to be robust against vPCs not recorded for exception handling, since the Sampler may ask for an arbitrary vPC.

• VM/Machine.cpp: (JSC::Machine::execute): (JSC::Machine::privateExecute): (JSC::Machine::cti_op_call_NotJSFunction): (JSC::Machine::cti_op_construct_NotJSConstruct):
• VM/Machine.h: (JSC::Machine::setSampler): (JSC::Machine::sampler): (JSC::Machine::jitCodeBuffer): Upated for refactored #ifdefs. Changed Machine to use SamplingTool helper objects to record movement in and out of host code. This makes samples a bit more precise.

• VM/Opcode.cpp: (JSC::OpcodeStats::~OpcodeStats):
• VM/Opcode.h: Upated for refactored #ifdefs. Added a little more padding, to accomodate our more verbose opcode names.

• VM/SamplingTool.cpp: (JSC::ScopeSampleRecord::sample): Only count a sample toward our total if we actually record it. This solves cases where a CodeBlock will claim to have been sampled many times, with reported samples that don't match.

(JSC::SamplingTool::run): Read the current sample into a Sample helper
object, to ensure that the data doesn't change while we're analyzing it,
and to help decode the data. Only access the CodeBlock sampling hash
table if CodeBlock sampling has been enabled, so non-CodeBlock sampling
runs can operate with even less overhead.

(JSC::SamplingTool::dump): I reorganized this code a lot to print the
most important info at the top, print as a table, annotate and document
the stuff I didn't understand when I started, etc.

• VM/SamplingTool.h: New helper classes, described above.

• kjs/Parser.h:
• kjs/Shell.cpp: (runWithScripts):
• kjs/nodes.cpp: (JSC::ScopeNode::ScopeNode): Updated for new sampling APIs.

• wtf/Platform.h: Moved sampling #defines here, since our custom is to put ENABLE #defines into Platform.h. Made explicit the fact that CODEBLOCK_SAMPLING depends on OPCODE_SAMPLING.

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• JavaScriptCore.exp (modified) (1 diff)
• VM/CTI.cpp (modified) (119 diffs)
• VM/CTI.h (modified) (4 diffs)
• VM/CodeBlock.cpp (modified) (4 diffs)
• VM/CodeBlock.h (modified) (2 diffs)
• VM/Machine.cpp (modified) (14 diffs)
• VM/Machine.h (modified) (2 diffs)
• VM/Opcode.cpp (modified) (6 diffs)
• VM/Opcode.h (modified) (3 diffs)
• VM/SamplingTool.cpp (modified) (8 diffs)
• VM/SamplingTool.h (modified) (5 diffs)
• kjs/Parser.h (modified) (1 diff)
• kjs/Shell.cpp (modified) (3 diffs)
• kjs/nodes.cpp (modified) (2 diffs)
• wtf/Platform.h (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-10-25  Geoffrey Garen  <[email protected]>
+
+        Reviewed by Sam Weinig, with Gavin Barraclough's help.
+        
+        Fixed Sampling Tool:
+            - Made CodeBlock sampling work with CTI
+            - Improved accuracy by unifying most sampling data into a single
+              32bit word, which can be written / read atomically.
+            - Split out three different #ifdefs for modularity: OPCODE_SAMPLING;
+              CODEBLOCK_SAMPLING; OPCODE_STATS.
+            - Improved reporting clarity
+            - Refactored for code clarity
+
+        * JavaScriptCore.exp: Exported another symbol.
+
+        * VM/CTI.cpp:
+        (JSC::CTI::emitCTICall):
+        (JSC::CTI::compileOpCall):
+        (JSC::CTI::emitSlowScriptCheck):
+        (JSC::CTI::compileBinaryArithOpSlowCase):
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileSlowCases):
+        (JSC::CTI::privateCompile):
+        * VM/CTI.h: Updated CTI codegen to use the unified SamplingTool interface
+        for encoding samples. (This required passing the current vPC to a lot
+        more functions, since the unified interface samples the current vPC.)
+        Added hooks for writing the current CodeBlock* on function entry and
+        after a function call, for the sake of the CodeBlock sampler. Removed
+        obsolete hook for clearing the current sample inside op_end. Also removed
+        the custom enum used to differentiate flavors of op_call, since the
+        OpcodeID enum works just as well. (This was important in an earlier
+        version of the patch, but now it's just cleanup.)
+
+        * VM/CodeBlock.cpp:
+        (JSC::CodeBlock::lineNumberForVPC):
+        * VM/CodeBlock.h: Upated for refactored #ifdefs. Changed lineNumberForVPC
+        to be robust against vPCs not recorded for exception handling, since
+        the Sampler may ask for an arbitrary vPC.
+
+        * VM/Machine.cpp:
+        (JSC::Machine::execute):
+        (JSC::Machine::privateExecute):
+        (JSC::Machine::cti_op_call_NotJSFunction):
+        (JSC::Machine::cti_op_construct_NotJSConstruct):
+        * VM/Machine.h:
+        (JSC::Machine::setSampler):
+        (JSC::Machine::sampler):
+        (JSC::Machine::jitCodeBuffer): Upated for refactored #ifdefs. Changed
+        Machine to use SamplingTool helper objects to record movement in and
+        out of host code. This makes samples a bit more precise.
+        
+        * VM/Opcode.cpp:
+        (JSC::OpcodeStats::~OpcodeStats):
+        * VM/Opcode.h: Upated for refactored #ifdefs. Added a little more padding,
+        to accomodate our more verbose opcode names.
+
+        * VM/SamplingTool.cpp:
+        (JSC::ScopeSampleRecord::sample): Only count a sample toward our total
+        if we actually record it. This solves cases where a CodeBlock will
+        claim to have been sampled many times, with reported samples that don't
+        match.
+
+        (JSC::SamplingTool::run): Read the current sample into a Sample helper
+        object, to ensure that the data doesn't change while we're analyzing it,
+        and to help decode the data. Only access the CodeBlock sampling hash
+        table if CodeBlock sampling has been enabled, so non-CodeBlock sampling
+        runs can operate with even less overhead.
+
+        (JSC::SamplingTool::dump): I reorganized this code a lot to print the
+        most important info at the top, print as a table, annotate and document
+        the stuff I didn't understand when I started, etc.
+
+        * VM/SamplingTool.h: New helper classes, described above.
+
+        * kjs/Parser.h:
+        * kjs/Shell.cpp:
+        (runWithScripts):
+        * kjs/nodes.cpp:
+        (JSC::ScopeNode::ScopeNode): Updated for new sampling APIs.
+
+        * wtf/Platform.h: Moved sampling #defines here, since our custom is to
+        put ENABLE #defines into Platform.h. Made explicit the fact that
+        CODEBLOCK_SAMPLING depends on OPCODE_SAMPLING.
+
 2008-10-25  Jan Michael Alonzo  <[email protected]>
 

trunk/JavaScriptCore/JavaScriptCore.exp

@@ -125 +125 @@
 __ZN3JSC12JSGlobalData6createEv
 __ZN3JSC12JSGlobalDataD1Ev
+__ZN3JSC12SamplingTool13notifyOfScopeEPNS_9ScopeNodeE
 __ZN3JSC12SamplingTool4dumpEPNS_9ExecStateE
 __ZN3JSC12SamplingTool4stopEv

trunk/JavaScriptCore/VM/CTI.cpp

@@ -35 +35 @@
 #include "wrec/WREC.h"
 #include "ResultType.h"
+#include "SamplingTool.h"
 
 #ifndef NDEBUG
@@ -262 +263 @@
     // FIXME: #ifndef NDEBUG, Write the correct m_type to the register.
 }
-
-#if ENABLE(SAMPLING_TOOL)
-unsigned inCalledCode = 0;
-#endif
 
 void ctiSetReturnAddress(void** where, void* what)
@@ -330 +327 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_j helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_j helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -339 +338 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -346 +345 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_o helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_o helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -355 +356 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -362 +363 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_p helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_p helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -371 +374 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -378 +381 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_b helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_b helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -387 +392 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -394 +399 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_v helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_v helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -403 +410 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -410 +417 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_s helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_s helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -419 +428 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -426 +435 @@
 }
 
-ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(unsigned opcodeIndex, CTIHelper_2 helper)
-{
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(1, &inCalledCode);
+ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned opcodeIndex, CTIHelper_2 helper)
+{
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, true), m_machine->sampler()->sampleSlot());
+#else
+    UNUSED_PARAM(vPC);
 #endif
     m_jit.emitRestoreArgumentReference();
@@ -435 +446 @@
     X86Assembler::JmpSrc call = m_jit.emitCall();
     m_calls.append(CallRecord(call, helper, opcodeIndex));
-#if ENABLE(SAMPLING_TOOL)
-    m_jit.movl_i32m(0, &inCalledCode);
+#if ENABLE(OPCODE_SAMPLING)
+    m_jit.movl_i32m(m_machine->sampler()->encodeSample(vPC, false), m_machine->sampler()->sampleSlot());
 #endif
 
@@ -527 +538 @@
         emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, Machine::cti_##name); \
         emitPutResult(instruction[i + 1].u.operand); \
         i += 4; \
@@ -536 +547 @@
     case name: { \
         emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
-        emitCTICall(i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, Machine::cti_##name); \
         emitPutResult(instruction[i + 1].u.operand); \
         i += 3; \
         break; \
     }
-
-#if ENABLE(SAMPLING_TOOL)
-OpcodeID currentOpcodeID = static_cast<OpcodeID>(-1);
-#endif
 
 static void unreachable()
@@ -582 +589 @@
 }
 
-void CTI::compileOpCall(Instruction* instruction, unsigned i, unsigned callLinkInfoIndex, CompileOpCallType type)
+void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex)
 {
     int dst = instruction[1].u.operand;
@@ -591 +598 @@
 
     // Setup this value as the first argument (does not apply to constructors)
-    if (type != OpConstruct) {
+    if (opcodeID != op_construct) {
         int thisVal = instruction[3].u.operand;
         if (thisVal == missingThisObjectMarker()) {
@@ -604 +611 @@
     // Handle eval
     X86Assembler::JmpSrc wasEval;
-    if (type == OpCallEval) {
+    if (opcodeID == op_call_eval) {
         emitGetArg(callee, X86::ecx);
         compileOpCallSetupArgs(instruction, false, true);
 
-        emitCTICall(i, Machine::cti_op_call_eval);
+        emitCTICall(instruction, i, Machine::cti_op_call_eval);
         m_jit.cmpl_i32r(asInteger(JSImmediate::impossibleValue()), X86::eax);
         wasEval = m_jit.emitUnlinkedJne();
@@ -625 +632 @@
 
     // In the case of OpConstruct, call oout to a cti_ function to create the new object.
-    if (type == OpConstruct) {
+    if (opcodeID == op_construct) {
         emitPutArg(X86::ecx, 0);
         emitGetPutArg(instruction[3].u.operand, 4, X86::eax);
-        emitCTICall(i, Machine::cti_op_construct_JSConstructFast);
+        emitCTICall(instruction, i, Machine::cti_op_construct_JSConstructFast);
         emitPutResult(instruction[4].u.operand);
         emitGetArg(callee, X86::ecx);
@@ -646 +653 @@
     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall(i, unreachable);
     
-    if (type == OpCallEval)
+    if (opcodeID == op_call_eval)
         m_jit.link(wasEval, m_jit.label());
 
     // Put the return value in dst. In the interpreter, op_ret does this.
     emitPutResult(dst);
+
+#if ENABLE(CODEBLOCK_SAMPLING)
+        m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
+#endif
 }
 
@@ -709 +720 @@
 }
 
-void CTI::emitSlowScriptCheck(unsigned opcodeIndex)
+void CTI::emitSlowScriptCheck(Instruction* vPC, unsigned opcodeIndex)
 {
     m_jit.subl_i8r(1, X86::esi);
     X86Assembler::JmpSrc skipTimeout = m_jit.emitUnlinkedJne();
-    emitCTICall(opcodeIndex, Machine::cti_timeout_check);
+    emitCTICall(vPC, opcodeIndex, Machine::cti_timeout_check);
 
     emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
@@ -906 +917 @@
 }
 
-void CTI::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
+void CTI::compileBinaryArithOpSlowCase(Instruction* vPC, OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
 {
     X86Assembler::JmpDst here = m_jit.label();
@@ -940 +951 @@
     emitGetPutArg(src2, 4, X86::ecx);
     if (opcodeID == op_add)
-        emitCTICall(i, Machine::cti_op_add);
+        emitCTICall(vPC, i, Machine::cti_op_add);
     else if (opcodeID == op_sub)
-        emitCTICall(i, Machine::cti_op_sub);
+        emitCTICall(vPC, i, Machine::cti_op_sub);
     else {
         ASSERT(opcodeID == op_mul);
-        emitCTICall(i, Machine::cti_op_mul);
+        emitCTICall(vPC, i, Machine::cti_op_mul);
     }
     emitPutResult(dst);
@@ -959 +970 @@
 
     for (unsigned i = 0; i < instructionCount; ) {
+        ASSERT_WITH_MESSAGE(m_machine->isOpcode(instruction[i].u.opcode), "privateCompileMainPass gone bad @ %d", i);
+
+#if ENABLE(OPCODE_SAMPLING)
+        m_jit.movl_i32m(m_machine->sampler()->encodeSample(instruction + i), m_machine->sampler()->sampleSlot());
+#endif
+
         m_labels[i] = m_jit.label();
-
-#if ENABLE(SAMPLING_TOOL)
-        m_jit.movl_i32m(m_machine->getOpcodeID(instruction[i].u.opcode), &currentOpcodeID);
-#endif
-
-        ASSERT_WITH_MESSAGE(m_machine->isOpcode(instruction[i].u.opcode), "privateCompileMainPass gone bad @ %d", i);
-        switch (m_machine->getOpcodeID(instruction[i].u.opcode)) {
+        OpcodeID opcodeID = m_machine->getOpcodeID(instruction[i].u.opcode);
+        switch (opcodeID) {
         case op_mov: {
             unsigned src = instruction[i + 2].u.operand;
@@ -1001 +1013 @@
                     emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
                     emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
-                    emitCTICall(i, Machine::cti_op_add);
+                    emitCTICall(instruction + i, i, Machine::cti_op_add);
                     emitPutResult(instruction[i + 1].u.operand);
                 }
@@ -1011 +1023 @@
         case op_end: {
             if (m_codeBlock->needsFullScopeChain)
-                emitCTICall(i, Machine::cti_op_end);
+                emitCTICall(instruction + i, i, Machine::cti_op_end);
             emitGetArg(instruction[i + 1].u.operand, X86::eax);
-#if ENABLE(SAMPLING_TOOL)
-            m_jit.movl_i32m(-1, &currentOpcodeID);
-#endif
             m_jit.pushl_m(RegisterFile::ReturnPC * static_cast<int>(sizeof(Register)), X86::edi);
             m_jit.ret();
@@ -1038 +1047 @@
         }
         case op_loop: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             unsigned target = instruction[i + 1].u.operand;
@@ -1046 +1055 @@
         }
         case op_loop_if_less: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             unsigned target = instruction[i + 3].u.operand;
@@ -1067 +1076 @@
         }
         case op_loop_if_lesseq: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             unsigned target = instruction[i + 3].u.operand;
@@ -1088 +1097 @@
         }
         case op_new_object: {
-            emitCTICall(i, Machine::cti_op_new_object);
+            emitCTICall(instruction + i, i, Machine::cti_op_new_object);
             emitPutResult(instruction[i + 1].u.operand);
             i += 2;
@@ -1214 +1223 @@
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
-            emitCTICall(i, Machine::cti_op_del_by_id);
+            emitCTICall(instruction + i, i, Machine::cti_op_del_by_id);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -1253 +1262 @@
             FuncDeclNode* func = (m_codeBlock->functions[instruction[i + 2].u.operand]).get();
             emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
-            emitCTICall(i, Machine::cti_op_new_func);
+            emitCTICall(instruction + i, i, Machine::cti_op_new_func);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1259 +1268 @@
         }
         case op_call: {
-            compileOpCall(instruction + i, i, callLinkInfoIndex++);
+            compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
             i += 7;
             break;
@@ -1307 +1316 @@
         case op_tear_off_activation: {
             emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(i, Machine::cti_op_tear_off_activation);
+            emitCTICall(instruction + i, i, Machine::cti_op_tear_off_activation);
             i += 2;
             break;
         }
         case op_tear_off_arguments: {
-            emitCTICall(i, Machine::cti_op_tear_off_arguments);
+            emitCTICall(instruction + i, i, Machine::cti_op_tear_off_arguments);
             i += 1;
             break;
@@ -1319 +1328 @@
             // We could JIT generate the deref, only calling out to C when the refcount hits zero.
             if (m_codeBlock->needsFullScopeChain)
-                emitCTICall(i, Machine::cti_op_ret_scopeChain);
+                emitCTICall(instruction + i, i, Machine::cti_op_ret_scopeChain);
 
             // Return the result in %eax.
@@ -1341 +1350 @@
             emitPutArg(X86::edx, 0);
             emitPutArgConstant(instruction[i + 3].u.operand, 4);
-            emitCTICall(i, Machine::cti_op_new_array);
+            emitCTICall(instruction + i, i, Machine::cti_op_new_array);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -1349 +1358 @@
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(i, Machine::cti_op_resolve);
+            emitCTICall(instruction + i, i, Machine::cti_op_resolve);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1355 +1364 @@
         }
         case op_construct: {
-            compileOpCall(instruction + i, i, callLinkInfoIndex++, OpConstruct);
+            compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
             i += 7;
             break;
@@ -1400 +1409 @@
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(i, Machine::cti_op_resolve_func);
+            emitCTICall(instruction + i, i, Machine::cti_op_resolve_func);
             emitPutResult(instruction[i + 1].u.operand);
             emitPutResult(instruction[i + 2].u.operand, X86::edx);
@@ -1443 +1452 @@
         CTI_COMPILE_BINARY_OP(op_lesseq)
         case op_loop_if_true: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             unsigned target = instruction[i + 2].u.operand;
@@ -1465 +1474 @@
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 2].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(i, Machine::cti_op_resolve_base);
+            emitCTICall(instruction + i, i, Machine::cti_op_resolve_base);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1472 +1481 @@
         case op_negate: {
             emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
-            emitCTICall(i, Machine::cti_op_negate);
+            emitCTICall(instruction + i, i, Machine::cti_op_negate);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1481 +1490 @@
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
             emitPutArgConstant(instruction[i + 3].u.operand + m_codeBlock->needsFullScopeChain, 4);
-            emitCTICall(i, Machine::cti_op_resolve_skip);
+            emitCTICall(instruction + i, i, Machine::cti_op_resolve_skip);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -1511 +1520 @@
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitPutArgConstant(reinterpret_cast<unsigned>(instruction + i), 8);
-            emitCTICall(i, Machine::cti_op_resolve_global);
+            emitCTICall(instruction + i, i, Machine::cti_op_resolve_global);
             emitPutResult(instruction[i + 1].u.operand);
             m_jit.link(end, m_jit.label());
@@ -1742 +1751 @@
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
-            emitCTICall(i, Machine::cti_op_resolve_with_base);
+            emitCTICall(instruction + i, i, Machine::cti_op_resolve_with_base);
             emitPutResult(instruction[i + 1].u.operand);
             emitPutResult(instruction[i + 2].u.operand, X86::edx);
@@ -1751 +1760 @@
             FuncExprNode* func = (m_codeBlock->functionExpressions[instruction[i + 2].u.operand]).get();
             emitPutArgConstant(reinterpret_cast<unsigned>(func), 0);
-            emitCTICall(i, Machine::cti_op_new_func_exp);
+            emitCTICall(instruction + i, i, Machine::cti_op_new_func_exp);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1831 +1840 @@
             RegExp* regExp = m_codeBlock->regexps[instruction[i + 2].u.operand].get();
             emitPutArgConstant(reinterpret_cast<unsigned>(regExp), 0);
-            emitCTICall(i, Machine::cti_op_new_regexp);
+            emitCTICall(instruction + i, i, Machine::cti_op_new_regexp);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1846 +1855 @@
         }
         case op_call_eval: {
-            compileOpCall(instruction + i, i, callLinkInfoIndex++, OpCallEval);
+            compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
             i += 7;
             break;
@@ -1852 +1861 @@
         case op_throw: {
             emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(i, Machine::cti_op_throw);
+            emitCTICall(instruction + i, i, Machine::cti_op_throw);
             m_jit.addl_i8r(0x20, X86::esp);
             m_jit.popl_r(X86::ebx);
@@ -1863 +1872 @@
         case op_get_pnames: {
             emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
-            emitCTICall(i, Machine::cti_op_get_pnames);
+            emitCTICall(instruction + i, i, Machine::cti_op_get_pnames);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -1871 +1880 @@
             emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
             unsigned target = instruction[i + 3].u.operand;
-            emitCTICall(i, Machine::cti_op_next_pname);
+            emitCTICall(instruction + i, i, Machine::cti_op_next_pname);
             m_jit.testl_rr(X86::eax, X86::eax);
             X86Assembler::JmpSrc endOfIter = m_jit.emitUnlinkedJe();
@@ -1882 +1891 @@
         case op_push_scope: {
             emitGetPutArg(instruction[i + 1].u.operand, 0, X86::ecx);
-            emitCTICall(i, Machine::cti_op_push_scope);
+            emitCTICall(instruction + i, i, Machine::cti_op_push_scope);
             i += 2;
             break;
         }
         case op_pop_scope: {
-            emitCTICall(i, Machine::cti_op_pop_scope);
+            emitCTICall(instruction + i, i, Machine::cti_op_pop_scope);
             i += 1;
             break;
@@ -1930 +1939 @@
             emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
             emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
-            emitCTICall(i, Machine::cti_op_in);
+            emitCTICall(instruction + i, i, Machine::cti_op_in);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -1939 +1948 @@
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 0);
             emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
-            emitCTICall(i, Machine::cti_op_push_new_scope);
+            emitCTICall(instruction + i, i, Machine::cti_op_push_new_scope);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -1953 +1962 @@
             unsigned count = instruction[i + 1].u.operand;
             emitPutArgConstant(count, 0);
-            emitCTICall(i, Machine::cti_op_jmp_scopes);
+            emitCTICall(instruction + i, i, Machine::cti_op_jmp_scopes);
             unsigned target = instruction[i + 2].u.operand;
             m_jmpTable.append(JmpTable(m_jit.emitUnlinkedJmp(), i + 2 + target));
@@ -1963 +1972 @@
             emitPutArgConstant(instruction[i + 2].u.operand, 4);
             emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
-            emitCTICall(i, Machine::cti_op_put_by_index);
+            emitCTICall(instruction + i, i, Machine::cti_op_put_by_index);
             i += 4;
             break;
@@ -1979 +1988 @@
             emitGetPutArg(scrutinee, 0, X86::ecx);
             emitPutArgConstant(tableIndex, 4);
-            emitCTICall(i, Machine::cti_op_switch_imm);
+            emitCTICall(instruction + i, i, Machine::cti_op_switch_imm);
             m_jit.jmp_r(X86::eax);
             i += 4;
@@ -1996 +2005 @@
             emitGetPutArg(scrutinee, 0, X86::ecx);
             emitPutArgConstant(tableIndex, 4);
-            emitCTICall(i, Machine::cti_op_switch_char);
+            emitCTICall(instruction + i, i, Machine::cti_op_switch_char);
             m_jit.jmp_r(X86::eax);
             i += 4;
@@ -2012 +2021 @@
             emitGetPutArg(scrutinee, 0, X86::ecx);
             emitPutArgConstant(tableIndex, 4);
-            emitCTICall(i, Machine::cti_op_switch_string);
+            emitCTICall(instruction + i, i, Machine::cti_op_switch_string);
             m_jit.jmp_r(X86::eax);
             i += 4;
@@ -2020 +2029 @@
             emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx);
             emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
-            emitCTICall(i, Machine::cti_op_del_by_val);
+            emitCTICall(instruction + i, i, Machine::cti_op_del_by_val);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2030 +2039 @@
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
-            emitCTICall(i, Machine::cti_op_put_getter);
+            emitCTICall(instruction + i, i, Machine::cti_op_put_getter);
             i += 4;
             break;
@@ -2039 +2048 @@
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
             emitGetPutArg(instruction[i + 3].u.operand, 8, X86::ecx);
-            emitCTICall(i, Machine::cti_op_put_setter);
+            emitCTICall(instruction + i, i, Machine::cti_op_put_setter);
             i += 4;
             break;
@@ -2048 +2057 @@
             emitPutArgConstant(asInteger(message), 4);
             emitPutArgConstant(m_codeBlock->lineNumberForVPC(&instruction[i]), 8);
-            emitCTICall(i, Machine::cti_op_new_error);
+            emitCTICall(instruction + i, i, Machine::cti_op_new_error);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2057 +2066 @@
             emitPutArgConstant(instruction[i + 2].u.operand, 4);
             emitPutArgConstant(instruction[i + 3].u.operand, 8);
-            emitCTICall(i, Machine::cti_op_debug);
+            emitCTICall(instruction + i, i, Machine::cti_op_debug);
             i += 4;
             break;
@@ -2140 +2149 @@
                 emitInitRegister(j);
 
-            emitCTICall(i, Machine::cti_op_push_activation);
+            emitCTICall(instruction + i, i, Machine::cti_op_push_activation);
             emitPutResult(instruction[i + 1].u.operand);
 
@@ -2147 +2156 @@
         }
         case op_create_arguments: {
-            emitCTICall(i, (m_codeBlock->numParameters == 1) ? Machine::cti_op_create_arguments_no_params : Machine::cti_op_create_arguments);
+            emitCTICall(instruction + i, i, (m_codeBlock->numParameters == 1) ? Machine::cti_op_create_arguments_no_params : Machine::cti_op_create_arguments);
             i += 1;
             break;
@@ -2167 +2176 @@
             X86Assembler::JmpSrc noProfiler = m_jit.emitUnlinkedJe();
             emitGetPutArg(instruction[i + 1].u.operand, 0, X86::eax);
-            emitCTICall(i, Machine::cti_op_profile_will_call);
+            emitCTICall(instruction + i, i, Machine::cti_op_profile_will_call);
             m_jit.link(noProfiler, m_jit.label());
 
@@ -2178 +2187 @@
             X86Assembler::JmpSrc noProfiler = m_jit.emitUnlinkedJe();
             emitGetPutArg(instruction[i + 1].u.operand, 0, X86::eax);
-            emitCTICall(i, Machine::cti_op_profile_did_call);
+            emitCTICall(instruction + i, i, Machine::cti_op_profile_did_call);
             m_jit.link(noProfiler, m_jit.label());
 
@@ -2215 +2224 @@
         emitGetPutArg(instruction[i + 2].u.operand, 0, X86::ecx); \
         emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx); \
-        emitCTICall(i, Machine::cti_##name); \
+        emitCTICall(instruction + i, i, Machine::cti_##name); \
         emitPutResult(instruction[i + 1].u.operand); \
         i += 4; \
@@ -2234 +2243 @@
             m_jit.link((++iter)->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_convert_this);
+            emitCTICall(instruction + i, i, Machine::cti_op_convert_this);
             emitPutResult(instruction[i + 1].u.operand);
             i += 2;
@@ -2250 +2259 @@
                 emitGetPutArg(src1, 0, X86::ecx);
                 emitPutArg(X86::edx, 4);
-                emitCTICall(i, Machine::cti_op_add);
+                emitCTICall(instruction + i, i, Machine::cti_op_add);
                 emitPutResult(dst);
             } else if (JSValue* value = getConstantImmediateNumericArg(src2)) {
@@ -2259 +2268 @@
                 emitPutArg(X86::eax, 0);
                 emitGetPutArg(src2, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_add);
+                emitCTICall(instruction + i, i, Machine::cti_op_add);
                 emitPutResult(dst);
             } else {
                 OperandTypes types = OperandTypes::fromInt(instruction[i + 4].u.operand);
                 if (types.first().mightBeNumber() && types.second().mightBeNumber())
-                    compileBinaryArithOpSlowCase(op_add, iter, dst, src1, src2, types, i);
+                    compileBinaryArithOpSlowCase(instruction, op_add, iter, dst, src1, src2, types, i);
                 else
                     ASSERT_NOT_REACHED();
@@ -2283 +2292 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::edx, 4);
-            emitCTICall(i, Machine::cti_op_get_by_val);
+            emitCTICall(instruction + i, i, Machine::cti_op_get_by_val);
             emitPutResult(instruction[i + 1].u.operand);
             m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
@@ -2304 +2313 @@
         }
         case op_sub: {
-            compileBinaryArithOpSlowCase(op_sub, iter, instruction[i + 1].u.operand, instruction[i + 2].u.operand, instruction[i + 3].u.operand, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
+            compileBinaryArithOpSlowCase(instruction, op_sub, iter, instruction[i + 1].u.operand, instruction[i + 2].u.operand, instruction[i + 3].u.operand, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
             i += 5;
             break;
@@ -2313 +2322 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::ecx, 4);
-            emitCTICall(i, Machine::cti_op_rshift);
+            emitCTICall(instruction + i, i, Machine::cti_op_rshift);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2328 +2337 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::ecx, 4);
-            emitCTICall(i, Machine::cti_op_lshift);
+            emitCTICall(instruction + i, i, Machine::cti_op_lshift);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2334 +2343 @@
         }
         case op_loop_if_less: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             unsigned target = instruction[i + 3].u.operand;
@@ -2342 +2351 @@
                 emitPutArg(X86::edx, 0);
                 emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_loop_if_less);
+                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_less);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
@@ -2350 +2359 @@
                 emitPutArg(X86::eax, 0);
                 emitPutArg(X86::edx, 4);
-                emitCTICall(i, Machine::cti_op_loop_if_less);
+                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_less);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
@@ -2365 +2374 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::edx, 8);
-            X86Assembler::JmpSrc call = emitCTICall(i, Machine::cti_op_put_by_id);
+            X86Assembler::JmpSrc call = emitCTICall(instruction + i, i, Machine::cti_op_put_by_id);
 
             // Track the location of the call; this will be used to recover repatch information.
@@ -2391 +2400 @@
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
             emitPutArgConstant(reinterpret_cast<unsigned>(ident), 4);
-            X86Assembler::JmpSrc call = emitCTICall(i, Machine::cti_op_get_by_id);
+            X86Assembler::JmpSrc call = emitCTICall(instruction + i, i, Machine::cti_op_get_by_id);
             ASSERT(X86Assembler::getDifferenceBetweenLabels(coldPathBegin, call) == repatchOffsetGetByIdSlowCaseCall);
             emitPutResult(instruction[i + 1].u.operand);
@@ -2404 +2413 @@
         }
         case op_loop_if_lesseq: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             unsigned target = instruction[i + 3].u.operand;
@@ -2412 +2421 @@
                 emitPutArg(X86::edx, 0);
                 emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_loop_if_lesseq);
+                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_lesseq);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
@@ -2420 +2429 @@
                 emitPutArg(X86::eax, 0);
                 emitPutArg(X86::edx, 4);
-                emitCTICall(i, Machine::cti_op_loop_if_lesseq);
+                emitCTICall(instruction + i, i, Machine::cti_op_loop_if_lesseq);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJne(), m_labels[i + 3 + target]);
@@ -2434 +2443 @@
             m_jit.link(notImm, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_pre_inc);
+            emitCTICall(instruction + i, i, Machine::cti_op_pre_inc);
             emitPutResult(srcDst);
             i += 2;
@@ -2450 +2459 @@
             emitPutArg(X86::edx, 4);
             emitPutArg(X86::ecx, 8);
-            emitCTICall(i, Machine::cti_op_put_by_val);
+            emitCTICall(instruction + i, i, Machine::cti_op_put_by_val);
             m_jit.link(m_jit.emitUnlinkedJmp(), m_labels[i + 4]);
 
@@ -2460 +2469 @@
             emitPutArg(X86::edx, 4);
             emitPutArg(X86::ecx, 8);
-            emitCTICall(i, Machine::cti_op_put_by_val_array);
+            emitCTICall(instruction + i, i, Machine::cti_op_put_by_val_array);
 
             i += 4;
@@ -2466 +2475 @@
         }
         case op_loop_if_true: {
-            emitSlowScriptCheck(i);
+            emitSlowScriptCheck(instruction, i);
 
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_jtrue);
+            emitCTICall(instruction + i, i, Machine::cti_op_jtrue);
             m_jit.testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
@@ -2484 +2493 @@
             m_jit.link(notImm, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_pre_dec);
+            emitCTICall(instruction + i, i, Machine::cti_op_pre_dec);
             emitPutResult(srcDst);
             i += 2;
@@ -2496 +2505 @@
                 emitPutArg(X86::edx, 0);
                 emitGetPutArg(instruction[i + 2].u.operand, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_jless);
+                emitCTICall(instruction + i, i, Machine::cti_op_jless);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
@@ -2504 +2513 @@
                 emitPutArg(X86::eax, 0);
                 emitPutArg(X86::edx, 4);
-                emitCTICall(i, Machine::cti_op_jless);
+                emitCTICall(instruction + i, i, Machine::cti_op_jless);
                 m_jit.testl_rr(X86::eax, X86::eax);
                 m_jit.link(m_jit.emitUnlinkedJe(), m_labels[i + 3 + target]);
@@ -2515 +2524 @@
             m_jit.xorl_i8r(JSImmediate::FullTagTypeBool, X86::eax);
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_not);
+            emitCTICall(instruction + i, i, Machine::cti_op_not);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -2523 +2532 @@
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_jtrue);
+            emitCTICall(instruction + i, i, Machine::cti_op_jtrue);
             m_jit.testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
@@ -2535 +2544 @@
             m_jit.link((++iter)->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_post_inc);
+            emitCTICall(instruction + i, i, Machine::cti_op_post_inc);
             emitPutResult(instruction[i + 1].u.operand);
             emitPutResult(srcDst, X86::edx);
@@ -2544 +2553 @@
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_bitnot);
+            emitCTICall(instruction + i, i, Machine::cti_op_bitnot);
             emitPutResult(instruction[i + 1].u.operand);
             i += 3;
@@ -2557 +2566 @@
                 emitGetPutArg(src1, 0, X86::ecx);
                 emitPutArg(X86::eax, 4);
-                emitCTICall(i, Machine::cti_op_bitand);
+                emitCTICall(instruction + i, i, Machine::cti_op_bitand);
                 emitPutResult(dst);
             } else if (getConstantImmediateNumericArg(src2)) {
@@ -2563 +2572 @@
                 emitPutArg(X86::eax, 0);
                 emitGetPutArg(src2, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_bitand);
+                emitCTICall(instruction + i, i, Machine::cti_op_bitand);
                 emitPutResult(dst);
             } else {
@@ -2569 +2578 @@
                 emitGetPutArg(src1, 0, X86::ecx);
                 emitPutArg(X86::edx, 4);
-                emitCTICall(i, Machine::cti_op_bitand);
+                emitCTICall(instruction + i, i, Machine::cti_op_bitand);
                 emitPutResult(dst);
             }
@@ -2578 +2587 @@
             m_jit.link(iter->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_jtrue);
+            emitCTICall(instruction + i, i, Machine::cti_op_jtrue);
             m_jit.testl_rr(X86::eax, X86::eax);
             unsigned target = instruction[i + 2].u.operand;
@@ -2590 +2599 @@
             m_jit.link((++iter)->from, m_jit.label());
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_post_dec);
+            emitCTICall(instruction + i, i, Machine::cti_op_post_dec);
             emitPutResult(instruction[i + 1].u.operand);
             emitPutResult(srcDst, X86::edx);
@@ -2600 +2609 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::edx, 4);
-            emitCTICall(i, Machine::cti_op_bitxor);
+            emitCTICall(instruction + i, i, Machine::cti_op_bitxor);
             emitPutResult(instruction[i + 1].u.operand);
             i += 5;
@@ -2609 +2618 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::edx, 4);
-            emitCTICall(i, Machine::cti_op_bitor);
+            emitCTICall(instruction + i, i, Machine::cti_op_bitor);
             emitPutResult(instruction[i + 1].u.operand);
             i += 5;
@@ -2618 +2627 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::edx, 4);
-            emitCTICall(i, Machine::cti_op_eq);
+            emitCTICall(instruction + i, i, Machine::cti_op_eq);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2627 +2636 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::edx, 4);
-            emitCTICall(i, Machine::cti_op_neq);
+            emitCTICall(instruction + i, i, Machine::cti_op_neq);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2639 +2648 @@
             emitGetPutArg(instruction[i + 3].u.operand, 4, X86::ecx);
             emitGetPutArg(instruction[i + 4].u.operand, 8, X86::ecx);
-            emitCTICall(i, Machine::cti_op_instanceof);
+            emitCTICall(instruction + i, i, Machine::cti_op_instanceof);
             emitPutResult(instruction[i + 1].u.operand);
             i += 5;
@@ -2654 +2663 @@
             emitPutArg(X86::eax, 0);
             emitPutArg(X86::ecx, 4);
-            emitCTICall(i, Machine::cti_op_mod);
+            emitCTICall(instruction + i, i, Machine::cti_op_mod);
             emitPutResult(instruction[i + 1].u.operand);
             i += 4;
@@ -2671 +2680 @@
                 emitGetPutArg(src1, 0, X86::ecx);
                 emitGetPutArg(src2, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_mul);
+                emitCTICall(instruction + i, i, Machine::cti_op_mul);
                 emitPutResult(dst);
             } else if (src2Value && ((value = JSImmediate::intValue(src2Value)) > 0)) {
@@ -2678 +2687 @@
                 emitGetPutArg(src1, 0, X86::ecx);
                 emitGetPutArg(src2, 4, X86::ecx);
-                emitCTICall(i, Machine::cti_op_mul);
+                emitCTICall(instruction + i, i, Machine::cti_op_mul);
                 emitPutResult(dst);
             } else
-                compileBinaryArithOpSlowCase(op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
+                compileBinaryArithOpSlowCase(instruction, op_mul, iter, dst, src1, src2, OperandTypes::fromInt(instruction[i + 4].u.operand), i);
             i += 5;
             break;
@@ -2706 +2715 @@
 
             // This handles JSFunctions
-            emitCTICall(i, (opcodeID == op_construct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
+            emitCTICall(instruction + i, i, (opcodeID == op_construct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
             // initialize the new call frame (pointed to by edx, after the last call), then set edi to point to it.
             compileOpCallInitializeCallFrame(callee, argCount);
@@ -2715 +2724 @@
             emitPutArgConstant(reinterpret_cast<unsigned>(info), 4);
             m_callStructureStubCompilationInfo[callLinkInfoIndex].callReturnLocation =
-                emitCTICall(i, Machine::cti_vm_lazyLinkCall);
+                emitCTICall(instruction + i, i, Machine::cti_vm_lazyLinkCall);
             emitNakedCall(i, X86::eax);
             X86Assembler::JmpSrc storeResultForFirstRun = m_jit.emitUnlinkedJmp();
@@ -2737 +2746 @@
             m_jit.link(callLinkFailNotObject, notJSFunctionlabel);
             m_jit.link(callLinkFailNotJSFunction, notJSFunctionlabel);
-            emitCTICall(i, ((opcodeID == op_construct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
+            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? Machine::cti_op_construct_NotJSConstruct : Machine::cti_op_call_NotJSFunction));
             X86Assembler::JmpSrc wasNotJSFunction = m_jit.emitUnlinkedJmp();
 
             // Next, handle JSFunctions...
             m_jit.link(isJSFunction, m_jit.label());
-            emitCTICall(i, (opcodeID == op_construct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
+            emitCTICall(instruction + i, i, (opcodeID == op_construct) ? Machine::cti_op_construct_JSConstruct : Machine::cti_op_call_JSFunction);
             // initialize the new call frame (pointed to by edx, after the last call).
             compileOpCallInitializeCallFrame(callee, argCount);
@@ -2756 +2765 @@
             m_jit.testl_rr(X86::eax, X86::eax);
             X86Assembler::JmpSrc hasCode = m_jit.emitUnlinkedJne();
-            emitCTICall(i, Machine::cti_vm_compile);
+            emitCTICall(instruction + i, i, Machine::cti_vm_compile);
             m_jit.link(hasCode, m_jit.label());
 
@@ -2767 +2776 @@
             emitPutResult(dst);
 
+#if ENABLE(CODEBLOCK_SAMPLING)
+            m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
+#endif
             ++callLinkInfoIndex;
+
             i += 7;
             break;
@@ -2776 +2789 @@
 
             emitPutArg(X86::eax, 0);
-            emitCTICall(i, Machine::cti_op_to_jsnumber);
+            emitCTICall(instruction + i, i, Machine::cti_op_to_jsnumber);
 
             emitPutResult(instruction[i + 1].u.operand);
@@ -2797 +2810 @@
 void CTI::privateCompile()
 {
+#if ENABLE(CODEBLOCK_SAMPLING)
+        m_jit.movl_i32m(reinterpret_cast<unsigned>(m_codeBlock), m_machine->sampler()->codeBlockSlot());
+#endif
+#if ENABLE(OPCODE_SAMPLING)
+        m_jit.movl_i32m(m_machine->sampler()->encodeSample(m_codeBlock->instructions.begin()), m_machine->sampler()->sampleSlot());
+#endif
+
     // Could use a popl_m, but would need to offset the following instruction if so.
     m_jit.popl_r(X86::ecx);
@@ -2820 +2840 @@
     if (m_codeBlock->codeType == FunctionCode) {
         m_jit.link(slowRegisterFileCheck, m_jit.label());
-        emitCTICall(0, Machine::cti_register_file_check);
+        emitCTICall(m_codeBlock->instructions.begin(), 0, Machine::cti_register_file_check);
         X86Assembler::JmpSrc backToBody = m_jit.emitUnlinkedJmp();
         m_jit.link(backToBody, afterRegisterFileCheck);

trunk/JavaScriptCore/VM/CTI.h

@@ -267 +267 @@
         static const int repatchOffsetGetByIdBranchToSlowCase = 25;
         static const int repatchOffsetGetByIdPropertyMapOffset = 34;
-#if ENABLE(SAMPLING_TOOL)
+#if ENABLE(OPCODE_SAMPLING)
         static const int repatchOffsetGetByIdSlowCaseCall = 27 + 4 + ctiArgumentInitSize;
 #else
@@ -366 +366 @@
         void privateCompilePatchGetArrayLength(void* returnAddress);
 
-        enum CompileOpCallType { OpCallNormal, OpCallEval, OpConstruct };
-        void compileOpCall(Instruction* instruction, unsigned i, unsigned structureIDInstructionIndex, CompileOpCallType type = OpCallNormal);
+        void compileOpCall(OpcodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex);
         void compileOpCallInitializeCallFrame(unsigned callee, unsigned argCount);
         void compileOpCallSetupArgs(Instruction* instruction, bool isConstruct, bool isEval);
@@ -374 +373 @@
         void putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSource, X86::RegisterID jsNumberCell, unsigned dst, X86Assembler::JmpSrc* wroteJSNumberCell,  X86::XMMRegisterID tempXmm, X86::RegisterID tempReg1, X86::RegisterID tempReg2);
         void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
-        void compileBinaryArithOpSlowCase(OpcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
+        void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector<SlowCaseEntry>::iterator& iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
 
         void emitGetArg(int src, X86Assembler::RegisterID dst);
@@ -412 +411 @@
         X86Assembler::JmpSrc emitNakedCall(unsigned opcodeIndex, X86::RegisterID);
         X86Assembler::JmpSrc emitNakedCall(unsigned opcodeIndex, void(*function)());
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_j);
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_o);
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_p);
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_v);
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_s);
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_b);
-        X86Assembler::JmpSrc emitCTICall(unsigned opcodeIndex, CTIHelper_2);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_j);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_o);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_p);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_v);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_s);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_b);
+        X86Assembler::JmpSrc emitCTICall(Instruction*, unsigned opcodeIndex, CTIHelper_2);
 
         void emitGetVariableObjectRegister(X86Assembler::RegisterID variableObject, int index, X86Assembler::RegisterID dst);
         void emitPutVariableObjectRegister(X86Assembler::RegisterID src, X86Assembler::RegisterID variableObject, int index);
         
-        void emitSlowScriptCheck(unsigned opcodeIndex);
+        void emitSlowScriptCheck(Instruction*, unsigned opcodeIndex);
 #ifndef NDEBUG
         void printOpcodeOperandTypes(unsigned src1, unsigned src2);

trunk/JavaScriptCore/VM/CodeBlock.cpp

@@ -40 +40 @@
 namespace JSC {
 
-#if !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
+#if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
 
 static UString escapeQuotes(const UString& str)
@@ -947 +947 @@
 }
 
-#endif // !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
+#endif // !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
 
 CodeBlock::~CodeBlock()
@@ -1111 +1111 @@
 int CodeBlock::lineNumberForVPC(const Instruction* vPC)
 {
-    ASSERT(lineInfo.size());    
     unsigned instructionOffset = vPC - instructions.begin();
     ASSERT(instructionOffset < instructions.size());
 
     if (!lineInfo.size())
-        return 1; // Empty function
+        return ownerNode->source().firstLine(); // Empty function
 
     int low = 0;
@@ -1127 +1126 @@
             high = mid;
     }
+    
+    if (!low)
+        return ownerNode->source().firstLine();
     return lineInfo[low - 1].lineNumber;
 }

trunk/JavaScriptCore/VM/CodeBlock.h

@@ -290 +290 @@
         }
 
-#if !defined(NDEBUG) || ENABLE_SAMPLING_TOOL
+#if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
         void dump(ExecState*) const;
         void printStructureIDs(const Instruction*) const;
@@ -362 +362 @@
 
     private:
-#if !defined(NDEBUG) || ENABLE(SAMPLING_TOOL)
+#if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
         void dump(ExecState*, const Vector<Instruction>::const_iterator& begin, Vector<Instruction>::const_iterator&) const;
 #endif

trunk/JavaScriptCore/VM/Machine.cpp

@@ -924 +924 @@
         (*profiler)->willExecute(newCallFrame, programNode->sourceURL(), programNode->lineNo());
 
-    m_reentryDepth++;
+    JSValue* result;
+    {
+        SamplingTool::CallRecord callRecord(m_sampler);
+
+        m_reentryDepth++;
 #if ENABLE(CTI)
-    if (!codeBlock->ctiCode)
-        CTI::compile(this, newCallFrame, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
+        if (!codeBlock->ctiCode)
+            CTI::compile(this, newCallFrame, codeBlock);
+        result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
+        result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
 #endif
-    m_reentryDepth--;
-
-    MACHINE_SAMPLING_privateExecuteReturned();
+        m_reentryDepth--;
+    }
 
     if (*profiler)
@@ -987 +990 @@
         (*profiler)->willExecute(newCallFrame, function);
 
-    m_reentryDepth++;
+    JSValue* result;
+    {
+        SamplingTool::CallRecord callRecord(m_sampler);
+
+        m_reentryDepth++;
 #if ENABLE(CTI)
-    if (!codeBlock->ctiCode)
-        CTI::compile(this, newCallFrame, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
+        if (!codeBlock->ctiCode)
+            CTI::compile(this, newCallFrame, codeBlock);
+        result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
+        result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
 #endif
-    m_reentryDepth--;
+        m_reentryDepth--;
+    }
 
     if (*profiler)
         (*profiler)->didExecute(newCallFrame, function);
-
-    MACHINE_SAMPLING_privateExecuteReturned();
 
     m_registerFile.shrink(oldEnd);
@@ -1076 +1082 @@
         (*profiler)->willExecute(newCallFrame, evalNode->sourceURL(), evalNode->lineNo());
 
-    m_reentryDepth++;
+    JSValue* result;
+    {
+        SamplingTool::CallRecord callRecord(m_sampler);
+
+        m_reentryDepth++;
 #if ENABLE(CTI)
-    if (!codeBlock->ctiCode)
-        CTI::compile(this, newCallFrame, codeBlock);
-    JSValue* result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
+        if (!codeBlock->ctiCode)
+            CTI::compile(this, newCallFrame, codeBlock);
+        result = CTI::execute(codeBlock->ctiCode, &m_registerFile, newCallFrame, scopeChain->globalData, exception);
 #else
-    JSValue* result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
+        result = privateExecute(Normal, &m_registerFile, newCallFrame, exception);
 #endif
-    m_reentryDepth--;
-
-    MACHINE_SAMPLING_privateExecuteReturned();
+        m_reentryDepth--;
+    }
 
     if (*profiler)
@@ -1473 +1482 @@
     } while (0)
 
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
     OpcodeStats::resetLastInstruction();
 #endif
@@ -1483 +1492 @@
         tickCount = m_ticksUntilNextTimeoutCheck; \
     }
+    
+#if ENABLE(OPCODE_SAMPLING)
+    #define SAMPLE(codeBlock, vPC) m_sampler->sample(codeBlock, vPC)
+    #define CTI_SAMPLER ARG_globalData->machine->sampler()
+#else
+    #define SAMPLE(codeBlock, vPC)
+    #define CTI_SAMPLER
+#endif
 
 #if HAVE(COMPUTED_GOTO)
-    #define NEXT_OPCODE MACHINE_SAMPLING_sample(callFrame->codeBlock(), vPC); goto *vPC->u.opcode
-#if DUMP_OPCODE_STATS
+    #define NEXT_OPCODE SAMPLE(callFrame->codeBlock(), vPC); goto *vPC->u.opcode
+#if ENABLE(OPCODE_STATS)
     #define BEGIN_OPCODE(opcode) opcode: OpcodeStats::recordInstruction(opcode);
 #else
@@ -1493 +1510 @@
     NEXT_OPCODE;
 #else
-    #define NEXT_OPCODE MACHINE_SAMPLING_sample(callFrame->codeBlock(), vPC); goto interpreterLoopStart
-#if DUMP_OPCODE_STATS
+    #define NEXT_OPCODE SAMPLE(callFrame->codeBlock(), vPC); goto interpreterLoopStart
+#if ENABLE(OPCODE_STATS)
     #define BEGIN_OPCODE(opcode) case opcode: OpcodeStats::recordInstruction(opcode);
 #else
@@ -2959 +2976 @@
            the JS timeout is reached.
          */
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
         OpcodeStats::resetLastInstruction();
 #endif
@@ -2973 +2990 @@
            instruction.
         */
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
         OpcodeStats::resetLastInstruction();
 #endif
@@ -3354 +3371 @@
             vPC = newCodeBlock->instructions.begin();
 
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
             OpcodeStats::resetLastInstruction();
 #endif
@@ -3369 +3386 @@
             newCallFrame->init(0, vPC + 7, scopeChain, callFrame, dst, argCount, 0);
 
-            MACHINE_SAMPLING_callingHostFunction();
-
-            JSValue* returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args);
+            JSValue* returnValue;
+            {
+                SamplingTool::HostCallRecord callRecord(m_sampler);
+                returnValue = callData.native.function(newCallFrame, asObject(v), thisValue, args);
+            }
             VM_CHECK_EXCEPTION();
 
@@ -3599 +3618 @@
             vPC = newCodeBlock->instructions.begin();
 
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
             OpcodeStats::resetLastInstruction();
 #endif
@@ -3613 +3632 @@
             newCallFrame->init(0, vPC + 7, scopeChain, callFrame, dst, argCount, 0);
 
-            MACHINE_SAMPLING_callingHostFunction();
-
-            JSValue* returnValue = constructData.native.function(newCallFrame, asObject(v), args);
-
+            JSValue* returnValue;
+            {
+                SamplingTool::HostCallRecord callRecord(m_sampler);
+                returnValue = constructData.native.function(newCallFrame, asObject(v), args);
+            }
             VM_CHECK_EXCEPTION();
             callFrame[dst] = returnValue;
@@ -4795 +4815 @@
         ArgList argList(argv + 1, argCount - 1);
 
-        CTI_MACHINE_SAMPLING_callingHostFunction();
-
-        JSValue* returnValue = callData.native.function(callFrame, asObject(funcVal), argv[0].jsValue(callFrame), argList);
+        JSValue* returnValue;
+        {
+            SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
+            returnValue = callData.native.function(callFrame, asObject(funcVal), argv[0].jsValue(callFrame), argList);
+        }
         ARG_setCallFrame(previousCallFrame);
         VM_CHECK_EXCEPTION();
@@ -5000 +5022 @@
         ArgList argList(callFrame->registers() + firstArg + 1, argCount - 1);
 
-        CTI_MACHINE_SAMPLING_callingHostFunction();
-
-        JSValue* returnValue = constructData.native.function(callFrame, asObject(constrVal), argList);
+        JSValue* returnValue;
+        {
+            SamplingTool::HostCallRecord callRecord(CTI_SAMPLER);
+            returnValue = constructData.native.function(callFrame, asObject(constrVal), argList);
+        }
         VM_CHECK_EXCEPTION();
 

trunk/JavaScriptCore/VM/Machine.h

@@ -158 +158 @@
         }
 
-        SamplingTool* m_sampler;
+        void setSampler(SamplingTool* sampler) { m_sampler = sampler; }
+        SamplingTool* sampler() { return m_sampler; }
 
 #if ENABLE(CTI)
@@ -319 +320 @@
         void* getCTIStringLengthTrampoline(CallFrame*, CodeBlock*);
 
+        JITCodeBuffer* jitCodeBuffer() const { return m_jitCodeBuffer.get(); }
+#endif
+
+        SamplingTool* m_sampler;
+
+#if ENABLE(CTI)
         void* m_ctiArrayLengthTrampoline;
         void* m_ctiStringLengthTrampoline;
 
         OwnPtr<JITCodeBuffer> m_jitCodeBuffer;
-        JITCodeBuffer* jitCodeBuffer() const { return m_jitCodeBuffer.get(); }
 #endif
 

trunk/JavaScriptCore/VM/Opcode.cpp

@@ -35 +35 @@
 namespace JSC {
 
-#if ENABLE(SAMPLING_TOOL) || DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_SAMPLING) || ENABLE(CODEBLOCK_SAMPLING) || ENABLE(OPCODE_STATS)
 
 const char* const opcodeNames[] = {
@@ -45 +45 @@
 #endif
 
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
 
 long long OpcodeStats::opcodeCounts[numOpcodeIDs];
@@ -122 +122 @@
     for (int i = 0; i < numOpcodeIDs; ++i) {
         int index = sortedIndices[i];
-        printf("%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 24), opcodeCounts[index], ((double) opcodeCounts[index]) / ((double) totalInstructions) * 100.0);    
+        printf("%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCounts[index], ((double) opcodeCounts[index]) / ((double) totalInstructions) * 100.0);    
     }
     
@@ -135 +135 @@
             break;
         
-        printf("%s%s %s:%s %lld %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 24), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 24), count, ((double) count) / ((double) totalInstructionPairs) * 100.0);
+        printf("%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);
     }
     
@@ -147 +147 @@
         if (opcodeProportion < 0.0001)
             break;
-        printf("\n%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 24), opcodeCount, opcodeProportion * 100.0);
+        printf("\n%s:%s %lld - %.2f%%\n", opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCount, opcodeProportion * 100.0);
 
         for (int j = 0; j < numOpcodeIDs * numOpcodeIDs; ++j) {
@@ -160 +160 @@
                 continue;
 
-            printf("    %s%s %s:%s %lld - %.2f%%\n", opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 24), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 24), pairCount, pairProportion * 100.0);
+            printf("    %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);
         }
         

trunk/JavaScriptCore/VM/Opcode.h

@@ -38 +38 @@
 namespace JSC {
 
-#define DUMP_OPCODE_STATS 0
-
     #define FOR_EACH_OPCODE_ID(macro) \
         macro(op_enter) \
@@ -183 +181 @@
 #endif
 
-#if ENABLE(SAMPLING_TOOL) || DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_SAMPLING) || ENABLE(CODEBLOCK_SAMPLING) || ENABLE(OPCODE_STATS)
 
 #define PADDING_STRING "                                "
@@ -202 +200 @@
 #endif
 
-#if DUMP_OPCODE_STATS
+#if ENABLE(OPCODE_STATS)
 
     struct OpcodeStats {

trunk/JavaScriptCore/VM/SamplingTool.cpp

@@ -42 +42 @@
 void ScopeSampleRecord::sample(CodeBlock* codeBlock, Instruction* vPC)
 {
-    m_totalCount++;
-
     if (!m_vpcCounts) {
         m_size = codeBlock->instructions.size();
@@ -50 +48 @@
     }
 
-    unsigned codeOffset = static_cast<unsigned>(reinterpret_cast<ptrdiff_t>(vPC) - reinterpret_cast<ptrdiff_t>(codeBlock->instructions.begin())) / sizeof(Instruction*);
-    // This could occur if codeBlock & vPC are not consistent - e.g. sample mid op_call/op_ret.
-    if (codeOffset < m_size)
+    unsigned codeOffset = vPC - codeBlock->instructions.begin();
+    // Since we don't read and write codeBlock and vPC atomically, this check
+    // can fail if we sample mid op_call / op_ret.
+    if (codeOffset < m_size) {
         m_vpcCounts[codeOffset]++;
+        m_totalCount++;
+    }
 }
 
@@ -80 +81 @@
 }
 
-#if ENABLE(SAMPLING_TOOL)
-unsigned totalOpcodeIDCount = 0;
-unsigned opcodeIDCountInCalledCode[numOpcodeIDs] = {0};
-unsigned opcodeIDCountInJITCode[numOpcodeIDs] = {0};
-#endif
-
 void SamplingTool::run()
 {
@@ -91 +86 @@
         sleepForMicroseconds(hertz2us(m_hertz));
 
-        m_totalSamples++;
-#if ENABLE(SAMPLING_TOOL)
-        if (currentOpcodeID != static_cast<OpcodeID>(-1)) {
-            ++totalOpcodeIDCount;
-            if (inCalledCode)
-                opcodeIDCountInCalledCode[currentOpcodeID]++;
-            else
-                opcodeIDCountInJITCode[currentOpcodeID]++;
+        Sample sample(m_sample, m_codeBlock);
+        ++m_sampleCount;
+
+        if (sample.isNull())
+            continue;
+
+        if (!sample.inHostFunction()) {
+            unsigned opcodeID = m_machine->getOpcodeID(sample.vPC()[0].u.opcode);
+
+            ++m_opcodeSampleCount;
+            ++m_opcodeSamples[opcodeID];
+
+            if (sample.inCTIFunction())
+                m_opcodeSamplesInCTIFunctions[opcodeID]++;
         }
-#endif        
-        CodeBlock* codeBlock = m_recordedCodeBlock;
-        Instruction* vPC = m_recordedVPC;
-
-        if (codeBlock && vPC) {
-            if (ScopeSampleRecord* record = m_scopeSampleMap->get(codeBlock->ownerNode))
-                record->sample(codeBlock, vPC);
-        }
+
+#if ENABLE(CODEBLOCK_SAMPLING)
+        ScopeSampleRecord* record = m_scopeSampleMap->get(sample.codeBlock()->ownerNode);
+        ASSERT(record);
+        record->sample(sample.codeBlock(), sample.vPC());
+#endif
     }
 }
@@ -138 +137 @@
 }
 
-#if ENABLE(SAMPLING_TOOL)
+#if ENABLE(OPCODE_SAMPLING)
 
 struct OpcodeSampleInfo {
     OpcodeID opcode;
     long long count;
-    long long countInCalledCode;
+    long long countInCTIFunctions;
 };
 
@@ -178 +177 @@
 {
     // Tidies up SunSpider output by removing short scripts - such a small number of samples would likely not be useful anyhow.
-    if (m_totalSamples < 10)
+    if (m_sampleCount < 10)
         return;
     
-    // (1) Calculate 'totalCodeBlockSamples', build and sort 'codeBlockSamples' array.
+    // (1) Build and sort 'opcodeSampleInfo' array.
+
+    OpcodeSampleInfo opcodeSampleInfo[numOpcodeIDs];
+    for (int i = 0; i < numOpcodeIDs; ++i) {
+        opcodeSampleInfo[i].opcode = static_cast<OpcodeID>(i);
+        opcodeSampleInfo[i].count = m_opcodeSamples[i];
+        opcodeSampleInfo[i].countInCTIFunctions = m_opcodeSamplesInCTIFunctions[i];
+    }
+
+    qsort(opcodeSampleInfo, numOpcodeIDs, sizeof(OpcodeSampleInfo), compareOpcodeIndicesSampling);
+
+    // (2) Print Opcode sampling results.
+
+    printf("\nOpcode samples [*]\n");
+    printf("                             sample   %% of       %% of     |   cti     cti %%\n");
+    printf("opcode                       count     VM        total    |  count   of self\n");
+    printf("-------------------------------------------------------   |  ----------------\n");
+
+    for (int i = 0; i < numOpcodeIDs; ++i) {
+        long long count = opcodeSampleInfo[i].count;
+        if (!count)
+            continue;
+
+        OpcodeID opcode = opcodeSampleInfo[i].opcode;
+        
+        const char* opcodeName = opcodeNames[opcode];
+        const char* opcodePadding = padOpcodeName(opcode, 28);
+        double percentOfVM = (static_cast<double>(count) * 100) / m_opcodeSampleCount;
+        double percentOfTotal = (static_cast<double>(count) * 100) / m_sampleCount;
+        long long countInCTIFunctions = opcodeSampleInfo[i].countInCTIFunctions;
+        double percentInCTIFunctions = (static_cast<double>(countInCTIFunctions) * 100) / count;
+        fprintf(stdout, "%s:%s%-6lld %.3f%%\t%.3f%%\t  |   %-6lld %.3f%%\n", opcodeName, opcodePadding, count, percentOfVM, percentOfTotal, countInCTIFunctions, percentInCTIFunctions);
+    }
+    
+    printf("\n[*] Samples inside host code are not charged to any Opcode.\n\n");
+    printf("\tSamples inside VM:\t\t%lld / %lld (%.3f%%)\n", m_opcodeSampleCount, m_sampleCount, (static_cast<double>(m_opcodeSampleCount) * 100) / m_sampleCount);
+    printf("\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);
+    printf("\tsample count:\tsamples inside this opcode\n");
+    printf("\t%% of VM:\tsample count / all opcode samples\n");
+    printf("\t%% of total:\tsample count / all samples\n");
+    printf("\t--------------\n");
+    printf("\tcti count:\tsamples inside a CTI function called by this opcode\n");
+    printf("\tcti %% of self:\tcti count / sample count\n");
+    
+    // (3) Calculate 'codeBlockSampleCount', build and sort 'codeBlockSamples' array.
 
     int scopeCount = m_scopeSampleMap->size();
-    long long totalCodeBlockSamples = 0;
+    long long codeBlockSampleCount = 0;
     Vector<ScopeSampleRecord*> codeBlockSamples(scopeCount);
     ScopeSampleRecordMap::iterator iter = m_scopeSampleMap->begin();
     for (int i = 0; i < scopeCount; ++i, ++iter) {
         codeBlockSamples[i] = iter->second;
-        totalCodeBlockSamples += codeBlockSamples[i]->m_totalCount;
+        codeBlockSampleCount += codeBlockSamples[i]->m_totalCount;
     }
 
     qsort(codeBlockSamples.begin(), scopeCount, sizeof(ScopeSampleRecord*), compareScopeSampleRecords);
 
-    // (2) Print data from 'codeBlockSamples' array, calculate 'totalOpcodeSamples', populate 'opcodeSampleCounts' array.
-
-    long long totalOpcodeSamples = 0;
-    long long opcodeSampleCounts[numOpcodeIDs] = { 0 };
-
-    printf("\nBlock sampling results\n\n"); 
-    printf("Total blocks sampled (total samples): %lld (%lld)\n\n", totalCodeBlockSamples, m_totalSamples);
+    // (4) Print data from 'codeBlockSamples' array.
+
+    printf("\nCodeBlock samples [*]\n\n"); 
 
     for (int i = 0; i < scopeCount; ++i) {
@@ -206 +245 @@
         CodeBlock* codeBlock = record->m_codeBlock;
 
-        double totalPercent = (record->m_totalCount * 100.0)/m_totalSamples;
-        double blockPercent = (record->m_totalCount * 100.0)/totalCodeBlockSamples;
-
-        if ((blockPercent >= 1) && codeBlock) {
+        double blockPercent = (record->m_totalCount * 100.0) / codeBlockSampleCount;
+
+        if (blockPercent >= 1) {
             Instruction* code = codeBlock->instructions.begin();
-            printf("#%d: %s:%d: sampled %d times - %.3f%% (%.3f%%)\n", i + 1, record->m_scope->sourceURL().UTF8String().c_str(), codeBlock->lineNumberForVPC(code), record->m_totalCount, blockPercent, totalPercent);
+            printf("#%d: %s:%d: %d / %lld (%.3f%%)\n", i + 1, record->m_scope->sourceURL().UTF8String().c_str(), codeBlock->lineNumberForVPC(code), record->m_totalCount, codeBlockSampleCount, blockPercent);
             if (i < 10) {
                 HashMap<unsigned,unsigned> lineCounts;
@@ -240 +278 @@
             }
         }
-        
-        if (record->m_vpcCounts && codeBlock) {
-            Instruction* instructions = codeBlock->instructions.begin();
-            for (unsigned op = 0; op < record->m_size; ++op) {
-                Opcode opcode = instructions[op].u.opcode;
-                if (exec->machine()->isOpcode(opcode)) {
-                    totalOpcodeSamples += record->m_vpcCounts[op];
-                    opcodeSampleCounts[exec->machine()->getOpcodeID(opcode)] += record->m_vpcCounts[op];
-                }
-            }
-        }
-    }
-    printf("\n");
-
-    // (3) Build and sort 'opcodeSampleInfo' array.
-
-    OpcodeSampleInfo opcodeSampleInfo[numOpcodeIDs];
-    for (int i = 0; i < numOpcodeIDs; ++i) {
-        opcodeSampleInfo[i].opcode = static_cast<OpcodeID>(i);
-        opcodeSampleInfo[i].count = opcodeIDCountInJITCode[i] + opcodeIDCountInCalledCode[i];
-        opcodeSampleInfo[i].countInCalledCode = opcodeIDCountInCalledCode[i];
-    }
-
-    qsort(opcodeSampleInfo, numOpcodeIDs, sizeof(OpcodeSampleInfo), compareOpcodeIndicesSampling);
-
-    // (4) Print Opcode sampling results.
-
-    printf("\nOpcode sampling results\n\n"); 
-
-    for (int i = 0; i < numOpcodeIDs; ++i) {
-        OpcodeID opcode = opcodeSampleInfo[i].opcode;
-        long long count = opcodeSampleInfo[i].count;
-        long long countInCalledCode = opcodeSampleInfo[i].countInCalledCode;
-        fprintf(stdout, "%s:%s%6lld\t%6lld\t%.3f%%\t%.3f%%\t(%.3f%%)\n", opcodeNames[opcode], padOpcodeName(opcode, 20), count, countInCalledCode, (static_cast<double>(count) * 100) / totalOpcodeIDCount, (static_cast<double>(count) * 100) / m_totalSamples, (static_cast<double>(countInCalledCode) * 100) / m_totalSamples);    
-    }
-    printf("\n");
+    }
+
+    printf("\n[*] Samples inside host code are charged to the calling Opcode.\n");
+    printf("    Samples that fall on a call / return boundary are discarded.\n\n");
+    printf("\tSamples discarded:\t\t%lld / %lld (%.3f%%)\n\n", m_sampleCount - codeBlockSampleCount, m_sampleCount, (static_cast<double>(m_sampleCount - codeBlockSampleCount) * 100) / m_sampleCount);
 }
 

trunk/JavaScriptCore/VM/SamplingTool.h

@@ -34 +34 @@
 #include <wtf/Threading.h>
 
-#include <nodes.h>
-#include <Opcode.h>
+#include "nodes.h"
+#include "Opcode.h"
 
 namespace JSC {
 
+    class CodeBlock;
     class ExecState;
+    class Machine;
     class ScopeNode;
-    class CodeBlock;
     struct Instruction;
-
-#if ENABLE(SAMPLING_TOOL)
-    extern OpcodeID currentOpcodeID;
-    extern unsigned inCalledCode;
-#endif
 
     struct ScopeSampleRecord {
@@ -71 +67 @@
         }
         
-        void sample(CodeBlock* codeBlock, Instruction* vPC);
+        void sample(CodeBlock*, Instruction*);
     };
 
@@ -78 +74 @@
     class SamplingTool {
     public:
-        SamplingTool()
-            : m_running(false)
-            , m_recordedCodeBlock(0)
-            , m_recordedVPC(0)
-            , m_totalSamples(0)
+        friend class CallRecord;
+        friend class HostCallRecord;
+        
+#if ENABLE(OPCODE_SAMPLING)
+        class CallRecord : Noncopyable {
+        public:
+            CallRecord(SamplingTool* samplingTool)
+                : m_samplingTool(samplingTool)
+                , m_savedSample(samplingTool->m_sample)
+                , m_savedCodeBlock(samplingTool->m_codeBlock)
+            {
+            }
+
+            ~CallRecord()
+            {
+                m_samplingTool->m_sample = m_savedSample;
+                m_samplingTool->m_codeBlock = m_savedCodeBlock;
+            }
+
+        private:
+            SamplingTool* m_samplingTool;
+            intptr_t m_savedSample;
+            CodeBlock* m_savedCodeBlock;
+        };
+        
+        class HostCallRecord : public CallRecord {
+        public:
+            HostCallRecord(SamplingTool* samplingTool)
+                : CallRecord(samplingTool)
+            {
+                samplingTool->m_sample |= 0x1;
+            }
+        };
+#else
+        class CallRecord : Noncopyable {
+        public:
+            CallRecord(SamplingTool*)
+            {
+            }
+        };
+
+        class HostCallRecord : public CallRecord {
+        public:
+            HostCallRecord(SamplingTool* samplingTool)
+                : CallRecord(samplingTool)
+            {
+            }
+        };
+#endif        
+
+        SamplingTool(Machine* machine)
+            : m_machine(machine)
+            , m_running(false)
+            , m_codeBlock(0)
+            , m_sample(0)
+            , m_sampleCount(0)
+            , m_opcodeSampleCount(0)
             , m_scopeSampleMap(new ScopeSampleRecordMap())
         {
+            memset(m_opcodeSamples, 0, sizeof(m_opcodeSamples));
+            memset(m_opcodeSamplesInCTIFunctions, 0, sizeof(m_opcodeSamplesInCTIFunctions));
         }
 
@@ -98 +148 @@
         void notifyOfScope(ScopeNode* scope);
 
-        void sample(CodeBlock* recordedCodeBlock, Instruction* recordedVPC)
-        {
-            m_recordedCodeBlock = recordedCodeBlock;
-            m_recordedVPC = recordedVPC;
-        }
-
-        void privateExecuteReturned()
-        {
-            m_recordedCodeBlock = 0;
-            m_recordedVPC = 0;
-#if ENABLE(SAMPLING_TOOL)
-            currentOpcodeID = static_cast<OpcodeID>(-1);
-#endif
-        }
-        
-        void callingHostFunction()
-        {
-            m_recordedCodeBlock = 0;
-            m_recordedVPC = 0;
-#if ENABLE(SAMPLING_TOOL)
-            currentOpcodeID = static_cast<OpcodeID>(-1);
-#endif
+        void sample(CodeBlock* codeBlock, Instruction* vPC)
+        {
+            ASSERT(!(reinterpret_cast<intptr_t>(vPC) & 0x3));
+            m_codeBlock = codeBlock;
+            m_sample = reinterpret_cast<intptr_t>(vPC);
+        }
+
+        CodeBlock** codeBlockSlot() { return &m_codeBlock; }
+        intptr_t* sampleSlot() { return &m_sample; }
+
+        unsigned encodeSample(Instruction* vPC, bool inCTIFunction = false, bool inHostFunction = false)
+        {
+            ASSERT(!(reinterpret_cast<intptr_t>(vPC) & 0x3));
+            return reinterpret_cast<intptr_t>(vPC) | (inCTIFunction << 1) | inHostFunction;
         }
 
     private:
+        class Sample {
+        public:
+            Sample(volatile intptr_t sample, CodeBlock* volatile codeBlock)
+                : m_sample(sample)
+                , m_codeBlock(codeBlock)
+            {
+            }
+            
+            bool isNull() { return !m_sample || !m_codeBlock; }
+            CodeBlock* codeBlock() { return m_codeBlock; }
+            Instruction* vPC() { return reinterpret_cast<Instruction*>(m_sample & ~0x3); }
+            bool inHostFunction() { return m_sample & 0x1; }
+            bool inCTIFunction() { return m_sample & 0x2; }
+
+        private:
+            intptr_t m_sample;
+            CodeBlock* m_codeBlock;
+        };
+        
         static void* threadStartFunc(void*);
         void run();
+        
+        Machine* m_machine;
         
         // Sampling thread state.
@@ -132 +195 @@
 
         // State tracked by the main thread, used by the sampling thread.
-        CodeBlock* m_recordedCodeBlock;
-        Instruction* m_recordedVPC;
+        CodeBlock* m_codeBlock;
+        intptr_t m_sample;
 
         // Gathered sample data.
-        long long m_totalSamples;
+        long long m_sampleCount;
+        long long m_opcodeSampleCount;
+        unsigned m_opcodeSamples[numOpcodeIDs];
+        unsigned m_opcodeSamplesInCTIFunctions[numOpcodeIDs];
         OwnPtr<ScopeSampleRecordMap> m_scopeSampleMap;
     };
 
-// SCOPENODE_ / MACHINE_ macros for use from within member methods on ScopeNode / Machine respectively.
-#if ENABLE(SAMPLING_TOOL)
-#define SCOPENODE_SAMPLING_notifyOfScope(sampler) sampler->notifyOfScope(this)
-#define MACHINE_SAMPLING_sample(codeBlock, vPC) m_sampler->sample(codeBlock, vPC)
-#define MACHINE_SAMPLING_privateExecuteReturned() m_sampler->privateExecuteReturned()
-#define MACHINE_SAMPLING_callingHostFunction() m_sampler->callingHostFunction()
-#define CTI_MACHINE_SAMPLING_callingHostFunction() ARG_globalData->machine->m_sampler->callingHostFunction()
-#else
-#define SCOPENODE_SAMPLING_notifyOfScope(sampler)
-#define MACHINE_SAMPLING_sample(codeBlock, vPC)
-#define MACHINE_SAMPLING_privateExecuteReturned()
-#define MACHINE_SAMPLING_callingHostFunction()
-#define CTI_MACHINE_SAMPLING_callingHostFunction()
-#endif
-
 } // namespace JSC
 

trunk/JavaScriptCore/kjs/Parser.h

@@ -24 +24 @@
 #define Parser_h
 
+#include "SourceProvider.h"
 #include "debugger.h"
-#include "SourceProvider.h"
 #include "nodes.h"
 #include <wtf/Forward.h>

trunk/JavaScriptCore/kjs/Shell.cpp

@@ -323 +323 @@
         CodeGenerator::setDumpsGeneratedCode(true);
 
-#if ENABLE(SAMPLING_TOOL)
+#if ENABLE(OPCODE_SAMPLING)
     Machine* machine = globalObject->globalData()->machine;
-    machine->m_sampler = new SamplingTool();
-    machine->m_sampler->start();
+    machine->setSampler(new SamplingTool(machine));
 #endif
 
@@ -339 +338 @@
             prettyPrintScript(globalObject->globalExec(), fileName, script);
         else {
+#if ENABLE(OPCODE_SAMPLING)
+            machine->sampler()->start();
+#endif
             Completion completion = Interpreter::evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
             success = success && completion.complType() != Throw;
@@ -349 +351 @@
 
             globalObject->globalExec()->clearException();
-        }
-    }
-
-#if ENABLE(SAMPLING_TOOL)
-    machine->m_sampler->stop();
-    machine->m_sampler->dump(globalObject->globalExec());
-    delete machine->m_sampler;
+
+#if ENABLE(OPCODE_SAMPLING)
+            machine->sampler()->stop();
+#endif
+        }
+    }
+
+#if ENABLE(OPCODE_SAMPLING)
+    machine->sampler()->dump(globalObject->globalExec());
+    delete machine->sampler();
 #endif
     return success;

trunk/JavaScriptCore/kjs/nodes.cpp

@@ -34 +34 @@
 #include "PropertyNameArray.h"
 #include "RegExpObject.h"
+#include "SamplingTool.h"
 #include "debugger.h"
 #include "lexer.h"
 #include "operations.h"
-#include "SamplingTool.h"
 #include <math.h>
 #include <wtf/Assertions.h>
@@ -1699 +1699 @@
     if (funcStack)
         m_functionStack = *funcStack;
-
-    SCOPENODE_SAMPLING_notifyOfScope(globalData->machine->m_sampler);
+#if ENABLE(OPCODE_SAMPLING)
+    globalData->machine->sampler()->notifyOfScope(this);
+#endif
 }
 

trunk/JavaScriptCore/wtf/Platform.h

@@ -348 +348 @@
 #endif
 
-#if !defined(ENABLE_SAMPLING_TOOL)
-#define ENABLE_SAMPLING_TOOL 0
+#if !defined(ENABLE_OPCODE_STATS)
+#define ENABLE_OPCODE_STATS 0
+#endif
+
+#if !defined(ENABLE_CODEBLOCK_SAMPLING)
+#define ENABLE_CODEBLOCK_SAMPLING 0
+#endif
+
+#if ENABLE(CODEBLOCK_SAMPLING) && !defined(ENABLE_OPCODE_SAMPLING)
+#define ENABLE_OPCODE_SAMPLING 1
+#endif
+
+#if !defined(ENABLE_OPCODE_SAMPLING)
+#define ENABLE_OPCODE_SAMPLING 0
 #endif