Bug 1277775 - Replace MOZ_CONSTEXPR{_VAR,_TMPL} with constexpr. r=froydnj
authorChris Peterson <cpeterson@mozilla.com>
Fri, 08 Jul 2016 14:39:53 -0700
changeset 304308 96875d7ae6f2f4cb0f56cd872eaae90345933563
parent 304307 6e8cf178dae89be067d3f16d9fbd92aae08476b9
child 304309 408eb09d21b449bfcc554a427b88d4a74a4072a9
push id30420
push userphilringnalda@gmail.com
push dateSat, 09 Jul 2016 15:52:07 +0000
treeherdermozilla-central@d55b1b1d51cf [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1277775
milestone50.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 1277775 - Replace MOZ_CONSTEXPR{_VAR,_TMPL} with constexpr. r=froydnj
accessible/windows/msaa/IDSet.h
devtools/shared/heapsnapshot/HeapSnapshot.cpp
dom/animation/AnimationPerformanceWarning.h
dom/animation/KeyframeEffect.h
dom/base/WindowNamedPropertiesHandler.h
dom/base/nsGlobalWindow.cpp
dom/base/nsJSEnvironment.cpp
dom/bindings/BindingUtils.h
dom/bindings/Codegen.py
dom/bindings/DOMJSClass.h
dom/bindings/DOMJSProxyHandler.h
dom/cache/DBSchema.cpp
dom/cellbroadcast/CellBroadcastMessage.cpp
dom/events/EventStates.h
dom/html/HTMLTrackElement.cpp
dom/indexedDB/ActorsParent.cpp
dom/ipc/Blob.cpp
dom/smil/SMILBoolType.h
dom/smil/SMILEnumType.h
dom/smil/SMILIntegerType.h
dom/smil/SMILStringType.h
dom/smil/nsSMILCSSValueType.h
dom/smil/nsSMILFloatType.h
dom/smil/nsSMILNullType.h
dom/svg/SVGIntegerPairSMILType.h
dom/svg/SVGLengthListSMILType.h
dom/svg/SVGMotionSMILType.h
dom/svg/SVGNumberListSMILType.h
dom/svg/SVGNumberPairSMILType.h
dom/svg/SVGOrientSMILType.h
dom/svg/SVGPathSegListSMILType.h
dom/svg/SVGPointListSMILType.h
dom/svg/SVGTransformListSMILType.h
dom/svg/SVGViewBoxSMILType.h
gfx/2d/BaseCoord.h
gfx/2d/BasePoint.h
gfx/2d/BaseSize.h
gfx/2d/Coord.h
gfx/2d/Point.h
gfx/2d/ScaleFactor.h
gfx/2d/ScaleFactors2D.h
gfx/gl/GLXLibrary.h
ipc/dbus/DBusConnectionDelete.h
js/ipc/WrapperOwner.cpp
js/public/Proxy.h
js/public/RootingAPI.h
js/public/Utility.h
js/public/Value.h
js/src/frontend/TokenStream.h
js/src/gc/Heap.h
js/src/jit/AtomicOp.h
js/src/jit/RegisterAllocator.h
js/src/jit/RegisterSets.h
js/src/jit/Registers.h
js/src/jit/VMFunctions.h
js/src/jit/arm/Architecture-arm.h
js/src/jit/arm/Assembler-arm.cpp
js/src/jit/arm/Assembler-arm.h
js/src/jit/arm/SharedICRegisters-arm.h
js/src/jit/arm64/Architecture-arm64.h
js/src/jit/arm64/Assembler-arm64.h
js/src/jit/mips-shared/Assembler-mips-shared.h
js/src/jit/mips32/Architecture-mips32.h
js/src/jit/mips32/Assembler-mips32.h
js/src/jit/mips32/SharedICRegisters-mips32.h
js/src/jit/mips64/Architecture-mips64.h
js/src/jit/mips64/Assembler-mips64.h
js/src/jit/mips64/SharedICRegisters-mips64.h
js/src/jit/none/Architecture-none.h
js/src/jit/none/MacroAssembler-none.h
js/src/jit/none/SharedICRegisters-none.h
js/src/jit/x64/Assembler-x64.h
js/src/jit/x64/SharedICRegisters-x64.h
js/src/jit/x86-shared/Architecture-x86-shared.h
js/src/jit/x86/Assembler-x86.h
js/src/jit/x86/SharedICRegisters-x86.h
js/src/jsapi-tests/testJitMoveEmitterCycles-mips32.cpp
js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
js/src/jswrapper.h
js/src/proxy/DeadObjectProxy.h
js/src/proxy/ScriptedProxyHandler.h
js/src/vm/NativeObject.h
js/src/vm/Opcodes.h
js/src/vm/ScopeObject.cpp
js/src/vm/TypedArrayObject.cpp
js/xpconnect/src/XPCComponents.cpp
js/xpconnect/wrappers/AddonWrapper.h
js/xpconnect/wrappers/ChromeObjectWrapper.h
js/xpconnect/wrappers/FilteringWrapper.h
js/xpconnect/wrappers/WaiveXrayWrapper.h
js/xpconnect/wrappers/XrayWrapper.h
layout/base/FramePropertyTable.h
layout/base/nsChangeHint.h
layout/generic/JustificationUtils.h
layout/generic/nsIFrame.h
layout/style/CounterStyleManager.cpp
layout/style/CounterStyleManager.h
layout/style/nsCSSParser.cpp
layout/style/nsRuleNode.cpp
mfbt/ArrayUtils.h
mfbt/Atomics.h
mfbt/Attributes.h
mfbt/FloatingPoint.h
mfbt/IndexSequence.h
mfbt/InitializerList.h
mfbt/SplayTree.h
mfbt/TypedEnumBits.h
mfbt/UniquePtr.h
mfbt/XorShift128PlusRNG.h
mozglue/misc/TimeStamp.h
mozglue/misc/TimeStamp_windows.h
storage/mozStorageAsyncStatement.cpp
storage/mozStorageStatement.cpp
toolkit/components/telemetry/Telemetry.cpp
toolkit/components/terminator/nsTerminator.cpp
toolkit/xre/nsAppRunner.cpp
widget/android/AndroidGraphicBuffer.cpp
widget/gonk/hwchal/HwcHALBase.h
xpcom/base/CycleCollectedJSRuntime.h
xpcom/base/Logging.h
xpcom/base/nsError.h
xpcom/base/nsMemoryImpl.h
xpcom/glue/PLDHashTable.h
xpcom/glue/nsCycleCollectionParticipant.h
xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
--- a/accessible/windows/msaa/IDSet.h
+++ b/accessible/windows/msaa/IDSet.h
@@ -26,17 +26,17 @@ namespace a11y {
  * it can be allocated again.  Allocated ID are tracked by a sparse bitmap
  * implemented with a splay tree.  Nodes in the tree are keyed by the upper N
  * bits of the bitwise negation of the ID, and the node contains a bitmap
  * tracking the allocation of 2^(32 - N) IDs.
  */
 class IDSet
 {
 public:
-  MOZ_CONSTEXPR IDSet() : mBitSet(), mIdx(0) {}
+  constexpr IDSet() : mBitSet(), mIdx(0) {}
 
   /**
    * Return a new unique id.
    */
   uint32_t GetID()
   {
     uint32_t idx = mIdx;
     while (true) {
--- a/devtools/shared/heapsnapshot/HeapSnapshot.cpp
+++ b/devtools/shared/heapsnapshot/HeapSnapshot.cpp
@@ -1442,17 +1442,17 @@ HeapSnapshot::CreateUniqueCoreDumpFile(E
 
   return file.forget();
 }
 
 // Deletion policy for cleaning up PHeapSnapshotTempFileHelperChild pointers.
 class DeleteHeapSnapshotTempFileHelperChild
 {
 public:
-  MOZ_CONSTEXPR DeleteHeapSnapshotTempFileHelperChild() { }
+  constexpr DeleteHeapSnapshotTempFileHelperChild() { }
 
   void operator()(PHeapSnapshotTempFileHelperChild* ptr) const {
     NS_WARN_IF(!HeapSnapshotTempFileHelperChild::Send__delete__(ptr));
   }
 };
 
 // A UniquePtr alias to automatically manage PHeapSnapshotTempFileHelperChild
 // pointers.
--- a/dom/animation/AnimationPerformanceWarning.h
+++ b/dom/animation/AnimationPerformanceWarning.h
@@ -44,17 +44,17 @@ struct AnimationPerformanceWarning
 
   // Maximum number of parameters passed to
   // nsContentUtils::FormatLocalizedString to localize warning messages.
   //
   // NOTE: This constexpr can't be forward declared, so if you want to use
   // this variable, please include this header file directly.
   // This value is the same as the limit of nsStringBundle::FormatString.
   // See the implementation of nsStringBundle::FormatString.
-  static MOZ_CONSTEXPR_VAR uint8_t kMaxParamsForLocalization = 10;
+  static constexpr uint8_t kMaxParamsForLocalization = 10;
 
   // Indicates why this property could not be animated on the compositor.
   Type mType;
 
   // Optional parameters that may be used for localization.
   Maybe<nsTArray<int32_t>> mParams;
 
   bool ToLocalizedString(nsXPIDLString& aLocalizedString) const;
--- a/dom/animation/KeyframeEffect.h
+++ b/dom/animation/KeyframeEffect.h
@@ -102,17 +102,17 @@ struct Keyframe
     mOffset         = aOther.mOffset;
     mComputedOffset = aOther.mComputedOffset;
     mTimingFunction = Move(aOther.mTimingFunction);
     mPropertyValues = Move(aOther.mPropertyValues);
     return *this;
   }
 
   Maybe<double>                 mOffset;
-  static MOZ_CONSTEXPR_VAR double kComputedOffsetNotSet = -1.0;
+  static constexpr double kComputedOffsetNotSet = -1.0;
   double                        mComputedOffset = kComputedOffsetNotSet;
   Maybe<ComputedTimingFunction> mTimingFunction; // Nothing() here means
                                                  // "linear"
   nsTArray<PropertyValuePair>   mPropertyValues;
 };
 
 struct AnimationPropertySegment
 {
--- a/dom/base/WindowNamedPropertiesHandler.h
+++ b/dom/base/WindowNamedPropertiesHandler.h
@@ -10,17 +10,17 @@
 #include "mozilla/dom/DOMJSProxyHandler.h"
 
 namespace mozilla {
 namespace dom {
 
 class WindowNamedPropertiesHandler : public BaseDOMProxyHandler
 {
 public:
-  MOZ_CONSTEXPR WindowNamedPropertiesHandler()
+  constexpr WindowNamedPropertiesHandler()
     : BaseDOMProxyHandler(nullptr, /* hasPrototype = */ true)
   {
   }
   virtual bool
   getOwnPropDescriptor(JSContext* aCx, JS::Handle<JSObject*> aProxy,
                        JS::Handle<jsid> aId,
                        bool /* unused */,
                        JS::MutableHandle<JS::PropertyDescriptor> aDesc)
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -664,17 +664,17 @@ NS_IMPL_CYCLE_COLLECTING_RELEASE(DialogV
 
 //*****************************************************************************
 // nsOuterWindowProxy: Outer Window Proxy
 //*****************************************************************************
 
 class nsOuterWindowProxy : public js::Wrapper
 {
 public:
-  MOZ_CONSTEXPR nsOuterWindowProxy() : js::Wrapper(0) { }
+  constexpr nsOuterWindowProxy() : js::Wrapper(0) { }
 
   virtual bool finalizeInBackground(JS::Value priv) const override {
     return false;
   }
 
   // Standard internal methods
   virtual bool getOwnPropertyDescriptor(JSContext* cx,
                                         JS::Handle<JSObject*> proxy,
@@ -1134,17 +1134,17 @@ nsOuterWindowProxy::ObjectMoved(JSObject
 }
 
 const nsOuterWindowProxy
 nsOuterWindowProxy::singleton;
 
 class nsChromeOuterWindowProxy : public nsOuterWindowProxy
 {
 public:
-  MOZ_CONSTEXPR nsChromeOuterWindowProxy() : nsOuterWindowProxy() { }
+  constexpr nsChromeOuterWindowProxy() : nsOuterWindowProxy() { }
 
   virtual const char *className(JSContext *cx, JS::Handle<JSObject*> wrapper) const override;
 
   static const nsChromeOuterWindowProxy singleton;
 };
 
 const char *
 nsChromeOuterWindowProxy::className(JSContext *cx,
--- a/dom/base/nsJSEnvironment.cpp
+++ b/dom/base/nsJSEnvironment.cpp
@@ -1286,17 +1286,17 @@ TimeUntilNow(TimeStamp start)
   if (start.IsNull()) {
     return 0;
   }
   return TimeBetween(start, TimeStamp::Now());
 }
 
 struct CycleCollectorStats
 {
-  MOZ_CONSTEXPR CycleCollectorStats() :
+  constexpr CycleCollectorStats() :
     mMaxGCDuration(0), mRanSyncForgetSkippable(false), mSuspected(0),
     mMaxSkippableDuration(0), mMaxSliceTime(0), mMaxSliceTimeSinceClear(0),
     mTotalSliceTime(0), mAnyLockedOut(false), mExtraForgetSkippableCalls(0) {}
 
   void Init()
   {
     Clear();
     mMaxSliceTimeSinceClear = 0;
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -2951,46 +2951,46 @@ AddForDeferredFinalization(T* aObject)
 // This returns T's CC participant if it participates in CC or null if it
 // doesn't. This also returns null for classes that don't inherit from
 // nsISupports (QI should be used to get the participant for those).
 template<class T, bool isISupports=IsBaseOf<nsISupports, T>::value>
 class GetCCParticipant
 {
   // Helper for GetCCParticipant for classes that participate in CC.
   template<class U>
-  static MOZ_CONSTEXPR nsCycleCollectionParticipant*
+  static constexpr nsCycleCollectionParticipant*
   GetHelper(int, typename U::NS_CYCLE_COLLECTION_INNERCLASS* dummy=nullptr)
   {
     return T::NS_CYCLE_COLLECTION_INNERCLASS::GetParticipant();
   }
   // Helper for GetCCParticipant for classes that don't participate in CC.
   template<class U>
-  static MOZ_CONSTEXPR nsCycleCollectionParticipant*
+  static constexpr nsCycleCollectionParticipant*
   GetHelper(double)
   {
     return nullptr;
   }
 
 public:
-  static MOZ_CONSTEXPR nsCycleCollectionParticipant*
+  static constexpr nsCycleCollectionParticipant*
   Get()
   {
     // Passing int() here will try to call the GetHelper that takes an int as
     // its firt argument. If T doesn't participate in CC then substitution for
     // the second argument (with a default value) will fail and because of
     // SFINAE the next best match (the variant taking a double) will be called.
     return GetHelper<T>(int());
   }
 };
 
 template<class T>
 class GetCCParticipant<T, true>
 {
 public:
-  static MOZ_CONSTEXPR nsCycleCollectionParticipant*
+  static constexpr nsCycleCollectionParticipant*
   Get()
   {
     return nullptr;
   }
 };
 
 /*
  * Helper function for testing whether the given object comes from a
@@ -3017,34 +3017,34 @@ bool
 MayResolveGlobal(const JSAtomState& aNames, jsid aId, JSObject* aMaybeObj);
 
 bool
 EnumerateGlobal(JSContext* aCx, JS::Handle<JSObject*> aObj);
 
 template <class T>
 struct CreateGlobalOptions
 {
-  static MOZ_CONSTEXPR_VAR ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
+  static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
     ProtoAndIfaceCache::NonWindowLike;
   static void TraceGlobal(JSTracer* aTrc, JSObject* aObj)
   {
     mozilla::dom::TraceProtoAndIfaceCache(aTrc, aObj);
   }
   static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal)
   {
     MOZ_ALWAYS_TRUE(TryPreserveWrapper(aGlobal));
 
     return true;
   }
 };
 
 template <>
 struct CreateGlobalOptions<nsGlobalWindow>
 {
-  static MOZ_CONSTEXPR_VAR ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
+  static constexpr ProtoAndIfaceCache::Kind ProtoAndIfaceCacheKind =
     ProtoAndIfaceCache::WindowLike;
   static void TraceGlobal(JSTracer* aTrc, JSObject* aObj);
   static bool PostCreateGlobal(JSContext* aCx, JS::Handle<JSObject*> aGlobal);
 };
 
 nsresult
 RegisterDOMNames();
 
--- a/dom/bindings/Codegen.py
+++ b/dom/bindings/Codegen.py
@@ -10141,17 +10141,17 @@ class ClassConstructor(ClassItem):
 
     def getDecorators(self, declaring):
         decorators = []
         if self.explicit:
             decorators.append('explicit')
         if self.inline and declaring:
             decorators.append('inline')
         if self.constexpr and declaring:
-            decorators.append('MOZ_CONSTEXPR')
+            decorators.append('constexpr')
         if decorators:
             return ' '.join(decorators) + ' '
         return ''
 
     def getInitializationList(self, cgClass):
         items = [str(c) for c in self.baseConstructors]
         for m in cgClass.members:
             if not m.static:
--- a/dom/bindings/DOMJSClass.h
+++ b/dom/bindings/DOMJSClass.h
@@ -233,17 +233,17 @@ struct NativePropertiesN {
   struct Trio {
     const /*Prefable<const T>*/ void* const mPrefables;
     const jsid* const mIds;
     const /*T*/ void* const mSpecs;
   };
 
   const int32_t iteratorAliasMethodIndex;
 
-  MOZ_CONSTEXPR const NativePropertiesN<7>* Upcast() const {
+  constexpr const NativePropertiesN<7>* Upcast() const {
     return reinterpret_cast<const NativePropertiesN<7>*>(this);
   }
 
 #define DO(SpecT, FieldName) \
 public: \
   /* The bitfields indicating the trio's presence and (if present) offset. */ \
   const uint32_t mHas##FieldName##s:1; \
   const uint32_t m##FieldName##sOffset:3; \
--- a/dom/bindings/DOMJSProxyHandler.h
+++ b/dom/bindings/DOMJSProxyHandler.h
@@ -42,17 +42,17 @@ enum {
   JSPROXYSLOT_EXPANDO = 0
 };
 
 template<typename T> struct Prefable;
 
 class BaseDOMProxyHandler : public js::BaseProxyHandler
 {
 public:
-  explicit MOZ_CONSTEXPR BaseDOMProxyHandler(const void* aProxyFamily, bool aHasPrototype = false)
+  explicit constexpr BaseDOMProxyHandler(const void* aProxyFamily, bool aHasPrototype = false)
     : js::BaseProxyHandler(aProxyFamily, aHasPrototype)
   {}
 
   // Implementations of methods that can be implemented in terms of
   // other lower-level methods.
   bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> proxy,
                                 JS::Handle<jsid> id,
                                 JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
@@ -93,17 +93,17 @@ protected:
                                     JS::Handle<jsid> id,
                                     bool ignoreNamedProps,
                                     JS::MutableHandle<JS::PropertyDescriptor> desc) const = 0;
 };
 
 class DOMProxyHandler : public BaseDOMProxyHandler
 {
 public:
-  MOZ_CONSTEXPR DOMProxyHandler()
+  constexpr DOMProxyHandler()
     : BaseDOMProxyHandler(&family)
   {}
 
   bool defineProperty(JSContext* cx, JS::Handle<JSObject*> proxy, JS::Handle<jsid> id,
                       JS::Handle<JS::PropertyDescriptor> desc,
                       JS::ObjectOpResult &result) const override
   {
     bool unused;
--- a/dom/cache/DBSchema.cpp
+++ b/dom/cache/DBSchema.cpp
@@ -2458,17 +2458,17 @@ Validate(mozIStorageConnection* aConn)
 
 // -----
 // Schema migration code
 // -----
 
 typedef nsresult (*MigrationFunc)(mozIStorageConnection*, bool&);
 struct Migration
 {
-  MOZ_CONSTEXPR Migration(int32_t aFromVersion, MigrationFunc aFunc)
+  constexpr Migration(int32_t aFromVersion, MigrationFunc aFunc)
     : mFromVersion(aFromVersion)
     , mFunc(aFunc)
   { }
   int32_t mFromVersion;
   MigrationFunc mFunc;
 };
 
 // Declare migration functions here.  Each function should upgrade
--- a/dom/cellbroadcast/CellBroadcastMessage.cpp
+++ b/dom/cellbroadcast/CellBroadcastMessage.cpp
@@ -19,22 +19,22 @@ namespace dom {
 template<class T> struct EnumConverter {};
 
 template<class T>
 struct StaticEnumConverter
 {
   typedef T WebidlEnumType;
   typedef uint32_t XpidlEnumType;
 
-  static MOZ_CONSTEXPR WebidlEnumType
+  static constexpr WebidlEnumType
   x2w(XpidlEnumType aXpidlEnum) { return static_cast<WebidlEnumType>(aXpidlEnum); }
 };
 
 template<class T>
-MOZ_CONSTEXPR T
+constexpr T
 ToWebidlEnum(uint32_t aXpidlEnum) { return EnumConverter<T>::x2w(aXpidlEnum); }
 
 // Declare converters here:
 template <>
 struct EnumConverter<CellBroadcastGsmGeographicalScope> :
   public StaticEnumConverter<CellBroadcastGsmGeographicalScope> {};
 template <>
 struct EnumConverter<CellBroadcastMessageClass> :
--- a/dom/events/EventStates.h
+++ b/dom/events/EventStates.h
@@ -19,46 +19,46 @@ namespace mozilla {
  * informing the layout/style engine of the change.
  * Event states are associated with pseudo-classes.
  */
 class EventStates
 {
 public:
   typedef uint64_t InternalType;
 
-  MOZ_CONSTEXPR EventStates()
+  constexpr EventStates()
     : mStates(0)
   {
   }
 
   // NOTE: the ideal scenario would be to have the default constructor public
   // setting mStates to 0 and this constructor (without = 0) private.
   // In that case, we could be sure that only macros at the end were creating
   // EventStates instances with mStates set to something else than 0.
   // Unfortunately, this constructor is needed at at least two places now.
-  explicit MOZ_CONSTEXPR EventStates(InternalType aStates)
+  explicit constexpr EventStates(InternalType aStates)
     : mStates(aStates)
   {
   }
 
-  EventStates MOZ_CONSTEXPR operator|(const EventStates& aEventStates) const
+  EventStates constexpr operator|(const EventStates& aEventStates) const
   {
     return EventStates(mStates | aEventStates.mStates);
   }
 
   EventStates& operator|=(const EventStates& aEventStates)
   {
     mStates |= aEventStates.mStates;
     return *this;
   }
 
   // NOTE: calling if (eventStates1 & eventStates2) will not build.
   // This might work correctly if operator bool() is defined
   // but using HasState, HasAllStates or HasAtLeastOneOfStates is recommended.
-  EventStates MOZ_CONSTEXPR operator&(const EventStates& aEventStates) const
+  EventStates constexpr operator&(const EventStates& aEventStates) const
   {
     return EventStates(mStates & aEventStates.mStates);
   }
 
   EventStates& operator&=(const EventStates& aEventStates)
   {
     mStates &= aEventStates.mStates;
     return *this;
--- a/dom/html/HTMLTrackElement.cpp
+++ b/dom/html/HTMLTrackElement.cpp
@@ -55,28 +55,28 @@ NS_NewHTMLTrackElement(already_AddRefed<
 
   return new mozilla::dom::HTMLTrackElement(aNodeInfo);
 }
 
 namespace mozilla {
 namespace dom {
 
 // Map html attribute string values to TextTrackKind enums.
-static MOZ_CONSTEXPR nsAttrValue::EnumTable kKindTable[] = {
+static constexpr nsAttrValue::EnumTable kKindTable[] = {
   { "subtitles", static_cast<int16_t>(TextTrackKind::Subtitles) },
   { "captions", static_cast<int16_t>(TextTrackKind::Captions) },
   { "descriptions", static_cast<int16_t>(TextTrackKind::Descriptions) },
   { "chapters", static_cast<int16_t>(TextTrackKind::Chapters) },
   { "metadata", static_cast<int16_t>(TextTrackKind::Metadata) },
   { 0 }
 };
 
 // Invalid values are treated as "metadata" in ParseAttribute, but if no value
 // at all is specified, it's treated as "subtitles" in GetKind
-static MOZ_CONSTEXPR const nsAttrValue::EnumTable* kKindTableInvalidValueDefault = &kKindTable[4];
+static constexpr const nsAttrValue::EnumTable* kKindTableInvalidValueDefault = &kKindTable[4];
 
 /** HTMLTrackElement */
 HTMLTrackElement::HTMLTrackElement(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
   : nsGenericHTMLElement(aNodeInfo)
 {
 }
 
 HTMLTrackElement::~HTMLTrackElement()
--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -251,17 +251,17 @@ const uint32_t kDEBUGThreadSleepMS = 0;
 
 const int32_t kDEBUGTransactionThreadPriority =
   nsISupportsPriority::PRIORITY_NORMAL;
 const uint32_t kDEBUGTransactionThreadSleepMS = 0;
 
 #endif
 
 template <size_t N>
-MOZ_CONSTEXPR size_t
+constexpr size_t
 LiteralStringLength(const char (&aArr)[N])
 {
   static_assert(N, "Zero-length string literal?!");
 
   // Don't include the null terminator.
   return N - 1;
 }
 
@@ -2883,21 +2883,21 @@ UpgradeKeyFunction::CopyAndUpgradeKeyBuf
   MOZ_ASSERT(!IsOnBackgroundThread());
   MOZ_ASSERT(aSource);
   MOZ_ASSERT(*aSource);
   MOZ_ASSERT(aSourceEnd);
   MOZ_ASSERT(aSource < aSourceEnd);
   MOZ_ASSERT(aDestination);
   MOZ_ASSERT(aTagOffset <=  Key::kMaxArrayCollapse);
 
-  static MOZ_CONSTEXPR_VAR uint8_t kOldNumberTag = 0x1;
-  static MOZ_CONSTEXPR_VAR uint8_t kOldDateTag = 0x2;
-  static MOZ_CONSTEXPR_VAR uint8_t kOldStringTag = 0x3;
-  static MOZ_CONSTEXPR_VAR uint8_t kOldArrayTag = 0x4;
-  static MOZ_CONSTEXPR_VAR uint8_t kOldMaxType = kOldArrayTag;
+  static constexpr uint8_t kOldNumberTag = 0x1;
+  static constexpr uint8_t kOldDateTag = 0x2;
+  static constexpr uint8_t kOldStringTag = 0x3;
+  static constexpr uint8_t kOldArrayTag = 0x4;
+  static constexpr uint8_t kOldMaxType = kOldArrayTag;
 
   if (NS_WARN_IF(aRecursionDepth > Key::kMaxRecursionDepth)) {
     IDB_REPORT_INTERNAL_ERR();
     return NS_ERROR_FILE_CORRUPTED;
   }
 
   const uint8_t sourceTag = *aSource - (aTagOffset * kOldMaxType);
   MOZ_ASSERT(sourceTag);
--- a/dom/ipc/Blob.cpp
+++ b/dom/ipc/Blob.cpp
@@ -718,17 +718,17 @@ CreateBlobImpl(const nsTArray<uint8_t>& 
   static_assert(sizeof(size_t) <= sizeof(uint64_t),
                 "size_t won't fit in uint64_t!");
 
   MOZ_ASSERT(gProcessType == GeckoProcessType_Default);
 
   RefPtr<BlobImpl> blobImpl;
 
   if (auto length = static_cast<size_t>(aMemoryData.Length())) {
-    static MOZ_CONSTEXPR_VAR size_t elementSizeMultiplier =
+    static constexpr size_t elementSizeMultiplier =
       sizeof(aMemoryData[0]) / sizeof(char);
 
     if (!aMetadata.mHasRecursed &&
         NS_WARN_IF(aMetadata.mLength != uint64_t(length))) {
       ASSERT_UNLESS_FUZZING();
       return nullptr;
     }
 
--- a/dom/smil/SMILBoolType.h
+++ b/dom/smil/SMILBoolType.h
@@ -37,14 +37,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SMILBoolType() {}
+  constexpr SMILBoolType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SMILBOOLTYPE_H_
--- a/dom/smil/SMILEnumType.h
+++ b/dom/smil/SMILEnumType.h
@@ -38,14 +38,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SMILEnumType() {}
+  constexpr SMILEnumType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SMILENUMTYPE_H_
--- a/dom/smil/SMILIntegerType.h
+++ b/dom/smil/SMILIntegerType.h
@@ -33,14 +33,14 @@ public:
   static SMILIntegerType*
   Singleton()
   {
     static SMILIntegerType sSingleton;
     return &sSingleton;
   }
 
 private:
-  MOZ_CONSTEXPR SMILIntegerType() {}
+  constexpr SMILIntegerType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SMILINTEGERTYPE_H_
--- a/dom/smil/SMILStringType.h
+++ b/dom/smil/SMILStringType.h
@@ -38,14 +38,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SMILStringType() {}
+  constexpr SMILStringType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SMILSTRINGTYPE_H_
--- a/dom/smil/nsSMILCSSValueType.h
+++ b/dom/smil/nsSMILCSSValueType.h
@@ -105,12 +105,12 @@ public:
    * @return           The nsCSSProperty enum value of the property animated
    *                   by |aValue|, or eCSSProperty_UNKNOWN if the type of
    *                   |aValue| is not nsSMILCSSValueType.
    */
   static nsCSSProperty PropertyFromValue(const nsSMILValue& aValue);
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR nsSMILCSSValueType() {}
+  constexpr nsSMILCSSValueType() {}
 };
 
 #endif // NS_SMILCSSVALUETYPE_H_
--- a/dom/smil/nsSMILFloatType.h
+++ b/dom/smil/nsSMILFloatType.h
@@ -36,12 +36,12 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR nsSMILFloatType() {}
+  constexpr nsSMILFloatType() {}
 };
 
 #endif // NS_SMILFLOATTYPE_H_
--- a/dom/smil/nsSMILNullType.h
+++ b/dom/smil/nsSMILNullType.h
@@ -39,12 +39,12 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR nsSMILNullType() {}
+  constexpr nsSMILNullType() {}
 };
 
 #endif // NS_SMILNULLTYPE_H_
--- a/dom/svg/SVGIntegerPairSMILType.h
+++ b/dom/svg/SVGIntegerPairSMILType.h
@@ -40,14 +40,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGIntegerPairSMILType() {}
+  constexpr SVGIntegerPairSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGINTEGERPAIRSMILTYPE_H_
--- a/dom/svg/SVGLengthListSMILType.h
+++ b/dom/svg/SVGLengthListSMILType.h
@@ -88,14 +88,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGLengthListSMILType() {}
+  constexpr SVGLengthListSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGLENGTHLISTSMILTYPE_H_
--- a/dom/svg/SVGMotionSMILType.h
+++ b/dom/svg/SVGMotionSMILType.h
@@ -73,14 +73,14 @@ public:
   // the given path.
   static nsSMILValue ConstructSMILValue(Path* aPath,
                                         float aDist,
                                         RotateType aRotateType,
                                         float aRotateAngle);
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGMotionSMILType() {}
+  constexpr SVGMotionSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGMOTIONSMILTYPE_H_
--- a/dom/svg/SVGNumberListSMILType.h
+++ b/dom/svg/SVGNumberListSMILType.h
@@ -42,14 +42,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGNumberListSMILType() {}
+  constexpr SVGNumberListSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGNUMBERLISTSMILTYPE_H_
--- a/dom/svg/SVGNumberPairSMILType.h
+++ b/dom/svg/SVGNumberPairSMILType.h
@@ -35,14 +35,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGNumberPairSMILType() {}
+  constexpr SVGNumberPairSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGNUMBERPAIRSMILTYPE_H_
--- a/dom/svg/SVGOrientSMILType.h
+++ b/dom/svg/SVGOrientSMILType.h
@@ -55,14 +55,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGOrientSMILType() {}
+  constexpr SVGOrientSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGORIENTSMILTYPE_H_
--- a/dom/svg/SVGPathSegListSMILType.h
+++ b/dom/svg/SVGPathSegListSMILType.h
@@ -46,14 +46,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGPathSegListSMILType() {}
+  constexpr SVGPathSegListSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGPATHSEGLISTSMILTYPE_H_
--- a/dom/svg/SVGPointListSMILType.h
+++ b/dom/svg/SVGPointListSMILType.h
@@ -42,14 +42,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGPointListSMILType() {}
+  constexpr SVGPointListSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGPOINTLISTSMILTYPE_H_
--- a/dom/svg/SVGTransformListSMILType.h
+++ b/dom/svg/SVGTransformListSMILType.h
@@ -118,14 +118,14 @@ public:
   static bool AppendTransforms(const SVGTransformList& aList,
                                  nsSMILValue& aValue);
   static bool GetTransforms(const nsSMILValue& aValue,
                               FallibleTArray<nsSVGTransform>& aTransforms);
 
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGTransformListSMILType() {}
+  constexpr SVGTransformListSMILType() {}
 };
 
 } // end namespace mozilla
 
 #endif // SVGLISTTRANSFORMSMILTYPE_H_
--- a/dom/svg/SVGViewBoxSMILType.h
+++ b/dom/svg/SVGViewBoxSMILType.h
@@ -35,14 +35,14 @@ protected:
                                    double& aDistance) const override;
   virtual nsresult Interpolate(const nsSMILValue& aStartVal,
                                const nsSMILValue& aEndVal,
                                double aUnitDistance,
                                nsSMILValue& aResult) const override;
 
 private:
   // Private constructor: prevent instances beyond my singleton.
-  MOZ_CONSTEXPR SVGViewBoxSMILType() {}
+  constexpr SVGViewBoxSMILType() {}
 };
 
 } // namespace mozilla
 
 #endif // MOZILLA_SVGVIEWBOXSMILTYPE_H_
--- a/gfx/2d/BaseCoord.h
+++ b/gfx/2d/BaseCoord.h
@@ -16,18 +16,18 @@ namespace gfx {
  * Sub parameter, and only use that subclass. This allows methods to safely
  * cast 'this' to 'Sub*'.
  */
 template <class T, class Sub>
 struct BaseCoord {
   T value;
 
   // Constructors
-  MOZ_CONSTEXPR BaseCoord() : value(0) {}
-  explicit MOZ_CONSTEXPR BaseCoord(T aValue) : value(aValue) {}
+  constexpr BaseCoord() : value(0) {}
+  explicit constexpr BaseCoord(T aValue) : value(aValue) {}
 
   // Note that '=' isn't defined so we'll get the
   // compiler generated default assignment operator
 
   operator T() const { return value; }
 
   friend bool operator==(Sub aA, Sub aB) {
     return aA.value == aB.value;
--- a/gfx/2d/BasePoint.h
+++ b/gfx/2d/BasePoint.h
@@ -25,18 +25,18 @@ struct BasePoint {
   union {
     struct {
       T x, y;
     };
     T components[2];
   };
 
   // Constructors
-  MOZ_CONSTEXPR BasePoint() : x(0), y(0) {}
-  MOZ_CONSTEXPR BasePoint(Coord aX, Coord aY) : x(aX), y(aY) {}
+  constexpr BasePoint() : x(0), y(0) {}
+  constexpr BasePoint(Coord aX, Coord aY) : x(aX), y(aY) {}
 
   void MoveTo(T aX, T aY) { x = aX; y = aY; }
   void MoveBy(T aDx, T aDy) { x += aDx; y += aDy; }
 
   // Note that '=' isn't defined so we'll get the
   // compiler generated default assignment operator
 
   bool operator==(const Sub& aPoint) const {
--- a/gfx/2d/BaseSize.h
+++ b/gfx/2d/BaseSize.h
@@ -21,18 +21,18 @@ struct BaseSize {
   union {
     struct {
       T width, height;
     };
     T components[2];
   };
 
   // Constructors
-  MOZ_CONSTEXPR BaseSize() : width(0), height(0) {}
-  MOZ_CONSTEXPR BaseSize(T aWidth, T aHeight) : width(aWidth), height(aHeight) {}
+  constexpr BaseSize() : width(0), height(0) {}
+  constexpr BaseSize(T aWidth, T aHeight) : width(aWidth), height(aHeight) {}
 
   void SizeTo(T aWidth, T aHeight) { width = aWidth; height = aHeight; }
 
   bool IsEmpty() const {
     return width <= 0 || height <= 0;
   }
 
   bool IsSquare() const {
--- a/gfx/2d/Coord.h
+++ b/gfx/2d/Coord.h
@@ -105,35 +105,35 @@ struct IntCoordTyped :
   public BaseCoord< int32_t, IntCoordTyped<units> >,
   public CoordOperatorsHelper< true, IntCoordTyped<units>, float >,
   public CoordOperatorsHelper< true, IntCoordTyped<units>, double > {
   static_assert(IsPixel<units>::value,
                 "'units' must be a coordinate system tag");
 
   typedef BaseCoord< int32_t, IntCoordTyped<units> > Super;
 
-  MOZ_CONSTEXPR IntCoordTyped() : Super() {}
-  MOZ_CONSTEXPR MOZ_IMPLICIT IntCoordTyped(int32_t aValue) : Super(aValue) {}
+  constexpr IntCoordTyped() : Super() {}
+  constexpr MOZ_IMPLICIT IntCoordTyped(int32_t aValue) : Super(aValue) {}
 };
 
 template<class units, class F>
 struct CoordTyped :
   public BaseCoord< F, CoordTyped<units, F> >,
   public CoordOperatorsHelper< !IsSame<F, int32_t>::value, CoordTyped<units, F>, int32_t >,
   public CoordOperatorsHelper< !IsSame<F, uint32_t>::value, CoordTyped<units, F>, uint32_t >,
   public CoordOperatorsHelper< !IsSame<F, double>::value, CoordTyped<units, F>, double >,
   public CoordOperatorsHelper< !IsSame<F, float>::value, CoordTyped<units, F>, float > {
   static_assert(IsPixel<units>::value,
                 "'units' must be a coordinate system tag");
 
   typedef BaseCoord< F, CoordTyped<units, F> > Super;
 
-  MOZ_CONSTEXPR CoordTyped() : Super() {}
-  MOZ_CONSTEXPR MOZ_IMPLICIT CoordTyped(F aValue) : Super(aValue) {}
-  explicit MOZ_CONSTEXPR CoordTyped(const IntCoordTyped<units>& aCoord) : Super(F(aCoord.value)) {}
+  constexpr CoordTyped() : Super() {}
+  constexpr MOZ_IMPLICIT CoordTyped(F aValue) : Super(aValue) {}
+  explicit constexpr CoordTyped(const IntCoordTyped<units>& aCoord) : Super(F(aCoord.value)) {}
 
   void Round() {
     this->value = floor(this->value + 0.5);
   }
   void Truncate() {
     this->value = int32_t(this->value);
   }
 
--- a/gfx/2d/Point.h
+++ b/gfx/2d/Point.h
@@ -38,23 +38,23 @@ struct IntPointTyped :
   public BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> >,
   public units {
   static_assert(IsPixel<units>::value,
                 "'units' must be a coordinate system tag");
 
   typedef IntCoordTyped<units> Coord;
   typedef BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> > Super;
 
-  MOZ_CONSTEXPR IntPointTyped() : Super() {}
-  MOZ_CONSTEXPR IntPointTyped(int32_t aX, int32_t aY) : Super(Coord(aX), Coord(aY)) {}
+  constexpr IntPointTyped() : Super() {}
+  constexpr IntPointTyped(int32_t aX, int32_t aY) : Super(Coord(aX), Coord(aY)) {}
   // The mixed-type constructors (int, Coord) and (Coord, int) are needed to
   // avoid ambiguities because Coord is implicitly convertible to int.
-  MOZ_CONSTEXPR IntPointTyped(int32_t aX, Coord aY) : Super(Coord(aX), aY) {}
-  MOZ_CONSTEXPR IntPointTyped(Coord aX, int32_t aY) : Super(aX, Coord(aY)) {}
-  MOZ_CONSTEXPR IntPointTyped(Coord aX, Coord aY) : Super(aX, aY) {}
+  constexpr IntPointTyped(int32_t aX, Coord aY) : Super(Coord(aX), aY) {}
+  constexpr IntPointTyped(Coord aX, int32_t aY) : Super(aX, Coord(aY)) {}
+  constexpr IntPointTyped(Coord aX, Coord aY) : Super(aX, aY) {}
 
   // XXX When all of the code is ported, the following functions to convert to and from
   // unknown types should be removed.
 
   static IntPointTyped<units> FromUnknownPoint(const IntPointTyped<UnknownUnits>& aPoint) {
     return IntPointTyped<units>(aPoint.x, aPoint.y);
   }
 
@@ -69,24 +69,24 @@ struct PointTyped :
   public BasePoint< F, PointTyped<units, F>, CoordTyped<units, F> >,
   public units {
   static_assert(IsPixel<units>::value,
                 "'units' must be a coordinate system tag");
 
   typedef CoordTyped<units, F> Coord;
   typedef BasePoint< F, PointTyped<units, F>, CoordTyped<units, F> > Super;
 
-  MOZ_CONSTEXPR PointTyped() : Super() {}
-  MOZ_CONSTEXPR PointTyped(F aX, F aY) : Super(Coord(aX), Coord(aY)) {}
+  constexpr PointTyped() : Super() {}
+  constexpr PointTyped(F aX, F aY) : Super(Coord(aX), Coord(aY)) {}
   // The mixed-type constructors (Float, Coord) and (Coord, Float) are needed to
   // avoid ambiguities because Coord is implicitly convertible to Float.
-  MOZ_CONSTEXPR PointTyped(F aX, Coord aY) : Super(Coord(aX), aY) {}
-  MOZ_CONSTEXPR PointTyped(Coord aX, F aY) : Super(aX, Coord(aY)) {}
-  MOZ_CONSTEXPR PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
-  MOZ_CONSTEXPR MOZ_IMPLICIT PointTyped(const IntPointTyped<units>& point) : Super(F(point.x), F(point.y)) {}
+  constexpr PointTyped(F aX, Coord aY) : Super(Coord(aX), aY) {}
+  constexpr PointTyped(Coord aX, F aY) : Super(aX, Coord(aY)) {}
+  constexpr PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
+  constexpr MOZ_IMPLICIT PointTyped(const IntPointTyped<units>& point) : Super(F(point.x), F(point.y)) {}
 
   // XXX When all of the code is ported, the following functions to convert to and from
   // unknown types should be removed.
 
   static PointTyped<units, F> FromUnknownPoint(const PointTyped<UnknownUnits, F>& aPoint) {
     return PointTyped<units, F>(aPoint.x, aPoint.y);
   }
 
@@ -167,18 +167,18 @@ template<class units>
 struct IntSizeTyped :
   public BaseSize< int32_t, IntSizeTyped<units> >,
   public units {
   static_assert(IsPixel<units>::value,
                 "'units' must be a coordinate system tag");
 
   typedef BaseSize< int32_t, IntSizeTyped<units> > Super;
 
-  MOZ_CONSTEXPR IntSizeTyped() : Super() {}
-  MOZ_CONSTEXPR IntSizeTyped(int32_t aWidth, int32_t aHeight) : Super(aWidth, aHeight) {}
+  constexpr IntSizeTyped() : Super() {}
+  constexpr IntSizeTyped(int32_t aWidth, int32_t aHeight) : Super(aWidth, aHeight) {}
 
   // XXX When all of the code is ported, the following functions to convert to and from
   // unknown types should be removed.
 
   static IntSizeTyped<units> FromUnknownSize(const IntSizeTyped<UnknownUnits>& aSize) {
     return IntSizeTyped<units>(aSize.width, aSize.height);
   }
 
@@ -192,18 +192,18 @@ template<class units, class F = Float>
 struct SizeTyped :
   public BaseSize< F, SizeTyped<units> >,
   public units {
   static_assert(IsPixel<units>::value,
                 "'units' must be a coordinate system tag");
 
   typedef BaseSize< F, SizeTyped<units, F> > Super;
 
-  MOZ_CONSTEXPR SizeTyped() : Super() {}
-  MOZ_CONSTEXPR SizeTyped(F aWidth, F aHeight) : Super(aWidth, aHeight) {}
+  constexpr SizeTyped() : Super() {}
+  constexpr SizeTyped(F aWidth, F aHeight) : Super(aWidth, aHeight) {}
   explicit SizeTyped(const IntSizeTyped<units>& size) :
     Super(F(size.width), F(size.height)) {}
 
   // XXX When all of the code is ported, the following functions to convert to and from
   // unknown types should be removed.
 
   static SizeTyped<units, F> FromUnknownSize(const SizeTyped<UnknownUnits, F>& aSize) {
     return SizeTyped<units, F>(aSize.width, aSize.height);
--- a/gfx/2d/ScaleFactor.h
+++ b/gfx/2d/ScaleFactor.h
@@ -21,19 +21,19 @@ namespace gfx {
  * This class is meant to be used in cases where a single scale applies to
  * both the x and y axes. For cases where two diferent scales apply, use
  * ScaleFactors2D.
  */
 template<class src, class dst>
 struct ScaleFactor {
   float scale;
 
-  MOZ_CONSTEXPR ScaleFactor() : scale(1.0) {}
-  MOZ_CONSTEXPR ScaleFactor(const ScaleFactor<src, dst>& aCopy) : scale(aCopy.scale) {}
-  explicit MOZ_CONSTEXPR ScaleFactor(float aScale) : scale(aScale) {}
+  constexpr ScaleFactor() : scale(1.0) {}
+  constexpr ScaleFactor(const ScaleFactor<src, dst>& aCopy) : scale(aCopy.scale) {}
+  explicit constexpr ScaleFactor(float aScale) : scale(aScale) {}
 
   ScaleFactor<dst, src> Inverse() {
     return ScaleFactor<dst, src>(1 / scale);
   }
 
   bool operator==(const ScaleFactor<src, dst>& aOther) const {
     return scale == aOther.scale;
   }
--- a/gfx/2d/ScaleFactors2D.h
+++ b/gfx/2d/ScaleFactors2D.h
@@ -21,30 +21,30 @@ namespace gfx {
  * This class is like ScaleFactor, but allows different scales on the x and
  * y axes.
  */
 template<class src, class dst>
 struct ScaleFactors2D {
   float xScale;
   float yScale;
 
-  MOZ_CONSTEXPR ScaleFactors2D() : xScale(1.0), yScale(1.0) {}
-  MOZ_CONSTEXPR ScaleFactors2D(const ScaleFactors2D<src, dst>& aCopy)
+  constexpr ScaleFactors2D() : xScale(1.0), yScale(1.0) {}
+  constexpr ScaleFactors2D(const ScaleFactors2D<src, dst>& aCopy)
     : xScale(aCopy.xScale), yScale(aCopy.yScale) {}
-  MOZ_CONSTEXPR ScaleFactors2D(float aXScale, float aYScale)
+  constexpr ScaleFactors2D(float aXScale, float aYScale)
     : xScale(aXScale), yScale(aYScale) {}
   // Layout code often uses gfxSize to represent a pair of x/y scales.
-  explicit MOZ_CONSTEXPR ScaleFactors2D(const gfxSize& aSize)
+  explicit constexpr ScaleFactors2D(const gfxSize& aSize)
     : xScale(aSize.width), yScale(aSize.height) {}
 
   // "Upgrade" from a ScaleFactor.
   // This is deliberately 'explicit' so that the treatment of a single scale
   // number as both the x- and y-scale in a context where they are allowed to
   // be different, is more visible.
-  explicit MOZ_CONSTEXPR ScaleFactors2D(const ScaleFactor<src, dst>& aScale)
+  explicit constexpr ScaleFactors2D(const ScaleFactor<src, dst>& aScale)
     : xScale(aScale.scale), yScale(aScale.scale) {}
 
   bool AreScalesSame() const {
     return FuzzyEqualsMultiplicative(xScale, yScale);
   }
 
   // Convert to a ScaleFactor. Asserts that the scales are, in fact, equal.
   ScaleFactor<src, dst> ToScaleFactor() const {
--- a/gfx/gl/GLXLibrary.h
+++ b/gfx/gl/GLXLibrary.h
@@ -27,17 +27,17 @@ struct PRLibrary;
 class gfxASurface;
 
 namespace mozilla {
 namespace gl {
 
 class GLXLibrary
 {
 public:
-    MOZ_CONSTEXPR GLXLibrary()
+    constexpr GLXLibrary()
     : xDestroyContextInternal(nullptr)
     , xMakeCurrentInternal(nullptr)
     , xGetCurrentContextInternal(nullptr)
     , xGetProcAddressInternal(nullptr)
     , xChooseFBConfigInternal(nullptr)
     , xGetFBConfigsInternal(nullptr)
     , xCreateNewContextInternal(nullptr)
     , xGetFBConfigAttribInternal(nullptr)
--- a/ipc/dbus/DBusConnectionDelete.h
+++ b/ipc/dbus/DBusConnectionDelete.h
@@ -19,17 +19,17 @@ namespace mozilla {
  * structure.
  *
  * Do not use |UniquePtr| with shared DBus connections. For
  * shared connections, use |RefPtr|.
  */
 class DBusConnectionDelete
 {
 public:
-  MOZ_CONSTEXPR DBusConnectionDelete()
+  constexpr DBusConnectionDelete()
   { }
 
   void operator()(DBusConnection* aConnection) const
   {
     MOZ_ASSERT(aConnection);
     if (dbus_connection_get_is_connected(aConnection)) {
       dbus_connection_close(aConnection);
     }
--- a/js/ipc/WrapperOwner.cpp
+++ b/js/ipc/WrapperOwner.cpp
@@ -86,17 +86,17 @@ WrapperOwner::idOf(JSObject* obj)
     ObjectId objId = idOfUnchecked(obj);
     MOZ_ASSERT(findCPOWById(objId) == obj);
     return objId;
 }
 
 class CPOWProxyHandler : public BaseProxyHandler
 {
   public:
-    MOZ_CONSTEXPR CPOWProxyHandler()
+    constexpr CPOWProxyHandler()
       : BaseProxyHandler(&family) {}
 
     virtual bool finalizeInBackground(Value priv) const override {
         return false;
     }
 
     virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                           MutableHandle<PropertyDescriptor> desc) const override;
--- a/js/public/Proxy.h
+++ b/js/public/Proxy.h
@@ -184,17 +184,17 @@ class JS_FRIEND_API(BaseProxyHandler)
      * All proxies indicate whether they have any sort of interesting security
      * policy that might prevent the caller from doing something it wants to
      * the object. In the case of wrappers, this distinction is used to
      * determine whether the caller may strip off the wrapper if it so desires.
      */
     bool mHasSecurityPolicy;
 
   public:
-    explicit MOZ_CONSTEXPR BaseProxyHandler(const void* aFamily, bool aHasPrototype = false,
+    explicit constexpr BaseProxyHandler(const void* aFamily, bool aHasPrototype = false,
                                             bool aHasSecurityPolicy = false)
       : mFamily(aFamily),
         mHasPrototype(aHasPrototype),
         mHasSecurityPolicy(aHasSecurityPolicy)
     { }
 
     bool hasPrototype() const {
         return mHasPrototype;
--- a/js/public/RootingAPI.h
+++ b/js/public/RootingAPI.h
@@ -413,17 +413,17 @@ class MOZ_NONHEAP_CLASS Handle : public 
      *  1) the location of the T is guaranteed to be marked (for some reason
      *     other than being a Rooted), e.g., if it is guaranteed to be reachable
      *     from an implicit root.
      *
      *  2) the contents of the location are immutable, or at least cannot change
      *     for the lifetime of the handle, as its users may not expect its value
      *     to change underneath them.
      */
-    static MOZ_CONSTEXPR Handle fromMarkedLocation(const T* p) {
+    static constexpr Handle fromMarkedLocation(const T* p) {
         return Handle(p, DeliberatelyChoosingThisOverload,
                       ImUsingThisOnlyInFromFromMarkedLocation);
     }
 
     /*
      * Construct a handle from an explicitly rooted location. This is the
      * normal way to create a handle, and normally happens implicitly.
      */
@@ -448,17 +448,17 @@ class MOZ_NONHEAP_CLASS Handle : public 
     DECLARE_NONPOINTER_ACCESSOR_METHODS(*ptr);
 
   private:
     Handle() {}
     DELETE_ASSIGNMENT_OPS(Handle, T);
 
     enum Disambiguator { DeliberatelyChoosingThisOverload = 42 };
     enum CallerIdentity { ImUsingThisOnlyInFromFromMarkedLocation = 17 };
-    MOZ_CONSTEXPR Handle(const T* p, Disambiguator, CallerIdentity) : ptr(p) {}
+    constexpr Handle(const T* p, Disambiguator, CallerIdentity) : ptr(p) {}
 
     const T* ptr;
 };
 
 /**
  * Similar to a handle, but the underlying storage can be changed. This is
  * useful for outparams.
  *
--- a/js/public/Utility.h
+++ b/js/public/Utility.h
@@ -467,17 +467,17 @@ SCOPED_TEMPLATE(ScopedReleasePtr, Scoped
 
 } /* namespace js */
 
 namespace JS {
 
 template<typename T>
 struct DeletePolicy
 {
-    MOZ_CONSTEXPR DeletePolicy() {}
+    constexpr DeletePolicy() {}
 
     template<typename U>
     MOZ_IMPLICIT DeletePolicy(DeletePolicy<U> other,
                               typename mozilla::EnableIf<mozilla::IsConvertible<U*, T*>::value,
                                                          int>::Type dummy = 0)
     {}
 
     void operator()(const T* ptr) {
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -362,18 +362,18 @@ JS_STATIC_ASSERT(sizeof(jsval_layout) ==
 #  if MOZ_GCC_VERSION_AT_LEAST(4, 7, 3)
 #    define JS_VALUE_IS_CONSTEXPR
 #  endif
 #endif
 
 #if defined(JS_VALUE_IS_CONSTEXPR)
 #  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
     return (jsval_layout) { .asBits = (BITS) }
-#  define JS_VALUE_CONSTEXPR MOZ_CONSTEXPR
-#  define JS_VALUE_CONSTEXPR_VAR MOZ_CONSTEXPR_VAR
+#  define JS_VALUE_CONSTEXPR constexpr
+#  define JS_VALUE_CONSTEXPR_VAR constexpr
 #else
 #  define JS_RETURN_LAYOUT_FROM_BITS(BITS) \
     jsval_layout l;                        \
     l.asBits = (BITS);                     \
     return l;
 #  define JS_VALUE_CONSTEXPR
 #  define JS_VALUE_CONSTEXPR_VAR const
 #endif
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -449,26 +449,26 @@ class MOZ_STACK_CLASS TokenStream
 
         Flags()
           : isEOF(), isDirtyLine(), sawOctalEscape(), hadError(), hitOOM()
         {}
     };
 
   public:
     typedef Token::Modifier Modifier;
-    static MOZ_CONSTEXPR_VAR Modifier None = Token::None;
-    static MOZ_CONSTEXPR_VAR Modifier Operand = Token::Operand;
-    static MOZ_CONSTEXPR_VAR Modifier KeywordIsName = Token::KeywordIsName;
-    static MOZ_CONSTEXPR_VAR Modifier TemplateTail = Token::TemplateTail;
+    static constexpr Modifier None = Token::None;
+    static constexpr Modifier Operand = Token::Operand;
+    static constexpr Modifier KeywordIsName = Token::KeywordIsName;
+    static constexpr Modifier TemplateTail = Token::TemplateTail;
 
     typedef Token::ModifierException ModifierException;
-    static MOZ_CONSTEXPR_VAR ModifierException NoException = Token::NoException;
-    static MOZ_CONSTEXPR_VAR ModifierException NoneIsOperand = Token::NoneIsOperand;
-    static MOZ_CONSTEXPR_VAR ModifierException OperandIsNone = Token::OperandIsNone;
-    static MOZ_CONSTEXPR_VAR ModifierException NoneIsKeywordIsName = Token::NoneIsKeywordIsName;
+    static constexpr ModifierException NoException = Token::NoException;
+    static constexpr ModifierException NoneIsOperand = Token::NoneIsOperand;
+    static constexpr ModifierException OperandIsNone = Token::OperandIsNone;
+    static constexpr ModifierException NoneIsKeywordIsName = Token::NoneIsKeywordIsName;
 
     void addModifierException(ModifierException modifierException) {
 #ifdef DEBUG
         const Token& next = nextToken();
         if (next.modifierException == NoneIsOperand)
         {
             // Token after yield expression without operand already has
             // NoneIsOperand exception.
--- a/js/src/gc/Heap.h
+++ b/js/src/gc/Heap.h
@@ -324,17 +324,17 @@ class TenuredCell : public Cell
 #ifdef DEBUG
     inline bool isAligned() const;
 #endif
 };
 
 /* Cells are aligned to CellShift, so the largest tagged null pointer is: */
 const uintptr_t LargestTaggedNullCellPointer = (1 << CellShift) - 1;
 
-MOZ_CONSTEXPR size_t
+constexpr size_t
 DivideAndRoundUp(size_t numerator, size_t divisor) {
     return (numerator + divisor - 1) / divisor;
 }
 
 const size_t ArenaCellCount = ArenaSize / CellSize;
 static_assert(ArenaSize % CellSize == 0, "Arena size must be a multiple of cell size");
 
 /*
--- a/js/src/jit/AtomicOp.h
+++ b/js/src/jit/AtomicOp.h
@@ -34,40 +34,40 @@ enum MemoryBarrierBits {
 
     MembarSynchronizing = 16,
 
     // For validity testing
     MembarNobits = 0,
     MembarAllbits = 31,
 };
 
-static inline MOZ_CONSTEXPR MemoryBarrierBits
+static inline constexpr MemoryBarrierBits
 operator|(MemoryBarrierBits a, MemoryBarrierBits b)
 {
     return MemoryBarrierBits(int(a) | int(b));
 }
 
-static inline MOZ_CONSTEXPR MemoryBarrierBits
+static inline constexpr MemoryBarrierBits
 operator&(MemoryBarrierBits a, MemoryBarrierBits b)
 {
     return MemoryBarrierBits(int(a) & int(b));
 }
 
-static inline MOZ_CONSTEXPR MemoryBarrierBits
+static inline constexpr MemoryBarrierBits
 operator~(MemoryBarrierBits a)
 {
     return MemoryBarrierBits(~int(a));
 }
 
 // Standard barrier bits for a full barrier.
-static MOZ_CONSTEXPR_VAR MemoryBarrierBits MembarFull = MembarLoadLoad|MembarLoadStore|MembarStoreLoad|MembarStoreStore;
+static constexpr MemoryBarrierBits MembarFull = MembarLoadLoad|MembarLoadStore|MembarStoreLoad|MembarStoreStore;
 
 // Standard sets of barrier bits for atomic loads and stores.
 // See http://gee.cs.oswego.edu/dl/jmm/cookbook.html for more.
-static MOZ_CONSTEXPR_VAR MemoryBarrierBits MembarBeforeLoad = MembarNobits;
-static MOZ_CONSTEXPR_VAR MemoryBarrierBits MembarAfterLoad = MembarLoadLoad|MembarLoadStore;
-static MOZ_CONSTEXPR_VAR MemoryBarrierBits MembarBeforeStore = MembarStoreStore;
-static MOZ_CONSTEXPR_VAR MemoryBarrierBits MembarAfterStore = MembarStoreLoad;
+static constexpr MemoryBarrierBits MembarBeforeLoad = MembarNobits;
+static constexpr MemoryBarrierBits MembarAfterLoad = MembarLoadLoad|MembarLoadStore;
+static constexpr MemoryBarrierBits MembarBeforeStore = MembarStoreStore;
+static constexpr MemoryBarrierBits MembarAfterStore = MembarStoreLoad;
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_AtomicOp_h */
--- a/js/src/jit/RegisterAllocator.h
+++ b/js/src/jit/RegisterAllocator.h
@@ -139,17 +139,17 @@ struct AllocationIntegrityState
 // this instruction, it can be clobbered in the output". Just having ranges
 // of instruction IDs is insufficiently expressive to denote all possibilities.
 // This class solves this issue by associating an extra bit with the instruction
 // ID which indicates whether the position is the input half or output half of
 // an instruction.
 class CodePosition
 {
   private:
-    MOZ_CONSTEXPR explicit CodePosition(uint32_t bits)
+    constexpr explicit CodePosition(uint32_t bits)
       : bits_(bits)
     { }
 
     static const unsigned int INSTRUCTION_SHIFT = 1;
     static const unsigned int SUBPOSITION_MASK = 1;
     uint32_t bits_;
 
   public:
@@ -158,17 +158,17 @@ class CodePosition
 
     // This is the half of the instruction this code position represents, as
     // described in the huge comment above.
     enum SubPosition {
         INPUT,
         OUTPUT
     };
 
-    MOZ_CONSTEXPR CodePosition() : bits_(0)
+    constexpr CodePosition() : bits_(0)
     { }
 
     CodePosition(uint32_t instruction, SubPosition where) {
         MOZ_ASSERT(instruction < 0x80000000u);
         MOZ_ASSERT(((uint32_t)where & SUBPOSITION_MASK) == (uint32_t)where);
         bits_ = (instruction << INSTRUCTION_SHIFT) | (uint32_t)where;
     }
 
--- a/js/src/jit/RegisterSets.h
+++ b/js/src/jit/RegisterSets.h
@@ -106,17 +106,17 @@ struct AnyRegister {
 // platforms, two registers on 32 bit platforms.
 class ValueOperand
 {
 #if defined(JS_NUNBOX32)
     Register type_;
     Register payload_;
 
   public:
-    MOZ_CONSTEXPR ValueOperand(Register type, Register payload)
+    constexpr ValueOperand(Register type, Register payload)
       : type_(type), payload_(payload)
     { }
 
     Register typeReg() const {
         return type_;
     }
     Register payloadReg() const {
         return payload_;
@@ -133,17 +133,17 @@ class ValueOperand
     bool operator!=(const ValueOperand& o) const {
         return !(*this == o);
     }
 
 #elif defined(JS_PUNBOX64)
     Register value_;
 
   public:
-    explicit MOZ_CONSTEXPR ValueOperand(Register value)
+    explicit constexpr ValueOperand(Register value)
       : value_(value)
     { }
 
     Register valueReg() const {
         return value_;
     }
     bool aliases(Register reg) const {
         return value_ == reg;
@@ -310,23 +310,23 @@ class TypedRegisterSet
   public:
     typedef T RegType;
     typedef typename T::SetType SetType;
 
   private:
     SetType bits_;
 
   public:
-    explicit MOZ_CONSTEXPR TypedRegisterSet(SetType bits)
+    explicit constexpr TypedRegisterSet(SetType bits)
       : bits_(bits)
     { }
 
-    MOZ_CONSTEXPR TypedRegisterSet() : bits_(0)
+    constexpr TypedRegisterSet() : bits_(0)
     { }
-    MOZ_CONSTEXPR TypedRegisterSet(const TypedRegisterSet<T>& set) : bits_(set.bits_)
+    constexpr TypedRegisterSet(const TypedRegisterSet<T>& set) : bits_(set.bits_)
     { }
 
     static inline TypedRegisterSet All() {
         return TypedRegisterSet(T::Codes::AllocatableMask);
     }
     static inline TypedRegisterSet Intersect(const TypedRegisterSet& lhs,
                                              const TypedRegisterSet& rhs) {
         return TypedRegisterSet(lhs.bits_ & rhs.bits_);
@@ -428,17 +428,17 @@ class RegisterSet {
     GeneralRegisterSet gpr_;
     FloatRegisterSet fpu_;
 
     friend class AnyRegisterIterator;
 
   public:
     RegisterSet()
     { }
-    MOZ_CONSTEXPR RegisterSet(const GeneralRegisterSet& gpr, const FloatRegisterSet& fpu)
+    constexpr RegisterSet(const GeneralRegisterSet& gpr, const FloatRegisterSet& fpu)
       : gpr_(gpr),
         fpu_(fpu)
     { }
     static inline RegisterSet All() {
         return RegisterSet(GeneralRegisterSet::All(), FloatRegisterSet::All());
     }
     static inline RegisterSet Intersect(const RegisterSet& lhs, const RegisterSet& rhs) {
         return RegisterSet(GeneralRegisterSet::Intersect(lhs.gpr_, rhs.gpr_),
@@ -468,23 +468,23 @@ class RegisterSet {
         gpr_.clear();
     }
     bool emptyGeneral() const {
         return gpr_.empty();
     }
     bool emptyFloat() const {
         return fpu_.empty();
     }
-    MOZ_CONSTEXPR GeneralRegisterSet gprs() const {
+    constexpr GeneralRegisterSet gprs() const {
         return gpr_;
     }
     GeneralRegisterSet& gprs() {
         return gpr_;
     }
-    MOZ_CONSTEXPR FloatRegisterSet fpus() const {
+    constexpr FloatRegisterSet fpus() const {
         return fpu_;
     }
     FloatRegisterSet& fpus() {
         return fpu_;
     }
     bool operator ==(const RegisterSet& other) const {
         return other.gpr_ == gpr_ && other.fpu_ == fpu_;
     }
@@ -562,18 +562,18 @@ class AllocatableSetAccessors
     typedef typename RegSet::RegType RegType;
     typedef typename RegSet::SetType SetType;
 
   protected:
     RegSet set_;
 
   public:
     AllocatableSetAccessors() : set_() {}
-    explicit MOZ_CONSTEXPR AllocatableSetAccessors(SetType set) : set_(set) {}
-    explicit MOZ_CONSTEXPR AllocatableSetAccessors(RegSet set) : set_(set) {}
+    explicit constexpr AllocatableSetAccessors(SetType set) : set_(set) {}
+    explicit constexpr AllocatableSetAccessors(RegSet set) : set_(set) {}
 
     bool has(RegType reg) const {
         return set_.hasAllocatable(reg);
     }
 
     void addUnchecked(RegType reg) {
         set_.addAllocatable(reg);
     }
@@ -592,18 +592,18 @@ class AllocatableSetAccessors<RegisterSe
     typedef AnyRegister RegType;
     typedef char SetType;
 
   protected:
     RegisterSet set_;
 
   public:
     AllocatableSetAccessors() : set_() {}
-    explicit MOZ_CONSTEXPR AllocatableSetAccessors(SetType) = delete;
-    explicit MOZ_CONSTEXPR AllocatableSetAccessors(RegisterSet set) : set_(set) {}
+    explicit constexpr AllocatableSetAccessors(SetType) = delete;
+    explicit constexpr AllocatableSetAccessors(RegisterSet set) : set_(set) {}
 
     bool has(Register reg) const {
         return set_.gprs().hasAllocatable(reg);
     }
     bool has(FloatRegister reg) const {
         return set_.fpus().hasAllocatable(reg);
     }
 
@@ -644,18 +644,18 @@ class LiveSetAccessors
     typedef typename RegSet::RegType RegType;
     typedef typename RegSet::SetType SetType;
 
   protected:
     RegSet set_;
 
   public:
     LiveSetAccessors() : set_() {}
-    explicit MOZ_CONSTEXPR LiveSetAccessors(SetType set) : set_(set) {}
-    explicit MOZ_CONSTEXPR LiveSetAccessors(RegSet set) : set_(set) {}
+    explicit constexpr LiveSetAccessors(SetType set) : set_(set) {}
+    explicit constexpr LiveSetAccessors(RegSet set) : set_(set) {}
 
     bool has(RegType reg) const {
         return set_.hasRegisterIndex(reg);
     }
 
     void addUnchecked(RegType reg) {
         set_.addRegisterIndex(reg);
     }
@@ -674,18 +674,18 @@ class LiveSetAccessors<RegisterSet>
     typedef AnyRegister RegType;
     typedef char SetType;
 
   protected:
     RegisterSet set_;
 
   public:
     LiveSetAccessors() : set_() {}
-    explicit MOZ_CONSTEXPR LiveSetAccessors(SetType) = delete;
-    explicit MOZ_CONSTEXPR LiveSetAccessors(RegisterSet set) : set_(set) {}
+    explicit constexpr LiveSetAccessors(SetType) = delete;
+    explicit constexpr LiveSetAccessors(RegisterSet set) : set_(set) {}
 
     bool has(Register reg) const {
         return set_.gprs().hasRegisterIndex(reg);
     }
     bool has(FloatRegister reg) const {
         return set_.fpus().hasRegisterIndex(reg);
     }
 
@@ -704,19 +704,19 @@ class LiveSetAccessors<RegisterSet>
     }
 };
 
 #define DEFINE_ACCESSOR_CONSTRUCTORS_(REGSET)                         \
     typedef typename Parent::RegSet  RegSet;                          \
     typedef typename Parent::RegType RegType;                         \
     typedef typename Parent::SetType SetType;                         \
                                                                       \
-    MOZ_CONSTEXPR_TMPL REGSET() : Parent() {}                         \
-    explicit MOZ_CONSTEXPR_TMPL REGSET(SetType set) : Parent(set) {}  \
-    explicit MOZ_CONSTEXPR_TMPL REGSET(RegSet set) : Parent(set) {}
+    constexpr REGSET() : Parent() {}                                  \
+    explicit constexpr REGSET(SetType set) : Parent(set) {}           \
+    explicit constexpr REGSET(RegSet set) : Parent(set) {}
 
 // This class adds checked accessors on top of the unchecked variants defined by
 // AllocatableSet and LiveSet accessors. Also it defines interface which are
 // specialized to the register set implementation, such as |getAny| and
 // |takeAny| variants.
 template <class Accessors, typename Set>
 class SpecializedRegSet : public Accessors
 {
@@ -1021,20 +1021,20 @@ class AllocatableSet : public CommonRegS
     }
 };
 
 #define DEFINE_ACCESSOR_CONSTRUCTORS_FOR_REGISTERSET_(REGSET)               \
     typedef Parent::RegSet  RegSet;                                         \
     typedef Parent::RegType RegType;                                        \
     typedef Parent::SetType SetType;                                        \
                                                                             \
-    MOZ_CONSTEXPR_TMPL REGSET() : Parent() {}                               \
-    explicit MOZ_CONSTEXPR_TMPL REGSET(SetType) = delete;                   \
-    explicit MOZ_CONSTEXPR_TMPL REGSET(RegSet set) : Parent(set) {}         \
-    MOZ_CONSTEXPR_TMPL REGSET(GeneralRegisterSet gpr, FloatRegisterSet fpu) \
+    constexpr REGSET() : Parent() {}                                        \
+    explicit constexpr REGSET(SetType) = delete;                            \
+    explicit constexpr REGSET(RegSet set) : Parent(set) {}                  \
+    constexpr REGSET(GeneralRegisterSet gpr, FloatRegisterSet fpu)          \
       : Parent(RegisterSet(gpr, fpu))                                       \
     {}                                                                      \
     REGSET(REGSET<GeneralRegisterSet> gpr, REGSET<FloatRegisterSet> fpu)    \
       : Parent(RegisterSet(gpr.set(), fpu.set()))                           \
     {}
 
 template <>
 class LiveSet<RegisterSet>
--- a/js/src/jit/Registers.h
+++ b/js/src/jit/Registers.h
@@ -45,17 +45,17 @@ struct Register {
         Code code = Registers::FromName(name);
         Register r = { Encoding(code) };
         return r;
     }
     static Register Invalid() {
         Register r = { Encoding(Codes::Invalid) };
         return r;
     }
-    MOZ_CONSTEXPR Code code() const {
+    constexpr Code code() const {
         return Code(reg_);
     }
     Encoding encoding() const {
         MOZ_ASSERT(Code(reg_) < Registers::Total);
         return reg_;
     }
     const char* name() const {
         return Registers::GetName(code());
@@ -104,31 +104,31 @@ struct Register64
 #ifdef JS_PUNBOX64
     Register reg;
 #else
     Register high;
     Register low;
 #endif
 
 #ifdef JS_PUNBOX64
-    explicit MOZ_CONSTEXPR Register64(Register r)
+    explicit constexpr Register64(Register r)
       : reg(r)
     {}
     bool operator ==(Register64 other) const {
         return reg == other.reg;
     }
     bool operator !=(Register64 other) const {
         return reg != other.reg;
     }
 #else
     explicit Register64(Register r)
       : high(Register::Invalid()), low(Register::Invalid())
     {}
 
-    MOZ_CONSTEXPR Register64(Register h, Register l)
+    constexpr Register64(Register h, Register l)
       : high(h), low(l)
     {}
     bool operator ==(Register64 other) const {
         return high == other.high && low == other.low;
     }
     bool operator !=(Register64 other) const {
         return high != other.high || low != other.low;
     }
@@ -223,17 +223,17 @@ struct AutoGenericRegisterScope : public
     // which causes the destructor to fire more than once.
     AutoGenericRegisterScope(const AutoGenericRegisterScope& other) = delete;
 
 #ifdef DEBUG
     MacroAssembler& masm_;
     explicit AutoGenericRegisterScope(MacroAssembler& masm, RegisterType reg);
     ~AutoGenericRegisterScope();
 #else
-    MOZ_CONSTEXPR explicit AutoGenericRegisterScope(MacroAssembler& masm, RegisterType reg)
+    constexpr explicit AutoGenericRegisterScope(MacroAssembler& masm, RegisterType reg)
       : RegisterType(reg)
     { }
 #endif
 };
 
 typedef AutoGenericRegisterScope<Register> AutoRegisterScope;
 typedef AutoGenericRegisterScope<FloatRegister> AutoFloatRegisterScope;
 
--- a/js/src/jit/VMFunctions.h
+++ b/js/src/jit/VMFunctions.h
@@ -457,58 +457,58 @@ template <> struct MatchContext<Exclusiv
 // Extract the last element of a list of types.
 template <typename... ArgTypes>
 struct LastArg;
 
 template <>
 struct LastArg<>
 {
     typedef void Type;
-    static MOZ_CONSTEXPR_VAR size_t nbArgs = 0;
+    static constexpr size_t nbArgs = 0;
 };
 
 template <typename HeadType>
 struct LastArg<HeadType>
 {
     typedef HeadType Type;
-    static MOZ_CONSTEXPR_VAR size_t nbArgs = 1;
+    static constexpr size_t nbArgs = 1;
 };
 
 template <typename HeadType, typename... TailTypes>
 struct LastArg<HeadType, TailTypes...>
 {
     typedef typename LastArg<TailTypes...>::Type Type;
-    static MOZ_CONSTEXPR_VAR size_t nbArgs = LastArg<TailTypes...>::nbArgs + 1;
+    static constexpr size_t nbArgs = LastArg<TailTypes...>::nbArgs + 1;
 };
 
 // Construct a bit mask from a list of types.  The mask is constructed as an OR
 // of the mask produced for each argument. The result of each argument is
 // shifted by its index, such that the result of the first argument is on the
 // low bits of the mask, and the result of the last argument in part of the
 // high bits of the mask.
 template <template<typename> class Each, typename ResultType, size_t Shift,
           typename... Args>
 struct BitMask;
 
 template <template<typename> class Each, typename ResultType, size_t Shift>
 struct BitMask<Each, ResultType, Shift>
 {
-    static MOZ_CONSTEXPR_VAR ResultType result = ResultType();
+    static constexpr ResultType result = ResultType();
 };
 
 template <template<typename> class Each, typename ResultType, size_t Shift,
           typename HeadType, typename... TailTypes>
 struct BitMask<Each, ResultType, Shift, HeadType, TailTypes...>
 {
     static_assert(ResultType(Each<HeadType>::result) < (1 << Shift),
                   "not enough bits reserved by the shift for individual results");
     static_assert(LastArg<TailTypes...>::nbArgs < (8 * sizeof(ResultType) / Shift),
                   "not enough bits in the result type to store all bit masks");
 
-    static MOZ_CONSTEXPR_VAR ResultType result =
+    static constexpr ResultType result =
         ResultType(Each<HeadType>::result) |
         (BitMask<Each, ResultType, Shift, TailTypes...>::result << Shift);
 };
 
 // Extract VMFunction properties based on the signature of the function. The
 // properties are used to generate the logic for calling the VM function, and
 // also for marking the stack during GCs.
 template <typename... Args>
--- a/js/src/jit/arm/Architecture-arm.h
+++ b/js/src/jit/arm/Architecture-arm.h
@@ -364,28 +364,28 @@ class VFPRegister
     // likely specify it as a separate field.
   public:
     uint32_t code_ : 5;
   protected:
     bool _isInvalid : 1;
     bool _isMissing : 1;
 
   public:
-    MOZ_CONSTEXPR VFPRegister(uint32_t r, RegType k)
+    constexpr VFPRegister(uint32_t r, RegType k)
       : kind(k), code_ (Code(r)), _isInvalid(false), _isMissing(false)
     { }
-    MOZ_CONSTEXPR VFPRegister()
+    constexpr VFPRegister()
       : kind(Double), code_(Code(0)), _isInvalid(true), _isMissing(false)
     { }
 
-    MOZ_CONSTEXPR VFPRegister(RegType k, uint32_t id, bool invalid, bool missing) :
+    constexpr VFPRegister(RegType k, uint32_t id, bool invalid, bool missing) :
         kind(k), code_(Code(id)), _isInvalid(invalid), _isMissing(missing) {
     }
 
-    explicit MOZ_CONSTEXPR VFPRegister(Code id)
+    explicit constexpr VFPRegister(Code id)
       : kind(Double), code_(id), _isInvalid(false), _isMissing(false)
     { }
     bool operator==(const VFPRegister& other) const {
         MOZ_ASSERT(!isInvalid());
         MOZ_ASSERT(!other.isInvalid());
         return kind == other.kind && code_ == other.code_;
     }
 
--- a/js/src/jit/arm/Assembler-arm.cpp
+++ b/js/src/jit/arm/Assembler-arm.cpp
@@ -1758,17 +1758,17 @@ Assembler::as_teq(Register src1, Operand
     return as_alu(InvalidReg, src1, op2, OpTeq, SetCC, c);
 }
 BufferOffset
 Assembler::as_tst(Register src1, Operand2 op2, Condition c)
 {
     return as_alu(InvalidReg, src1, op2, OpTst, SetCC, c);
 }
 
-static MOZ_CONSTEXPR_VAR Register NoAddend = { Registers::pc };
+static constexpr Register NoAddend = { Registers::pc };
 
 static const int SignExtend = 0x06000070;
 
 enum SignExtend {
     SxSxtb = 10 << 20,
     SxSxth = 11 << 20,
     SxUxtb = 14 << 20,
     SxUxth = 15 << 20
--- a/js/src/jit/arm/Assembler-arm.h
+++ b/js/src/jit/arm/Assembler-arm.h
@@ -20,62 +20,62 @@
 
 namespace js {
 namespace jit {
 
 // NOTE: there are duplicates in this list! Sometimes we want to specifically
 // refer to the link register as a link register (bl lr is much clearer than bl
 // r14). HOWEVER, this register can easily be a gpr when it is not busy holding
 // the return address.
-static MOZ_CONSTEXPR_VAR Register r0  = { Registers::r0 };
-static MOZ_CONSTEXPR_VAR Register r1  = { Registers::r1 };
-static MOZ_CONSTEXPR_VAR Register r2  = { Registers::r2 };
-static MOZ_CONSTEXPR_VAR Register r3  = { Registers::r3 };
-static MOZ_CONSTEXPR_VAR Register r4  = { Registers::r4 };
-static MOZ_CONSTEXPR_VAR Register r5  = { Registers::r5 };
-static MOZ_CONSTEXPR_VAR Register r6  = { Registers::r6 };
-static MOZ_CONSTEXPR_VAR Register r7  = { Registers::r7 };
-static MOZ_CONSTEXPR_VAR Register r8  = { Registers::r8 };
-static MOZ_CONSTEXPR_VAR Register r9  = { Registers::r9 };
-static MOZ_CONSTEXPR_VAR Register r10 = { Registers::r10 };
-static MOZ_CONSTEXPR_VAR Register r11 = { Registers::r11 };
-static MOZ_CONSTEXPR_VAR Register r12 = { Registers::ip };
-static MOZ_CONSTEXPR_VAR Register ip  = { Registers::ip };
-static MOZ_CONSTEXPR_VAR Register sp  = { Registers::sp };
-static MOZ_CONSTEXPR_VAR Register r14 = { Registers::lr };
-static MOZ_CONSTEXPR_VAR Register lr  = { Registers::lr };
-static MOZ_CONSTEXPR_VAR Register pc  = { Registers::pc };
+static constexpr Register r0  = { Registers::r0 };
+static constexpr Register r1  = { Registers::r1 };
+static constexpr Register r2  = { Registers::r2 };
+static constexpr Register r3  = { Registers::r3 };
+static constexpr Register r4  = { Registers::r4 };
+static constexpr Register r5  = { Registers::r5 };
+static constexpr Register r6  = { Registers::r6 };
+static constexpr Register r7  = { Registers::r7 };
+static constexpr Register r8  = { Registers::r8 };
+static constexpr Register r9  = { Registers::r9 };
+static constexpr Register r10 = { Registers::r10 };
+static constexpr Register r11 = { Registers::r11 };
+static constexpr Register r12 = { Registers::ip };
+static constexpr Register ip  = { Registers::ip };
+static constexpr Register sp  = { Registers::sp };
+static constexpr Register r14 = { Registers::lr };
+static constexpr Register lr  = { Registers::lr };
+static constexpr Register pc  = { Registers::pc };
 
-static MOZ_CONSTEXPR_VAR Register ScratchRegister = {Registers::ip};
+static constexpr Register ScratchRegister = {Registers::ip};
 
 // Helper class for ScratchRegister usage. Asserts that only one piece
 // of code thinks it has exclusive ownership of the scratch register.
 struct ScratchRegisterScope : public AutoRegisterScope
 {
     explicit ScratchRegisterScope(MacroAssembler& masm)
       : AutoRegisterScope(masm, ScratchRegister)
     { }
 };
 
-static MOZ_CONSTEXPR_VAR Register OsrFrameReg = r3;
-static MOZ_CONSTEXPR_VAR Register ArgumentsRectifierReg = r8;
-static MOZ_CONSTEXPR_VAR Register CallTempReg0 = r5;
-static MOZ_CONSTEXPR_VAR Register CallTempReg1 = r6;
-static MOZ_CONSTEXPR_VAR Register CallTempReg2 = r7;
-static MOZ_CONSTEXPR_VAR Register CallTempReg3 = r8;
-static MOZ_CONSTEXPR_VAR Register CallTempReg4 = r0;
-static MOZ_CONSTEXPR_VAR Register CallTempReg5 = r1;
+static constexpr Register OsrFrameReg = r3;
+static constexpr Register ArgumentsRectifierReg = r8;
+static constexpr Register CallTempReg0 = r5;
+static constexpr Register CallTempReg1 = r6;
+static constexpr Register CallTempReg2 = r7;
+static constexpr Register CallTempReg3 = r8;
+static constexpr Register CallTempReg4 = r0;
+static constexpr Register CallTempReg5 = r1;
 
-static MOZ_CONSTEXPR_VAR Register IntArgReg0 = r0;
-static MOZ_CONSTEXPR_VAR Register IntArgReg1 = r1;
-static MOZ_CONSTEXPR_VAR Register IntArgReg2 = r2;
-static MOZ_CONSTEXPR_VAR Register IntArgReg3 = r3;
-static MOZ_CONSTEXPR_VAR Register GlobalReg = r10;
-static MOZ_CONSTEXPR_VAR Register HeapReg = r11;
-static MOZ_CONSTEXPR_VAR Register CallTempNonArgRegs[] = { r5, r6, r7, r8 };
+static constexpr Register IntArgReg0 = r0;
+static constexpr Register IntArgReg1 = r1;
+static constexpr Register IntArgReg2 = r2;
+static constexpr Register IntArgReg3 = r3;
+static constexpr Register GlobalReg = r10;
+static constexpr Register HeapReg = r11;
+static constexpr Register CallTempNonArgRegs[] = { r5, r6, r7, r8 };
 static const uint32_t NumCallTempNonArgRegs =
     mozilla::ArrayLength(CallTempNonArgRegs);
 
 class ABIArgGenerator
 {
     unsigned intRegIndex_;
     unsigned floatRegIndex_;
     uint32_t stackOffset_;
@@ -98,45 +98,45 @@ class ABIArgGenerator
         MOZ_ASSERT(intRegIndex_ == 0 && floatRegIndex_ == 0);
         useHardFp_ = useHardFp;
     }
     ABIArg next(MIRType argType);
     ABIArg& current() { return current_; }
     uint32_t stackBytesConsumedSoFar() const { return stackOffset_; }
 };
 
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = r4;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = r5;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = r4;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = r5;
+static constexpr Register ABINonArgReg0 = r4;
+static constexpr Register ABINonArgReg1 = r5;
+static constexpr Register ABINonArgReturnReg0 = r4;
+static constexpr Register ABINonArgReturnReg1 = r5;
 
 // Registers used for asm.js/wasm table calls. These registers must be disjoint
 // from the ABI argument registers and from each other.
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = ABINonArgReg0;
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = ABINonArgReg1;
+static constexpr Register WasmTableCallPtrReg = ABINonArgReg0;
+static constexpr Register WasmTableCallSigReg = ABINonArgReg1;
 
-static MOZ_CONSTEXPR_VAR Register PreBarrierReg = r1;
+static constexpr Register PreBarrierReg = r1;
 
-static MOZ_CONSTEXPR_VAR Register InvalidReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister InvalidFloatReg;
+static constexpr Register InvalidReg = { Registers::invalid_reg };
+static constexpr FloatRegister InvalidFloatReg;
 
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = r3;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = r2;
-static MOZ_CONSTEXPR_VAR Register StackPointer = sp;
-static MOZ_CONSTEXPR_VAR Register FramePointer = InvalidReg;
-static MOZ_CONSTEXPR_VAR Register ReturnReg = r0;
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(InvalidReg, InvalidReg);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = { FloatRegisters::d0, VFPRegister::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = { FloatRegisters::d0, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnSimd128Reg = InvalidFloatReg;
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = { FloatRegisters::d30, VFPRegister::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = { FloatRegisters::d15, VFPRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchSimd128Reg = InvalidFloatReg;
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchUIntReg = { FloatRegisters::d15, VFPRegister::UInt };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchIntReg = { FloatRegisters::d15, VFPRegister::Int };
+static constexpr Register JSReturnReg_Type = r3;
+static constexpr Register JSReturnReg_Data = r2;
+static constexpr Register StackPointer = sp;
+static constexpr Register FramePointer = InvalidReg;
+static constexpr Register ReturnReg = r0;
+static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg);
+static constexpr FloatRegister ReturnFloat32Reg = { FloatRegisters::d0, VFPRegister::Single };
+static constexpr FloatRegister ReturnDoubleReg = { FloatRegisters::d0, VFPRegister::Double};
+static constexpr FloatRegister ReturnSimd128Reg = InvalidFloatReg;
+static constexpr FloatRegister ScratchFloat32Reg = { FloatRegisters::d30, VFPRegister::Single };
+static constexpr FloatRegister ScratchDoubleReg = { FloatRegisters::d15, VFPRegister::Double };
+static constexpr FloatRegister ScratchSimd128Reg = InvalidFloatReg;
+static constexpr FloatRegister ScratchUIntReg = { FloatRegisters::d15, VFPRegister::UInt };
+static constexpr FloatRegister ScratchIntReg = { FloatRegisters::d15, VFPRegister::Int };
 
 struct ScratchFloat32Scope : public AutoFloatRegisterScope
 {
     explicit ScratchFloat32Scope(MacroAssembler& masm)
       : AutoFloatRegisterScope(masm, ScratchFloat32Reg)
     { }
 };
 struct ScratchDoubleScope : public AutoFloatRegisterScope
@@ -147,94 +147,94 @@ struct ScratchDoubleScope : public AutoF
 };
 
 // A bias applied to the GlobalReg to allow the use of instructions with small
 // negative immediate offsets which doubles the range of global data that can be
 // accessed with a single instruction.
 static const int32_t AsmJSGlobalRegBias = 1024;
 
 // Registers used in the GenerateFFIIonExit Enable Activation block.
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegCallee = r4;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE0 = r0;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE1 = r1;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE2 = r2;
+static constexpr Register AsmJSIonExitRegCallee = r4;
+static constexpr Register AsmJSIonExitRegE0 = r0;
+static constexpr Register AsmJSIonExitRegE1 = r1;
+static constexpr Register AsmJSIonExitRegE2 = r2;
 
 // Registers used in the GenerateFFIIonExit Disable Activation block.
 // None of these may be the second scratch register (lr).
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = r2;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = r3;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD0 = r0;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD1 = r1;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD2 = r4;
+static constexpr Register AsmJSIonExitRegReturnData = r2;
+static constexpr Register AsmJSIonExitRegReturnType = r3;
+static constexpr Register AsmJSIonExitRegD0 = r0;
+static constexpr Register AsmJSIonExitRegD1 = r1;
+static constexpr Register AsmJSIonExitRegD2 = r4;
 
 // Registerd used in RegExpMatcher instruction (do not use JSReturnOperand).
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherLastIndexReg = CallTempReg2;
+static constexpr Register RegExpMatcherRegExpReg = CallTempReg0;
+static constexpr Register RegExpMatcherStringReg = CallTempReg1;
+static constexpr Register RegExpMatcherLastIndexReg = CallTempReg2;
 
 // Registerd used in RegExpTester instruction (do not use ReturnReg).
-static MOZ_CONSTEXPR_VAR Register RegExpTesterRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterLastIndexReg = CallTempReg2;
+static constexpr Register RegExpTesterRegExpReg = CallTempReg0;
+static constexpr Register RegExpTesterStringReg = CallTempReg1;
+static constexpr Register RegExpTesterLastIndexReg = CallTempReg2;
 
-static MOZ_CONSTEXPR_VAR FloatRegister d0  = {FloatRegisters::d0, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d1  = {FloatRegisters::d1, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d2  = {FloatRegisters::d2, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d3  = {FloatRegisters::d3, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d4  = {FloatRegisters::d4, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d5  = {FloatRegisters::d5, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d6  = {FloatRegisters::d6, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d7  = {FloatRegisters::d7, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d8  = {FloatRegisters::d8, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d9  = {FloatRegisters::d9, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d10 = {FloatRegisters::d10, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d11 = {FloatRegisters::d11, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d12 = {FloatRegisters::d12, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d13 = {FloatRegisters::d13, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d14 = {FloatRegisters::d14, VFPRegister::Double};
-static MOZ_CONSTEXPR_VAR FloatRegister d15 = {FloatRegisters::d15, VFPRegister::Double};
+static constexpr FloatRegister d0  = {FloatRegisters::d0, VFPRegister::Double};
+static constexpr FloatRegister d1  = {FloatRegisters::d1, VFPRegister::Double};
+static constexpr FloatRegister d2  = {FloatRegisters::d2, VFPRegister::Double};
+static constexpr FloatRegister d3  = {FloatRegisters::d3, VFPRegister::Double};
+static constexpr FloatRegister d4  = {FloatRegisters::d4, VFPRegister::Double};
+static constexpr FloatRegister d5  = {FloatRegisters::d5, VFPRegister::Double};
+static constexpr FloatRegister d6  = {FloatRegisters::d6, VFPRegister::Double};
+static constexpr FloatRegister d7  = {FloatRegisters::d7, VFPRegister::Double};
+static constexpr FloatRegister d8  = {FloatRegisters::d8, VFPRegister::Double};
+static constexpr FloatRegister d9  = {FloatRegisters::d9, VFPRegister::Double};
+static constexpr FloatRegister d10 = {FloatRegisters::d10, VFPRegister::Double};
+static constexpr FloatRegister d11 = {FloatRegisters::d11, VFPRegister::Double};
+static constexpr FloatRegister d12 = {FloatRegisters::d12, VFPRegister::Double};
+static constexpr FloatRegister d13 = {FloatRegisters::d13, VFPRegister::Double};
+static constexpr FloatRegister d14 = {FloatRegisters::d14, VFPRegister::Double};
+static constexpr FloatRegister d15 = {FloatRegisters::d15, VFPRegister::Double};
 
 
 // For maximal awesomeness, 8 should be sufficent. ldrd/strd (dual-register
 // load/store) operate in a single cycle when the address they are dealing with
 // is 8 byte aligned. Also, the ARM abi wants the stack to be 8 byte aligned at
 // function boundaries. I'm trying to make sure this is always true.
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 8;
-static MOZ_CONSTEXPR_VAR uint32_t CodeAlignment = 8;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackAlignment = 8;
+static constexpr uint32_t ABIStackAlignment = 8;
+static constexpr uint32_t CodeAlignment = 8;
+static constexpr uint32_t JitStackAlignment = 8;
 
-static MOZ_CONSTEXPR_VAR uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
+static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
 static_assert(JitStackAlignment % sizeof(Value) == 0 && JitStackValueAlignment >= 1,
   "Stack alignment should be a non-zero multiple of sizeof(Value)");
 
 // This boolean indicates whether we support SIMD instructions flavoured for
 // this architecture or not. Rather than a method in the LIRGenerator, it is
 // here such that it is accessible from the entire codebase. Once full support
 // for SIMD is reached on all tier-1 platforms, this constant can be deleted.
-static MOZ_CONSTEXPR_VAR bool SupportsSimd = false;
-static MOZ_CONSTEXPR_VAR uint32_t SimdMemoryAlignment = 8;
+static constexpr bool SupportsSimd = false;
+static constexpr uint32_t SimdMemoryAlignment = 8;
 
 static_assert(CodeAlignment % SimdMemoryAlignment == 0,
   "Code alignment should be larger than any of the alignments which are used for "
   "the constant sections of the code buffer.  Thus it should be larger than the "
   "alignment for SIMD constants.");
 
 static_assert(JitStackAlignment % SimdMemoryAlignment == 0,
   "Stack alignment should be larger than any of the alignments which are used for "
   "spilled values.  Thus it should be larger than the alignment for SIMD accesses.");
 
 static const uint32_t AsmJSStackAlignment = SimdMemoryAlignment;
 
 // Does this architecture support SIMD conversions between Uint32x4 and Float32x4?
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4FloatConversions = false;
+static constexpr bool SupportsUint32x4FloatConversions = false;
 
 // Does this architecture support comparisons of unsigned integer vectors?
-static MOZ_CONSTEXPR_VAR bool SupportsUint8x16Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint16x8Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4Compares = false;
+static constexpr bool SupportsUint8x16Compares = false;
+static constexpr bool SupportsUint16x8Compares = false;
+static constexpr bool SupportsUint32x4Compares = false;
 
 static const Scale ScalePointer = TimesFour;
 
 class Instruction;
 class InstBranchImm;
 uint32_t RM(Register r);
 uint32_t RS(Register r);
 uint32_t RD(Register r);
@@ -252,17 +252,17 @@ Register toR(Instruction i);
 
 class VFPRegister;
 uint32_t VD(VFPRegister vr);
 uint32_t VN(VFPRegister vr);
 uint32_t VM(VFPRegister vr);
 
 // For being passed into the generic vfp instruction generator when there is an
 // instruction that only takes two registers.
-static MOZ_CONSTEXPR_VAR VFPRegister NoVFPRegister(VFPRegister::Double, 0, false, true);
+static constexpr VFPRegister NoVFPRegister(VFPRegister::Double, 0, false, true);
 
 struct ImmTag : public Imm32
 {
     ImmTag(JSValueTag mask)
       : Imm32(int32_t(mask))
     { }
 };
 
@@ -541,18 +541,18 @@ struct Imm8VFPOffData
 // register.
 struct Imm8VFPImmData
 {
     // This structure's members are public and it has no constructor to
     // initialize them, for a very special reason. Were this structure to
     // have a constructor, the initialization for DoubleEncoder's internal
     // table (see below) would require a rather large static constructor on
     // some of our supported compilers. The known solution to this is to mark
-    // the constructor MOZ_CONSTEXPR, but, again, some of our supported
-    // compilers don't support MOZ_CONSTEXPR! So we are reduced to public
+    // the constructor constexpr, but, again, some of our supported
+    // compilers don't support constexpr! So we are reduced to public
     // members and eschewing a constructor in hopes that the initialization
     // of DoubleEncoder's table is correct.
     uint32_t imm4L : 4;
     uint32_t imm4H : 4;
     int32_t isInvalid : 24;
 
     uint32_t encode() const {
         // This assert is an attempting at ensuring that we don't create random
--- a/js/src/jit/arm/SharedICRegisters-arm.h
+++ b/js/src/jit/arm/SharedICRegisters-arm.h
@@ -12,43 +12,43 @@
 namespace js {
 namespace jit {
 
 // r15 = program-counter
 // r14 = link-register
 
 // r13 = stack-pointer
 // r11 = frame-pointer
-static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = r11;
-static MOZ_CONSTEXPR_VAR Register BaselineStackReg = sp;
+static constexpr Register BaselineFrameReg = r11;
+static constexpr Register BaselineStackReg = sp;
 
 // ValueOperands R0, R1, and R2.
 // R0 == JSReturnReg, and R2 uses registers not preserved across calls. R1 value
 // should be preserved across calls.
-static MOZ_CONSTEXPR_VAR ValueOperand R0(r3, r2);
-static MOZ_CONSTEXPR_VAR ValueOperand R1(r5, r4);
-static MOZ_CONSTEXPR_VAR ValueOperand R2(r1, r0);
+static constexpr ValueOperand R0(r3, r2);
+static constexpr ValueOperand R1(r5, r4);
+static constexpr ValueOperand R2(r1, r0);
 
 // ICTailCallReg and ICStubReg
 // These use registers that are not preserved across calls.
-static MOZ_CONSTEXPR_VAR Register ICTailCallReg = r14;
-static MOZ_CONSTEXPR_VAR Register ICStubReg     = r9;
+static constexpr Register ICTailCallReg = r14;
+static constexpr Register ICStubReg     = r9;
 
-static MOZ_CONSTEXPR_VAR Register ExtractTemp0        = InvalidReg;
-static MOZ_CONSTEXPR_VAR Register ExtractTemp1        = InvalidReg;
+static constexpr Register ExtractTemp0        = InvalidReg;
+static constexpr Register ExtractTemp1        = InvalidReg;
 
 // Register used internally by MacroAssemblerARM.
-static MOZ_CONSTEXPR_VAR Register BaselineSecondScratchReg = r6;
+static constexpr Register BaselineSecondScratchReg = r6;
 
 // R7 - R9 are generally available for use within stubcode.
 
 // Note that ICTailCallReg is actually just the link register. In ARM code
 // emission, we do not clobber ICTailCallReg since we keep the return
 // address for calls there.
 
 // FloatReg0 must be equal to ReturnFloatReg.
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = d0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = d1;
+static constexpr FloatRegister FloatReg0      = d0;
+static constexpr FloatRegister FloatReg1      = d1;
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_arm_SharedICRegisters_arm_h */
--- a/js/src/jit/arm64/Architecture-arm64.h
+++ b/js/src/jit/arm64/Architecture-arm64.h
@@ -392,17 +392,17 @@ struct FloatRegister
     // This function mostly exists for the ARM backend.  It is to ensure that two
     // floating point registers' types are equivalent.  e.g. S0 is not equivalent
     // to D16, since S0 holds a float32, and D16 holds a Double.
     // Since all floating point registers on x86 and x64 are equivalent, it is
     // reasonable for this function to do the same.
     bool equiv(FloatRegister other) const {
         return k_ == other.k_;
     }
-    MOZ_CONSTEXPR uint32_t size() const {
+    constexpr uint32_t size() const {
         return k_ == FloatRegisters::Double ? sizeof(double) : sizeof(float);
     }
     uint32_t numAlignedAliased() {
         return numAliased();
     }
     void alignedAliased(uint32_t aliasIdx, FloatRegister* ret) {
         MOZ_ASSERT(aliasIdx == 0);
         aliased(aliasIdx, ret);
--- a/js/src/jit/arm64/Assembler-arm64.h
+++ b/js/src/jit/arm64/Assembler-arm64.h
@@ -129,24 +129,24 @@ static constexpr Register AsmJSIonExitRe
 // None of these may be the second scratch register.
 static constexpr Register AsmJSIonExitRegReturnData = r2;
 static constexpr Register AsmJSIonExitRegReturnType = r3;
 static constexpr Register AsmJSIonExitRegD0 = r0;
 static constexpr Register AsmJSIonExitRegD1 = r1;
 static constexpr Register AsmJSIonExitRegD2 = r4;
 
 // Registerd used in RegExpMatcher instruction (do not use JSReturnOperand).
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherLastIndexReg = CallTempReg2;
+static constexpr Register RegExpMatcherRegExpReg = CallTempReg0;
+static constexpr Register RegExpMatcherStringReg = CallTempReg1;
+static constexpr Register RegExpMatcherLastIndexReg = CallTempReg2;
 
 // Registerd used in RegExpTester instruction (do not use ReturnReg).
-static MOZ_CONSTEXPR_VAR Register RegExpTesterRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterLastIndexReg = CallTempReg2;
+static constexpr Register RegExpTesterRegExpReg = CallTempReg0;
+static constexpr Register RegExpTesterStringReg = CallTempReg1;
+static constexpr Register RegExpTesterLastIndexReg = CallTempReg2;
 
 static constexpr Register JSReturnReg_Type = r3;
 static constexpr Register JSReturnReg_Data = r2;
 
 static constexpr FloatRegister NANReg = { FloatRegisters::d14, FloatRegisters::Single };
 // N.B. r8 isn't listed as an aapcs temp register, but we can use it as such because we never
 // use return-structs.
 static constexpr Register CallTempNonArgRegs[] = { r8, r9, r10, r11, r12, r13, r14, r15 };
@@ -170,22 +170,22 @@ static_assert(CodeAlignment % SimdMemory
   "Code alignment should be larger than any of the alignments which are used for "
   "the constant sections of the code buffer.  Thus it should be larger than the "
   "alignment for SIMD constants.");
 
 static const uint32_t AsmJSStackAlignment = SimdMemoryAlignment;
 static const int32_t AsmJSGlobalRegBias = 1024;
 
 // Does this architecture support SIMD conversions between Uint32x4 and Float32x4?
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4FloatConversions = false;
+static constexpr bool SupportsUint32x4FloatConversions = false;
 
 // Does this architecture support comparisons of unsigned integer vectors?
-static MOZ_CONSTEXPR_VAR bool SupportsUint8x16Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint16x8Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4Compares = false;
+static constexpr bool SupportsUint8x16Compares = false;
+static constexpr bool SupportsUint16x8Compares = false;
+static constexpr bool SupportsUint32x4Compares = false;
 
 class Assembler : public vixl::Assembler
 {
   public:
     Assembler()
       : vixl::Assembler()
     { }
 
@@ -452,25 +452,25 @@ class ABIArgGenerator
 
   protected:
     unsigned intRegIndex_;
     unsigned floatRegIndex_;
     uint32_t stackOffset_;
     ABIArg current_;
 };
 
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = r8;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = r9;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = r8;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = r9;
+static constexpr Register ABINonArgReg0 = r8;
+static constexpr Register ABINonArgReg1 = r9;
+static constexpr Register ABINonArgReturnReg0 = r8;
+static constexpr Register ABINonArgReturnReg1 = r9;
 
 // Registers used for asm.js/wasm table calls. These registers must be disjoint
 // from the ABI argument registers and from each other.
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = ABINonArgReg0;
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = ABINonArgReg1;
+static constexpr Register WasmTableCallPtrReg = ABINonArgReg0;
+static constexpr Register WasmTableCallSigReg = ABINonArgReg1;
 
 static inline bool
 GetIntArgReg(uint32_t usedIntArgs, uint32_t usedFloatArgs, Register* out)
 {
     if (usedIntArgs >= NumIntArgRegs)
         return false;
     *out = Register::FromCode(usedIntArgs);
     return true;
--- a/js/src/jit/mips-shared/Assembler-mips-shared.h
+++ b/js/src/jit/mips-shared/Assembler-mips-shared.h
@@ -17,55 +17,55 @@
 #include "jit/JitSpewer.h"
 #include "jit/mips-shared/Architecture-mips-shared.h"
 #include "jit/shared/Assembler-shared.h"
 #include "jit/shared/IonAssemblerBuffer.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register zero = { Registers::zero };
-static MOZ_CONSTEXPR_VAR Register at = { Registers::at };
-static MOZ_CONSTEXPR_VAR Register v0 = { Registers::v0 };
-static MOZ_CONSTEXPR_VAR Register v1 = { Registers::v1 };
-static MOZ_CONSTEXPR_VAR Register a0 = { Registers::a0 };
-static MOZ_CONSTEXPR_VAR Register a1 = { Registers::a1 };
-static MOZ_CONSTEXPR_VAR Register a2 = { Registers::a2 };
-static MOZ_CONSTEXPR_VAR Register a3 = { Registers::a3 };
-static MOZ_CONSTEXPR_VAR Register a4 = { Registers::ta0 };
-static MOZ_CONSTEXPR_VAR Register a5 = { Registers::ta1 };
-static MOZ_CONSTEXPR_VAR Register a6 = { Registers::ta2 };
-static MOZ_CONSTEXPR_VAR Register a7 = { Registers::ta3 };
-static MOZ_CONSTEXPR_VAR Register t0 = { Registers::t0 };
-static MOZ_CONSTEXPR_VAR Register t1 = { Registers::t1 };
-static MOZ_CONSTEXPR_VAR Register t2 = { Registers::t2 };
-static MOZ_CONSTEXPR_VAR Register t3 = { Registers::t3 };
-static MOZ_CONSTEXPR_VAR Register t4 = { Registers::ta0 };
-static MOZ_CONSTEXPR_VAR Register t5 = { Registers::ta1 };
-static MOZ_CONSTEXPR_VAR Register t6 = { Registers::ta2 };
-static MOZ_CONSTEXPR_VAR Register t7 = { Registers::ta3 };
-static MOZ_CONSTEXPR_VAR Register s0 = { Registers::s0 };
-static MOZ_CONSTEXPR_VAR Register s1 = { Registers::s1 };
-static MOZ_CONSTEXPR_VAR Register s2 = { Registers::s2 };
-static MOZ_CONSTEXPR_VAR Register s3 = { Registers::s3 };
-static MOZ_CONSTEXPR_VAR Register s4 = { Registers::s4 };
-static MOZ_CONSTEXPR_VAR Register s5 = { Registers::s5 };
-static MOZ_CONSTEXPR_VAR Register s6 = { Registers::s6 };
-static MOZ_CONSTEXPR_VAR Register s7 = { Registers::s7 };
-static MOZ_CONSTEXPR_VAR Register t8 = { Registers::t8 };
-static MOZ_CONSTEXPR_VAR Register t9 = { Registers::t9 };
-static MOZ_CONSTEXPR_VAR Register k0 = { Registers::k0 };
-static MOZ_CONSTEXPR_VAR Register k1 = { Registers::k1 };
-static MOZ_CONSTEXPR_VAR Register gp = { Registers::gp };
-static MOZ_CONSTEXPR_VAR Register sp = { Registers::sp };
-static MOZ_CONSTEXPR_VAR Register fp = { Registers::fp };
-static MOZ_CONSTEXPR_VAR Register ra = { Registers::ra };
+static constexpr Register zero = { Registers::zero };
+static constexpr Register at = { Registers::at };
+static constexpr Register v0 = { Registers::v0 };
+static constexpr Register v1 = { Registers::v1 };
+static constexpr Register a0 = { Registers::a0 };
+static constexpr Register a1 = { Registers::a1 };
+static constexpr Register a2 = { Registers::a2 };
+static constexpr Register a3 = { Registers::a3 };
+static constexpr Register a4 = { Registers::ta0 };
+static constexpr Register a5 = { Registers::ta1 };
+static constexpr Register a6 = { Registers::ta2 };
+static constexpr Register a7 = { Registers::ta3 };
+static constexpr Register t0 = { Registers::t0 };
+static constexpr Register t1 = { Registers::t1 };
+static constexpr Register t2 = { Registers::t2 };
+static constexpr Register t3 = { Registers::t3 };
+static constexpr Register t4 = { Registers::ta0 };
+static constexpr Register t5 = { Registers::ta1 };
+static constexpr Register t6 = { Registers::ta2 };
+static constexpr Register t7 = { Registers::ta3 };
+static constexpr Register s0 = { Registers::s0 };
+static constexpr Register s1 = { Registers::s1 };
+static constexpr Register s2 = { Registers::s2 };
+static constexpr Register s3 = { Registers::s3 };
+static constexpr Register s4 = { Registers::s4 };
+static constexpr Register s5 = { Registers::s5 };
+static constexpr Register s6 = { Registers::s6 };
+static constexpr Register s7 = { Registers::s7 };
+static constexpr Register t8 = { Registers::t8 };
+static constexpr Register t9 = { Registers::t9 };
+static constexpr Register k0 = { Registers::k0 };
+static constexpr Register k1 = { Registers::k1 };
+static constexpr Register gp = { Registers::gp };
+static constexpr Register sp = { Registers::sp };
+static constexpr Register fp = { Registers::fp };
+static constexpr Register ra = { Registers::ra };
 
-static MOZ_CONSTEXPR_VAR Register ScratchRegister = at;
-static MOZ_CONSTEXPR_VAR Register SecondScratchReg = t8;
+static constexpr Register ScratchRegister = at;
+static constexpr Register SecondScratchReg = t8;
 
 // Helper classes for ScratchRegister usage. Asserts that only one piece
 // of code thinks it has exclusive ownership of each scratch register.
 struct ScratchRegisterScope : public AutoRegisterScope
 {
     explicit ScratchRegisterScope(MacroAssembler& masm)
       : AutoRegisterScope(masm, ScratchRegister)
     { }
@@ -73,79 +73,79 @@ struct ScratchRegisterScope : public Aut
 struct SecondScratchRegisterScope : public AutoRegisterScope
 {
     explicit SecondScratchRegisterScope(MacroAssembler& masm)
       : AutoRegisterScope(masm, SecondScratchReg)
     { }
 };
 
 // Use arg reg from EnterJIT function as OsrFrameReg.
-static MOZ_CONSTEXPR_VAR Register OsrFrameReg = a3;
-static MOZ_CONSTEXPR_VAR Register ArgumentsRectifierReg = s3;
-static MOZ_CONSTEXPR_VAR Register CallTempReg0 = t0;
-static MOZ_CONSTEXPR_VAR Register CallTempReg1 = t1;
-static MOZ_CONSTEXPR_VAR Register CallTempReg2 = t2;
-static MOZ_CONSTEXPR_VAR Register CallTempReg3 = t3;
+static constexpr Register OsrFrameReg = a3;
+static constexpr Register ArgumentsRectifierReg = s3;
+static constexpr Register CallTempReg0 = t0;
+static constexpr Register CallTempReg1 = t1;
+static constexpr Register CallTempReg2 = t2;
+static constexpr Register CallTempReg3 = t3;
 
-static MOZ_CONSTEXPR_VAR Register IntArgReg0 = a0;
-static MOZ_CONSTEXPR_VAR Register IntArgReg1 = a1;
-static MOZ_CONSTEXPR_VAR Register IntArgReg2 = a2;
-static MOZ_CONSTEXPR_VAR Register IntArgReg3 = a3;
-static MOZ_CONSTEXPR_VAR Register IntArgReg4 = a4;
-static MOZ_CONSTEXPR_VAR Register IntArgReg5 = a5;
-static MOZ_CONSTEXPR_VAR Register IntArgReg6 = a6;
-static MOZ_CONSTEXPR_VAR Register IntArgReg7 = a7;
-static MOZ_CONSTEXPR_VAR Register GlobalReg = s6; // used by Odin
-static MOZ_CONSTEXPR_VAR Register HeapReg = s7; // used by Odin
+static constexpr Register IntArgReg0 = a0;
+static constexpr Register IntArgReg1 = a1;
+static constexpr Register IntArgReg2 = a2;
+static constexpr Register IntArgReg3 = a3;
+static constexpr Register IntArgReg4 = a4;
+static constexpr Register IntArgReg5 = a5;
+static constexpr Register IntArgReg6 = a6;
+static constexpr Register IntArgReg7 = a7;
+static constexpr Register GlobalReg = s6; // used by Odin
+static constexpr Register HeapReg = s7; // used by Odin
 
-static MOZ_CONSTEXPR_VAR Register PreBarrierReg = a1;
+static constexpr Register PreBarrierReg = a1;
 
-static MOZ_CONSTEXPR_VAR Register InvalidReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister InvalidFloatReg;
+static constexpr Register InvalidReg = { Registers::invalid_reg };
+static constexpr FloatRegister InvalidFloatReg;
 
-static MOZ_CONSTEXPR_VAR Register StackPointer = sp;
-static MOZ_CONSTEXPR_VAR Register FramePointer = InvalidReg;
-static MOZ_CONSTEXPR_VAR Register ReturnReg = v0;
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnSimd128Reg = InvalidFloatReg;
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchSimd128Reg = InvalidFloatReg;
+static constexpr Register StackPointer = sp;
+static constexpr Register FramePointer = InvalidReg;
+static constexpr Register ReturnReg = v0;
+static constexpr FloatRegister ReturnSimd128Reg = InvalidFloatReg;
+static constexpr FloatRegister ScratchSimd128Reg = InvalidFloatReg;
 
 // A bias applied to the GlobalReg to allow the use of instructions with small
 // negative immediate offsets which doubles the range of global data that can be
 // accessed with a single instruction.
 static const int32_t AsmJSGlobalRegBias = 32768;
 
 // Registers used in the GenerateFFIIonExit Enable Activation block.
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegCallee = t0;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE0 = a0;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE1 = a1;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE2 = a2;
+static constexpr Register AsmJSIonExitRegCallee = t0;
+static constexpr Register AsmJSIonExitRegE0 = a0;
+static constexpr Register AsmJSIonExitRegE1 = a1;
+static constexpr Register AsmJSIonExitRegE2 = a2;
 
 // Registers used in the GenerateFFIIonExit Disable Activation block.
 // None of these may be the second scratch register (t8).
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD0 = a0;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD1 = a1;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD2 = t0;
+static constexpr Register AsmJSIonExitRegD0 = a0;
+static constexpr Register AsmJSIonExitRegD1 = a1;
+static constexpr Register AsmJSIonExitRegD2 = t0;
 
 // Registerd used in RegExpMatcher instruction (do not use JSReturnOperand).
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherLastIndexReg = CallTempReg2;
+static constexpr Register RegExpMatcherRegExpReg = CallTempReg0;
+static constexpr Register RegExpMatcherStringReg = CallTempReg1;
+static constexpr Register RegExpMatcherLastIndexReg = CallTempReg2;
 
 // Registerd used in RegExpTester instruction (do not use ReturnReg).
-static MOZ_CONSTEXPR_VAR Register RegExpTesterRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterLastIndexReg = CallTempReg2;
+static constexpr Register RegExpTesterRegExpReg = CallTempReg0;
+static constexpr Register RegExpTesterStringReg = CallTempReg1;
+static constexpr Register RegExpTesterLastIndexReg = CallTempReg2;
 
-static MOZ_CONSTEXPR_VAR uint32_t CodeAlignment = 4;
+static constexpr uint32_t CodeAlignment = 4;
 
 // This boolean indicates whether we support SIMD instructions flavoured for
 // this architecture or not. Rather than a method in the LIRGenerator, it is
 // here such that it is accessible from the entire codebase. Once full support
 // for SIMD is reached on all tier-1 platforms, this constant can be deleted.
-static MOZ_CONSTEXPR_VAR bool SupportsSimd = false;
+static constexpr bool SupportsSimd = false;
 
 // MIPS instruction types
 //                +---------------------------------------------------------------+
 //                |    6      |    5    |    5    |    5    |    5    |    6      |
 //                +---------------------------------------------------------------+
 // Register type  |  Opcode   |    Rs   |    Rt   |    Rd   |    Sa   | Function  |
 //                +---------------------------------------------------------------+
 //                |    6      |    5    |    5    |               16              |
--- a/js/src/jit/mips32/Architecture-mips32.h
+++ b/js/src/jit/mips32/Architecture-mips32.h
@@ -133,20 +133,20 @@ class FloatRegister : public FloatRegist
     typedef Codes::Code Code;
     typedef Codes::Encoding Encoding;
 
     uint32_t code_ : 6;
   protected:
     RegType kind_ : 1;
 
   public:
-    MOZ_CONSTEXPR FloatRegister(uint32_t code, RegType kind = Double)
+    constexpr FloatRegister(uint32_t code, RegType kind = Double)
       : code_ (Code(code)), kind_(kind)
     { }
-    MOZ_CONSTEXPR FloatRegister()
+    constexpr FloatRegister()
       : code_(Code(FloatRegisters::invalid_freg)), kind_(Double)
     { }
 
     bool operator==(const FloatRegister& other) const {
         MOZ_ASSERT(!isInvalid());
         MOZ_ASSERT(!other.isInvalid());
         return kind_ == other.kind_ && code_ == other.code_;
     }
--- a/js/src/jit/mips32/Assembler-mips32.h
+++ b/js/src/jit/mips32/Assembler-mips32.h
@@ -9,20 +9,20 @@
 
 #include "jit/mips-shared/Assembler-mips-shared.h"
 
 #include "jit/mips32/Architecture-mips32.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register CallTempReg4 = t4;
-static MOZ_CONSTEXPR_VAR Register CallTempReg5 = t5;
+static constexpr Register CallTempReg4 = t4;
+static constexpr Register CallTempReg5 = t5;
 
-static MOZ_CONSTEXPR_VAR Register CallTempNonArgRegs[] = { t0, t1, t2, t3, t4 };
+static constexpr Register CallTempNonArgRegs[] = { t0, t1, t2, t3, t4 };
 static const uint32_t NumCallTempNonArgRegs = mozilla::ArrayLength(CallTempNonArgRegs);
 
 class ABIArgGenerator
 {
     unsigned usedArgSlots_;
     unsigned firstArgFloatSize_;
     // Note: This is not compliant with the system ABI.  The Lowering phase
     // expects to lower an MAsmJSParameter to only one register.
@@ -41,82 +41,82 @@ class ABIArgGenerator
     uint32_t stackBytesConsumedSoFar() const {
         if (usedArgSlots_ <= 4)
             return ShadowStackSpace;
 
         return usedArgSlots_ * sizeof(intptr_t);
     }
 };
 
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = t0;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = t1;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = t0;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = t1;
+static constexpr Register ABINonArgReg0 = t0;
+static constexpr Register ABINonArgReg1 = t1;
+static constexpr Register ABINonArgReturnReg0 = t0;
+static constexpr Register ABINonArgReturnReg1 = t1;
 
 // Registers used for asm.js/wasm table calls. These registers must be disjoint
 // from the ABI argument registers and from each other.
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = ABINonArgReg0;
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = ABINonArgReg1;
+static constexpr Register WasmTableCallPtrReg = ABINonArgReg0;
+static constexpr Register WasmTableCallSigReg = ABINonArgReg1;
 
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = a3;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = a2;
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(InvalidReg, InvalidReg);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = { FloatRegisters::f0, FloatRegister::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = { FloatRegisters::f0, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = { FloatRegisters::f18, FloatRegister::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = { FloatRegisters::f18, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister SecondScratchFloat32Reg = { FloatRegisters::f16, FloatRegister::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister SecondScratchDoubleReg = { FloatRegisters::f16, FloatRegister::Double };
+static constexpr Register JSReturnReg_Type = a3;
+static constexpr Register JSReturnReg_Data = a2;
+static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg);
+static constexpr FloatRegister ReturnFloat32Reg = { FloatRegisters::f0, FloatRegister::Single };
+static constexpr FloatRegister ReturnDoubleReg = { FloatRegisters::f0, FloatRegister::Double };
+static constexpr FloatRegister ScratchFloat32Reg = { FloatRegisters::f18, FloatRegister::Single };
+static constexpr FloatRegister ScratchDoubleReg = { FloatRegisters::f18, FloatRegister::Double };
+static constexpr FloatRegister SecondScratchFloat32Reg = { FloatRegisters::f16, FloatRegister::Single };
+static constexpr FloatRegister SecondScratchDoubleReg = { FloatRegisters::f16, FloatRegister::Double };
 
 // Registers used in the GenerateFFIIonExit Disable Activation block.
 // None of these may be the second scratch register (t8).
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = JSReturnReg_Data;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = JSReturnReg_Type;
+static constexpr Register AsmJSIonExitRegReturnData = JSReturnReg_Data;
+static constexpr Register AsmJSIonExitRegReturnType = JSReturnReg_Type;
 
-static MOZ_CONSTEXPR_VAR FloatRegister f0  = { FloatRegisters::f0, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f2  = { FloatRegisters::f2, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f4  = { FloatRegisters::f4, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f6  = { FloatRegisters::f6, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f8  = { FloatRegisters::f8, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f10 = { FloatRegisters::f10, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f12 = { FloatRegisters::f12, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f14 = { FloatRegisters::f14, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f16 = { FloatRegisters::f16, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f18 = { FloatRegisters::f18, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f20 = { FloatRegisters::f20, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f22 = { FloatRegisters::f22, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f24 = { FloatRegisters::f24, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f26 = { FloatRegisters::f26, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f28 = { FloatRegisters::f28, FloatRegister::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f30 = { FloatRegisters::f30, FloatRegister::Double };
+static constexpr FloatRegister f0  = { FloatRegisters::f0, FloatRegister::Double };
+static constexpr FloatRegister f2  = { FloatRegisters::f2, FloatRegister::Double };
+static constexpr FloatRegister f4  = { FloatRegisters::f4, FloatRegister::Double };
+static constexpr FloatRegister f6  = { FloatRegisters::f6, FloatRegister::Double };
+static constexpr FloatRegister f8  = { FloatRegisters::f8, FloatRegister::Double };
+static constexpr FloatRegister f10 = { FloatRegisters::f10, FloatRegister::Double };
+static constexpr FloatRegister f12 = { FloatRegisters::f12, FloatRegister::Double };
+static constexpr FloatRegister f14 = { FloatRegisters::f14, FloatRegister::Double };
+static constexpr FloatRegister f16 = { FloatRegisters::f16, FloatRegister::Double };
+static constexpr FloatRegister f18 = { FloatRegisters::f18, FloatRegister::Double };
+static constexpr FloatRegister f20 = { FloatRegisters::f20, FloatRegister::Double };
+static constexpr FloatRegister f22 = { FloatRegisters::f22, FloatRegister::Double };
+static constexpr FloatRegister f24 = { FloatRegisters::f24, FloatRegister::Double };
+static constexpr FloatRegister f26 = { FloatRegisters::f26, FloatRegister::Double };
+static constexpr FloatRegister f28 = { FloatRegisters::f28, FloatRegister::Double };
+static constexpr FloatRegister f30 = { FloatRegisters::f30, FloatRegister::Double };
 
 // MIPS CPUs can only load multibyte data that is "naturally"
 // four-byte-aligned, sp register should be eight-byte-aligned.
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 8;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackAlignment = 8;
+static constexpr uint32_t ABIStackAlignment = 8;
+static constexpr uint32_t JitStackAlignment = 8;
 
-static MOZ_CONSTEXPR_VAR uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
+static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
 static_assert(JitStackAlignment % sizeof(Value) == 0 && JitStackValueAlignment >= 1,
   "Stack alignment should be a non-zero multiple of sizeof(Value)");
 
 // TODO this is just a filler to prevent a build failure. The MIPS SIMD
 // alignment requirements still need to be explored.
 // TODO Copy the static_asserts from x64/x86 assembler files.
-static MOZ_CONSTEXPR_VAR uint32_t SimdMemoryAlignment = 8;
-static MOZ_CONSTEXPR_VAR uint32_t AsmJSStackAlignment = SimdMemoryAlignment;
+static constexpr uint32_t SimdMemoryAlignment = 8;
+static constexpr uint32_t AsmJSStackAlignment = SimdMemoryAlignment;
 
 // Does this architecture support SIMD conversions between Uint32x4 and Float32x4?
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4FloatConversions = false;
+static constexpr bool SupportsUint32x4FloatConversions = false;
 
 // Does this architecture support comparisons of unsigned integer vectors?
-static MOZ_CONSTEXPR_VAR bool SupportsUint8x16Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint16x8Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4Compares = false;
+static constexpr bool SupportsUint8x16Compares = false;
+static constexpr bool SupportsUint16x8Compares = false;
+static constexpr bool SupportsUint32x4Compares = false;
 
-static MOZ_CONSTEXPR_VAR Scale ScalePointer = TimesFour;
+static constexpr Scale ScalePointer = TimesFour;
 
 class Assembler : public AssemblerMIPSShared
 {
   public:
     Assembler()
       : AssemblerMIPSShared()
     { }
 
--- a/js/src/jit/mips32/SharedICRegisters-mips32.h
+++ b/js/src/jit/mips32/SharedICRegisters-mips32.h
@@ -7,38 +7,38 @@
 #ifndef jit_mips32_SharedICRegisters_mips32_h
 #define jit_mips32_SharedICRegisters_mips32_h
 
 #include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = s5;
-static MOZ_CONSTEXPR_VAR Register BaselineStackReg = sp;
+static constexpr Register BaselineFrameReg = s5;
+static constexpr Register BaselineStackReg = sp;
 
-static MOZ_CONSTEXPR_VAR ValueOperand R0(a3, a2);
-static MOZ_CONSTEXPR_VAR ValueOperand R1(s7, s6);
-static MOZ_CONSTEXPR_VAR ValueOperand R2(t7, t6);
+static constexpr ValueOperand R0(a3, a2);
+static constexpr ValueOperand R1(s7, s6);
+static constexpr ValueOperand R2(t7, t6);
 
 // ICTailCallReg and ICStubReg
 // These use registers that are not preserved across calls.
-static MOZ_CONSTEXPR_VAR Register ICTailCallReg = ra;
-static MOZ_CONSTEXPR_VAR Register ICStubReg = t5;
+static constexpr Register ICTailCallReg = ra;
+static constexpr Register ICStubReg = t5;
 
-static MOZ_CONSTEXPR_VAR Register ExtractTemp0 = InvalidReg;
-static MOZ_CONSTEXPR_VAR Register ExtractTemp1 = InvalidReg;
+static constexpr Register ExtractTemp0 = InvalidReg;
+static constexpr Register ExtractTemp1 = InvalidReg;
 
 // Register used internally by MacroAssemblerMIPS.
-static MOZ_CONSTEXPR_VAR Register BaselineSecondScratchReg = SecondScratchReg;
+static constexpr Register BaselineSecondScratchReg = SecondScratchReg;
 
 // Note that ICTailCallReg is actually just the link register.
 // In MIPS code emission, we do not clobber ICTailCallReg since we keep
 // the return address for calls there.
 
 // FloatReg0 must be equal to ReturnFloatReg.
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0 = f0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1 = f2;
+static constexpr FloatRegister FloatReg0 = f0;
+static constexpr FloatRegister FloatReg1 = f2;
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_mips32_SharedICRegisters_mips32_h */
--- a/js/src/jit/mips64/Architecture-mips64.h
+++ b/js/src/jit/mips64/Architecture-mips64.h
@@ -101,20 +101,20 @@ class FloatRegister : public FloatRegist
     typedef Codes::Encoding Encoding;
     typedef Codes::ContentType ContentType;
 
     Encoding reg_: 6;
   private:
     ContentType kind_ : 3;
 
   public:
-    MOZ_CONSTEXPR FloatRegister(uint32_t r, ContentType kind = Codes::Double)
+    constexpr FloatRegister(uint32_t r, ContentType kind = Codes::Double)
       : reg_(Encoding(r)), kind_(kind)
     { }
-    MOZ_CONSTEXPR FloatRegister()
+    constexpr FloatRegister()
       : reg_(Encoding(FloatRegisters::invalid_freg)), kind_(Codes::Double)
     { }
 
     bool operator==(const FloatRegister& other) const {
         MOZ_ASSERT(!isInvalid());
         MOZ_ASSERT(!other.isInvalid());
         return kind_ == other.kind_ && reg_ == other.reg_;
     }
--- a/js/src/jit/mips64/Assembler-mips64.h
+++ b/js/src/jit/mips64/Assembler-mips64.h
@@ -9,20 +9,20 @@
 
 #include "jit/mips-shared/Assembler-mips-shared.h"
 
 #include "jit/mips64/Architecture-mips64.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register CallTempReg4 = a4;
-static MOZ_CONSTEXPR_VAR Register CallTempReg5 = a5;
+static constexpr Register CallTempReg4 = a4;
+static constexpr Register CallTempReg5 = a5;
 
-static MOZ_CONSTEXPR_VAR Register CallTempNonArgRegs[] = { t0, t1, t2, t3 };
+static constexpr Register CallTempNonArgRegs[] = { t0, t1, t2, t3 };
 static const uint32_t NumCallTempNonArgRegs = mozilla::ArrayLength(CallTempNonArgRegs);
 
 class ABIArgGenerator
 {
     unsigned usedArgSlots_;
     bool firstArgFloat;
     ABIArg current_;
 
@@ -34,100 +34,100 @@ class ABIArgGenerator
     uint32_t stackBytesConsumedSoFar() const {
         if (usedArgSlots_ <= 8)
             return 0;
 
         return (usedArgSlots_ - 8) * sizeof(int64_t);
     }
 };
 
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = t0;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = t1;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = t0;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = t1;
+static constexpr Register ABINonArgReg0 = t0;
+static constexpr Register ABINonArgReg1 = t1;
+static constexpr Register ABINonArgReturnReg0 = t0;
+static constexpr Register ABINonArgReturnReg1 = t1;
 
 // Registers used for asm.js/wasm table calls. These registers must be disjoint
 // from the ABI argument registers and from each other.
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = ABINonArgReg0;
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = ABINonArgReg1;
+static constexpr Register WasmTableCallPtrReg = ABINonArgReg0;
+static constexpr Register WasmTableCallSigReg = ABINonArgReg1;
 
-static MOZ_CONSTEXPR_VAR Register JSReturnReg = v1;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = JSReturnReg;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = JSReturnReg;
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(ReturnReg);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = { FloatRegisters::f0, FloatRegisters::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = { FloatRegisters::f0, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = { FloatRegisters::f23, FloatRegisters::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = { FloatRegisters::f23, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister SecondScratchFloat32Reg = { FloatRegisters::f21, FloatRegisters::Single };
-static MOZ_CONSTEXPR_VAR FloatRegister SecondScratchDoubleReg = { FloatRegisters::f21, FloatRegisters::Double };
+static constexpr Register JSReturnReg = v1;
+static constexpr Register JSReturnReg_Type = JSReturnReg;
+static constexpr Register JSReturnReg_Data = JSReturnReg;
+static constexpr Register64 ReturnReg64(ReturnReg);
+static constexpr FloatRegister ReturnFloat32Reg = { FloatRegisters::f0, FloatRegisters::Single };
+static constexpr FloatRegister ReturnDoubleReg = { FloatRegisters::f0, FloatRegisters::Double };
+static constexpr FloatRegister ScratchFloat32Reg = { FloatRegisters::f23, FloatRegisters::Single };
+static constexpr FloatRegister ScratchDoubleReg = { FloatRegisters::f23, FloatRegisters::Double };
+static constexpr FloatRegister SecondScratchFloat32Reg = { FloatRegisters::f21, FloatRegisters::Single };
+static constexpr FloatRegister SecondScratchDoubleReg = { FloatRegisters::f21, FloatRegisters::Double };
 
 // Registers used in the GenerateFFIIonExit Disable Activation block.
 // None of these may be the second scratch register (t8).
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = JSReturnReg_Data;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = JSReturnReg_Type;
+static constexpr Register AsmJSIonExitRegReturnData = JSReturnReg_Data;
+static constexpr Register AsmJSIonExitRegReturnType = JSReturnReg_Type;
 
-static MOZ_CONSTEXPR_VAR FloatRegister f0  = { FloatRegisters::f0, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f1  = { FloatRegisters::f1, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f2  = { FloatRegisters::f2, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f3  = { FloatRegisters::f3, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f4  = { FloatRegisters::f4, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f5  = { FloatRegisters::f5, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f6  = { FloatRegisters::f6, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f7  = { FloatRegisters::f7, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f8  = { FloatRegisters::f8, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f9  = { FloatRegisters::f9, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f10 = { FloatRegisters::f10, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f11 = { FloatRegisters::f11, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f12 = { FloatRegisters::f12, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f13 = { FloatRegisters::f13, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f14 = { FloatRegisters::f14, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f15 = { FloatRegisters::f15, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f16 = { FloatRegisters::f16, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f17 = { FloatRegisters::f17, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f18 = { FloatRegisters::f18, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f19 = { FloatRegisters::f19, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f20 = { FloatRegisters::f20, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f21 = { FloatRegisters::f21, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f22 = { FloatRegisters::f22, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f23 = { FloatRegisters::f23, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f24 = { FloatRegisters::f24, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f25 = { FloatRegisters::f25, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f26 = { FloatRegisters::f26, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f27 = { FloatRegisters::f27, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f28 = { FloatRegisters::f28, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f29 = { FloatRegisters::f29, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f30 = { FloatRegisters::f30, FloatRegisters::Double };
-static MOZ_CONSTEXPR_VAR FloatRegister f31 = { FloatRegisters::f31, FloatRegisters::Double };
+static constexpr FloatRegister f0  = { FloatRegisters::f0, FloatRegisters::Double };
+static constexpr FloatRegister f1  = { FloatRegisters::f1, FloatRegisters::Double };
+static constexpr FloatRegister f2  = { FloatRegisters::f2, FloatRegisters::Double };
+static constexpr FloatRegister f3  = { FloatRegisters::f3, FloatRegisters::Double };
+static constexpr FloatRegister f4  = { FloatRegisters::f4, FloatRegisters::Double };
+static constexpr FloatRegister f5  = { FloatRegisters::f5, FloatRegisters::Double };
+static constexpr FloatRegister f6  = { FloatRegisters::f6, FloatRegisters::Double };
+static constexpr FloatRegister f7  = { FloatRegisters::f7, FloatRegisters::Double };
+static constexpr FloatRegister f8  = { FloatRegisters::f8, FloatRegisters::Double };
+static constexpr FloatRegister f9  = { FloatRegisters::f9, FloatRegisters::Double };
+static constexpr FloatRegister f10 = { FloatRegisters::f10, FloatRegisters::Double };
+static constexpr FloatRegister f11 = { FloatRegisters::f11, FloatRegisters::Double };
+static constexpr FloatRegister f12 = { FloatRegisters::f12, FloatRegisters::Double };
+static constexpr FloatRegister f13 = { FloatRegisters::f13, FloatRegisters::Double };
+static constexpr FloatRegister f14 = { FloatRegisters::f14, FloatRegisters::Double };
+static constexpr FloatRegister f15 = { FloatRegisters::f15, FloatRegisters::Double };
+static constexpr FloatRegister f16 = { FloatRegisters::f16, FloatRegisters::Double };
+static constexpr FloatRegister f17 = { FloatRegisters::f17, FloatRegisters::Double };
+static constexpr FloatRegister f18 = { FloatRegisters::f18, FloatRegisters::Double };
+static constexpr FloatRegister f19 = { FloatRegisters::f19, FloatRegisters::Double };
+static constexpr FloatRegister f20 = { FloatRegisters::f20, FloatRegisters::Double };
+static constexpr FloatRegister f21 = { FloatRegisters::f21, FloatRegisters::Double };
+static constexpr FloatRegister f22 = { FloatRegisters::f22, FloatRegisters::Double };
+static constexpr FloatRegister f23 = { FloatRegisters::f23, FloatRegisters::Double };
+static constexpr FloatRegister f24 = { FloatRegisters::f24, FloatRegisters::Double };
+static constexpr FloatRegister f25 = { FloatRegisters::f25, FloatRegisters::Double };
+static constexpr FloatRegister f26 = { FloatRegisters::f26, FloatRegisters::Double };
+static constexpr FloatRegister f27 = { FloatRegisters::f27, FloatRegisters::Double };
+static constexpr FloatRegister f28 = { FloatRegisters::f28, FloatRegisters::Double };
+static constexpr FloatRegister f29 = { FloatRegisters::f29, FloatRegisters::Double };
+static constexpr FloatRegister f30 = { FloatRegisters::f30, FloatRegisters::Double };
+static constexpr FloatRegister f31 = { FloatRegisters::f31, FloatRegisters::Double };
 
 // MIPS64 CPUs can only load multibyte data that is "naturally"
 // eight-byte-aligned, sp register should be sixteen-byte-aligned.
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 16;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackAlignment = 16;
+static constexpr uint32_t ABIStackAlignment = 16;
+static constexpr uint32_t JitStackAlignment = 16;
 
-static MOZ_CONSTEXPR_VAR uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
+static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
 static_assert(JitStackAlignment % sizeof(Value) == 0 && JitStackValueAlignment >= 1,
   "Stack alignment should be a non-zero multiple of sizeof(Value)");
 
 // TODO this is just a filler to prevent a build failure. The MIPS SIMD
 // alignment requirements still need to be explored.
 // TODO Copy the static_asserts from x64/x86 assembler files.
-static MOZ_CONSTEXPR_VAR uint32_t SimdMemoryAlignment = 16;
+static constexpr uint32_t SimdMemoryAlignment = 16;
 
-static MOZ_CONSTEXPR_VAR uint32_t AsmJSStackAlignment = SimdMemoryAlignment;
+static constexpr uint32_t AsmJSStackAlignment = SimdMemoryAlignment;
 
 // Does this architecture support SIMD conversions between Uint32x4 and Float32x4?
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4FloatConversions = false;
+static constexpr bool SupportsUint32x4FloatConversions = false;
 
 // Does this architecture support comparisons of unsigned integer vectors?
-static MOZ_CONSTEXPR_VAR bool SupportsUint8x16Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint16x8Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4Compares = false;
+static constexpr bool SupportsUint8x16Compares = false;
+static constexpr bool SupportsUint16x8Compares = false;
+static constexpr bool SupportsUint32x4Compares = false;
 
-static MOZ_CONSTEXPR_VAR Scale ScalePointer = TimesEight;
+static constexpr Scale ScalePointer = TimesEight;
 
 class Assembler : public AssemblerMIPSShared
 {
   public:
     Assembler()
       : AssemblerMIPSShared()
     { }
 
--- a/js/src/jit/mips64/SharedICRegisters-mips64.h
+++ b/js/src/jit/mips64/SharedICRegisters-mips64.h
@@ -7,41 +7,41 @@
 #ifndef jit_mips64_SharedICRegisters_mips64_h
 #define jit_mips64_SharedICRegisters_mips64_h
 
 #include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = s5;
-static MOZ_CONSTEXPR_VAR Register BaselineStackReg = sp;
+static constexpr Register BaselineFrameReg = s5;
+static constexpr Register BaselineStackReg = sp;
 
 // ValueOperands R0, R1, and R2.
 // R0 == JSReturnReg, and R2 uses registers not preserved across calls. R1 value
 // should be preserved across calls.
-static MOZ_CONSTEXPR_VAR ValueOperand R0(v1);
-static MOZ_CONSTEXPR_VAR ValueOperand R1(s4);
-static MOZ_CONSTEXPR_VAR ValueOperand R2(a6);
+static constexpr ValueOperand R0(v1);
+static constexpr ValueOperand R1(s4);
+static constexpr ValueOperand R2(a6);
 
 // ICTailCallReg and ICStubReg
 // These use registers that are not preserved across calls.
-static MOZ_CONSTEXPR_VAR Register ICTailCallReg = ra;
-static MOZ_CONSTEXPR_VAR Register ICStubReg = a5;
+static constexpr Register ICTailCallReg = ra;
+static constexpr Register ICStubReg = a5;
 
-static MOZ_CONSTEXPR_VAR Register ExtractTemp0 = s6;
-static MOZ_CONSTEXPR_VAR Register ExtractTemp1 = s7;
+static constexpr Register ExtractTemp0 = s6;
+static constexpr Register ExtractTemp1 = s7;
 
 // Register used internally by MacroAssemblerMIPS.
-static MOZ_CONSTEXPR_VAR Register BaselineSecondScratchReg = SecondScratchReg;
+static constexpr Register BaselineSecondScratchReg = SecondScratchReg;
 
 // Note that ICTailCallReg is actually just the link register.
 // In MIPS code emission, we do not clobber ICTailCallReg since we keep
 // the return address for calls there.
 
 // FloatReg0 must be equal to ReturnFloatReg.
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0 = f0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1 = f2;
+static constexpr FloatRegister FloatReg0 = f0;
+static constexpr FloatRegister FloatReg1 = f2;
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_mips64_SharedICRegisters_mips64_h */
--- a/js/src/jit/none/Architecture-none.h
+++ b/js/src/jit/none/Architecture-none.h
@@ -14,22 +14,22 @@
 namespace js {
 namespace jit {
 
 static const bool SupportsSimd = false;
 static const uint32_t SimdMemoryAlignment = 4; // Make it 4 to avoid a bunch of div-by-zero warnings
 static const uint32_t AsmJSStackAlignment = 8;
 
 // Does this architecture support SIMD conversions between Uint32x4 and Float32x4?
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4FloatConversions = false;
+static constexpr bool SupportsUint32x4FloatConversions = false;
 
 // Does this architecture support comparisons of unsigned integer vectors?
-static MOZ_CONSTEXPR_VAR bool SupportsUint8x16Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint16x8Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4Compares = false;
+static constexpr bool SupportsUint8x16Compares = false;
+static constexpr bool SupportsUint16x8Compares = false;
+static constexpr bool SupportsUint32x4Compares = false;
 
 class Registers
 {
   public:
     enum RegisterID {
         r0 = 0,
         invalid_reg
     };
--- a/js/src/jit/none/MacroAssembler-none.h
+++ b/js/src/jit/none/MacroAssembler-none.h
@@ -9,92 +9,92 @@
 
 #include "jit/JitCompartment.h"
 #include "jit/MoveResolver.h"
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register StackPointer = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register FramePointer = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ReturnReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnSimd128Reg = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchSimd128Reg = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister InvalidFloatReg = { FloatRegisters::invalid_reg };
+static constexpr Register StackPointer = { Registers::invalid_reg };
+static constexpr Register FramePointer = { Registers::invalid_reg };
+static constexpr Register ReturnReg = { Registers::invalid_reg };
+static constexpr FloatRegister ReturnFloat32Reg = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister ReturnDoubleReg = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister ReturnSimd128Reg = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister ScratchFloat32Reg = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister ScratchDoubleReg = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister ScratchSimd128Reg = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister InvalidFloatReg = { FloatRegisters::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register OsrFrameReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ArgumentsRectifierReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register PreBarrierReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register CallTempReg0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register CallTempReg1 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register CallTempReg2 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register CallTempReg3 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register CallTempReg4 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register CallTempReg5 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register InvalidReg = { Registers::invalid_reg };
+static constexpr Register OsrFrameReg = { Registers::invalid_reg };
+static constexpr Register ArgumentsRectifierReg = { Registers::invalid_reg };
+static constexpr Register PreBarrierReg = { Registers::invalid_reg };
+static constexpr Register CallTempReg0 = { Registers::invalid_reg };
+static constexpr Register CallTempReg1 = { Registers::invalid_reg };
+static constexpr Register CallTempReg2 = { Registers::invalid_reg };
+static constexpr Register CallTempReg3 = { Registers::invalid_reg };
+static constexpr Register CallTempReg4 = { Registers::invalid_reg };
+static constexpr Register CallTempReg5 = { Registers::invalid_reg };
+static constexpr Register InvalidReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register IntArgReg0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register IntArgReg1 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register IntArgReg2 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register IntArgReg3 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register GlobalReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register HeapReg = { Registers::invalid_reg };
+static constexpr Register IntArgReg0 = { Registers::invalid_reg };
+static constexpr Register IntArgReg1 = { Registers::invalid_reg };
+static constexpr Register IntArgReg2 = { Registers::invalid_reg };
+static constexpr Register IntArgReg3 = { Registers::invalid_reg };
+static constexpr Register GlobalReg = { Registers::invalid_reg };
+static constexpr Register HeapReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegCallee = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE1 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE2 = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegCallee = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegE0 = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegE1 = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegE2 = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD1 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD2 = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegReturnData = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegReturnType = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegD0 = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegD1 = { Registers::invalid_reg };
+static constexpr Register AsmJSIonExitRegD2 = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register RegExpTesterRegExpReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStringReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register RegExpTesterLastIndexReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStickyReg = { Registers::invalid_reg };
+static constexpr Register RegExpTesterRegExpReg = { Registers::invalid_reg };
+static constexpr Register RegExpTesterStringReg = { Registers::invalid_reg };
+static constexpr Register RegExpTesterLastIndexReg = { Registers::invalid_reg };
+static constexpr Register RegExpTesterStickyReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherRegExpReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStringReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherLastIndexReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStickyReg = { Registers::invalid_reg };
+static constexpr Register RegExpMatcherRegExpReg = { Registers::invalid_reg };
+static constexpr Register RegExpMatcherStringReg = { Registers::invalid_reg };
+static constexpr Register RegExpMatcherLastIndexReg = { Registers::invalid_reg };
+static constexpr Register RegExpMatcherStickyReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register JSReturnReg = { Registers::invalid_reg };
+static constexpr Register JSReturnReg_Type = { Registers::invalid_reg };
+static constexpr Register JSReturnReg_Data = { Registers::invalid_reg };
+static constexpr Register JSReturnReg = { Registers::invalid_reg };
 
 #if defined(JS_NUNBOX32)
-static MOZ_CONSTEXPR_VAR ValueOperand JSReturnOperand(InvalidReg, InvalidReg);
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(InvalidReg, InvalidReg);
+static constexpr ValueOperand JSReturnOperand(InvalidReg, InvalidReg);
+static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg);
 #elif defined(JS_PUNBOX64)
-static MOZ_CONSTEXPR_VAR ValueOperand JSReturnOperand(InvalidReg);
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(InvalidReg);
+static constexpr ValueOperand JSReturnOperand(InvalidReg);
+static constexpr Register64 ReturnReg64(InvalidReg);
 #else
 #error "Bad architecture"
 #endif
 
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = { Registers::invalid_reg };
+static constexpr Register ABINonArgReg0 = { Registers::invalid_reg };
+static constexpr Register ABINonArgReg1 = { Registers::invalid_reg };
+static constexpr Register ABINonArgReturnReg0 = { Registers::invalid_reg };
+static constexpr Register ABINonArgReturnReg1 = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = { Registers::invalid_reg };
+static constexpr Register WasmTableCallPtrReg = { Registers::invalid_reg };
+static constexpr Register WasmTableCallSigReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 4;
-static MOZ_CONSTEXPR_VAR uint32_t CodeAlignment = 4;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackAlignment = 8;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
+static constexpr uint32_t ABIStackAlignment = 4;
+static constexpr uint32_t CodeAlignment = 4;
+static constexpr uint32_t JitStackAlignment = 8;
+static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
 
 static const Scale ScalePointer = TimesOne;
 
 class Assembler : public AssemblerShared
 {
   public:
     enum Condition {
         Equal,
--- a/js/src/jit/none/SharedICRegisters-none.h
+++ b/js/src/jit/none/SharedICRegisters-none.h
@@ -7,29 +7,29 @@
 #ifndef jit_none_SharedICRegisters_none_h
 #define jit_none_SharedICRegisters_none_h
 
 #include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register BaselineStackReg = { Registers::invalid_reg };
+static constexpr Register BaselineFrameReg = { Registers::invalid_reg };
+static constexpr Register BaselineStackReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR ValueOperand R0 = JSReturnOperand;
-static MOZ_CONSTEXPR_VAR ValueOperand R1 = JSReturnOperand;
-static MOZ_CONSTEXPR_VAR ValueOperand R2 = JSReturnOperand;
+static constexpr ValueOperand R0 = JSReturnOperand;
+static constexpr ValueOperand R1 = JSReturnOperand;
+static constexpr ValueOperand R2 = JSReturnOperand;
 
-static MOZ_CONSTEXPR_VAR Register ICTailCallReg = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ICStubReg = { Registers::invalid_reg };
+static constexpr Register ICTailCallReg = { Registers::invalid_reg };
+static constexpr Register ICStubReg = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR Register ExtractTemp0 = { Registers::invalid_reg };
-static MOZ_CONSTEXPR_VAR Register ExtractTemp1 = { Registers::invalid_reg };
+static constexpr Register ExtractTemp0 = { Registers::invalid_reg };
+static constexpr Register ExtractTemp1 = { Registers::invalid_reg };
 
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0 = { FloatRegisters::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1 = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister FloatReg0 = { FloatRegisters::invalid_reg };
+static constexpr FloatRegister FloatReg1 = { FloatRegisters::invalid_reg };
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_none_SharedICRegisters_none_h */
 
--- a/js/src/jit/x64/Assembler-x64.h
+++ b/js/src/jit/x64/Assembler-x64.h
@@ -11,171 +11,171 @@
 
 #include "jit/IonCode.h"
 #include "jit/JitCompartment.h"
 #include "jit/shared/Assembler-shared.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register rax = { X86Encoding::rax };
-static MOZ_CONSTEXPR_VAR Register rbx = { X86Encoding::rbx };
-static MOZ_CONSTEXPR_VAR Register rcx = { X86Encoding::rcx };
-static MOZ_CONSTEXPR_VAR Register rdx = { X86Encoding::rdx };
-static MOZ_CONSTEXPR_VAR Register rsi = { X86Encoding::rsi };
-static MOZ_CONSTEXPR_VAR Register rdi = { X86Encoding::rdi };
-static MOZ_CONSTEXPR_VAR Register rbp = { X86Encoding::rbp };
-static MOZ_CONSTEXPR_VAR Register r8  = { X86Encoding::r8  };
-static MOZ_CONSTEXPR_VAR Register r9  = { X86Encoding::r9  };
-static MOZ_CONSTEXPR_VAR Register r10 = { X86Encoding::r10 };
-static MOZ_CONSTEXPR_VAR Register r11 = { X86Encoding::r11 };
-static MOZ_CONSTEXPR_VAR Register r12 = { X86Encoding::r12 };
-static MOZ_CONSTEXPR_VAR Register r13 = { X86Encoding::r13 };
-static MOZ_CONSTEXPR_VAR Register r14 = { X86Encoding::r14 };
-static MOZ_CONSTEXPR_VAR Register r15 = { X86Encoding::r15 };
-static MOZ_CONSTEXPR_VAR Register rsp = { X86Encoding::rsp };
+static constexpr Register rax = { X86Encoding::rax };
+static constexpr Register rbx = { X86Encoding::rbx };
+static constexpr Register rcx = { X86Encoding::rcx };
+static constexpr Register rdx = { X86Encoding::rdx };
+static constexpr Register rsi = { X86Encoding::rsi };
+static constexpr Register rdi = { X86Encoding::rdi };
+static constexpr Register rbp = { X86Encoding::rbp };
+static constexpr Register r8  = { X86Encoding::r8  };
+static constexpr Register r9  = { X86Encoding::r9  };
+static constexpr Register r10 = { X86Encoding::r10 };
+static constexpr Register r11 = { X86Encoding::r11 };
+static constexpr Register r12 = { X86Encoding::r12 };
+static constexpr Register r13 = { X86Encoding::r13 };
+static constexpr Register r14 = { X86Encoding::r14 };
+static constexpr Register r15 = { X86Encoding::r15 };
+static constexpr Register rsp = { X86Encoding::rsp };
 
-static MOZ_CONSTEXPR_VAR FloatRegister xmm0 = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm1 = FloatRegister(X86Encoding::xmm1, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm2 = FloatRegister(X86Encoding::xmm2, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm3 = FloatRegister(X86Encoding::xmm3, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm4 = FloatRegister(X86Encoding::xmm4, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm5 = FloatRegister(X86Encoding::xmm5, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm6 = FloatRegister(X86Encoding::xmm6, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm7 = FloatRegister(X86Encoding::xmm7, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm8 = FloatRegister(X86Encoding::xmm8, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm9 = FloatRegister(X86Encoding::xmm9, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm10 = FloatRegister(X86Encoding::xmm10, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm11 = FloatRegister(X86Encoding::xmm11, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm12 = FloatRegister(X86Encoding::xmm12, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm13 = FloatRegister(X86Encoding::xmm13, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm14 = FloatRegister(X86Encoding::xmm14, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm15 = FloatRegister(X86Encoding::xmm15, FloatRegisters::Double);
+static constexpr FloatRegister xmm0 = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
+static constexpr FloatRegister xmm1 = FloatRegister(X86Encoding::xmm1, FloatRegisters::Double);
+static constexpr FloatRegister xmm2 = FloatRegister(X86Encoding::xmm2, FloatRegisters::Double);
+static constexpr FloatRegister xmm3 = FloatRegister(X86Encoding::xmm3, FloatRegisters::Double);
+static constexpr FloatRegister xmm4 = FloatRegister(X86Encoding::xmm4, FloatRegisters::Double);
+static constexpr FloatRegister xmm5 = FloatRegister(X86Encoding::xmm5, FloatRegisters::Double);
+static constexpr FloatRegister xmm6 = FloatRegister(X86Encoding::xmm6, FloatRegisters::Double);
+static constexpr FloatRegister xmm7 = FloatRegister(X86Encoding::xmm7, FloatRegisters::Double);
+static constexpr FloatRegister xmm8 = FloatRegister(X86Encoding::xmm8, FloatRegisters::Double);
+static constexpr FloatRegister xmm9 = FloatRegister(X86Encoding::xmm9, FloatRegisters::Double);
+static constexpr FloatRegister xmm10 = FloatRegister(X86Encoding::xmm10, FloatRegisters::Double);
+static constexpr FloatRegister xmm11 = FloatRegister(X86Encoding::xmm11, FloatRegisters::Double);
+static constexpr FloatRegister xmm12 = FloatRegister(X86Encoding::xmm12, FloatRegisters::Double);
+static constexpr FloatRegister xmm13 = FloatRegister(X86Encoding::xmm13, FloatRegisters::Double);
+static constexpr FloatRegister xmm14 = FloatRegister(X86Encoding::xmm14, FloatRegisters::Double);
+static constexpr FloatRegister xmm15 = FloatRegister(X86Encoding::xmm15, FloatRegisters::Double);
 
 // X86-common synonyms.
-static MOZ_CONSTEXPR_VAR Register eax = rax;
-static MOZ_CONSTEXPR_VAR Register ebx = rbx;
-static MOZ_CONSTEXPR_VAR Register ecx = rcx;
-static MOZ_CONSTEXPR_VAR Register edx = rdx;
-static MOZ_CONSTEXPR_VAR Register esi = rsi;
-static MOZ_CONSTEXPR_VAR Register edi = rdi;
-static MOZ_CONSTEXPR_VAR Register ebp = rbp;
-static MOZ_CONSTEXPR_VAR Register esp = rsp;
+static constexpr Register eax = rax;
+static constexpr Register ebx = rbx;
+static constexpr Register ecx = rcx;
+static constexpr Register edx = rdx;
+static constexpr Register esi = rsi;
+static constexpr Register edi = rdi;
+static constexpr Register ebp = rbp;
+static constexpr Register esp = rsp;
 
-static MOZ_CONSTEXPR_VAR Register InvalidReg = { X86Encoding::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister InvalidFloatReg = FloatRegister();
+static constexpr Register InvalidReg = { X86Encoding::invalid_reg };
+static constexpr FloatRegister InvalidFloatReg = FloatRegister();
 
-static MOZ_CONSTEXPR_VAR Register StackPointer = rsp;
-static MOZ_CONSTEXPR_VAR Register FramePointer = rbp;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg = rcx;
+static constexpr Register StackPointer = rsp;
+static constexpr Register FramePointer = rbp;
+static constexpr Register JSReturnReg = rcx;
 // Avoid, except for assertions.
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = JSReturnReg;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = JSReturnReg;
+static constexpr Register JSReturnReg_Type = JSReturnReg;
+static constexpr Register JSReturnReg_Data = JSReturnReg;
 
-static MOZ_CONSTEXPR_VAR Register ScratchReg = r11;
+static constexpr Register ScratchReg = r11;
 
 // Helper class for ScratchRegister usage. Asserts that only one piece
 // of code thinks it has exclusive ownership of the scratch register.
 struct ScratchRegisterScope : public AutoRegisterScope
 {
     explicit ScratchRegisterScope(MacroAssembler& masm)
       : AutoRegisterScope(masm, ScratchReg)
     { }
 };
 
-static MOZ_CONSTEXPR_VAR Register ReturnReg = rax;
-static MOZ_CONSTEXPR_VAR Register HeapReg = r15;
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(rax);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Single);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnSimd128Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Simd128);
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = FloatRegister(X86Encoding::xmm15, FloatRegisters::Single);
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = FloatRegister(X86Encoding::xmm15, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchSimd128Reg = xmm15;
+static constexpr Register ReturnReg = rax;
+static constexpr Register HeapReg = r15;
+static constexpr Register64 ReturnReg64(rax);
+static constexpr FloatRegister ReturnFloat32Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Single);
+static constexpr FloatRegister ReturnDoubleReg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
+static constexpr FloatRegister ReturnSimd128Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Simd128);
+static constexpr FloatRegister ScratchFloat32Reg = FloatRegister(X86Encoding::xmm15, FloatRegisters::Single);
+static constexpr FloatRegister ScratchDoubleReg = FloatRegister(X86Encoding::xmm15, FloatRegisters::Double);
+static constexpr FloatRegister ScratchSimd128Reg = xmm15;
 
 // Avoid rbp, which is the FramePointer, which is unavailable in some modes.
-static MOZ_CONSTEXPR_VAR Register ArgumentsRectifierReg = r8;
-static MOZ_CONSTEXPR_VAR Register CallTempReg0 = rax;
-static MOZ_CONSTEXPR_VAR Register CallTempReg1 = rdi;
-static MOZ_CONSTEXPR_VAR Register CallTempReg2 = rbx;
-static MOZ_CONSTEXPR_VAR Register CallTempReg3 = rcx;
-static MOZ_CONSTEXPR_VAR Register CallTempReg4 = rsi;
-static MOZ_CONSTEXPR_VAR Register CallTempReg5 = rdx;
+static constexpr Register ArgumentsRectifierReg = r8;
+static constexpr Register CallTempReg0 = rax;
+static constexpr Register CallTempReg1 = rdi;
+static constexpr Register CallTempReg2 = rbx;
+static constexpr Register CallTempReg3 = rcx;
+static constexpr Register CallTempReg4 = rsi;
+static constexpr Register CallTempReg5 = rdx;
 
 // Different argument registers for WIN64
 #if defined(_WIN64)
-static MOZ_CONSTEXPR_VAR Register IntArgReg0 = rcx;
-static MOZ_CONSTEXPR_VAR Register IntArgReg1 = rdx;
-static MOZ_CONSTEXPR_VAR Register IntArgReg2 = r8;
-static MOZ_CONSTEXPR_VAR Register IntArgReg3 = r9;
-static MOZ_CONSTEXPR_VAR uint32_t NumIntArgRegs = 4;
-// Use "const" instead of MOZ_CONSTEXPR_VAR here to work around a bug
+static constexpr Register IntArgReg0 = rcx;
+static constexpr Register IntArgReg1 = rdx;
+static constexpr Register IntArgReg2 = r8;
+static constexpr Register IntArgReg3 = r9;
+static constexpr uint32_t NumIntArgRegs = 4;
+// Use "const" instead of constexpr here to work around a bug
 // of VS2015 Update 1. See bug 1229604.
 static const Register IntArgRegs[NumIntArgRegs] = { rcx, rdx, r8, r9 };
 
 static const Register CallTempNonArgRegs[] = { rax, rdi, rbx, rsi };
 static const uint32_t NumCallTempNonArgRegs =
     mozilla::ArrayLength(CallTempNonArgRegs);
 
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg0 = xmm0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg1 = xmm1;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg2 = xmm2;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg3 = xmm3;
+static constexpr FloatRegister FloatArgReg0 = xmm0;
+static constexpr FloatRegister FloatArgReg1 = xmm1;
+static constexpr FloatRegister FloatArgReg2 = xmm2;
+static constexpr FloatRegister FloatArgReg3 = xmm3;
 static const uint32_t NumFloatArgRegs = 4;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgRegs[NumFloatArgRegs] = { xmm0, xmm1, xmm2, xmm3 };
+static constexpr FloatRegister FloatArgRegs[NumFloatArgRegs] = { xmm0, xmm1, xmm2, xmm3 };
 #else
-static MOZ_CONSTEXPR_VAR Register IntArgReg0 = rdi;
-static MOZ_CONSTEXPR_VAR Register IntArgReg1 = rsi;
-static MOZ_CONSTEXPR_VAR Register IntArgReg2 = rdx;
-static MOZ_CONSTEXPR_VAR Register IntArgReg3 = rcx;
-static MOZ_CONSTEXPR_VAR Register IntArgReg4 = r8;
-static MOZ_CONSTEXPR_VAR Register IntArgReg5 = r9;
-static MOZ_CONSTEXPR_VAR uint32_t NumIntArgRegs = 6;
+static constexpr Register IntArgReg0 = rdi;
+static constexpr Register IntArgReg1 = rsi;
+static constexpr Register IntArgReg2 = rdx;
+static constexpr Register IntArgReg3 = rcx;
+static constexpr Register IntArgReg4 = r8;
+static constexpr Register IntArgReg5 = r9;
+static constexpr uint32_t NumIntArgRegs = 6;
 static const Register IntArgRegs[NumIntArgRegs] = { rdi, rsi, rdx, rcx, r8, r9 };
 
-// Use "const" instead of MOZ_CONSTEXPR_VAR here to work around a bug
+// Use "const" instead of constexpr here to work around a bug
 // of VS2015 Update 1. See bug 1229604.
 static const Register CallTempNonArgRegs[] = { rax, rbx };
 static const uint32_t NumCallTempNonArgRegs =
     mozilla::ArrayLength(CallTempNonArgRegs);
 
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg0 = xmm0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg1 = xmm1;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg2 = xmm2;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg3 = xmm3;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg4 = xmm4;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg5 = xmm5;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg6 = xmm6;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgReg7 = xmm7;
-static MOZ_CONSTEXPR_VAR uint32_t NumFloatArgRegs = 8;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatArgRegs[NumFloatArgRegs] = { xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7 };
+static constexpr FloatRegister FloatArgReg0 = xmm0;
+static constexpr FloatRegister FloatArgReg1 = xmm1;
+static constexpr FloatRegister FloatArgReg2 = xmm2;
+static constexpr FloatRegister FloatArgReg3 = xmm3;
+static constexpr FloatRegister FloatArgReg4 = xmm4;
+static constexpr FloatRegister FloatArgReg5 = xmm5;
+static constexpr FloatRegister FloatArgReg6 = xmm6;
+static constexpr FloatRegister FloatArgReg7 = xmm7;
+static constexpr uint32_t NumFloatArgRegs = 8;
+static constexpr FloatRegister FloatArgRegs[NumFloatArgRegs] = { xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7 };
 #endif
 
 // Registers used in the GenerateFFIIonExit Enable Activation block.
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegCallee = r10;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE0 = rax;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE1 = rdi;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE2 = rbx;
+static constexpr Register AsmJSIonExitRegCallee = r10;
+static constexpr Register AsmJSIonExitRegE0 = rax;
+static constexpr Register AsmJSIonExitRegE1 = rdi;
+static constexpr Register AsmJSIonExitRegE2 = rbx;
 
 // Registers used in the GenerateFFIIonExit Disable Activation block.
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = ecx;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = ecx;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD0 = rax;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD1 = rdi;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD2 = rbx;
+static constexpr Register AsmJSIonExitRegReturnData = ecx;
+static constexpr Register AsmJSIonExitRegReturnType = ecx;
+static constexpr Register AsmJSIonExitRegD0 = rax;
+static constexpr Register AsmJSIonExitRegD1 = rdi;
+static constexpr Register AsmJSIonExitRegD2 = rbx;
 
 // Registerd used in RegExpMatcher instruction (do not use JSReturnOperand).
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherLastIndexReg = CallTempReg2;
+static constexpr Register RegExpMatcherRegExpReg = CallTempReg0;
+static constexpr Register RegExpMatcherStringReg = CallTempReg1;
+static constexpr Register RegExpMatcherLastIndexReg = CallTempReg2;
 
 // Registerd used in RegExpTester instruction (do not use ReturnReg).
-static MOZ_CONSTEXPR_VAR Register RegExpTesterRegExpReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStringReg = CallTempReg2;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterLastIndexReg = CallTempReg3;
+static constexpr Register RegExpTesterRegExpReg = CallTempReg1;
+static constexpr Register RegExpTesterStringReg = CallTempReg2;
+static constexpr Register RegExpTesterLastIndexReg = CallTempReg3;
 
 class ABIArgGenerator
 {
 #if defined(XP_WIN)
     unsigned regIndex_;
 #else
     unsigned intRegIndex_;
     unsigned floatRegIndex_;
@@ -186,47 +186,47 @@ class ABIArgGenerator
   public:
     ABIArgGenerator();
     ABIArg next(MIRType argType);
     ABIArg& current() { return current_; }
     uint32_t stackBytesConsumedSoFar() const { return stackOffset_; }
 };
 
 // Avoid r11, which is the MacroAssembler's ScratchReg.
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = rax;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = rbx;
+static constexpr Register ABINonArgReg0 = rax;
+static constexpr Register ABINonArgReg1 = rbx;
 
 // Note: these three registers are all guaranteed to be different
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = r10;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = r12;
-static MOZ_CONSTEXPR_VAR Register ABINonVolatileReg = r13;
+static constexpr Register ABINonArgReturnReg0 = r10;
+static constexpr Register ABINonArgReturnReg1 = r12;
+static constexpr Register ABINonVolatileReg = r13;
 
 // Registers used for asm.js/wasm table calls. These registers must be disjoint
 // from the ABI argument registers and from each other.
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = ABINonArgReg0;
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = ABINonArgReg1;
+static constexpr Register WasmTableCallPtrReg = ABINonArgReg0;
+static constexpr Register WasmTableCallSigReg = ABINonArgReg1;
 
-static MOZ_CONSTEXPR_VAR Register OsrFrameReg = IntArgReg3;
+static constexpr Register OsrFrameReg = IntArgReg3;
 
-static MOZ_CONSTEXPR_VAR Register PreBarrierReg = rdx;
+static constexpr Register PreBarrierReg = rdx;
 
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 16;
-static MOZ_CONSTEXPR_VAR uint32_t CodeAlignment = 16;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackAlignment = 16;
+static constexpr uint32_t ABIStackAlignment = 16;
+static constexpr uint32_t CodeAlignment = 16;
+static constexpr uint32_t JitStackAlignment = 16;
 
-static MOZ_CONSTEXPR_VAR uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
+static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
 static_assert(JitStackAlignment % sizeof(Value) == 0 && JitStackValueAlignment >= 1,
   "Stack alignment should be a non-zero multiple of sizeof(Value)");
 
 // This boolean indicates whether we support SIMD instructions flavoured for
 // this architecture or not. Rather than a method in the LIRGenerator, it is
 // here such that it is accessible from the entire codebase. Once full support
 // for SIMD is reached on all tier-1 platforms, this constant can be deleted.
-static MOZ_CONSTEXPR_VAR bool SupportsSimd = true;
-static MOZ_CONSTEXPR_VAR uint32_t SimdMemoryAlignment = 16;
+static constexpr bool SupportsSimd = true;
+static constexpr uint32_t SimdMemoryAlignment = 16;
 
 static_assert(CodeAlignment % SimdMemoryAlignment == 0,
   "Code alignment should be larger than any of the alignments which are used for "
   "the constant sections of the code buffer.  Thus it should be larger than the "
   "alignment for SIMD constants.");
 
 static_assert(JitStackAlignment % SimdMemoryAlignment == 0,
   "Stack alignment should be larger than any of the alignments which are used for "
@@ -240,17 +240,17 @@ static const Scale ScalePointer = TimesE
 } // namespace js
 
 #include "jit/x86-shared/Assembler-x86-shared.h"
 
 namespace js {
 namespace jit {
 
 // Return operand from a JS -> JS call.
-static MOZ_CONSTEXPR_VAR ValueOperand JSReturnOperand = ValueOperand(JSReturnReg);
+static constexpr ValueOperand JSReturnOperand = ValueOperand(JSReturnReg);
 
 class Assembler : public AssemblerX86Shared
 {
     // x64 jumps may need extra bits of relocation, because a jump may extend
     // beyond the signed 32-bit range. To account for this we add an extended
     // jump table at the bottom of the instruction stream, and if a jump
     // overflows its range, it will redirect here.
     //
--- a/js/src/jit/x64/SharedICRegisters-x64.h
+++ b/js/src/jit/x64/SharedICRegisters-x64.h
@@ -7,29 +7,29 @@
 #ifndef jit_x64_SharedICRegisters_x64_h
 #define jit_x64_SharedICRegisters_x64_h
 
 #include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register BaselineFrameReg    = rbp;
-static MOZ_CONSTEXPR_VAR Register BaselineStackReg    = rsp;
+static constexpr Register BaselineFrameReg    = rbp;
+static constexpr Register BaselineStackReg    = rsp;
 
-static MOZ_CONSTEXPR_VAR ValueOperand R0(rcx);
-static MOZ_CONSTEXPR_VAR ValueOperand R1(rbx);
-static MOZ_CONSTEXPR_VAR ValueOperand R2(rax);
+static constexpr ValueOperand R0(rcx);
+static constexpr ValueOperand R1(rbx);
+static constexpr ValueOperand R2(rax);
 
-static MOZ_CONSTEXPR_VAR Register ICTailCallReg       = rsi;
-static MOZ_CONSTEXPR_VAR Register ICStubReg           = rdi;
+static constexpr Register ICTailCallReg       = rsi;
+static constexpr Register ICStubReg           = rdi;
 
-static MOZ_CONSTEXPR_VAR Register ExtractTemp0        = r14;
-static MOZ_CONSTEXPR_VAR Register ExtractTemp1        = r15;
+static constexpr Register ExtractTemp0        = r14;
+static constexpr Register ExtractTemp1        = r15;
 
 // FloatReg0 must be equal to ReturnFloatReg.
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = xmm0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = xmm1;
+static constexpr FloatRegister FloatReg0      = xmm0;
+static constexpr FloatRegister FloatReg1      = xmm1;
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_x64_SharedICRegisters_x64_h */
--- a/js/src/jit/x86-shared/Architecture-x86-shared.h
+++ b/js/src/jit/x86-shared/Architecture-x86-shared.h
@@ -16,22 +16,22 @@
 #include <string.h>
 
 #include "jit/x86-shared/Constants-x86-shared.h"
 
 namespace js {
 namespace jit {
 
 // Does this architecture support SIMD conversions between Uint32x4 and Float32x4?
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4FloatConversions = false;
+static constexpr bool SupportsUint32x4FloatConversions = false;
 
 // Does this architecture support comparisons of unsigned integer vectors?
-static MOZ_CONSTEXPR_VAR bool SupportsUint8x16Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint16x8Compares = false;
-static MOZ_CONSTEXPR_VAR bool SupportsUint32x4Compares = false;
+static constexpr bool SupportsUint8x16Compares = false;
+static constexpr bool SupportsUint16x8Compares = false;
+static constexpr bool SupportsUint32x4Compares = false;
 
 #if defined(JS_CODEGEN_X86)
 // In bytes: slots needed for potential memory->memory move spills.
 //   +8 for cycles
 //   +4 for gpr spills
 //   +8 for double spills
 static const uint32_t ION_FRAME_SLACK_SIZE    = 20;
 
@@ -345,23 +345,23 @@ struct FloatRegister {
 #if defined(JS_CODEGEN_X86)
     static const size_t RegSize = 3;
 #elif defined(JS_CODEGEN_X64)
     static const size_t RegSize = 4;
 #endif
     static const size_t RegMask = (1 << RegSize) - 1;
 
   public:
-    MOZ_CONSTEXPR FloatRegister()
+    constexpr FloatRegister()
         : reg_(Codes::Encoding(0)), type_(Codes::Single), isInvalid_(true)
     { }
-    MOZ_CONSTEXPR FloatRegister(uint32_t r, Codes::ContentType k)
+    constexpr FloatRegister(uint32_t r, Codes::ContentType k)
         : reg_(Codes::Encoding(r)), type_(k), isInvalid_(false)
     { }
-    MOZ_CONSTEXPR FloatRegister(Codes::Encoding r, Codes::ContentType k)
+    constexpr FloatRegister(Codes::Encoding r, Codes::ContentType k)
         : reg_(r), type_(k), isInvalid_(false)
     { }
 
     static FloatRegister FromCode(uint32_t i) {
         MOZ_ASSERT(i < Codes::Total);
         return FloatRegister(i & RegMask, Codes::ContentType(i >> RegSize));
     }
 
--- a/js/src/jit/x86/Assembler-x86.h
+++ b/js/src/jit/x86/Assembler-x86.h
@@ -13,61 +13,61 @@
 #include "jit/IonCode.h"
 #include "jit/JitCompartment.h"
 #include "jit/shared/Assembler-shared.h"
 #include "jit/x86-shared/Constants-x86-shared.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register eax = { X86Encoding::rax };
-static MOZ_CONSTEXPR_VAR Register ecx = { X86Encoding::rcx };
-static MOZ_CONSTEXPR_VAR Register edx = { X86Encoding::rdx };
-static MOZ_CONSTEXPR_VAR Register ebx = { X86Encoding::rbx };
-static MOZ_CONSTEXPR_VAR Register esp = { X86Encoding::rsp };
-static MOZ_CONSTEXPR_VAR Register ebp = { X86Encoding::rbp };
-static MOZ_CONSTEXPR_VAR Register esi = { X86Encoding::rsi };
-static MOZ_CONSTEXPR_VAR Register edi = { X86Encoding::rdi };
+static constexpr Register eax = { X86Encoding::rax };
+static constexpr Register ecx = { X86Encoding::rcx };
+static constexpr Register edx = { X86Encoding::rdx };
+static constexpr Register ebx = { X86Encoding::rbx };
+static constexpr Register esp = { X86Encoding::rsp };
+static constexpr Register ebp = { X86Encoding::rbp };
+static constexpr Register esi = { X86Encoding::rsi };
+static constexpr Register edi = { X86Encoding::rdi };
 
-static MOZ_CONSTEXPR_VAR FloatRegister xmm0 = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm1 = FloatRegister(X86Encoding::xmm1, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm2 = FloatRegister(X86Encoding::xmm2, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm3 = FloatRegister(X86Encoding::xmm3, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm4 = FloatRegister(X86Encoding::xmm4, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm5 = FloatRegister(X86Encoding::xmm5, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm6 = FloatRegister(X86Encoding::xmm6, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister xmm7 = FloatRegister(X86Encoding::xmm7, FloatRegisters::Double);
+static constexpr FloatRegister xmm0 = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
+static constexpr FloatRegister xmm1 = FloatRegister(X86Encoding::xmm1, FloatRegisters::Double);
+static constexpr FloatRegister xmm2 = FloatRegister(X86Encoding::xmm2, FloatRegisters::Double);
+static constexpr FloatRegister xmm3 = FloatRegister(X86Encoding::xmm3, FloatRegisters::Double);
+static constexpr FloatRegister xmm4 = FloatRegister(X86Encoding::xmm4, FloatRegisters::Double);
+static constexpr FloatRegister xmm5 = FloatRegister(X86Encoding::xmm5, FloatRegisters::Double);
+static constexpr FloatRegister xmm6 = FloatRegister(X86Encoding::xmm6, FloatRegisters::Double);
+static constexpr FloatRegister xmm7 = FloatRegister(X86Encoding::xmm7, FloatRegisters::Double);
 
-static MOZ_CONSTEXPR_VAR Register InvalidReg = { X86Encoding::invalid_reg };
-static MOZ_CONSTEXPR_VAR FloatRegister InvalidFloatReg = FloatRegister();
+static constexpr Register InvalidReg = { X86Encoding::invalid_reg };
+static constexpr FloatRegister InvalidFloatReg = FloatRegister();
 
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Type = ecx;
-static MOZ_CONSTEXPR_VAR Register JSReturnReg_Data = edx;
-static MOZ_CONSTEXPR_VAR Register StackPointer = esp;
-static MOZ_CONSTEXPR_VAR Register FramePointer = ebp;
-static MOZ_CONSTEXPR_VAR Register ReturnReg = eax;
-static MOZ_CONSTEXPR_VAR Register64 ReturnReg64(InvalidReg, InvalidReg);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnFloat32Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Single);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnDoubleReg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister ReturnSimd128Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Simd128);
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchFloat32Reg = FloatRegister(X86Encoding::xmm7, FloatRegisters::Single);
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchDoubleReg = FloatRegister(X86Encoding::xmm7, FloatRegisters::Double);
-static MOZ_CONSTEXPR_VAR FloatRegister ScratchSimd128Reg = FloatRegister(X86Encoding::xmm7, FloatRegisters::Simd128);
+static constexpr Register JSReturnReg_Type = ecx;
+static constexpr Register JSReturnReg_Data = edx;
+static constexpr Register StackPointer = esp;
+static constexpr Register FramePointer = ebp;
+static constexpr Register ReturnReg = eax;
+static constexpr Register64 ReturnReg64(InvalidReg, InvalidReg);
+static constexpr FloatRegister ReturnFloat32Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Single);
+static constexpr FloatRegister ReturnDoubleReg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Double);
+static constexpr FloatRegister ReturnSimd128Reg = FloatRegister(X86Encoding::xmm0, FloatRegisters::Simd128);
+static constexpr FloatRegister ScratchFloat32Reg = FloatRegister(X86Encoding::xmm7, FloatRegisters::Single);
+static constexpr FloatRegister ScratchDoubleReg = FloatRegister(X86Encoding::xmm7, FloatRegisters::Double);
+static constexpr FloatRegister ScratchSimd128Reg = FloatRegister(X86Encoding::xmm7, FloatRegisters::Simd128);
 
 // Avoid ebp, which is the FramePointer, which is unavailable in some modes.
-static MOZ_CONSTEXPR_VAR Register ArgumentsRectifierReg = esi;
-static MOZ_CONSTEXPR_VAR Register CallTempReg0 = edi;
-static MOZ_CONSTEXPR_VAR Register CallTempReg1 = eax;
-static MOZ_CONSTEXPR_VAR Register CallTempReg2 = ebx;
-static MOZ_CONSTEXPR_VAR Register CallTempReg3 = ecx;
-static MOZ_CONSTEXPR_VAR Register CallTempReg4 = esi;
-static MOZ_CONSTEXPR_VAR Register CallTempReg5 = edx;
+static constexpr Register ArgumentsRectifierReg = esi;
+static constexpr Register CallTempReg0 = edi;
+static constexpr Register CallTempReg1 = eax;
+static constexpr Register CallTempReg2 = ebx;
+static constexpr Register CallTempReg3 = ecx;
+static constexpr Register CallTempReg4 = esi;
+static constexpr Register CallTempReg5 = edx;
 
 // We have no arg regs, so our NonArgRegs are just our CallTempReg*
-// Use "const" instead of MOZ_CONSTEXPR_VAR here to work around a bug
+// Use "const" instead of constexpr here to work around a bug
 // of VS2015 Update 1. See bug 1229604.
 static const Register CallTempNonArgRegs[] = { edi, eax, ebx, ecx, esi, edx };
 static const uint32_t NumCallTempNonArgRegs =
     mozilla::ArrayLength(CallTempNonArgRegs);
 
 class ABIArgGenerator
 {
     uint32_t stackOffset_;
@@ -76,75 +76,75 @@ class ABIArgGenerator
   public:
     ABIArgGenerator();
     ABIArg next(MIRType argType);
     ABIArg& current() { return current_; }
     uint32_t stackBytesConsumedSoFar() const { return stackOffset_; }
 
 };
 
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg0 = eax;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReg1 = ecx;
+static constexpr Register ABINonArgReg0 = eax;
+static constexpr Register ABINonArgReg1 = ecx;
 
 // Note: these three registers are all guaranteed to be different
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg0 = ecx;
-static MOZ_CONSTEXPR_VAR Register ABINonArgReturnReg1 = edx;
-static MOZ_CONSTEXPR_VAR Register ABINonVolatileReg = ebx;
+static constexpr Register ABINonArgReturnReg0 = ecx;
+static constexpr Register ABINonArgReturnReg1 = edx;
+static constexpr Register ABINonVolatileReg = ebx;
 
 // Registers used for asm.js/wasm table calls. These registers must be disjoint
 // from the ABI argument registers and from each other.
-static MOZ_CONSTEXPR_VAR Register WasmTableCallPtrReg = ABINonArgReg0;
-static MOZ_CONSTEXPR_VAR Register WasmTableCallSigReg = ABINonArgReg1;
+static constexpr Register WasmTableCallPtrReg = ABINonArgReg0;
+static constexpr Register WasmTableCallSigReg = ABINonArgReg1;
 
-static MOZ_CONSTEXPR_VAR Register OsrFrameReg = edx;
-static MOZ_CONSTEXPR_VAR Register PreBarrierReg = edx;
+static constexpr Register OsrFrameReg = edx;
+static constexpr Register PreBarrierReg = edx;
 
 // Registers used in the GenerateFFIIonExit Enable Activation block.
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegCallee = ecx;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE0 = edi;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE1 = eax;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegE2 = ebx;
+static constexpr Register AsmJSIonExitRegCallee = ecx;
+static constexpr Register AsmJSIonExitRegE0 = edi;
+static constexpr Register AsmJSIonExitRegE1 = eax;
+static constexpr Register AsmJSIonExitRegE2 = ebx;
 
 // Registers used in the GenerateFFIIonExit Disable Activation block.
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnData = edx;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegReturnType = ecx;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD0 = edi;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD1 = eax;
-static MOZ_CONSTEXPR_VAR Register AsmJSIonExitRegD2 = esi;
+static constexpr Register AsmJSIonExitRegReturnData = edx;
+static constexpr Register AsmJSIonExitRegReturnType = ecx;
+static constexpr Register AsmJSIonExitRegD0 = edi;
+static constexpr Register AsmJSIonExitRegD1 = eax;
+static constexpr Register AsmJSIonExitRegD2 = esi;
 
 // Registerd used in RegExpMatcher instruction (do not use JSReturnOperand).
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherStringReg = CallTempReg1;
-static MOZ_CONSTEXPR_VAR Register RegExpMatcherLastIndexReg = CallTempReg2;
+static constexpr Register RegExpMatcherRegExpReg = CallTempReg0;
+static constexpr Register RegExpMatcherStringReg = CallTempReg1;
+static constexpr Register RegExpMatcherLastIndexReg = CallTempReg2;
 
 // Registerd used in RegExpTester instruction (do not use ReturnReg).
-static MOZ_CONSTEXPR_VAR Register RegExpTesterRegExpReg = CallTempReg0;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterStringReg = CallTempReg2;
-static MOZ_CONSTEXPR_VAR Register RegExpTesterLastIndexReg = CallTempReg3;
+static constexpr Register RegExpTesterRegExpReg = CallTempReg0;
+static constexpr Register RegExpTesterStringReg = CallTempReg2;
+static constexpr Register RegExpTesterLastIndexReg = CallTempReg3;
 
 // GCC stack is aligned on 16 bytes. Ion does not maintain this for internal
 // calls. asm.js code does.
 #if defined(__GNUC__)
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 16;
+static constexpr uint32_t ABIStackAlignment = 16;
 #else
-static MOZ_CONSTEXPR_VAR uint32_t ABIStackAlignment = 4;
+static constexpr uint32_t ABIStackAlignment = 4;
 #endif
-static MOZ_CONSTEXPR_VAR uint32_t CodeAlignment = 16;
-static MOZ_CONSTEXPR_VAR uint32_t JitStackAlignment = 16;
+static constexpr uint32_t CodeAlignment = 16;
+static constexpr uint32_t JitStackAlignment = 16;
 
-static MOZ_CONSTEXPR_VAR uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
+static constexpr uint32_t JitStackValueAlignment = JitStackAlignment / sizeof(Value);
 static_assert(JitStackAlignment % sizeof(Value) == 0 && JitStackValueAlignment >= 1,
   "Stack alignment should be a non-zero multiple of sizeof(Value)");
 
 // This boolean indicates whether we support SIMD instructions flavoured for
 // this architecture or not. Rather than a method in the LIRGenerator, it is
 // here such that it is accessible from the entire codebase. Once full support
 // for SIMD is reached on all tier-1 platforms, this constant can be deleted.
-static MOZ_CONSTEXPR_VAR bool SupportsSimd = true;
-static MOZ_CONSTEXPR_VAR uint32_t SimdMemoryAlignment = 16;
+static constexpr bool SupportsSimd = true;
+static constexpr uint32_t SimdMemoryAlignment = 16;
 
 static_assert(CodeAlignment % SimdMemoryAlignment == 0,
   "Code alignment should be larger than any of the alignments which are used for "
   "the constant sections of the code buffer.  Thus it should be larger than the "
   "alignment for SIMD constants.");
 
 static_assert(JitStackAlignment % SimdMemoryAlignment == 0,
   "Stack alignment should be larger than any of the alignments which are used for "
--- a/js/src/jit/x86/SharedICRegisters-x86.h
+++ b/js/src/jit/x86/SharedICRegisters-x86.h
@@ -7,32 +7,32 @@
 #ifndef jit_x86_SharedICRegisters_x86_h
 #define jit_x86_SharedICRegisters_x86_h
 
 #include "jit/MacroAssembler.h"
 
 namespace js {
 namespace jit {
 
-static MOZ_CONSTEXPR_VAR Register BaselineFrameReg = ebp;
-static MOZ_CONSTEXPR_VAR Register BaselineStackReg = esp;
+static constexpr Register BaselineFrameReg = ebp;
+static constexpr Register BaselineStackReg = esp;
 
 // ValueOperands R0, R1, and R2
-static MOZ_CONSTEXPR_VAR ValueOperand R0(ecx, edx);
-static MOZ_CONSTEXPR_VAR ValueOperand R1(eax, ebx);
-static MOZ_CONSTEXPR_VAR ValueOperand R2(esi, edi);
+static constexpr ValueOperand R0(ecx, edx);
+static constexpr ValueOperand R1(eax, ebx);
+static constexpr ValueOperand R2(esi, edi);
 
 // ICTailCallReg and ICStubReg reuse
 // registers from R2.
-static MOZ_CONSTEXPR_VAR Register ICTailCallReg       = esi;
-static MOZ_CONSTEXPR_VAR Register ICStubReg           = edi;
+static constexpr Register ICTailCallReg       = esi;
+static constexpr Register ICStubReg           = edi;
 
-static MOZ_CONSTEXPR_VAR Register ExtractTemp0        = InvalidReg;
-static MOZ_CONSTEXPR_VAR Register ExtractTemp1        = InvalidReg;
+static constexpr Register ExtractTemp0        = InvalidReg;
+static constexpr Register ExtractTemp1        = InvalidReg;
 
 // FloatReg0 must be equal to ReturnFloatReg.
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg0      = xmm0;
-static MOZ_CONSTEXPR_VAR FloatRegister FloatReg1      = xmm1;
+static constexpr FloatRegister FloatReg0      = xmm0;
+static constexpr FloatRegister FloatReg1      = xmm1;
 
 } // namespace jit
 } // namespace js
 
 #endif /* jit_x86_SharedICRegisters_x86_h */
--- a/js/src/jsapi-tests/testJitMoveEmitterCycles-mips32.cpp
+++ b/js/src/jsapi-tests/testJitMoveEmitterCycles-mips32.cpp
@@ -14,65 +14,65 @@
 #include "jit/MoveResolver.h"
 
 #include "jsapi-tests/tests.h"
 
 #include "vm/Runtime.h"
 
 static const int LIFO_ALLOC_PRIMARY_CHUNK_SIZE = 4*1024;
 
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single0(0, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single1(1, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single2(2, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single3(3, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single4(4, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single5(5, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single6(6, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single7(7, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single8(8, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single9(9, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single10(10, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single11(11, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single12(12, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single13(13, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single14(14, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single15(15, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single16(16, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single17(17, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single18(18, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single19(19, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single20(20, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single21(21, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single22(22, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single23(23, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single24(24, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single25(25, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single26(26, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single27(27, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single28(28, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single29(29, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single30(30, js::jit::FloatRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister single31(31, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single0(0, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single1(1, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single2(2, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single3(3, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single4(4, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single5(5, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single6(6, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single7(7, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single8(8, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single9(9, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single10(10, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single11(11, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single12(12, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single13(13, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single14(14, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single15(15, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single16(16, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single17(17, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single18(18, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single19(19, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single20(20, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single21(21, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single22(22, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single23(23, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single24(24, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single25(25, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single26(26, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single27(27, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single28(28, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single29(29, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single30(30, js::jit::FloatRegister::Single);
+static constexpr js::jit::FloatRegister single31(31, js::jit::FloatRegister::Single);
 
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double0(0, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double1(2, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double2(4, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double3(6, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double4(8, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double5(10, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double6(12, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double7(14, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double8(16, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double9(18, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double10(20, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double11(22, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double12(24, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double13(26, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double14(28, js::jit::FloatRegister::Double);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister double15(30, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double0(0, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double1(2, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double2(4, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double3(6, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double4(8, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double5(10, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double6(12, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double7(14, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double8(16, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double9(18, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double10(20, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double11(22, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double12(24, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double13(26, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double14(28, js::jit::FloatRegister::Double);
+static constexpr js::jit::FloatRegister double15(30, js::jit::FloatRegister::Double);
 
 static js::jit::JitCode*
 linkAndAllocate(JSContext* cx, js::jit::MacroAssembler* masm)
 {
     using namespace js;
     using namespace js::jit;
     AutoFlushICache afc("test");
     Linker l(*masm);
--- a/js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
+++ b/js/src/jsapi-tests/testJitMoveEmitterCycles.cpp
@@ -14,48 +14,48 @@
 #include "jit/MoveResolver.h"
 
 #include "jsapi-tests/tests.h"
 
 #include "vm/Runtime.h"
 
 static const int LIFO_ALLOC_PRIMARY_CHUNK_SIZE = 4*1024;
 
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s0(0, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s1(1, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s2(2, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s3(3, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s4(4, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s5(5, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s6(6, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s7(7, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s8(8, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s9(9, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s10(10, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s11(11, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s12(12, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s13(13, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s14(14, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s15(15, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s16(16, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s17(17, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s18(18, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s19(19, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s20(20, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s21(21, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s22(22, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s23(23, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s24(24, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s25(25, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s26(26, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s27(27, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s28(28, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s29(29, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s30(30, js::jit::VFPRegister::Single);
-static MOZ_CONSTEXPR_VAR js::jit::FloatRegister s31(31, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s0(0, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s1(1, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s2(2, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s3(3, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s4(4, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s5(5, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s6(6, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s7(7, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s8(8, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s9(9, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s10(10, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s11(11, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s12(12, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s13(13, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s14(14, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s15(15, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s16(16, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s17(17, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s18(18, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s19(19, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s20(20, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s21(21, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s22(22, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s23(23, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s24(24, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s25(25, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s26(26, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s27(27, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s28(28, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s29(29, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s30(30, js::jit::VFPRegister::Single);
+static constexpr js::jit::FloatRegister s31(31, js::jit::VFPRegister::Single);
 
 static js::jit::JitCode*
 linkAndAllocate(JSContext* cx, js::jit::MacroAssembler* masm)
 {
     using namespace js;
     using namespace js::jit;
     AutoFlushICache afc("test");
     Linker l(*masm);
--- a/js/src/jswrapper.h
+++ b/js/src/jswrapper.h
@@ -55,17 +55,17 @@ class MOZ_STACK_CLASS WrapperOptions : p
  * to add an override in CrossCompartmentWrapper. If you don't, you risk
  * compartment mismatches. See bug 945826 comment 0.
  */
 class JS_FRIEND_API(Wrapper) : public BaseProxyHandler
 {
     unsigned mFlags;
 
   public:
-    explicit MOZ_CONSTEXPR Wrapper(unsigned aFlags, bool aHasPrototype = false,
+    explicit constexpr Wrapper(unsigned aFlags, bool aHasPrototype = false,
                                    bool aHasSecurityPolicy = false)
       : BaseProxyHandler(&family, aHasPrototype, aHasSecurityPolicy),
         mFlags(aFlags)
     { }
 
     virtual bool finalizeInBackground(Value priv) const override;
 
     /* Standard internal methods. */
@@ -158,17 +158,17 @@ WrapperOptions::proto() const
 {
     return proto_ ? *proto_ : Wrapper::defaultProto;
 }
 
 /* Base class for all cross compartment wrapper handlers. */
 class JS_FRIEND_API(CrossCompartmentWrapper) : public Wrapper
 {
   public:
-    explicit MOZ_CONSTEXPR CrossCompartmentWrapper(unsigned aFlags, bool aHasPrototype = false,
+    explicit constexpr CrossCompartmentWrapper(unsigned aFlags, bool aHasPrototype = false,
                                                    bool aHasSecurityPolicy = false)
       : Wrapper(CROSS_COMPARTMENT | aFlags, aHasPrototype, aHasSecurityPolicy)
     { }
 
     /* Standard internal methods. */
     virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
                                           MutableHandle<PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
@@ -217,17 +217,17 @@ class JS_FRIEND_API(CrossCompartmentWrap
 
     static const CrossCompartmentWrapper singleton;
     static const CrossCompartmentWrapper singletonWithPrototype;
 };
 
 class JS_FRIEND_API(OpaqueCrossCompartmentWrapper) : public CrossCompartmentWrapper
 {
   public:
-    explicit MOZ_CONSTEXPR OpaqueCrossCompartmentWrapper() : CrossCompartmentWrapper(0)
+    explicit constexpr OpaqueCrossCompartmentWrapper() : CrossCompartmentWrapper(0)
     { }
 
     /* Standard internal methods. */
     virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
                                           MutableHandle<PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
                                 Handle<PropertyDescriptor> desc,
                                 ObjectOpResult& result) const override;
@@ -281,17 +281,17 @@ class JS_FRIEND_API(OpaqueCrossCompartme
  *
  * NB: Currently, only a few ProxyHandler operations are overridden to deny
  * access, relying on derived SecurityWrapper to block access when necessary.
  */
 template <class Base>
 class JS_FRIEND_API(SecurityWrapper) : public Base
 {
   public:
-    explicit MOZ_CONSTEXPR SecurityWrapper(unsigned flags, bool hasPrototype = false)
+    explicit constexpr SecurityWrapper(unsigned flags, bool hasPrototype = false)
       : Base(flags, hasPrototype, /* hasSecurityPolicy = */ true)
     { }
 
     virtual bool enter(JSContext* cx, HandleObject wrapper, HandleId id, Wrapper::Action act,
                        bool* bp) const override;
 
     virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
                                 Handle<PropertyDescriptor> desc,
--- a/js/src/proxy/DeadObjectProxy.h
+++ b/js/src/proxy/DeadObjectProxy.h
@@ -9,17 +9,17 @@
 
 #include "js/Proxy.h"
 
 namespace js {
 
 class DeadObjectProxy : public BaseProxyHandler
 {
   public:
-    explicit MOZ_CONSTEXPR DeadObjectProxy()
+    explicit constexpr DeadObjectProxy()
       : BaseProxyHandler(&family)
     { }
 
     /* Standard internal methods. */
     virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject wrapper, HandleId id,
                                           MutableHandle<PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, HandleObject wrapper, HandleId id,
                                 Handle<PropertyDescriptor> desc,
--- a/js/src/proxy/ScriptedProxyHandler.h
+++ b/js/src/proxy/ScriptedProxyHandler.h
@@ -10,17 +10,17 @@
 #include "js/Proxy.h"
 
 namespace js {
 
 /* Derived class for all scripted proxy handlers. */
 class ScriptedProxyHandler : public BaseProxyHandler
 {
   public:
-    MOZ_CONSTEXPR ScriptedProxyHandler()
+    constexpr ScriptedProxyHandler()
       : BaseProxyHandler(&family)
     { }
 
     /* Standard internal methods. */
     virtual bool getOwnPropertyDescriptor(JSContext* cx, HandleObject proxy, HandleId id,
                                           MutableHandle<PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, HandleObject proxy, HandleId id,
                                 Handle<PropertyDescriptor> desc,
--- a/js/src/vm/NativeObject.h
+++ b/js/src/vm/NativeObject.h
@@ -235,25 +235,25 @@ class ObjectElements
         return flags & COPY_ON_WRITE;
     }
     void clearCopyOnWrite() {
         MOZ_ASSERT(isCopyOnWrite());
         flags &= ~COPY_ON_WRITE;
     }
 
   public:
-    MOZ_CONSTEXPR ObjectElements(uint32_t capacity, uint32_t length)
+    constexpr ObjectElements(uint32_t capacity, uint32_t length)
       : flags(0), initializedLength(0), capacity(capacity), length(length)
     {}
 
     enum class SharedMemory {
         IsShared
     };
 
-    MOZ_CONSTEXPR ObjectElements(uint32_t capacity, uint32_t length, SharedMemory shmem)
+    constexpr ObjectElements(uint32_t capacity, uint32_t length, SharedMemory shmem)
       : flags(SHARED_MEMORY), initializedLength(0), capacity(capacity), length(length)
     {}
 
     HeapSlot* elements() {
         return reinterpret_cast<HeapSlot*>(uintptr_t(this) + sizeof(ObjectElements));
     }
     const HeapSlot* elements() const {
         return reinterpret_cast<const HeapSlot*>(uintptr_t(this) + sizeof(ObjectElements));
--- a/js/src/vm/Opcodes.h
+++ b/js/src/vm/Opcodes.h
@@ -2246,15 +2246,15 @@ static_assert((0 ==
                256),
               "opcode values and trailing unused opcode values monotonically "
               "increase from zero to 255");
 #undef TRAILING_VALUE_AND_VALUE_PLUS_ONE
 #undef VALUE_AND_VALUE_PLUS_ONE
 
 // Define JSOP_*_LENGTH constants for all ops.
 #define DEFINE_LENGTH_CONSTANT(op, val, name, image, len, ...) \
-    MOZ_CONSTEXPR_VAR size_t op##_LENGTH = len;
+    constexpr size_t op##_LENGTH = len;
 FOR_EACH_OPCODE(DEFINE_LENGTH_CONSTANT)
 #undef DEFINE_LENGTH_CONSTANT
 
 } // namespace js
 
 #endif // vm_Opcodes_h
--- a/js/src/vm/ScopeObject.cpp
+++ b/js/src/vm/ScopeObject.cpp
@@ -1989,17 +1989,17 @@ class DebugScopeProxy : public BaseProxy
         *success = true;
         return true;
     }
 
   public:
     static const char family;
     static const DebugScopeProxy singleton;
 
-    MOZ_CONSTEXPR DebugScopeProxy() : BaseProxyHandler(&family) {}
+    constexpr DebugScopeProxy() : BaseProxyHandler(&family) {}
 
     static bool isFunctionScopeWithThis(const JSObject& scope)
     {
         // All functions except arrows and generator expression lambdas should
         // have their own this binding.
         return isFunctionScope(scope) && !scope.as<CallObject>().callee().hasLexicalThis();
     }
 
--- a/js/src/vm/TypedArrayObject.cpp
+++ b/js/src/vm/TypedArrayObject.cpp
@@ -208,17 +208,17 @@ GetPrototypeForInstance(JSContext* cx, H
 template<typename NativeType>
 class TypedArrayObjectTemplate : public TypedArrayObject
 {
     friend class TypedArrayObject;
 
   public:
     typedef NativeType ElementType;
 
-    static MOZ_CONSTEXPR Scalar::Type ArrayTypeID() { return TypeIDOfType<NativeType>::id; }
+    static constexpr Scalar::Type ArrayTypeID() { return TypeIDOfType<NativeType>::id; }
     static bool ArrayTypeIsUnsigned() { return TypeIsUnsigned<NativeType>(); }
     static bool ArrayTypeIsFloatingPoint() { return TypeIsFloatingPoint<NativeType>(); }
 
     static const size_t BYTES_PER_ELEMENT = sizeof(NativeType);
 
     static JSObject*
     createPrototype(JSContext* cx, JSProtoKey key)
     {
--- a/js/xpconnect/src/XPCComponents.cpp
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -3489,17 +3489,17 @@ NS_IMETHODIMP nsXPCComponents::ReportErr
     return utils->ReportError(error, cx);
 }
 
 /**********************************************/
 
 class ComponentsSH : public nsIXPCScriptable
 {
 public:
-    explicit MOZ_CONSTEXPR ComponentsSH(unsigned dummy)
+    explicit constexpr ComponentsSH(unsigned dummy)
     {
     }
 
     // We don't actually inherit any ref counting infrastructure, but we don't
     // need an nsAutoRefCnt member, so the _INHERITED macro is a hack to avoid
     // having one.
     NS_DECL_ISUPPORTS_INHERITED
     NS_DECL_NSIXPCSCRIPTABLE
--- a/js/xpconnect/wrappers/AddonWrapper.h
+++ b/js/xpconnect/wrappers/AddonWrapper.h
@@ -21,17 +21,17 @@ InterposeProperty(JSContext* cx, JS::Han
 
 bool
 InterposeCall(JSContext* cx, JS::HandleObject wrapper,
               const JS::CallArgs& args, bool& done);
 
 template<typename Base>
 class AddonWrapper : public Base {
   public:
-    explicit MOZ_CONSTEXPR AddonWrapper(unsigned flags) : Base(flags) { }
+    explicit constexpr AddonWrapper(unsigned flags) : Base(flags) { }
 
     virtual bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                           JS::Handle<jsid> id,
                                           JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
                                 JS::Handle<JS::PropertyDescriptor> desc,
                                 JS::ObjectOpResult& result) const override;
     virtual bool delete_(JSContext* cx, JS::HandleObject proxy, JS::HandleId id,
--- a/js/xpconnect/wrappers/ChromeObjectWrapper.h
+++ b/js/xpconnect/wrappers/ChromeObjectWrapper.h
@@ -20,17 +20,17 @@ struct ExposedPropertiesOnly;
 // the traps that allow content to pass an object to chrome, and perform extra
 // security checks on them.
 #define ChromeObjectWrapperBase \
   FilteringWrapper<js::CrossCompartmentSecurityWrapper, ExposedPropertiesOnly>
 
 class ChromeObjectWrapper : public ChromeObjectWrapperBase
 {
   public:
-    MOZ_CONSTEXPR ChromeObjectWrapper() : ChromeObjectWrapperBase(0) {}
+    constexpr ChromeObjectWrapper() : ChromeObjectWrapperBase(0) {}
 
     virtual bool defineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                 JS::Handle<jsid> id,
                                 JS::Handle<JS::PropertyDescriptor> desc,
                                 JS::ObjectOpResult& result) const override;
     virtual bool set(JSContext* cx, JS::HandleObject wrapper, JS::HandleId id,
                      JS::HandleValue v, JS::HandleValue receiver,
                      JS::ObjectOpResult& result) const override;
--- a/js/xpconnect/wrappers/FilteringWrapper.h
+++ b/js/xpconnect/wrappers/FilteringWrapper.h
@@ -18,17 +18,17 @@ class AutoVectorRooter;
 typedef AutoVectorRooter<jsid> AutoIdVector;
 } // namespace JS
 
 namespace xpc {
 
 template <typename Base, typename Policy>
 class FilteringWrapper : public Base {
   public:
-    MOZ_CONSTEXPR explicit FilteringWrapper(unsigned flags) : Base(flags) {}
+    constexpr explicit FilteringWrapper(unsigned flags) : Base(flags) {}
 
     virtual bool enter(JSContext* cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,
                        js::Wrapper::Action act, bool* bp) const override;
 
     virtual bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                           JS::Handle<jsid> id,
                                           JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
     virtual bool ownPropertyKeys(JSContext* cx, JS::Handle<JSObject*> wrapper,
@@ -58,17 +58,17 @@ class FilteringWrapper : public Base {
 
 /*
  * The HTML5 spec mandates very particular object behavior for cross-origin DOM
  * objects (Window and Location), some of which runs contrary to the way that
  * other XrayWrappers behave. We use this class to implement those semantics.
  */
 class CrossOriginXrayWrapper : public SecurityXrayDOM {
   public:
-    MOZ_CONSTEXPR explicit CrossOriginXrayWrapper(unsigned flags) :
+    constexpr explicit CrossOriginXrayWrapper(unsigned flags) :
       SecurityXrayDOM(flags) {}
 
 
     virtual bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                           JS::Handle<jsid> id,
                                           JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                 JS::Handle<jsid> id,
--- a/js/xpconnect/wrappers/WaiveXrayWrapper.h
+++ b/js/xpconnect/wrappers/WaiveXrayWrapper.h
@@ -10,17 +10,17 @@
 #include "mozilla/Attributes.h"
 
 #include "jswrapper.h"
 
 namespace xpc {
 
 class WaiveXrayWrapper : public js::CrossCompartmentWrapper {
   public:
-    explicit MOZ_CONSTEXPR WaiveXrayWrapper(unsigned flags) : js::CrossCompartmentWrapper(flags) { }
+    explicit constexpr WaiveXrayWrapper(unsigned flags) : js::CrossCompartmentWrapper(flags) { }
 
     virtual bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                           JS::Handle<jsid> id,
                                           JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
     virtual bool getPrototype(JSContext* cx, JS::Handle<JSObject*> wrapper,
                               JS::MutableHandle<JSObject*> protop) const override;
     virtual bool getPrototypeIfOrdinary(JSContext* cx, JS::Handle<JSObject*> wrapper,
                                         bool* isOrdinary,
--- a/js/xpconnect/wrappers/XrayWrapper.h
+++ b/js/xpconnect/wrappers/XrayWrapper.h
@@ -56,17 +56,17 @@ enum XrayType {
     XrayForJSObject,
     XrayForOpaqueObject,
     NotXray
 };
 
 class XrayTraits
 {
 public:
-    MOZ_CONSTEXPR XrayTraits() {}
+    constexpr XrayTraits() {}
 
     static JSObject* getTargetObject(JSObject* wrapper) {
         return js::UncheckedUnwrap(wrapper, /* stopAtWindowProxy = */ false);
     }
 
     virtual bool resolveNativeProperty(JSContext* cx, JS::HandleObject wrapper,
                                        JS::HandleObject holder, JS::HandleId id,
                                        JS::MutableHandle<JS::PropertyDescriptor> desc) = 0;
@@ -155,17 +155,17 @@ public:
 
     static const JSClass HolderClass;
     static XPCWrappedNativeXrayTraits singleton;
 };
 
 class DOMXrayTraits : public XrayTraits
 {
 public:
-    MOZ_CONSTEXPR DOMXrayTraits() = default;
+    constexpr DOMXrayTraits() = default;
 
     enum {
         HasPrototype = 1
     };
 
     static const XrayType Type = XrayForDOMObject;
 
     virtual bool resolveNativeProperty(JSContext* cx, JS::HandleObject wrapper,
@@ -406,17 +406,17 @@ public:
 
 XrayType GetXrayType(JSObject* obj);
 XrayTraits* GetXrayTraits(JSObject* obj);
 
 // NB: Base *must* derive from JSProxyHandler
 template <typename Base, typename Traits = XPCWrappedNativeXrayTraits >
 class XrayWrapper : public Base {
   public:
-    MOZ_CONSTEXPR explicit XrayWrapper(unsigned flags)
+    constexpr explicit XrayWrapper(unsigned flags)
       : Base(flags | WrapperFactory::IS_XRAY_WRAPPER_FLAG, Traits::HasPrototype)
     { };
 
     /* Standard internal methods. */
     virtual bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,
                                           JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
     virtual bool defineProperty(JSContext* cx, JS::Handle<JSObject*> wrapper, JS::Handle<jsid> id,
                                 JS::Handle<JS::PropertyDescriptor> desc,
@@ -494,17 +494,17 @@ class XrayWrapper : public Base {
 #define PermissiveXrayDOM xpc::XrayWrapper<js::CrossCompartmentWrapper, xpc::DOMXrayTraits>
 #define SecurityXrayDOM xpc::XrayWrapper<js::CrossCompartmentSecurityWrapper, xpc::DOMXrayTraits>
 #define PermissiveXrayJS xpc::XrayWrapper<js::CrossCompartmentWrapper, xpc::JSXrayTraits>
 #define PermissiveXrayOpaque xpc::XrayWrapper<js::CrossCompartmentWrapper, xpc::OpaqueXrayTraits>
 #define SCSecurityXrayXPCWN xpc::XrayWrapper<js::SameCompartmentSecurityWrapper, xpc::XPCWrappedNativeXrayTraits>
 
 class SandboxProxyHandler : public js::Wrapper {
 public:
-    MOZ_CONSTEXPR SandboxProxyHandler() : js::Wrapper(0)
+    constexpr SandboxProxyHandler() : js::Wrapper(0)
     {
     }
 
     virtual bool getOwnPropertyDescriptor(JSContext* cx, JS::Handle<JSObject*> proxy,
                                           JS::Handle<jsid> id,
                                           JS::MutableHandle<JS::PropertyDescriptor> desc) const override;
 
     // We just forward the high-level methods to the BaseProxyHandler versions
@@ -530,17 +530,17 @@ public:
 
 extern const SandboxProxyHandler sandboxProxyHandler;
 
 // A proxy handler that lets us wrap callables and invoke them with
 // the correct this object, while forwarding all other operations down
 // to them directly.
 class SandboxCallableProxyHandler : public js::Wrapper {
 public:
-    MOZ_CONSTEXPR SandboxCallableProxyHandler() : js::Wrapper(0)
+    constexpr SandboxCallableProxyHandler() : js::Wrapper(0)
     {
     }
 
     virtual bool call(JSContext* cx, JS::Handle<JSObject*> proxy,
                       const JS::CallArgs& args) const override;
 
     static const size_t SandboxProxySlot = 0;
 
--- a/layout/base/FramePropertyTable.h
+++ b/layout/base/FramePropertyTable.h
@@ -41,17 +41,17 @@ struct FramePropertyDescriptorUntyped
    */
 
 protected:
   /**
    * At most one destructor should be passed in. In general, you should
    * just use the static function FramePropertyDescriptor::New* below
    * instead of using this constructor directly.
    */
-  MOZ_CONSTEXPR FramePropertyDescriptorUntyped(
+  constexpr FramePropertyDescriptorUntyped(
     UntypedDestructor* aDtor, UntypedDestructorWithFrame* aDtorWithFrame)
     : mDestructor(aDtor)
     , mDestructorWithFrame(aDtorWithFrame)
   {}
 };
 
 /**
  * A pointer to a FramePropertyDescriptor serves as a unique property ID.
@@ -67,35 +67,35 @@ protected:
 template<typename T>
 struct FramePropertyDescriptor : public FramePropertyDescriptorUntyped
 {
   typedef void Destructor(T* aPropertyValue);
   typedef void DestructorWithFrame(const nsIFrame* aaFrame,
                                    T* aPropertyValue);
 
   template<Destructor Dtor>
-  static MOZ_CONSTEXPR const FramePropertyDescriptor<T> NewWithDestructor()
+  static constexpr const FramePropertyDescriptor<T> NewWithDestructor()
   {
     return { Destruct<Dtor>, nullptr };
   }
 
   template<DestructorWithFrame Dtor>
-  static MOZ_CONSTEXPR
+  static constexpr
   const FramePropertyDescriptor<T> NewWithDestructorWithFrame()
   {
     return { nullptr, DestructWithFrame<Dtor> };
   }
 
-  static MOZ_CONSTEXPR const FramePropertyDescriptor<T> NewWithoutDestructor()
+  static constexpr const FramePropertyDescriptor<T> NewWithoutDestructor()
   {
     return { nullptr, nullptr };
   }
 
 private:
-  MOZ_CONSTEXPR FramePropertyDescriptor(
+  constexpr FramePropertyDescriptor(
     UntypedDestructor* aDtor, UntypedDestructorWithFrame* aDtorWithFrame)
     : FramePropertyDescriptorUntyped(aDtor, aDtorWithFrame)
   {}
 
   template<Destructor Dtor>
   static void Destruct(void* aPropertyValue)
   {
     Dtor(static_cast<T*>(aPropertyValue));
--- a/layout/base/nsChangeHint.h
+++ b/layout/base/nsChangeHint.h
@@ -227,45 +227,45 @@ inline void operator>=(nsChangeHint s1, 
 inline bool NS_IsHintSubset(nsChangeHint aSubset, nsChangeHint aSuperSet) {
   return (aSubset & aSuperSet) == aSubset;
 }
 
 // The functions below need an integral type to cast to to avoid
 // infinite recursion.
 typedef decltype(nsChangeHint(0) + nsChangeHint(0)) nsChangeHint_size_t;
 
-inline nsChangeHint MOZ_CONSTEXPR
+inline nsChangeHint constexpr
 operator|(nsChangeHint aLeft, nsChangeHint aRight)
 {
   return nsChangeHint(nsChangeHint_size_t(aLeft) | nsChangeHint_size_t(aRight));
 }
 
-inline nsChangeHint MOZ_CONSTEXPR
+inline nsChangeHint constexpr
 operator&(nsChangeHint aLeft, nsChangeHint aRight)
 {
   return nsChangeHint(nsChangeHint_size_t(aLeft) & nsChangeHint_size_t(aRight));
 }
 
 inline nsChangeHint& operator|=(nsChangeHint& aLeft, nsChangeHint aRight)
 {
   return aLeft = aLeft | aRight;
 }
 
 inline nsChangeHint& operator&=(nsChangeHint& aLeft, nsChangeHint aRight)
 {
   return aLeft = aLeft & aRight;
 }
 
-inline nsChangeHint MOZ_CONSTEXPR
+inline nsChangeHint constexpr
 operator~(nsChangeHint aArg)
 {
   return nsChangeHint(~nsChangeHint_size_t(aArg));
 }
 
-inline nsChangeHint MOZ_CONSTEXPR
+inline nsChangeHint constexpr
 operator^(nsChangeHint aLeft, nsChangeHint aRight)
 {
   return nsChangeHint(nsChangeHint_size_t(aLeft) ^ nsChangeHint_size_t(aRight));
 }
 
 inline nsChangeHint operator^=(nsChangeHint& aLeft, nsChangeHint aRight)
 {
   return aLeft = aLeft ^ aRight;
@@ -459,46 +459,46 @@ enum nsRestyleHint {
                                     eRestyle_SVGAttrAnimations |
                                     eRestyle_StyleAttribute_Animations,
 };
 
 // The functions below need an integral type to cast to to avoid
 // infinite recursion.
 typedef decltype(nsRestyleHint(0) + nsRestyleHint(0)) nsRestyleHint_size_t;
 
-inline MOZ_CONSTEXPR nsRestyleHint operator|(nsRestyleHint aLeft,
+inline constexpr nsRestyleHint operator|(nsRestyleHint aLeft,
                                              nsRestyleHint aRight)
 {
   return nsRestyleHint(nsRestyleHint_size_t(aLeft) |
                        nsRestyleHint_size_t(aRight));
 }
 
-inline MOZ_CONSTEXPR nsRestyleHint operator&(nsRestyleHint aLeft,
+inline constexpr nsRestyleHint operator&(nsRestyleHint aLeft,
                                              nsRestyleHint aRight)
 {
   return nsRestyleHint(nsRestyleHint_size_t(aLeft) &
                        nsRestyleHint_size_t(aRight));
 }
 
 inline nsRestyleHint& operator|=(nsRestyleHint& aLeft, nsRestyleHint aRight)
 {
   return aLeft = aLeft | aRight;
 }
 
 inline nsRestyleHint& operator&=(nsRestyleHint& aLeft, nsRestyleHint aRight)
 {
   return aLeft = aLeft & aRight;
 }
 
-inline MOZ_CONSTEXPR nsRestyleHint operator~(nsRestyleHint aArg)
+inline constexpr nsRestyleHint operator~(nsRestyleHint aArg)
 {
   return nsRestyleHint(~nsRestyleHint_size_t(aArg));
 }
 
-inline MOZ_CONSTEXPR nsRestyleHint operator^(nsRestyleHint aLeft,
+inline constexpr nsRestyleHint operator^(nsRestyleHint aLeft,
                                              nsRestyleHint aRight)
 {
   return nsRestyleHint(nsRestyleHint_size_t(aLeft) ^
                        nsRestyleHint_size_t(aRight));
 }
 
 inline nsRestyleHint operator^=(nsRestyleHint& aLeft, nsRestyleHint aRight)
 {
--- a/layout/generic/JustificationUtils.h
+++ b/layout/generic/JustificationUtils.h
@@ -41,17 +41,17 @@ struct JustificationInfo
 {
   // Number of expansion opportunities inside a span. It doesn't include
   // any opportunities between this span and the one before or after.
   int32_t mInnerOpportunities;
   // The justifiability of the start and end sides of the span.
   bool mIsStartJustifiable;
   bool mIsEndJustifiable;
 
-  MOZ_CONSTEXPR JustificationInfo()
+  constexpr JustificationInfo()
     : mInnerOpportunities(0)
     , mIsStartJustifiable(false)
     , mIsEndJustifiable(false)
   {
   }
 
   // Claim that the last opportunity should be cancelled
   // because the trailing space just gets trimmed.
@@ -71,17 +71,17 @@ struct JustificationInfo
 };
 
 struct JustificationAssignment
 {
   // There are at most 2 gaps per end, so it is enough to use 2 bits.
   uint8_t mGapsAtStart : 2;
   uint8_t mGapsAtEnd : 2;
 
-  MOZ_CONSTEXPR JustificationAssignment()
+  constexpr JustificationAssignment()
     : mGapsAtStart(0)
     , mGapsAtEnd(0)
   {
   }
 
   int32_t TotalGaps() const { return mGapsAtStart + mGapsAtEnd; }
 };
 
--- a/layout/generic/nsIFrame.h
+++ b/layout/generic/nsIFrame.h
@@ -858,34 +858,34 @@ public:
   
   nsPoint GetPositionIgnoringScrolling();
 
   typedef AutoTArray<nsIContent*, 2> ContentArray;
   static void DestroyContentArray(ContentArray* aArray);
 
 #define NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, dtor)             \
   static const mozilla::FramePropertyDescriptor<type>* prop() {           \
-    /* Use of MOZ_CONSTEXPR caused startup crashes with MSVC2015u1 PGO. */\
+    /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */    \
     static const auto descriptor =                                        \
       mozilla::FramePropertyDescriptor<type>::NewWithDestructor<dtor>();  \
     return &descriptor;                                                   \
   }
 
 // Don't use this unless you really know what you're doing!
 #define NS_DECLARE_FRAME_PROPERTY_WITH_FRAME_IN_DTOR(prop, type, dtor)    \
   static const mozilla::FramePropertyDescriptor<type>* prop() {           \
-    /* Use of MOZ_CONSTEXPR caused startup crashes with MSVC2015u1 PGO. */\
+    /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */    \
     static const auto descriptor = mozilla::                              \
       FramePropertyDescriptor<type>::NewWithDestructorWithFrame<dtor>();  \
     return &descriptor;                                                   \
   }
 
 #define NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(prop, type)                \
   static const mozilla::FramePropertyDescriptor<type>* prop() {           \
-    /* Use of MOZ_CONSTEXPR caused startup crashes with MSVC2015u1 PGO. */\
+    /* Use of constexpr caused startup crashes with MSVC2015u1 PGO. */    \
     static const auto descriptor =                                        \
       mozilla::FramePropertyDescriptor<type>::NewWithoutDestructor();     \
     return &descriptor;                                                   \
   }
 
 #define NS_DECLARE_FRAME_PROPERTY_DELETABLE(prop, type) \
   NS_DECLARE_FRAME_PROPERTY_WITH_DTOR(prop, type, DeleteValue)
 
--- a/layout/style/CounterStyleManager.cpp
+++ b/layout/style/CounterStyleManager.cpp
@@ -573,23 +573,23 @@ SystemUsesNegativeSign(uint8_t aSystem)
 }
 
 class BuiltinCounterStyle : public CounterStyle
 {
 public:
   friend class CounterStyleManager;
 
   // will be initialized by CounterStyleManager::InitializeBuiltinCounterStyles
-  MOZ_CONSTEXPR BuiltinCounterStyle()
+  constexpr BuiltinCounterStyle()
     : CounterStyle(NS_STYLE_LIST_STYLE_NONE)
   {
   }
 
 protected:
-  MOZ_CONSTEXPR explicit BuiltinCounterStyle(int32_t aStyle)
+  constexpr explicit BuiltinCounterStyle(int32_t aStyle)
     : CounterStyle(aStyle)
   {
   }
 
 public:
   virtual void GetStyleName(nsSubstring& aResult) override;
   virtual void GetPrefix(nsSubstring& aResult) override;
   virtual void GetSuffix(nsSubstring& aResult) override;
--- a/layout/style/CounterStyleManager.h
+++ b/layout/style/CounterStyleManager.h
@@ -28,17 +28,17 @@ class CounterStyleManager;
 class AnonymousCounterStyle;
 
 struct NegativeType;
 struct PadType;
 
 class CounterStyle
 {
 protected:
-  explicit MOZ_CONSTEXPR CounterStyle(int32_t aStyle)
+  explicit constexpr CounterStyle(int32_t aStyle)
     : mStyle(aStyle)
   {
   }
 
 private:
   CounterStyle(const CounterStyle& aOther) = delete;
   void operator=(const CounterStyle& other) = delete;
 
--- a/layout/style/nsCSSParser.cpp
+++ b/layout/style/nsCSSParser.cpp
@@ -15089,21 +15089,21 @@ CSSParserImpl::ParseTextDecoration()
     AppendValue(kTextDecorationIDs[index], values[index]);
   }
   return true;
 }
 
 bool
 CSSParserImpl::ParseTextEmphasis()
 {
-  static MOZ_CONSTEXPR_VAR nsCSSProperty kTextEmphasisIDs[] = {
+  static constexpr nsCSSProperty kTextEmphasisIDs[] = {
     eCSSProperty_text_emphasis_style,
     eCSSProperty_text_emphasis_color
   };
-  MOZ_CONSTEXPR_VAR int32_t numProps = MOZ_ARRAY_LENGTH(kTextEmphasisIDs);
+  constexpr int32_t numProps = MOZ_ARRAY_LENGTH(kTextEmphasisIDs);
   nsCSSValue values[numProps];
 
   int32_t found = ParseChoice(values, kTextEmphasisIDs, numProps);
   if (found < 1) {
     return false;
   }
 
   if (!(found & 1)) { // Provide default text-emphasis-style
--- a/layout/style/nsRuleNode.cpp
+++ b/layout/style/nsRuleNode.cpp
@@ -4261,17 +4261,17 @@ struct TextEmphasisChars
 #define TEXT_EMPHASIS_CHARS_LIST() \
   TEXT_EMPHASIS_CHARS_ITEM("", "", NONE) \
   TEXT_EMPHASIS_CHARS_ITEM("\u2022", "\u25e6", DOT) \
   TEXT_EMPHASIS_CHARS_ITEM("\u25cf", "\u25cb", CIRCLE) \
   TEXT_EMPHASIS_CHARS_ITEM("\u25c9", "\u25ce", DOUBLE_CIRCLE) \
   TEXT_EMPHASIS_CHARS_ITEM("\u25b2", "\u25b3", TRIANGLE) \
   TEXT_EMPHASIS_CHARS_ITEM("\ufe45", "\ufe46", SESAME)
 
-static MOZ_CONSTEXPR_VAR TextEmphasisChars kTextEmphasisChars[] =
+static constexpr TextEmphasisChars kTextEmphasisChars[] =
 {
 #define TEXT_EMPHASIS_CHARS_ITEM(filled_, open_, type_) \
   { MOZ_UTF16(filled_), MOZ_UTF16(open_) }, // type_
   TEXT_EMPHASIS_CHARS_LIST()
 #undef TEXT_EMPHASIS_CHARS_ITEM
 };
 
 // MSVC before 2015 doesn't consider string literal as a constant expr,
--- a/mfbt/ArrayUtils.h
+++ b/mfbt/ArrayUtils.h
@@ -47,57 +47,57 @@ PointerRangeSize(T* aBegin, T* aEnd)
 
 /*
  * Compute the length of an array with constant length.  (Use of this method
  * with a non-array pointer will not compile.)
  *
  * Beware of the implicit trailing '\0' when using this with string constants.
  */
 template<typename T, size_t N>
-MOZ_CONSTEXPR size_t
+constexpr size_t
 ArrayLength(T (&aArr)[N])
 {
   return N;
 }
 
 template<typename T, size_t N>
-MOZ_CONSTEXPR size_t
+constexpr size_t
 ArrayLength(const Array<T, N>& aArr)
 {
   return N;
 }
 
 template<typename E, E N, typename T>
-MOZ_CONSTEXPR size_t
+constexpr size_t
 ArrayLength(const EnumeratedArray<E, N, T>& aArr)
 {
   return size_t(N);
 }
 
 /*
  * Compute the address one past the last element of a constant-length array.
  *
  * Beware of the implicit trailing '\0' when using this with string constants.
  */
 template<typename T, size_t N>
-MOZ_CONSTEXPR T*
+constexpr T*
 ArrayEnd(T (&aArr)[N])
 {
   return aArr + ArrayLength(aArr);
 }
 
 template<typename T, size_t N>
-MOZ_CONSTEXPR T*
+constexpr T*
 ArrayEnd(Array<T, N>& aArr)
 {
   return &aArr[0] + ArrayLength(aArr);
 }
 
 template<typename T, size_t N>
-MOZ_CONSTEXPR const T*
+constexpr const T*
 ArrayEnd(const Array<T, N>& aArr)
 {
   return &aArr[0] + ArrayLength(aArr);
 }
 
 namespace detail {
 
 template<typename AlignType, typename Pointee,
--- a/mfbt/Atomics.h
+++ b/mfbt/Atomics.h
@@ -318,17 +318,17 @@ template<typename T, MemoryOrdering Orde
 struct AtomicIntrinsics<T*, Order>
   : public IntrinsicMemoryOps<T*, Order>, public IntrinsicIncDec<T*, Order>
 {
 };
 
 template<typename T>
 struct ToStorageTypeArgument
 {
-  static MOZ_CONSTEXPR T convert (T aT) { return aT; }
+  static constexpr T convert (T aT) { return aT; }
 };
 
 } // namespace detail
 } // namespace mozilla
 
 #elif defined(__GNUC__)
 
 namespace mozilla {
@@ -509,23 +509,23 @@ struct AtomicIntrinsics<T*, Order> : pub
 {
 };
 
 template<typename T, bool TIsEnum = IsEnum<T>::value>
 struct ToStorageTypeArgument
 {
   typedef typename AtomicStorageType<T>::Type ResultType;
 
-  static MOZ_CONSTEXPR ResultType convert (T aT) { return ResultType(aT); }
+  static constexpr ResultType convert (T aT) { return ResultType(aT); }
 };
 
 template<typename T>
 struct ToStorageTypeArgument<T, false>
 {
-  static MOZ_CONSTEXPR T convert (T aT) { return aT; }
+  static constexpr T convert (T aT) { return aT; }
 };
 
 } // namespace detail
 } // namespace mozilla
 
 #else
 # error "Atomic compiler intrinsics are not supported on your platform"
 #endif
@@ -541,18 +541,18 @@ class AtomicBase
                 "mozilla/Atomics.h only supports 32-bit and 64-bit types");
 
 protected:
   typedef typename detail::AtomicIntrinsics<T, Order> Intrinsics;
   typedef typename Intrinsics::ValueType ValueType;
   ValueType mValue;
 
 public:
-  MOZ_CONSTEXPR AtomicBase() : mValue() {}
-  explicit MOZ_CONSTEXPR AtomicBase(T aInit)
+  constexpr AtomicBase() : mValue() {}
+  explicit constexpr AtomicBase(T aInit)
     : mValue(ToStorageTypeArgument<T>::convert(aInit))
   {}
 
   // Note: we can't provide operator T() here because Atomic<bool> inherits
   // from AtomcBase with T=uint32_t and not T=bool. If we implemented
   // operator T() here, it would cause errors when comparing Atomic<bool> with
   // a regular bool.
 
@@ -593,18 +593,18 @@ private:
 };
 
 template<typename T, MemoryOrdering Order>
 class AtomicBaseIncDec : public AtomicBase<T, Order>
 {
   typedef typename detail::AtomicBase<T, Order> Base;
 
 public:
-  MOZ_CONSTEXPR AtomicBaseIncDec() : Base() {}
-  explicit MOZ_CONSTEXPR AtomicBaseIncDec(T aInit) : Base(aInit) {}
+  constexpr AtomicBaseIncDec() : Base() {}
+  explicit constexpr AtomicBaseIncDec(T aInit) : Base(aInit) {}
 
   using Base::operator=;
 
   operator T() const { return Base::Intrinsics::load(Base::mValue); }
   T operator++(int) { return Base::Intrinsics::inc(Base::mValue); }
   T operator--(int) { return Base::Intrinsics::dec(Base::mValue); }
   T operator++() { return Base::Intrinsics::inc(Base::mValue) + 1; }
   T operator--() { return Base::Intrinsics::dec(Base::mValue) - 1; }
@@ -649,18 +649,18 @@ class Atomic;
 template<typename T, MemoryOrdering Order>
 class Atomic<T, Order, typename EnableIf<IsIntegral<T>::value &&
                        !IsSame<T, bool>::value>::Type>
   : public detail::AtomicBaseIncDec<T, Order>
 {
   typedef typename detail::AtomicBaseIncDec<T, Order> Base;
 
 public:
-  MOZ_CONSTEXPR Atomic() : Base() {}
-  explicit MOZ_CONSTEXPR Atomic(T aInit) : Base(aInit) {}
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(T aInit) : Base(aInit) {}
 
   using Base::operator=;
 
   T operator+=(T aDelta)
   {
     return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
   }
 
@@ -697,18 +697,18 @@ private:
  * exchange()) is included as well.
  */
 template<typename T, MemoryOrdering Order>
 class Atomic<T*, Order> : public detail::AtomicBaseIncDec<T*, Order>
 {
   typedef typename detail::AtomicBaseIncDec<T*, Order> Base;
 
 public:
-  MOZ_CONSTEXPR Atomic() : Base() {}
-  explicit MOZ_CONSTEXPR Atomic(T* aInit) : Base(aInit) {}
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(T* aInit) : Base(aInit) {}
 
   using Base::operator=;
 
   T* operator+=(ptrdiff_t aDelta)
   {
     return Base::Intrinsics::add(Base::mValue, aDelta) + aDelta;
   }
 
@@ -728,18 +728,18 @@ private:
  */
 template<typename T, MemoryOrdering Order>
 class Atomic<T, Order, typename EnableIf<IsEnum<T>::value>::Type>
   : public detail::AtomicBase<T, Order>
 {
   typedef typename detail::AtomicBase<T, Order> Base;
 
 public:
-  MOZ_CONSTEXPR Atomic() : Base() {}
-  explicit MOZ_CONSTEXPR Atomic(T aInit) : Base(aInit) {}
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(T aInit) : Base(aInit) {}
 
   operator T() const { return T(Base::Intrinsics::load(Base::mValue)); }
 
   using Base::operator=;
 
 private:
   Atomic(Atomic<T, Order>& aOther) = delete;
 };
@@ -762,18 +762,18 @@ private:
  */
 template<MemoryOrdering Order>
 class Atomic<bool, Order>
   : protected detail::AtomicBase<uint32_t, Order>
 {
   typedef typename detail::AtomicBase<uint32_t, Order> Base;
 
 public:
-  MOZ_CONSTEXPR Atomic() : Base() {}
-  explicit MOZ_CONSTEXPR Atomic(bool aInit) : Base(aInit) {}
+  constexpr Atomic() : Base() {}
+  explicit constexpr Atomic(bool aInit) : Base(aInit) {}
 
   // We provide boolean wrappers for the underlying AtomicBase methods.
   MOZ_IMPLICIT operator bool() const
   {
     return Base::Intrinsics::load(Base::mValue);
   }
 
   bool operator=(bool aVal)
--- a/mfbt/Attributes.h
+++ b/mfbt/Attributes.h
@@ -48,18 +48,16 @@
  *
  * Even though some versions of MSVC support explicit conversion operators, we
  * don't indicate support for them here, due to
  * http://stackoverflow.com/questions/20498142/visual-studio-2013-explicit-keyword-bug
  */
 #  define MOZ_HAVE_NEVER_INLINE          __declspec(noinline)
 #  define MOZ_HAVE_NORETURN              __declspec(noreturn)
 #  if _MSC_VER >= 1900
-#    define MOZ_HAVE_CXX11_CONSTEXPR
-#    define MOZ_HAVE_CXX11_CONSTEXPR_IN_TEMPLATES
 #    define MOZ_HAVE_EXPLICIT_CONVERSION
 #  endif
 #  ifdef __clang__
      /* clang-cl probably supports explicit conversions. */
 #    if __has_extension(cxx_explicit_conversions)
 #      define MOZ_HAVE_EXPLICIT_CONVERSION
 #    endif
 #  endif
@@ -67,32 +65,27 @@
    /*
     * Per Clang documentation, "Note that marketing version numbers should not
     * be used to check for language features, as different vendors use different
     * numbering schemes. Instead, use the feature checking macros."
     */
 #  ifndef __has_extension
 #    define __has_extension __has_feature /* compatibility, for older versions of clang */
 #  endif
-#  if __has_extension(cxx_constexpr)
-#    define MOZ_HAVE_CXX11_CONSTEXPR
-#  endif
 #  if __has_extension(cxx_explicit_conversions)
 #    define MOZ_HAVE_EXPLICIT_CONVERSION
 #  endif
 #  if __has_attribute(noinline)
 #    define MOZ_HAVE_NEVER_INLINE        __attribute__((noinline))
 #  endif
 #  if __has_attribute(noreturn)
 #    define MOZ_HAVE_NORETURN            __attribute__((noreturn))
 #  endif
 #elif defined(__GNUC__)
 #  if defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L
-#    define MOZ_HAVE_CXX11_CONSTEXPR
-#    define MOZ_HAVE_CXX11_CONSTEXPR_IN_TEMPLATES
 #    define MOZ_HAVE_EXPLICIT_CONVERSION
 #  endif
 #  define MOZ_HAVE_NEVER_INLINE          __attribute__((noinline))
 #  define MOZ_HAVE_NORETURN              __attribute__((noreturn))
 #endif
 
 /*
  * When built with clang analyzer (a.k.a scan-build), define MOZ_HAVE_NORETURN
@@ -100,40 +93,16 @@
  */
 #ifdef __clang_analyzer__
 #  if __has_extension(attribute_analyzer_noreturn)
 #    define MOZ_HAVE_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
 #  endif
 #endif
 
 /*
- * The MOZ_CONSTEXPR specifier declares that a C++11 compiler can evaluate a
- * function at compile time. A constexpr function cannot examine any values
- * except its arguments and can have no side effects except its return value.
- * The MOZ_CONSTEXPR_VAR specifier tells a C++11 compiler that a variable's
- * value may be computed at compile time.  It should be prefered to just
- * marking variables as MOZ_CONSTEXPR because if the compiler does not support
- * constexpr it will fall back to making the variable const, and some compilers
- * do not accept variables being marked both const and constexpr.
- */
-#ifdef MOZ_HAVE_CXX11_CONSTEXPR
-#  define MOZ_CONSTEXPR         constexpr
-#  define MOZ_CONSTEXPR_VAR     constexpr
-#  ifdef MOZ_HAVE_CXX11_CONSTEXPR_IN_TEMPLATES
-#    define MOZ_CONSTEXPR_TMPL  constexpr
-#  else
-#    define MOZ_CONSTEXPR_TMPL
-#  endif
-#else
-#  define MOZ_CONSTEXPR         /* no support */
-#  define MOZ_CONSTEXPR_VAR     const
-#  define MOZ_CONSTEXPR_TMPL
-#endif
-
-/*
  * MOZ_EXPLICIT_CONVERSION is a specifier on a type conversion
  * overloaded operator that declares that a C++11 compiler should restrict
  * this operator to allow only explicit type conversions, disallowing
  * implicit conversions.
  *
  * Example:
  *
  *   template<typename T>
--- a/mfbt/FloatingPoint.h
+++ b/mfbt/FloatingPoint.h
@@ -112,17 +112,17 @@ struct FloatingPoint : public SelectTrai
    * these algorithms that preceded this header, so we shouldn't break anything
    * if we keep doing so.
    */
   static_assert(sizeof(T) == sizeof(Bits), "Bits must be same size as T");
 };
 
 /** Determines whether a float/double is NaN. */
 template<typename T>
-static MOZ_ALWAYS_INLINE MOZ_CONSTEXPR bool
+static MOZ_ALWAYS_INLINE constexpr bool
 IsNaN(T aValue)
 {
   /*
    * A float/double is NaN if all exponent bits are 1 and the significand
    * contains at least one non-zero bit.
    */
   typedef FloatingPoint<T> Traits;
   typedef typename Traits::Bits Bits;
--- a/mfbt/IndexSequence.h
+++ b/mfbt/IndexSequence.h
@@ -69,17 +69,17 @@
 namespace mozilla {
 
 /**
  * Represents a compile-time sequence of integer indices.
  */
 template<size_t... Indices>
 struct IndexSequence
 {
-  static MOZ_CONSTEXPR size_t Size() { return sizeof...(Indices); }
+  static constexpr size_t Size() { return sizeof...(Indices); }
 };
 
 namespace detail {
 
 // Helpers used by MakeIndexSequence.
 
 template<size_t... Indices>
 struct IndexTuple
--- a/mfbt/InitializerList.h
+++ b/mfbt/InitializerList.h
@@ -40,17 +40,17 @@ class initializer_list
     size_t   mSize;
 
     /* This constructor is called directly by the compiler */
     initializer_list(const T* aBegin, size_t aSize)
       : mBegin(aBegin)
       , mSize(aSize) { }
 public:
 
-    MOZ_CONSTEXPR initializer_list() : mBegin(nullptr), mSize(0) {}
+    constexpr initializer_list() : mBegin(nullptr), mSize(0) {}
 
     typedef T value_type;
     typedef const T& reference;
     typedef const T& const_reference;
     typedef size_t size_type;
     typedef const T* iterator;
     typedef const T* const_iterator;
 
--- a/mfbt/SplayTree.h
+++ b/mfbt/SplayTree.h
@@ -51,17 +51,17 @@ private:
  * method must be free from side effects.
  */
 template<typename T, class Comparator>
 class SplayTree
 {
   T* mRoot;
 
 public:
-  MOZ_CONSTEXPR SplayTree()
+  constexpr SplayTree()
     : mRoot(nullptr)
   {}
 
   bool empty() const
   {
     return !mRoot;
   }
 
--- a/mfbt/TypedEnumBits.h
+++ b/mfbt/TypedEnumBits.h
@@ -42,60 +42,60 @@ namespace mozilla {
  */
 template<typename E>
 class CastableTypedEnumResult
 {
 private:
   const E mValue;
 
 public:
-  explicit MOZ_CONSTEXPR CastableTypedEnumResult(E aValue)
+  explicit constexpr CastableTypedEnumResult(E aValue)
     : mValue(aValue)
   {}
 
-  MOZ_CONSTEXPR operator E() const { return mValue; }
+  constexpr operator E() const { return mValue; }
 
   template<typename DestinationType>
-  MOZ_EXPLICIT_CONVERSION MOZ_CONSTEXPR
+  MOZ_EXPLICIT_CONVERSION constexpr
   operator DestinationType() const { return DestinationType(mValue); }
 
-  MOZ_CONSTEXPR bool operator !() const { return !bool(mValue); }
+  constexpr bool operator !() const { return !bool(mValue); }
 };
 
 #define MOZ_CASTABLETYPEDENUMRESULT_BINOP(Op, OtherType, ReturnType) \
 template<typename E> \
-MOZ_CONSTEXPR ReturnType \
+constexpr ReturnType \
 operator Op(const OtherType& aE, const CastableTypedEnumResult<E>& aR) \
 { \
   return ReturnType(aE Op OtherType(aR)); \
 } \
 template<typename E> \
-MOZ_CONSTEXPR ReturnType \
+constexpr ReturnType \
 operator Op(const CastableTypedEnumResult<E>& aR, const OtherType& aE) \
 { \
   return ReturnType(OtherType(aR) Op aE); \
 } \
 template<typename E> \
-MOZ_CONSTEXPR ReturnType \
+constexpr ReturnType \
 operator Op(const CastableTypedEnumResult<E>& aR1, \
             const CastableTypedEnumResult<E>& aR2) \
 { \
   return ReturnType(OtherType(aR1) Op OtherType(aR2)); \
 }
 
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(|, E, CastableTypedEnumResult<E>)
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(&, E, CastableTypedEnumResult<E>)
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(^, E, CastableTypedEnumResult<E>)
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(==, E, bool)
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(!=, E, bool)
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(||, bool, bool)
 MOZ_CASTABLETYPEDENUMRESULT_BINOP(&&, bool, bool)
 
 template <typename E>
-MOZ_CONSTEXPR CastableTypedEnumResult<E>
+constexpr CastableTypedEnumResult<E>
 operator ~(const CastableTypedEnumResult<E>& aR)
 {
   return CastableTypedEnumResult<E>(~(E(aR)));
 }
 
 #define MOZ_CASTABLETYPEDENUMRESULT_COMPOUND_ASSIGN_OP(Op) \
 template<typename E> \
 E& \
@@ -118,17 +118,17 @@ template<typename E>
 struct UnsignedIntegerTypeForEnum
   : UnsignedStdintTypeForSize<sizeof(E)>
 {};
 } // namespace detail
 
 } // namespace mozilla
 
 #define MOZ_MAKE_ENUM_CLASS_BINOP_IMPL(Name, Op) \
-   inline MOZ_CONSTEXPR mozilla::CastableTypedEnumResult<Name> \
+   inline constexpr mozilla::CastableTypedEnumResult<Name> \
    operator Op(Name a, Name b) \
    { \
      typedef mozilla::CastableTypedEnumResult<Name> Result; \
      typedef mozilla::detail::UnsignedIntegerTypeForEnum<Name>::Type U; \
      return Result(Name(U(a) Op U(b))); \
    } \
  \
    inline Name& \
@@ -140,17 +140,17 @@ struct UnsignedIntegerTypeForEnum
 /**
  * MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS generates standard bitwise operators
  * for the given enum type. Use this to enable using an enum type as bit-field.
  */
 #define MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(Name) \
    MOZ_MAKE_ENUM_CLASS_BINOP_IMPL(Name, |) \
    MOZ_MAKE_ENUM_CLASS_BINOP_IMPL(Name, &) \
    MOZ_MAKE_ENUM_CLASS_BINOP_IMPL(Name, ^) \
-   inline MOZ_CONSTEXPR mozilla::CastableTypedEnumResult<Name> \
+   inline constexpr mozilla::CastableTypedEnumResult<Name> \
    operator~(Name a) \
    { \
      typedef mozilla::CastableTypedEnumResult<Name> Result; \
      typedef mozilla::detail::UnsignedIntegerTypeForEnum<Name>::Type U; \
      return Result(Name(~(U(a)))); \
    }
 
 #endif // mozilla_TypedEnumBits_h
--- a/mfbt/UniquePtr.h
+++ b/mfbt/UniquePtr.h
@@ -200,17 +200,17 @@ private:
 
   DeleterType& del() { return mTuple.second(); }
   const DeleterType& del() const { return mTuple.second(); }
 
 public:
   /**
    * Construct a UniquePtr containing |nullptr|.
    */
-  MOZ_CONSTEXPR UniquePtr()
+  constexpr UniquePtr()
     : mTuple(static_cast<Pointer>(nullptr), DeleterType())
   {
     static_assert(!IsPointer<D>::value, "must provide a deleter instance");
     static_assert(!IsReference<D>::value, "must provide a deleter instance");
   }
 
   /**
    * Construct a UniquePtr containing |aPtr|.
@@ -367,17 +367,17 @@ public:
 
 private:
   Pair<Pointer, DeleterType> mTuple;
 
 public:
   /**
    * Construct a UniquePtr containing nullptr.
    */
-  MOZ_CONSTEXPR UniquePtr()
+  constexpr UniquePtr()
     : mTuple(static_cast<Pointer>(nullptr), DeleterType())
   {
     static_assert(!IsPointer<D>::value, "must provide a deleter instance");
     static_assert(!IsReference<D>::value, "must provide a deleter instance");
   }
 
   /**
    * Construct a UniquePtr containing |aPtr|.
@@ -509,17 +509,17 @@ public:
  * This is a non-issue for types which are always incomplete (i.e. opaque handle
  * types), since |delete|-ing such a type will always trigger a compilation
  * error.
  */
 template<typename T>
 class DefaultDelete
 {
 public:
-  MOZ_CONSTEXPR DefaultDelete() {}
+  constexpr DefaultDelete() {}
 
   template<typename U>
   MOZ_IMPLICIT DefaultDelete(const DefaultDelete<U>& aOther,
                              typename EnableIf<mozilla::IsConvertible<U*, T*>::value,
                                                int>::Type aDummy = 0)
   {}
 
   void operator()(T* aPtr) const
@@ -529,17 +529,17 @@ public:
   }
 };
 
 /** A default deletion policy using operator delete[]. */
 template<typename T>
 class DefaultDelete<T[]>
 {
 public:
-  MOZ_CONSTEXPR DefaultDelete() {}
+  constexpr DefaultDelete() {}
 
   void operator()(T* aPtr) const
   {
     static_assert(sizeof(T) > 0, "T must be complete");
     delete[] aPtr;
   }
 
   template<typename U>
--- a/mfbt/XorShift128PlusRNG.h
+++ b/mfbt/XorShift128PlusRNG.h
@@ -85,17 +85,17 @@ class XorShift128PlusRNG {
   double nextDouble() {
     /*
      * Because the IEEE 64-bit floating point format stores the leading '1' bit
      * of the mantissa implicitly, it effectively represents a mantissa in the
      * range [0, 2**53) in only 52 bits. FloatingPoint<double>::kExponentShift
      * is the width of the bitfield in the in-memory format, so we must add one
      * to get the mantissa's range.
      */
-    static MOZ_CONSTEXPR_VAR int kMantissaBits =
+    static constexpr int kMantissaBits =
       mozilla::FloatingPoint<double>::kExponentShift + 1;
     uint64_t mantissa = next() & ((UINT64_C(1) << kMantissaBits) - 1);
     return double(mantissa) / (UINT64_C(1) << kMantissaBits);
   }
 
   /*
    * Set the stream's current state to |aState0| and |aState1|. These must not
    * both be zero; ideally, they should have an almost even mix of zero and one
--- a/mozglue/misc/TimeStamp.h
+++ b/mozglue/misc/TimeStamp.h
@@ -57,17 +57,17 @@ public:
  * The ValueCalculator template parameter determines how arithmetic
  * operations are performed on the integer count of ticks (mValue).
  */
 template <typename ValueCalculator>
 class BaseTimeDuration
 {
 public:
   // The default duration is 0.
-  MOZ_CONSTEXPR BaseTimeDuration() : mValue(0) {}
+  constexpr BaseTimeDuration() : mValue(0) {}
   // Allow construction using '0' as the initial value, for readability,
   // but no other numbers (so we don't have any implicit unit conversions).
   struct _SomethingVeryRandomHere;
   MOZ_IMPLICIT BaseTimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0)
   {
     MOZ_ASSERT(!aZero, "Who's playing funny games here?");
   }
   // Default copy-constructor and assignment are OK
@@ -390,17 +390,17 @@ typedef BaseTimeDuration<TimeDurationVal
  * t.IsNull() is equivalent to t.time_since_epoch() == decltype(t)::duration::zero();
  */
 class TimeStamp
 {
 public:
   /**
    * Initialize to the "null" moment
    */
-  MOZ_CONSTEXPR TimeStamp() : mValue(0) {}
+  constexpr TimeStamp() : mValue(0) {}
   // Default copy-constructor and assignment are OK
 
   /**
    * The system timestamps are the same as the TimeStamp
    * retrieved by mozilla::TimeStamp. Since we need this for
    * vsync timestamps, we enable the creation of mozilla::TimeStamps
    * on platforms that support vsync aligned refresh drivers / compositors
    * Verified true as of Jan 31, 2015: B2G and OS X
--- a/mozglue/misc/TimeStamp_windows.h
+++ b/mozglue/misc/TimeStamp_windows.h
@@ -25,17 +25,17 @@ class TimeStampValue
   bool mHasQPC;
   bool mIsNull;
 
   MFBT_API TimeStampValue(uint64_t aGTC, uint64_t aQPC, bool aHasQPC);
 
   MFBT_API uint64_t CheckQPC(const TimeStampValue& aOther) const;
 
   struct _SomethingVeryRandomHere;
-  MOZ_CONSTEXPR TimeStampValue(_SomethingVeryRandomHere* aNullValue)
+  constexpr TimeStampValue(_SomethingVeryRandomHere* aNullValue)
     : mGTC(0)
     , mQPC(0)
     , mHasQPC(false)
     , mIsNull(true)
   {
   }
 
 public:
--- a/storage/mozStorageAsyncStatement.cpp
+++ b/storage/mozStorageAsyncStatement.cpp
@@ -39,17 +39,17 @@ NS_IMPL_CI_INTERFACE_GETTER(AsyncStateme
                             mozIStorageAsyncStatement,
                             mozIStorageBaseStatement,
                             mozIStorageBindingParams,
                             mozilla::storage::StorageBaseStatementInternal)
 
 class AsyncStatementClassInfo : public nsIClassInfo
 {
 public:
-  MOZ_CONSTEXPR AsyncStatementClassInfo() {}
+  constexpr AsyncStatementClassInfo() {}
 
   NS_DECL_ISUPPORTS_INHERITED
 
   NS_IMETHODIMP
   GetInterfaces(uint32_t *_count, nsIID ***_array) override
   {
     return NS_CI_INTERFACE_GETTER_NAME(AsyncStatement)(_count, _array);
   }
--- a/storage/mozStorageStatement.cpp
+++ b/storage/mozStorageStatement.cpp
@@ -41,17 +41,17 @@ NS_IMPL_CI_INTERFACE_GETTER(Statement,
                             mozIStorageBaseStatement,
                             mozIStorageBindingParams,
                             mozIStorageValueArray,
                             mozilla::storage::StorageBaseStatementInternal)
 
 class StatementClassInfo : public nsIClassInfo
 {
 public:
-  MOZ_CONSTEXPR StatementClassInfo() {}
+  constexpr StatementClassInfo() {}
 
   NS_DECL_ISUPPORTS_INHERITED
 
   NS_IMETHODIMP
   GetInterfaces(uint32_t *_count, nsIID ***_array) override
   {
     return NS_CI_INTERFACE_GETTER_NAME(Statement)(_count, _array);
   }
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -2118,31 +2118,31 @@ TelemetryImpl::SanitizeSQL(const nsACStr
 // A whitelist mechanism to prevent Telemetry reporting on Addon & Thunderbird
 // DBs.
 struct TrackedDBEntry
 {
   const char* mName;
   const uint32_t mNameLength;
 
   // This struct isn't meant to be used beyond the static arrays below.
-  MOZ_CONSTEXPR
+  constexpr
   TrackedDBEntry(const char* aName, uint32_t aNameLength)
     : mName(aName)
     , mNameLength(aNameLength)
   { }
 
   TrackedDBEntry() = delete;
   TrackedDBEntry(TrackedDBEntry&) = delete;
 };
 
 #define TRACKEDDB_ENTRY(_name) { _name, (sizeof(_name) - 1) }
 
 // A whitelist of database names. If the database name exactly matches one of
 // these then its SQL statements will always be recorded.
-static MOZ_CONSTEXPR_VAR TrackedDBEntry kTrackedDBs[] = {
+static constexpr TrackedDBEntry kTrackedDBs[] = {
   // IndexedDB for about:home, see aboutHome.js
   TRACKEDDB_ENTRY("818200132aebmoouht.sqlite"),
   TRACKEDDB_ENTRY("addons.sqlite"),
   TRACKEDDB_ENTRY("content-prefs.sqlite"),
   TRACKEDDB_ENTRY("cookies.sqlite"),
   TRACKEDDB_ENTRY("downloads.sqlite"),
   TRACKEDDB_ENTRY("extensions.sqlite"),
   TRACKEDDB_ENTRY("formhistory.sqlite"),
--- a/toolkit/components/terminator/nsTerminator.cpp
+++ b/toolkit/components/terminator/nsTerminator.cpp
@@ -168,17 +168,17 @@ RunWatchdog(void* arg)
 // thread rather than usual XPCOM I/O simply because we outlive XPCOM and its
 // threads.
 //
 
 // Utility class, used by UniquePtr<> to close nspr files.
 class PR_CloseDelete
 {
 public:
-  MOZ_CONSTEXPR PR_CloseDelete() {}
+  constexpr PR_CloseDelete() {}
 
   PR_CloseDelete(const PR_CloseDelete& aOther)
   {}
 
   void operator()(PRFileDesc* aPtr) const
   {
     PR_Close(aPtr);
   }
@@ -303,17 +303,17 @@ void RunWriter(void* arg)
  * notification. The duration of a step is defined as the number of
  * ticks between the time we receive a notification and the next one.
  */
 struct ShutdownStep
 {
   char const* const mTopic;
   int mTicks;
 
-  MOZ_CONSTEXPR explicit ShutdownStep(const char *const topic)
+  constexpr explicit ShutdownStep(const char *const topic)
     : mTopic(topic)
     , mTicks(-1)
   {}
 
 };
 
 static ShutdownStep sShutdownSteps[] = {
   ShutdownStep("quit-application"),
--- a/toolkit/xre/nsAppRunner.cpp
+++ b/toolkit/xre/nsAppRunner.cpp
@@ -624,17 +624,17 @@ class nsXULAppInfo : public nsIXULAppInf
 #ifdef MOZ_CRASHREPORTER
                      public nsICrashReporter,
                      public nsIFinishDumpingCallback,
 #endif
                      public nsIXULRuntime
 
 {
 public:
-  MOZ_CONSTEXPR nsXULAppInfo() {}
+  constexpr nsXULAppInfo() {}
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_NSIPLATFORMINFO
   NS_DECL_NSIXULAPPINFO
   NS_DECL_NSIXULRUNTIME
   NS_DECL_NSIOBSERVER
 #ifdef MOZ_CRASHREPORTER
   NS_DECL_NSICRASHREPORTER
   NS_DECL_NSIFINISHDUMPINGCALLBACK
--- a/widget/android/AndroidGraphicBuffer.cpp
+++ b/widget/android/AndroidGraphicBuffer.cpp
@@ -83,17 +83,17 @@ typedef struct ARect {
     int32_t bottom;
 } ARect;
 
 static bool gTryRealloc = true;
 
 static class GLFunctions
 {
 public:
-  MOZ_CONSTEXPR GLFunctions() : fGetDisplay(nullptr),
+  constexpr GLFunctions() : fGetDisplay(nullptr),
                                 fEGLGetError(nullptr),
                                 fCreateImageKHR(nullptr),
                                 fDestroyImageKHR(nullptr),
                                 fImageTargetTexture2DOES(nullptr),
                                 fBindTexture(nullptr),
                                 fGLGetError(nullptr),
                                 fGraphicBufferCtor(nullptr),
                                 fGraphicBufferDtor(nullptr),
--- a/widget/gonk/hwchal/HwcHALBase.h
+++ b/widget/gonk/hwchal/HwcHALBase.h
@@ -118,17 +118,17 @@ public:
 
     // Enable HW Vsync
     virtual bool EnableVsync(bool aEnable) = 0;
 
     // Register HW event callback functions
     virtual bool RegisterHwcEventCallback(const HwcHALProcs_t &aProcs) = 0;
 
 protected:
-    MOZ_CONSTEXPR static uint32_t HwcAPIVersion(uint32_t aMaj, uint32_t aMin) {
+    constexpr static uint32_t HwcAPIVersion(uint32_t aMaj, uint32_t aMin) {
         // HARDWARE_MAKE_API_VERSION_2, from Android hardware.h
         return (((aMaj & 0xff) << 24) | ((aMin & 0xff) << 16) | (1 & 0xffff));
     }
 };
 
 } // namespace mozilla
 
 #endif // mozilla_HwcHALBase
--- a/xpcom/base/CycleCollectedJSRuntime.h
+++ b/xpcom/base/CycleCollectedJSRuntime.h
@@ -61,17 +61,17 @@ public:
     override;
 
   NS_DECL_CYCLE_COLLECTION_CLASS_NAME_METHOD(JSGCThingParticipant)
 };
 
 class JSZoneParticipant : public nsCycleCollectionParticipant
 {
 public:
-  MOZ_CONSTEXPR JSZoneParticipant(): nsCycleCollectionParticipant()
+  constexpr JSZoneParticipant(): nsCycleCollectionParticipant()
   {
   }
 
   NS_IMETHOD_(void) Root(void*) override
   {
     MOZ_ASSERT(false, "Don't call Root on GC things");
   }
 
--- a/xpcom/base/Logging.h
+++ b/xpcom/base/Logging.h
@@ -135,17 +135,17 @@ private:
  *
  *   void Foo() {
  *     MOZ_LOG(sLayoutLog, LogLevel::Verbose, ("Entering foo"));
  *   }
  */
 class LazyLogModule final
 {
 public:
-  explicit MOZ_CONSTEXPR LazyLogModule(const char* aLogName)
+  explicit constexpr LazyLogModule(const char* aLogName)
     : mLogName(aLogName)
     , mLog(nullptr)
   {
   }
 
   operator LogModule*()
   {
     // NB: The use of an atomic makes the reading and assignment of mLog
--- a/xpcom/base/nsError.h
+++ b/xpcom/base/nsError.h
@@ -188,22 +188,22 @@ static_assert(sizeof(nsresult) == sizeof
 extern nsresult
 NS_ErrorAccordingToNSPR();
 
 
 /**
  * @name Standard Macros for retrieving error bits
  */
 
-inline MOZ_CONSTEXPR uint16_t
+inline constexpr uint16_t
 NS_ERROR_GET_CODE(nsresult aErr)
 {
   return uint32_t(aErr) & 0xffff;
 }
-inline MOZ_CONSTEXPR uint16_t
+inline constexpr uint16_t
 NS_ERROR_GET_MODULE(nsresult aErr)
 {
   return ((uint32_t(aErr) >> 16) - NS_ERROR_MODULE_BASE_OFFSET) & 0x1fff;
 }
 inline bool
 NS_ERROR_GET_SEVERITY(nsresult aErr)
 {
   return uint32_t(aErr) >> 31;
--- a/xpcom/base/nsMemoryImpl.h
+++ b/xpcom/base/nsMemoryImpl.h
@@ -36,17 +36,17 @@ public:
                          const nsIID& aIID, void** aResult);
 
   nsresult FlushMemory(const char16_t* aReason, bool aImmediate);
   nsresult RunFlushers(const char16_t* aReason);
 
 protected:
   struct FlushEvent : public nsIRunnable
   {
-    MOZ_CONSTEXPR FlushEvent() : mReason(nullptr) {}
+    constexpr FlushEvent() : mReason(nullptr) {}
     NS_DECL_ISUPPORTS_INHERITED
     NS_DECL_NSIRUNNABLE
     const char16_t* mReason;
   };
 
   static mozilla::Atomic<bool> sIsFlushing;
   static FlushEvent sFlushEvent;
   static PRIntervalTime sLastFlushTime;
--- a/xpcom/glue/PLDHashTable.h
+++ b/xpcom/glue/PLDHashTable.h
@@ -70,17 +70,17 @@ private:
 //   - Read(n), where 'n' is the number of concurrent read operations
 //   - Write
 //
 // - mIsWritable, which indicates if the table is mutable.
 //
 class Checker
 {
 public:
-  MOZ_CONSTEXPR Checker() : mState(kIdle), mIsWritable(1) {}
+  constexpr Checker() : mState(kIdle), mIsWritable(1) {}
 
   Checker& operator=(Checker&& aOther) {
     // Atomic<> doesn't have an |operator=(Atomic<>&&)|.
     mState = uint32_t(aOther.mState);
     mIsWritable = uint32_t(aOther.mIsWritable);
 
     aOther.mState = kIdle;
 
--- a/xpcom/glue/nsCycleCollectionParticipant.h
+++ b/xpcom/glue/nsCycleCollectionParticipant.h
@@ -108,18 +108,18 @@ private:
 };
 
 /**
  * Participant implementation classes
  */
 class NS_NO_VTABLE nsCycleCollectionParticipant
 {
 public:
-  MOZ_CONSTEXPR nsCycleCollectionParticipant() : mMightSkip(false) {}
-  MOZ_CONSTEXPR explicit nsCycleCollectionParticipant(bool aSkip) : mMightSkip(aSkip) {}
+  constexpr nsCycleCollectionParticipant() : mMightSkip(false) {}
+  constexpr explicit nsCycleCollectionParticipant(bool aSkip) : mMightSkip(aSkip) {}
 
   NS_IMETHOD Traverse(void* aPtr, nsCycleCollectionTraversalCallback& aCb) = 0;
 
   NS_IMETHOD_(void) Root(void* aPtr) = 0;
   NS_IMETHOD_(void) Unlink(void* aPtr) = 0;
   NS_IMETHOD_(void) Unroot(void* aPtr) = 0;
   NS_IMETHOD_(const char*) ClassName() = 0;
 
@@ -172,41 +172,41 @@ protected:
 
 private:
   const bool mMightSkip;
 };
 
 class NS_NO_VTABLE nsScriptObjectTracer : public nsCycleCollectionParticipant
 {
 public:
-  MOZ_CONSTEXPR nsScriptObjectTracer()
+  constexpr nsScriptObjectTracer()
     : nsCycleCollectionParticipant(false)
   {
   }
-  MOZ_CONSTEXPR explicit nsScriptObjectTracer(bool aSkip)
+  constexpr explicit nsScriptObjectTracer(bool aSkip)
     : nsCycleCollectionParticipant(aSkip)
   {
   }
 
   NS_IMETHOD_(void) Trace(void* aPtr, const TraceCallbacks& aCb,
                           void* aClosure) override = 0;
 
   // Implemented in nsCycleCollectorTraceJSHelpers.cpp.
   static void NoteJSChild(JS::GCCellPtr aGCThing, const char* aName,
                           void* aClosure);
 };
 
 class NS_NO_VTABLE nsXPCOMCycleCollectionParticipant : public nsScriptObjectTracer
 {
 public:
-  MOZ_CONSTEXPR nsXPCOMCycleCollectionParticipant()
+  constexpr nsXPCOMCycleCollectionParticipant()
     : nsScriptObjectTracer(false)
   {
   }
-  MOZ_CONSTEXPR explicit nsXPCOMCycleCollectionParticipant(bool aSkip)
+  constexpr explicit nsXPCOMCycleCollectionParticipant(bool aSkip)
     : nsScriptObjectTracer(aSkip)
   {
   }
 
   NS_DECLARE_STATIC_IID_ACCESSOR(NS_XPCOMCYCLECOLLECTIONPARTICIPANT_IID)
 
   NS_IMETHOD_(void) Root(void* aPtr) override;
   NS_IMETHOD_(void) Unroot(void* aPtr) override;
@@ -535,17 +535,17 @@ public:                                 
 #define NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base)                     \
   NS_DECL_CYCLE_COLLECTION_CLASS_BODY_NO_UNLINK(_class, _base)                 \
   NS_IMETHOD_(void) Unlink(void *p) override;
 
 #define NS_PARTICIPANT_AS(type, participant)                                   \
   const_cast<type*>(reinterpret_cast<const type*>(participant))
 
 #define NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class)                 \
-  static MOZ_CONSTEXPR nsXPCOMCycleCollectionParticipant* GetParticipant()     \
+  static constexpr nsXPCOMCycleCollectionParticipant* GetParticipant()         \
   {                                                                            \
     return &_class::NS_CYCLE_COLLECTION_INNERNAME;                             \
   }
 
 /**
  * We use this macro to force that classes that inherit from a ccable class and
  * declare their own participant declare themselves as inherited cc classes.
  * To avoid possibly unnecessary vtables we only do this checking in debug
@@ -572,17 +572,17 @@ static NS_CYCLE_COLLECTION_INNERCLASS NS
   NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(_class, _class)
 
 // Cycle collector helper for ambiguous classes that can sometimes be skipped.
 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_CLASS_AMBIGUOUS(_class, _base)        \
 class NS_CYCLE_COLLECTION_INNERCLASS                                             \
  : public nsXPCOMCycleCollectionParticipant                                      \
 {                                                                                \
 public:                                                                          \
-  MOZ_CONSTEXPR NS_CYCLE_COLLECTION_INNERCLASS ()                                \
+  constexpr NS_CYCLE_COLLECTION_INNERCLASS ()                                    \
   : nsXPCOMCycleCollectionParticipant(true) {}                                   \
 private:                                                                         \
   NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base)                             \
   NS_IMETHOD_(bool) CanSkipReal(void *p, bool aRemovingAllowed) override;        \
   NS_IMETHOD_(bool) CanSkipInCCReal(void *p) override;                           \
   NS_IMETHOD_(bool) CanSkipThisReal(void *p) override;                           \
   NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class)                         \
 };                                                                               \
@@ -605,17 +605,17 @@ NS_CHECK_FOR_RIGHT_PARTICIPANT_IMPL(_cla
 static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME; \
 NOT_INHERITED_CANT_OVERRIDE
 
 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_AMBIGUOUS(_class, _base)   \
 class NS_CYCLE_COLLECTION_INNERCLASS                                                      \
  : public nsXPCOMCycleCollectionParticipant                                               \
 {                                                                                         \
 public:                                                                                   \
-  MOZ_CONSTEXPR NS_CYCLE_COLLECTION_INNERCLASS ()                                         \
+  constexpr NS_CYCLE_COLLECTION_INNERCLASS ()                                             \
   : nsXPCOMCycleCollectionParticipant(true) {}                                            \
 private:                                                                                  \
   NS_DECL_CYCLE_COLLECTION_CLASS_BODY(_class, _base)                                      \
   NS_IMETHOD_(void) Trace(void *p, const TraceCallbacks &cb, void *closure) override;     \
   NS_IMETHOD_(bool) CanSkipReal(void *p, bool aRemovingAllowed) override;                 \
   NS_IMETHOD_(bool) CanSkipInCCReal(void *p) override;                                    \
   NS_IMETHOD_(bool) CanSkipThisReal(void *p) override;                                    \
   NS_IMPL_GET_XPCOM_CYCLE_COLLECTION_PARTICIPANT(_class)                                  \
@@ -724,33 +724,33 @@ static NS_CYCLE_COLLECTION_INNERCLASS NS
   void DeleteCycleCollectable(void)                                            \
   {                                                                            \
     delete this;                                                               \
   }                                                                            \
   class NS_CYCLE_COLLECTION_INNERCLASS                                         \
    : public nsCycleCollectionParticipant                                       \
   {                                                                            \
     NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY(_class)                         \
-    static MOZ_CONSTEXPR nsCycleCollectionParticipant* GetParticipant()        \
+    static constexpr nsCycleCollectionParticipant* GetParticipant()            \
     {                                                                          \
       return &_class::NS_CYCLE_COLLECTION_INNERNAME;                           \
     }                                                                          \
   };                                                                           \
   static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
 
 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_NATIVE_CLASS(_class)                \
   void DeleteCycleCollectable(void)                                            \
   {                                                                            \
     delete this;                                                               \
   }                                                                            \
   class NS_CYCLE_COLLECTION_INNERCLASS                                         \
    : public nsCycleCollectionParticipant                                       \
   {                                                                            \
   public:                                                                      \
-    MOZ_CONSTEXPR NS_CYCLE_COLLECTION_INNERCLASS ()                            \
+    constexpr NS_CYCLE_COLLECTION_INNERCLASS ()                                \
     : nsCycleCollectionParticipant(true) {}                                    \
   private:                                                                     \
     NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY(_class)                         \
     NS_IMETHOD_(bool) CanSkipReal(void *p, bool aRemovingAllowed) override;    \
     NS_IMETHOD_(bool) CanSkipInCCReal(void *p) override;                       \
     NS_IMETHOD_(bool) CanSkipThisReal(void *p) override;                       \
     static nsCycleCollectionParticipant* GetParticipant()                      \
     {                                                                          \
@@ -759,17 +759,17 @@ static NS_CYCLE_COLLECTION_INNERCLASS NS
   };                                                                           \
   static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
 
 #define NS_DECL_CYCLE_COLLECTION_SKIPPABLE_NATIVE_CLASS_WITH_CUSTOM_DELETE(_class) \
 class NS_CYCLE_COLLECTION_INNERCLASS                                           \
  : public nsCycleCollectionParticipant                                         \
 {                                                                              \
 public:                                                                        \
-  MOZ_CONSTEXPR NS_CYCLE_COLLECTION_INNERCLASS ()                              \
+  constexpr NS_CYCLE_COLLECTION_INNERCLASS ()                                  \
   : nsCycleCollectionParticipant(true) {}                                      \
 private:                                                                       \
   NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY(_class)                           \
   NS_IMETHOD_(bool) CanSkipReal(void *p, bool aRemovingAllowed) override;      \
   NS_IMETHOD_(bool) CanSkipInCCReal(void *p) override;                         \
   NS_IMETHOD_(bool) CanSkipThisReal(void *p) override;                         \
   static nsCycleCollectionParticipant* GetParticipant()                        \
   {                                                                            \
@@ -784,17 +784,17 @@ static NS_CYCLE_COLLECTION_INNERCLASS NS
     delete this;                                                               \
   }                                                                            \
   class NS_CYCLE_COLLECTION_INNERCLASS                                         \
    : public nsScriptObjectTracer                                               \
   {                                                                            \
     NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS_BODY(_class)                         \
     NS_IMETHOD_(void) Trace(void *p, const TraceCallbacks &cb, void *closure)  \
       override;                                                                \
-    static MOZ_CONSTEXPR nsScriptObjectTracer* GetParticipant()                \
+    static constexpr nsScriptObjectTracer* GetParticipant()                    \
     {                                                                          \
       return &_class::NS_CYCLE_COLLECTION_INNERNAME;                           \
     }                                                                          \
   };                                                                           \
   static NS_CYCLE_COLLECTION_INNERCLASS NS_CYCLE_COLLECTION_INNERNAME;
 
 #define NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(_class, _root_function)           \
   NS_IMETHODIMP_(void)                                                         \
--- a/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
+++ b/xpcom/reflect/xptinfo/ShimInterfaceInfo.cpp
@@ -270,17 +270,17 @@
 #include "mozilla/dom/XPathResultBinding.h"
 #include "mozilla/dom/XULCommandEventBinding.h"
 #include "mozilla/dom/XULDocumentBinding.h"
 #include "mozilla/dom/XULElementBinding.h"
 
 using namespace mozilla;
 
 struct ComponentsInterfaceShimEntry {
-  MOZ_CONSTEXPR
+  constexpr
   ComponentsInterfaceShimEntry(const char* aName, const nsIID& aIID,
                                const dom::NativePropertyHooks* aNativePropHooks)
     : geckoName(aName), iid(aIID), nativePropHooks(aNativePropHooks) {}
 
   const char *geckoName;
   const nsIID& iid;
   const dom::NativePropertyHooks* nativePropHooks;
 };