Bug 1157628: Reformat spidermonkey source directory, again; r=jandem
authorBenjamin Bouvier <benj@benj.me>
Thu, 23 Apr 2015 12:22:36 +0200
changeset 240735 b7e1e4899a60af3cff747c56b2bc83af19bb32bc
parent 240734 6c7ff528de780e6a25302142a5d2bc68f2697b8d
child 240736 8bd57bc35131ac9c331a43c01b4cc0e0ff51fd5e
push id28644
push userryanvm@gmail.com
push dateThu, 23 Apr 2015 21:10:29 +0000
treeherdermozilla-central@22a157f7feb7 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem
bugs1157628
milestone40.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 1157628: Reformat spidermonkey source directory, again; r=jandem
js/ipc/CPOWTimer.cpp
js/public/TracingAPI.h
js/src/builtin/TestingFunctions.cpp
js/src/gc/Barrier.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineIC.h
js/src/jit/CodeGenerator.cpp
js/src/jit/EffectiveAddressAnalysis.cpp
js/src/jit/EffectiveAddressAnalysis.h
js/src/jit/IonBuilder.cpp
js/src/jit/JitFrames.cpp
js/src/jit/MIR.h
js/src/jit/MacroAssembler.h
js/src/jsapi.h
js/src/jscntxt.cpp
js/src/jsobj.cpp
js/src/jsobj.h
js/src/jspropertytree.cpp
js/src/vm/Interpreter.cpp
js/src/vm/Interpreter.h
js/src/vm/ObjectGroup.h
js/src/vm/Runtime.cpp
js/src/vm/Shape.h
js/src/vm/TypedArrayObject.cpp
js/src/vm/TypedArrayObject.h
js/xpconnect/src/XPCConvert.cpp
--- a/js/ipc/CPOWTimer.cpp
+++ b/js/ipc/CPOWTimer.cpp
@@ -14,12 +14,12 @@ CPOWTimer::~CPOWTimer()
     JSContext* cx = nsContentUtils::GetCurrentJSContextForThread();
     if (!cx)
         return;
 
     JSRuntime* runtime = JS_GetRuntime(cx);
     if (!js::IsStopwatchActive(runtime))
         return;
 
-    js::PerformanceData *performance = js::GetPerformanceData(runtime);
+    js::PerformanceData* performance = js::GetPerformanceData(runtime);
     uint64_t duration = PR_IntervalToMicroseconds(PR_IntervalNow() - startInterval);
     performance->totalCPOWTime += duration;
 }
