Bug 693838 - Convert capitalization of Probes::functionName to probes::FunctionName. r=sfink
authorSankha Narayan Guria <sankha93@gmail.com>
Sat, 12 Oct 2013 03:17:59 +0530
changeset 165473 44024cc4a59f9ca19ad329a5aaa389f406c8b8ae
parent 165472 75380019dc499a85552e43097c5a1bf68798b209
child 165474 37e29c27e6e8bd66a4d29e4c065782761e6c5243
push id428
push userbbajaj@mozilla.com
push dateTue, 28 Jan 2014 00:16:25 +0000
treeherdermozilla-release@cd72a7ff3a75 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssfink
bugs693838
milestone27.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 693838 - Convert capitalization of Probes::functionName to probes::FunctionName. r=sfink
js/src/builtin/Profilers.cpp
js/src/jit/IonFrames.cpp
js/src/jit/IonMacroAssembler.h
js/src/jit/VMFunctions.cpp
js/src/jsarray.cpp
js/src/jsobj.cpp
js/src/jsobjinlines.h
js/src/vm/Interpreter.cpp
js/src/vm/Probes-inl.h
js/src/vm/Probes.cpp
js/src/vm/Probes.h
js/src/vm/Runtime-inl.h
js/src/vm/Stack.cpp
--- a/js/src/builtin/Profilers.cpp
+++ b/js/src/builtin/Profilers.cpp
@@ -117,17 +117,17 @@ JS_StopProfiling(const char *profileName
  * Start or stop whatever platform- and configuration-specific profiling
  * backends are available.
  */
 static bool
 ControlProfilers(bool toState)
 {
     bool ok = true;
 
-    if (! Probes::ProfilingActive && toState) {
+    if (! probes::ProfilingActive && toState) {
 #ifdef __APPLE__
 #if defined(MOZ_SHARK) || defined(MOZ_INSTRUMENTS)
         const char* profiler;
 #ifdef MOZ_SHARK
         ok = Shark::Start();
         profiler = "Shark";
 #endif
 #ifdef MOZ_INSTRUMENTS
@@ -140,34 +140,34 @@ ControlProfilers(bool toState)
 #endif
 #endif
 #ifdef MOZ_CALLGRIND
         if (! js_StartCallgrind()) {
             UnsafeError("Failed to start Callgrind");
             ok = false;
         }
 #endif
-    } else if (Probes::ProfilingActive && ! toState) {
+    } else if (probes::ProfilingActive && ! toState) {
 #ifdef __APPLE__
 #ifdef MOZ_SHARK
         Shark::Stop();
 #endif
 #ifdef MOZ_INSTRUMENTS
         Instruments::Pause();
 #endif
 #endif
 #ifdef MOZ_CALLGRIND
         if (! js_StopCallgrind()) {
             UnsafeError("failed to stop Callgrind");
             ok = false;
         }
 #endif
     }
 
-    Probes::ProfilingActive = toState;
+    probes::ProfilingActive = toState;
 
     return ok;
 }
 
 /*
  * Pause/resume whatever profiling mechanism is currently compiled
  * in, if applicable. This will not affect things like dtrace.
  *
--- a/js/src/jit/IonFrames.cpp
+++ b/js/src/jit/IonFrames.cpp
@@ -549,17 +549,17 @@ HandleException(ResumeFromException *rfe
                 }
 
                 JS_ASSERT(rfe->kind == ResumeFromException::RESUME_ENTRY_FRAME);
 
                 // When profiling, each frame popped needs a notification that
                 // the function has exited, so invoke the probe that a function
                 // is exiting.
                 JSScript *script = frames.script();
-                Probes::exitScript(cx, script, script->function(), nullptr);
+                probes::ExitScript(cx, script, script->function(), nullptr);
                 if (!frames.more())
                     break;
                 ++frames;
             }
 
             IonScript *ionScript = nullptr;
             if (iter.checkInvalidation(&ionScript))
                 ionScript->decref(cx->runtime()->defaultFreeOp());
@@ -569,17 +569,17 @@ HandleException(ResumeFromException *rfe
             bool calledDebugEpilogue = false;
 
             HandleExceptionBaseline(cx, iter, rfe, &calledDebugEpilogue);
             if (rfe->kind != ResumeFromException::RESUME_ENTRY_FRAME)
                 return;
 
             // Unwind profiler pseudo-stack
             JSScript *script = iter.script();
-            Probes::exitScript(cx, script, script->function(), iter.baselineFrame());
+            probes::ExitScript(cx, script, script->function(), iter.baselineFrame());
             // After this point, any pushed SPS frame would have been popped if it needed
             // to be.  Unset the flag here so that if we call DebugEpilogue below,
             // it doesn't try to pop the SPS frame again.
             iter.baselineFrame()->unsetPushedSPSFrame();
  
             if (cx->compartment()->debugMode() && !calledDebugEpilogue) {
                 // If DebugEpilogue returns |true|, we have to perform a forced
                 // return, e.g. return frame->returnValue() to the caller.
--- a/js/src/jit/IonMacroAssembler.h
+++ b/js/src/jit/IonMacroAssembler.h
@@ -1059,17 +1059,17 @@ class MacroAssembler : public MacroAssem
         storePtr(temp2, Address(temp, ProfileEntry::offsetOfString()));
 
         loadPtr(script, temp2);
         storePtr(temp2, Address(temp, ProfileEntry::offsetOfScript()));
 
         storePtr(ImmPtr(nullptr), Address(temp, ProfileEntry::offsetOfStackAddress()));
 
         // Store 0 for PCIdx because that's what interpreter does.
-        // (See Probes::enterScript, which calls spsProfiler.enter, which pushes an entry
+        // (See probes::EnterScript, which calls spsProfiler.enter, which pushes an entry
         //  with 0 pcIdx).
         store32(Imm32(0), Address(temp, ProfileEntry::offsetOfPCIdx()));
 
         /* Always increment the stack size, whether or not we actually pushed. */
         bind(&stackFull);
         movePtr(ImmPtr(p->addressOfSizePointer()), temp);
         loadPtr(Address(temp, 0), temp);
         add32(Imm32(1), Address(temp, 0));
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -711,17 +711,17 @@ DebugEpilogue(JSContext *cx, BaselineFra
         JS_ASSERT_IF(frame->hasCallObj(), frame->scopeChain()->as<CallObject>().isForEval());
         DebugScopes::onPopStrictEvalScope(frame);
     }
 
     // If the frame has a pushed SPS frame, make sure to pop it.
     if (frame->hasPushedSPSFrame()) {
         cx->runtime()->spsProfiler.exit(cx, frame->script(), frame->maybeFun());
         // Unset the pushedSPSFrame flag because DebugEpilogue may get called before
-        // Probes::exitScript in baseline during exception handling, and we don't
+        // probes::ExitScript in baseline during exception handling, and we don't
         // want to double-pop SPS frames.
         frame->unsetPushedSPSFrame();
     }
 
     if (!ok) {
         // Pop this frame by updating ionTop, so that the exception handling
         // code will start at the previous frame.
 
--- a/js/src/jsarray.cpp
+++ b/js/src/jsarray.cpp
@@ -3187,17 +3187,17 @@ NewArray(ExclusiveContext *cxArg, uint32
     if (entry != -1) {
         cxArg->asJSContext()->runtime()->newObjectCache.fillGlobal(entry, &ArrayObject::class_,
                                                                    cxArg->global(), allocKind, arr);
     }
 
     if (allocateCapacity && !EnsureNewArrayElements(cxArg, arr, length))
         return nullptr;
 
-    Probes::createObject(cxArg, arr);
+    probes::CreateObject(cxArg, arr);
     return arr;
 }
 
 ArrayObject * JS_FASTCALL
 js::NewDenseEmptyArray(JSContext *cx, JSObject *proto /* = nullptr */,
                        NewObjectKind newKind /* = GenericObject */)
 {
     return NewArray<false>(cx, 0, proto, newKind);
--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -1304,17 +1304,17 @@ NewObject(ExclusiveContext *cx, const Cl
                     "JSCLASS_IMPLEMENTS_BARRIERS flag. Please ensure that it correctly\n"
                     "implements write barriers and then set the flag.\n",
                     clasp->name);
             MOZ_CRASH();
         }
 #endif
     }
 
-    Probes::createObject(cx, obj);
+    probes::CreateObject(cx, obj);
     return obj;
 }
 
 void
 NewObjectCache::fillProto(EntryIndex entry, const Class *clasp, js::TaggedProto proto,
                           gc::AllocKind kind, JSObject *obj)
 {
     JS_ASSERT_IF(proto.isObject(), !proto.toObject()->is<GlobalObject>());
--- a/js/src/jsobjinlines.h
+++ b/js/src/jsobjinlines.h
@@ -70,17 +70,17 @@ JSObject::deleteSpecial(JSContext *cx, j
     js::types::MarkTypePropertyConfigured(cx, obj, id);
     js::DeleteSpecialOp op = obj->getOps()->deleteSpecial;
     return (op ? op : js::baseops::DeleteSpecial)(cx, obj, sid, succeeded);
 }
 
 inline void
 JSObject::finalize(js::FreeOp *fop)
 {
-    js::Probes::finalizeObject(this);
+    js::probes::FinalizeObject(this);
 
 #ifdef DEBUG
     JS_ASSERT(isTenured());
     if (!IsBackgroundFinalized(tenuredGetAllocKind())) {
         /* Assert we're on the main thread. */
         JS_ASSERT(CurrentThreadCanAccessRuntime(fop->runtime()));
     }
 #endif
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -601,20 +601,20 @@ js::ExecuteKernel(JSContext *cx, HandleS
     if (script->isEmpty()) {
         if (result)
             result->setUndefined();
         return true;
     }
 
     TypeScript::SetThis(cx, script, thisv);
 
-    Probes::startExecution(script);
+    probes::StartExecution(script);
     ExecuteState state(cx, script, thisv, scopeChainArg, type, evalInFrame, result);
     bool ok = RunScript(cx, state);
-    Probes::stopExecution(script);
+    probes::StopExecution(script);
 
     return ok;
 }
 
 bool
 js::Execute(JSContext *cx, HandleScript script, JSObject &scopeChainArg, Value *rval)
 {
     /* The scope chain could be anything, so innerize just in case. */
@@ -1330,29 +1330,29 @@ Interpret(JSContext *cx, RunState &state
         JS_ASSERT(size_t(regs.pc - script->code) <= script->length);
         JS_ASSERT(regs.stackDepth() <= script->nslots);
 
         /*
          * To support generator_throw and to catch ignored exceptions,
          * fail if cx->isExceptionPending() is true.
          */
         if (cx->isExceptionPending()) {
-            Probes::enterScript(cx, script, script->function(), regs.fp());
+            probes::EnterScript(cx, script, script->function(), regs.fp());
             goto error;
         }
     }
 
     /* State communicated between non-local jumps: */
     bool interpReturnOK;
 
     if (!entryFrame->isGeneratorFrame()) {
         if (!entryFrame->prologue(cx))
             goto error;
     } else {
-        Probes::enterScript(cx, script, script->function(), entryFrame);
+        probes::EnterScript(cx, script, script->function(), entryFrame);
     }
     if (cx->compartment()->debugMode()) {
         JSTrapStatus status = ScriptDebugPrologue(cx, entryFrame);
         switch (status) {
           case JSTRAP_CONTINUE:
             break;
           case JSTRAP_RETURN:
             interpReturnOK = true;
@@ -1618,17 +1618,17 @@ BEGIN_CASE(JSOP_STOP)
 #endif
 
         if (cx->compartment()->debugMode())
             interpReturnOK = ScriptDebugEpilogue(cx, regs.fp(), interpReturnOK);
 
         if (!regs.fp()->isYielding())
             regs.fp()->epilogue(cx);
         else
-            Probes::exitScript(cx, script, script->function(), regs.fp());
+            probes::ExitScript(cx, script, script->function(), regs.fp());
 
 #if defined(JS_ION)
   jit_return_pop_frame:
 #endif
 
         activation.popInlineFrame(regs.fp());
         SET_SCRIPT(regs.fp()->script());
 
@@ -3396,17 +3396,17 @@ default:
         goto inline_return;
 
   exit:
     if (cx->compartment()->debugMode())
         interpReturnOK = ScriptDebugEpilogue(cx, regs.fp(), interpReturnOK);
     if (!regs.fp()->isYielding())
         regs.fp()->epilogue(cx);
     else
-        Probes::exitScript(cx, script, script->function(), regs.fp());
+        probes::ExitScript(cx, script, script->function(), regs.fp());
 
     gc::MaybeVerifyBarriers(cx, true);
 
 #if JS_TRACE_LOGGING
         TraceLogging::defaultLogger()->log(TraceLogging::SCRIPT_STOP);
 #endif
 
 #ifdef JS_ION
--- a/js/src/vm/Probes-inl.h
+++ b/js/src/vm/Probes-inl.h
@@ -14,38 +14,38 @@
 namespace js {
 
 /*
  * Many probe handlers are implemented inline for minimal performance impact,
  * especially important when no backends are enabled.
  */
 
 inline bool
-Probes::callTrackingActive(JSContext *cx)
+probes::CallTrackingActive(JSContext *cx)
 {
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_FUNCTION_ENTRY_ENABLED() || JAVASCRIPT_FUNCTION_RETURN_ENABLED())
         return true;
 #endif
 #ifdef MOZ_TRACE_JSCALLS
     if (cx->functionCallback)
         return true;
 #endif
     return false;
 }
 
 inline bool
-Probes::wantNativeAddressInfo(JSContext *cx)
+probes::WantNativeAddressInfo(JSContext *cx)
 {
     return (cx->reportGranularity >= JITREPORT_GRANULARITY_FUNCTION &&
             JITGranularityRequested(cx) >= JITREPORT_GRANULARITY_FUNCTION);
 }
 
 inline bool
-Probes::enterScript(JSContext *cx, JSScript *script, JSFunction *maybeFun,
+probes::EnterScript(JSContext *cx, JSScript *script, JSFunction *maybeFun,
                     StackFrame *fp)
 {
     bool ok = true;
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_FUNCTION_ENTRY_ENABLED())
         DTraceEnterJSFun(cx, maybeFun, script);
 #endif
 #ifdef MOZ_TRACE_JSCALLS
@@ -58,17 +58,17 @@ Probes::enterScript(JSContext *cx, JSScr
         JS_ASSERT_IF(!fp->isGeneratorFrame(), !fp->hasPushedSPSFrame());
         fp->setPushedSPSFrame();
     }
 
     return ok;
 }
 
 inline bool
-Probes::exitScript(JSContext *cx, JSScript *script, JSFunction *maybeFun,
+probes::ExitScript(JSContext *cx, JSScript *script, JSFunction *maybeFun,
                    AbstractFramePtr fp)
 {
     bool ok = true;
 
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_FUNCTION_RETURN_ENABLED())
         DTraceExitJSFun(cx, maybeFun, script);
 #endif
@@ -83,38 +83,38 @@ Probes::exitScript(JSContext *cx, JSScri
      * guaranteed that fp->hasPushedSPSFrame() would have been true
      */
     if ((!fp && rt->spsProfiler.enabled()) || (fp && fp.hasPushedSPSFrame()))
         rt->spsProfiler.exit(cx, script, maybeFun);
     return ok;
 }
 
 inline bool
-Probes::exitScript(JSContext *cx, JSScript *script, JSFunction *maybeFun,
+probes::ExitScript(JSContext *cx, JSScript *script, JSFunction *maybeFun,
                    StackFrame *fp)
 {
-    return Probes::exitScript(cx, script, maybeFun, fp ? AbstractFramePtr(fp) : AbstractFramePtr());
+    return probes::ExitScript(cx, script, maybeFun, fp ? AbstractFramePtr(fp) : AbstractFramePtr());
 }
 
 inline bool
-Probes::startExecution(JSScript *script)
+probes::StartExecution(JSScript *script)
 {
     bool ok = true;
 
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_EXECUTE_START_ENABLED())
         JAVASCRIPT_EXECUTE_START((script->filename() ? (char *)script->filename() : nullName),
                                  script->lineno);
 #endif
 
     return ok;
 }
 
 inline bool
-Probes::stopExecution(JSScript *script)
+probes::StopExecution(JSScript *script)
 {
     bool ok = true;
 
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_EXECUTE_DONE_ENABLED())
         JAVASCRIPT_EXECUTE_DONE((script->filename() ? (char *)script->filename() : nullName),
                                 script->lineno);
 #endif
--- a/js/src/vm/Probes.cpp
+++ b/js/src/vm/Probes.cpp
@@ -11,75 +11,75 @@
 #ifdef INCLUDE_MOZILLA_DTRACE
 #include "jsscriptinlines.h" 
 #endif
 
 #define TYPEOF(cx,v)    (JSVAL_IS_NULL(v) ? JSTYPE_NULL : JS_TypeOfValue(cx,v))
 
 using namespace js;
 
-const char Probes::nullName[] = "(null)";
-const char Probes::anonymousName[] = "(anonymous)";
+const char probes::nullName[] = "(null)";
+const char probes::anonymousName[] = "(anonymous)";
 
-bool Probes::ProfilingActive = true;
+bool probes::ProfilingActive = true;
 
-Probes::JITReportGranularity
-Probes::JITGranularityRequested(JSContext *cx)
+probes::JITReportGranularity
+probes::JITGranularityRequested(JSContext *cx)
 {
     if (cx->runtime()->spsProfiler.enabled())
         return JITREPORT_GRANULARITY_LINE;
     return JITREPORT_GRANULARITY_NONE;
 }
 
 /* ICs are unregistered in a batch */
 void
-Probes::discardExecutableRegion(void *start, size_t size)
+probes::DiscardExecutableRegion(void *start, size_t size)
 {
     /*
      * Not needed for SPS because ICs are disposed of when the normal JITChunk
      * is disposed of
      */
 }
 
 #ifdef INCLUDE_MOZILLA_DTRACE
 static const char *
 ScriptFilename(const JSScript *script)
 {
     if (!script)
-        return Probes::nullName;
+        return probes::nullName;
     if (!script->filename())
-        return Probes::anonymousName;
+        return probes::anonymousName;
     return script->filename();
 }
 
 static const char *
 FunctionName(JSContext *cx, JSFunction *fun, JSAutoByteString* bytes)
 {
     if (!fun)
-        return Probes::nullName;
+        return probes::nullName;
     if (!fun->displayAtom())
-        return Probes::anonymousName;
-    return bytes->encodeLatin1(cx, fun->displayAtom()) ? bytes->ptr() : Probes::nullName;
+        return probes::anonymousName;
+    return bytes->encodeLatin1(cx, fun->displayAtom()) ? bytes->ptr() : probes::nullName;
 }
 
 /*
  * These functions call the DTrace macros for the JavaScript USDT probes.
  * Originally this code was inlined in the JavaScript code; however since
  * a number of operations are called, these have been placed into functions
  * to reduce any negative compiler optimization effect that the addition of
  * a number of usually unused lines of code would cause.
  */
 void
-Probes::DTraceEnterJSFun(JSContext *cx, JSFunction *fun, JSScript *script)
+probes::DTraceEnterJSFun(JSContext *cx, JSFunction *fun, JSScript *script)
 {
     JSAutoByteString funNameBytes;
-    JAVASCRIPT_FUNCTION_ENTRY(ScriptFilename(script), Probes::nullName,
+    JAVASCRIPT_FUNCTION_ENTRY(ScriptFilename(script), probes::nullName,
                               FunctionName(cx, fun, &funNameBytes));
 }
 
 void
-Probes::DTraceExitJSFun(JSContext *cx, JSFunction *fun, JSScript *script)
+probes::DTraceExitJSFun(JSContext *cx, JSFunction *fun, JSScript *script)
 {
     JSAutoByteString funNameBytes;
-    JAVASCRIPT_FUNCTION_RETURN(ScriptFilename(script), Probes::nullName,
+    JAVASCRIPT_FUNCTION_RETURN(ScriptFilename(script), probes::nullName,
                                FunctionName(cx, fun, &funNameBytes));
 }
 #endif
--- a/js/src/vm/Probes.h
+++ b/js/src/vm/Probes.h
@@ -10,23 +10,23 @@
 #ifdef INCLUDE_MOZILLA_DTRACE
 #include "javascript-trace.h"
 #endif
 
 #include "vm/Stack.h"
 
 namespace js {
 
-namespace Probes {
+namespace probes {
 
 /*
  * Static probes
  *
  * The probe points defined in this file are scattered around the SpiderMonkey
- * source tree. The presence of Probes::someEvent() means that someEvent is
+ * source tree. The presence of probes::SomeEvent() means that someEvent is
  * about to happen or has happened. To the extent possible, probes should be
  * inserted in all paths associated with a given event, regardless of the
  * active runmode (interpreter/traceJIT/methodJIT/ionJIT).
  *
  * When a probe fires, it is handled by any probe handling backends that have
  * been compiled in. By default, most probes do nothing or at least do nothing
  * expensive, so the presence of the probe should have negligible effect on
  * running time. (Probes in slow paths may do something by default, as long as
@@ -52,47 +52,47 @@ extern bool ProfilingActive;
 extern const char nullName[];
 extern const char anonymousName[];
 
 /*
  * Test whether we are tracking JS function call enter/exit. The JITs use this
  * to decide whether they can optimize in a way that would prevent probes from
  * firing.
  */
-bool callTrackingActive(JSContext *);
+bool CallTrackingActive(JSContext *);
 
 /*
  * Test whether anything is looking for JIT native code registration events.
  * This information will not be collected otherwise.
  */
-bool wantNativeAddressInfo(JSContext *);
+bool WantNativeAddressInfo(JSContext *);
 
 /* Entering a JS function */
-bool enterScript(JSContext *, JSScript *, JSFunction *, StackFrame *);
+bool EnterScript(JSContext *, JSScript *, JSFunction *, StackFrame *);
 
 /* About to leave a JS function */
-bool exitScript(JSContext *, JSScript *, JSFunction *, AbstractFramePtr);
-bool exitScript(JSContext *, JSScript *, JSFunction *, StackFrame *);
+bool ExitScript(JSContext *, JSScript *, JSFunction *, AbstractFramePtr);
+bool ExitScript(JSContext *, JSScript *, JSFunction *, StackFrame *);
 
 /* Executing a script */
-bool startExecution(JSScript *script);
+bool StartExecution(JSScript *script);
 
 /* Script has completed execution */
-bool stopExecution(JSScript *script);
+bool StopExecution(JSScript *script);
 
 /*
  * Object has been created. |obj| must exist (its class and size are read)
  */
-bool createObject(ExclusiveContext *cx, JSObject *obj);
+bool CreateObject(ExclusiveContext *cx, JSObject *obj);
 
 /*
  * Object is about to be finalized. |obj| must still exist (its class is
  * read)
  */
-bool finalizeObject(JSObject *obj);
+bool FinalizeObject(JSObject *obj);
 
 /* JIT code observation */
 
 enum JITReportGranularity {
     JITREPORT_GRANULARITY_NONE = 0,
     JITREPORT_GRANULARITY_FUNCTION = 1,
     JITREPORT_GRANULARITY_LINE = 2,
     JITREPORT_GRANULARITY_OP = 3
@@ -104,21 +104,21 @@ enum JITReportGranularity {
 JITReportGranularity
 JITGranularityRequested(JSContext *cx);
 
 /*
  * A whole region of code has been deallocated, containing any number of ICs.
  * (ICs are unregistered in a batch, so individual ICs are not registered.)
  */
 void
-discardExecutableRegion(void *start, size_t size);
+DiscardExecutableRegion(void *start, size_t size);
 
 /*
- * Internal: DTrace-specific functions to be called during Probes::enterScript
- * and Probes::exitScript. These will not be inlined, but the argument
+ * Internal: DTrace-specific functions to be called during probes::EnterScript
+ * and probes::ExitScript. These will not be inlined, but the argument
  * marshalling required for these probe points is expensive enough that it
  * shouldn't really matter.
  */
 void DTraceEnterJSFun(JSContext *cx, JSFunction *fun, JSScript *script);
 void DTraceExitJSFun(JSContext *cx, JSFunction *fun, JSScript *script);
 
 } /* namespace Probes */
 
@@ -132,30 +132,30 @@ static const char *ObjectClassname(JSObj
     const char *class_name = clasp->name;
     if (!class_name)
         return "(null class name)";
     return class_name;
 }
 #endif
 
 inline bool
-Probes::createObject(ExclusiveContext *cx, JSObject *obj)
+probes::CreateObject(ExclusiveContext *cx, JSObject *obj)
 {
     bool ok = true;
 
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_OBJECT_CREATE_ENABLED())
         JAVASCRIPT_OBJECT_CREATE(ObjectClassname(obj), (uintptr_t)obj);
 #endif
 
     return ok;
 }
 
 inline bool
-Probes::finalizeObject(JSObject *obj)
+probes::FinalizeObject(JSObject *obj)
 {
     bool ok = true;
 
 #ifdef INCLUDE_MOZILLA_DTRACE
     if (JAVASCRIPT_OBJECT_FINALIZE_ENABLED()) {
         const Class *clasp = obj->getClass();
 
         /* the first arg is nullptr - reserved for future use (filename?) */
--- a/js/src/vm/Runtime-inl.h
+++ b/js/src/vm/Runtime-inl.h
@@ -48,17 +48,17 @@ NewObjectCache::newObjectFromHit(JSConte
 
     JSObject *templateObj = reinterpret_cast<JSObject *>(&entry->templateObject);
     if (templateObj->type()->isLongLivedForCachedAlloc())
         heap = gc::TenuredHeap;
 
     JSObject *obj = js_NewGCObject<NoGC>(cx, entry->kind, heap);
     if (obj) {
         copyCachedToObject(obj, templateObj, entry->kind);
-        Probes::createObject(cx, obj);
+        probes::CreateObject(cx, obj);
         return obj;
     }
 
     return nullptr;
 }
 
 }  /* namespace js */
 
--- a/js/src/vm/Stack.cpp
+++ b/js/src/vm/Stack.cpp
@@ -259,22 +259,22 @@ StackFrame::prologue(JSContext *cx)
     if (isEvalFrame()) {
         if (script->strict) {
             CallObject *callobj = CallObject::createForStrictEval(cx, this);
             if (!callobj)
                 return false;
             pushOnScopeChain(*callobj);
             flags_ |= HAS_CALL_OBJ;
         }
-        Probes::enterScript(cx, script, nullptr, this);
+        probes::EnterScript(cx, script, nullptr, this);
         return true;
     }
 
     if (isGlobalFrame()) {
-        Probes::enterScript(cx, script, nullptr, this);
+        probes::EnterScript(cx, script, nullptr, this);
         return true;
     }
 
     JS_ASSERT(isNonEvalFunctionFrame());
     AssertDynamicScopeMatchesStaticScope(cx, script, scopeChain());
 
     if (fun()->isHeavyweight() && !initFunctionScopeObjects(cx))
         return false;
@@ -282,28 +282,28 @@ StackFrame::prologue(JSContext *cx)
     if (isConstructing()) {
         RootedObject callee(cx, &this->callee());
         JSObject *obj = CreateThisForFunction(cx, callee, useNewType());
         if (!obj)
             return false;
         functionThis() = ObjectValue(*obj);
     }
 
-    Probes::enterScript(cx, script, script->function(), this);
+    probes::EnterScript(cx, script, script->function(), this);
     return true;
 }
 
 void
 StackFrame::epilogue(JSContext *cx)
 {
     JS_ASSERT(!isYielding());
     JS_ASSERT(!hasBlockChain());
 
     RootedScript script(cx, this->script());
-    Probes::exitScript(cx, script, script->function(), this);
+    probes::ExitScript(cx, script, script->function(), this);
 
     if (isEvalFrame()) {
         if (isStrictEvalFrame()) {
             JS_ASSERT_IF(hasCallObj(), scopeChain()->as<CallObject>().isForEval());
             if (cx->compartment()->debugMode())
                 DebugScopes::onPopStrictEvalScope(this);
         } else if (isDirectEvalFrame()) {
             if (isDebuggerFrame())