--- a/js/public/TracingAPI.h
+++ b/js/public/TracingAPI.h
@@ -214,17 +214,17 @@ class JS_PUBLIC_API(CallbackTracer) : pu
     friend class AutoOriginalTraceLocation;
     void*const* contextRealLocation_;
 };
 
 // Set the name portion of the tracer's context for the current edge.
 class AutoTracingName
 {
     CallbackTracer* trc_;
-    const char *prior_;
+    const char* prior_;
 
   public:
     AutoTracingName(CallbackTracer* trc, const char* name) : trc_(trc), prior_(trc->contextName_) {
         MOZ_ASSERT(name);
         trc->contextName_ = name;
     }
     ~AutoTracingName() {
         MOZ_ASSERT(trc_->contextName_);
@@ -285,17 +285,17 @@ class AutoTracingDetails
 // Some dynamic analyses depend on knowing the edge source location as it
 // exists in the object graph. When marking some types of things, e.g. Value
 // edges, it is necessary to copy into a temporary on the stack. This class
 // records the original location if we need to copy the tracee, so that the
 // relevant analyses can continue to operate correctly.
 class AutoOriginalTraceLocation
 {
 #ifdef JS_GC_ZEAL
-    CallbackTracer *trc_;
+    CallbackTracer* trc_;
 
   public:
     template <typename T>
     AutoOriginalTraceLocation(JSTracer* trc, T*const* realLocation) : trc_(nullptr) {
         if (trc->isCallbackTracer() && trc->asCallbackTracer()->contextRealLocation_ == nullptr) {
             trc_ = trc->asCallbackTracer();
             trc_->contextRealLocation_ = reinterpret_cast<void*const*>(realLocation);
         }
--- a/js/src/builtin/TestingFunctions.cpp
+++ b/js/src/builtin/TestingFunctions.cpp
@@ -206,17 +206,17 @@ GetBuildConfiguration(JSContext* cx, uns
 #ifdef MOZ_MEMORY
     value = BooleanValue(true);
 #else
     value = BooleanValue(false);
 #endif
     if (!JS_SetProperty(cx, info, "moz-memory", value))
         return false;
 
-    value.setInt32(sizeof(void *));
+    value.setInt32(sizeof(void*));
     if (!JS_SetProperty(cx, info, "pointer-byte-size", value))
         return false;
 
     args.rval().setObject(*info);
     return true;
 }
 
 static bool
--- a/js/src/gc/Barrier.h
+++ b/js/src/gc/Barrier.h
@@ -399,17 +399,17 @@ struct InternalGCMethods<jsid>
   private:
     static JSRuntime* runtimeFromAnyThread(jsid id) {
         MOZ_ASSERT(JSID_IS_GCTHING(id));
         return JSID_TO_GCTHING(id).asCell()->runtimeFromAnyThread();
     }
     static JS::shadow::Runtime* shadowRuntimeFromAnyThread(jsid id) {
         return reinterpret_cast<JS::shadow::Runtime*>(runtimeFromAnyThread(id));
     }
-    static void preBarrierImpl(Zone *zone, jsid id) {
+    static void preBarrierImpl(Zone* zone, jsid id) {
         JS::shadow::Zone* shadowZone = JS::shadow::Zone::asShadowZone(zone);
         if (shadowZone->needsIncrementalBarrier()) {
             jsid tmp(id);
             js::gc::MarkIdForBarrier(shadowZone->barrierTracer(), &tmp, "id write barrier");
             MOZ_ASSERT(tmp == id);
         }
     }
 
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -346,31 +346,31 @@ ICStub::trace(JSTracer* trc)
         break;
       }
       case ICStub::TypeUpdate_ObjectGroup: {
         ICTypeUpdate_ObjectGroup* updateStub = toTypeUpdate_ObjectGroup();
         TraceEdge(trc, &updateStub->group(), "baseline-update-group");
         break;
       }
       case ICStub::In_Native: {
-        ICIn_Native *inStub = toIn_Native();
+        ICIn_Native* inStub = toIn_Native();
         TraceEdge(trc, &inStub->shape(), "baseline-innative-stub-shape");
         TraceEdge(trc, &inStub->name(), "baseline-innative-stub-name");
         break;
       }
       case ICStub::In_NativePrototype: {
-        ICIn_NativePrototype *inStub = toIn_NativePrototype();
+        ICIn_NativePrototype* inStub = toIn_NativePrototype();
         TraceEdge(trc, &inStub->shape(), "baseline-innativeproto-stub-shape");
         TraceEdge(trc, &inStub->name(), "baseline-innativeproto-stub-name");
         TraceEdge(trc, &inStub->holder(), "baseline-innativeproto-stub-holder");
         TraceEdge(trc, &inStub->holderShape(), "baseline-innativeproto-stub-holdershape");
         break;
       }
       case ICStub::In_NativeDoesNotExist: {
-        ICIn_NativeDoesNotExist *inStub = toIn_NativeDoesNotExist();
+        ICIn_NativeDoesNotExist* inStub = toIn_NativeDoesNotExist();
         TraceEdge(trc, &inStub->name(), "baseline-innativedoesnotexist-stub-name");
         JS_STATIC_ASSERT(ICIn_NativeDoesNotExist::MAX_PROTO_CHAIN_DEPTH == 8);
         switch (inStub->protoChainDepth()) {
           case 0: inStub->toImpl<0>()->traceShapes(trc); break;
           case 1: inStub->toImpl<1>()->traceShapes(trc); break;
           case 2: inStub->toImpl<2>()->traceShapes(trc); break;
           case 3: inStub->toImpl<3>()->traceShapes(trc); break;
           case 4: inStub->toImpl<4>()->traceShapes(trc); break;
@@ -378,17 +378,17 @@ ICStub::trace(JSTracer* trc)
           case 6: inStub->toImpl<6>()->traceShapes(trc); break;
           case 7: inStub->toImpl<7>()->traceShapes(trc); break;
           case 8: inStub->toImpl<8>()->traceShapes(trc); break;
           default: MOZ_CRASH("Invalid proto stub.");
         }
         break;
       }
       case ICStub::In_Dense: {
-        ICIn_Dense *inStub = toIn_Dense();
+        ICIn_Dense* inStub = toIn_Dense();
         TraceEdge(trc, &inStub->shape(), "baseline-in-dense-shape");
         break;
       }
       case ICStub::GetName_Global: {
         ICGetName_Global* globalStub = toGetName_Global();
         TraceEdge(trc, &globalStub->shape(), "baseline-global-stub-shape");
         break;
       }
@@ -3801,17 +3801,17 @@ ArgumentsGetElemStubExists(ICGetElem_Fal
             continue;
         if (iter->toGetElem_Arguments()->which() == which)
             return true;
     }
     return false;
 }
 
 static bool
-IsOptimizableElementPropertyName(JSContext *cx, HandleValue key, MutableHandleId idp)
+IsOptimizableElementPropertyName(JSContext* cx, HandleValue key, MutableHandleId idp)
 {
     if (!key.isString())
         return false;
 
     // Convert to interned property name.
     if (!ValueToId<CanGC>(cx, key, idp))
         return false;
 
@@ -5851,38 +5851,38 @@ ICSetElem_TypedArray::Compiler::generate
     return true;
 }
 
 //
 // In_Fallback
 //
 
 static bool
-TryAttachDenseInStub(JSContext *cx, HandleScript script, ICIn_Fallback *stub,
-                     HandleValue key, HandleObject obj, bool *attached)
+TryAttachDenseInStub(JSContext* cx, HandleScript script, ICIn_Fallback* stub,
+                     HandleValue key, HandleObject obj, bool* attached)
 {
     MOZ_ASSERT(!*attached);
 
     if (!IsNativeDenseElementAccess(obj, key))
         return true;
 
     JitSpew(JitSpew_BaselineIC, "  Generating In(Native[Int32] dense) stub");
     ICIn_Dense::Compiler compiler(cx, obj->as<NativeObject>().lastProperty());
-    ICStub *denseStub = compiler.getStub(compiler.getStubSpace(script));
+    ICStub* denseStub = compiler.getStub(compiler.getStubSpace(script));
     if (!denseStub)
         return false;
 
     *attached = true;
     stub->addNewStub(denseStub);
     return true;
 }
 
 static bool
-TryAttachNativeInStub(JSContext *cx, HandleScript script, ICIn_Fallback *stub,
-                      HandleValue key, HandleObject obj, bool *attached)
+TryAttachNativeInStub(JSContext* cx, HandleScript script, ICIn_Fallback* stub,
+                      HandleValue key, HandleObject obj, bool* attached)
 {
     MOZ_ASSERT(!*attached);
 
     RootedId id(cx);
     if (!IsOptimizableElementPropertyName(cx, key, &id))
         return true;
 
     RootedPropertyName name(cx, JSID_TO_ATOM(id)->asPropertyName());
@@ -5892,32 +5892,32 @@ TryAttachNativeInStub(JSContext *cx, Han
         return false;
 
     if (IsCacheableGetPropReadSlot(obj, holder, shape)) {
         ICStub::Kind kind = (obj == holder) ? ICStub::In_Native
                                             : ICStub::In_NativePrototype;
         JitSpew(JitSpew_BaselineIC, "  Generating In(Native %s) stub",
                     (obj == holder) ? "direct" : "prototype");
         ICInNativeCompiler compiler(cx, kind, obj, holder, name);
-        ICStub *newStub = compiler.getStub(compiler.getStubSpace(script));
+        ICStub* newStub = compiler.getStub(compiler.getStubSpace(script));
         if (!newStub)
             return false;
 
         *attached = true;
         stub->addNewStub(newStub);
         return true;
     }
 
     return true;
 }
 
 static bool
-TryAttachNativeInDoesNotExistStub(JSContext *cx, HandleScript script,
-                                  ICIn_Fallback *stub, HandleValue key,
-                                  HandleObject obj, bool *attached)
+TryAttachNativeInDoesNotExistStub(JSContext* cx, HandleScript script,
+                                  ICIn_Fallback* stub, HandleValue key,
+                                  HandleObject obj, bool* attached)
 {
     MOZ_ASSERT(!*attached);
 
     RootedId id(cx);
     if (!IsOptimizableElementPropertyName(cx, key, &id))
         return true;
 
     // Check if does-not-exist can be confirmed on property.
@@ -5929,27 +5929,27 @@ TryAttachNativeInDoesNotExistStub(JSCont
     MOZ_ASSERT(protoChainDepth < SIZE_MAX);
 
     if (protoChainDepth > ICIn_NativeDoesNotExist::MAX_PROTO_CHAIN_DEPTH)
         return true;
 
     // Confirmed no-such-property. Add stub.
     JitSpew(JitSpew_BaselineIC, "  Generating In_NativeDoesNotExist stub");
     ICInNativeDoesNotExistCompiler compiler(cx, obj, name, protoChainDepth);
-    ICStub *newStub = compiler.getStub(compiler.getStubSpace(script));
+    ICStub* newStub = compiler.getStub(compiler.getStubSpace(script));
     if (!newStub)
         return false;
 
     *attached = true;
     stub->addNewStub(newStub);
     return true;
 }
 
 static bool
-DoInFallback(JSContext *cx, BaselineFrame *frame, ICIn_Fallback *stub_,
+DoInFallback(JSContext* cx, BaselineFrame* frame, ICIn_Fallback* stub_,
              HandleValue key, HandleValue objValue, MutableHandleValue res)
 {
     // This fallback stub may trigger debug mode toggling.
     DebugModeOSRVolatileStub<ICIn_Fallback*> stub(frame, stub_);
 
     FallbackICSpew(cx, stub, "In");
 
     if (!objValue.isObject()) {
@@ -5988,17 +5988,17 @@ DoInFallback(JSContext *cx, BaselineFram
             if (attached)
                 return true;
         }
     }
 
     return true;
 }
 
-typedef bool (*DoInFallbackFn)(JSContext *, BaselineFrame *, ICIn_Fallback *, HandleValue,
+typedef bool (*DoInFallbackFn)(JSContext*, BaselineFrame*, ICIn_Fallback*, HandleValue,
                                HandleValue, MutableHandleValue);
 static const VMFunction DoInFallbackInfo =
     FunctionInfo<DoInFallbackFn>(DoInFallback, TailCall, PopValues(2));
 
 bool
 ICIn_Fallback::Compiler::generateStubCode(MacroAssembler& masm)
 {
     EmitRestoreTailCallReg(masm);
@@ -6012,17 +6012,17 @@ ICIn_Fallback::Compiler::generateStubCod
     masm.pushValue(R0);
     masm.push(BaselineStubReg);
     masm.pushBaselineFramePtr(BaselineFrameReg, R0.scratchReg());
 
     return tailCallVM(DoInFallbackInfo, masm);
 }
 
 bool
-ICInNativeCompiler::generateStubCode(MacroAssembler &masm)
+ICInNativeCompiler::generateStubCode(MacroAssembler& masm)
 {
     Label failure, failurePopR0Scratch;
 
     masm.branchTestString(Assembler::NotEqual, R0, &failure);
     masm.branchTestObject(Assembler::NotEqual, R1, &failure);
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(2));
     Register scratch = regs.takeAny();
@@ -6056,29 +6056,29 @@ ICInNativeCompiler::generateStubCode(Mac
     // Failure case - jump to next stub
     masm.bind(&failurePopR0Scratch);
     masm.pop(R0.scratchReg());
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
-ICStub *
-ICInNativeDoesNotExistCompiler::getStub(ICStubSpace *space)
+ICStub*
+ICInNativeDoesNotExistCompiler::getStub(ICStubSpace* space)
 {
     AutoShapeVector shapes(cx);
     if (!shapes.append(obj_->as<NativeObject>().lastProperty()))
         return nullptr;
 
     if (!GetProtoShapes(obj_, protoChainDepth_, &shapes))
         return nullptr;
 
     JS_STATIC_ASSERT(ICIn_NativeDoesNotExist::MAX_PROTO_CHAIN_DEPTH == 8);
 
-    ICStub *stub = nullptr;
+    ICStub* stub = nullptr;
     switch (protoChainDepth_) {
       case 0: stub = getStubSpecific<0>(space, &shapes); break;
       case 1: stub = getStubSpecific<1>(space, &shapes); break;
       case 2: stub = getStubSpecific<2>(space, &shapes); break;
       case 3: stub = getStubSpecific<3>(space, &shapes); break;
       case 4: stub = getStubSpecific<4>(space, &shapes); break;
       case 5: stub = getStubSpecific<5>(space, &shapes); break;
       case 6: stub = getStubSpecific<6>(space, &shapes); break;
@@ -6087,17 +6087,17 @@ ICInNativeDoesNotExistCompiler::getStub(
       default: MOZ_CRASH("ProtoChainDepth too high.");
     }
     if (!stub)
         return nullptr;
     return stub;
 }
 
 bool
-ICInNativeDoesNotExistCompiler::generateStubCode(MacroAssembler &masm)
+ICInNativeDoesNotExistCompiler::generateStubCode(MacroAssembler& masm)
 {
     Label failure, failurePopR0Scratch;
 
     masm.branchTestString(Assembler::NotEqual, R0, &failure);
     masm.branchTestObject(Assembler::NotEqual, R1, &failure);
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(2));
     Register scratch = regs.takeAny();
@@ -6144,17 +6144,17 @@ ICInNativeDoesNotExistCompiler::generate
     masm.bind(&failurePopR0Scratch);
     masm.pop(R0.scratchReg());
     masm.bind(&failure);
     EmitStubGuardFailure(masm);
     return true;
 }
 
 bool
-ICIn_Dense::Compiler::generateStubCode(MacroAssembler &masm)
+ICIn_Dense::Compiler::generateStubCode(MacroAssembler& masm)
 {
     Label failure;
 
     masm.branchTestInt32(Assembler::NotEqual, R0, &failure);
     masm.branchTestObject(Assembler::NotEqual, R1, &failure);
 
     AllocatableGeneralRegisterSet regs(availableGeneralRegs(2));
     Register scratch = regs.takeAny();
@@ -7330,20 +7330,20 @@ TryAttachPrimitiveGetPropStub(JSContext*
         return false;
 
     stub->addNewStub(newStub);
     *attached = true;
     return true;
 }
 
 static bool
-TryAttachNativeGetPropDoesNotExistStub(JSContext *cx, HandleScript script,
-                                       jsbytecode *pc, ICGetProp_Fallback *stub,
+TryAttachNativeGetPropDoesNotExistStub(JSContext* cx, HandleScript script,
+                                       jsbytecode* pc, ICGetProp_Fallback* stub,
                                        HandlePropertyName name, HandleValue val,
-                                       bool *attached)
+                                       bool* attached)
 {
     MOZ_ASSERT(!*attached);
 
     if (!val.isObject())
         return true;
 
     RootedObject obj(cx, &val.toObject());
 
@@ -12367,32 +12367,32 @@ ICSetElem_TypedArray::ICSetElem_TypedArr
   : ICStub(SetElem_TypedArray, stubCode),
     shape_(shape)
 {
     extra_ = uint8_t(type);
     MOZ_ASSERT(extra_ == type);
     extra_ |= (static_cast<uint16_t>(expectOutOfBounds) << 8);
 }
 
-ICInNativeStub::ICInNativeStub(ICStub::Kind kind, JitCode *stubCode, HandleShape shape,
+ICInNativeStub::ICInNativeStub(ICStub::Kind kind, JitCode* stubCode, HandleShape shape,
                                HandlePropertyName name)
   : ICStub(kind, stubCode),
     shape_(shape),
     name_(name)
 { }
 
-ICIn_NativePrototype::ICIn_NativePrototype(JitCode *stubCode, HandleShape shape,
+ICIn_NativePrototype::ICIn_NativePrototype(JitCode* stubCode, HandleShape shape,
                                            HandlePropertyName name, HandleObject holder,
                                            HandleShape holderShape)
   : ICInNativeStub(In_NativePrototype, stubCode, shape, name),
     holder_(holder),
     holderShape_(holderShape)
 { }
 
-ICIn_NativeDoesNotExist::ICIn_NativeDoesNotExist(JitCode *stubCode, size_t protoChainDepth,
+ICIn_NativeDoesNotExist::ICIn_NativeDoesNotExist(JitCode* stubCode, size_t protoChainDepth,
                                                  HandlePropertyName name)
   : ICStub(In_NativeDoesNotExist, stubCode),
     name_(name)
 {
     MOZ_ASSERT(protoChainDepth <= MAX_PROTO_CHAIN_DEPTH);
     extra_ = protoChainDepth;
 }
 
@@ -12402,35 +12402,35 @@ ICIn_NativeDoesNotExist::offsetOfShape(s
     MOZ_ASSERT(ICIn_NativeDoesNotExistImpl<0>::offsetOfShape(idx) ==
                ICIn_NativeDoesNotExistImpl<
                     ICIn_NativeDoesNotExist::MAX_PROTO_CHAIN_DEPTH>::offsetOfShape(idx));
     return ICIn_NativeDoesNotExistImpl<0>::offsetOfShape(idx);
 }
 
 template <size_t ProtoChainDepth>
 ICIn_NativeDoesNotExistImpl<ProtoChainDepth>::ICIn_NativeDoesNotExistImpl(
-        JitCode *stubCode, const AutoShapeVector *shapes, HandlePropertyName name)
+        JitCode* stubCode, const AutoShapeVector* shapes, HandlePropertyName name)
   : ICIn_NativeDoesNotExist(stubCode, ProtoChainDepth, name)
 {
     MOZ_ASSERT(shapes->length() == NumShapes);
     for (size_t i = 0; i < NumShapes; i++)
         shapes_[i].init((*shapes)[i]);
 }
 
 ICInNativeDoesNotExistCompiler::ICInNativeDoesNotExistCompiler(
-        JSContext *cx, HandleObject obj, HandlePropertyName name, size_t protoChainDepth)
+        JSContext* cx, HandleObject obj, HandlePropertyName name, size_t protoChainDepth)
   : ICStubCompiler(cx, ICStub::In_NativeDoesNotExist),
     obj_(cx, obj),
     name_(cx, name),
     protoChainDepth_(protoChainDepth)
 {
     MOZ_ASSERT(protoChainDepth_ <= ICIn_NativeDoesNotExist::MAX_PROTO_CHAIN_DEPTH);
 }
 
-ICIn_Dense::ICIn_Dense(JitCode *stubCode, HandleShape shape)
+ICIn_Dense::ICIn_Dense(JitCode* stubCode, HandleShape shape)
   : ICStub(In_Dense, stubCode),
     shape_(shape)
 { }
 
 ICGetName_Global::ICGetName_Global(JitCode* stubCode, ICStub* firstMonitorStub, Shape* shape,
                                    uint32_t slot)
   : ICMonitoredStub(GetName_Global, stubCode, firstMonitorStub),
     shape_(shape),
--- a/js/src/jit/BaselineIC.h
+++ b/js/src/jit/BaselineIC.h
@@ -3417,63 +3417,63 @@ class ICIn_Fallback : public ICFallbackS
 
 // Base class for In_Native and In_NativePrototype stubs.
 class ICInNativeStub : public ICStub
 {
     HeapPtrShape shape_;
     HeapPtrPropertyName name_;
 
   protected:
-    ICInNativeStub(ICStub::Kind kind, JitCode *stubCode, HandleShape shape,
+    ICInNativeStub(ICStub::Kind kind, JitCode* stubCode, HandleShape shape,
                    HandlePropertyName name);
 
   public:
-    HeapPtrShape &shape() {
+    HeapPtrShape& shape() {
         return shape_;
     }
     static size_t offsetOfShape() {
         return offsetof(ICInNativeStub, shape_);
     }
 
-    HeapPtrPropertyName &name() {
+    HeapPtrPropertyName& name() {
         return name_;
     }
     static size_t offsetOfName() {
         return offsetof(ICInNativeStub, name_);
     }
 };
 
 // Stub for confirming an own property on a native object.
 class ICIn_Native : public ICInNativeStub
 {
     friend class ICStubSpace;
 
-    ICIn_Native(JitCode *stubCode, HandleShape shape, HandlePropertyName name)
+    ICIn_Native(JitCode* stubCode, HandleShape shape, HandlePropertyName name)
       : ICInNativeStub(In_Native, stubCode, shape, name)
     {}
 };
 
 // Stub for confirming a property on a native object's prototype. Note that due to
 // the shape teleporting optimization, we only have to guard on the object's shape
 // and the holder's shape.
 class ICIn_NativePrototype : public ICInNativeStub
 {
     friend class ICStubSpace;
 
     HeapPtrObject holder_;
     HeapPtrShape holderShape_;
 
-    ICIn_NativePrototype(JitCode *stubCode, HandleShape shape, HandlePropertyName name,
+    ICIn_NativePrototype(JitCode* stubCode, HandleShape shape, HandlePropertyName name,
                          HandleObject holder, HandleShape holderShape);
 
   public:
-    HeapPtrObject &holder() {
+    HeapPtrObject& holder() {
         return holder_;
     }
-    HeapPtrShape &holderShape() {
+    HeapPtrShape& holderShape() {
         return holderShape_;
     }
     static size_t offsetOfHolder() {
         return offsetof(ICIn_NativePrototype, holder_);
     }
     static size_t offsetOfHolderShape() {
         return offsetof(ICIn_NativePrototype, holderShape_);
     }
@@ -3481,28 +3481,28 @@ class ICIn_NativePrototype : public ICIn
 
 // Compiler for In_Native and In_NativePrototype stubs.
 class ICInNativeCompiler : public ICStubCompiler
 {
     RootedObject obj_;
     RootedObject holder_;
     RootedPropertyName name_;
 
-    bool generateStubCode(MacroAssembler &masm);
+    bool generateStubCode(MacroAssembler& masm);
 
   public:
-    ICInNativeCompiler(JSContext *cx, ICStub::Kind kind, HandleObject obj, HandleObject holder,
+    ICInNativeCompiler(JSContext* cx, ICStub::Kind kind, HandleObject obj, HandleObject holder,
                        HandlePropertyName name)
       : ICStubCompiler(cx, kind),
         obj_(cx, obj),
         holder_(cx, holder),
         name_(cx, name)
     {}
 
-    ICStub *getStub(ICStubSpace *space) {
+    ICStub* getStub(ICStubSpace* space) {
         RootedShape shape(cx, obj_->as<NativeObject>().lastProperty());
         if (kind == ICStub::In_Native) {
             MOZ_ASSERT(obj_ == holder_);
             return ICStub::New<ICIn_Native>(space, getStubCode(), shape, name_);
         }
 
         MOZ_ASSERT(obj_ != holder_);
         MOZ_ASSERT(kind == ICStub::In_NativePrototype);
@@ -3519,32 +3519,32 @@ class ICIn_NativeDoesNotExist : public I
     friend class ICStubSpace;
 
     HeapPtrPropertyName name_;
 
   public:
     static const size_t MAX_PROTO_CHAIN_DEPTH = 8;
 
   protected:
-    ICIn_NativeDoesNotExist(JitCode *stubCode, size_t protoChainDepth,
+    ICIn_NativeDoesNotExist(JitCode* stubCode, size_t protoChainDepth,
                             HandlePropertyName name);
 
   public:
     size_t protoChainDepth() const {
         MOZ_ASSERT(extra_ <= MAX_PROTO_CHAIN_DEPTH);
         return extra_;
     }
-    HeapPtrPropertyName &name() {
+    HeapPtrPropertyName& name() {
         return name_;
     }
 
     template <size_t ProtoChainDepth>
-    ICIn_NativeDoesNotExistImpl<ProtoChainDepth> *toImpl() {
+    ICIn_NativeDoesNotExistImpl<ProtoChainDepth>* toImpl() {
         MOZ_ASSERT(ProtoChainDepth == protoChainDepth());
-        return static_cast<ICIn_NativeDoesNotExistImpl<ProtoChainDepth> *>(this);
+        return static_cast<ICIn_NativeDoesNotExistImpl<ProtoChainDepth>*>(this);
     }
 
     static size_t offsetOfShape(size_t idx);
     static size_t offsetOfName() {
         return offsetof(ICIn_NativeDoesNotExist, name_);
     }
 };
 
@@ -3555,21 +3555,21 @@ class ICIn_NativeDoesNotExistImpl : publ
 
   public:
     static const size_t MAX_PROTO_CHAIN_DEPTH = 8;
     static const size_t NumShapes = ProtoChainDepth + 1;
 
   private:
     mozilla::Array<HeapPtrShape, NumShapes> shapes_;
 
-    ICIn_NativeDoesNotExistImpl(JitCode *stubCode, const AutoShapeVector *shapes,
+    ICIn_NativeDoesNotExistImpl(JitCode* stubCode, const AutoShapeVector* shapes,
                                 HandlePropertyName name);
 
   public:
-    void traceShapes(JSTracer *trc) {
+    void traceShapes(JSTracer* trc) {
         for (size_t i = 0; i < NumShapes; i++)
             TraceEdge(trc, &shapes_[i], "baseline-innativedoesnotexist-stub-shape");
     }
 
     static size_t offsetOfShape(size_t idx) {
         return offsetof(ICIn_NativeDoesNotExistImpl, shapes_) + (idx * sizeof(HeapPtrShape));
     }
 };
@@ -3580,60 +3580,60 @@ class ICInNativeDoesNotExistCompiler : p
     RootedPropertyName name_;
     size_t protoChainDepth_;
 
   protected:
     virtual int32_t getKey() const {
         return static_cast<int32_t>(kind) | (static_cast<int32_t>(protoChainDepth_) << 16);
     }
 
-    bool generateStubCode(MacroAssembler &masm);
+    bool generateStubCode(MacroAssembler& masm);
 
   public:
-    ICInNativeDoesNotExistCompiler(JSContext *cx, HandleObject obj, HandlePropertyName name,
+    ICInNativeDoesNotExistCompiler(JSContext* cx, HandleObject obj, HandlePropertyName name,
                                    size_t protoChainDepth);
 
     template <size_t ProtoChainDepth>
-    ICStub *getStubSpecific(ICStubSpace *space, const AutoShapeVector *shapes) {
+    ICStub* getStubSpecific(ICStubSpace* space, const AutoShapeVector* shapes) {
         return ICStub::New<ICIn_NativeDoesNotExistImpl<ProtoChainDepth>>(space, getStubCode(),
                                                                          shapes, name_);
     }
 
-    ICStub *getStub(ICStubSpace *space);
+    ICStub* getStub(ICStubSpace* space);
 };
 
 class ICIn_Dense : public ICStub
 {
     friend class ICStubSpace;
 
     HeapPtrShape shape_;
 
-    ICIn_Dense(JitCode *stubCode, HandleShape shape);
+    ICIn_Dense(JitCode* stubCode, HandleShape shape);
 
   public:
-    HeapPtrShape &shape() {
+    HeapPtrShape& shape() {
         return shape_;
     }
     static size_t offsetOfShape() {
         return offsetof(ICIn_Dense, shape_);
     }
 
     class Compiler : public ICStubCompiler {
       RootedShape shape_;
 
       protected:
-        bool generateStubCode(MacroAssembler &masm);
+        bool generateStubCode(MacroAssembler& masm);
 
       public:
-        Compiler(JSContext *cx, Shape *shape)
+        Compiler(JSContext* cx, Shape* shape)
           : ICStubCompiler(cx, ICStub::In_Dense),
             shape_(cx, shape)
         {}
 
-        ICStub *getStub(ICStubSpace *space) {
+        ICStub* getStub(ICStubSpace* space) {
             return ICStub::New<ICIn_Dense>(space, getStubCode(), shape_);
         }
     };
 };
 
 // GetName
 //      JSOP_GETNAME
 //      JSOP_GETGNAME
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -1018,17 +1018,17 @@ static const size_t RegExpReservedStack 
 
 static size_t
 RegExpPairsVectorStartOffset(size_t inputOutputDataStartOffset)
 {
     return inputOutputDataStartOffset + sizeof(irregexp::InputOutputData) + sizeof(MatchPairs);
 }
 
 static Address
-RegExpPairCountAddress(MacroAssembler &masm, size_t inputOutputDataStartOffset)
+RegExpPairCountAddress(MacroAssembler& masm, size_t inputOutputDataStartOffset)
 {
     return Address(masm.getStackPointer(), inputOutputDataStartOffset
                                            + sizeof(irregexp::InputOutputData)
                                            + MatchPairs::offsetOfPairCount());
 }
 
 // Prepare an InputOutputData and optional MatchPairs which space has been
 // allocated for on the stack, and try to execute a RegExp on a string input.
--- a/js/src/jit/EffectiveAddressAnalysis.cpp
+++ b/js/src/jit/EffectiveAddressAnalysis.cpp
@@ -97,17 +97,17 @@ AnalyzeLsh(TempAllocator& alloc, MLsh* l
 
     MEffectiveAddress* eaddr = MEffectiveAddress::New(alloc, base, index, scale, displacement);
     last->replaceAllUsesWith(eaddr);
     last->block()->insertAfter(last, eaddr);
 }
 
 template<typename MAsmJSHeapAccessType>
 bool
-EffectiveAddressAnalysis::tryAddDisplacement(MAsmJSHeapAccessType *ins, int32_t o)
+EffectiveAddressAnalysis::tryAddDisplacement(MAsmJSHeapAccessType* ins, int32_t o)
 {
     // Compute the new offset. Check for overflow and negative. In theory it
     // ought to be possible to support negative offsets, but it'd require
     // more elaborate bounds checking mechanisms than we currently have.
     MOZ_ASSERT(ins->offset() >= 0);
     int32_t newOffset = uint32_t(ins->offset()) + o;
     if (newOffset < 0)
         return false;
--- a/js/src/jit/EffectiveAddressAnalysis.h
+++ b/js/src/jit/EffectiveAddressAnalysis.h
@@ -13,23 +13,23 @@ namespace jit {
 class MIRGraph;
 
 class EffectiveAddressAnalysis
 {
     MIRGenerator* mir_;
     MIRGraph& graph_;
 
     template<typename MAsmJSHeapAccessType>
-    bool tryAddDisplacement(MAsmJSHeapAccessType *ins, int32_t o);
+    bool tryAddDisplacement(MAsmJSHeapAccessType* ins, int32_t o);
 
     template<typename MAsmJSHeapAccessType>
     void analyzeAsmHeapAccess(MAsmJSHeapAccessType* ins);
 
   public:
-    EffectiveAddressAnalysis(MIRGenerator *mir, MIRGraph& graph)
+    EffectiveAddressAnalysis(MIRGenerator* mir, MIRGraph& graph)
       : mir_(mir), graph_(graph)
     {}
 
     bool analyze();
 };
 
 } /* namespace jit */
 } /* namespace js */
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -12878,17 +12878,17 @@ MConstant*
 IonBuilder::constant(const Value& v)
 {
     // For performance reason (TLS) and error code handling (AtomizeString), we
     // should prefer the specialized frunction constantMaybeAtomize instead of
     // constant.
     MOZ_ASSERT(!v.isString() || v.toString()->isAtom(),
                "To handle non-atomized strings, you should use constantMaybeAtomize instead of constant.");
     if (v.isString() && MOZ_UNLIKELY(!v.toString()->isAtom())) {
-        MConstant *cst = constantMaybeAtomize(v);
+        MConstant* cst = constantMaybeAtomize(v);
         if (!cst)
             js::CrashAtUnhandlableOOM("Use constantMaybeAtomize.");
         return cst;
     }
 
     MConstant* c = MConstant::New(alloc(), v, constraints());
     current->add(c);
     return c;
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -523,17 +523,17 @@ BaselineFrameAndStackPointersFromTryNote
 {
     JSScript* script = frame.baselineFrame()->script();
     *framePointer = frame.fp() - BaselineFrame::FramePointerOffset;
     *stackPointer = *framePointer - BaselineFrame::Size() -
                     (script->nfixed() + tn->stackDepth) * sizeof(Value);
 }
 
 static void
-SettleOnTryNote(JSContext* cx, JSTryNote *tn, const JitFrameIterator& frame,
+SettleOnTryNote(JSContext* cx, JSTryNote* tn, const JitFrameIterator& frame,
                 ScopeIter& si, ResumeFromException* rfe, jsbytecode** pc)
 {
     RootedScript script(cx, frame.baselineFrame()->script());
 
     // Unwind scope chain (pop block objects).
     if (cx->isExceptionPending())
         UnwindScope(cx, si, UnwindScopeToTryPc(script, tn));
 
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -8085,17 +8085,17 @@ class MNot
         operandIsNeverNaN_(false)
     {
         setResultType(MIRType_Boolean);
         setMovable();
         if (constraints)
             cacheOperandMightEmulateUndefined(constraints);
     }
 
-    void cacheOperandMightEmulateUndefined(CompilerConstraintList *constraints);
+    void cacheOperandMightEmulateUndefined(CompilerConstraintList* constraints);
 
   public:
     static MNot* New(TempAllocator& alloc, MDefinition* elements,
                      CompilerConstraintList* constraints = nullptr)
     {
         return new(alloc) MNot(elements, constraints);
     }
     static MNot* NewAsmJS(TempAllocator& alloc, MDefinition* elements) {
--- a/js/src/jit/MacroAssembler.h
+++ b/js/src/jit/MacroAssembler.h
@@ -965,25 +965,25 @@ class MacroAssembler : public MacroAssem
     void loadStackPtr(T t) { loadPtr(t, getStackPointer()); }
     template <typename T>
     void storeStackPtr(T t) { storePtr(getStackPointer(), t); }
 
     // StackPointer testing functions.
     // On ARM64, sp can function as the zero register depending on context.
     // Code shared across platforms must use these functions to be valid.
     template <typename T>
-    void branchTestStackPtr(Condition cond, T t, Label *label) {
+    void branchTestStackPtr(Condition cond, T t, Label* label) {
         branchTestPtr(cond, getStackPointer(), t, label);
     }
     template <typename T>
-    void branchStackPtr(Condition cond, T rhs, Label *label) {
+    void branchStackPtr(Condition cond, T rhs, Label* label) {
         branchPtr(cond, getStackPointer(), rhs, label);
     }
     template <typename T>
-    void branchStackPtrRhs(Condition cond, T lhs, Label *label) {
+    void branchStackPtrRhs(Condition cond, T lhs, Label* label) {
         branchPtr(cond, lhs, getStackPointer(), label);
     }
 #endif // !JS_CODEGEN_ARM64
 
   private:
     // These two functions are helpers used around call sites throughout the
     // assembler. They are called from the above call wrappers to emit the
     // necessary instrumentation.
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -979,17 +979,17 @@ JS_ValueToFunction(JSContext* cx, JS::Ha
 
 extern JS_PUBLIC_API(JSFunction*)
 JS_ValueToConstructor(JSContext* cx, JS::HandleValue v);
 
 extern JS_PUBLIC_API(JSString*)
 JS_ValueToSource(JSContext* cx, JS::Handle<JS::Value> v);
 
 extern JS_PUBLIC_API(bool)
-JS_DoubleIsInt32(double d, int32_t *ip);
+JS_DoubleIsInt32(double d, int32_t* ip);
 
 extern JS_PUBLIC_API(JSType)
 JS_TypeOfValue(JSContext* cx, JS::Handle<JS::Value> v);
 
 extern JS_PUBLIC_API(bool)
 JS_StrictlyEqual(JSContext* cx, JS::Handle<JS::Value> v1, JS::Handle<JS::Value> v2, bool* equal);
 
 extern JS_PUBLIC_API(bool)
@@ -5425,24 +5425,24 @@ struct PerformanceGroup {
     // the performance of this performance group for this iteration
     // of the event loop, `false` otherwise.
     bool hasStopwatch(uint64_t iteration) const {
         return stopwatch_ != nullptr && iteration_ == iteration;
     }
 
     // Mark that an instance of `AutoStopwatch` is monitoring
     // the performance of this group for a given iteration.
-    void acquireStopwatch(uint64_t iteration, const AutoStopwatch *stopwatch) {
+    void acquireStopwatch(uint64_t iteration, const AutoStopwatch* stopwatch) {
         iteration_ = iteration;
         stopwatch_ = stopwatch;
     }
 
     // Mark that no `AutoStopwatch` is monitoring the
     // performance of this group for the iteration.
-    void releaseStopwatch(uint64_t iteration, const AutoStopwatch *stopwatch) {
+    void releaseStopwatch(uint64_t iteration, const AutoStopwatch* stopwatch) {
         if (iteration_ != iteration)
             return;
 
         MOZ_ASSERT(stopwatch == stopwatch_ || stopwatch_ == nullptr);
         stopwatch_ = nullptr;
     }
 
     PerformanceGroup()
@@ -5455,17 +5455,17 @@ struct PerformanceGroup {
         MOZ_ASSERT(refCount_ == 0);
     }
   private:
     PerformanceGroup& operator=(const PerformanceGroup&) = delete;
     PerformanceGroup(const PerformanceGroup&) = delete;
 
     // The stopwatch currently monitoring the group,
     // or `nullptr` if none. Used ony for comparison.
-    const AutoStopwatch *stopwatch_;
+    const AutoStopwatch* stopwatch_;
 
     // The current iteration of the event loop. If necessary,
     // may safely overflow.
     uint64_t iteration_;
 
     // Increment/decrement the refcounter, return the updated value.
     uint64_t incRefCount() {
         MOZ_ASSERT(refCount_ + 1 > 0);
@@ -5485,50 +5485,50 @@ struct PerformanceGroup {
 //
 // Indirection towards a PerformanceGroup.
 // This structure handles reference counting for instances of PerformanceGroup.
 //
 struct PerformanceGroupHolder {
     // Get the group.
     // On first call, this causes a single Hashtable lookup.
     // Successive calls do not require further lookups.
-    js::PerformanceGroup *getGroup();
+    js::PerformanceGroup* getGroup();
 
     // `true` if the this holder is currently associated to a
     // PerformanceGroup, `false` otherwise. Use this method to avoid
     // instantiating a PerformanceGroup if you only need to get
     // available performance data.
     inline bool isLinked() const {
         return group_ != nullptr;
     }
 
     // Remove the link to the PerformanceGroup. This method is designed
     // as an invalidation mechanism if the JSCompartment changes nature
     // (new values of `isSystem()`, `principals()` or `addonId`).
     void unlink();
 
-    PerformanceGroupHolder(JSRuntime *runtime, JSCompartment *compartment)
+    PerformanceGroupHolder(JSRuntime* runtime, JSCompartment* compartment)
       : runtime_(runtime)
       , compartment_(compartment)
       , group_(nullptr)
     {   }
     ~PerformanceGroupHolder();
 private:
     // Return the key representing this PerformanceGroup in
     // Runtime::Stopwatch.
     // Do not deallocate the key.
     void* getHashKey();
 
-    JSRuntime *runtime_;
-    JSCompartment *compartment_;
+    JSRuntime* runtime_;
+    JSCompartment* compartment_;
 
     // The PerformanceGroup held by this object.
     // Initially set to `nullptr` until the first cal to `getGroup`.
     // May be reset to `nullptr` by a call to `unlink`.
-    js::PerformanceGroup *group_;
+    js::PerformanceGroup* group_;
 };
 
 /**
  * Reset any stopwatch currently measuring.
  *
  * This function is designed to be called when we process a new event.
  */
 extern JS_PUBLIC_API(void)
@@ -5555,17 +5555,17 @@ GetPerformanceData(JSRuntime*);
  * Performance statistics for a performance group (a process, an
  * add-on, a webpage, the built-ins or a special compartment).
  */
 struct PerformanceStats {
     /**
      * If this group represents an add-on, the ID of the addon,
      * otherwise `nullptr`.
      */
-    JSAddonId *addonId;
+    JSAddonId* addonId;
 
     /**
      * If this group represents a webpage, the process itself or a special
      * compartment, a human-readable name. Unspecified for add-ons.
      */
     char name[1024];
 
     /**
@@ -5593,14 +5593,14 @@ typedef js::Vector<PerformanceStats, 0, 
     /**
  * Extract the performance statistics.
  *
  * After a successful call, `stats` holds the `PerformanceStats` for
  * all performance groups, and `global` holds a `PerformanceStats`
  * representing the entire process.
  */
 extern JS_PUBLIC_API(bool)
-GetPerformanceStats(JSRuntime *rt, js::PerformanceStatsVector &stats, js::PerformanceStats &global);
+GetPerformanceStats(JSRuntime* rt, js::PerformanceStatsVector& stats, js::PerformanceStats& global);
 
 } /* namespace js */
 
 
 #endif /* jsapi_h */
--- a/js/src/jscntxt.cpp
+++ b/js/src/jscntxt.cpp
@@ -759,19 +759,19 @@ js::ReportErrorNumberVA(JSContext* cx, u
         js_free((void*)report.messageArgs);
     }
     js_free((void*)report.ucmessage);
 
     return warning;
 }
 
 static bool
-ExpandErrorArguments(ExclusiveContext *cx, JSErrorCallback callback,
-                     void *userRef, const unsigned errorNumber,
-                     char **messagep, JSErrorReport *reportp,
+ExpandErrorArguments(ExclusiveContext* cx, JSErrorCallback callback,
+                     void* userRef, const unsigned errorNumber,
+                     char** messagep, JSErrorReport* reportp,
                      ErrorArgumentsType argumentsType, ...)
 {
     va_list ap;
     va_start(ap, argumentsType);
     bool expanded = js::ExpandErrorArgumentsVA(cx, callback, userRef, errorNumber,
                                                messagep, reportp, argumentsType, ap);
     va_end(ap);
     return expanded;
--- a/js/src/jsobj.cpp
+++ b/js/src/jsobj.cpp
@@ -4036,39 +4036,39 @@ JSObject::addSizeOfExcludingThis(mozilla
 size_t
 JSObject::sizeOfIncludingThisInNursery() const
 {
     // This function doesn't concern itself yet with typed objects (bug 1133593)
     // nor unboxed objects (bug 1133592).
 
     MOZ_ASSERT(!isTenured());
 
-    const Nursery &nursery = compartment()->runtimeFromAnyThread()->gc.nursery;
+    const Nursery& nursery = compartment()->runtimeFromAnyThread()->gc.nursery;
     size_t size = Arena::thingSize(allocKindForTenure(nursery));
 
     if (is<NativeObject>()) {
-        const NativeObject &native = as<NativeObject>();
+        const NativeObject& native = as<NativeObject>();
 
         size += native.numFixedSlots() * sizeof(Value);
         size += native.numDynamicSlots() * sizeof(Value);
 
         if (native.hasDynamicElements()) {
-            js::ObjectElements &elements = *native.getElementsHeader();
+            js::ObjectElements& elements = *native.getElementsHeader();
             if (!elements.isCopyOnWrite() || elements.ownerObject() == this)
                 size += elements.capacity * sizeof(HeapSlot);
         }
     }
 
     return size;
 }
 
 size_t
 JS::ubi::Concrete<JSObject>::size(mozilla::MallocSizeOf mallocSizeOf) const
 {
-    JSObject &obj = get();
+    JSObject& obj = get();
 
     if (!obj.isTenured())
         return obj.sizeOfIncludingThisInNursery();
 
     JS::ClassInfo info;
     obj.addSizeOfExcludingThis(mallocSizeOf, &info);
     return obj.tenuredSizeOfThis() + info.sizeOfAllThings();
 }
--- a/js/src/jsobj.h
+++ b/js/src/jsobj.h
@@ -278,17 +278,17 @@ class JSObject : public js::gc::Cell
     }
     static MOZ_ALWAYS_INLINE void readBarrier(JSObject* obj);
     static MOZ_ALWAYS_INLINE void writeBarrierPre(JSObject* obj);
     static MOZ_ALWAYS_INLINE void writeBarrierPost(JSObject* obj, void* cellp);
     static MOZ_ALWAYS_INLINE void writeBarrierPostRelocate(JSObject* obj, void* cellp);
     static MOZ_ALWAYS_INLINE void writeBarrierPostRemove(JSObject* obj, void* cellp);
 
     /* Return the allocKind we would use if we were to tenure this object. */
-    js::gc::AllocKind allocKindForTenure(const js::Nursery &nursery) const;
+    js::gc::AllocKind allocKindForTenure(const js::Nursery& nursery) const;
 
     size_t tenuredSizeOfThis() const {
         MOZ_ASSERT(isTenured());
         return js::gc::Arena::thingSize(asTenured().getAllocKind());
     }
 
     void addSizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf, JS::ClassInfo* info);
 
--- a/js/src/jspropertytree.cpp
+++ b/js/src/jspropertytree.cpp
@@ -305,17 +305,17 @@ Shape::fixupAfterMovingGC()
 {
     if (inDictionary())
         fixupDictionaryShapeAfterMovingGC();
     else
         fixupShapeTreeAfterMovingGC();
 }
 
 void
-Shape::fixupGetterSetterForBarrier(JSTracer *trc)
+Shape::fixupGetterSetterForBarrier(JSTracer* trc)
 {
     // Relocating the getterObj or setterObj will change our location in our
     // parent's KidsHash, so remove ourself first if we're going to get moved.
     if (parent && !parent->inDictionary() && parent->kids.isHash()) {
         KidsHash* kh = parent->kids.toHash();
         MOZ_ASSERT(kh->lookup(StackShape(this)));
         kh->remove(StackShape(this));
     }
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -403,17 +403,17 @@ namespace js {
 // group performance stats).
 struct AutoStopwatch final
 {
     // If the stopwatch is active, constructing an instance of
     // AutoStopwatch causes it to become the current owner of the
     // stopwatch.
     //
     // Previous owner is restored upon destruction.
-    explicit inline AutoStopwatch(JSContext *cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+    explicit inline AutoStopwatch(JSContext* cx MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
       : compartment_(nullptr)
       , runtime_(nullptr)
       , iteration_(0)
       , isActive_(false)
       , isTop_(false)
       , userTimeStart_(0)
       , systemTimeStart_(0)
       , CPOWTimeStart_(0)
@@ -423,17 +423,17 @@ struct AutoStopwatch final
         if (!runtime_->stopwatch.isActive())
             return;
         compartment_ = cx->compartment();
         MOZ_ASSERT(compartment_);
         if (compartment_->scheduledForDestruction)
             return;
         iteration_ = runtime_->stopwatch.iteration;
 
-        PerformanceGroup *group = compartment_->performanceMonitoring.getGroup();
+        PerformanceGroup* group = compartment_->performanceMonitoring.getGroup();
         MOZ_ASSERT(group);
 
         if (group->hasStopwatch(iteration_)) {
             // Someone is already monitoring this group during this
             // tick, no need for further monitoring.
             return;
         }
 
@@ -472,17 +472,17 @@ struct AutoStopwatch final
         }
 
         if (iteration_ != runtime_->stopwatch.iteration) {
             // We have entered a nested event loop at some point.
             // Any information we may have is obsolete.
             return;
         }
 
-        PerformanceGroup *group = compartment_->performanceMonitoring.getGroup();
+        PerformanceGroup* group = compartment_->performanceMonitoring.getGroup();
         MOZ_ASSERT(group);
 
         // Compute time spent.
         group->releaseStopwatch(iteration_, this);
         uint64_t userTimeEnd, systemTimeEnd;
         if (!this->getTimes(&userTimeEnd, &systemTimeEnd))
             return;
 
@@ -601,21 +601,21 @@ struct AutoStopwatch final
 #endif // defined(XP_MACOSX) || defined(XP_UNIX) || defined(XP_WIN)
 
         return true;
     }
 
   private:
     // The compartment with which this object was initialized.
     // Non-null.
-    JSCompartment *compartment_;
+    JSCompartment* compartment_;
 
     // The runtime with which this object was initialized.
     // Non-null.
-    JSRuntime *runtime_;
+    JSRuntime* runtime_;
 
     // An indication of the number of times we have entered the event
     // loop.  Used only for comparison.
     uint64_t iteration_;
 
     // `true` if this object is currently used to monitor performance,
     // `false` otherwise, i.e. if the stopwatch mechanism is off or if
     // another stopwatch is already in charge of monitoring for the
--- a/js/src/vm/Interpreter.h
+++ b/js/src/vm/Interpreter.h
@@ -318,17 +318,17 @@ class MOZ_STACK_CLASS TryNoteIter
         settle();
     }
 
     bool done() const { return tn_ == tnEnd_; }
     JSTryNote* operator*() const { return tn_; }
 };
 
 bool
-HandleClosingGeneratorReturn(JSContext *cx, AbstractFramePtr frame, bool ok);
+HandleClosingGeneratorReturn(JSContext* cx, AbstractFramePtr frame, bool ok);
 
 /************************************************************************/
 
 bool
 Throw(JSContext* cx, HandleValue v);
 
 bool
 ThrowingOperation(JSContext* cx, HandleValue v);
--- a/js/src/vm/ObjectGroup.h
+++ b/js/src/vm/ObjectGroup.h
@@ -535,17 +535,17 @@ class ObjectGroup : public gc::TenuredCe
     void clearNewScript(ExclusiveContext* cx, ObjectGroup* replacement = nullptr);
     bool isPropertyNonData(jsid id);
     bool isPropertyNonWritable(jsid id);
 
     void print();
 
     inline void clearProperties();
     void maybeSweep(AutoClearTypeInferenceStateOnOOM* oom);
-    void traceChildren(JSTracer *trc);
+    void traceChildren(JSTracer* trc);
 
   private:
 #ifdef DEBUG
     bool needsSweep();
 #endif
 
     uint32_t generation() {
         return (flags_ & OBJECT_FLAG_GENERATION_MASK) >> OBJECT_FLAG_GENERATION_SHIFT;
--- a/js/src/vm/Runtime.cpp
+++ b/js/src/vm/Runtime.cpp
@@ -865,31 +865,31 @@ JS::UpdateJSRuntimeProfilerSampleBufferG
 JS_FRIEND_API(bool)
 JS::IsProfilingEnabledForRuntime(JSRuntime* runtime)
 {
     MOZ_ASSERT(runtime);
     return runtime->spsProfiler.enabled();
 }
 
 void
-js::ResetStopwatches(JSRuntime *rt)
+js::ResetStopwatches(JSRuntime* rt)
 {
     MOZ_ASSERT(rt);
     rt->stopwatch.reset();
 }
 
 bool
-js::SetStopwatchActive(JSRuntime *rt, bool isActive)
+js::SetStopwatchActive(JSRuntime* rt, bool isActive)
 {
     MOZ_ASSERT(rt);
     return rt->stopwatch.setIsActive(isActive);
 }
 
 bool
-js::IsStopwatchActive(JSRuntime *rt)
+js::IsStopwatchActive(JSRuntime* rt)
 {
     MOZ_ASSERT(rt);
     return rt->stopwatch.isActive();
 }
 
 js::PerformanceGroupHolder::~PerformanceGroupHolder()
 {
     unlink();
@@ -926,17 +926,17 @@ js::PerformanceGroupHolder::unlink()
 
     JSRuntime::Stopwatch::Groups::Ptr ptr =
         runtime_->stopwatch.groups_.lookup(getHashKey());
     MOZ_ASSERT(ptr);
     runtime_->stopwatch.groups_.remove(ptr);
     js_delete(group);
 }
 
-PerformanceGroup *
+PerformanceGroup*
 js::PerformanceGroupHolder::getGroup()
 {
     if (group_)
         return group_;
 
     void* key = getHashKey();
     JSRuntime::Stopwatch::Groups::AddPtr ptr =
         runtime_->stopwatch.groups_.lookupForAdd(key);
@@ -949,12 +949,12 @@ js::PerformanceGroupHolder::getGroup()
     }
 
     group_->incRefCount();
 
     return group_;
 }
 
 PerformanceData*
-js::GetPerformanceData(JSRuntime *rt)
+js::GetPerformanceData(JSRuntime* rt)
 {
     return &rt->stopwatch.performance;
 }
--- a/js/src/vm/Shape.h
+++ b/js/src/vm/Shape.h
@@ -965,17 +965,17 @@ class Shape : public gc::TenuredCell
     static inline ThingRootKind rootKind() { return THING_ROOT_SHAPE; }
 
     inline void traceChildren(JSTracer* trc);
 
     inline Shape* search(ExclusiveContext* cx, jsid id);
     inline Shape* searchLinear(jsid id);
 
     void fixupAfterMovingGC();
-    void fixupGetterSetterForBarrier(JSTracer *trc);
+    void fixupGetterSetterForBarrier(JSTracer* trc);
 
     /* For JIT usage */
     static inline size_t offsetOfBase() { return offsetof(Shape, base_); }
     static inline size_t offsetOfSlotInfo() { return offsetof(Shape, slotInfo); }
     static inline uint32_t fixedSlotsMask() { return FIXED_SLOTS_MASK; }
 
   private:
     void fixupDictionaryShapeAfterMovingGC();
@@ -1247,24 +1247,24 @@ class ShapeGetterSetterRef : public gc::
     void mark(JSTracer* trc) { shape_->fixupGetterSetterForBarrier(trc); }
 };
 
 static inline void
 GetterSetterWriteBarrierPost(AccessorShape* shape)
 {
     MOZ_ASSERT(shape);
     if (shape->hasGetterObject()) {
-        gc::StoreBuffer *sb = reinterpret_cast<gc::Cell*>(shape->getterObject())->storeBuffer();
+        gc::StoreBuffer* sb = reinterpret_cast<gc::Cell*>(shape->getterObject())->storeBuffer();
         if (sb) {
             sb->putGeneric(ShapeGetterSetterRef(shape));
             return;
         }
     }
     if (shape->hasSetterObject()) {
-        gc::StoreBuffer *sb = reinterpret_cast<gc::Cell*>(shape->setterObject())->storeBuffer();
+        gc::StoreBuffer* sb = reinterpret_cast<gc::Cell*>(shape->setterObject())->storeBuffer();
         if (sb) {
             sb->putGeneric(ShapeGetterSetterRef(shape));
             return;
         }
     }
 }
 
 inline
--- a/js/src/vm/TypedArrayObject.cpp
+++ b/js/src/vm/TypedArrayObject.cpp
@@ -2106,18 +2106,18 @@ js::StringIsTypedArrayIndex(const CharT*
 template bool
 js::StringIsTypedArrayIndex(const char16_t* s, size_t length, uint64_t* indexp);
 
 template bool
 js::StringIsTypedArrayIndex(const Latin1Char* s, size_t length, uint64_t* indexp);
 
 /* ES6 draft rev 34 (2015 Feb 20) 9.4.5.3 [[DefineOwnProperty]] step 3.c. */
 bool
-js::DefineTypedArrayElement(JSContext *cx, HandleObject obj, uint64_t index,
-                            Handle<PropertyDescriptor> desc, ObjectOpResult &result)
+js::DefineTypedArrayElement(JSContext* cx, HandleObject obj, uint64_t index,
+                            Handle<PropertyDescriptor> desc, ObjectOpResult& result)
 {
     MOZ_ASSERT(IsAnyTypedArray(obj));
 
     // These are all substeps of 3.c.
     // Steps i-vi.
     // We (wrongly) ignore out of range defines with a value.
     if (index >= AnyTypedArrayLength(obj))
         return result.succeed();
--- a/js/src/vm/TypedArrayObject.h
+++ b/js/src/vm/TypedArrayObject.h
@@ -286,18 +286,18 @@ IsTypedArrayIndex(jsid id, uint64_t* ind
     return StringIsTypedArrayIndex(s, length, indexp);
 }
 
 /*
  * Implements [[DefineOwnProperty]] for TypedArrays and SharedTypedArrays
  * when the property key is a TypedArray index.
  */
 bool
-DefineTypedArrayElement(JSContext *cx, HandleObject arr, uint64_t index,
-                        Handle<PropertyDescriptor> desc, ObjectOpResult &result);
+DefineTypedArrayElement(JSContext* cx, HandleObject arr, uint64_t index,
+                        Handle<PropertyDescriptor> desc, ObjectOpResult& result);
 
 static inline unsigned
 TypedArrayShift(Scalar::Type viewType)
 {
     switch (viewType) {
       case Scalar::Int8:
       case Scalar::Uint8:
       case Scalar::Uint8Clamped:
--- a/js/xpconnect/src/XPCConvert.cpp
+++ b/js/xpconnect/src/XPCConvert.cpp
@@ -560,17 +560,17 @@ XPCConvert::JSData2Native(void* d, Handl
             if (chars)
                 CheckCharsInCharRange(chars, len);
         }
 #endif // DEBUG
         size_t length = JS_GetStringEncodingLength(cx, str);
         if (length == size_t(-1)) {
             return false;
         }
-        char* buffer = static_cast<char *>(moz_xmalloc(length + 1));
+        char* buffer = static_cast<char*>(moz_xmalloc(length + 1));
         if (!buffer) {
             return false;
         }
         JS_EncodeStringToBuffer(cx, str, buffer, length);
         buffer[length] = '\0';
         *((void**)d) = buffer;
         return true;
     }
@@ -1716,17 +1716,17 @@ XPCConvert::JSStringWithSize2Native(void
                 return false;
             }
             len = uint32_t(length);
 
             if (len < count)
                 len = count;
 
             uint32_t alloc_len = (len + 1) * sizeof(char);
-            char* buffer = static_cast<char *>(moz_xmalloc(alloc_len));
+            char* buffer = static_cast<char*>(moz_xmalloc(alloc_len));
             if (!buffer) {
                 return false;
             }
             JS_EncodeStringToBuffer(cx, str, buffer, len);
             buffer[len] = '\0';
             *((char**)d) = buffer;
 
             return true;