Bug 1527860 - Remove ENABLE_BIGINT #ifdef r=jandem,froydnj
authorAndy Wingo <wingo@igalia.com>
Thu, 14 Feb 2019 15:03:44 +0000
changeset 517028 fdb6f449e8c0858442997e9fdf5d35fbc35d5fec
parent 517027 a420bc5350d7ac1c8e25ef5c53d7e35339b30252
child 517029 bf2ec5cdc33be29622d03a6caddc500476604bbe
push id10862
push userffxbld-merge
push dateMon, 11 Mar 2019 13:01:11 +0000
treeherdermozilla-beta@a2e7f5c935da [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjandem, froydnj
bugs1527860
milestone67.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 1527860 - Remove ENABLE_BIGINT #ifdef r=jandem,froydnj Differential Revision: https://phabricator.services.mozilla.com/D19766
dom/bindings/BindingUtils.h
js/moz.configure
js/public/Class.h
js/public/CompileOptions.h
js/public/GCPolicyAPI.h
js/public/MemoryMetrics.h
js/public/ProtoKey.h
js/public/TraceKind.h
js/public/TracingAPI.h
js/public/TypeDecls.h
js/public/UbiNode.h
js/public/Value.h
js/src/NamespaceImports.h
js/src/builtin/Array.cpp
js/src/builtin/Boolean.cpp
js/src/builtin/JSON.cpp
js/src/builtin/MapObject.cpp
js/src/builtin/Object.cpp
js/src/builtin/ReflectParse.cpp
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/BytecodeEmitter.h
js/src/frontend/FoldConstants.cpp
js/src/frontend/FullParseHandler.h
js/src/frontend/NameFunctions.cpp
js/src/frontend/ParseNode.cpp
js/src/frontend/ParseNode.h
js/src/frontend/Parser.cpp
js/src/frontend/Parser.h
js/src/frontend/SyntaxParseHandler.h
js/src/frontend/TokenKind.h
js/src/frontend/TokenStream.cpp
js/src/frontend/TokenStream.h
js/src/fuzz-tests/tests.cpp
js/src/gc/AllocKind.h
js/src/gc/AtomMarking.cpp
js/src/gc/DeletePolicy.h
js/src/gc/GC.cpp
js/src/gc/Marking-inl.h
js/src/gc/Marking.cpp
js/src/gc/RootMarking.cpp
js/src/gc/Tracer.cpp
js/src/gdb/lib-for-tests/prologue.py
js/src/gdb/mozilla/jsval.py
js/src/gdb/tests/test-jsval.cpp
js/src/gdb/tests/test-jsval.py
js/src/jit/BaselineBailouts.cpp
js/src/jit/BaselineCompiler.cpp
js/src/jit/BaselineCompiler.h
js/src/jit/BaselineIC.cpp
js/src/jit/BaselineInspector.cpp
js/src/jit/CacheIR.cpp
js/src/jit/CacheIR.h
js/src/jit/CacheIRCompiler.cpp
js/src/jit/CacheIRCompiler.h
js/src/jit/CodeGenerator.cpp
js/src/jit/IonAnalysis.cpp
js/src/jit/IonBuilder.cpp
js/src/jit/IonTypes.h
js/src/jit/JitFrames.cpp
js/src/jit/LIR.h
js/src/jit/Lowering.cpp
js/src/jit/MCallOptimize.cpp
js/src/jit/MIR.cpp
js/src/jit/MIR.h
js/src/jit/MacroAssembler.cpp
js/src/jit/MacroAssembler.h
js/src/jit/Snapshots.cpp
js/src/jit/TypePolicy.cpp
js/src/jit/VMFunctions.cpp
js/src/jit/VMFunctions.h
js/src/jit/arm/MacroAssembler-arm-inl.h
js/src/jit/arm/MacroAssembler-arm.cpp
js/src/jit/arm/MacroAssembler-arm.h
js/src/jit/arm64/CodeGenerator-arm64.cpp
js/src/jit/arm64/MacroAssembler-arm64-inl.h
js/src/jit/arm64/MacroAssembler-arm64.h
js/src/jit/mips32/MacroAssembler-mips32-inl.h
js/src/jit/mips64/CodeGenerator-mips64.cpp
js/src/jit/mips64/MacroAssembler-mips64-inl.h
js/src/jit/mips64/MacroAssembler-mips64.cpp
js/src/jit/mips64/MacroAssembler-mips64.h
js/src/jit/none/MacroAssembler-none.h
js/src/jit/shared/CodeGenerator-shared.cpp
js/src/jit/shared/Lowering-shared-inl.h
js/src/jit/x64/CodeGenerator-x64.cpp
js/src/jit/x64/MacroAssembler-x64.h
js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
js/src/jit/x86/MacroAssembler-x86.h
js/src/jsapi-tests/testJitRValueAlloc.cpp
js/src/jsapi-tests/tests.cpp
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsexn.cpp
js/src/jsfriendapi.cpp
js/src/jsnum.cpp
js/src/jsnum.h
js/src/jspubtd.h
js/src/moz.build
js/src/shell/js.cpp
js/src/util/StringBuffer.cpp
js/src/vm/BytecodeUtil.cpp
js/src/vm/BytecodeUtil.h
js/src/vm/Compartment-inl.h
js/src/vm/Compartment.cpp
js/src/vm/Compartment.h
js/src/vm/EqualityOperations.cpp
js/src/vm/GlobalObject.cpp
js/src/vm/Initialization.cpp
js/src/vm/Interpreter-inl.h
js/src/vm/Interpreter.cpp
js/src/vm/JSAtom.cpp
js/src/vm/JSContext-inl.h
js/src/vm/JSObject.cpp
js/src/vm/JSScript.cpp
js/src/vm/MemoryMetrics.cpp
js/src/vm/Opcodes.h
js/src/vm/StringType.cpp
js/src/vm/StructuredClone.cpp
js/src/vm/TypeInference-inl.h
js/src/vm/TypeInference.cpp
js/src/vm/TypeSet.h
js/src/vm/TypedArrayObject-inl.h
js/src/vm/UbiNode.cpp
js/xpconnect/src/XPCJSContext.cpp
modules/libpref/init/StaticPrefList.h
--- a/dom/bindings/BindingUtils.h
+++ b/dom/bindings/BindingUtils.h
@@ -962,25 +962,23 @@ MOZ_ALWAYS_INLINE bool MaybeWrapValue(JS
                                       JS::MutableHandle<JS::Value> rval) {
   if (rval.isGCThing()) {
     if (rval.isString()) {
       return MaybeWrapStringValue(cx, rval);
     }
     if (rval.isObject()) {
       return MaybeWrapObjectValue(cx, rval);
     }
-#ifdef ENABLE_BIGINT
     // This could be optimized by checking the zone first, similar to
     // the way strings are handled. At present, this is used primarily
     // for structured cloning, so avoiding the overhead of JS_WrapValue
     // calls is less important than for other types.
     if (rval.isBigInt()) {
       return JS_WrapValue(cx, rval);
     }
-#endif
     MOZ_ASSERT(rval.isSymbol());
     JS_MarkCrossZoneId(cx, SYMBOL_TO_JSID(rval.toSymbol()));
   }
   return true;
 }
 
 namespace binding_detail {
 enum GetOrCreateReflectorWrapBehavior {
--- a/js/moz.configure
+++ b/js/moz.configure
@@ -102,29 +102,16 @@ def disable_export_js(value):
     if value and not len(value):
         suggestion = '--disable-export-js'
     else:
         suggestion = '--enable-export-js'
 
     die('Setting %s is deprecated, use %s instead.',
         value.format('DISABLE_EXPORT_JS'), suggestion)
 
-# Experimental BigInt support
-# =======================================================
-js_option('--disable-bigint',
-          help='{Enable|Disable} BigInt')
-
-@depends('--disable-bigint')
-def enable_bigint(value):
-    if value:
-        return True
-
-set_config('ENABLE_BIGINT', enable_bigint)
-set_define('ENABLE_BIGINT', enable_bigint)
-
 # JIT support
 # =======================================================
 @depends(target)
 def ion_default(target):
     if target.cpu in ('x86', 'x86_64', 'arm', 'aarch64', 'mips32', 'mips64'):
         return True
     return False
 
--- a/js/public/Class.h
+++ b/js/public/Class.h
@@ -1033,19 +1033,17 @@ enum class ESClass {
   Date,
   Set,
   Map,
   Promise,
   MapIterator,
   SetIterator,
   Arguments,
   Error,
-#ifdef ENABLE_BIGINT
   BigInt,
-#endif
 
   /** None of the above. */
   Other
 };
 
 /* Fills |vp| with the unboxed value for boxed types, or undefined otherwise. */
 bool Unbox(JSContext* cx, JS::HandleObject obj, JS::MutableHandleValue vp);
 
--- a/js/public/CompileOptions.h
+++ b/js/public/CompileOptions.h
@@ -111,19 +111,17 @@ class JS_PUBLIC_API TransitiveCompileOpt
   bool werrorOption = false;
   AsmJSOption asmJSOption = AsmJSOption::Disabled;
   bool throwOnAsmJSValidationFailureOption = false;
   bool forceAsync = false;
   bool sourceIsLazy = false;
   bool allowHTMLComments = true;
   bool isProbablySystemCode = false;
   bool hideScriptFromDebugger = false;
-#ifdef ENABLE_BIGINT
   bool bigIntEnabledOption = false;
-#endif
 
   /**
    * |introductionType| is a statically allocated C string: one of "eval",
    * "Function", or "GeneratorFunction".
    */
   const char* introductionType = nullptr;
 
   unsigned introductionLineno = 0;
--- a/js/public/GCPolicyAPI.h
+++ b/js/public/GCPolicyAPI.h
@@ -42,17 +42,17 @@
 
 #include "js/TraceKind.h"
 #include "js/TracingAPI.h"
 #include "js/TypeDecls.h"
 
 // Expand the given macro D for each public GC pointer.
 #define FOR_EACH_PUBLIC_GC_POINTER_TYPE(D) \
   D(JS::Symbol*)                           \
-  IF_BIGINT(D(JS::BigInt*), )              \
+  D(JS::BigInt*)                           \
   D(JSAtom*)                               \
   D(JSFunction*)                           \
   D(JSObject*)                             \
   D(JSScript*)                             \
   D(JSString*)
 
 // Expand the given macro D for each public tagged GC pointer type.
 #define FOR_EACH_PUBLIC_TAGGED_GC_POINTER_TYPE(D) \
--- a/js/public/MemoryMetrics.h
+++ b/js/public/MemoryMetrics.h
@@ -564,17 +564,17 @@ struct UnusedGCThingSizes {
   MACRO(Other, GCHeapUnused, object)              \
   MACRO(Other, GCHeapUnused, script)              \
   MACRO(Other, GCHeapUnused, lazyScript)          \
   MACRO(Other, GCHeapUnused, shape)               \
   MACRO(Other, GCHeapUnused, baseShape)           \
   MACRO(Other, GCHeapUnused, objectGroup)         \
   MACRO(Other, GCHeapUnused, string)              \
   MACRO(Other, GCHeapUnused, symbol)              \
-  IF_BIGINT(MACRO(Other, GCHeapUnused, bigInt), ) \
+  MACRO(Other, GCHeapUnused, bigInt)              \
   MACRO(Other, GCHeapUnused, jitcode)             \
   MACRO(Other, GCHeapUnused, scope)               \
   MACRO(Other, GCHeapUnused, regExpShared)
 
   UnusedGCThingSizes() : FOR_EACH_SIZE(ZERO_SIZE) dummy() {}
 
   UnusedGCThingSizes(UnusedGCThingSizes&& other)
       : FOR_EACH_SIZE(COPY_OTHER_SIZE) dummy() {}
@@ -585,21 +585,19 @@ struct UnusedGCThingSizes {
         object += n;
         break;
       case JS::TraceKind::String:
         string += n;
         break;
       case JS::TraceKind::Symbol:
         symbol += n;
         break;
-#ifdef ENABLE_BIGINT
       case JS::TraceKind::BigInt:
         bigInt += n;
         break;
-#endif
       case JS::TraceKind::Script:
         script += n;
         break;
       case JS::TraceKind::Shape:
         shape += n;
         break;
       case JS::TraceKind::BaseShape:
         baseShape += n;
@@ -643,18 +641,18 @@ struct UnusedGCThingSizes {
                                        // comma from FOR_EACH_SIZE(ZERO_SIZE)
 
 #undef FOR_EACH_SIZE
 };
 
 struct ZoneStats {
 #define FOR_EACH_SIZE(MACRO)                               \
   MACRO(Other, GCHeapUsed, symbolsGCHeap)                  \
-  IF_BIGINT(MACRO(Other, GCHeapUsed, bigIntsGCHeap), )     \
-  IF_BIGINT(MACRO(Other, MallocHeap, bigIntsMallocHeap), ) \
+  MACRO(Other, GCHeapUsed, bigIntsGCHeap)                  \
+  MACRO(Other, MallocHeap, bigIntsMallocHeap)              \
   MACRO(Other, GCHeapAdmin, gcHeapArenaAdmin)              \
   MACRO(Other, GCHeapUsed, lazyScriptsGCHeap)              \
   MACRO(Other, MallocHeap, lazyScriptsMallocHeap)          \
   MACRO(Other, GCHeapUsed, jitCodesGCHeap)                 \
   MACRO(Other, GCHeapUsed, objectGroupsGCHeap)             \
   MACRO(Other, MallocHeap, objectGroupsMallocHeap)         \
   MACRO(Other, GCHeapUsed, scopesGCHeap)                   \
   MACRO(Other, MallocHeap, scopesMallocHeap)               \
--- a/js/public/ProtoKey.h
+++ b/js/public/ProtoKey.h
@@ -50,17 +50,17 @@
 
 #ifdef ENABLE_SHARED_ARRAY_BUFFER
 #  define IF_SAB(REAL, IMAGINARY) REAL
 #else
 #  define IF_SAB(REAL, IMAGINARY) IMAGINARY
 #endif
 
 #define JS_FOR_PROTOTYPES_(REAL, IMAGINARY, REAL_IF_INTL, REAL_IF_BDATA,     \
-                           REAL_IF_SAB, REAL_IF_BIGINT)                      \
+                           REAL_IF_SAB)                                      \
   IMAGINARY(Null, InitNullClass, dummy)                                      \
   REAL(Object, InitViaClassSpec, OCLASP(Plain))                              \
   REAL(Function, InitViaClassSpec, &JSFunction::class_)                      \
   REAL(Array, InitViaClassSpec, OCLASP(Array))                               \
   REAL(Boolean, InitBooleanClass, OCLASP(Boolean))                           \
   REAL(JSON, InitJSONClass, CLASP(JSON))                                     \
   REAL(Date, InitViaClassSpec, OCLASP(Date))                                 \
   REAL(Math, InitMathClass, CLASP(Math))                                     \
@@ -85,17 +85,17 @@
   REAL(Uint8Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Uint8))               \
   REAL(Int16Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Int16))               \
   REAL(Uint16Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Uint16))             \
   REAL(Int32Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Int32))               \
   REAL(Uint32Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Uint32))             \
   REAL(Float32Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Float32))           \
   REAL(Float64Array, InitViaClassSpec, TYPED_ARRAY_CLASP(Float64))           \
   REAL(Uint8ClampedArray, InitViaClassSpec, TYPED_ARRAY_CLASP(Uint8Clamped)) \
-  REAL_IF_BIGINT(BigInt, InitViaClassSpec, OCLASP(BigInt))                   \
+  REAL(BigInt, InitViaClassSpec, OCLASP(BigInt))                             \
   REAL(Proxy, InitProxyClass, &js::ProxyClass)                               \
   REAL(WeakMap, InitViaClassSpec, OCLASP(WeakMap))                           \
   REAL(Map, InitViaClassSpec, OCLASP(Map))                                   \
   REAL(Set, InitViaClassSpec, OCLASP(Set))                                   \
   REAL(DataView, InitViaClassSpec, OCLASP(DataView))                         \
   REAL(Symbol, InitSymbolClass, OCLASP(Symbol))                              \
   REAL(SharedArrayBuffer, InitViaClassSpec, OCLASP(SharedArrayBuffer))       \
   REAL_IF_INTL(Intl, InitIntlClass, CLASP(Intl))                             \
@@ -126,14 +126,13 @@
   IMAGINARY(WasmModule, dummy, dummy)                                        \
   IMAGINARY(WasmInstance, dummy, dummy)                                      \
   IMAGINARY(WasmMemory, dummy, dummy)                                        \
   IMAGINARY(WasmTable, dummy, dummy)                                         \
   IMAGINARY(WasmGlobal, dummy, dummy)
 
 #define JS_FOR_PROTOTYPES(REAL, IMAGINARY)                               \
   JS_FOR_PROTOTYPES_(REAL, IMAGINARY, IF_INTL(REAL, IMAGINARY),          \
-                     IF_BDATA(REAL, IMAGINARY), IF_SAB(REAL, IMAGINARY), \
-                     IF_BIGINT(REAL, IMAGINARY))
+                     IF_BDATA(REAL, IMAGINARY), IF_SAB(REAL, IMAGINARY))
 
 #define JS_FOR_EACH_PROTOTYPE(MACRO) JS_FOR_PROTOTYPES(MACRO, MACRO)
 
 #endif /* js_ProtoKey_h */
--- a/js/public/TraceKind.h
+++ b/js/public/TraceKind.h
@@ -57,19 +57,17 @@ enum class TraceKind {
   Null = 0x06,
 
   // The following kinds do not have an exposed C++ idiom.
   BaseShape = 0x0F,
   JitCode = 0x1F,
   LazyScript = 0x2F,
   Scope = 0x3F,
   RegExpShared = 0x4F,
-#ifdef ENABLE_BIGINT
   BigInt = 0x5F
-#endif
 };
 const static uintptr_t OutOfLineTraceKindMask = 0x07;
 
 // Returns true if the JS::TraceKind is one the cycle collector cares about.
 // Everything used as WeakMap key should be listed here, to represent the key
 // in cycle collector's graph, otherwise the key is considered to be pointed
 // from somewhere unknown, and results in leaking the subgraph which contains
 // the key.
@@ -108,17 +106,17 @@ struct MapTypeToTraceKind {
   D(LazyScript, js::LazyScript, true)                     \
   D(Scope, js::Scope, true)                               \
   D(Object, JSObject, true)                               \
   D(ObjectGroup, js::ObjectGroup, true)                   \
   D(Script, JSScript, true)                               \
   D(Shape, js::Shape, true)                               \
   D(String, JSString, false)                              \
   D(Symbol, JS::Symbol, false)                            \
-  IF_BIGINT(D(BigInt, JS::BigInt, false), )               \
+  D(BigInt, JS::BigInt, false)                            \
   D(RegExpShared, js::RegExpShared, true)
 
 // Map from all public types to their trace kind.
 #define JS_EXPAND_DEF(name, type, _)                       \
   template <>                                              \
   struct MapTypeToTraceKind<type> {                        \
     static const JS::TraceKind kind = JS::TraceKind::name; \
   };
--- a/js/public/TracingAPI.h
+++ b/js/public/TracingAPI.h
@@ -154,19 +154,17 @@ class JS_PUBLIC_API CallbackTracer : pub
   // dispatches to the fully-generic onChild implementation, so for cases that
   // do not care about boxing overhead and do not need the actual edges,
   // just override the generic onChild.
   virtual void onObjectEdge(JSObject** objp) { onChild(JS::GCCellPtr(*objp)); }
   virtual void onStringEdge(JSString** strp) { onChild(JS::GCCellPtr(*strp)); }
   virtual void onSymbolEdge(JS::Symbol** symp) {
     onChild(JS::GCCellPtr(*symp));
   }
-#ifdef ENABLE_BIGINT
   virtual void onBigIntEdge(JS::BigInt** bip) { onChild(JS::GCCellPtr(*bip)); }
-#endif
   virtual void onScriptEdge(JSScript** scriptp) {
     onChild(JS::GCCellPtr(*scriptp));
   }
   virtual void onShapeEdge(js::Shape** shapep) {
     onChild(JS::GCCellPtr(*shapep, JS::TraceKind::Shape));
   }
   virtual void onObjectGroupEdge(js::ObjectGroup** groupp) {
     onChild(JS::GCCellPtr(*groupp, JS::TraceKind::ObjectGroup));
@@ -254,19 +252,17 @@ class JS_PUBLIC_API CallbackTracer : pub
   // In C++, overriding a method hides all methods in the base class with
   // that name, not just methods with that signature. Thus, the typed edge
   // methods have to have distinct names to allow us to override them
   // individually, which is freqently useful if, for example, we only want to
   // process only one type of edge.
   void dispatchToOnEdge(JSObject** objp) { onObjectEdge(objp); }
   void dispatchToOnEdge(JSString** strp) { onStringEdge(strp); }
   void dispatchToOnEdge(JS::Symbol** symp) { onSymbolEdge(symp); }
-#ifdef ENABLE_BIGINT
   void dispatchToOnEdge(JS::BigInt** bip) { onBigIntEdge(bip); }
-#endif
   void dispatchToOnEdge(JSScript** scriptp) { onScriptEdge(scriptp); }
   void dispatchToOnEdge(js::Shape** shapep) { onShapeEdge(shapep); }
   void dispatchToOnEdge(js::ObjectGroup** groupp) { onObjectGroupEdge(groupp); }
   void dispatchToOnEdge(js::BaseShape** basep) { onBaseShapeEdge(basep); }
   void dispatchToOnEdge(js::jit::JitCode** codep) { onJitCodeEdge(codep); }
   void dispatchToOnEdge(js::LazyScript** lazyp) { onLazyScriptEdge(lazyp); }
   void dispatchToOnEdge(js::Scope** scopep) { onScopeEdge(scopep); }
   void dispatchToOnEdge(js::RegExpShared** sharedp) {
--- a/js/public/TypeDecls.h
+++ b/js/public/TypeDecls.h
@@ -35,19 +35,17 @@ struct JSFreeOp;
 
 namespace JS {
 
 struct PropertyKey;
 
 typedef unsigned char Latin1Char;
 
 class Symbol;
-#ifdef ENABLE_BIGINT
 class BigInt;
-#endif
 union Value;
 
 class Compartment;
 class Realm;
 struct Runtime;
 class Zone;
 
 template <typename T>
@@ -60,57 +58,43 @@ template <typename T>
 class PersistentRooted;
 
 typedef Handle<JSFunction*> HandleFunction;
 typedef Handle<PropertyKey> HandleId;
 typedef Handle<JSObject*> HandleObject;
 typedef Handle<JSScript*> HandleScript;
 typedef Handle<JSString*> HandleString;
 typedef Handle<JS::Symbol*> HandleSymbol;
-#ifdef ENABLE_BIGINT
 typedef Handle<JS::BigInt*> HandleBigInt;
-#endif
 typedef Handle<Value> HandleValue;
 
 typedef MutableHandle<JSFunction*> MutableHandleFunction;
 typedef MutableHandle<PropertyKey> MutableHandleId;
 typedef MutableHandle<JSObject*> MutableHandleObject;
 typedef MutableHandle<JSScript*> MutableHandleScript;
 typedef MutableHandle<JSString*> MutableHandleString;
 typedef MutableHandle<JS::Symbol*> MutableHandleSymbol;
-#ifdef ENABLE_BIGINT
 typedef MutableHandle<JS::BigInt*> MutableHandleBigInt;
-#endif
 typedef MutableHandle<Value> MutableHandleValue;
 
 typedef Rooted<JSObject*> RootedObject;
 typedef Rooted<JSFunction*> RootedFunction;
 typedef Rooted<JSScript*> RootedScript;
 typedef Rooted<JSString*> RootedString;
 typedef Rooted<JS::Symbol*> RootedSymbol;
-#ifdef ENABLE_BIGINT
 typedef Rooted<JS::BigInt*> RootedBigInt;
-#endif
 typedef Rooted<PropertyKey> RootedId;
 typedef Rooted<JS::Value> RootedValue;
 
 typedef PersistentRooted<JSFunction*> PersistentRootedFunction;
 typedef PersistentRooted<PropertyKey> PersistentRootedId;
 typedef PersistentRooted<JSObject*> PersistentRootedObject;
 typedef PersistentRooted<JSScript*> PersistentRootedScript;
 typedef PersistentRooted<JSString*> PersistentRootedString;
 typedef PersistentRooted<JS::Symbol*> PersistentRootedSymbol;
-#ifdef ENABLE_BIGINT
 typedef PersistentRooted<JS::BigInt*> PersistentRootedBigInt;
-#endif
 typedef PersistentRooted<Value> PersistentRootedValue;
 
 }  // namespace JS
 
 using jsid = JS::PropertyKey;
 
-#ifdef ENABLE_BIGINT
-#  define IF_BIGINT(x, y) x
-#else
-#  define IF_BIGINT(x, y) y
-#endif
-
 #endif /* js_TypeDecls_h */
--- a/js/public/UbiNode.h
+++ b/js/public/UbiNode.h
@@ -1075,33 +1075,31 @@ class JS_PUBLIC_API Concrete<JS::Symbol>
   }
 
   Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
 
   const char16_t* typeName() const override { return concreteTypeName; }
   static const char16_t concreteTypeName[];
 };
 
-#ifdef ENABLE_BIGINT
 template <>
 class JS_PUBLIC_API Concrete<JS::BigInt> : TracerConcrete<JS::BigInt> {
  protected:
   explicit Concrete(JS::BigInt* ptr) : TracerConcrete(ptr) {}
 
  public:
   static void construct(void* storage, JS::BigInt* ptr) {
     new (storage) Concrete(ptr);
   }
 
   Size size(mozilla::MallocSizeOf mallocSizeOf) const override;
 
   const char16_t* typeName() const override { return concreteTypeName; }
   static const char16_t concreteTypeName[];
 };
-#endif
 
 template <>
 class JS_PUBLIC_API Concrete<JSScript> : TracerConcreteWithRealm<JSScript> {
  protected:
   explicit Concrete(JSScript* ptr) : TracerConcreteWithRealm<JSScript>(ptr) {}
 
  public:
   static void construct(void* storage, JSScript* ptr) {
--- a/js/public/Value.h
+++ b/js/public/Value.h
@@ -56,19 +56,17 @@ enum JSValueType : uint8_t {
   JSVAL_TYPE_INT32 = 0x01,
   JSVAL_TYPE_BOOLEAN = 0x02,
   JSVAL_TYPE_UNDEFINED = 0x03,
   JSVAL_TYPE_NULL = 0x04,
   JSVAL_TYPE_MAGIC = 0x05,
   JSVAL_TYPE_STRING = 0x06,
   JSVAL_TYPE_SYMBOL = 0x07,
   JSVAL_TYPE_PRIVATE_GCTHING = 0x08,
-#ifdef ENABLE_BIGINT
   JSVAL_TYPE_BIGINT = 0x09,
-#endif
   JSVAL_TYPE_OBJECT = 0x0c,
 
   // These never appear in a jsval; they are only provided as an out-of-band
   // value.
   JSVAL_TYPE_UNKNOWN = 0x20,
   JSVAL_TYPE_MISSING = 0x21
 };
 
@@ -82,19 +80,17 @@ JS_ENUM_HEADER(JSValueTag, uint32_t){
     JSVAL_TAG_INT32 = JSVAL_TAG_CLEAR | JSVAL_TYPE_INT32,
     JSVAL_TAG_UNDEFINED = JSVAL_TAG_CLEAR | JSVAL_TYPE_UNDEFINED,
     JSVAL_TAG_NULL = JSVAL_TAG_CLEAR | JSVAL_TYPE_NULL,
     JSVAL_TAG_BOOLEAN = JSVAL_TAG_CLEAR | JSVAL_TYPE_BOOLEAN,
     JSVAL_TAG_MAGIC = JSVAL_TAG_CLEAR | JSVAL_TYPE_MAGIC,
     JSVAL_TAG_STRING = JSVAL_TAG_CLEAR | JSVAL_TYPE_STRING,
     JSVAL_TAG_SYMBOL = JSVAL_TAG_CLEAR | JSVAL_TYPE_SYMBOL,
     JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_CLEAR | JSVAL_TYPE_PRIVATE_GCTHING,
-#  ifdef ENABLE_BIGINT
     JSVAL_TAG_BIGINT = JSVAL_TAG_CLEAR | JSVAL_TYPE_BIGINT,
-#  endif
     JSVAL_TAG_OBJECT = JSVAL_TAG_CLEAR |
                        JSVAL_TYPE_OBJECT} JS_ENUM_FOOTER(JSValueTag);
 
 static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
               "compiler typed enum support is apparently buggy");
 
 #elif defined(JS_PUNBOX64)
 
@@ -104,19 +100,17 @@ JS_ENUM_HEADER(JSValueTag, uint32_t){
     JSVAL_TAG_UNDEFINED = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_UNDEFINED,
     JSVAL_TAG_NULL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_NULL,
     JSVAL_TAG_BOOLEAN = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BOOLEAN,
     JSVAL_TAG_MAGIC = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_MAGIC,
     JSVAL_TAG_STRING = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_STRING,
     JSVAL_TAG_SYMBOL = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_SYMBOL,
     JSVAL_TAG_PRIVATE_GCTHING = JSVAL_TAG_MAX_DOUBLE |
                                 JSVAL_TYPE_PRIVATE_GCTHING,
-#  ifdef ENABLE_BIGINT
     JSVAL_TAG_BIGINT = JSVAL_TAG_MAX_DOUBLE | JSVAL_TYPE_BIGINT,
-#  endif
     JSVAL_TAG_OBJECT = JSVAL_TAG_MAX_DOUBLE |
                        JSVAL_TYPE_OBJECT} JS_ENUM_FOOTER(JSValueTag);
 
 static_assert(sizeof(JSValueTag) == sizeof(uint32_t),
               "compiler typed enum support is apparently buggy");
 
 enum JSValueShiftedTag : uint64_t {
   JSVAL_SHIFTED_TAG_MAX_DOUBLE =
@@ -127,19 +121,17 @@ enum JSValueShiftedTag : uint64_t {
   JSVAL_SHIFTED_TAG_NULL = (((uint64_t)JSVAL_TAG_NULL) << JSVAL_TAG_SHIFT),
   JSVAL_SHIFTED_TAG_BOOLEAN =
       (((uint64_t)JSVAL_TAG_BOOLEAN) << JSVAL_TAG_SHIFT),
   JSVAL_SHIFTED_TAG_MAGIC = (((uint64_t)JSVAL_TAG_MAGIC) << JSVAL_TAG_SHIFT),
   JSVAL_SHIFTED_TAG_STRING = (((uint64_t)JSVAL_TAG_STRING) << JSVAL_TAG_SHIFT),
   JSVAL_SHIFTED_TAG_SYMBOL = (((uint64_t)JSVAL_TAG_SYMBOL) << JSVAL_TAG_SHIFT),
   JSVAL_SHIFTED_TAG_PRIVATE_GCTHING =
       (((uint64_t)JSVAL_TAG_PRIVATE_GCTHING) << JSVAL_TAG_SHIFT),
-#  ifdef ENABLE_BIGINT
   JSVAL_SHIFTED_TAG_BIGINT = (((uint64_t)JSVAL_TAG_BIGINT) << JSVAL_TAG_SHIFT),
-#  endif
   JSVAL_SHIFTED_TAG_OBJECT = (((uint64_t)JSVAL_TAG_OBJECT) << JSVAL_TAG_SHIFT)
 };
 
 static_assert(sizeof(JSValueShiftedTag) == sizeof(uint64_t),
               "compiler typed enum support is apparently buggy");
 
 #endif
 
@@ -352,19 +344,17 @@ union alignas(8) Value {
     JSValueTag tag_;
 #  endif  // MOZ_BIG_ENDIAN
     union {
       int32_t i32_;
       uint32_t u32_;
       uint32_t boo_;  // Don't use |bool| -- it must be four bytes.
       JSString* str_;
       JS::Symbol* sym_;
-#  ifdef ENABLE_BIGINT
       JS::BigInt* bi_;
-#  endif
       JSObject* obj_;
       js::gc::Cell* cell_;
       void* ptr_;
       JSWhyMagic why_;
     } payload_;
 #  if MOZ_LITTLE_ENDIAN
     JSValueTag tag_;
 #  endif  // MOZ_LITTLE_ENDIAN
@@ -453,22 +443,20 @@ union alignas(8) Value {
     asBits_ = bitsFromTagAndPayload(JSVAL_TAG_STRING, PayloadType(str));
   }
 
   void setSymbol(JS::Symbol* sym) {
     MOZ_ASSERT(js::gc::IsCellPointerValid(sym));
     asBits_ = bitsFromTagAndPayload(JSVAL_TAG_SYMBOL, PayloadType(sym));
   }
 
-#ifdef ENABLE_BIGINT
   void setBigInt(JS::BigInt* bi) {
     MOZ_ASSERT(js::gc::IsCellPointerValid(bi));
     asBits_ = bitsFromTagAndPayload(JSVAL_TAG_BIGINT, PayloadType(bi));
   }
-#endif
 
   void setObject(JSObject& obj) {
     MOZ_ASSERT(js::gc::IsCellPointerValid(&obj));
 
 #if defined(JS_PUNBOX64)
     // VisualStudio cannot contain parenthesized C++ style cast and shift
     // inside decltype in template parameter:
     //   AssertionConditionType<decltype((uintptr_t(x) >> 1))>
@@ -606,19 +594,17 @@ union alignas(8) Value {
     return asBits_ < JSVAL_UPPER_EXCL_SHIFTED_TAG_OF_NUMBER_SET;
 #endif
   }
 
   bool isString() const { return toTag() == JSVAL_TAG_STRING; }
 
   bool isSymbol() const { return toTag() == JSVAL_TAG_SYMBOL; }
 
-#ifdef ENABLE_BIGINT
   bool isBigInt() const { return toTag() == JSVAL_TAG_BIGINT; }
-#endif
 
   bool isObject() const {
 #if defined(JS_NUNBOX32)
     return toTag() == JSVAL_TAG_OBJECT;
 #elif defined(JS_PUNBOX64)
     MOZ_ASSERT((asBits_ >> JSVAL_TAG_SHIFT) <= JSVAL_TAG_OBJECT);
     return asBits_ >= JSVAL_SHIFTED_TAG_OBJECT;
 #endif
@@ -666,21 +652,19 @@ union alignas(8) Value {
                   "Value type tags must correspond with JS::TraceKinds.");
     static_assert((JSVAL_TAG_SYMBOL & 0x03) == size_t(JS::TraceKind::Symbol),
                   "Value type tags must correspond with JS::TraceKinds.");
     static_assert((JSVAL_TAG_OBJECT & 0x03) == size_t(JS::TraceKind::Object),
                   "Value type tags must correspond with JS::TraceKinds.");
     if (MOZ_UNLIKELY(isPrivateGCThing())) {
       return JS::GCThingTraceKind(toGCThing());
     }
-#ifdef ENABLE_BIGINT
     if (MOZ_UNLIKELY(isBigInt())) {
       return JS::TraceKind::BigInt;
     }
-#endif
     return JS::TraceKind(toTag() & 0x03);
   }
 
   JSWhyMagic whyMagic() const {
     MOZ_ASSERT(isMagic());
     return s_.payload_.why_;
   }
 
@@ -731,26 +715,24 @@ union alignas(8) Value {
     MOZ_ASSERT(isSymbol());
 #if defined(JS_NUNBOX32)
     return s_.payload_.sym_;
 #elif defined(JS_PUNBOX64)
     return reinterpret_cast<JS::Symbol*>(asBits_ ^ JSVAL_SHIFTED_TAG_SYMBOL);
 #endif
   }
 
-#ifdef ENABLE_BIGINT
   JS::BigInt* toBigInt() const {
     MOZ_ASSERT(isBigInt());
 #  if defined(JS_NUNBOX32)
     return s_.payload_.bi_;
 #  elif defined(JS_PUNBOX64)
     return reinterpret_cast<JS::BigInt*>(asBits_ ^ JSVAL_SHIFTED_TAG_BIGINT);
 #  endif
   }
-#endif
 
   JSObject& toObject() const {
     MOZ_ASSERT(isObject());
 #if defined(JS_NUNBOX32)
     return *s_.payload_.obj_;
 #elif defined(JS_PUNBOX64)
     uint64_t ptrBits = asBits_ ^ JSVAL_SHIFTED_TAG_OBJECT;
     MOZ_ASSERT(ptrBits);
@@ -856,21 +838,19 @@ union alignas(8) Value {
 
   void setPrivateGCThing(js::gc::Cell* cell) {
     MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::String,
                "Private GC thing Values must not be strings. Make a "
                "StringValue instead.");
     MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::Symbol,
                "Private GC thing Values must not be symbols. Make a "
                "SymbolValue instead.");
-#ifdef ENABLE_BIGINT
     MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::BigInt,
                "Private GC thing Values must not be BigInts. Make a "
                "BigIntValue instead.");
-#endif
     MOZ_ASSERT(JS::GCThingTraceKind(cell) != JS::TraceKind::Object,
                "Private GC thing Values must not be objects. Make an "
                "ObjectValue instead.");
 
     MOZ_ASSERT(js::gc::IsCellPointerValid(cell));
 #if defined(JS_PUNBOX64)
     // VisualStudio cannot contain parenthesized C++ style cast and shift
     // inside decltype in template parameter:
@@ -964,23 +944,21 @@ static inline Value StringValue(JSString
 }
 
 static inline Value SymbolValue(JS::Symbol* sym) {
   Value v;
   v.setSymbol(sym);
   return v;
 }
 
-#ifdef ENABLE_BIGINT
 static inline Value BigIntValue(JS::BigInt* bi) {
   Value v;
   v.setBigInt(bi);
   return v;
 }
-#endif
 
 static inline Value BooleanValue(bool boo) {
   Value v;
   v.setBoolean(boo);
   return v;
 }
 
 static inline Value TrueValue() {
@@ -1173,37 +1151,33 @@ class WrappedPtrOperations<JS::Value, Wr
   bool isTrue() const { return value().isTrue(); }
   bool isFalse() const { return value().isFalse(); }
   bool isNumber() const { return value().isNumber(); }
   bool isInt32() const { return value().isInt32(); }
   bool isInt32(int32_t i32) const { return value().isInt32(i32); }
   bool isDouble() const { return value().isDouble(); }
   bool isString() const { return value().isString(); }
   bool isSymbol() const { return value().isSymbol(); }
-#ifdef ENABLE_BIGINT
   bool isBigInt() const { return value().isBigInt(); }
-#endif
   bool isObject() const { return value().isObject(); }
   bool isMagic() const { return value().isMagic(); }
   bool isMagic(JSWhyMagic why) const { return value().isMagic(why); }
   bool isGCThing() const { return value().isGCThing(); }
   bool isPrimitive() const { return value().isPrimitive(); }
 
   bool isNullOrUndefined() const { return value().isNullOrUndefined(); }
   bool isObjectOrNull() const { return value().isObjectOrNull(); }
 
   bool toBoolean() const { return value().toBoolean(); }
   double toNumber() const { return value().toNumber(); }
   int32_t toInt32() const { return value().toInt32(); }
   double toDouble() const { return value().toDouble(); }
   JSString* toString() const { return value().toString(); }
   JS::Symbol* toSymbol() const { return value().toSymbol(); }
-#ifdef ENABLE_BIGINT
   JS::BigInt* toBigInt() const { return value().toBigInt(); }
-#endif
   JSObject& toObject() const { return value().toObject(); }
   JSObject* toObjectOrNull() const { return value().toObjectOrNull(); }
   gc::Cell* toGCThing() const { return value().toGCThing(); }
   JS::TraceKind traceKind() const { return value().traceKind(); }
   void* toPrivate() const { return value().toPrivate(); }
   uint32_t toPrivateUint32() const { return value().toPrivateUint32(); }
 
   uint64_t asRawBits() const { return value().asRawBits(); }
@@ -1233,19 +1207,17 @@ class MutableWrappedPtrOperations<JS::Va
   void setDouble(double d) { value().setDouble(d); }
   void setNaN() { setDouble(JS::GenericNaN()); }
   void setBoolean(bool b) { value().setBoolean(b); }
   void setMagic(JSWhyMagic why) { value().setMagic(why); }
   bool setNumber(uint32_t ui) { return value().setNumber(ui); }
   bool setNumber(double d) { return value().setNumber(d); }
   void setString(JSString* str) { this->value().setString(str); }
   void setSymbol(JS::Symbol* sym) { this->value().setSymbol(sym); }
-#ifdef ENABLE_BIGINT
   void setBigInt(JS::BigInt* bi) { this->value().setBigInt(bi); }
-#endif
   void setObject(JSObject& obj) { this->value().setObject(obj); }
   void setObjectOrNull(JSObject* arg) { this->value().setObjectOrNull(arg); }
   void setPrivate(void* ptr) { this->value().setPrivate(ptr); }
   void setPrivateUint32(uint32_t ui) { this->value().setPrivateUint32(ui); }
   void setPrivateGCThing(js::gc::Cell* cell) {
     this->value().setPrivateGCThing(cell);
   }
 };
@@ -1266,19 +1238,17 @@ class HeapBase<JS::Value, Wrapper>
   void setUndefined() { setBarriered(JS::UndefinedValue()); }
   void setInt32(int32_t i) { setBarriered(JS::Int32Value(i)); }
   void setDouble(double d) { setBarriered(JS::DoubleValue(d)); }
   void setNaN() { setDouble(JS::GenericNaN()); }
   void setBoolean(bool b) { setBarriered(JS::BooleanValue(b)); }
   void setMagic(JSWhyMagic why) { setBarriered(JS::MagicValue(why)); }
   void setString(JSString* str) { setBarriered(JS::StringValue(str)); }
   void setSymbol(JS::Symbol* sym) { setBarriered(JS::SymbolValue(sym)); }
-#ifdef ENABLE_BIGINT
   void setBigInt(JS::BigInt* bi) { setBarriered(JS::BigIntValue(bi)); }
-#endif
   void setObject(JSObject& obj) { setBarriered(JS::ObjectValue(obj)); }
   void setPrivateGCThing(js::gc::Cell* cell) {
     setBarriered(JS::PrivateGCThingValue(cell));
   }
 
   bool setNumber(uint32_t ui) {
     if (ui > JSVAL_INT_MAX) {
       setDouble((double)ui);
@@ -1324,23 +1294,21 @@ auto MapGCThingTyped(const JS::Value& va
     MOZ_ASSERT(gc::IsCellPointerValid(obj));
     return mozilla::Some(f(obj));
   }
   if (val.isSymbol()) {
     JS::Symbol* sym = val.toSymbol();
     MOZ_ASSERT(gc::IsCellPointerValid(sym));
     return mozilla::Some(f(sym));
   }
-#ifdef ENABLE_BIGINT
   if (val.isBigInt()) {
     JS::BigInt* bi = val.toBigInt();
     MOZ_ASSERT(gc::IsCellPointerValid(bi));
     return mozilla::Some(f(bi));
   }
-#endif
   if (MOZ_UNLIKELY(val.isPrivateGCThing())) {
     MOZ_ASSERT(gc::IsCellPointerValid(val.toGCThing()));
     return mozilla::Some(MapGCThingTyped(val.toGCCellPtr(), std::move(f)));
   }
   MOZ_ASSERT(!val.isGCThing());
   using ReturnType = decltype(f(static_cast<JSObject*>(nullptr)));
   return mozilla::Maybe<ReturnType>();
 }
--- a/js/src/NamespaceImports.h
+++ b/js/src/NamespaceImports.h
@@ -105,55 +105,47 @@ using JS::NativeImpl;
 
 using JS::Rooted;
 using JS::RootedFunction;
 using JS::RootedId;
 using JS::RootedObject;
 using JS::RootedScript;
 using JS::RootedString;
 using JS::RootedSymbol;
-#ifdef ENABLE_BIGINT
 using JS::RootedBigInt;
-#endif
 using JS::RootedValue;
 
 using JS::PersistentRooted;
 using JS::PersistentRootedFunction;
 using JS::PersistentRootedId;
 using JS::PersistentRootedObject;
 using JS::PersistentRootedScript;
 using JS::PersistentRootedString;
 using JS::PersistentRootedSymbol;
-#ifdef ENABLE_BIGINT
 using JS::PersistentRootedBigInt;
-#endif
 using JS::PersistentRootedValue;
 
 using JS::Handle;
 using JS::HandleFunction;
 using JS::HandleId;
 using JS::HandleObject;
 using JS::HandleScript;
 using JS::HandleString;
 using JS::HandleSymbol;
-#ifdef ENABLE_BIGINT
 using JS::HandleBigInt;
-#endif
 using JS::HandleValue;
 
 using JS::MutableHandle;
 using JS::MutableHandleFunction;
 using JS::MutableHandleId;
 using JS::MutableHandleObject;
 using JS::MutableHandleScript;
 using JS::MutableHandleString;
 using JS::MutableHandleSymbol;
-#ifdef ENABLE_BIGINT
 using JS::MutableHandleBigInt;
-#endif
 using JS::MutableHandleValue;
 
 using JS::FalseHandleValue;
 using JS::NullHandleValue;
 using JS::TrueHandleValue;
 using JS::UndefinedHandleValue;
 
 using JS::HandleValueArray;
@@ -163,15 +155,13 @@ using JS::PropertyResult;
 
 using JS::Compartment;
 using JS::Realm;
 using JS::Zone;
 
 using JS::Symbol;
 using JS::SymbolCode;
 
-#ifdef ENABLE_BIGINT
 using JS::BigInt;
-#endif
 
 } /* namespace js */
 
 #endif /* NamespaceImports_h */
--- a/js/src/builtin/Array.cpp
+++ b/js/src/builtin/Array.cpp
@@ -1307,17 +1307,17 @@ static bool ArrayJoinDenseKernel(JSConte
        * Object stringifying could modify the initialized length or make
        * the array sparse. Delegate it to a separate loop to keep this
        * one tight.
        *
        * Symbol stringifying is a TypeError, so into the slow path
        * with those as well.
        */
       break;
-    } else if (IF_BIGINT(elem.isBigInt(), false)) {
+    } else if (elem.isBigInt()) {
       // ToString(bigint) doesn't access bigint.toString or
       // anything like that, so it can't mutate the array we're
       // walking through, so it *could* be handled here. We don't
       // do so yet for reasons of initial-implementation economy.
       break;
     } else {
       MOZ_ASSERT(elem.isMagic(JS_ELEMENTS_HOLE) || elem.isNullOrUndefined());
     }
--- a/js/src/builtin/Boolean.cpp
+++ b/js/src/builtin/Boolean.cpp
@@ -11,19 +11,17 @@
 #include "builtin/Boolean-inl.h"
 
 #include "jsapi.h"
 #include "jstypes.h"
 
 #include "jit/InlinableNatives.h"
 #include "js/PropertySpec.h"
 #include "util/StringBuffer.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/GlobalObject.h"
 #include "vm/JSAtom.h"
 #include "vm/JSContext.h"
 #include "vm/JSObject.h"
 #include "vm/ProxyObject.h"
 
 #include "vm/BooleanObject-inl.h"
 
@@ -157,17 +155,15 @@ JSObject* js::InitBooleanClass(JSContext
 JSString* js::BooleanToString(JSContext* cx, bool b) {
   return b ? cx->names().true_ : cx->names().false_;
 }
 
 JS_PUBLIC_API bool js::ToBooleanSlow(HandleValue v) {
   if (v.isString()) {
     return v.toString()->length() != 0;
   }
-#ifdef ENABLE_BIGINT
   if (v.isBigInt()) {
     return !v.toBigInt()->isZero();
   }
-#endif
 
   MOZ_ASSERT(v.isObject());
   return !EmulatesUndefined(&v.toObject());
 }
--- a/js/src/builtin/JSON.cpp
+++ b/js/src/builtin/JSON.cpp
@@ -11,19 +11,17 @@
 #include "mozilla/Range.h"
 #include "mozilla/ScopeExit.h"
 
 #include "jsnum.h"
 #include "jstypes.h"
 #include "jsutil.h"
 
 #include "builtin/Array.h"
-#ifdef ENABLE_BIGINT
-#  include "builtin/BigInt.h"
-#endif
+#include "builtin/BigInt.h"
 #include "builtin/String.h"
 #include "js/PropertySpec.h"
 #include "js/StableStringChars.h"
 #include "util/StringBuffer.h"
 #include "vm/Interpreter.h"
 #include "vm/JSAtom.h"
 #include "vm/JSContext.h"
 #include "vm/JSObject.h"
@@ -286,17 +284,17 @@ static bool PreprocessValue(JSContext* c
   if (scx->maybeSafely) {
     return true;
   }
 
   RootedString keyStr(cx);
 
   // Step 2. Modified by BigInt spec 6.1 to check for a toJSON method on the
   // BigInt prototype when the value is a BigInt.
-  if (vp.isObject() || IF_BIGINT(vp.isBigInt(), false)) {
+  if (vp.isObject() || vp.isBigInt()) {
     RootedValue toJSON(cx);
     RootedObject obj(cx, JS::ToObject(cx, vp));
     if (!obj) {
       return false;
     }
 
     if (!GetProperty(cx, obj, obj, cx->names().toJSON, &toJSON)) {
       return false;
@@ -354,24 +352,21 @@ static bool PreprocessValue(JSContext* c
       if (!str) {
         return false;
       }
       vp.setString(str);
     } else if (cls == ESClass::Boolean) {
       if (!Unbox(cx, obj, vp)) {
         return false;
       }
-    }
-#ifdef ENABLE_BIGINT
-    else if (cls == ESClass::BigInt) {
+    } else if (cls == ESClass::BigInt) {
       if (!Unbox(cx, obj, vp)) {
         return false;
       }
     }
-#endif
   }
 
   return true;
 }
 
 /*
  * Determines whether a value which has passed by ES5 150.2.3 Str steps 1-4's
  * gauntlet will result in Str returning |undefined|.  This function is used to
@@ -676,24 +671,22 @@ static bool Str(JSContext* cx, const Val
                    "reachable non-finite numbers");
         return scx->sb.append("null");
       }
     }
 
     return NumberValueToStringBuffer(cx, v, scx->sb);
   }
 
-#ifdef ENABLE_BIGINT
   /* Step 10 in the BigInt proposal. */
   if (v.isBigInt()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_BIGINT_NOT_SERIALIZABLE);
     return false;
   }
-#endif
 
   /* Step 10. */
   MOZ_ASSERT(v.isObject());
   RootedObject obj(cx, &v.toObject());
 
   MOZ_ASSERT(
       !scx->maybeSafely || obj->is<PlainObject>() || obj->is<ArrayObject>(),
       "input to JS::ToJSONMaybeSafely must not include reachable "
--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -54,17 +54,17 @@ bool HashableValue::setValue(JSContext* 
       value = v;
     }
   } else {
     value = v;
   }
 
   MOZ_ASSERT(value.isUndefined() || value.isNull() || value.isBoolean() ||
              value.isNumber() || value.isString() || value.isSymbol() ||
-             value.isObject() || IF_BIGINT(value.isBigInt(), false));
+             value.isObject() || value.isBigInt());
   return true;
 }
 
 static HashNumber HashValue(const Value& v,
                             const mozilla::HashCodeScrambler& hcs) {
   // HashableValue::setValue normalizes values so that the SameValue relation
   // on HashableValues is the same as the == relationship on
   // value.asRawBits(). So why not just return that? Security.
@@ -75,48 +75,44 @@ static HashNumber HashValue(const Value&
   // HashCodeScrambler.
 
   if (v.isString()) {
     return v.toString()->asAtom().hash();
   }
   if (v.isSymbol()) {
     return v.toSymbol()->hash();
   }
-#ifdef ENABLE_BIGINT
   if (v.isBigInt()) {
     return v.toBigInt()->hash();
   }
-#endif
   if (v.isObject()) {
     return hcs.scramble(v.asRawBits());
   }
 
   MOZ_ASSERT(!v.isGCThing(), "do not reveal pointers via hash codes");
   return mozilla::HashGeneric(v.asRawBits());
 }
 
 HashNumber HashableValue::hash(const mozilla::HashCodeScrambler& hcs) const {
   return HashValue(value, hcs);
 }
 
 bool HashableValue::operator==(const HashableValue& other) const {
   // Two HashableValues are equal if they have equal bits.
   bool b = (value.asRawBits() == other.value.asRawBits());
 
-#ifdef ENABLE_BIGINT
   // BigInt values are considered equal if they represent the same
   // integer. This test should use a comparison function that doesn't
   // require a JSContext once one is defined in the BigInt class.
   if (!b && (value.isBigInt() && other.value.isBigInt())) {
     JSContext* cx = TlsContext.get();
     RootedValue valueRoot(cx, value);
     RootedValue otherRoot(cx, other.value);
     SameValue(cx, valueRoot, otherRoot, &b);
   }
-#endif
 
 #ifdef DEBUG
   bool same;
   JSContext* cx = TlsContext.get();
   RootedValue valueRoot(cx, value);
   RootedValue otherRoot(cx, other.value);
   MOZ_ASSERT(SameValue(cx, valueRoot, otherRoot, &same));
   MOZ_ASSERT(same == b);
--- a/js/src/builtin/Object.cpp
+++ b/js/src/builtin/Object.cpp
@@ -3,19 +3,17 @@
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "builtin/Object.h"
 
 #include "mozilla/MaybeOneOf.h"
 
-#ifdef ENABLE_BIGINT
-#  include "builtin/BigInt.h"
-#endif
+#include "builtin/BigInt.h"
 #include "builtin/Eval.h"
 #include "builtin/SelfHostingDefines.h"
 #include "builtin/String.h"
 #include "frontend/BytecodeCompiler.h"
 #include "jit/InlinableNatives.h"
 #include "js/PropertySpec.h"
 #include "js/UniquePtr.h"
 #include "util/StringBuffer.h"
--- a/js/src/builtin/ReflectParse.cpp
+++ b/js/src/builtin/ReflectParse.cpp
@@ -16,19 +16,17 @@
 
 #include "builtin/Array.h"
 #include "builtin/Reflect.h"
 #include "frontend/ModuleSharedContext.h"
 #include "frontend/ParseNode.h"
 #include "frontend/Parser.h"
 #include "js/CharacterEncoding.h"
 #include "js/StableStringChars.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/JSAtom.h"
 #include "vm/JSObject.h"
 #include "vm/RegExpObject.h"
 
 #include "vm/JSObject-inl.h"
 
 using namespace js;
 using namespace js::frontend;
@@ -2945,19 +2943,17 @@ bool ASTSerializer::expression(ParseNode
 
       return builder.templateLiteral(elts, &list->pn_pos, dst);
     }
 
     case ParseNodeKind::TemplateStringExpr:
     case ParseNodeKind::StringExpr:
     case ParseNodeKind::RegExpExpr:
     case ParseNodeKind::NumberExpr:
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr:
-#endif
     case ParseNodeKind::TrueExpr:
     case ParseNodeKind::FalseExpr:
     case ParseNodeKind::NullExpr:
     case ParseNodeKind::RawUndefinedExpr:
       return literal(pn, dst);
 
     case ParseNodeKind::YieldStarExpr: {
       UnaryNode* yieldNode = &pn->as<UnaryNode>();
@@ -3120,24 +3116,22 @@ bool ASTSerializer::literal(ParseNode* p
       val.setObject(*re2);
       break;
     }
 
     case ParseNodeKind::NumberExpr:
       val.setNumber(pn->as<NumericLiteral>().value());
       break;
 
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr: {
       BigInt* x = pn->as<BigIntLiteral>().box()->value();
       cx->check(x);
       val.setBigInt(x);
       break;
     }
-#endif
 
     case ParseNodeKind::NullExpr:
       val.setNull();
       break;
 
     case ParseNodeKind::RawUndefinedExpr:
       val.setUndefined();
       break;
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -1056,22 +1056,20 @@ restart:
       *answer = false;
       return true;
 
     case ParseNodeKind::NumberExpr:
       MOZ_ASSERT(pn->is<NumericLiteral>());
       *answer = false;
       return true;
 
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr:
       MOZ_ASSERT(pn->is<BigIntLiteral>());
       *answer = false;
       return true;
-#endif
 
     // |this| can throw in derived class constructors, including nested arrow
     // functions or eval.
     case ParseNodeKind::ThisExpr:
       MOZ_ASSERT(pn->is<UnaryNode>());
       *answer = sc->needsThisTDZChecks();
       return true;
 
@@ -4389,21 +4387,19 @@ bool ParseNode::getConstantValue(JSConte
                                  MutableHandleValue vp, Value* compare,
                                  size_t ncompare, NewObjectKind newKind) {
   MOZ_ASSERT(newKind == TenuredObject || newKind == SingletonObject);
 
   switch (getKind()) {
     case ParseNodeKind::NumberExpr:
       vp.setNumber(as<NumericLiteral>().value());
       return true;
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr:
       vp.setBigInt(as<BigIntLiteral>().box()->value());
       return true;
-#endif
     case ParseNodeKind::TemplateStringExpr:
     case ParseNodeKind::StringExpr:
       vp.setString(as<NameNode>().atom());
       return true;
     case ParseNodeKind::TrueExpr:
       vp.setBoolean(true);
       return true;
     case ParseNodeKind::FalseExpr:
@@ -4972,24 +4968,22 @@ bool BytecodeEmitter::emitCopyDataProper
     //              [stack]
     return false;
   }
 
   MOZ_ASSERT(depth - int(argc) == this->stackDepth);
   return true;
 }
 
-#ifdef ENABLE_BIGINT
 bool BytecodeEmitter::emitBigIntOp(BigInt* bigint) {
   if (!numberList.append(BigIntValue(bigint))) {
     return false;
   }
   return emitIndex32(JSOP_BIGINT, numberList.length() - 1);
 }
-#endif
 
 bool BytecodeEmitter::emitIterator() {
   // Convert iterable to iterator.
   if (!emit1(JSOP_DUP)) {
     //              [stack] OBJ OBJ
     return false;
   }
   if (!emit2(JSOP_SYMBOL, uint8_t(JS::SymbolCode::iterator))) {
@@ -9239,23 +9233,21 @@ bool BytecodeEmitter::emitTree(
       break;
 
     case ParseNodeKind::NumberExpr:
       if (!emitNumberOp(pn->as<NumericLiteral>().value())) {
         return false;
       }
       break;
 
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr:
       if (!emitBigIntOp(pn->as<BigIntLiteral>().box()->value())) {
         return false;
       }
       break;
-#endif
 
     case ParseNodeKind::RegExpExpr:
       if (!emitRegExp(objectList.add(pn->as<RegExpLiteral>().objbox()))) {
         return false;
       }
       break;
 
     case ParseNodeKind::TrueExpr:
--- a/js/src/frontend/BytecodeEmitter.h
+++ b/js/src/frontend/BytecodeEmitter.h
@@ -535,19 +535,17 @@ struct MOZ_STACK_CLASS BytecodeEmitter {
   // Emit a bytecode followed by an uint32 immediate operand.
   MOZ_MUST_USE bool emitUint32Operand(JSOp op, uint32_t operand);
 
   // Emit (1 + extra) bytecodes, for N bytes of op and its immediate operand.
   MOZ_MUST_USE bool emitN(JSOp op, size_t extra, ptrdiff_t* offset = nullptr);
 
   MOZ_MUST_USE bool emitNumberOp(double dval);
 
-#ifdef ENABLE_BIGINT
   MOZ_MUST_USE bool emitBigIntOp(BigInt* bigint);
-#endif
 
   MOZ_MUST_USE bool emitThisLiteral(ThisLiteral* pn);
   MOZ_MUST_USE bool emitGetFunctionThis(NameNode* thisName);
   MOZ_MUST_USE bool emitGetFunctionThis(const mozilla::Maybe<uint32_t>& offset);
   MOZ_MUST_USE bool emitGetThisForSuperBase(UnaryNode* superBase);
   MOZ_MUST_USE bool emitSetThis(BinaryNode* setThisNode);
   MOZ_MUST_USE bool emitCheckDerivedClassConstructorReturn();
 
--- a/js/src/frontend/FoldConstants.cpp
+++ b/js/src/frontend/FoldConstants.cpp
@@ -393,19 +393,17 @@ restart:
     case ParseNodeKind::RegExpExpr:
     case ParseNodeKind::TrueExpr:
     case ParseNodeKind::FalseExpr:
     case ParseNodeKind::NullExpr:
     case ParseNodeKind::RawUndefinedExpr:
     case ParseNodeKind::ThisExpr:
     case ParseNodeKind::Elision:
     case ParseNodeKind::NumberExpr:
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr:
-#endif
     case ParseNodeKind::NewExpr:
     case ParseNodeKind::Generator:
     case ParseNodeKind::ParamsBody:
     case ParseNodeKind::Catch:
     case ParseNodeKind::ForIn:
     case ParseNodeKind::ForOf:
     case ParseNodeKind::ForHead:
     case ParseNodeKind::ClassMethod:
@@ -477,39 +475,35 @@ static bool FoldType(JSContext* cx, Full
 }
 
 static bool IsEffectless(ParseNode* node) {
   return node->isKind(ParseNodeKind::TrueExpr) ||
          node->isKind(ParseNodeKind::FalseExpr) ||
          node->isKind(ParseNodeKind::StringExpr) ||
          node->isKind(ParseNodeKind::TemplateStringExpr) ||
          node->isKind(ParseNodeKind::NumberExpr) ||
-#ifdef ENABLE_BIGINT
          node->isKind(ParseNodeKind::BigIntExpr) ||
-#endif
          node->isKind(ParseNodeKind::NullExpr) ||
          node->isKind(ParseNodeKind::RawUndefinedExpr) ||
          node->isKind(ParseNodeKind::Function);
 }
 
 enum Truthiness { Truthy, Falsy, Unknown };
 
 static Truthiness Boolish(ParseNode* pn) {
   switch (pn->getKind()) {
     case ParseNodeKind::NumberExpr:
       return (pn->as<NumericLiteral>().value() != 0 &&
               !IsNaN(pn->as<NumericLiteral>().value()))
                  ? Truthy
                  : Falsy;
 
-#ifdef ENABLE_BIGINT
     case ParseNodeKind::BigIntExpr:
       return (pn->as<BigIntLiteral>().box()->value()->isZero()) ? Falsy
                                                                 : Truthy;
-#endif
 
     case ParseNodeKind::StringExpr:
     case ParseNodeKind::TemplateStringExpr:
       return (pn->as<NameNode>().atom()->length() > 0) ? Truthy : Falsy;
 
     case ParseNodeKind::TrueExpr:
     case ParseNodeKind::Function:
       return Truthy;
@@ -569,23 +563,19 @@ static bool FoldTypeOfExpr(JSContext* cx
 
   // Constant-fold the entire |typeof| if given a constant with known type.
   RootedPropertyName result(cx);
   if (expr->isKind(ParseNodeKind::StringExpr) ||
       expr->isKind(ParseNodeKind::TemplateStringExpr)) {
     result = cx->names().string;
   } else if (expr->isKind(ParseNodeKind::NumberExpr)) {
     result = cx->names().number;
-  }
-#ifdef ENABLE_BIGINT
-  else if (expr->isKind(ParseNodeKind::BigIntExpr)) {
+  } else if (expr->isKind(ParseNodeKind::BigIntExpr)) {
     result = cx->names().bigint;
-  }
-#endif
-  else if (expr->isKind(ParseNodeKind::NullExpr)) {
+  } else if (expr->isKind(ParseNodeKind::NullExpr)) {
     result = cx->names().object;
   } else if (expr->isKind(ParseNodeKind::TrueExpr) ||
              expr->isKind(ParseNodeKind::FalseExpr)) {
     result = cx->names().boolean;
   } else if (expr->is<FunctionNode>()) {
     result = cx->names().function;
   }
 
--- a/js/src/frontend/FullParseHandler.h
+++ b/js/src/frontend/FullParseHandler.h
@@ -125,29 +125,27 @@ class FullParseHandler {
                           pos);
   }
 
   NumericLiteralType newNumber(double value, DecimalPoint decimalPoint,
                                const TokenPos& pos) {
     return new_<NumericLiteral>(value, decimalPoint, pos);
   }
 
-#ifdef ENABLE_BIGINT
   // The Boxer object here is any object that can allocate BigIntBoxes.
   // Specifically, a Boxer has a .newBigIntBox(T) method that accepts a
   // BigInt* argument and returns a BigIntBox*.
   template <class Boxer>
   BigIntLiteralType newBigInt(BigInt* bi, const TokenPos& pos, Boxer& boxer) {
     BigIntBox* box = boxer.newBigIntBox(bi);
     if (!box) {
       return null();
     }
     return new_<BigIntLiteral>(box, pos);
   }
-#endif
 
   BooleanLiteralType newBooleanLiteral(bool cond, const TokenPos& pos) {
     return new_<BooleanLiteral>(cond, pos);
   }
 
   NameNodeType newStringLiteral(JSAtom* atom, const TokenPos& pos) {
     return new_<NameNode>(ParseNodeKind::StringExpr, JSOP_NOP, atom, pos);
   }
--- a/js/src/frontend/NameFunctions.cpp
+++ b/js/src/frontend/NameFunctions.cpp
@@ -459,21 +459,19 @@ class NameResolver {
       case ParseNodeKind::RegExpExpr:
         MOZ_ASSERT(cur->is<RegExpLiteral>());
         break;
 
       case ParseNodeKind::NumberExpr:
         MOZ_ASSERT(cur->is<NumericLiteral>());
         break;
 
-#ifdef ENABLE_BIGINT
       case ParseNodeKind::BigIntExpr:
         MOZ_ASSERT(cur->is<BigIntLiteral>());
         break;
-#endif
 
       case ParseNodeKind::TypeOfNameExpr:
       case ParseNodeKind::SuperBase:
         MOZ_ASSERT(cur->as<UnaryNode>().kid()->isKind(ParseNodeKind::Name));
         MOZ_ASSERT(!cur->as<UnaryNode>().kid()->as<NameNode>().initializer());
         break;
 
       case ParseNodeKind::NewTargetExpr:
--- a/js/src/frontend/ParseNode.cpp
+++ b/js/src/frontend/ParseNode.cpp
@@ -164,21 +164,19 @@ void ParseNode::dump(GenericPrinter& out
       as<NameNode>().dump(out, indent);
       return;
     case PN_FIELD:
       as<ClassField>().dump(out, indent);
       return;
     case PN_NUMBER:
       as<NumericLiteral>().dump(out, indent);
       return;
-#  ifdef ENABLE_BIGINT
     case PN_BIGINT:
       as<BigIntLiteral>().dump(out, indent);
       return;
-#  endif
     case PN_REGEXP:
       as<RegExpLiteral>().dump(out, indent);
       return;
     case PN_LOOP:
       as<LoopControlStatement>().dump(out, indent);
       return;
     case PN_SCOPE:
       as<LexicalScopeNode>().dump(out, indent);
@@ -215,21 +213,19 @@ void NumericLiteral::dump(GenericPrinter
   }
   if (cstr) {
     out.printf("%s", cstr);
   } else {
     out.printf("%g", value());
   }
 }
 
-#  ifdef ENABLE_BIGINT
 void BigIntLiteral::dump(GenericPrinter& out, int indent) {
   out.printf("(%s)", parseNodeNames[size_t(getKind())]);
 }
-#  endif
 
 void RegExpLiteral::dump(GenericPrinter& out, int indent) {
   out.printf("(%s)", parseNodeNames[size_t(getKind())]);
 }
 
 void LoopControlStatement::dump(GenericPrinter& out, int indent) {
   const char* name = parseNodeNames[size_t(getKind())];
   out.printf("(%s", name);
@@ -427,32 +423,28 @@ void LexicalScopeNode::dump(GenericPrint
 }
 #endif
 
 TraceListNode::TraceListNode(js::gc::Cell* gcThing, TraceListNode* traceLink)
     : gcThing(gcThing), traceLink(traceLink) {
   MOZ_ASSERT(gcThing->isTenured());
 }
 
-#ifdef ENABLE_BIGINT
 BigIntBox* TraceListNode::asBigIntBox() {
   MOZ_ASSERT(isBigIntBox());
   return static_cast<BigIntBox*>(this);
 }
-#endif
 
 ObjectBox* TraceListNode::asObjectBox() {
   MOZ_ASSERT(isObjectBox());
   return static_cast<ObjectBox*>(this);
 }
 
-#ifdef ENABLE_BIGINT
 BigIntBox::BigIntBox(BigInt* bi, TraceListNode* traceLink)
     : TraceListNode(bi, traceLink) {}
-#endif
 
 ObjectBox::ObjectBox(JSObject* obj, TraceListNode* traceLink)
     : TraceListNode(obj, traceLink), emitLink(nullptr) {
   MOZ_ASSERT(!object()->is<JSFunction>());
 }
 
 ObjectBox::ObjectBox(JSFunction* function, TraceListNode* traceLink)
     : TraceListNode(function, traceLink), emitLink(nullptr) {
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -5,19 +5,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #ifndef frontend_ParseNode_h
 #define frontend_ParseNode_h
 
 #include "mozilla/Attributes.h"
 
 #include "frontend/TokenStream.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/BytecodeUtil.h"
 #include "vm/Printer.h"
 #include "vm/Scope.h"
 
 /* clang-format off */
 //
 // A few notes on lifetime of ParseNode trees:
 //
@@ -43,19 +41,17 @@
 
 namespace js {
 namespace frontend {
 
 class ParseContext;
 class FullParseHandler;
 class FunctionBox;
 class ObjectBox;
-#ifdef ENABLE_BIGINT
 class BigIntBox;
-#endif
 
 #define FOR_EACH_PARSE_NODE_KIND(F)                                          \
   F(EmptyStmt, NullaryNode)                                                  \
   F(ExpressionStmt, UnaryNode)                                               \
   F(CommaExpr, ListNode)                                                     \
   F(ConditionalExpr, ConditionalExpression)                                  \
   F(Colon, BinaryNode)                                                       \
   F(Shorthand, BinaryNode)                                                   \
@@ -75,17 +71,17 @@ class BigIntBox;
   F(ObjectExpr, ListNode)                                                    \
   F(CallExpr, BinaryNode)                                                    \
   F(Arguments, ListNode)                                                     \
   F(Name, NameNode)                                                          \
   F(ObjectPropertyName, NameNode)                                            \
   F(PrivateName, NameNode)                                                   \
   F(ComputedName, UnaryNode)                                                 \
   F(NumberExpr, NumericLiteral)                                              \
-  IF_BIGINT(F(BigIntExpr, BigIntLiteral), /**/)                              \
+  F(BigIntExpr, BigIntLiteral)                                               \
   F(StringExpr, NameNode)                                                    \
   F(TemplateStringListExpr, ListNode)                                        \
   F(TemplateStringExpr, NameNode)                                            \
   F(TaggedTemplateExpr, BinaryNode)                                          \
   F(CallSiteObjExpr, CallSiteNode)                                           \
   F(RegExpExpr, RegExpLiteral)                                               \
   F(TrueExpr, BooleanLiteral)                                                \
   F(FalseExpr, BooleanLiteral)                                               \
@@ -530,22 +526,20 @@ enum ParseNodeArity {
   PN_BINARY,   /* two kids, plus a couple of scalars */
   PN_TERNARY,  /* three kids */
   PN_FUNCTION, /* function definition node */
   PN_MODULE,   /* module node */
   PN_LIST,     /* generic singly linked list */
   PN_NAME,     /* name, label, string */
   PN_FIELD,    /* field name, optional initializer */
   PN_NUMBER,   /* numeric literal */
-#ifdef ENABLE_BIGINT
-  PN_BIGINT, /* BigInt literal */
-#endif
-  PN_REGEXP, /* regexp literal */
-  PN_LOOP,   /* loop control (break/continue) */
-  PN_SCOPE   /* lexical scope */
+  PN_BIGINT,   /* BigInt literal */
+  PN_REGEXP,   /* regexp literal */
+  PN_LOOP,     /* loop control (break/continue) */
+  PN_SCOPE     /* lexical scope */
 };
 
 // FIXME: Remove `*Type` (bug 1489008)
 #define FOR_EACH_PARSENODE_SUBCLASS(MACRO)                                   \
   MACRO(BinaryNode, BinaryNodeType, asBinary)                                \
   MACRO(AssignmentNode, AssignmentNodeType, asAssignment)                    \
   MACRO(CaseClause, CaseClauseType, asCaseClause)                            \
   MACRO(ClassMethod, ClassMethodType, asClassMethod)                         \
@@ -574,17 +568,17 @@ enum ParseNodeArity {
                                                                              \
   MACRO(NullaryNode, NullaryNodeType, asNullary)                             \
   MACRO(BooleanLiteral, BooleanLiteralType, asBooleanLiteral)                \
   MACRO(DebuggerStatement, DebuggerStatementType, asDebuggerStatement)       \
   MACRO(NullLiteral, NullLiteralType, asNullLiteral)                         \
   MACRO(RawUndefinedLiteral, RawUndefinedLiteralType, asRawUndefinedLiteral) \
                                                                              \
   MACRO(NumericLiteral, NumericLiteralType, asNumericLiteral)                \
-  IF_BIGINT(MACRO(BigIntLiteral, BigIntLiteralType, asBigIntLiteral), )      \
+  MACRO(BigIntLiteral, BigIntLiteralType, asBigIntLiteral)                   \
                                                                              \
   MACRO(RegExpLiteral, RegExpLiteralType, asRegExpLiteral)                   \
                                                                              \
   MACRO(TernaryNode, TernaryNodeType, asTernary)                             \
   MACRO(ClassNode, ClassNodeType, asClass)                                   \
   MACRO(ConditionalExpression, ConditionalExpressionType,                    \
         asConditionalExpression)                                             \
   MACRO(TryNode, TryNodeType, asTry)                                         \
@@ -703,19 +697,17 @@ class ParseNode {
   static ParseNode* appendOrCreateList(ParseNodeKind kind, ParseNode* left,
                                        ParseNode* right,
                                        FullParseHandler* handler,
                                        ParseContext* pc);
 
   /* True if pn is a parsenode representing a literal constant. */
   bool isLiteral() const {
     return isKind(ParseNodeKind::NumberExpr) ||
-#ifdef ENABLE_BIGINT
            isKind(ParseNodeKind::BigIntExpr) ||
-#endif
            isKind(ParseNodeKind::StringExpr) ||
            isKind(ParseNodeKind::TrueExpr) ||
            isKind(ParseNodeKind::FalseExpr) ||
            isKind(ParseNodeKind::NullExpr) ||
            isKind(ParseNodeKind::RawUndefinedExpr);
   }
 
   // True iff this is a for-in/of loop variable declaration (var/let/const).
@@ -1526,17 +1518,16 @@ class NumericLiteral : public ParseNode 
 
   DecimalPoint decimalPoint() const { return decimalPoint_; }
 
   void setValue(double v) { value_ = v; }
 
   void setDecimalPoint(DecimalPoint d) { decimalPoint_ = d; }
 };
 
-#ifdef ENABLE_BIGINT
 class BigIntLiteral : public ParseNode {
   BigIntBox* box_;
 
  public:
   BigIntLiteral(BigIntBox* bibox, const TokenPos& pos)
       : ParseNode(ParseNodeKind::BigIntExpr, JSOP_NOP, pos), box_(bibox) {}
 
   static bool test(const ParseNode& node) {
@@ -1553,17 +1544,16 @@ class BigIntLiteral : public ParseNode {
   }
 
 #  ifdef DEBUG
   void dump(GenericPrinter& out, int indent);
 #  endif
 
   BigIntBox* box() const { return box_; }
 };
-#endif
 
 class LexicalScopeNode : public ParseNode {
   LexicalScope::Data* bindings;
   ParseNode* body;
 
  public:
   LexicalScopeNode(LexicalScope::Data* bindings, ParseNode* body)
       : ParseNode(ParseNodeKind::LexicalScope, JSOP_NOP, body->pn_pos),
@@ -2159,39 +2149,33 @@ inline bool ParseNode::isConstant() {
 
 class TraceListNode {
  protected:
   js::gc::Cell* gcThing;
   TraceListNode* traceLink;
 
   TraceListNode(js::gc::Cell* gcThing, TraceListNode* traceLink);
 
-#ifdef ENABLE_BIGINT
   bool isBigIntBox() const { return gcThing->is<BigInt>(); }
-#endif
   bool isObjectBox() const { return gcThing->is<JSObject>(); }
 
-#ifdef ENABLE_BIGINT
   BigIntBox* asBigIntBox();
-#endif
   ObjectBox* asObjectBox();
 
   virtual void trace(JSTracer* trc);
 
  public:
   static void TraceList(JSTracer* trc, TraceListNode* listHead);
 };
 
-#ifdef ENABLE_BIGINT
 class BigIntBox : public TraceListNode {
  public:
   BigIntBox(BigInt* bi, TraceListNode* link);
   BigInt* value() const { return gcThing->as<BigInt>(); }
 };
-#endif
 
 class ObjectBox : public TraceListNode {
  protected:
   friend struct CGObjectList;
   ObjectBox* emitLink;
 
   ObjectBox(JSFunction* function, TraceListNode* link);
 
--- a/js/src/frontend/Parser.cpp
+++ b/js/src/frontend/Parser.cpp
@@ -270,21 +270,19 @@ BoxT* ParserBase::newTraceListNode(ArgT*
 
   return box;
 }
 
 ObjectBox* ParserBase::newObjectBox(JSObject* obj) {
   return newTraceListNode<ObjectBox, JSObject>(obj);
 }
 
-#ifdef ENABLE_BIGINT
 BigIntBox* ParserBase::newBigIntBox(BigInt* val) {
   return newTraceListNode<BigIntBox, BigInt>(val);
 }
-#endif
 
 template <class ParseHandler>
 FunctionBox* PerHandlerParser<ParseHandler>::newFunctionBox(
     FunctionNodeType funNode, JSFunction* fun, uint32_t toStringStart,
     Directives inheritedDirectives, GeneratorKind generatorKind,
     FunctionAsyncKind asyncKind) {
   MOZ_ASSERT(fun);
 
@@ -9015,17 +9013,16 @@ Parser<SyntaxParseHandler, Unit>::newReg
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::RegExpLiteralType
 GeneralParser<ParseHandler, Unit>::newRegExp() {
   return asFinalParser()->newRegExp();
 }
 
-#ifdef ENABLE_BIGINT
 template <typename Unit>
 BigIntLiteral* Parser<FullParseHandler, Unit>::newBigInt() {
   // The token's charBuffer contains the DecimalIntegerLiteral or
   // NumericLiteralBase production, and as such does not include the
   // BigIntLiteralSuffix (the trailing "n").  Note that NumericLiteralBase
   // productions may start with 0[bBoOxX], indicating binary/octal/hex.
   const auto& chars = tokenStream.getCharBuffer();
   mozilla::Range<const char16_t> source(chars.begin(), chars.length());
@@ -9049,17 +9046,16 @@ Parser<SyntaxParseHandler, Unit>::newBig
   return handler.newBigInt();
 }
 
 template <class ParseHandler, typename Unit>
 typename ParseHandler::BigIntLiteralType
 GeneralParser<ParseHandler, Unit>::newBigInt() {
   return asFinalParser()->newBigInt();
 }
-#endif /* ENABLE_BIGINT */
 
 // |exprPossibleError| is the PossibleError state within |expr|,
 // |possibleError| is the surrounding PossibleError state.
 template <class ParseHandler, typename Unit>
 bool GeneralParser<ParseHandler, Unit>::checkDestructuringAssignmentTarget(
     Node expr, TokenPos exprPos, PossibleError* exprPossibleError,
     PossibleError* possibleError, TargetBehavior behavior) {
   // Report any pending expression error if we're definitely not in a
@@ -10075,20 +10071,18 @@ typename ParseHandler::Node GeneralParse
     }
 
     case TokenKind::RegExp:
       return newRegExp();
 
     case TokenKind::Number:
       return newNumber(anyChars.currentToken());
 
-#ifdef ENABLE_BIGINT
     case TokenKind::BigInt:
       return newBigInt();
-#endif
 
     case TokenKind::True:
       return handler.newBooleanLiteral(true, pos());
     case TokenKind::False:
       return handler.newBooleanLiteral(false, pos());
     case TokenKind::This: {
       if (pc->isFunctionBox()) {
         pc->functionBox()->usesThis = true;
--- a/js/src/frontend/Parser.h
+++ b/js/src/frontend/Parser.h
@@ -394,19 +394,17 @@ class MOZ_STACK_CLASS ParserBase : priva
   }
 
  private:
   template <typename BoxT, typename ArgT>
   BoxT* newTraceListNode(ArgT* arg);
 
  public:
   ObjectBox* newObjectBox(JSObject* obj);
-#ifdef ENABLE_BIGINT
   BigIntBox* newBigIntBox(BigInt* val);
-#endif
 
   mozilla::Maybe<GlobalScope::Data*> newGlobalScopeData(
       ParseContext::Scope& scope);
   mozilla::Maybe<ModuleScope::Data*> newModuleScopeData(
       ParseContext::Scope& scope);
   mozilla::Maybe<EvalScope::Data*> newEvalScopeData(ParseContext::Scope& scope);
   mozilla::Maybe<FunctionScope::Data*> newFunctionScopeData(
       ParseContext::Scope& scope, bool hasParameterExprs);
@@ -1380,19 +1378,17 @@ class MOZ_STACK_CLASS GeneralParser : pu
   bool checkDestructuringAssignmentElement(Node expr, TokenPos exprPos,
                                            PossibleError* exprPossibleError,
                                            PossibleError* possibleError);
 
   NumericLiteralType newNumber(const Token& tok) {
     return handler.newNumber(tok.number(), tok.decimalPoint(), tok.pos);
   }
 
-#ifdef ENABLE_BIGINT
   inline BigIntLiteralType newBigInt();
-#endif
 
  protected:
   // Match the current token against the BindingIdentifier production with
   // the given Yield parameter.  If there is no match, report a syntax
   // error.
   PropertyName* bindingIdentifier(YieldHandling yieldHandling);
 
   bool checkLabelOrIdentifierReference(PropertyName* ident, uint32_t offset,
@@ -1525,19 +1521,17 @@ class MOZ_STACK_CLASS Parser<SyntaxParse
   }
 
   // Functions present in both Parser<ParseHandler, Unit> specializations.
 
   inline void setAwaitHandling(AwaitHandling awaitHandling);
   inline void setInParametersOfAsyncFunction(bool inParameters);
 
   RegExpLiteralType newRegExp();
-#ifdef ENABLE_BIGINT
   BigIntLiteralType newBigInt();
-#endif
 
   // Parse a module.
   ModuleNodeType moduleBody(ModuleSharedContext* modulesc);
 
   inline BinaryNodeType importDeclaration();
   inline bool checkLocalExportNames(ListNodeType node);
   inline bool checkExportedName(JSAtom* exportName);
   inline bool checkExportedNamesForArrayBinding(ListNodeType array);
@@ -1680,19 +1674,17 @@ class MOZ_STACK_CLASS Parser<FullParseHa
 
   friend class AutoAwaitIsKeyword<SyntaxParseHandler, Unit>;
   inline void setAwaitHandling(AwaitHandling awaitHandling);
 
   friend class AutoInParametersOfAsyncFunction<SyntaxParseHandler, Unit>;
   inline void setInParametersOfAsyncFunction(bool inParameters);
 
   RegExpLiteralType newRegExp();
-#ifdef ENABLE_BIGINT
   BigIntLiteralType newBigInt();
-#endif
 
   // Parse a module.
   ModuleNodeType moduleBody(ModuleSharedContext* modulesc);
 
   BinaryNodeType importDeclaration();
   bool checkLocalExportNames(ListNodeType node);
   bool checkExportedName(JSAtom* exportName);
   bool checkExportedNamesForArrayBinding(ListNodeType array);
--- a/js/src/frontend/SyntaxParseHandler.h
+++ b/js/src/frontend/SyntaxParseHandler.h
@@ -202,19 +202,17 @@ class SyntaxParseHandler {
     return NodeName;
   }
 
   NumericLiteralType newNumber(double value, DecimalPoint decimalPoint,
                                const TokenPos& pos) {
     return NodeGeneric;
   }
 
-#ifdef ENABLE_BIGINT
   BigIntLiteralType newBigInt() { return NodeGeneric; }
-#endif
 
   BooleanLiteralType newBooleanLiteral(bool cond, const TokenPos& pos) {
     return NodeGeneric;
   }
 
   NameNodeType newStringLiteral(JSAtom* atom, const TokenPos& pos) {
     lastAtom = atom;
     lastStringPos = pos;
--- a/js/src/frontend/TokenKind.h
+++ b/js/src/frontend/TokenKind.h
@@ -71,17 +71,17 @@
   MACRO(LeftCurly, "'{'")                                                   \
   MACRO(RightCurly, "'}'")                                                  \
   MACRO(LeftParen, "'('")                                                   \
   MACRO(RightParen, "')'")                                                  \
   MACRO(Name, "identifier")                                                 \
   MACRO(PrivateName, "private identifier")                                  \
   MACRO(Number, "numeric literal")                                          \
   MACRO(String, "string literal")                                           \
-  IF_BIGINT(MACRO(BigInt, "bigint literal"), )                              \
+  MACRO(BigInt, "bigint literal")                                           \
                                                                             \
   /* start of template literal with substitutions */                        \
   MACRO(TemplateHead, "'${'")                                               \
   /* template literal without substitutions */                              \
   MACRO(NoSubsTemplate, "template literal")                                 \
                                                                             \
   MACRO(RegExp, "regular expression literal")                               \
   MACRO(True, "boolean literal 'true'")                                     \
--- a/js/src/frontend/TokenStream.cpp
+++ b/js/src/frontend/TokenStream.cpp
@@ -2137,39 +2137,32 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
 
   // Consume integral component digits.
   while (IsAsciiDigit(unit)) {
     unit = getCodeUnit();
   }
 
   // Numbers contain no escapes, so we can read directly from |sourceUnits|.
   double dval;
-#ifdef ENABLE_BIGINT
   bool isBigInt = false;
-#endif
   DecimalPoint decimalPoint = NoDecimal;
-  if (unit != '.' && unit != 'e' && unit != 'E' &&
-      IF_BIGINT(unit != 'n', true)) {
+  if (unit != '.' && unit != 'e' && unit != 'E' && unit != 'n') {
     // NOTE: |unit| may be EOF here.
     ungetCodeUnit(unit);
 
     // Most numbers are pure decimal integers without fractional component
     // or exponential notation.  Handle that with optimized code.
     if (!GetDecimalInteger(anyCharsAccess().cx, numStart,
                            this->sourceUnits.addressOfNextCodeUnit(), &dval)) {
       return false;
     }
-  }
-#ifdef ENABLE_BIGINT
-  else if (unit == 'n' && anyCharsAccess().options().bigIntEnabledOption) {
+  } else if (unit == 'n' && anyCharsAccess().options().bigIntEnabledOption) {
     isBigInt = true;
     unit = peekCodeUnit();
-  }
-#endif
-  else {
+  } else {
     // Consume any decimal dot and fractional component.
     if (unit == '.') {
       decimalPoint = HasDecimal;
       do {
         unit = getCodeUnit();
       } while (IsAsciiDigit(unit));
     }
 
@@ -2221,21 +2214,19 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
         error(JSMSG_IDSTART_AFTER_NUMBER);
         return false;
       }
     }
   }
 
   noteBadToken.release();
 
-#ifdef ENABLE_BIGINT
   if (isBigInt) {
     return bigIntLiteral(start, modifier, out);
   }
-#endif
 
   newNumberToken(dval, decimalPoint, start, modifier, out);
   return true;
 }
 
 template <typename Unit, class AnyCharsAccess>
 MOZ_MUST_USE bool TokenStreamSpecific<Unit, AnyCharsAccess>::regexpLiteral(
     TokenStart start, TokenKind* out) {
@@ -2356,17 +2347,16 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
     reflags = RegExpFlag(reflags | flag);
   }
   ungetCodeUnit(unit);
 
   newRegExpToken(reflags, start, out);
   return true;
 }
 
-#ifdef ENABLE_BIGINT
 template <typename Unit, class AnyCharsAccess>
 MOZ_MUST_USE bool TokenStreamSpecific<Unit, AnyCharsAccess>::bigIntLiteral(
     TokenStart start, Modifier modifier, TokenKind* out) {
   MOZ_ASSERT(anyCharsAccess().options().bigIntEnabledOption);
   MOZ_ASSERT(this->sourceUnits.previousCodeUnit() == toUnit('n'));
   MOZ_ASSERT(this->sourceUnits.offset() > start.offset());
   uint32_t length = this->sourceUnits.offset() - start.offset();
   MOZ_ASSERT(length >= 2);
@@ -2381,17 +2371,16 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
     MOZ_ASSERT(isAsciiCodePoint(unit));
     if (!this->appendCodePointToCharBuffer(unit)) {
       return false;
     }
   }
   newBigIntToken(start, modifier, out);
   return true;
 }
-#endif
 
 template <typename Unit, class AnyCharsAccess>
 MOZ_MUST_USE bool TokenStreamSpecific<Unit, AnyCharsAccess>::getTokenInternal(
     TokenKind* const ttp, const Modifier modifier) {
   // Assume we'll fail: success cases will overwrite this.
 #ifdef DEBUG
   *ttp = TokenKind::Limit;
 #endif
@@ -2547,20 +2536,18 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
 
     // From a '0', look for a hexadecimal, binary, octal, or "noctal" (a
     // number starting with '0' that contains '8' or '9' and is treated as
     // decimal) number.
     //
     if (c1kind == ZeroDigit) {
       TokenStart start(this->sourceUnits, -1);
       int radix;
-#ifdef ENABLE_BIGINT
       bool isLegacyOctalOrNoctal = false;
       bool isBigInt = false;
-#endif
       const Unit* numStart;
       unit = getCodeUnit();
       if (unit == 'x' || unit == 'X') {
         radix = 16;
         unit = getCodeUnit();
         if (!JS7_ISHEX(unit)) {
           // NOTE: |unit| may be EOF here.
           ungetCodeUnit(unit);
@@ -2603,19 +2590,17 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
         // one past the '0o'
         numStart = this->sourceUnits.addressOfNextCodeUnit() - 1;
 
         while (JS7_ISOCT(unit)) {
           unit = getCodeUnit();
         }
       } else if (IsAsciiDigit(unit)) {
         radix = 8;
-#ifdef ENABLE_BIGINT
         isLegacyOctalOrNoctal = true;
-#endif
         // one past the '0'
         numStart = this->sourceUnits.addressOfNextCodeUnit() - 1;
 
         do {
           // Octal integer literals are not permitted in strict mode
           // code.
           if (!strictModeError(JSMSG_DEPRECATED_OCTAL)) {
             return badToken();
@@ -2640,30 +2625,26 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
         // '0' not followed by [XxBbOo0-9];  scan as a decimal number.
         numStart = this->sourceUnits.addressOfNextCodeUnit() - 1;
 
         // NOTE: |unit| may be EOF here.  (This is permitted by case #3
         //       in TokenStream.h docs for this function.)
         return decimalNumber(unit, start, numStart, modifier, ttp);
       }
 
-#ifdef ENABLE_BIGINT
       if (unit == 'n' && anyCharsAccess().options().bigIntEnabledOption) {
         if (isLegacyOctalOrNoctal) {
           error(JSMSG_BIGINT_INVALID_SYNTAX);
           return badToken();
         }
         isBigInt = true;
         unit = peekCodeUnit();
       } else {
         ungetCodeUnit(unit);
       }
-#else
-      ungetCodeUnit(unit);
-#endif
 
       // Error if an identifier-start code point appears immediately
       // after the number.  Somewhat surprisingly, if we don't check
       // here, we'll never check at all.
       if (MOZ_LIKELY(isAsciiCodePoint(unit))) {
         if (unicode::IsIdentifierStart(char16_t(unit))) {
           error(JSMSG_IDSTART_AFTER_NUMBER);
           return badToken();
@@ -2674,21 +2655,19 @@ MOZ_MUST_USE bool TokenStreamSpecific<Un
         PeekedCodePoint<Unit> peeked = this->sourceUnits.peekCodePoint();
         if (!peeked.isNone() &&
             unicode::IsIdentifierStart(peeked.codePoint())) {
           error(JSMSG_IDSTART_AFTER_NUMBER);
           return badToken();
         }
       }
 
-#ifdef ENABLE_BIGINT
       if (isBigInt) {
         return bigIntLiteral(start, modifier, ttp);
       }
-#endif
 
       double dval;
       if (!GetFullInteger(anyCharsAccess().cx, numStart,
                           this->sourceUnits.addressOfNextCodeUnit(), radix,
                           &dval)) {
         return badToken();
       }
       newNumberToken(dval, NoDecimal, start, modifier, ttp);
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -1949,22 +1949,20 @@ class GeneralTokenStreamChars : public S
   }
 
   void newNumberToken(double dval, DecimalPoint decimalPoint, TokenStart start,
                       TokenStreamShared::Modifier modifier, TokenKind* out) {
     Token* token = newToken(TokenKind::Number, start, modifier, out);
     token->setNumber(dval, decimalPoint);
   }
 
-#ifdef ENABLE_BIGINT
   void newBigIntToken(TokenStart start, TokenStreamShared::Modifier modifier,
                       TokenKind* out) {
     newToken(TokenKind::BigInt, start, modifier, out);
   }
-#endif
 
   void newAtomToken(TokenKind kind, JSAtom* atom, TokenStart start,
                     TokenStreamShared::Modifier modifier, TokenKind* out) {
     MOZ_ASSERT(kind == TokenKind::String || kind == TokenKind::TemplateHead ||
                kind == TokenKind::NoSubsTemplate);
 
     Token* token = newToken(kind, start, modifier, out);
     token->setAtom(atom);
@@ -2407,19 +2405,17 @@ class MOZ_STACK_CLASS TokenStreamSpecifi
   using GeneralCharsBase::newNameToken;
   using GeneralCharsBase::newNumberToken;
   using GeneralCharsBase::newPrivateNameToken;
   using SpecializedChars::getNonAsciiCodePoint;
   using SpecializedChars::getNonAsciiCodePointDontNormalize;
   using TokenStreamCharsShared::copyCharBufferTo;
   using TokenStreamCharsShared::drainCharBufferIntoAtom;
   using TokenStreamCharsShared::isAsciiCodePoint;
-#ifdef ENABLE_BIGINT
   using GeneralCharsBase::newBigIntToken;
-#endif
   using CharsBase::peekCodeUnit;
   using GeneralCharsBase::newRegExpToken;
   using GeneralCharsBase::newSimpleToken;
   // Deliberately don't |using| |sourceUnits| because of bug 1472569.  :-(
   using CharsBase::toUnit;
   using GeneralCharsBase::ungetCodeUnit;
   using GeneralCharsBase::updateLineInfoForEOL;
 
--- a/js/src/fuzz-tests/tests.cpp
+++ b/js/src/fuzz-tests/tests.cpp
@@ -38,19 +38,17 @@ static const JSClass* getGlobalClass() {
   return &c;
 }
 
 static JSObject* jsfuzz_createGlobal(JSContext* cx, JSPrincipals* principals) {
   /* Create the global object. */
   JS::RootedObject newGlobal(cx);
   JS::RealmOptions options;
   options.creationOptions().setStreamsEnabled(true);
-#ifdef ENABLE_BIGINT
   options.creationOptions().setBigIntEnabled(true);
-#endif
   newGlobal = JS_NewGlobalObject(cx, getGlobalClass(), principals,
                                  JS::FireOnNewGlobalHook, options);
   if (!newGlobal) {
     return nullptr;
   }
 
   JSAutoRealm ar(cx, newGlobal);
 
--- a/js/src/gc/AllocKind.h
+++ b/js/src/gc/AllocKind.h
@@ -61,17 +61,17 @@ namespace gc {
     D(SHAPE,               Shape,        js::Shape,         js::Shape,         true,   false,  true) \
     D(ACCESSOR_SHAPE,      Shape,        js::AccessorShape, js::AccessorShape, true,   false,  true) \
     D(BASE_SHAPE,          BaseShape,    js::BaseShape,     js::BaseShape,     true,   false,  true) \
     D(OBJECT_GROUP,        ObjectGroup,  js::ObjectGroup,   js::ObjectGroup,   true,   false,  false) \
     D(EXTERNAL_STRING,     String,       JSExternalString,  JSExternalString,  true,   false,  true) \
     D(FAT_INLINE_ATOM,     String,       js::FatInlineAtom, js::FatInlineAtom, true,   false,  true) \
     D(ATOM,                String,       js::NormalAtom,    js::NormalAtom,    true,   false,  true) \
     D(SYMBOL,              Symbol,       JS::Symbol,        JS::Symbol,        true,   false,  false) \
-    IF_BIGINT(D(BIGINT,    BigInt,       JS::BigInt,        JS::BigInt,        true,   false,  false),) \
+    D(BIGINT,              BigInt,       JS::BigInt,        JS::BigInt,        true,   false,  false) \
     D(JITCODE,             JitCode,      js::jit::JitCode,  js::jit::JitCode,  false,  false,  false) \
     D(SCOPE,               Scope,        js::Scope,         js::Scope,         true,   false,  true) \
     D(REGEXP_SHARED,       RegExpShared, js::RegExpShared,  js::RegExpShared,  true,   false,  true)
 
 #define FOR_EACH_NURSERY_STRING_ALLOCKIND(D) \
     D(FAT_INLINE_STRING,   String,        JSFatInlineString, JSFatInlineString, true,   true,  true) \
     D(STRING,              String,        JSString,          JSString,          true,   true,  true)
 // clang-format on
--- a/js/src/gc/AtomMarking.cpp
+++ b/js/src/gc/AtomMarking.cpp
@@ -179,19 +179,19 @@ void AtomMarkingRuntime::markAtomValue(J
       markAtom(cx, &value.toString()->asAtom());
     }
     return;
   }
   if (value.isSymbol()) {
     markAtom(cx, value.toSymbol());
     return;
   }
-  MOZ_ASSERT_IF(value.isGCThing(), value.isObject() ||
-                                       value.isPrivateGCThing() ||
-                                       IF_BIGINT(value.isBigInt(), false));
+  MOZ_ASSERT_IF(value.isGCThing(),
+                value.isObject() || value.isPrivateGCThing() ||
+                value.isBigInt());
 }
 
 void AtomMarkingRuntime::adoptMarkedAtoms(Zone* target, Zone* source) {
   MOZ_ASSERT(CurrentThreadCanAccessZone(source));
   MOZ_ASSERT(CurrentThreadCanAccessZone(target));
   target->markedAtoms().bitwiseOrWith(source->markedAtoms());
 }
 
@@ -262,19 +262,19 @@ bool AtomMarkingRuntime::valueIsMarked(Z
     }
     return true;
   }
 
   if (value.isSymbol()) {
     return atomIsMarked(zone, value.toSymbol());
   }
 
-  MOZ_ASSERT_IF(value.isGCThing(), value.isObject() ||
-                                       value.isPrivateGCThing() ||
-                                       IF_BIGINT(value.isBigInt(), false));
+  MOZ_ASSERT_IF(value.isGCThing(),
+                value.isObject() || value.isPrivateGCThing() ||
+                value.isBigInt());
   return true;
 }
 
 #endif  // DEBUG
 
 }  // namespace gc
 
 #ifdef DEBUG
--- a/js/src/gc/DeletePolicy.h
+++ b/js/src/gc/DeletePolicy.h
@@ -20,19 +20,17 @@ struct ClearEdgesTracer : public JS::Cal
 #endif
 
   template <typename T>
   inline void clearEdge(T** thingp);
 
   void onObjectEdge(JSObject** objp) override;
   void onStringEdge(JSString** strp) override;
   void onSymbolEdge(JS::Symbol** symp) override;
-#ifdef ENABLE_BIGINT
   void onBigIntEdge(JS::BigInt** bip) override;
-#endif
   void onScriptEdge(JSScript** scriptp) override;
   void onShapeEdge(js::Shape** shapep) override;
   void onObjectGroupEdge(js::ObjectGroup** groupp) override;
   void onBaseShapeEdge(js::BaseShape** basep) override;
   void onJitCodeEdge(js::jit::JitCode** codep) override;
   void onLazyScriptEdge(js::LazyScript** lazyp) override;
   void onScopeEdge(js::Scope** scopep) override;
   void onRegExpSharedEdge(js::RegExpShared** sharedp) override;
--- a/js/src/gc/GC.cpp
+++ b/js/src/gc/GC.cpp
@@ -224,19 +224,17 @@
 #include "jit/BaselineJIT.h"
 #include "jit/IonCode.h"
 #include "jit/JitcodeMap.h"
 #include "jit/JitRealm.h"
 #include "jit/MacroAssembler.h"
 #include "js/SliceBudget.h"
 #include "proxy/DeadObjectProxy.h"
 #include "util/Windows.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/Debugger.h"
 #include "vm/GeckoProfiler.h"
 #include "vm/JSAtom.h"
 #include "vm/JSContext.h"
 #include "vm/JSObject.h"
 #include "vm/JSScript.h"
 #include "vm/Printer.h"
 #include "vm/ProxyObject.h"
@@ -501,20 +499,17 @@ static const FinalizePhase BackgroundFin
      }},
     {gcstats::PhaseKind::SWEEP_REGEXP_SHARED,
      {
          AllocKind::REGEXP_SHARED,
      }},
     {gcstats::PhaseKind::SWEEP_STRING,
      {AllocKind::FAT_INLINE_STRING, AllocKind::STRING,
       AllocKind::EXTERNAL_STRING, AllocKind::FAT_INLINE_ATOM, AllocKind::ATOM,
-      AllocKind::SYMBOL,
-#ifdef ENABLE_BIGINT
-      AllocKind::BIGINT
-#endif
+      AllocKind::SYMBOL, AllocKind::BIGINT
      }},
     {gcstats::PhaseKind::SWEEP_SHAPE,
      {AllocKind::SHAPE, AllocKind::ACCESSOR_SHAPE, AllocKind::BASE_SHAPE,
       AllocKind::OBJECT_GROUP}}};
 
 template <>
 JSObject* ArenaCellIterImpl::get<JSObject>() const {
   MOZ_ASSERT(!done());
@@ -8378,20 +8373,18 @@ JS_FRIEND_API const char* JS::GCTraceKin
 
 JS::GCCellPtr::GCCellPtr(const Value& v) : ptr(0) {
   if (v.isString()) {
     ptr = checkedCast(v.toString(), JS::TraceKind::String);
   } else if (v.isObject()) {
     ptr = checkedCast(&v.toObject(), JS::TraceKind::Object);
   } else if (v.isSymbol()) {
     ptr = checkedCast(v.toSymbol(), JS::TraceKind::Symbol);
-#ifdef ENABLE_BIGINT
   } else if (v.isBigInt()) {
     ptr = checkedCast(v.toBigInt(), JS::TraceKind::BigInt);
-#endif
   } else if (v.isPrivateGCThing()) {
     ptr = checkedCast(v.toGCThing(), v.toGCThing()->getTraceKind());
   } else {
     ptr = checkedCast(nullptr, JS::TraceKind::Null);
   }
 }
 
 JS::TraceKind JS::GCCellPtr::outOfLineKind() const {
@@ -8998,21 +8991,19 @@ void js::gc::ClearEdgesTracer::onObjectE
   clearEdge(objp);
 }
 void js::gc::ClearEdgesTracer::onStringEdge(JSString** strp) {
   clearEdge(strp);
 }
 void js::gc::ClearEdgesTracer::onSymbolEdge(JS::Symbol** symp) {
   clearEdge(symp);
 }
-#ifdef ENABLE_BIGINT
 void js::gc::ClearEdgesTracer::onBigIntEdge(JS::BigInt** bip) {
   clearEdge(bip);
 }
-#endif
 void js::gc::ClearEdgesTracer::onScriptEdge(JSScript** scriptp) {
   clearEdge(scriptp);
 }
 void js::gc::ClearEdgesTracer::onShapeEdge(js::Shape** shapep) {
   clearEdge(shapep);
 }
 void js::gc::ClearEdgesTracer::onObjectGroupEdge(js::ObjectGroup** groupp) {
   clearEdge(groupp);
--- a/js/src/gc/Marking-inl.h
+++ b/js/src/gc/Marking-inl.h
@@ -8,38 +8,33 @@
 #define gc_Marking_inl_h
 
 #include "gc/Marking.h"
 
 #include "mozilla/Maybe.h"
 
 #include "gc/RelocationOverlay.h"
 
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
-
+#include "vm/BigIntType.h"
 #include "vm/RegExpShared.h"
 
 namespace js {
 namespace gc {
 
 // An abstraction to re-wrap any kind of typed pointer back to the tagged pointer
 // it came from with |TaggedPtr<TargetType>::wrap(sourcePtr)|.
 template <typename T>
 struct TaggedPtr {};
 
 template <>
 struct TaggedPtr<JS::Value> {
   static JS::Value wrap(JSObject* obj) { return JS::ObjectOrNullValue(obj); }
   static JS::Value wrap(JSString* str) { return JS::StringValue(str); }
   static JS::Value wrap(JS::Symbol* sym) { return JS::SymbolValue(sym); }
-#ifdef ENABLE_BIGINT
   static JS::Value wrap(JS::BigInt* bi) { return JS::BigIntValue(bi); }
-#endif
   template <typename T>
   static JS::Value wrap(T* priv) {
     static_assert(mozilla::IsBaseOf<Cell, T>::value,
                   "Type must be a GC thing derived from js::gc::Cell");
     return JS::PrivateGCThingValue(priv);
   }
 };
 
--- a/js/src/gc/Marking.cpp
+++ b/js/src/gc/Marking.cpp
@@ -17,19 +17,17 @@
 
 #include "builtin/ModuleObject.h"
 #include "gc/GCInternals.h"
 #include "gc/Policy.h"
 #include "jit/IonCode.h"
 #include "js/SliceBudget.h"
 #include "vm/ArgumentsObject.h"
 #include "vm/ArrayObject.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/Debugger.h"
 #include "vm/EnvironmentObject.h"
 #include "vm/RegExpShared.h"
 #include "vm/Scope.h"
 #include "vm/Shape.h"
 #include "vm/SymbolType.h"
 #include "vm/TypedArrayObject.h"
 #include "vm/UnboxedObject.h"
@@ -798,22 +796,20 @@ namespace js {
 template <>
 void GCMarker::traverse(BaseShape* thing) {
   markAndTraceChildren(thing);
 }
 template <>
 void GCMarker::traverse(JS::Symbol* thing) {
   markAndTraceChildren(thing);
 }
-#ifdef ENABLE_BIGINT
 template <>
 void GCMarker::traverse(JS::BigInt* thing) {
   markAndTraceChildren(thing);
 }
-#endif
 template <>
 void GCMarker::traverse(RegExpShared* thing) {
   markAndTraceChildren(thing);
 }
 }  // namespace js
 
 // Strings, LazyScripts, Shapes, and Scopes are extremely common, but have
 // simple patterns of recursion. We traverse trees of these edges immediately,
@@ -1491,19 +1487,17 @@ void js::GCMarker::lazilyMarkChildren(Ob
     traverseEdge(group, static_cast<JSObject*>(descr));
   }
 
   if (JSFunction* fun = group->maybeInterpretedFunction()) {
     traverseEdge(group, static_cast<JSObject*>(fun));
   }
 }
 
-#ifdef ENABLE_BIGINT
 void JS::BigInt::traceChildren(JSTracer* trc) { return; }
-#endif
 
 template <typename Functor>
 static void VisitTraceList(const Functor& f, const int32_t* traceList,
                            uint8_t* memory);
 
 // Call the trace hook set on the object, if present. If further tracing of
 // NativeObject fields is required, this will return the native object.
 enum class CheckGeneration { DoChecks, NoChecks };
@@ -1654,17 +1648,17 @@ inline static bool ObjectDenseElementsMa
   // This typeset doesn't escape this function so avoid sweeping here.
   HeapTypeSet* typeSet = group->maybeGetPropertyDontCheckGeneration(JSID_VOID);
   if (!typeSet) {
     return true;
   }
 
   static const uint32_t flagMask = TYPE_FLAG_STRING | TYPE_FLAG_SYMBOL |
                                    TYPE_FLAG_LAZYARGS | TYPE_FLAG_ANYOBJECT |
-                                   IF_BIGINT(TYPE_FLAG_BIGINT, 0);
+                                   TYPE_FLAG_BIGINT;
   bool mayBeMarkable =
       typeSet->hasAnyFlag(flagMask) || typeSet->getObjectCount() != 0;
 
 #ifdef DEBUG
   if (!mayBeMarkable) {
     const Value* elements = nobj->getDenseElementsAllowCopyOnWrite();
     for (unsigned i = 0; i < nobj->getDenseInitializedLength(); i++) {
       MOZ_ASSERT(!elements[i].isGCThing());
@@ -1771,23 +1765,19 @@ scan_value_array:
         // Save the rest of this value array for later and start scanning obj2's
         // children.
         pushValueArray(obj, vp, end);
         obj = obj2;
         goto scan_obj;
       }
     } else if (v.isSymbol()) {
       traverseEdge(obj, v.toSymbol());
-    }
-#ifdef ENABLE_BIGINT
-    else if (v.isBigInt()) {
+    } else if (v.isBigInt()) {
       traverseEdge(obj, v.toBigInt());
-    }
-#endif
-    else if (v.isPrivateGCThing()) {
+    } else if (v.isPrivateGCThing()) {
       // v.toGCCellPtr cannot be inlined, so construct one manually.
       Cell* cell = v.toGCThing();
       traverseEdge(obj, JS::GCCellPtr(cell, cell->getTraceKind()));
     }
   }
   return;
 
 scan_obj : {
--- a/js/src/gc/RootMarking.cpp
+++ b/js/src/gc/RootMarking.cpp
@@ -461,19 +461,17 @@ void js::gc::GCRuntime::finishRoots() {
 class BufferGrayRootsTracer final : public JS::CallbackTracer {
   // Set to false if we OOM while buffering gray roots.
   bool bufferingGrayRootsFailed;
 
   void onObjectEdge(JSObject** objp) override { bufferRoot(*objp); }
   void onStringEdge(JSString** stringp) override { bufferRoot(*stringp); }
   void onScriptEdge(JSScript** scriptp) override { bufferRoot(*scriptp); }
   void onSymbolEdge(JS::Symbol** symbolp) override { bufferRoot(*symbolp); }
-#ifdef ENABLE_BIGINT
   void onBigIntEdge(JS::BigInt** bip) override { bufferRoot(*bip); }
-#endif
 
   void onChild(const JS::GCCellPtr& thing) override {
     MOZ_CRASH("Unexpected gray root kind");
   }
 
   template <typename T>
   inline void bufferRoot(T* thing);
 
--- a/js/src/gc/Tracer.cpp
+++ b/js/src/gc/Tracer.cpp
@@ -10,19 +10,17 @@
 
 #include "jsutil.h"
 #include "NamespaceImports.h"
 
 #include "gc/GCInternals.h"
 #include "gc/PublicIterators.h"
 #include "gc/Zone.h"
 #include "util/Text.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/JSFunction.h"
 #include "vm/JSScript.h"
 #include "vm/Shape.h"
 #include "vm/SymbolType.h"
 
 #include "gc/GC-inl.h"
 #include "gc/Marking-inl.h"
 #include "vm/ObjectGroup-inl.h"
@@ -329,21 +327,19 @@ JS_PUBLIC_API void JS_GetTraceThingInfo(
     case JS::TraceKind::String:
       name = ((JSString*)thing)->isDependent() ? "substring" : "string";
       break;
 
     case JS::TraceKind::Symbol:
       name = "symbol";
       break;
 
-#ifdef ENABLE_BIGINT
     case JS::TraceKind::BigInt:
       name = "BigInt";
       break;
-#endif
 
     default:
       name = "INVALID";
       break;
   }
 
   n = strlen(name);
   if (n > bufsize - 1) {
--- a/js/src/gdb/lib-for-tests/prologue.py
+++ b/js/src/gdb/lib-for-tests/prologue.py
@@ -78,23 +78,16 @@ def assert_subprinter_registered(printer
     output = gdb.execute('info pretty-printer', to_string=True)
     if not re.search(pat, output, re.MULTILINE):
         raise AssertionError("assert_subprinter_registered failed to find pretty-printer:\n"
                              "  %s:%s\n"
                              "'info pretty-printer' says:\n"
                              "%s" % (printer, subprinter, output))
 
 
-enable_bigint = False
-try:
-    if gdb.lookup_type('JS::BigInt'):
-        enable_bigint = True
-except Exception:
-    pass
-
 # Request full stack traces for Python errors.
 gdb.execute('set python print-stack full')
 
 # Tell GDB not to ask the user about the things we tell it to do.
 gdb.execute('set confirm off', False)
 
 # Some print settings that make testing easier.
 gdb.execute('set print static-members off')
--- a/js/src/gdb/mozilla/jsval.py
+++ b/js/src/gdb/mozilla/jsval.py
@@ -147,28 +147,20 @@ class JSValueTypeCache(object):
 
         self.DOUBLE = get('JSVAL_TYPE_DOUBLE')
         self.INT32 = get('JSVAL_TYPE_INT32')
         self.UNDEFINED = get('JSVAL_TYPE_UNDEFINED')
         self.BOOLEAN = get('JSVAL_TYPE_BOOLEAN')
         self.MAGIC = get('JSVAL_TYPE_MAGIC')
         self.STRING = get('JSVAL_TYPE_STRING')
         self.SYMBOL = get('JSVAL_TYPE_SYMBOL')
+        self.BIGINT = get('JSVAL_TYPE_BIGINT')
         self.NULL = get('JSVAL_TYPE_NULL')
         self.OBJECT = get('JSVAL_TYPE_OBJECT')
 
-        self.enable_bigint = False
-        try:
-            # Looking up the tag will throw an exception if BigInt is not
-            # enabled.
-            self.BIGINT = get('JSVAL_TYPE_BIGINT')
-            self.enable_bigint = True
-        except Exception:
-            pass
-
         # Let self.magic_names be an array whose i'th element is the name of
         # the i'th magic value.
         d = gdb.types.make_enum_dict(gdb.lookup_type('JSWhyMagic'))
         self.magic_names = list(range(max(d.values()) + 1))
         for (k, v) in d.items():
             self.magic_names[v] = k
 
         # Choose an unboxing scheme for this architecture.
@@ -213,13 +205,13 @@ class JSValue(object):
             return '$JS::DoubleValue(%s)' % self.value['asDouble_']
 
         if tag == self.jtc.STRING:
             value = self.box.as_address().cast(self.cache.JSString_ptr_t)
         elif tag == self.jtc.OBJECT:
             value = self.box.as_address().cast(self.cache.JSObject_ptr_t)
         elif tag == self.jtc.SYMBOL:
             value = self.box.as_address().cast(self.cache.JSSymbol_ptr_t)
-        elif self.jtc.enable_bigint and tag == self.jtc.BIGINT:
+        elif tag == self.jtc.BIGINT:
             return '$JS::BigIntValue()'
         else:
             value = 'unrecognized!'
         return '$JS::Value(%s)' % (value,)
--- a/js/src/gdb/tests/test-jsval.cpp
+++ b/js/src/gdb/tests/test-jsval.cpp
@@ -1,15 +1,13 @@
 #include "gdb-tests.h"
 #include "jsapi.h"
 
 #include "js/Symbol.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 
 FRAGMENT(jsval, simple) {
   using namespace JS;
 
   RootedValue fortytwo(cx, Int32Value(42));
   RootedValue fortytwoD(cx, DoubleValue(42));
   RootedValue negone(cx, Int32Value(-1));
   RootedValue undefined(cx, UndefinedValue());
@@ -18,19 +16,17 @@ FRAGMENT(jsval, simple) {
   RootedValue js_false(cx, BooleanValue(false));
   RootedValue elements_hole(cx, js::MagicValue(JS_ELEMENTS_HOLE));
 
   RootedValue empty_string(cx);
   empty_string.setString(JS_NewStringCopyZ(cx, ""));
   RootedString hello(cx, JS_NewStringCopyZ(cx, "Hello!"));
   RootedValue friendly_string(cx, StringValue(hello));
   RootedValue symbol(cx, SymbolValue(GetSymbolFor(cx, hello)));
-#ifdef ENABLE_BIGINT
   RootedValue bi(cx, BigIntValue(BigInt::zero(cx)));
-#endif
 
   RootedValue global(cx);
   global.setObject(*CurrentGlobalOrNull(cx));
 
   // Some interesting value that floating-point won't munge.
   RootedValue onehundredthirtysevenonehundredtwentyeighths(
       cx, DoubleValue(137.0 / 128.0));
 
@@ -42,13 +38,11 @@ FRAGMENT(jsval, simple) {
   use(undefined);
   use(js_true);
   use(js_false);
   use(null);
   use(elements_hole);
   use(empty_string);
   use(friendly_string);
   use(symbol);
-#ifdef ENABLE_BIGINT
   use(bi);
-#endif
   use(global);
 }
--- a/js/src/gdb/tests/test-jsval.py
+++ b/js/src/gdb/tests/test-jsval.py
@@ -11,12 +11,11 @@ assert_pretty('negone', '$JS::Int32Value
 assert_pretty('undefined', '$JS::UndefinedValue()')
 assert_pretty('null', '$JS::NullValue()')
 assert_pretty('js_true', '$JS::BooleanValue(true)')
 assert_pretty('js_false', '$JS::BooleanValue(false)')
 assert_pretty('elements_hole', '$JS::MagicValue(JS_ELEMENTS_HOLE)')
 assert_pretty('empty_string', '$JS::Value("")')
 assert_pretty('friendly_string', '$JS::Value("Hello!")')
 assert_pretty('symbol', '$JS::Value(Symbol.for("Hello!"))')
-if enable_bigint:
-    assert_pretty('bi', '$JS::BigIntValue()')
+assert_pretty('bi', '$JS::BigIntValue()')
 assert_pretty('global', '$JS::Value((JSObject *)  [object global] delegate)')
 assert_pretty('onehundredthirtysevenonehundredtwentyeighths', '$JS::DoubleValue(1.0703125)')
--- a/js/src/jit/BaselineBailouts.cpp
+++ b/js/src/jit/BaselineBailouts.cpp
@@ -2178,19 +2178,17 @@ bool jit::FinishBailoutToBaseline(Baseli
     case Bailout_Hole:
     case Bailout_NegativeIndex:
     case Bailout_NonInt32Input:
     case Bailout_NonNumericInput:
     case Bailout_NonBooleanInput:
     case Bailout_NonObjectInput:
     case Bailout_NonStringInput:
     case Bailout_NonSymbolInput:
-#ifdef ENABLE_BIGINT
     case Bailout_NonBigIntInput:
-#endif
     case Bailout_NonSharedTypedArrayInput:
     case Bailout_Debugger:
     case Bailout_UninitializedThis:
     case Bailout_BadDerivedConstructorReturn:
       // Do nothing.
       break;
 
     case Bailout_FirstExecution:
--- a/js/src/jit/BaselineCompiler.cpp
+++ b/js/src/jit/BaselineCompiler.cpp
@@ -2037,22 +2037,20 @@ bool BaselineCompilerCodeGen::emit_JSOP_
   return true;
 }
 
 template <>
 bool BaselineInterpreterCodeGen::emit_JSOP_DOUBLE() {
   MOZ_CRASH("NYI: interpreter JSOP_DOUBLE");
 }
 
-#ifdef ENABLE_BIGINT
 template <typename Handler>
 bool BaselineCodeGen<Handler>::emit_JSOP_BIGINT() {
   return emit_JSOP_DOUBLE();
 }
-#endif
 
 template <>
 bool BaselineCompilerCodeGen::emit_JSOP_STRING() {
   frame.push(StringValue(handler.script()->getAtom(handler.pc())));
   return true;
 }
 
 template <>
--- a/js/src/jit/BaselineCompiler.h
+++ b/js/src/jit/BaselineCompiler.h
@@ -50,17 +50,17 @@ namespace jit {
   _(JSOP_ZERO)                  \
   _(JSOP_ONE)                   \
   _(JSOP_INT8)                  \
   _(JSOP_INT32)                 \
   _(JSOP_UINT16)                \
   _(JSOP_UINT24)                \
   _(JSOP_RESUMEINDEX)           \
   _(JSOP_DOUBLE)                \
-  IF_BIGINT(_(JSOP_BIGINT), )   \
+  _(JSOP_BIGINT)                \
   _(JSOP_STRING)                \
   _(JSOP_SYMBOL)                \
   _(JSOP_OBJECT)                \
   _(JSOP_CALLSITEOBJ)           \
   _(JSOP_REGEXP)                \
   _(JSOP_LAMBDA)                \
   _(JSOP_LAMBDA_ARROW)          \
   _(JSOP_SETFUNNAME)            \
--- a/js/src/jit/BaselineIC.cpp
+++ b/js/src/jit/BaselineIC.cpp
@@ -1459,21 +1459,19 @@ bool ICTypeMonitor_PrimitiveSet::Compile
   if (flags_ & TypeToFlag(JSVAL_TYPE_STRING)) {
     masm.branchTestString(Assembler::Equal, R0, &success);
   }
 
   if (flags_ & TypeToFlag(JSVAL_TYPE_SYMBOL)) {
     masm.branchTestSymbol(Assembler::Equal, R0, &success);
   }
 
-#ifdef ENABLE_BIGINT
   if (flags_ & TypeToFlag(JSVAL_TYPE_BIGINT)) {
     masm.branchTestBigInt(Assembler::Equal, R0, &success);
   }
-#endif
 
   if (flags_ & TypeToFlag(JSVAL_TYPE_OBJECT)) {
     masm.branchTestObject(Assembler::Equal, R0, &success);
   }
 
   if (flags_ & TypeToFlag(JSVAL_TYPE_NULL)) {
     masm.branchTestNull(Assembler::Equal, R0, &success);
   }
@@ -1805,21 +1803,19 @@ bool ICTypeUpdate_PrimitiveSet::Compiler
   if (flags_ & TypeToFlag(JSVAL_TYPE_STRING)) {
     masm.branchTestString(Assembler::Equal, R0, &success);
   }
 
   if (flags_ & TypeToFlag(JSVAL_TYPE_SYMBOL)) {
     masm.branchTestSymbol(Assembler::Equal, R0, &success);
   }
 
-#ifdef ENABLE_BIGINT
   if (flags_ & TypeToFlag(JSVAL_TYPE_BIGINT)) {
     masm.branchTestBigInt(Assembler::Equal, R0, &success);
   }
-#endif
 
   if (flags_ & TypeToFlag(JSVAL_TYPE_OBJECT)) {
     masm.branchTestObject(Assembler::Equal, R0, &success);
   }
 
   if (flags_ & TypeToFlag(JSVAL_TYPE_NULL)) {
     masm.branchTestNull(Assembler::Equal, R0, &success);
   }
--- a/js/src/jit/BaselineInspector.cpp
+++ b/js/src/jit/BaselineInspector.cpp
@@ -480,21 +480,19 @@ static bool GuardType(CacheIRReader& rea
   switch (op) {
     // 0 Skip cases
     case CacheOp::GuardIsString:
       guardType[guardOperand] = MIRType::String;
       break;
     case CacheOp::GuardIsSymbol:
       guardType[guardOperand] = MIRType::Symbol;
       break;
-#ifdef ENABLE_BIGINT
     case CacheOp::GuardIsBigInt:
       guardType[guardOperand] = MIRType::BigInt;
       break;
-#endif
     case CacheOp::GuardIsNumber:
       guardType[guardOperand] = MIRType::Double;
       break;
     case CacheOp::GuardIsUndefined:
       guardType[guardOperand] = MIRType::Undefined;
       break;
     // 1 skip
     case CacheOp::GuardIsInt32:
--- a/js/src/jit/CacheIR.cpp
+++ b/js/src/jit/CacheIR.cpp
@@ -1947,23 +1947,19 @@ bool GetPropIRGenerator::tryAttachPrimit
     }
     protoKey = JSProto_String;
   } else if (val_.isNumber()) {
     protoKey = JSProto_Number;
   } else if (val_.isBoolean()) {
     protoKey = JSProto_Boolean;
   } else if (val_.isSymbol()) {
     protoKey = JSProto_Symbol;
-  }
-#ifdef ENABLE_BIGINT
-  else if (val_.isBigInt()) {
+  } else if (val_.isBigInt()) {
     protoKey = JSProto_BigInt;
-  }
-#endif
-  else {
+  } else {
     MOZ_ASSERT(val_.isNullOrUndefined() || val_.isMagic());
     return false;
   }
 
   RootedObject proto(cx_, cx_->global()->maybeGetPrototype(protoKey));
   if (!proto) {
     return false;
   }
@@ -5439,17 +5435,17 @@ bool CompareIRGenerator::tryAttachNumber
 bool CompareIRGenerator::tryAttachPrimitiveUndefined(ValOperandId lhsId,
                                                      ValOperandId rhsId) {
   MOZ_ASSERT(IsEqualityOp(op_));
 
   // The set of primitive cases we want to handle here (excluding null,
   // undefined)
   auto isPrimitive = [](HandleValue& x) {
     return x.isString() || x.isSymbol() || x.isBoolean() || x.isNumber() ||
-           IF_BIGINT(x.isBigInt(), false);
+           x.isBigInt();
   };
 
   if (!(lhsVal_.isNullOrUndefined() && isPrimitive(rhsVal_)) &&
       !(rhsVal_.isNullOrUndefined() && isPrimitive(lhsVal_))) {
     return false;
   }
 
   auto guardPrimitive = [&](HandleValue v, ValOperandId id) {
@@ -5459,21 +5455,19 @@ bool CompareIRGenerator::tryAttachPrimit
     }
     switch (v.extractNonDoubleType()) {
       case JSVAL_TYPE_BOOLEAN:
         writer.guardIsBoolean(id);
         return;
       case JSVAL_TYPE_SYMBOL:
         writer.guardIsSymbol(id);
         return;
-#ifdef ENABLE_BIGINT
       case JSVAL_TYPE_BIGINT:
         writer.guardIsBigInt(id);
         return;
-#endif
       case JSVAL_TYPE_STRING:
         writer.guardIsString(id);
         return;
       default:
         MOZ_CRASH("unexpected type");
         return;
     }
   };
--- a/js/src/jit/CacheIR.h
+++ b/js/src/jit/CacheIR.h
@@ -104,23 +104,21 @@ class StringOperandId : public OperandId
 };
 
 class SymbolOperandId : public OperandId {
  public:
   SymbolOperandId() = default;
   explicit SymbolOperandId(uint16_t id) : OperandId(id) {}
 };
 
-#ifdef ENABLE_BIGINT
 class BigIntOperandId : public OperandId {
  public:
   BigIntOperandId() = default;
   explicit BigIntOperandId(uint16_t id) : OperandId(id) {}
 };
-#endif
 
 class Int32OperandId : public OperandId {
  public:
   Int32OperandId() = default;
   explicit Int32OperandId(uint16_t id) : OperandId(id) {}
 };
 
 class TypedOperandId : public OperandId {
@@ -128,20 +126,18 @@ class TypedOperandId : public OperandId 
 
  public:
   MOZ_IMPLICIT TypedOperandId(ObjOperandId id)
       : OperandId(id.id()), type_(JSVAL_TYPE_OBJECT) {}
   MOZ_IMPLICIT TypedOperandId(StringOperandId id)
       : OperandId(id.id()), type_(JSVAL_TYPE_STRING) {}
   MOZ_IMPLICIT TypedOperandId(SymbolOperandId id)
       : OperandId(id.id()), type_(JSVAL_TYPE_SYMBOL) {}
-#ifdef ENABLE_BIGINT
   MOZ_IMPLICIT TypedOperandId(BigIntOperandId id)
       : OperandId(id.id()), type_(JSVAL_TYPE_BIGINT) {}
-#endif
   MOZ_IMPLICIT TypedOperandId(Int32OperandId id)
       : OperandId(id.id()), type_(JSVAL_TYPE_INT32) {}
   MOZ_IMPLICIT TypedOperandId(ValueTagOperandId val)
       : OperandId(val.id()), type_(JSVAL_TYPE_UNKNOWN) {}
   TypedOperandId(ValOperandId val, JSValueType type)
       : OperandId(val.id()), type_(type) {}
 
   JSValueType type() const { return type_; }
@@ -182,17 +178,17 @@ extern const char* const CacheKindNames[
   _(GuardIsObjectOrNull)                                               \
   _(GuardIsNullOrUndefined)                                            \
   _(GuardIsNotNullOrUndefined)                                         \
   _(GuardIsNull)                                                       \
   _(GuardIsUndefined)                                                  \
   _(GuardIsBoolean)                                                    \
   _(GuardIsString)                                                     \
   _(GuardIsSymbol)                                                     \
-  IF_BIGINT(_(GuardIsBigInt), )                                        \
+  _(GuardIsBigInt)                                                     \
   _(GuardIsNumber)                                                     \
   _(GuardIsInt32)                                                      \
   _(GuardIsInt32Index)                                                 \
   _(GuardType)                                                         \
   _(GuardShape)                                                        \
   _(GuardGroup)                                                        \
   _(GuardProto)                                                        \
   _(GuardClass)    /* Guard an object class, per GuardClassKind */     \
@@ -603,22 +599,20 @@ class MOZ_RAII CacheIRWriter : public JS
   StringOperandId guardIsString(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsString, val);
     return StringOperandId(val.id());
   }
   SymbolOperandId guardIsSymbol(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsSymbol, val);
     return SymbolOperandId(val.id());
   }
-#ifdef ENABLE_BIGINT
   BigIntOperandId guardIsBigInt(ValOperandId val) {
     writeOpWithOperandId(CacheOp::GuardIsBigInt, val);
     return BigIntOperandId(val.id());
   }
-#endif
   Int32OperandId guardIsInt32(ValOperandId val) {
     Int32OperandId res(nextOperandId_++);
     writeOpWithOperandId(CacheOp::GuardIsInt32, val);
     writeOperandId(res);
     return res;
   }
   Int32OperandId guardIsInt32Index(ValOperandId val) {
     Int32OperandId res(nextOperandId_++);
--- a/js/src/jit/CacheIRCompiler.cpp
+++ b/js/src/jit/CacheIRCompiler.cpp
@@ -1472,33 +1472,31 @@ bool CacheIRCompiler::emitGuardIsSymbol(
   FailurePath* failure;
   if (!addFailurePath(&failure)) {
     return false;
   }
   masm.branchTestSymbol(Assembler::NotEqual, input, failure->label());
   return true;
 }
 
-#ifdef ENABLE_BIGINT
 bool CacheIRCompiler::emitGuardIsBigInt() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   ValOperandId inputId = reader.valOperandId();
   if (allocator.knownType(inputId) == JSVAL_TYPE_BIGINT) {
     return true;
   }
 
   ValueOperand input = allocator.useValueRegister(masm, inputId);
   FailurePath* failure;
   if (!addFailurePath(&failure)) {
     return false;
   }
   masm.branchTestBigInt(Assembler::NotEqual, input, failure->label());
   return true;
 }
-#endif
 
 bool CacheIRCompiler::emitGuardIsInt32() {
   JitSpew(JitSpew_Codegen, __FUNCTION__);
   ValOperandId inputId = reader.valOperandId();
   Register output = allocator.defineRegister(masm, reader.int32OperandId());
 
   if (allocator.knownType(inputId) == JSVAL_TYPE_INT32) {
     Register input = allocator.useRegister(masm, Int32OperandId(inputId.id()));
@@ -1586,21 +1584,19 @@ bool CacheIRCompiler::emitGuardType() {
 
   switch (type) {
     case JSVAL_TYPE_STRING:
       masm.branchTestString(Assembler::NotEqual, input, failure->label());
       break;
     case JSVAL_TYPE_SYMBOL:
       masm.branchTestSymbol(Assembler::NotEqual, input, failure->label());
       break;
-#ifdef ENABLE_BIGINT
     case JSVAL_TYPE_BIGINT:
       masm.branchTestBigInt(Assembler::NotEqual, input, failure->label());
       break;
-#endif
     case JSVAL_TYPE_INT32:
       masm.branchTestInt32(Assembler::NotEqual, input, failure->label());
       break;
     case JSVAL_TYPE_DOUBLE:
       masm.branchTestDouble(Assembler::NotEqual, input, failure->label());
       break;
     case JSVAL_TYPE_BOOLEAN:
       masm.branchTestBoolean(Assembler::NotEqual, input, failure->label());
--- a/js/src/jit/CacheIRCompiler.h
+++ b/js/src/jit/CacheIRCompiler.h
@@ -21,17 +21,17 @@ namespace jit {
   _(GuardIsNullOrUndefined)               \
   _(GuardIsNotNullOrUndefined)            \
   _(GuardIsNull)                          \
   _(GuardIsUndefined)                     \
   _(GuardIsObjectOrNull)                  \
   _(GuardIsBoolean)                       \
   _(GuardIsString)                        \
   _(GuardIsSymbol)                        \
-  IF_BIGINT(_(GuardIsBigInt), )           \
+  _(GuardIsBigInt)                        \
   _(GuardIsNumber)                        \
   _(GuardIsInt32)                         \
   _(GuardIsInt32Index)                    \
   _(GuardType)                            \
   _(GuardClass)                           \
   _(GuardGroupHasUnanalyzedNewScript)     \
   _(GuardIsExtensible)                    \
   _(GuardIsNativeFunction)                \
--- a/js/src/jit/CodeGenerator.cpp
+++ b/js/src/jit/CodeGenerator.cpp
@@ -781,17 +781,17 @@ void CodeGenerator::testValueTruthyKerne
   bool mightBeUndefined = valueMIR->mightBeType(MIRType::Undefined);
   bool mightBeNull = valueMIR->mightBeType(MIRType::Null);
   bool mightBeBoolean = valueMIR->mightBeType(MIRType::Boolean);
   bool mightBeInt32 = valueMIR->mightBeType(MIRType::Int32);
   bool mightBeObject = valueMIR->mightBeType(MIRType::Object);
   bool mightBeString = valueMIR->mightBeType(MIRType::String);
   bool mightBeSymbol = valueMIR->mightBeType(MIRType::Symbol);
   bool mightBeDouble = valueMIR->mightBeType(MIRType::Double);
-  bool mightBeBigInt = IF_BIGINT(valueMIR->mightBeType(MIRType::BigInt), false);
+  bool mightBeBigInt = valueMIR->mightBeType(MIRType::BigInt);
   int tagCount = int(mightBeUndefined) + int(mightBeNull) +
                  int(mightBeBoolean) + int(mightBeInt32) + int(mightBeObject) +
                  int(mightBeString) + int(mightBeSymbol) + int(mightBeDouble) +
                  int(mightBeBigInt);
 
   MOZ_ASSERT_IF(!valueMIR->emptyResultTypeSet(), tagCount > 0);
 
   // If we know we're null or undefined, we're definitely falsy, no
@@ -899,34 +899,32 @@ void CodeGenerator::testValueTruthyKerne
     if (tagCount != 1) {
       masm.jump(ifTruthy);
     }
     // Else just fall through to truthiness.
     masm.bind(&notString);
     --tagCount;
   }
 
-#ifdef ENABLE_BIGINT
   if (mightBeBigInt) {
     MOZ_ASSERT(tagCount != 0);
     Label notBigInt;
     if (tagCount != 1) {
       masm.branchTestBigInt(Assembler::NotEqual, tag, &notBigInt);
     }
     {
       ScratchTagScopeRelease _(&tag);
       masm.branchTestBigIntTruthy(false, value, ifFalsy);
     }
     if (tagCount != 1) {
       masm.jump(ifTruthy);
     }
     masm.bind(&notBigInt);
     --tagCount;
   }
-#endif
 
   if (mightBeSymbol) {
     // All symbols are truthy.
     MOZ_ASSERT(tagCount != 0);
     if (tagCount != 1) {
       masm.branchTestSymbol(Assembler::Equal, tag, ifTruthy);
     }
     // Else fall through to ifTruthy.
@@ -1260,23 +1258,21 @@ void CodeGenerator::visitValueToString(L
   if (lir->mir()->input()->mightBeType(MIRType::Symbol)) {
     // Bail.
     MOZ_ASSERT(lir->mir()->fallible());
     Label bail;
     masm.branchTestSymbol(Assembler::Equal, tag, &bail);
     bailoutFrom(&bail, lir->snapshot());
   }
 
-#ifdef ENABLE_BIGINT
   // BigInt
   if (lir->mir()->input()->mightBeType(MIRType::BigInt)) {
     // No fastpath currently implemented.
     masm.branchTestBigInt(Assembler::Equal, tag, ool->entry());
   }
-#endif
 
 #ifdef DEBUG
   masm.assumeUnreachable("Unexpected type for MValueToString.");
 #endif
 
   masm.bind(&done);
   masm.bind(ool->rejoin());
 }
@@ -4004,20 +4000,18 @@ void CodeGenerator::visitLoadUnboxedExpa
 }
 
 void CodeGenerator::visitToNumeric(LToNumeric* lir) {
   ValueOperand operand = ToValue(lir, LToNumeric::Input);
   ValueOperand output = ToOutValue(lir);
   bool maybeInt32 = lir->mir()->mightBeType(MIRType::Int32);
   bool maybeDouble = lir->mir()->mightBeType(MIRType::Double);
   bool maybeNumber = maybeInt32 || maybeDouble;
-#ifdef ENABLE_BIGINT
   bool maybeBigInt = lir->mir()->mightBeType(MIRType::BigInt);
-#endif
-  int checks = int(maybeNumber) + IF_BIGINT(int(maybeBigInt), 0);
+  int checks = int(maybeNumber) + int(maybeBigInt);
 
   OutOfLineCode* ool =
       oolCallVM(ToNumericInfo, lir, ArgList(operand), StoreValueTo(output));
 
   if (checks == 0) {
     masm.jump(ool->entry());
   } else {
     Label done;
@@ -4026,24 +4020,22 @@ void CodeGenerator::visitToNumeric(LToNu
     constexpr Condition NotEqual = Assembler::NotEqual;
 
     if (maybeNumber) {
       checks--;
       Condition cond = checks ? Equal : NotEqual;
       Label* target = checks ? &done : ool->entry();
       masm.branchTestNumber(cond, operand, target);
     }
-#ifdef ENABLE_BIGINT
     if (maybeBigInt) {
       checks--;
       Condition cond = checks ? Equal : NotEqual;
       Label* target = checks ? &done : ool->entry();
       masm.branchTestBigInt(cond, operand, target);
     }
-#endif
 
     MOZ_ASSERT(checks == 0);
     masm.bind(&done);
     masm.moveValue(operand, output);
   }
 
   masm.bind(ool->rejoin());
 }
@@ -5671,17 +5663,17 @@ void CodeGenerator::branchIfInvalidated(
                 invalidated);
 }
 
 #ifdef DEBUG
 void CodeGenerator::emitAssertGCThingResult(Register input, MIRType type,
                                             const TemporaryTypeSet* typeset) {
   MOZ_ASSERT(type == MIRType::Object || type == MIRType::ObjectOrNull ||
              type == MIRType::String || type == MIRType::Symbol ||
-             IF_BIGINT(type == MIRType::BigInt, false));
+             type == MIRType::BigInt);
 
   AllocatableGeneralRegisterSet regs(GeneralRegisterSet::All());
   regs.take(input);
 
   Register temp = regs.takeAny();
   masm.push(temp);
 
   // Don't check if the script has been invalidated. In that case invalid
@@ -5729,21 +5721,19 @@ void CodeGenerator::emitAssertGCThingRes
         callee = JS_FUNC_TO_DATA_PTR(void*, AssertValidObjectOrNullPtr);
         break;
       case MIRType::String:
         callee = JS_FUNC_TO_DATA_PTR(void*, AssertValidStringPtr);
         break;
       case MIRType::Symbol:
         callee = JS_FUNC_TO_DATA_PTR(void*, AssertValidSymbolPtr);
         break;
-#  ifdef ENABLE_BIGINT
       case MIRType::BigInt:
         callee = JS_FUNC_TO_DATA_PTR(void*, AssertValidBigIntPtr);
         break;
-#  endif
       default:
         MOZ_CRASH();
     }
 
     masm.callWithABI(callee);
     restoreVolatile();
   }
 
@@ -5848,19 +5838,17 @@ void CodeGenerator::emitDebugResultCheck
     return;
   }
 
   switch (mir->type()) {
     case MIRType::Object:
     case MIRType::ObjectOrNull:
     case MIRType::String:
     case MIRType::Symbol:
-#  ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#  endif
       emitGCThingResultChecks(ins, mir);
       break;
     case MIRType::Value:
       emitValueResultChecks(ins, mir);
       break;
     default:
       break;
   }
@@ -11249,24 +11237,22 @@ void CodeGenerator::visitTypeOfV(LTypeOf
   bool testObject = input->mightBeType(MIRType::Object);
   bool testNumber =
       input->mightBeType(MIRType::Int32) || input->mightBeType(MIRType::Double);
   bool testBoolean = input->mightBeType(MIRType::Boolean);
   bool testUndefined = input->mightBeType(MIRType::Undefined);
   bool testNull = input->mightBeType(MIRType::Null);
   bool testString = input->mightBeType(MIRType::String);
   bool testSymbol = input->mightBeType(MIRType::Symbol);
-#ifdef ENABLE_BIGINT
   bool testBigInt = input->mightBeType(MIRType::BigInt);
-#endif
 
   unsigned numTests = unsigned(testObject) + unsigned(testNumber) +
                       unsigned(testBoolean) + unsigned(testUndefined) +
                       unsigned(testNull) + unsigned(testString) +
-                      unsigned(testSymbol) + unsigned(IF_BIGINT(testBigInt, 0));
+                      unsigned(testSymbol) + unsigned(testBigInt);
 
   MOZ_ASSERT_IF(!input->emptyResultTypeSet(), numTests > 0);
 
   OutOfLineTypeOfV* ool = nullptr;
   if (testObject) {
     if (lir->mir()->inputMaybeCallableOrEmulatesUndefined()) {
       // The input may be a callable object (result is "function") or may
       // emulate undefined (result is "undefined"). Use an OOL path.
@@ -11367,30 +11353,28 @@ void CodeGenerator::visitTypeOfV(LTypeOf
     masm.movePtr(ImmGCPtr(names.symbol), output);
     if (numTests > 1) {
       masm.jump(&done);
     }
     masm.bind(&notSymbol);
     numTests--;
   }
 
-#ifdef ENABLE_BIGINT
   if (testBigInt) {
     Label notBigInt;
     if (numTests > 1) {
       masm.branchTestBigInt(Assembler::NotEqual, tag, &notBigInt);
     }
     masm.movePtr(ImmGCPtr(names.bigint), output);
     if (numTests > 1) {
       masm.jump(&done);
     }
     masm.bind(&notBigInt);
     numTests--;
   }
-#endif
 
   MOZ_ASSERT(numTests == 0);
 
   masm.bind(&done);
   if (ool) {
     masm.bind(ool->rejoin());
   }
 }
--- a/js/src/jit/IonAnalysis.cpp
+++ b/js/src/jit/IonAnalysis.cpp
@@ -2340,17 +2340,17 @@ static bool CanCompareRegExp(MCompare* c
 
   // Loose equality comparison can invoke @@toPrimitive.
   if (value->mightBeType(MIRType::Boolean) ||
       value->mightBeType(MIRType::String) ||
       value->mightBeType(MIRType::Int32) ||
       value->mightBeType(MIRType::Double) ||
       value->mightBeType(MIRType::Float32) ||
       value->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(value->mightBeType(MIRType::BigInt), false)) {
+      value->mightBeType(MIRType::BigInt)) {
     return false;
   }
 
   return true;
 }
 
 static inline void SetNotInWorklist(MDefinitionVector& worklist) {
   for (size_t i = 0; i < worklist.length(); i++) {
@@ -3172,19 +3172,17 @@ static bool IsResumableMIRType(MIRType t
     case MIRType::Undefined:
     case MIRType::Null:
     case MIRType::Boolean:
     case MIRType::Int32:
     case MIRType::Double:
     case MIRType::Float32:
     case MIRType::String:
     case MIRType::Symbol:
-#  ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#  endif
     case MIRType::Object:
     case MIRType::MagicOptimizedArguments:
     case MIRType::MagicOptimizedOut:
     case MIRType::MagicUninitializedLexical:
     case MIRType::MagicIsConstructing:
     case MIRType::Value:
     case MIRType::Int32x4:
     case MIRType::Int16x8:
--- a/js/src/jit/IonBuilder.cpp
+++ b/js/src/jit/IonBuilder.cpp
@@ -712,21 +712,19 @@ AbortReasonOr<Ok> IonBuilder::analyzeNew
         case JSOP_MUL:
         case JSOP_DIV:
         case JSOP_MOD:
         case JSOP_NEG:
         case JSOP_INC:
         case JSOP_DEC:
           type = inspector->expectedResultType(last);
           break;
-#ifdef ENABLE_BIGINT
         case JSOP_BIGINT:
           type = MIRType::BigInt;
           break;
-#endif
         default:
           break;
       }
       if (type != MIRType::None) {
         if (!phi->addBackedgeType(alloc(), type, nullptr)) {
           return abort(AbortReason::Alloc);
         }
       }
@@ -1336,19 +1334,17 @@ AbortReasonOr<Ok> IonBuilder::addOsrValu
   }
 
   switch (type) {
     case MIRType::Boolean:
     case MIRType::Int32:
     case MIRType::Double:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
     case MIRType::Object:
       if (type != def->type()) {
         MUnbox* unbox = MUnbox::New(alloc(), def, type, MUnbox::Fallible);
         osrBlock->insertBefore(osrBlock->lastIns(), unbox);
         osrBlock->rewriteSlot(slot, unbox);
         def = unbox;
       }
       break;
@@ -1931,19 +1927,17 @@ AbortReasonOr<Ok> IonBuilder::inspectOpc
     case JSOP_STRICTNE:
     case JSOP_LT:
     case JSOP_LE:
     case JSOP_GT:
     case JSOP_GE:
       return jsop_compare(op);
 
     case JSOP_DOUBLE:
-#ifdef ENABLE_BIGINT
     case JSOP_BIGINT:
-#endif
       pushConstant(info().getConst(pc));
       return Ok();
 
     case JSOP_STRING:
       pushConstant(StringValue(info().getAtom(pc)));
       return Ok();
 
     case JSOP_SYMBOL: {
@@ -2804,23 +2798,19 @@ AbortReasonOr<Ok> IonBuilder::improveTyp
     filter.addType(TypeSet::BooleanType(), alloc_->lifoAlloc());
   } else if (constant->toString() == TypeName(JSTYPE_NUMBER, names)) {
     filter.addType(TypeSet::Int32Type(), alloc_->lifoAlloc());
     filter.addType(TypeSet::DoubleType(), alloc_->lifoAlloc());
   } else if (constant->toString() == TypeName(JSTYPE_STRING, names)) {
     filter.addType(TypeSet::StringType(), alloc_->lifoAlloc());
   } else if (constant->toString() == TypeName(JSTYPE_SYMBOL, names)) {
     filter.addType(TypeSet::SymbolType(), alloc_->lifoAlloc());
-  }
-#ifdef ENABLE_BIGINT
-  else if (constant->toString() == TypeName(JSTYPE_BIGINT, names)) {
+  } else if (constant->toString() == TypeName(JSTYPE_BIGINT, names)) {
     filter.addType(TypeSet::BigIntType(), alloc_->lifoAlloc());
-  }
-#endif
-  else if (constant->toString() == TypeName(JSTYPE_OBJECT, names)) {
+  } else if (constant->toString() == TypeName(JSTYPE_OBJECT, names)) {
     filter.addType(TypeSet::NullType(), alloc_->lifoAlloc());
     if (trueBranch) {
       filter.addType(TypeSet::AnyObjectType(), alloc_->lifoAlloc());
     }
   } else if (constant->toString() == TypeName(JSTYPE_FUNCTION, names)) {
     if (typeOf->inputMaybeCallableOrEmulatesUndefined() && trueBranch) {
       filter.addType(TypeSet::AnyObjectType(), alloc_->lifoAlloc());
     }
@@ -3054,20 +3044,18 @@ AbortReasonOr<Ok> IonBuilder::improveTyp
     base.addType(TypeSet::BooleanType(),
                  alloc_->lifoAlloc());  // ToBoolean(false) == false
     base.addType(TypeSet::Int32Type(),
                  alloc_->lifoAlloc());  // ToBoolean(0) == false
     base.addType(TypeSet::DoubleType(),
                  alloc_->lifoAlloc());  // ToBoolean(0.0) == false
     base.addType(TypeSet::StringType(),
                  alloc_->lifoAlloc());  // ToBoolean("") == false
-#ifdef ENABLE_BIGINT
     base.addType(TypeSet::BigIntType(),
                  alloc_->lifoAlloc());  // ToBoolean(0n) == false
-#endif
 
     // If the typeset does emulate undefined, then we cannot filter out
     // objects.
     if (oldType->maybeEmulatesUndefined(constraints())) {
       base.addType(TypeSet::AnyObjectType(), alloc_->lifoAlloc());
     }
 
     type = TypeSet::intersectSets(&base, oldType, alloc_->lifoAlloc());
@@ -3366,17 +3354,17 @@ AbortReasonOr<Ok> IonBuilder::bitnotTryS
                                                    MDefinition* input) {
   MOZ_ASSERT(*emitted == false);
 
   // Try to emit a specialized bitnot instruction based on the input type
   // of the operand.
 
   if (input->mightBeType(MIRType::Object) ||
       input->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(input->mightBeType(MIRType::BigInt), false)) {
+      input->mightBeType(MIRType::BigInt)) {
     return Ok();
   }
 
   MBitNot* ins = MBitNot::New(alloc(), input);
   ins->setSpecialization(MIRType::Int32);
 
   current->add(ins);
   current->push(ins);
@@ -3820,19 +3808,17 @@ AbortReasonOr<Ok> IonBuilder::jsop_tonum
   LifoAlloc* lifoAlloc = alloc().lifoAlloc();
   TemporaryTypeSet* types = lifoAlloc->new_<TemporaryTypeSet>();
   if (!types) {
     return abort(AbortReason::Alloc);
   }
 
   types->addType(TypeSet::Int32Type(), lifoAlloc);
   types->addType(TypeSet::DoubleType(), lifoAlloc);
-#ifdef ENABLE_BIGINT
   types->addType(TypeSet::BigIntType(), lifoAlloc);
-#endif
 
   if (peeked->type() == MIRType::Value && peeked->resultTypeSet() &&
       peeked->resultTypeSet()->isSubset(types)) {
     // Elide the ToNumeric because the arg is already a boxed numeric.
     peeked->setImplicitlyUsedUnchecked();
     return Ok();
   }
 
@@ -6265,17 +6251,17 @@ AbortReasonOr<Ok> IonBuilder::compareTry
   *emitted = true;
   return Ok();
 }
 
 static bool ObjectOrSimplePrimitive(MDefinition* op) {
   // Return true if op is either undefined/null/boolean/int32/symbol or an
   // object.
   return !op->mightBeType(MIRType::String) &&
-         IF_BIGINT(!op->mightBeType(MIRType::BigInt), true) &&
+         !op->mightBeType(MIRType::BigInt) &&
          !op->mightBeType(MIRType::Double) &&
          !op->mightBeType(MIRType::Float32) &&
          !op->mightBeType(MIRType::MagicOptimizedArguments) &&
          !op->mightBeType(MIRType::MagicHole) &&
          !op->mightBeType(MIRType::MagicIsConstructing);
 }
 
 AbortReasonOr<Ok> IonBuilder::compareTrySpecialized(bool* emitted, JSOp op,
@@ -7516,21 +7502,19 @@ JSObject* IonBuilder::testSingletonPrope
     case MIRType::String:
       key = JSProto_String;
       break;
 
     case MIRType::Symbol:
       key = JSProto_Symbol;
       break;
 
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       key = JSProto_BigInt;
       break;
-#endif
 
     case MIRType::Int32:
     case MIRType::Double:
       key = JSProto_Number;
       break;
 
     case MIRType::Boolean:
       key = JSProto_Boolean;
--- a/js/src/jit/IonTypes.h
+++ b/js/src/jit/IonTypes.h
@@ -119,19 +119,17 @@ enum BailoutKind {
 
   // Unbox expects a given type, bails out if it doesn't get it.
   Bailout_NonInt32Input,
   Bailout_NonNumericInput,  // unboxing a double works with int32 too
   Bailout_NonBooleanInput,
   Bailout_NonObjectInput,
   Bailout_NonStringInput,
   Bailout_NonSymbolInput,
-#ifdef ENABLE_BIGINT
   Bailout_NonBigIntInput,
-#endif
 
   // Atomic operations require shared memory, bail out if the typed array
   // maps unshared memory.
   Bailout_NonSharedTypedArrayInput,
 
   // We hit a |debugger;| statement.
   Bailout_Debugger,
 
@@ -221,20 +219,18 @@ inline const char* BailoutKindString(Bai
     case Bailout_NonBooleanInput:
       return "Bailout_NonBooleanInput";
     case Bailout_NonObjectInput:
       return "Bailout_NonObjectInput";
     case Bailout_NonStringInput:
       return "Bailout_NonStringInput";
     case Bailout_NonSymbolInput:
       return "Bailout_NonSymbolInput";
-#ifdef ENABLE_BIGINT
     case Bailout_NonBigIntInput:
       return "Bailout_NonBigIntInput";
-#endif
     case Bailout_NonSharedTypedArrayInput:
       return "Bailout_NonSharedTypedArrayInput";
     case Bailout_Debugger:
       return "Bailout_Debugger";
     case Bailout_UninitializedThis:
       return "Bailout_UninitializedThis";
     case Bailout_BadDerivedConstructorReturn:
       return "Bailout_BadDerivedConstructorReturn";
@@ -443,19 +439,17 @@ enum class MIRType : uint8_t {
   Boolean,
   Int32,
   Int64,
   Double,
   Float32,
   // Types above have trivial conversion to a number.
   String,
   Symbol,
-#ifdef ENABLE_BIGINT
   BigInt,
-#endif
   // Types above are primitive (including undefined and null).
   Object,
   MagicOptimizedArguments,    // JS_OPTIMIZED_ARGUMENTS magic value.
   MagicOptimizedOut,          // JS_OPTIMIZED_OUT magic value.
   MagicHole,                  // JS_ELEMENTS_HOLE magic value.
   MagicIsConstructing,        // JS_IS_CONSTRUCTING magic value.
   MagicUninitializedLexical,  // JS_UNINITIALIZED_LEXICAL magic value.
   // Types above are specialized.
@@ -494,20 +488,18 @@ static inline MIRType MIRTypeFromValueTy
     case JSVAL_TYPE_INT32:
       return MIRType::Int32;
     case JSVAL_TYPE_UNDEFINED:
       return MIRType::Undefined;
     case JSVAL_TYPE_STRING:
       return MIRType::String;
     case JSVAL_TYPE_SYMBOL:
       return MIRType::Symbol;
-#ifdef ENABLE_BIGINT
     case JSVAL_TYPE_BIGINT:
       return MIRType::BigInt;
-#endif
     case JSVAL_TYPE_BOOLEAN:
       return MIRType::Boolean;
     case JSVAL_TYPE_NULL:
       return MIRType::Null;
     case JSVAL_TYPE_OBJECT:
       return MIRType::Object;
     case JSVAL_TYPE_UNKNOWN:
       return MIRType::Value;
@@ -528,20 +520,18 @@ static inline JSValueType ValueTypeFromM
       return JSVAL_TYPE_INT32;
     case MIRType::Float32:  // Fall through, there's no JSVAL for Float32
     case MIRType::Double:
       return JSVAL_TYPE_DOUBLE;
     case MIRType::String:
       return JSVAL_TYPE_STRING;
     case MIRType::Symbol:
       return JSVAL_TYPE_SYMBOL;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       return JSVAL_TYPE_BIGINT;
-#endif
     case MIRType::MagicOptimizedArguments:
     case MIRType::MagicOptimizedOut:
     case MIRType::MagicHole:
     case MIRType::MagicIsConstructing:
     case MIRType::MagicUninitializedLexical:
       return JSVAL_TYPE_MAGIC;
     default:
       MOZ_ASSERT(type == MIRType::Object);
@@ -586,20 +576,18 @@ static inline const char* StringFromMIRT
     case MIRType::Double:
       return "Double";
     case MIRType::Float32:
       return "Float32";
     case MIRType::String:
       return "String";
     case MIRType::Symbol:
       return "Symbol";
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       return "BigInt";
-#endif
     case MIRType::Object:
       return "Object";
     case MIRType::MagicOptimizedArguments:
       return "MagicOptimizedArguments";
     case MIRType::MagicOptimizedOut:
       return "MagicOptimizedOut";
     case MIRType::MagicHole:
       return "MagicHole";
@@ -652,17 +640,17 @@ static inline bool IsIntType(MIRType typ
 }
 
 static inline bool IsNumberType(MIRType type) {
   return type == MIRType::Int32 || type == MIRType::Double ||
          type == MIRType::Float32 || type == MIRType::Int64;
 }
 
 static inline bool IsNumericType(MIRType type) {
-  return IsNumberType(type) || IF_BIGINT(type == MIRType::BigInt, false);
+  return IsNumberType(type) || type == MIRType::BigInt;
 }
 
 static inline bool IsTypeRepresentableAsDouble(MIRType type) {
   return type == MIRType::Int32 || type == MIRType::Double ||
          type == MIRType::Float32;
 }
 
 static inline bool IsFloatType(MIRType type) {
--- a/js/src/jit/JitFrames.cpp
+++ b/js/src/jit/JitFrames.cpp
@@ -1495,36 +1495,32 @@ static Value FromObjectPayload(uintptr_t
 static Value FromStringPayload(uintptr_t payload) {
   return StringValue(reinterpret_cast<JSString*>(payload));
 }
 
 static Value FromSymbolPayload(uintptr_t payload) {
   return SymbolValue(reinterpret_cast<JS::Symbol*>(payload));
 }
 
-#ifdef ENABLE_BIGINT
 static Value FromBigIntPayload(uintptr_t payload) {
   return BigIntValue(reinterpret_cast<JS::BigInt*>(payload));
 }
-#endif
 
 static Value FromTypedPayload(JSValueType type, uintptr_t payload) {
   switch (type) {
     case JSVAL_TYPE_INT32:
       return Int32Value(payload);
     case JSVAL_TYPE_BOOLEAN:
       return BooleanValue(!!payload);
     case JSVAL_TYPE_STRING:
       return FromStringPayload(payload);
     case JSVAL_TYPE_SYMBOL:
       return FromSymbolPayload(payload);
-#ifdef ENABLE_BIGINT
     case JSVAL_TYPE_BIGINT:
       return FromBigIntPayload(payload);
-#endif
     case JSVAL_TYPE_OBJECT:
       return FromObjectPayload(payload);
     default:
       MOZ_CRASH("unexpected type - needs payload");
   }
 }
 
 bool SnapshotIterator::allocationReadable(const RValueAllocation& alloc,
@@ -1611,20 +1607,18 @@ Value SnapshotIterator::allocationValue(
         case JSVAL_TYPE_INT32:
           return Int32Value(ReadFrameInt32Slot(fp_, alloc.stackOffset2()));
         case JSVAL_TYPE_BOOLEAN:
           return BooleanValue(ReadFrameBooleanSlot(fp_, alloc.stackOffset2()));
         case JSVAL_TYPE_STRING:
           return FromStringPayload(fromStack(alloc.stackOffset2()));
         case JSVAL_TYPE_SYMBOL:
           return FromSymbolPayload(fromStack(alloc.stackOffset2()));
-#ifdef ENABLE_BIGINT
         case JSVAL_TYPE_BIGINT:
           return FromBigIntPayload(fromStack(alloc.stackOffset2()));
-#endif
         case JSVAL_TYPE_OBJECT:
           return FromObjectPayload(fromStack(alloc.stackOffset2()));
         default:
           MOZ_CRASH("Unexpected type");
       }
     }
 
 #if defined(JS_NUNBOX32)
@@ -1736,19 +1730,17 @@ void SnapshotIterator::writeAllocationVa
 
     case RValueAllocation::TYPED_STACK:
       switch (alloc.knownType()) {
         default:
           MOZ_CRASH("Not a GC thing: Unexpected write");
           break;
         case JSVAL_TYPE_STRING:
         case JSVAL_TYPE_SYMBOL:
-#ifdef ENABLE_BIGINT
         case JSVAL_TYPE_BIGINT:
-#endif
         case JSVAL_TYPE_OBJECT:
           WriteFrameSlot(fp_, alloc.stackOffset2(), uintptr_t(v.toGCThing()));
           break;
       }
       break;
 
 #if defined(JS_NUNBOX32)
     case RValueAllocation::UNTYPED_REG_REG:
--- a/js/src/jit/LIR.h
+++ b/js/src/jit/LIR.h
@@ -520,19 +520,17 @@ class LDefinition {
       case MIRType::Int32:
         // The stack slot allocator doesn't currently support allocating
         // 1-byte slots, so for now we lower MIRType::Boolean into INT32.
         static_assert(sizeof(bool) <= sizeof(int32_t),
                       "bool doesn't fit in an int32 slot");
         return LDefinition::INT32;
       case MIRType::String:
       case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
       case MIRType::BigInt:
-#endif
       case MIRType::Object:
       case MIRType::ObjectOrNull:
         return LDefinition::OBJECT;
       case MIRType::Double:
         return LDefinition::DOUBLE;
       case MIRType::Float32:
         return LDefinition::FLOAT32;
 #if defined(JS_PUNBOX64)
--- a/js/src/jit/Lowering.cpp
+++ b/js/src/jit/Lowering.cpp
@@ -601,21 +601,19 @@ void LIRGenerator::visitTest(MTest* test
   MDefinition* opd = test->getOperand(0);
   MBasicBlock* ifTrue = test->ifTrue();
   MBasicBlock* ifFalse = test->ifFalse();
 
   // String is converted to length of string in the type analysis phase (see
   // TestPolicy).
   MOZ_ASSERT(opd->type() != MIRType::String);
 
-#ifdef ENABLE_BIGINT
   // BigInt is boxed in type analysis.
   MOZ_ASSERT(opd->type() != MIRType::BigInt,
              "BigInt should be boxed by TestPolicy");
-#endif
 
   // Testing a constant.
   if (MConstant* constant = opd->maybeConstantValue()) {
     bool b;
     if (constant->valueToBoolean(&b)) {
       add(new (alloc()) LGoto(b ? ifTrue : ifFalse));
       return;
     }
@@ -2107,19 +2105,17 @@ void LIRGenerator::visitToNumberInt32(MT
       LDoubleToInt32* lir = new (alloc()) LDoubleToInt32(useRegister(opd));
       assignSnapshot(lir, Bailout_PrecisionLoss);
       define(lir, convert);
       break;
     }
 
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
     case MIRType::Object:
     case MIRType::Undefined:
       // Objects might be effectful. Symbols and BigInts throw. Undefined
       // coerces to NaN, not int32.
       MOZ_CRASH("ToInt32 invalid input type");
 
     default:
       MOZ_CRASH("unexpected type");
@@ -2916,20 +2912,18 @@ void LIRGenerator::visitSetInitializedLe
 }
 
 void LIRGenerator::visitNot(MNot* ins) {
   MDefinition* op = ins->input();
 
   // String is converted to length of string in the type analysis phase (see
   // TestPolicy).
   MOZ_ASSERT(op->type() != MIRType::String);
-#ifdef ENABLE_BIGINT
   MOZ_ASSERT(op->type() != MIRType::BigInt,
              "BigInt should be boxed by TestPolicy");
-#endif
 
   // - boolean: x xor 1
   // - int32: LCompare(x, 0)
   // - double: LCompare(x, 0)
   // - null or undefined: true
   // - object: false if it never emulates undefined, else LNotO(x)
   switch (op->type()) {
     case MIRType::Boolean: {
@@ -4715,21 +4709,19 @@ void LIRGenerator::visitConstant(MConsta
       defineInt64(new (alloc()) LInteger64(ins->toInt64()), ins);
       break;
     case MIRType::String:
       define(new (alloc()) LPointer(ins->toString()), ins);
       break;
     case MIRType::Symbol:
       define(new (alloc()) LPointer(ins->toSymbol()), ins);
       break;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       define(new (alloc()) LPointer(ins->toBigInt()), ins);
       break;
-#endif
     case MIRType::Object:
       define(new (alloc()) LPointer(&ins->toObject()), ins);
       break;
     default:
       // Constants of special types (undefined, null) should never flow into
       // here directly. Operations blindly consuming them require a Box.
       MOZ_CRASH("unexpected constant type");
   }
--- a/js/src/jit/MCallOptimize.cpp
+++ b/js/src/jit/MCallOptimize.cpp
@@ -2134,17 +2134,17 @@ IonBuilder::InliningResult IonBuilder::i
   }
 
   MDefinition* codeUnit = callInfo.getArg(0);
   if (codeUnit->type() != MIRType::Int32) {
     // MTruncateToInt32 will always bail for objects, symbols and BigInts, so
     // don't try to inline String.fromCharCode() for these value types.
     if (codeUnit->mightBeType(MIRType::Object) ||
         codeUnit->mightBeType(MIRType::Symbol) ||
-        IF_BIGINT(codeUnit->mightBeType(MIRType::BigInt), false)) {
+        codeUnit->mightBeType(MIRType::BigInt)) {
       return InliningStatus_NotInlined;
     }
 
     codeUnit = MTruncateToInt32::New(alloc(), codeUnit);
     current->add(codeUnit->toInstruction());
   }
 
   callInfo.setImplicitlyUsedUnchecked();
@@ -3622,17 +3622,17 @@ IonBuilder::InliningResult IonBuilder::i
   MOZ_ASSERT(callInfo.argc() == 1);
 
   MDefinition* input = callInfo.getArg(0);
 
   // Only optimize cases where input contains only number, null or boolean
   if (input->mightBeType(MIRType::Object) ||
       input->mightBeType(MIRType::String) ||
       input->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(input->mightBeType(MIRType::BigInt), false) ||
+      input->mightBeType(MIRType::BigInt) ||
       input->mightBeType(MIRType::Undefined) || input->mightBeMagicType()) {
     return InliningStatus_NotInlined;
   }
 
   MOZ_ASSERT(input->type() == MIRType::Value ||
              input->type() == MIRType::Null ||
              input->type() == MIRType::Boolean || IsNumberType(input->type()));
 
@@ -3748,24 +3748,24 @@ IonBuilder::InliningResult IonBuilder::i
   }
 
   // These guards are desirable here and in subsequent atomics to
   // avoid bad bailouts with MTruncateToInt32, see
   // https://bugzilla.mozilla.org/show_bug.cgi?id=1141986#c20.
   MDefinition* oldval = callInfo.getArg(2);
   if (oldval->mightBeType(MIRType::Object) ||
       oldval->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(oldval->mightBeType(MIRType::BigInt), false)) {
+      oldval->mightBeType(MIRType::BigInt)) {
     return InliningStatus_NotInlined;
   }
 
   MDefinition* newval = callInfo.getArg(3);
   if (newval->mightBeType(MIRType::Object) ||
       newval->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(newval->mightBeType(MIRType::BigInt), false)) {
+      newval->mightBeType(MIRType::BigInt)) {
     return InliningStatus_NotInlined;
   }
 
   Scalar::Type arrayType;
   bool requiresCheck = false;
   if (!atomicsMeetsPreconditions(callInfo, &arrayType, &requiresCheck)) {
     return InliningStatus_NotInlined;
   }
@@ -3796,17 +3796,17 @@ IonBuilder::InliningResult IonBuilder::i
   if (callInfo.argc() != 3 || callInfo.constructing()) {
     trackOptimizationOutcome(TrackedOutcome::CantInlineNativeBadForm);
     return InliningStatus_NotInlined;
   }
 
   MDefinition* value = callInfo.getArg(2);
   if (value->mightBeType(MIRType::Object) ||
       value->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(value->mightBeType(MIRType::BigInt), false)) {
+      value->mightBeType(MIRType::BigInt)) {
     return InliningStatus_NotInlined;
   }
 
   Scalar::Type arrayType;
   bool requiresCheck = false;
   if (!atomicsMeetsPreconditions(callInfo, &arrayType, &requiresCheck)) {
     return InliningStatus_NotInlined;
   }
@@ -3882,17 +3882,17 @@ IonBuilder::InliningResult IonBuilder::i
   MDefinition* value = callInfo.getArg(2);
   if (!BytecodeIsPopped(pc) && value->type() != MIRType::Int32) {
     trackOptimizationOutcome(TrackedOutcome::CantInlineNativeBadType);
     return InliningStatus_NotInlined;
   }
 
   if (value->mightBeType(MIRType::Object) ||
       value->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(value->mightBeType(MIRType::BigInt), false)) {
+      value->mightBeType(MIRType::BigInt)) {
     return InliningStatus_NotInlined;
   }
 
   Scalar::Type arrayType;
   bool requiresCheck = false;
   if (!atomicsMeetsPreconditions(callInfo, &arrayType, &requiresCheck,
                                  DontCheckAtomicResult)) {
     return InliningStatus_NotInlined;
@@ -3928,17 +3928,17 @@ IonBuilder::InliningResult IonBuilder::i
   if (callInfo.argc() != 3 || callInfo.constructing()) {
     trackOptimizationOutcome(TrackedOutcome::CantInlineNativeBadForm);
     return InliningStatus_NotInlined;
   }
 
   MDefinition* value = callInfo.getArg(2);
   if (value->mightBeType(MIRType::Object) ||
       value->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(value->mightBeType(MIRType::BigInt), false)) {
+      value->mightBeType(MIRType::BigInt)) {
     return InliningStatus_NotInlined;
   }
 
   Scalar::Type arrayType;
   bool requiresCheck = false;
   if (!atomicsMeetsPreconditions(callInfo, &arrayType, &requiresCheck)) {
     return InliningStatus_NotInlined;
   }
--- a/js/src/jit/MIR.cpp
+++ b/js/src/jit/MIR.cpp
@@ -934,21 +934,19 @@ MConstant::MConstant(TempAllocator& allo
       break;
     case MIRType::String:
       MOZ_ASSERT(vp.toString()->isAtom());
       payload_.str = vp.toString();
       break;
     case MIRType::Symbol:
       payload_.sym = vp.toSymbol();
       break;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       payload_.bi = vp.toBigInt();
       break;
-#endif
     case MIRType::Object:
       payload_.obj = &vp.toObject();
       // Create a singleton type set for the object. This isn't necessary for
       // other types as the result type encodes all needed information.
       MOZ_ASSERT_IF(IsInsideNursery(&vp.toObject()),
                     IonCompilationCanUseNurseryPointers());
       setResultTypeSet(
           MakeSingletonTypeSet(alloc, constraints, &vp.toObject()));
@@ -1016,19 +1014,17 @@ void MConstant::assertInitializedPayload
 #  endif
       break;
     case MIRType::Double:
     case MIRType::Int64:
       break;
     case MIRType::String:
     case MIRType::Object:
     case MIRType::Symbol:
-#  ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#  endif
 #  if MOZ_LITTLE_ENDIAN
       MOZ_ASSERT_IF(JS_BITS_PER_WORD == 32, (payload_.asBits >> 32) == 0);
 #  else
       MOZ_ASSERT_IF(JS_BITS_PER_WORD == 32, (payload_.asBits << 32) == 0);
 #  endif
       break;
     default:
       MOZ_ASSERT(IsNullOrUndefined(type()) || IsMagicType(type()));
@@ -1110,21 +1106,19 @@ void MConstant::printOpcode(GenericPrint
         break;
       }
       out.printf("object %p (%s)", (void*)&toObject(),
                  toObject().getClass()->name);
       break;
     case MIRType::Symbol:
       out.printf("symbol at %p", (void*)toSymbol());
       break;
-#  ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       out.printf("BigInt at %p", (void*)toBigInt());
       break;
-#  endif
     case MIRType::String:
       out.printf("string %p", (void*)toString());
       break;
     case MIRType::MagicOptimizedArguments:
       out.printf("magic lazyargs");
       break;
     case MIRType::MagicHole:
       out.printf("magic hole");
@@ -1176,20 +1170,18 @@ Value MConstant::toJSValue() const {
     case MIRType::Double:
       return DoubleValue(toDouble());
     case MIRType::Float32:
       return Float32Value(toFloat32());
     case MIRType::String:
       return StringValue(toString());
     case MIRType::Symbol:
       return SymbolValue(toSymbol());
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       return BigIntValue(toBigInt());
-#endif
     case MIRType::Object:
       return ObjectValue(toObject());
     case MIRType::MagicOptimizedArguments:
       return MagicValue(JS_OPTIMIZED_ARGUMENTS);
     case MIRType::MagicOptimizedOut:
       return MagicValue(JS_OPTIMIZED_OUT);
     case MIRType::MagicHole:
       return MagicValue(JS_ELEMENTS_HOLE);
@@ -1221,21 +1213,19 @@ bool MConstant::valueToBoolean(bool* res
       return true;
     case MIRType::Null:
     case MIRType::Undefined:
       *res = false;
       return true;
     case MIRType::Symbol:
       *res = true;
       return true;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       *res = !toBigInt()->isZero();
       return true;
-#endif
     case MIRType::String:
       *res = toString()->length() != 0;
       return true;
     case MIRType::Object:
       // We have to call EmulatesUndefined but that reads obj->group->clasp
       // and so it's racy when the object has a lazy group. The main callers
       // of this (MTest, MNot) already know how to fold the object case, so
       // just give up.
@@ -1767,21 +1757,19 @@ void MUnbox::printOpcode(GenericPrinter&
       out.printf("to Boolean");
       break;
     case MIRType::String:
       out.printf("to String");
       break;
     case MIRType::Symbol:
       out.printf("to Symbol");
       break;
-#  ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       out.printf("to BigInt");
       break;
-#  endif
     case MIRType::Object:
       out.printf("to Object");
       break;
     default:
       break;
   }
 
   switch (mode()) {
@@ -2250,19 +2238,17 @@ bool jit::TypeSetIncludes(TypeSet* types
     case MIRType::Undefined:
     case MIRType::Null:
     case MIRType::Boolean:
     case MIRType::Int32:
     case MIRType::Double:
     case MIRType::Float32:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
     case MIRType::MagicOptimizedArguments:
       return types->hasType(
           TypeSet::PrimitiveType(ValueTypeFromMIRType(input)));
 
     case MIRType::Object:
       return types->unknownObject() ||
              (inputTypes && inputTypes->isSubset(types));
 
@@ -2513,20 +2499,20 @@ MDefinition* MBinaryBitwiseInstruction::
   }
 
   return this;
 }
 
 void MBinaryBitwiseInstruction::infer(BaselineInspector*, jsbytecode*) {
   if (getOperand(0)->mightBeType(MIRType::Object) ||
       getOperand(0)->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(getOperand(0)->mightBeType(MIRType::BigInt), false) ||
+      getOperand(0)->mightBeType(MIRType::BigInt) ||
       getOperand(1)->mightBeType(MIRType::Object) ||
       getOperand(1)->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(getOperand(1)->mightBeType(MIRType::BigInt), false)) {
+      getOperand(1)->mightBeType(MIRType::BigInt)) {
     specialization_ = MIRType::None;
     setResultType(MIRType::Value);
   } else {
     specializeAs(MIRType::Int32);
   }
 }
 
 void MBinaryBitwiseInstruction::specializeAs(MIRType type) {
@@ -2541,33 +2527,33 @@ void MBinaryBitwiseInstruction::speciali
   }
 }
 
 void MShiftInstruction::infer(BaselineInspector*, jsbytecode*) {
   if (getOperand(0)->mightBeType(MIRType::Object) ||
       getOperand(1)->mightBeType(MIRType::Object) ||
       getOperand(0)->mightBeType(MIRType::Symbol) ||
       getOperand(1)->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(getOperand(0)->mightBeType(MIRType::BigInt), false) ||
-      IF_BIGINT(getOperand(1)->mightBeType(MIRType::BigInt), false)) {
+      getOperand(0)->mightBeType(MIRType::BigInt) ||
+      getOperand(1)->mightBeType(MIRType::BigInt)) {
     specialization_ = MIRType::None;
     setResultType(MIRType::Value);
   } else {
     specialization_ = MIRType::Int32;
     setResultType(MIRType::Int32);
   }
 }
 
 void MUrsh::infer(BaselineInspector* inspector, jsbytecode* pc) {
   if (getOperand(0)->mightBeType(MIRType::Object) ||
       getOperand(1)->mightBeType(MIRType::Object) ||
       getOperand(0)->mightBeType(MIRType::Symbol) ||
       getOperand(1)->mightBeType(MIRType::Symbol) ||
-      IF_BIGINT(getOperand(0)->mightBeType(MIRType::BigInt), false) ||
-      IF_BIGINT(getOperand(1)->mightBeType(MIRType::BigInt), false)) {
+      getOperand(0)->mightBeType(MIRType::BigInt) ||
+      getOperand(1)->mightBeType(MIRType::BigInt)) {
     specialization_ = MIRType::None;
     setResultType(MIRType::Value);
     return;
   }
 
   if (inspector->hasSeenDoubleResult(pc)) {
     specialization_ = MIRType::Double;
     setResultType(MIRType::Double);
@@ -3598,21 +3584,19 @@ MDefinition* MTypeOf::foldsTo(TempAlloca
       type = JSTYPE_NUMBER;
       break;
     case MIRType::String:
       type = JSTYPE_STRING;
       break;
     case MIRType::Symbol:
       type = JSTYPE_SYMBOL;
       break;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       type = JSTYPE_BIGINT;
       break;
-#endif
     case MIRType::Null:
       type = JSTYPE_OBJECT;
       break;
     case MIRType::Undefined:
       type = JSTYPE_UNDEFINED;
       break;
     case MIRType::Boolean:
       type = JSTYPE_BOOLEAN;
@@ -4220,26 +4204,22 @@ bool MCompare::tryFoldTypeOf(bool* resul
       *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE);
       return true;
     }
   } else if (constant->toString() == TypeName(JSTYPE_SYMBOL, names)) {
     if (!typeOf->input()->mightBeType(MIRType::Symbol)) {
       *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE);
       return true;
     }
-  }
-#ifdef ENABLE_BIGINT
-  else if (constant->toString() == TypeName(JSTYPE_BIGINT, names)) {
+  } else if (constant->toString() == TypeName(JSTYPE_BIGINT, names)) {
     if (!typeOf->input()->mightBeType(MIRType::BigInt)) {
       *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE);
       return true;
     }
-  }
-#endif
-  else if (constant->toString() == TypeName(JSTYPE_OBJECT, names)) {
+  } else if (constant->toString() == TypeName(JSTYPE_OBJECT, names)) {
     if (!typeOf->input()->mightBeType(MIRType::Object) &&
         !typeOf->input()->mightBeType(MIRType::Null)) {
       *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE);
       return true;
     }
   } else if (constant->toString() == TypeName(JSTYPE_FUNCTION, names)) {
     if (!typeOf->inputMaybeCallableOrEmulatesUndefined()) {
       *result = (jsop() == JSOP_STRICTNE || jsop() == JSOP_NE);
@@ -5476,20 +5456,18 @@ bool MFunctionDispatch::appendRoots(MRoo
 }
 
 bool MConstant::appendRoots(MRootList& roots) const {
   switch (type()) {
     case MIRType::String:
       return roots.append(toString());
     case MIRType::Symbol:
       return roots.append(toSymbol());
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       return roots.append(toBigInt());
-#endif
     case MIRType::Object:
       return roots.append(&toObject());
     case MIRType::Undefined:
     case MIRType::Null:
     case MIRType::Boolean:
     case MIRType::Int32:
     case MIRType::Double:
     case MIRType::Float32:
@@ -6217,20 +6195,17 @@ static bool TryAddTypeBarrierForWrite(Te
 
   MIRType propertyType = aggregateProperty->knownMIRType(constraints);
   switch (propertyType) {
     case MIRType::Boolean:
     case MIRType::Int32:
     case MIRType::Double:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
-    case MIRType::BigInt:
-#endif
-    {
+    case MIRType::BigInt: {
       // The property is a particular primitive type, guard by unboxing the
       // value before the write.
       if (!(*pvalue)->mightBeType(propertyType)) {
         // The value's type does not match the property type. Just do a VM
         // call as it will always trigger invalidation of the compiled code.
         MOZ_ASSERT_IF((*pvalue)->type() != MIRType::Value,
                       (*pvalue)->type() != propertyType);
         return false;
--- a/js/src/jit/MIR.h
+++ b/js/src/jit/MIR.h
@@ -885,17 +885,17 @@ class MDefinition : public MNode {
 
   virtual bool canRecoverOnBailout() const { return false; }
 };
 
 static inline bool SimpleArithOperand(MDefinition* op) {
   return !op->emptyResultTypeSet() && !op->mightBeType(MIRType::Object) &&
          !op->mightBeType(MIRType::String) &&
          !op->mightBeType(MIRType::Symbol) &&
-         IF_BIGINT(!op->mightBeType(MIRType::BigInt), true) &&
+         !op->mightBeType(MIRType::BigInt) &&
          !op->mightBeType(MIRType::MagicOptimizedArguments) &&
          !op->mightBeType(MIRType::MagicHole) &&
          !op->mightBeType(MIRType::MagicIsConstructing);
 }
 
 // An MUseDefIterator walks over uses in a definition, skipping any use that is
 // not a definition. Items from the use list must not be deleted during
 // iteration.
@@ -1385,19 +1385,17 @@ class MConstant : public MNullaryInstruc
     union {
       bool b;
       int32_t i32;
       int64_t i64;
       float f;
       double d;
       JSString* str;
       JS::Symbol* sym;
-#ifdef ENABLE_BIGINT
       BigInt* bi;
-#endif
       JSObject* obj;
       uint64_t asBits;
     };
     Payload() : asBits(0) {}
   };
 
   Payload payload_;
 
@@ -1505,22 +1503,20 @@ class MConstant : public MNullaryInstruc
   JSString* toString() const {
     MOZ_ASSERT(type() == MIRType::String);
     return payload_.str;
   }
   JS::Symbol* toSymbol() const {
     MOZ_ASSERT(type() == MIRType::Symbol);
     return payload_.sym;
   }
-#ifdef ENABLE_BIGINT
   BigInt* toBigInt() const {
     MOZ_ASSERT(type() == MIRType::BigInt);
     return payload_.bi;
   }
-#endif
   JSObject& toObject() const {
     MOZ_ASSERT(type() == MIRType::Object);
     return *payload_.obj;
   }
   JSObject* toObjectOrNull() const {
     if (type() == MIRType::Object) {
       return payload_.obj;
     }
@@ -3348,18 +3344,17 @@ class MUnbox final : public MUnaryInstru
       : MUnaryInstruction(classOpcode, ins), mode_(mode) {
     // Only allow unboxing a non MIRType::Value when input and output types
     // don't match. This is often used to force a bailout. Boxing happens
     // during type analysis.
     MOZ_ASSERT_IF(ins->type() != MIRType::Value, type != ins->type());
 
     MOZ_ASSERT(type == MIRType::Boolean || type == MIRType::Int32 ||
                type == MIRType::Double || type == MIRType::String ||
-               type == MIRType::Symbol ||
-               IF_BIGINT(type == MIRType::BigInt, false) ||
+               type == MIRType::Symbol || type == MIRType::BigInt ||
                type == MIRType::Object);
 
     TemporaryTypeSet* resultSet = ins->resultTypeSet();
     if (resultSet && type == MIRType::Object) {
       resultSet = resultSet->cloneObjectsOnly(alloc.lifoAlloc());
     }
 
     setResultType(type);
@@ -3391,21 +3386,19 @@ class MUnbox final : public MUnaryInstru
         kind = Bailout_NonNumericInput;  // Int32s are fine too
         break;
       case MIRType::String:
         kind = Bailout_NonStringInput;
         break;
       case MIRType::Symbol:
         kind = Bailout_NonSymbolInput;
         break;
-#ifdef ENABLE_BIGINT
       case MIRType::BigInt:
         kind = Bailout_NonBigIntInput;
         break;
-#endif
       case MIRType::Object:
         kind = Bailout_NonObjectInput;
         break;
       default:
         MOZ_CRASH("Given MIRType cannot be unboxed.");
     }
 
     return new (alloc) MUnbox(ins, type, mode, kind, alloc);
@@ -3712,17 +3705,17 @@ class MToDouble : public MToFPInstructio
         implicitTruncate_(NoTruncate) {
     setResultType(MIRType::Double);
     setMovable();
 
     // An object might have "valueOf", which means it is effectful.
     // ToNumber(symbol) and ToNumber(bigint) throw.
     if (def->mightBeType(MIRType::Object) ||
         def->mightBeType(MIRType::Symbol) ||
-        IF_BIGINT(def->mightBeType(MIRType::BigInt), false)) {
+        def->mightBeType(MIRType::BigInt)) {
       setGuard();
     }
   }
 
  public:
   INSTRUCTION_HEADER(ToDouble)
   TRIVIAL_NEW_WRAPPERS
 
@@ -3753,21 +3746,19 @@ class MToDouble : public MToFPInstructio
       CompactBufferWriter& writer) const override;
   bool canRecoverOnBailout() const override {
     if (input()->type() == MIRType::Value) {
       return false;
     }
     if (input()->type() == MIRType::Symbol) {
       return false;
     }
-#ifdef ENABLE_BIGINT
     if (input()->type() == MIRType::BigInt) {
       return false;
     }
-#endif
 
     return true;
   }
 
   ALLOW_CLONE(MToDouble)
 };
 
 // Converts a primitive (either typed or untyped) to a float32. If the input is
@@ -3782,17 +3773,17 @@ class MToFloat32 : public MToFPInstructi
         mustPreserveNaN_(false) {
     setResultType(MIRType::Float32);
     setMovable();
 
     // An object might have "valueOf", which means it is effectful.
     // ToNumber(symbol) and ToNumber(BigInt) throw.
     if (def->mightBeType(MIRType::Object) ||
         def->mightBeType(MIRType::Symbol) ||
-        IF_BIGINT(def->mightBeType(MIRType::BigInt), false)) {
+        def->mightBeType(MIRType::BigInt)) {
       setGuard();
     }
   }
 
   explicit MToFloat32(MDefinition* def, bool mustPreserveNaN)
       : MToFloat32(def) {
     mustPreserveNaN_ = mustPreserveNaN;
   }
@@ -4074,17 +4065,17 @@ class MToNumberInt32 : public MUnaryInst
         conversion_(conversion) {
     setResultType(MIRType::Int32);
     setMovable();
 
     // An object might have "valueOf", which means it is effectful.
     // ToNumber(symbol) and ToNumber(BigInt) throw.
     if (def->mightBeType(MIRType::Object) ||
         def->mightBeType(MIRType::Symbol) ||
-        IF_BIGINT(def->mightBeType(MIRType::BigInt), false)) {
+        def->mightBeType(MIRType::BigInt)) {
       setGuard();
     }
   }
 
  public:
   INSTRUCTION_HEADER(ToNumberInt32)
   TRIVIAL_NEW_WRAPPERS
 
@@ -4130,17 +4121,17 @@ class MTruncateToInt32 : public MUnaryIn
       : MUnaryInstruction(classOpcode, def), bytecodeOffset_(bytecodeOffset) {
     setResultType(MIRType::Int32);
     setMovable();
 
     // An object might have "valueOf", which means it is effectful.
     // ToInt32(symbol) and ToInt32(BigInt) throw.
     if (def->mightBeType(MIRType::Object) ||
         def->mightBeType(MIRType::Symbol) ||
-        IF_BIGINT(def->mightBeType(MIRType::BigInt), false)) {
+        def->mightBeType(MIRType::BigInt)) {
       setGuard();
     }
   }
 
  public:
   INSTRUCTION_HEADER(TruncateToInt32)
   TRIVIAL_NEW_WRAPPERS
 
@@ -4173,17 +4164,17 @@ class MToString : public MUnaryInstructi
   explicit MToString(MDefinition* def) : MUnaryInstruction(classOpcode, def) {
     setResultType(MIRType::String);
     setMovable();
 
     // Objects might override toString; Symbol and BigInts throw. We bailout in
     // those cases and run side-effects in baseline instead.
     if (def->mightBeType(MIRType::Object) ||
         def->mightBeType(MIRType::Symbol) ||
-        IF_BIGINT(def->mightBeType(MIRType::BigInt), false)) {
+        def->mightBeType(MIRType::BigInt)) {
       setGuard();
     }
   }
 
  public:
   INSTRUCTION_HEADER(ToString)
   TRIVIAL_NEW_WRAPPERS
 
--- a/js/src/jit/MacroAssembler.cpp
+++ b/js/src/jit/MacroAssembler.cpp
@@ -60,21 +60,19 @@ static void EmitTypeCheck(MacroAssembler
       masm.branchTestBoolean(cond, src, label);
       break;
     case JSVAL_TYPE_STRING:
       masm.branchTestString(cond, src, label);
       break;
     case JSVAL_TYPE_SYMBOL:
       masm.branchTestSymbol(cond, src, label);
       break;
-#ifdef ENABLE_BIGINT
     case JSVAL_TYPE_BIGINT:
       masm.branchTestBigInt(cond, src, label);
       break;
-#endif
     case JSVAL_TYPE_NULL:
       masm.branchTestNull(cond, src, label);
       break;
     case JSVAL_TYPE_UNDEFINED:
       masm.branchTestUndefined(cond, src, label);
       break;
     case JSVAL_TYPE_MAGIC:
       masm.branchTestMagic(cond, src, label);
@@ -99,20 +97,17 @@ void MacroAssembler::guardTypeSet(const 
   // speculatively executed paths.
 
   MOZ_ASSERT(kind == BarrierKind::TypeTagOnly || kind == BarrierKind::TypeSet);
   MOZ_ASSERT(!types->unknown());
 
   Label matched;
   TypeSet::Type tests[] = {TypeSet::Int32Type(),    TypeSet::UndefinedType(),
                            TypeSet::BooleanType(),  TypeSet::StringType(),
-                           TypeSet::SymbolType(),
-#ifdef ENABLE_BIGINT
-                           TypeSet::BigIntType(),
-#endif
+                           TypeSet::SymbolType(),   TypeSet::BigIntType(),
                            TypeSet::NullType(),     TypeSet::MagicArgType(),
                            TypeSet::AnyObjectType()};
 
   // The double type also implies Int32.
   // So replace the int32 test with the double one.
   if (types->hasType(TypeSet::DoubleType())) {
     MOZ_ASSERT(types->hasType(TypeSet::Int32Type()));
     tests[0] = TypeSet::DoubleType();
@@ -3397,21 +3392,19 @@ void MacroAssembler::maybeBranchTestType
         branchTestDouble(Equal, tag, label);
         break;
       case MIRType::String:
         branchTestString(Equal, tag, label);
         break;
       case MIRType::Symbol:
         branchTestSymbol(Equal, tag, label);
         break;
-#ifdef ENABLE_BIGINT
       case MIRType::BigInt:
         branchTestBigInt(Equal, tag, label);
         break;
-#endif
       case MIRType::Object:
         branchTestObject(Equal, tag, label);
         break;
       default:
         MOZ_CRASH("Unsupported type");
     }
   }
 }
--- a/js/src/jit/MacroAssembler.h
+++ b/js/src/jit/MacroAssembler.h
@@ -1427,20 +1427,18 @@ class MacroAssembler : public MacroAssem
   inline void branchTestNumber(Condition cond, Register tag,
                                Label* label) PER_SHARED_ARCH;
   inline void branchTestBoolean(Condition cond, Register tag,
                                 Label* label) PER_SHARED_ARCH;
   inline void branchTestString(Condition cond, Register tag,
                                Label* label) PER_SHARED_ARCH;
   inline void branchTestSymbol(Condition cond, Register tag,
                                Label* label) PER_SHARED_ARCH;
-#ifdef ENABLE_BIGINT
   inline void branchTestBigInt(Condition cond, Register tag,
                                Label* label) PER_SHARED_ARCH;
-#endif
   inline void branchTestNull(Condition cond, Register tag,
                              Label* label) PER_SHARED_ARCH;
   inline void branchTestObject(Condition cond, Register tag,
                                Label* label) PER_SHARED_ARCH;
   inline void branchTestPrimitive(Condition cond, Register tag,
                                   Label* label) PER_SHARED_ARCH;
   inline void branchTestMagic(Condition cond, Register tag,
                               Label* label) PER_SHARED_ARCH;
@@ -1494,23 +1492,21 @@ class MacroAssembler : public MacroAssem
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
 
   inline void branchTestSymbol(Condition cond, const BaseIndex& address,
                                Label* label) PER_SHARED_ARCH;
   inline void branchTestSymbol(Condition cond, const ValueOperand& value,
                                Label* label)
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
 
-#ifdef ENABLE_BIGINT
   inline void branchTestBigInt(Condition cond, const BaseIndex& address,
                                Label* label) PER_SHARED_ARCH;
   inline void branchTestBigInt(Condition cond, const ValueOperand& value,
                                Label* label)
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
-#endif
 
   inline void branchTestNull(Condition cond, const Address& address,
                              Label* label) PER_SHARED_ARCH;
   inline void branchTestNull(Condition cond, const BaseIndex& address,
                              Label* label) PER_SHARED_ARCH;
   inline void branchTestNull(Condition cond, const ValueOperand& value,
                              Label* label)
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
@@ -1558,21 +1554,19 @@ class MacroAssembler : public MacroAssem
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
   inline void branchTestDoubleTruthy(bool truthy, FloatRegister reg,
                                      Label* label) PER_SHARED_ARCH;
   inline void branchTestBooleanTruthy(bool truthy, const ValueOperand& value,
                                       Label* label) PER_ARCH;
   inline void branchTestStringTruthy(bool truthy, const ValueOperand& value,
                                      Label* label)
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
-#ifdef ENABLE_BIGINT
   inline void branchTestBigIntTruthy(bool truthy, const ValueOperand& value,
                                      Label* label)
       DEFINED_ON(arm, arm64, mips32, mips64, x86_shared);
-#endif
 
   // Create an unconditional branch to the address given as argument.
   inline void branchToComputedAddress(const BaseIndex& address) PER_ARCH;
 
  private:
   template <typename T, typename S, typename L>
   inline void branchPtrImpl(Condition cond, const T& lhs, const S& rhs, L label)
       DEFINED_ON(x86_shared);
@@ -1600,21 +1594,19 @@ class MacroAssembler : public MacroAssem
   inline void branchTestBooleanImpl(Condition cond, const T& t, Label* label)
       DEFINED_ON(arm, arm64, x86_shared);
   template <typename T>
   inline void branchTestStringImpl(Condition cond, const T& t, Label* label)
       DEFINED_ON(arm, arm64, x86_shared);
   template <typename T>
   inline void branchTestSymbolImpl(Condition cond, const T& t, Label* label)
       DEFINED_ON(arm, arm64, x86_shared);
-#ifdef ENABLE_BIGINT
   template <typename T>
   inline void branchTestBigIntImpl(Condition cond, const T& t, Label* label)
       DEFINED_ON(arm, arm64, x86_shared);
-#endif
   template <typename T>
   inline void branchTestNullImpl(Condition cond, const T& t, Label* label)
       DEFINED_ON(arm, arm64, x86_shared);
   template <typename T>
   inline void branchTestObjectImpl(Condition cond, const T& t, Label* label)
       DEFINED_ON(arm, arm64, x86_shared);
   template <typename T>
   inline void branchTestGCThingImpl(Condition cond, const T& t, Label* label)
--- a/js/src/jit/Snapshots.cpp
+++ b/js/src/jit/Snapshots.cpp
@@ -338,20 +338,18 @@ static const char* ValTypeToString(JSVal
     case JSVAL_TYPE_INT32:
       return "int32_t";
     case JSVAL_TYPE_DOUBLE:
       return "double";
     case JSVAL_TYPE_STRING:
       return "string";
     case JSVAL_TYPE_SYMBOL:
       return "symbol";
-#ifdef ENABLE_BIGINT
     case JSVAL_TYPE_BIGINT:
       return "BigInt";
-#endif
     case JSVAL_TYPE_BOOLEAN:
       return "boolean";
     case JSVAL_TYPE_OBJECT:
       return "object";
     case JSVAL_TYPE_MAGIC:
       return "magic";
     default:
       MOZ_CRASH("no payload");
--- a/js/src/jit/TypePolicy.cpp
+++ b/js/src/jit/TypePolicy.cpp
@@ -770,19 +770,17 @@ bool ToDoublePolicy::staticAdjustInputs(
       }
       if (conversion == MToFPInstruction::NonNullNonStringPrimitives) {
         return true;
       }
       break;
     case MIRType::Object:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
       // Objects might be effectful. Symbols and BigInts give TypeError.
       break;
     default:
       break;
   }
 
   in = BoxAt(alloc, ins, in);
   ins->replaceOperand(0, in);
@@ -825,19 +823,17 @@ bool ToInt32Policy::staticAdjustInputs(T
       }
       if (conversion == IntConversionInputKind::NumbersOrBoolsOnly) {
         return true;
       }
       break;
     case MIRType::Object:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
       // Objects might be effectful. Symbols and BigInts give TypeError.
       break;
     default:
       break;
   }
 
   in = BoxAt(alloc, ins, in);
   ins->replaceOperand(0, in);
@@ -845,17 +841,17 @@ bool ToInt32Policy::staticAdjustInputs(T
 }
 
 bool ToStringPolicy::staticAdjustInputs(TempAllocator& alloc,
                                         MInstruction* ins) {
   MOZ_ASSERT(ins->isToString());
 
   MIRType type = ins->getOperand(0)->type();
   if (type == MIRType::Object || type == MIRType::Symbol ||
-      IF_BIGINT(type == MIRType::BigInt, false)) {
+      type == MIRType::BigInt) {
     ins->replaceOperand(0, BoxAt(alloc, ins, ins->getOperand(0)));
     return true;
   }
 
   // TODO remove the following line once 966957 has landed
   EnsureOperandNotFloat32(alloc, ins, 0);
 
   return true;
@@ -964,19 +960,17 @@ bool StoreUnboxedScalarPolicy::adjustVal
     case MIRType::Undefined:
       value->setImplicitlyUsedUnchecked();
       value = MConstant::New(alloc, DoubleNaNValue());
       ins->block()->insertBefore(ins, value->toInstruction());
       break;
     case MIRType::Object:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
       value = BoxAt(alloc, ins, value);
       break;
     default:
       MOZ_CRASH("Unexpected type");
   }
 
   if (value != curValue) {
     ins->replaceOperand(valueOperand, value);
--- a/js/src/jit/VMFunctions.cpp
+++ b/js/src/jit/VMFunctions.cpp
@@ -1258,41 +1258,37 @@ void AssertValidSymbolPtr(JSContext* cx,
   if (JSString* desc = sym->description()) {
     MOZ_ASSERT(desc->isAtom());
     AssertValidStringPtr(cx, desc);
   }
 
   MOZ_ASSERT(sym->getAllocKind() == gc::AllocKind::SYMBOL);
 }
 
-#ifdef ENABLE_BIGINT
 void AssertValidBigIntPtr(JSContext* cx, JS::BigInt* bi) {
   AutoUnsafeCallWithABI unsafe;
   // FIXME: check runtime?
   MOZ_ASSERT(cx->zone() == bi->zone());
   MOZ_ASSERT(bi->isAligned());
   MOZ_ASSERT(bi->isTenured());
   MOZ_ASSERT(bi->getAllocKind() == gc::AllocKind::BIGINT);
 }
-#endif
 
 void AssertValidValue(JSContext* cx, Value* v) {
   AutoUnsafeCallWithABI unsafe;
   if (v->isObject()) {
     AssertValidObjectPtr(cx, &v->toObject());
   } else if (v->isString()) {
     AssertValidStringPtr(cx, v->toString());
   } else if (v->isSymbol()) {
     AssertValidSymbolPtr(cx, v->toSymbol());
   }
-#ifdef ENABLE_BIGINT
   else if (v->isBigInt()) {
     AssertValidBigIntPtr(cx, v->toBigInt());
   }
-#endif
 }
 
 bool ObjectIsCallable(JSObject* obj) {
   AutoUnsafeCallWithABI unsafe;
   return obj->isCallable();
 }
 
 bool ObjectIsConstructor(JSObject* obj) {
@@ -1868,32 +1864,28 @@ const VMFunction AddOrUpdateSparseElemen
 
 typedef bool (*GetSparseElementHelperFn)(JSContext* cx, HandleArrayObject obj,
                                          int32_t int_id,
                                          MutableHandleValue result);
 const VMFunction GetSparseElementHelperInfo =
     FunctionInfo<GetSparseElementHelperFn>(GetSparseElementHelper,
                                            "getSparseElementHelper");
 
-#ifdef ENABLE_BIGINT
-template <bool allowBigInt = false>
-#endif
+static bool DoToNumber(JSContext* cx, HandleValue arg,
+                       MutableHandleValue ret) {
+  ret.set(arg);
+  return ToNumber(cx, ret);
+}
+
 static bool DoToNumeric(JSContext* cx, HandleValue arg,
                         MutableHandleValue ret) {
   ret.set(arg);
-#ifdef ENABLE_BIGINT
-  if (allowBigInt) {
-    return ToNumeric(cx, ret);
-  }
-#endif
-  return ToNumber(cx, ret);
+  return ToNumeric(cx, ret);
 }
 
 typedef bool (*ToNumericFn)(JSContext*, HandleValue, MutableHandleValue);
 const VMFunction ToNumberInfo =
-    FunctionInfo<ToNumericFn>(DoToNumeric, "ToNumber");
-#ifdef ENABLE_BIGINT
+    FunctionInfo<ToNumericFn>(DoToNumber, "ToNumber");
 const VMFunction ToNumericInfo =
-    FunctionInfo<ToNumericFn>(DoToNumeric<true>, "ToNumeric");
-#endif
+    FunctionInfo<ToNumericFn>(DoToNumeric, "ToNumeric");
 
 }  // namespace jit
 }  // namespace js
--- a/js/src/jit/VMFunctions.h
+++ b/js/src/jit/VMFunctions.h
@@ -1087,19 +1087,17 @@ JSString* StringReplace(JSContext* cx, H
 MOZ_MUST_USE bool SetDenseElement(JSContext* cx, HandleNativeObject obj,
                                   int32_t index, HandleValue value,
                                   bool strict);
 
 void AssertValidObjectPtr(JSContext* cx, JSObject* obj);
 void AssertValidObjectOrNullPtr(JSContext* cx, JSObject* obj);
 void AssertValidStringPtr(JSContext* cx, JSString* str);
 void AssertValidSymbolPtr(JSContext* cx, JS::Symbol* sym);
-#ifdef ENABLE_BIGINT
 void AssertValidBigIntPtr(JSContext* cx, JS::BigInt* bi);
-#endif
 void AssertValidValue(JSContext* cx, Value* v);
 
 void MarkValueFromJit(JSRuntime* rt, Value* vp);
 void MarkStringFromJit(JSRuntime* rt, JSString** stringp);
 void MarkObjectFromJit(JSRuntime* rt, JSObject** objp);
 void MarkShapeFromJit(JSRuntime* rt, Shape** shapep);
 void MarkObjectGroupFromJit(JSRuntime* rt, ObjectGroup** groupp);
 
@@ -1202,19 +1200,17 @@ extern const VMFunction ProxyHasInfo;
 extern const VMFunction ProxyHasOwnInfo;
 
 extern const VMFunction NativeGetElementInfo;
 
 extern const VMFunction AddOrUpdateSparseElementHelperInfo;
 extern const VMFunction GetSparseElementHelperInfo;
 
 extern const VMFunction ToNumberInfo;
-#ifdef ENABLE_BIGINT
 extern const VMFunction ToNumericInfo;
-#endif
 
 // TailCall VMFunctions
 extern const VMFunction DoConcatStringObjectInfo;
 
 }  // namespace jit
 }  // namespace js
 
 #endif /* jit_VMFunctions_h */
--- a/js/src/jit/arm/MacroAssembler-arm-inl.h
+++ b/js/src/jit/arm/MacroAssembler-arm-inl.h
@@ -1696,17 +1696,16 @@ void MacroAssembler::branchTestSymbol(Co
 
 template <typename T>
 void MacroAssembler::branchTestSymbolImpl(Condition cond, const T& t,
                                           Label* label) {
   Condition c = testSymbol(cond, t);
   ma_b(label, c);
 }
 
-#ifdef ENABLE_BIGINT
 void MacroAssembler::branchTestBigInt(Condition cond, Register tag,
                                       Label* label) {
   branchTestBigIntImpl(cond, tag, label);
 }
 
 void MacroAssembler::branchTestBigInt(Condition cond, const BaseIndex& address,
                                       Label* label) {
   branchTestBigIntImpl(cond, address, label);
@@ -1725,17 +1724,16 @@ void MacroAssembler::branchTestBigIntImp
 }
 
 void MacroAssembler::branchTestBigIntTruthy(bool truthy,
                                             const ValueOperand& value,
                                             Label* label) {
   Condition c = testBigIntTruthy(truthy, value);
   ma_b(label, c);
 }
-#endif
 
 void MacroAssembler::branchTestNull(Condition cond, Register tag,
                                     Label* label) {
   branchTestNullImpl(cond, tag, label);
 }
 
 void MacroAssembler::branchTestNull(Condition cond, const Address& address,
                                     Label* label) {
--- a/js/src/jit/arm/MacroAssembler-arm.cpp
+++ b/js/src/jit/arm/MacroAssembler-arm.cpp
@@ -2414,22 +2414,20 @@ Assembler::Condition MacroAssemblerARMCo
   return testString(cond, value.typeReg());
 }
 
 Assembler::Condition MacroAssemblerARMCompat::testSymbol(
     Assembler::Condition cond, const ValueOperand& value) {
   return testSymbol(cond, value.typeReg());
 }
 
-#ifdef ENABLE_BIGINT
 Assembler::Condition MacroAssemblerARMCompat::testBigInt(
     Assembler::Condition cond, const ValueOperand& value) {
   return testBigInt(cond, value.typeReg());
 }
-#endif
 
 Assembler::Condition MacroAssemblerARMCompat::testObject(
     Assembler::Condition cond, const ValueOperand& value) {
   return testObject(cond, value.typeReg());
 }
 
 Assembler::Condition MacroAssemblerARMCompat::testNumber(
     Assembler::Condition cond, const ValueOperand& value) {
@@ -2484,24 +2482,22 @@ Assembler::Condition MacroAssemblerARMCo
 
 Assembler::Condition MacroAssemblerARMCompat::testSymbol(
     Assembler::Condition cond, Register tag) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ma_cmp(tag, ImmTag(JSVAL_TAG_SYMBOL));
   return cond;
 }
 
-#ifdef ENABLE_BIGINT
 Assembler::Condition MacroAssemblerARMCompat::testBigInt(
     Assembler::Condition cond, Register tag) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ma_cmp(tag, ImmTag(JSVAL_TAG_BIGINT));
   return cond;
 }
-#endif
 
 Assembler::Condition MacroAssemblerARMCompat::testObject(
     Assembler::Condition cond, Register tag) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ma_cmp(tag, ImmTag(JSVAL_TAG_OBJECT));
   return cond;
 }
 
@@ -2589,25 +2585,23 @@ Assembler::Condition MacroAssemblerARMCo
 Assembler::Condition MacroAssemblerARMCompat::testSymbol(
     Condition cond, const Address& address) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ScratchRegisterScope scratch(asMasm());
   Register tag = extractTag(address, scratch);
   return testSymbol(cond, tag);
 }
 
-#ifdef ENABLE_BIGINT
 Assembler::Condition MacroAssemblerARMCompat::testBigInt(
     Condition cond, const Address& address) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ScratchRegisterScope scratch(asMasm());
   Register tag = extractTag(address, scratch);
   return testBigInt(cond, tag);
 }
-#endif
 
 Assembler::Condition MacroAssemblerARMCompat::testObject(
     Condition cond, const Address& address) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ScratchRegisterScope scratch(asMasm());
   Register tag = extractTag(address, scratch);
   return testObject(cond, tag);
 }
@@ -2675,26 +2669,24 @@ Assembler::Condition MacroAssemblerARMCo
                                                          const BaseIndex& src) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ScratchRegisterScope scratch(asMasm());
   Register tag = extractTag(src, scratch);
   ma_cmp(tag, ImmTag(JSVAL_TAG_SYMBOL));
   return cond;
 }
 
-#ifdef ENABLE_BIGINT
 Assembler::Condition MacroAssemblerARMCompat::testBigInt(Condition cond,
                                                          const BaseIndex& src) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ScratchRegisterScope scratch(asMasm());
   Register tag = extractTag(src, scratch);
   ma_cmp(tag, ImmTag(JSVAL_TAG_BIGINT));
   return cond;
 }
-#endif
 
 Assembler::Condition MacroAssemblerARMCompat::testInt32(Condition cond,
                                                         const BaseIndex& src) {
   MOZ_ASSERT(cond == Equal || cond == NotEqual);
   ScratchRegisterScope scratch(asMasm());
   Register tag = extractTag(src, scratch);
   ma_cmp(tag, ImmTag(JSVAL_TAG_INT32));
   return cond;
@@ -3436,29 +3428,27 @@ Assembler::Condition MacroAssemblerARMCo
   ScratchRegisterScope scratch(asMasm());
   SecondScratchRegisterScope scratch2(asMasm());
 
   ma_dtr(IsLoad, string, Imm32(JSString::offsetOfLength()), scratch, scratch2);
   as_cmp(scratch, Imm8(0));
   return truthy ? Assembler::NotEqual : Assembler::Equal;
 }
 
-#ifdef ENABLE_BIGINT
 Assembler::Condition MacroAssemblerARMCompat::testBigIntTruthy(
     bool truthy, const ValueOperand& value) {
   Register bi = value.payloadReg();
   ScratchRegisterScope scratch(asMasm());
   SecondScratchRegisterScope scratch2(asMasm());
 
   ma_dtr(IsLoad, bi, Imm32(BigInt::offsetOfLengthSignAndReservedBits()),
          scratch, scratch2);
   as_cmp(scratch, Imm8(0));
   return truthy ? Assembler::NotEqual : Assembler::Equal;
 }
-#endif
 
 void MacroAssemblerARMCompat::floor(FloatRegister input, Register output,
                                     Label* bail) {
   Label handleZero;
   Label handleNeg;
   Label fin;
 
   ScratchDoubleScope scratchDouble(asMasm());
--- a/js/src/jit/arm/MacroAssembler-arm.h
+++ b/js/src/jit/arm/MacroAssembler-arm.h
@@ -761,64 +761,56 @@ class MacroAssemblerARMCompat : public M
   // Higher level tag testing code.
   Condition testInt32(Condition cond, const ValueOperand& value);
   Condition testBoolean(Condition cond, const ValueOperand& value);
   Condition testDouble(Condition cond, const ValueOperand& value);
   Condition testNull(Condition cond, const ValueOperand& value);
   Condition testUndefined(Condition cond, const ValueOperand& value);
   Condition testString(Condition cond, const ValueOperand& value);
   Condition testSymbol(Condition cond, const ValueOperand& value);
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const ValueOperand& value);
-#endif
   Condition testObject(Condition cond, const ValueOperand& value);
   Condition testNumber(Condition cond, const ValueOperand& value);
   Condition testMagic(Condition cond, const ValueOperand& value);
 
   Condition testPrimitive(Condition cond, const ValueOperand& value);
 
   // Register-based tests.
   Condition testInt32(Condition cond, Register tag);
   Condition testBoolean(Condition cond, Register tag);
   Condition testNull(Condition cond, Register tag);
   Condition testUndefined(Condition cond, Register tag);
   Condition testString(Condition cond, Register tag);
   Condition testSymbol(Condition cond, Register tag);
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, Register tag);
-#endif
   Condition testObject(Condition cond, Register tag);
   Condition testDouble(Condition cond, Register tag);
   Condition testNumber(Condition cond, Register tag);
   Condition testMagic(Condition cond, Register tag);
   Condition testPrimitive(Condition cond, Register tag);
 
   Condition testGCThing(Condition cond, const Address& address);
   Condition testMagic(Condition cond, const Address& address);
   Condition testInt32(Condition cond, const Address& address);
   Condition testDouble(Condition cond, const Address& address);
   Condition testBoolean(Condition cond, const Address& address);
   Condition testNull(Condition cond, const Address& address);
   Condition testUndefined(Condition cond, const Address& address);
   Condition testString(Condition cond, const Address& address);
   Condition testSymbol(Condition cond, const Address& address);
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const Address& address);
-#endif
   Condition testObject(Condition cond, const Address& address);
   Condition testNumber(Condition cond, const Address& address);
 
   Condition testUndefined(Condition cond, const BaseIndex& src);
   Condition testNull(Condition cond, const BaseIndex& src);
   Condition testBoolean(Condition cond, const BaseIndex& src);
   Condition testString(Condition cond, const BaseIndex& src);
   Condition testSymbol(Condition cond, const BaseIndex& src);
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const BaseIndex& src);
-#endif
   Condition testInt32(Condition cond, const BaseIndex& src);
   Condition testObject(Condition cond, const BaseIndex& src);
   Condition testDouble(Condition cond, const BaseIndex& src);
   Condition testMagic(Condition cond, const BaseIndex& src);
   Condition testGCThing(Condition cond, const BaseIndex& src);
 
   // Unboxing code.
   void unboxNonDouble(const ValueOperand& operand, Register dest,
@@ -844,24 +836,22 @@ class MacroAssemblerARMCompat : public M
     unboxNonDouble(src, dest, JSVAL_TYPE_STRING);
   }
   void unboxSymbol(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
   void unboxSymbol(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
-#ifdef ENABLE_BIGINT
   void unboxBigInt(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
   void unboxBigInt(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
-#endif
   void unboxObject(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxObject(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxObject(const BaseIndex& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
@@ -920,19 +910,17 @@ class MacroAssemblerARMCompat : public M
                          int32_t shift = defaultShift);
   void loadConstantDouble(double dp, FloatRegister dest);
 
   // Treat the value as a boolean, and set condition codes accordingly.
   Condition testInt32Truthy(bool truthy, const ValueOperand& operand);
   Condition testBooleanTruthy(bool truthy, const ValueOperand& operand);
   Condition testDoubleTruthy(bool truthy, FloatRegister reg);
   Condition testStringTruthy(bool truthy, const ValueOperand& value);
-#ifdef ENABLE_BIGINT
   Condition testBigIntTruthy(bool truthy, const ValueOperand& value);
-#endif
 
   void boolValueToFloat32(const ValueOperand& operand, FloatRegister dest);
   void int32ValueToFloat32(const ValueOperand& operand, FloatRegister dest);
   void loadConstantFloat32(float f, FloatRegister dest);
 
   CodeOffsetJump jumpWithPatch(RepatchLabel* label);
 
   void loadUnboxedValue(Address address, MIRType type, AnyRegister dest) {
--- a/js/src/jit/arm64/CodeGenerator-arm64.cpp
+++ b/js/src/jit/arm64/CodeGenerator-arm64.cpp
@@ -1247,21 +1247,19 @@ void CodeGenerator::visitUnbox(LUnbox* u
         cond = masm.testObject(Assembler::NotEqual, value);
         break;
       case MIRType::String:
         cond = masm.testString(Assembler::NotEqual, value);
         break;
       case MIRType::Symbol:
         cond = masm.testSymbol(Assembler::NotEqual, value);
         break;
-#ifdef ENABLE_BIGINT
       case MIRType::BigInt:
         cond = masm.testBigInt(Assembler::NotEqual, value);
         break;
-#endif
       default:
         MOZ_CRASH("Given MIRType cannot be unboxed.");
     }
     bailoutIf(cond, unbox->snapshot());
   } else {
 #ifdef DEBUG
     JSValueTag tag = MIRTypeToTag(mir->type());
     Label ok;
@@ -1289,21 +1287,19 @@ void CodeGenerator::visitUnbox(LUnbox* u
       masm.unboxObject(input, result);
       break;
     case MIRType::String:
       masm.unboxString(input, result);
       break;
     case MIRType::Symbol:
       masm.unboxSymbol(input, result);
       break;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       masm.unboxBigInt(input, result);
       break;
-#endif
     default:
       MOZ_CRASH("Given MIRType cannot be unboxed.");
   }
 }
 
 void CodeGenerator::visitDouble(LDouble* ins) {
   ARMFPRegister output(ToFloatRegister(ins->getDef(0)), 64);
   masm.Fmov(output, ins->getDouble());
--- a/js/src/jit/arm64/MacroAssembler-arm64-inl.h
+++ b/js/src/jit/arm64/MacroAssembler-arm64-inl.h
@@ -1405,17 +1405,16 @@ void MacroAssembler::branchTestSymbol(Co
 
 template <typename T>
 void MacroAssembler::branchTestSymbolImpl(Condition cond, const T& t,
                                           Label* label) {
   Condition c = testSymbol(cond, t);
   B(label, c);
 }
 
-#ifdef ENABLE_BIGINT
 void MacroAssembler::branchTestBigInt(Condition cond, Register tag,
                                       Label* label) {
   branchTestBigIntImpl(cond, tag, label);
 }
 
 void MacroAssembler::branchTestBigInt(Condition cond, const BaseIndex& address,
                                       Label* label) {
   branchTestBigIntImpl(cond, address, label);
@@ -1434,17 +1433,16 @@ void MacroAssembler::branchTestBigIntImp
 }
 
 void MacroAssembler::branchTestBigIntTruthy(bool truthy,
                                             const ValueOperand& value,
                                             Label* label) {
   Condition c = testBigIntTruthy(truthy, value);
   B(label, c);
 }
-#endif
 
 void MacroAssembler::branchTestNull(Condition cond, Register tag,
                                     Label* label) {
   branchTestNullImpl(cond, tag, label);
 }
 
 void MacroAssembler::branchTestNull(Condition cond, const Address& address,
                                     Label* label) {
--- a/js/src/jit/arm64/MacroAssembler-arm64.h
+++ b/js/src/jit/arm64/MacroAssembler-arm64.h
@@ -1389,24 +1389,22 @@ class MacroAssemblerCompat : public vixl
     unboxNonDouble(src, dest, JSVAL_TYPE_STRING);
   }
   void unboxSymbol(const ValueOperand& operand, Register dest) {
     unboxNonDouble(operand, dest, JSVAL_TYPE_SYMBOL);
   }
   void unboxSymbol(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
-#ifdef ENABLE_BIGINT
   void unboxBigInt(const ValueOperand& operand, Register dest) {
     unboxNonDouble(operand, dest, JSVAL_TYPE_BIGINT);
   }
   void unboxBigInt(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
-#endif
   // These two functions use the low 32-bits of the full value register.
   void boolValueToDouble(const ValueOperand& operand, FloatRegister dest) {
     convertInt32ToDouble(operand.valueReg(), dest);
   }
   void int32ValueToDouble(const ValueOperand& operand, FloatRegister dest) {
     convertInt32ToDouble(operand.valueReg(), dest);
   }
 
@@ -1482,23 +1480,21 @@ class MacroAssemblerCompat : public vixl
     cmpTag(tag, ImmTag(JSVAL_TAG_STRING));
     return cond;
   }
   Condition testSymbol(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmpTag(tag, ImmTag(JSVAL_TAG_SYMBOL));
     return cond;
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmpTag(tag, ImmTag(JSVAL_TAG_BIGINT));
     return cond;
   }
-#endif
   Condition testObject(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmpTag(tag, ImmTag(JSVAL_TAG_OBJECT));
     return cond;
   }
   Condition testDouble(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmpTag(tag, ImmTag(JSVAL_TAG_MAX_DOUBLE));
@@ -1579,25 +1575,23 @@ class MacroAssemblerCompat : public vixl
   }
   Condition testSymbol(Condition cond, const ValueOperand& value) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(value.valueReg() != scratch);
     splitSignExtTag(value, scratch);
     return testSymbol(cond, scratch);
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const ValueOperand& value) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(value.valueReg() != scratch);
     splitSignExtTag(value, scratch);
     return testBigInt(cond, scratch);
   }
-#endif
   Condition testObject(Condition cond, const ValueOperand& value) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(value.valueReg() != scratch);
     splitSignExtTag(value, scratch);
     return testObject(cond, scratch);
   }
   Condition testNumber(Condition cond, const ValueOperand& value) {
@@ -1684,25 +1678,23 @@ class MacroAssemblerCompat : public vixl
   }
   Condition testSymbol(Condition cond, const Address& address) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(address.base != scratch);
     splitSignExtTag(address, scratch);
     return testSymbol(cond, scratch);
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const Address& address) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(address.base != scratch);
     splitSignExtTag(address, scratch);
     return testBigInt(cond, scratch);
   }
-#endif
   Condition testObject(Condition cond, const Address& address) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(address.base != scratch);
     splitSignExtTag(address, scratch);
     return testObject(cond, scratch);
   }
   Condition testNumber(Condition cond, const Address& address) {
@@ -1749,17 +1741,16 @@ class MacroAssemblerCompat : public vixl
   Condition testSymbol(Condition cond, const BaseIndex& src) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(src.base != scratch);
     MOZ_ASSERT(src.index != scratch);
     splitSignExtTag(src, scratch);
     return testSymbol(cond, scratch);
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const BaseIndex& src) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(src.base != scratch);
     MOZ_ASSERT(src.index != scratch);
     splitSignExtTag(src, scratch);
     return testBigInt(cond, scratch);
   }
@@ -1771,17 +1762,16 @@ class MacroAssemblerCompat : public vixl
     MOZ_ASSERT(value.valueReg() != scratch);
 
     unboxBigInt(value, scratch);
     Ldr(scratch64,
         MemOperand(scratch64, BigInt::offsetOfLengthSignAndReservedBits()));
     Cmp(scratch64, Operand(0));
     return truthy ? Condition::NonZero : Condition::Zero;
   }
-#endif
   Condition testInt32(Condition cond, const BaseIndex& src) {
     vixl::UseScratchRegisterScope temps(this);
     const Register scratch = temps.AcquireX().asUnsized();
     MOZ_ASSERT(src.base != scratch);
     MOZ_ASSERT(src.index != scratch);
     splitSignExtTag(src, scratch);
     return testInt32(cond, scratch);
   }
--- a/js/src/jit/mips32/MacroAssembler-mips32-inl.h
+++ b/js/src/jit/mips32/MacroAssembler-mips32-inl.h
@@ -809,30 +809,28 @@ void MacroAssembler::branchTestStringTru
   ma_b(scratch2, Imm32(0), label, b ? NotEqual : Equal);
 }
 
 void MacroAssembler::branchTestSymbol(Condition cond, const ValueOperand& value,
                                       Label* label) {
   branchTestSymbol(cond, value.typeReg(), label);
 }
 
-#ifdef ENABLE_BIGINT
 void MacroAssembler::branchTestBigInt(Condition cond, const ValueOperand& value,
                                       Label* label) {
   branchTestBigInt(cond, value.typeReg(), label);
 }
 
 void MacroAssembler::branchTestBigIntTruthy(bool b, const ValueOperand& value,
                                             Label* label) {
   Register bi = value.payloadReg();
   SecondScratchRegisterScope scratch2(*this);
   ma_lw(scratch2, Address(bi, BigInt::offsetOfLengthSignAndReservedBits()));
   ma_b(scratch2, Imm32(0), label, b ? NotEqual : Equal);
 }
-#endif
 
 void MacroAssembler::branchTestNull(Condition cond, const ValueOperand& value,
                                     Label* label) {
   branchTestNull(cond, value.typeReg(), label);
 }
 
 void MacroAssembler::branchTestObject(Condition cond, const ValueOperand& value,
                                       Label* label) {
--- a/js/src/jit/mips64/CodeGenerator-mips64.cpp
+++ b/js/src/jit/mips64/CodeGenerator-mips64.cpp
@@ -73,20 +73,18 @@ void CodeGenerator::visitUnbox(LUnbox* u
         masm.unboxObject(inputReg, result);
         break;
       case MIRType::String:
         masm.unboxString(inputReg, result);
         break;
       case MIRType::Symbol:
         masm.unboxSymbol(inputReg, result);
         break;
-#ifdef ENABLE_BIGINT
       case MIRType::BigInt:
         masm.unboxBigInt(inputReg, result);
-#endif
       default:
         MOZ_CRASH("Given MIRType cannot be unboxed.");
     }
     return;
   }
 
   Address inputAddr = ToAddress(input);
   switch (mir->type()) {
@@ -100,20 +98,18 @@ void CodeGenerator::visitUnbox(LUnbox* u
       masm.unboxObject(inputAddr, result);
       break;
     case MIRType::String:
       masm.unboxString(inputAddr, result);
       break;
     case MIRType::Symbol:
       masm.unboxSymbol(inputAddr, result);
       break;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       masm.unboxBigInt(inputAddr, result);
-#endif
     default:
       MOZ_CRASH("Given MIRType cannot be unboxed.");
   }
 }
 
 void CodeGeneratorMIPS64::splitTagForTest(const ValueOperand& value,
                                           ScratchTagScope& tag) {
   masm.splitTag(value.valueReg(), tag);
--- a/js/src/jit/mips64/MacroAssembler-mips64-inl.h
+++ b/js/src/jit/mips64/MacroAssembler-mips64-inl.h
@@ -541,33 +541,31 @@ void MacroAssembler::branchTestStringTru
 
 void MacroAssembler::branchTestSymbol(Condition cond, const ValueOperand& value,
                                       Label* label) {
   SecondScratchRegisterScope scratch2(*this);
   splitTag(value, scratch2);
   branchTestSymbol(cond, scratch2, label);
 }
 
-#ifdef ENABLE_BIGINT
 void MacroAssembler::branchTestBigInt(Condition cond, const ValueOperand& value,
                                       Label* label) {
   SecondScratchRegisterScope scratch2(*this);
   splitTag(value, scratch2);
   branchTestBigInt(cond, scratch2, label);
 }
 
 void MacroAssembler::branchTestBigIntTruthy(bool b, const ValueOperand& value,
                                             Label* label) {
   SecondScratchRegisterScope scratch2(*this);
   unboxBigInt(value, scratch2);
   loadPtr(Address(scratch2, BigInt::offsetOfLengthSignAndReservedBits()),
           scratch2);
   ma_b(scratch2, ImmWord(0), label, b ? NotEqual : Equal);
 }
-#endif
 
 void MacroAssembler::branchTestNull(Condition cond, const ValueOperand& value,
                                     Label* label) {
   SecondScratchRegisterScope scratch2(*this);
   splitTag(value, scratch2);
   branchTestNull(cond, scratch2, label);
 }
 
--- a/js/src/jit/mips64/MacroAssembler-mips64.cpp
+++ b/js/src/jit/mips64/MacroAssembler-mips64.cpp
@@ -1261,31 +1261,29 @@ void MacroAssemblerMIPS64Compat::unboxSy
   unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
 }
 
 void MacroAssemblerMIPS64Compat::unboxSymbol(const Address& src,
                                              Register dest) {
   unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
 }
 
-#ifdef ENABLE_BIGINT
 void MacroAssemblerMIPS64Compat::unboxBigInt(const ValueOperand& operand,
                                              Register dest) {
   unboxNonDouble(operand, dest, JSVAL_TYPE_BIGINT);
 }
 
 void MacroAssemblerMIPS64Compat::unboxBigInt(Register src, Register dest) {
   unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
 }
 
 void MacroAssemblerMIPS64Compat::unboxBigInt(const Address& src,
                                              Register dest) {
   unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
 }
-#endif
 
 void MacroAssemblerMIPS64Compat::unboxObject(const ValueOperand& src,
                                              Register dest) {
   unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
 }
 
 void MacroAssemblerMIPS64Compat::unboxObject(Register src, Register dest) {
   unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
--- a/js/src/jit/mips64/MacroAssembler-mips64.h
+++ b/js/src/jit/mips64/MacroAssembler-mips64.h
@@ -393,21 +393,19 @@ class MacroAssemblerMIPS64Compat : publi
   void unboxDouble(Register src, Register dest);
   void unboxDouble(const Address& src, FloatRegister dest);
   void unboxString(const ValueOperand& operand, Register dest);
   void unboxString(Register src, Register dest);
   void unboxString(const Address& src, Register dest);
   void unboxSymbol(const ValueOperand& src, Register dest);
   void unboxSymbol(Register src, Register dest);
   void unboxSymbol(const Address& src, Register dest);
-#ifdef ENABLE_BIGINT
   void unboxBigInt(const ValueOperand& operand, Register dest);
   void unboxBigInt(Register src, Register dest);
   void unboxBigInt(const Address& src, Register dest);
-#endif
   void unboxObject(const ValueOperand& src, Register dest);
   void unboxObject(Register src, Register dest);
   void unboxObject(const Address& src, Register dest);
   void unboxObject(const BaseIndex& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxValue(const ValueOperand& src, AnyRegister dest, JSValueType type);
   void unboxPrivate(const ValueOperand& src, Register dest);
--- a/js/src/jit/none/MacroAssembler-none.h
+++ b/js/src/jit/none/MacroAssembler-none.h
@@ -458,22 +458,20 @@ class MacroAssemblerNone : public Assemb
   template <typename T>
   void unboxString(T, Register) {
     MOZ_CRASH();
   }
   template <typename T>
   void unboxSymbol(T, Register) {
     MOZ_CRASH();
   }
-#ifdef ENABLE_BIGINT
   template <typename T>
   void unboxBigInt(T, Register) {
     MOZ_CRASH();
   }
-#endif
   template <typename T>
   void unboxObject(T, Register) {
     MOZ_CRASH();
   }
   template <typename T>
   void unboxDouble(T, FloatRegister) {
     MOZ_CRASH();
   }
@@ -523,19 +521,17 @@ class MacroAssemblerNone : public Assemb
   void boolValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
   void int32ValueToDouble(ValueOperand, FloatRegister) { MOZ_CRASH(); }
   void int32ValueToFloat32(ValueOperand, FloatRegister) { MOZ_CRASH(); }
 
   void loadConstantDouble(double, FloatRegister) { MOZ_CRASH(); }
   void loadConstantFloat32(float, FloatRegister) { MOZ_CRASH(); }
   Condition testInt32Truthy(bool, ValueOperand) { MOZ_CRASH(); }
   Condition testStringTruthy(bool, ValueOperand) { MOZ_CRASH(); }
-#ifdef ENABLE_BIGINT
   Condition testBigIntTruthy(bool, ValueOperand) { MOZ_CRASH(); }
-#endif
 
   template <typename T>
   void loadUnboxedValue(T, MIRType, AnyRegister) {
     MOZ_CRASH();
   }
   template <typename T>
   void storeUnboxedValue(const ConstantOrRegister&, MIRType, T, MIRType) {
     MOZ_CRASH();
--- a/js/src/jit/shared/CodeGenerator-shared.cpp
+++ b/js/src/jit/shared/CodeGenerator-shared.cpp
@@ -429,19 +429,17 @@ void CodeGeneratorShared::encodeAllocati
       alloc = RValueAllocation::Undefined();
       break;
     case MIRType::Null:
       alloc = RValueAllocation::Null();
       break;
     case MIRType::Int32:
     case MIRType::String:
     case MIRType::Symbol:
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
-#endif
     case MIRType::Object:
     case MIRType::ObjectOrNull:
     case MIRType::Boolean:
     case MIRType::Double: {
       LAllocation* payload = snapshot->payloadOfSlot(*allocIndex);
       if (payload->isConstant()) {
         MConstant* constant = mir->toConstant();
         uint32_t index;
--- a/js/src/jit/shared/Lowering-shared-inl.h
+++ b/js/src/jit/shared/Lowering-shared-inl.h
@@ -425,20 +425,17 @@ void LIRGeneratorShared::redefine(MDefin
     if (JitOptions.runExtraChecks && def->resultTypeSet() &&
         as->resultTypeSet() &&
         !def->resultTypeSet()->equals(as->resultTypeSet())) {
       switch (def->type()) {
         case MIRType::Object:
         case MIRType::ObjectOrNull:
         case MIRType::String:
         case MIRType::Symbol:
-#  ifdef ENABLE_BIGINT
-        case MIRType::BigInt:
-#  endif
-        {
+        case MIRType::BigInt: {
           LAssertResultT* check =
               new (alloc()) LAssertResultT(useRegister(def));
           add(check, def->toInstruction());
           break;
         }
         case MIRType::Value: {
           LAssertResultV* check = new (alloc()) LAssertResultV(useBox(def));
           add(check, def->toInstruction());
--- a/js/src/jit/x64/CodeGenerator-x64.cpp
+++ b/js/src/jit/x64/CodeGenerator-x64.cpp
@@ -80,21 +80,19 @@ void CodeGenerator::visitUnbox(LUnbox* u
         cond = masm.testObject(Assembler::NotEqual, value);
         break;
       case MIRType::String:
         cond = masm.testString(Assembler::NotEqual, value);
         break;
       case MIRType::Symbol:
         cond = masm.testSymbol(Assembler::NotEqual, value);
         break;
-#ifdef ENABLE_BIGINT
       case MIRType::BigInt:
         cond = masm.testBigInt(Assembler::NotEqual, value);
         break;
-#endif
       default:
         MOZ_CRASH("Given MIRType cannot be unboxed.");
     }
     bailoutIf(cond, unbox->snapshot());
   } else {
 #ifdef DEBUG
     Operand input = ToOperand(unbox->getOperand(LUnbox::Input));
     JSValueTag tag = MIRTypeToTag(mir->type());
@@ -119,21 +117,19 @@ void CodeGenerator::visitUnbox(LUnbox* u
       masm.unboxObject(input, result);
       break;
     case MIRType::String:
       masm.unboxString(input, result);
       break;
     case MIRType::Symbol:
       masm.unboxSymbol(input, result);
       break;
-#ifdef ENABLE_BIGINT
     case MIRType::BigInt:
       masm.unboxBigInt(input, result);
       break;
-#endif
     default:
       MOZ_CRASH("Given MIRType cannot be unboxed.");
   }
 }
 
 void CodeGenerator::visitCompareB(LCompareB* lir) {
   MCompare* mir = lir->mir();
 
--- a/js/src/jit/x64/MacroAssembler-x64.h
+++ b/js/src/jit/x64/MacroAssembler-x64.h
@@ -250,23 +250,21 @@ class MacroAssemblerX64 : public MacroAs
     cmp32(tag, ImmTag(JSVAL_TAG_STRING));
     return cond;
   }
   Condition testSymbol(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_TAG_SYMBOL));
     return cond;
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_TAG_BIGINT));
     return cond;
   }
-#endif
   Condition testObject(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_TAG_OBJECT));
     return cond;
   }
   Condition testDouble(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, Imm32(JSVAL_TAG_MAX_DOUBLE));
@@ -332,23 +330,21 @@ class MacroAssemblerX64 : public MacroAs
     splitTag(src, scratch);
     return testString(cond, scratch);
   }
   Condition testSymbol(Condition cond, const ValueOperand& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testSymbol(cond, scratch);
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const ValueOperand& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testBigInt(cond, scratch);
   }
-#endif
   Condition testObject(Condition cond, const ValueOperand& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testObject(cond, scratch);
   }
   Condition testGCThing(Condition cond, const ValueOperand& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
@@ -392,23 +388,21 @@ class MacroAssemblerX64 : public MacroAs
     splitTag(src, scratch);
     return testString(cond, scratch);
   }
   Condition testSymbol(Condition cond, const Address& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testSymbol(cond, scratch);
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const Address& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testBigInt(cond, scratch);
   }
-#endif
   Condition testObject(Condition cond, const Address& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testObject(cond, scratch);
   }
   Condition testPrimitive(Condition cond, const Address& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
@@ -445,23 +439,21 @@ class MacroAssemblerX64 : public MacroAs
     splitTag(src, scratch);
     return testString(cond, scratch);
   }
   Condition testSymbol(Condition cond, const BaseIndex& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testSymbol(cond, scratch);
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const BaseIndex& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testBigInt(cond, scratch);
   }
-#endif
   Condition testInt32(Condition cond, const BaseIndex& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
     return testInt32(cond, scratch);
   }
   Condition testObject(Condition cond, const BaseIndex& src) {
     ScratchRegisterScope scratch(asMasm());
     splitTag(src, scratch);
@@ -823,24 +815,22 @@ class MacroAssemblerX64 : public MacroAs
 
   void unboxSymbol(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
   void unboxSymbol(const Operand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
 
-#ifdef ENABLE_BIGINT
   void unboxBigInt(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
   void unboxBigInt(const Operand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
-#endif
 
   void unboxObject(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxObject(const Operand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxObject(const Address& src, Register dest) {
@@ -952,25 +942,23 @@ class MacroAssemblerX64 : public MacroAs
     return truthy ? NonZero : Zero;
   }
   Condition testStringTruthy(bool truthy, const ValueOperand& value) {
     ScratchRegisterScope scratch(asMasm());
     unboxString(value, scratch);
     cmp32(Operand(scratch, JSString::offsetOfLength()), Imm32(0));
     return truthy ? Assembler::NotEqual : Assembler::Equal;
   }
-#ifdef ENABLE_BIGINT
   Condition testBigIntTruthy(bool truthy, const ValueOperand& value) {
     ScratchRegisterScope scratch(asMasm());
     unboxBigInt(value, scratch);
     cmpPtr(Operand(scratch, BigInt::offsetOfLengthSignAndReservedBits()),
            ImmWord(0));
     return truthy ? Assembler::NotEqual : Assembler::Equal;
   }
-#endif
 
   template <typename T>
   inline void loadInt32OrDouble(const T& src, FloatRegister dest);
 
   template <typename T>
   void loadUnboxedValue(const T& src, MIRType type, AnyRegister dest) {
     if (dest.isFloat()) {
       loadInt32OrDouble(src, dest.fpu());
--- a/js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
+++ b/js/src/jit/x86-shared/MacroAssembler-x86-shared-inl.h
@@ -796,17 +796,16 @@ void MacroAssembler::branchTestSymbol(Co
 
 template <typename T>
 void MacroAssembler::branchTestSymbolImpl(Condition cond, const T& t,
                                           Label* label) {
   cond = testSymbol(cond, t);
   j(cond, label);
 }
 
-#ifdef ENABLE_BIGINT
 void MacroAssembler::branchTestBigInt(Condition cond, Register tag,
                                       Label* label) {
   branchTestBigIntImpl(cond, tag, label);
 }
 
 void MacroAssembler::branchTestBigInt(Condition cond, const BaseIndex& address,
                                       Label* label) {
   branchTestBigIntImpl(cond, address, label);
@@ -825,17 +824,16 @@ void MacroAssembler::branchTestBigIntImp
 }
 
 void MacroAssembler::branchTestBigIntTruthy(bool truthy,
                                             const ValueOperand& value,
                                             Label* label) {
   Condition cond = testBigIntTruthy(truthy, value);
   j(cond, label);
 }
-#endif
 
 void MacroAssembler::branchTestNull(Condition cond, Register tag,
                                     Label* label) {
   branchTestNullImpl(cond, tag, label);
 }
 
 void MacroAssembler::branchTestNull(Condition cond, const Address& address,
                                     Label* label) {
--- a/js/src/jit/x86/MacroAssembler-x86.h
+++ b/js/src/jit/x86/MacroAssembler-x86.h
@@ -304,23 +304,21 @@ class MacroAssemblerX86 : public MacroAs
     cmp32(tag, ImmTag(JSVAL_TAG_STRING));
     return cond;
   }
   Condition testSymbol(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_TAG_SYMBOL));
     return cond;
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_TAG_BIGINT));
     return cond;
   }
-#endif
   Condition testObject(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_TAG_OBJECT));
     return cond;
   }
   Condition testNumber(Condition cond, Register tag) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tag, ImmTag(JSVAL_UPPER_INCL_TAG_OF_NUMBER_SET));
@@ -426,21 +424,19 @@ class MacroAssemblerX86 : public MacroAs
     return testNull(cond, value.typeReg());
   }
   Condition testString(Condition cond, const ValueOperand& value) {
     return testString(cond, value.typeReg());
   }
   Condition testSymbol(Condition cond, const ValueOperand& value) {
     return testSymbol(cond, value.typeReg());
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const ValueOperand& value) {
     return testBigInt(cond, value.typeReg());
   }
-#endif
   Condition testObject(Condition cond, const ValueOperand& value) {
     return testObject(cond, value.typeReg());
   }
   Condition testMagic(Condition cond, const ValueOperand& value) {
     return testMagic(cond, value.typeReg());
   }
   Condition testError(Condition cond, const ValueOperand& value) {
     return testMagic(cond, value);
@@ -480,23 +476,21 @@ class MacroAssemblerX86 : public MacroAs
     cmp32(tagOf(address), ImmTag(JSVAL_TAG_STRING));
     return cond;
   }
   Condition testSymbol(Condition cond, const BaseIndex& address) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tagOf(address), ImmTag(JSVAL_TAG_SYMBOL));
     return cond;
   }
-#ifdef ENABLE_BIGINT
   Condition testBigInt(Condition cond, const BaseIndex& address) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tagOf(address), ImmTag(JSVAL_TAG_BIGINT));
     return cond;
   }
-#endif
   Condition testInt32(Condition cond, const BaseIndex& address) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tagOf(address), ImmTag(JSVAL_TAG_INT32));
     return cond;
   }
   Condition testObject(Condition cond, const BaseIndex& address) {
     MOZ_ASSERT(cond == Equal || cond == NotEqual);
     cmp32(tagOf(address), ImmTag(JSVAL_TAG_OBJECT));
@@ -761,24 +755,22 @@ class MacroAssemblerX86 : public MacroAs
     unboxNonDouble(src, dest, JSVAL_TYPE_STRING);
   }
   void unboxSymbol(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
   void unboxSymbol(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_SYMBOL);
   }
-#ifdef ENABLE_BIGINT
   void unboxBigInt(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
   void unboxBigInt(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_BIGINT);
   }
-#endif
   void unboxObject(const ValueOperand& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxObject(const Address& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
   }
   void unboxObject(const BaseIndex& src, Register dest) {
     unboxNonDouble(src, dest, JSVAL_TYPE_OBJECT);
@@ -885,24 +877,22 @@ class MacroAssemblerX86 : public MacroAs
     test32(operand.payloadReg(), operand.payloadReg());
     return truthy ? NonZero : Zero;
   }
   Condition testStringTruthy(bool truthy, const ValueOperand& value) {
     Register string = value.payloadReg();
     cmp32(Operand(string, JSString::offsetOfLength()), Imm32(0));
     return truthy ? Assembler::NotEqual : Assembler::Equal;
   }
-#ifdef ENABLE_BIGINT
   Condition testBigIntTruthy(bool truthy, const ValueOperand& value) {
     Register bi = value.payloadReg();
     cmpPtr(Operand(bi, BigInt::offsetOfLengthSignAndReservedBits()),
            ImmWord(0));
     return truthy ? Assembler::NotEqual : Assembler::Equal;
   }
-#endif
 
   template <typename T>
   inline void loadInt32OrDouble(const T& src, FloatRegister dest);
 
   template <typename T>
   inline void loadUnboxedValue(const T& src, MIRType type, AnyRegister dest);
 
   template <typename T>
--- a/js/src/jsapi-tests/testJitRValueAlloc.cpp
+++ b/js/src/jsapi-tests/testJitRValueAlloc.cpp
@@ -63,17 +63,17 @@ BEGIN_TEST(testJitRValueAlloc_TypedReg) 
 #define FOR_EACH_JSVAL(_)       \
   /* _(JSVAL_TYPE_DOUBLE) */    \
   _(JSVAL_TYPE_INT32)           \
   /* _(JSVAL_TYPE_UNDEFINED) */ \
   _(JSVAL_TYPE_BOOLEAN)         \
   /* _(JSVAL_TYPE_MAGIC) */     \
   _(JSVAL_TYPE_STRING)          \
   _(JSVAL_TYPE_SYMBOL)          \
-  IF_BIGINT(_(JSVAL_TYPE_BIGINT),) \
+  _(JSVAL_TYPE_BIGINT)          \
   /* _(JSVAL_TYPE_NULL) */      \
   _(JSVAL_TYPE_OBJECT)
 
 #define CHECK_WITH_JSVAL(jsval)                              \
   s = RValueAllocation::Typed(jsval, Register::FromCode(i)); \
   CHECK(s == Read(s));
 
     FOR_EACH_JSVAL(CHECK_WITH_JSVAL)
@@ -91,17 +91,17 @@ BEGIN_TEST(testJitRValueAlloc_TypedStack
 #define FOR_EACH_JSVAL(_)       \
   _(JSVAL_TYPE_DOUBLE)          \
   _(JSVAL_TYPE_INT32)           \
   /* _(JSVAL_TYPE_UNDEFINED) */ \
   _(JSVAL_TYPE_BOOLEAN)         \
   /* _(JSVAL_TYPE_MAGIC) */     \
   _(JSVAL_TYPE_STRING)          \
   _(JSVAL_TYPE_SYMBOL)          \
-  IF_BIGINT(_(JSVAL_TYPE_BIGINT),) \
+  _(JSVAL_TYPE_BIGINT)          \
   /* _(JSVAL_TYPE_NULL) */      \
   _(JSVAL_TYPE_OBJECT)
 
 #define CHECK_WITH_JSVAL(jsval)          \
   s = RValueAllocation::Typed(jsval, i); \
   CHECK(s == Read(s));
 
     FOR_EACH_JSVAL(CHECK_WITH_JSVAL)
--- a/js/src/jsapi-tests/tests.cpp
+++ b/js/src/jsapi-tests/tests.cpp
@@ -75,19 +75,17 @@ bool JSAPITest::definePrint() {
   return JS_DefineFunction(cx, global, "print", (JSNative)print, 0, 0);
 }
 
 JSObject* JSAPITest::createGlobal(JSPrincipals* principals) {
   /* Create the global object. */
   JS::RootedObject newGlobal(cx);
   JS::RealmOptions options;
   options.creationOptions().setStreamsEnabled(true);
-#ifdef ENABLE_BIGINT
   options.creationOptions().setBigIntEnabled(true);
-#endif
   newGlobal = JS_NewGlobalObject(cx, getGlobalClass(), principals,
                                  JS::FireOnNewGlobalHook, options);
   if (!newGlobal) {
     return nullptr;
   }
 
   JSAutoRealm ar(cx, newGlobal);
 
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -3419,19 +3419,17 @@ void JS::TransitiveCompileOptions::copyP
   forceAsync = rhs.forceAsync;
   sourceIsLazy = rhs.sourceIsLazy;
   introductionType = rhs.introductionType;
   introductionLineno = rhs.introductionLineno;
   introductionOffset = rhs.introductionOffset;
   hasIntroductionInfo = rhs.hasIntroductionInfo;
   isProbablySystemCode = rhs.isProbablySystemCode;
   hideScriptFromDebugger = rhs.hideScriptFromDebugger;
-#ifdef ENABLE_BIGINT
   bigIntEnabledOption = rhs.bigIntEnabledOption;
-#endif
 };
 
 void JS::ReadOnlyCompileOptions::copyPODOptions(
     const ReadOnlyCompileOptions& rhs) {
   copyPODTransitiveOptions(rhs);
   lineno = rhs.lineno;
   column = rhs.column;
   scriptSourceOffset = rhs.scriptSourceOffset;
@@ -3548,19 +3546,17 @@ JS::CompileOptions::CompileOptions(JSCon
     asmJSOption = AsmJSOption::Disabled;
   } else if (cx->realm()->debuggerObservesAsmJS()) {
     asmJSOption = AsmJSOption::DisabledByDebugger;
   } else {
     asmJSOption = AsmJSOption::Enabled;
   }
   throwOnAsmJSValidationFailureOption =
       cx->options().throwOnAsmJSValidationFailure();
-#ifdef ENABLE_BIGINT
   bigIntEnabledOption = cx->realm()->creationOptions().getBigIntEnabled();
-#endif
 }
 
 CompileOptions& CompileOptions::setIntroductionInfoToCaller(
     JSContext* cx, const char* introductionType) {
   RootedScript maybeScript(cx);
   const char* filename;
   unsigned lineno;
   uint32_t pcOffset;
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -958,19 +958,17 @@ class JS_PUBLIC_API RealmCreationOptions
         compSpec_(CompartmentSpecifier::NewCompartmentAndZone),
         comp_(nullptr),
         invisibleToDebugger_(false),
         mergeable_(false),
         preserveJitCode_(false),
         cloneSingletons_(false),
         sharedMemoryAndAtomics_(false),
         streams_(false),
-#ifdef ENABLE_BIGINT
         bigint_(false),
-#endif
         secureContext_(false),
         clampAndJitterTime_(true) {
   }
 
   JSTraceOp getTrace() const { return traceGlobal_; }
   RealmCreationOptions& setTrace(JSTraceOp op) {
     traceGlobal_ = op;
     return *this;
@@ -1037,23 +1035,21 @@ class JS_PUBLIC_API RealmCreationOptions
   RealmCreationOptions& setSharedMemoryAndAtomicsEnabled(bool flag);
 
   bool getStreamsEnabled() const { return streams_; }
   RealmCreationOptions& setStreamsEnabled(bool flag) {
     streams_ = flag;
     return *this;
   }
 
-#ifdef ENABLE_BIGINT
   bool getBigIntEnabled() const { return bigint_; }
   RealmCreationOptions& setBigIntEnabled(bool flag) {
     bigint_ = flag;
     return *this;
   }
-#endif
 
   // This flag doesn't affect JS engine behavior.  It is used by Gecko to
   // mark whether content windows and workers are "Secure Context"s. See
   // https://w3c.github.io/webappsec-secure-contexts/
   // https://bugzilla.mozilla.org/show_bug.cgi?id=1162772#c34
   bool secureContext() const { return secureContext_; }
   RealmCreationOptions& setSecureContext(bool flag) {
     secureContext_ = flag;
@@ -1074,19 +1070,17 @@ class JS_PUBLIC_API RealmCreationOptions
     JS::Zone* zone_;
   };
   bool invisibleToDebugger_;
   bool mergeable_;
   bool preserveJitCode_;
   bool cloneSingletons_;
   bool sharedMemoryAndAtomics_;
   bool streams_;
-#ifdef ENABLE_BIGINT
   bool bigint_;
-#endif
   bool secureContext_;
   bool clampAndJitterTime_;
 };
 
 /**
  * RealmBehaviors specifies behaviors of a realm that can be changed after the
  * realm's been created.
  */
--- a/js/src/jsexn.cpp
+++ b/js/src/jsexn.cpp
@@ -1063,25 +1063,21 @@ const char* js::ValueToSourceForError(JS
   } else if (val.isNumber()) {
     if (!sb.append("the number ")) {
       return "<<error converting value to string>>";
     }
   } else if (val.isString()) {
     if (!sb.append("the string ")) {
       return "<<error converting value to string>>";
     }
-  }
-#ifdef ENABLE_BIGINT
-  else if (val.isBigInt()) {
+  } else if (val.isBigInt()) {
     if (!sb.append("the BigInt ")) {
       return "<<error converting value to string>>";
     }
-  }
-#endif
-  else {
+  } else {
     MOZ_ASSERT(val.isBoolean() || val.isSymbol());
     bytes = StringToNewUTF8CharsZ(cx, *str);
     return bytes.get();
   }
   if (!sb.append(str)) {
     return "<<error converting value to string>>";
   }
   str = sb.finishString();
--- a/js/src/jsfriendapi.cpp
+++ b/js/src/jsfriendapi.cpp
@@ -8,19 +8,17 @@
 
 #include "mozilla/Atomics.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/PodOperations.h"
 #include "mozilla/TimeStamp.h"
 
 #include <stdint.h>
 
-#ifdef ENABLE_BIGINT
-#  include "builtin/BigInt.h"
-#endif
+#include "builtin/BigInt.h"
 #include "builtin/Promise.h"
 #include "builtin/TestingFunctions.h"
 #include "gc/GCInternals.h"
 #include "gc/PublicIterators.h"
 #include "gc/WeakMap.h"
 #include "js/CharacterEncoding.h"
 #include "js/Printf.h"
 #include "js/Proxy.h"
@@ -301,20 +299,18 @@ JS_FRIEND_API bool js::GetBuiltinClass(J
   } else if (obj->is<MapIteratorObject>()) {
     *cls = ESClass::MapIterator;
   } else if (obj->is<SetIteratorObject>()) {
     *cls = ESClass::SetIterator;
   } else if (obj->is<ArgumentsObject>()) {
     *cls = ESClass::Arguments;
   } else if (obj->is<ErrorObject>()) {
     *cls = ESClass::Error;
-#ifdef ENABLE_BIGINT
   } else if (obj->is<BigIntObject>()) {
     *cls = ESClass::BigInt;
-#endif
   } else {
     *cls = ESClass::Other;
   }
 
   return true;
 }
 
 JS_FRIEND_API bool js::IsArgumentsObject(HandleObject obj) {
--- a/js/src/jsnum.cpp
+++ b/js/src/jsnum.cpp
@@ -30,19 +30,17 @@
 #include "js/CharacterEncoding.h"
 #include "js/Conversions.h"
 #if !EXPOSE_INTL_API
 #  include "js/LocaleSensitive.h"
 #endif
 #include "js/PropertySpec.h"
 #include "util/DoubleToString.h"
 #include "util/StringBuffer.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/GlobalObject.h"
 #include "vm/JSAtom.h"
 #include "vm/JSContext.h"
 #include "vm/JSObject.h"
 
 #include "vm/NativeObject-inl.h"
 #include "vm/NumberObject-inl.h"
 #include "vm/StringType-inl.h"
@@ -540,21 +538,19 @@ const Class NumberObject::class_ = {
 static bool Number(JSContext* cx, unsigned argc, Value* vp) {
   CallArgs args = CallArgsFromVp(argc, vp);
 
   if (args.length() > 0) {
     // BigInt proposal section 6.2, steps 2a-c.
     if (!ToNumeric(cx, args[0])) {
       return false;
     }
-#ifdef ENABLE_BIGINT
     if (args[0].isBigInt()) {
       args[0].setNumber(BigInt::numberValue(args[0].toBigInt()));
     }
-#endif
     MOZ_ASSERT(args[0].isNumber());
   }
 
   if (!args.isConstructing()) {
     if (args.length() > 0) {
       args.rval().set(args[0]);
     } else {
       args.rval().setInt32(0);
@@ -1683,52 +1679,46 @@ JS_PUBLIC_API bool js::ToNumberSlow(JSCo
     return false;
   }
 
   if (v.isUndefined()) {
     *out = GenericNaN();
     return true;
   }
 
-  MOZ_ASSERT(v.isSymbol() || IF_BIGINT(v.isBigInt(), false));
+  MOZ_ASSERT(v.isSymbol() || v.isBigInt());
   if (!cx->helperThread()) {
     unsigned errnum = JSMSG_SYMBOL_TO_NUMBER;
-#ifdef ENABLE_BIGINT
     if (v.isBigInt()) {
       errnum = JSMSG_BIGINT_TO_NUMBER;
     }
-#endif
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, errnum);
   }
   return false;
 }
 
 // BigInt proposal section 3.1.6
 bool js::ToNumericSlow(JSContext* cx, MutableHandleValue vp) {
   MOZ_ASSERT(!vp.isNumber());
-#ifdef ENABLE_BIGINT
   MOZ_ASSERT(!vp.isBigInt());
-#endif
 
   // Step 1.
   if (!vp.isPrimitive()) {
     if (cx->helperThread()) {
       return false;
     }
     if (!ToPrimitive(cx, JSTYPE_NUMBER, vp)) {
       return false;
     }
   }
 
   // Step 2.
-#ifdef ENABLE_BIGINT
   if (vp.isBigInt()) {
     return true;
   }
-#endif
 
   // Step 3.
   return ToNumber(cx, vp);
 }
 
 /*
  * Convert a value to an int8_t, according to the WebIDL rules for byte
  * conversion. Return converted value in *out on success, false on failure.
@@ -1847,21 +1837,19 @@ bool js::ToInt32OrBigIntSlow(JSContext* 
     vp.setInt32(ToInt32(vp.toDouble()));
     return true;
   }
 
   if (!ToNumeric(cx, vp)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (vp.isBigInt()) {
     return true;
   }
-#endif
 
   vp.setInt32(ToInt32(vp.toNumber()));
   return true;
 }
 
 JS_PUBLIC_API bool js::ToUint32Slow(JSContext* cx, const HandleValue v,
                                     uint32_t* out) {
   MOZ_ASSERT(!v.isInt32());
--- a/js/src/jsnum.h
+++ b/js/src/jsnum.h
@@ -200,21 +200,19 @@ MOZ_ALWAYS_INLINE MOZ_MUST_USE bool ToNu
 bool ToNumericSlow(JSContext* cx, JS::MutableHandleValue vp);
 
 // BigInt proposal section 3.1.6
 MOZ_ALWAYS_INLINE MOZ_MUST_USE bool ToNumeric(JSContext* cx,
                                               JS::MutableHandleValue vp) {
   if (vp.isNumber()) {
     return true;
   }
-#ifdef ENABLE_BIGINT
   if (vp.isBigInt()) {
     return true;
   }
-#endif
   return ToNumericSlow(cx, vp);
 }
 
 bool ToInt32OrBigIntSlow(JSContext* cx, JS::MutableHandleValue vp);
 
 MOZ_ALWAYS_INLINE MOZ_MUST_USE bool ToInt32OrBigInt(JSContext* cx,
                                                     JS::MutableHandleValue vp) {
   if (vp.isInt32()) {
--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -41,19 +41,17 @@ enum JSType {
   JSTYPE_UNDEFINED, /* undefined */
   JSTYPE_OBJECT,    /* object */
   JSTYPE_FUNCTION,  /* function */
   JSTYPE_STRING,    /* string */
   JSTYPE_NUMBER,    /* number */
   JSTYPE_BOOLEAN,   /* boolean */
   JSTYPE_NULL,      /* null */
   JSTYPE_SYMBOL,    /* symbol */
-#ifdef ENABLE_BIGINT
   JSTYPE_BIGINT, /* BigInt */
-#endif
   JSTYPE_LIMIT
 };
 
 /* Dense index into cached prototypes and class atoms for standard objects. */
 enum JSProtoKey {
 #define PROTOKEY_AND_INITIALIZER(name, init, clasp) JSProto_##name,
   JS_FOR_EACH_PROTOTYPE(PROTOKEY_AND_INITIALIZER)
 #undef PROTOKEY_AND_INITIALIZER
--- a/js/src/moz.build
+++ b/js/src/moz.build
@@ -186,16 +186,17 @@ EXPORTS.js += [
     '../public/Vector.h',
     '../public/WeakMapPtr.h',
     '../public/Wrapper.h',
 ]
 
 UNIFIED_SOURCES += [
     'builtin/Array.cpp',
     'builtin/AtomicsObject.cpp',
+    'builtin/BigInt.cpp',
     'builtin/Boolean.cpp',
     'builtin/DataViewObject.cpp',
     'builtin/Eval.cpp',
     'builtin/intl/Collator.cpp',
     'builtin/intl/CommonFunctions.cpp',
     'builtin/intl/DateTimeFormat.cpp',
     'builtin/intl/IntlObject.cpp',
     'builtin/intl/NumberFormat.cpp',
@@ -253,16 +254,17 @@ UNIFIED_SOURCES += [
     'util/StructuredSpewer.cpp',
     'util/Text.cpp',
     'util/Unicode.cpp',
     'vm/ArgumentsObject.cpp',
     'vm/ArrayBufferObject.cpp',
     'vm/ArrayBufferViewObject.cpp',
     'vm/AsyncFunction.cpp',
     'vm/AsyncIteration.cpp',
+    'vm/BigIntType.cpp',
     'vm/BuildId.cpp',
     'vm/BytecodeUtil.cpp',
     'vm/Caches.cpp',
     'vm/CallNonGenericMethod.cpp',
     'vm/CharacterEncoding.cpp',
     'vm/CodeCoverage.cpp',
     'vm/Compartment.cpp',
     'vm/CompilationAndEvaluation.cpp',
@@ -341,22 +343,16 @@ SOURCES += [
     'builtin/RegExp.cpp',
     'jsmath.cpp',
     'jsutil.cpp',
     'util/DoubleToString.cpp',
     'vm/Interpreter.cpp',
     'vm/ProfilingStack.cpp',
 ]
 
-if CONFIG['ENABLE_BIGINT']:
-    SOURCES += [
-        'builtin/BigInt.cpp',
-        'vm/BigIntType.cpp',
-    ]
-
 if CONFIG['JS_POSIX_NSPR']:
     UNIFIED_SOURCES += [
         'vm/PosixNSPR.cpp',
     ]
 
 if CONFIG['MOZ_INSTRUMENTS']:
     SOURCES += [
         'devtools/Instruments.cpp',
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -495,19 +495,17 @@ static bool enableWasmIon = false;
 static bool enableWasmCranelift = false;
 #ifdef ENABLE_WASM_REFTYPES
 static bool enableWasmGc = false;
 #endif
 static bool enableWasmVerbose = false;
 static bool enableTestWasmAwaitTier2 = false;
 static bool enableAsyncStacks = false;
 static bool enableStreams = false;
-#ifdef ENABLE_BIGINT
 static bool enableBigInt = false;
-#endif
 #ifdef JS_GC_ZEAL
 static uint32_t gZealBits = 0;
 static uint32_t gZealFrequency = 0;
 #endif
 static bool printTiming = false;
 static RCFile* gErrFile = nullptr;
 static RCFile* gOutFile = nullptr;
 static bool reportWarnings = true;
@@ -3768,19 +3766,17 @@ static const JSClassOps sandbox_classOps
                                             JS_GlobalObjectTraceHook};
 
 static const JSClass sandbox_class = {"sandbox", JSCLASS_GLOBAL_FLAGS,
                                       &sandbox_classOps};
 
 static void SetStandardRealmOptions(JS::RealmOptions& options) {
   options.creationOptions()
       .setSharedMemoryAndAtomicsEnabled(enableSharedMemory)
-#ifdef ENABLE_BIGINT
       .setBigIntEnabled(enableBigInt)
-#endif
       .setStreamsEnabled(enableStreams);
 }
 
 static MOZ_MUST_USE bool CheckRealmOptions(JSContext* cx,
                                            JS::RealmOptions& options,
                                            JSPrincipals* principals) {
   JS::RealmCreationOptions& creationOptions = options.creationOptions();
   if (creationOptions.compartmentSpecifier() !=
@@ -9890,19 +9886,17 @@ static bool SetContextOptions(JSContext*
 
 #ifdef ENABLE_WASM_REFTYPES
   enableWasmGc = op.getBoolOption("wasm-gc");
 #endif
   enableWasmVerbose = op.getBoolOption("wasm-verbose");
   enableTestWasmAwaitTier2 = op.getBoolOption("test-wasm-await-tier2");
   enableAsyncStacks = !op.getBoolOption("no-async-stacks");
   enableStreams = !op.getBoolOption("no-streams");
-#ifdef ENABLE_BIGINT
   enableBigInt = !op.getBoolOption("no-bigint");
-#endif
 
   JS::ContextOptionsRef(cx)
       .setBaseline(enableBaseline)
       .setIon(enableIon)
       .setAsmJS(enableAsmJS)
       .setWasm(enableWasm)
       .setWasmBaseline(enableWasmBaseline)
       .setWasmIon(enableWasmIon)
@@ -10598,29 +10592,27 @@ int main(int argc, char** argv, char** e
       || !op.addBoolOption('\0', "wasm-gc", "No-op")
 #endif
       || !op.addBoolOption('\0', "no-native-regexp",
                            "Disable native regexp compilation") ||
       !op.addBoolOption('\0', "no-unboxed-objects",
                         "Disable creating unboxed plain objects") ||
       !op.addBoolOption('\0', "enable-streams",
                         "Enable WHATWG Streams (default)") ||
-      !op.addBoolOption('\0', "no-streams", "Disable WHATWG Streams")
-#ifdef ENABLE_BIGINT
-      || !op.addBoolOption('\0', "no-bigint",
-                           "Disable experimental BigInt support")
+      !op.addBoolOption('\0', "no-streams", "Disable WHATWG Streams") ||
+      !op.addBoolOption('\0', "no-bigint",
+                        "Disable experimental BigInt support") ||
+      !op.addStringOption('\0', "shared-memory", "on/off",
+                          "SharedArrayBuffer and Atomics "
+#if SHARED_MEMORY_DEFAULT
+                          "(default: on, off to disable)"
+#else
+                          "(default: off, on to enable)"
 #endif
-      || !op.addStringOption('\0', "shared-memory", "on/off",
-                             "SharedArrayBuffer and Atomics "
-#if SHARED_MEMORY_DEFAULT
-                             "(default: on, off to disable)"
-#else
-                             "(default: off, on to enable)"
-#endif
-                             ) ||
+                          ) ||
       !op.addStringOption('\0', "spectre-mitigations", "on/off",
                           "Whether Spectre mitigations are enabled (default: "
                           "off, on to enable)") ||
       !op.addStringOption(
           '\0', "cache-ir-stubs", "on/off/nobinary",
           "Use CacheIR stubs (default: on, off to disable, nobinary to"
           "just disable binary arith)") ||
       !op.addStringOption('\0', "ion-shared-stubs", "on/off",
--- a/js/src/util/StringBuffer.cpp
+++ b/js/src/util/StringBuffer.cpp
@@ -162,21 +162,19 @@ bool js::ValueToStringBufferSlow(JSConte
   if (v.isNull()) {
     return sb.append(cx->names().null);
   }
   if (v.isSymbol()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_SYMBOL_TO_STRING);
     return false;
   }
-#ifdef ENABLE_BIGINT
   if (v.isBigInt()) {
     RootedBigInt i(cx, v.toBigInt());
     JSLinearString* str = BigInt::toString<CanGC>(cx, i, 10);
     if (!str) {
       return false;
     }
     return sb.append(str);
   }
-#endif
   MOZ_ASSERT(v.isUndefined());
   return sb.append(cx->names().undefined);
 }
--- a/js/src/vm/BytecodeUtil.cpp
+++ b/js/src/vm/BytecodeUtil.cpp
@@ -1473,20 +1473,17 @@ static unsigned Disassemble1(JSContext* 
         return 0;
       }
       if (!sp->jsprintf(" %s", bytes.get())) {
         return 0;
       }
       break;
     }
 
-#  ifdef ENABLE_BIGINT
     case JOF_BIGINT:
-      // Fallthrough.
-#  endif
     case JOF_DOUBLE: {
       RootedValue v(cx, script->getConst(GET_UINT32_INDEX(pc)));
       UniqueChars bytes = ToDisassemblySource(cx, v);
       if (!bytes) {
         return 0;
       }
       if (!sp->jsprintf(" %s", bytes.get())) {
         return 0;
--- a/js/src/vm/BytecodeUtil.h
+++ b/js/src/vm/BytecodeUtil.h
@@ -57,19 +57,17 @@ enum {
   JOF_ATOM = 14,        /* uint32_t constant index */
   JOF_OBJECT = 15,      /* uint32_t object index */
   JOF_REGEXP = 16,      /* uint32_t regexp index */
   JOF_DOUBLE = 17,      /* uint32_t index for double value */
   JOF_SCOPE = 18,       /* uint32_t scope index */
   JOF_CODE_OFFSET = 19, /* int32_t bytecode offset */
   JOF_ICINDEX = 20,     /* uint32_t IC index */
   JOF_LOOPENTRY = 21,   /* JSOP_LOOPENTRY, combines JOF_ICINDEX and JOF_UINT8 */
-#ifdef ENABLE_BIGINT
-  JOF_BIGINT = 22, /* uint32_t index for BigInt value */
-#endif
+  JOF_BIGINT = 22,      /* uint32_t index for BigInt value */
   JOF_TYPEMASK = 0x001f, /* mask for above immediate types */
 
   JOF_NAME = 1 << 5,     /* name operation */
   JOF_PROP = 2 << 5,     /* obj.prop operation */
   JOF_ELEM = 3 << 5,     /* obj[index] operation */
   JOF_MODEMASK = 3 << 5, /* mask for above addressing modes */
 
   JOF_PROPSET = 1 << 7,      /* property/element/name set operation */
--- a/js/src/vm/Compartment-inl.h
+++ b/js/src/vm/Compartment-inl.h
@@ -44,26 +44,24 @@ inline bool JS::Compartment::wrap(JSCont
     JS::RootedString str(cx, vp.toString());
     if (!wrap(cx, &str)) {
       return false;
     }
     vp.setString(str);
     return true;
   }
 
-#ifdef ENABLE_BIGINT
   if (vp.isBigInt()) {
     JS::RootedBigInt bi(cx, vp.toBigInt());
     if (!wrap(cx, &bi)) {
       return false;
     }
     vp.setBigInt(bi);
     return true;
   }
-#endif
 
   MOZ_ASSERT(vp.isObject());
 
   /*
    * All that's left are objects.
    *
    * Object wrapping isn't the fastest thing in the world, in part because
    * we have to unwrap and invoke the prewrap hook to find the identity
--- a/js/src/vm/Compartment.cpp
+++ b/js/src/vm/Compartment.cpp
@@ -163,32 +163,30 @@ bool Compartment::wrap(JSContext* cx, Mu
   if (!putWrapper(cx, CrossCompartmentKey(key), StringValue(copy))) {
     return false;
   }
 
   strp.set(copy);
   return true;
 }
 
-#ifdef ENABLE_BIGINT
 bool Compartment::wrap(JSContext* cx, MutableHandleBigInt bi) {
   MOZ_ASSERT(cx->compartment() == this);
 
   if (bi->zone() == cx->zone()) {
     return true;
   }
 
   BigInt* copy = BigInt::copy(cx, bi);
   if (!copy) {
     return false;
   }
   bi.set(copy);
   return true;
 }
-#endif
 
 bool Compartment::getNonWrapperObjectForCurrentCompartment(
     JSContext* cx, MutableHandleObject obj) {
   // Ensure that we have entered a realm.
   MOZ_ASSERT(cx->global());
 
   // If we have a cross-compartment wrapper, make sure that the cx isn't
   // associated with the self-hosting zone. We don't want to create
--- a/js/src/vm/Compartment.h
+++ b/js/src/vm/Compartment.h
@@ -478,19 +478,17 @@ class JS::Compartment {
  public:
   explicit Compartment(JS::Zone* zone, bool invisibleToDebugger);
 
   void destroy(js::FreeOp* fop);
 
   MOZ_MUST_USE inline bool wrap(JSContext* cx, JS::MutableHandleValue vp);
 
   MOZ_MUST_USE bool wrap(JSContext* cx, js::MutableHandleString strp);
-#ifdef ENABLE_BIGINT
   MOZ_MUST_USE bool wrap(JSContext* cx, js::MutableHandle<JS::BigInt*> bi);
-#endif
   MOZ_MUST_USE bool wrap(JSContext* cx, JS::MutableHandleObject obj);
   MOZ_MUST_USE bool wrap(JSContext* cx,
                          JS::MutableHandle<JS::PropertyDescriptor> desc);
   MOZ_MUST_USE bool wrap(JSContext* cx,
                          JS::MutableHandle<JS::GCVector<JS::Value>> vec);
   MOZ_MUST_USE bool rewrap(JSContext* cx, JS::MutableHandleObject obj,
                            JS::HandleObject existing);
 
--- a/js/src/vm/EqualityOperations.cpp
+++ b/js/src/vm/EqualityOperations.cpp
@@ -11,19 +11,17 @@
 #include "jsapi.h"    // js::AssertHeapIsIdle
 #include "jsnum.h"    // js::StringToNumber
 #include "jstypes.h"  // JS_PUBLIC_API
 
 #include "js/Equality.h"  // JS::LooselyEqual, JS::StrictlyEqual, JS::SameValue
 #include "js/Result.h"    // JS_TRY_VAR_OR_RETURN_FALSE
 #include "js/RootingAPI.h"  // JS::Rooted
 #include "js/Value.h"       // JS::Int32Value, JS::SameType, JS::Value
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"  // JS::BigInt
-#endif                        // ENABLE_BIGINT
+#include "vm/BigIntType.h"  // JS::BigInt
 #include "vm/JSContext.h"     // CHECK_THREAD
 #include "vm/JSObject.h"      // js::ToPrimitive
 #include "vm/StringType.h"    // js::EqualStrings
 
 #include "builtin/Boolean-inl.h"  // js::EmulatesUndefined
 #include "vm/JSContext-inl.h"     // JSContext::check
 
 static bool EqualGivenSameType(JSContext* cx, JS::Handle<JS::Value> lval,
@@ -34,22 +32,20 @@ static bool EqualGivenSameType(JSContext
     return js::EqualStrings(cx, lval.toString(), rval.toString(), equal);
   }
 
   if (lval.isDouble()) {
     *equal = (lval.toDouble() == rval.toDouble());
     return true;
   }
 
-#ifdef ENABLE_BIGINT
   if (lval.isBigInt()) {
     *equal = JS::BigInt::equal(lval.toBigInt(), rval.toBigInt());
     return true;
   }
-#endif
 
   if (lval.isGCThing()) {  // objects or symbols
     *equal = (lval.toGCThing() == rval.toGCThing());
     return true;
   }
 
   *equal = lval.get().payloadAsRawUint32() == rval.get().payloadAsRawUint32();
   MOZ_ASSERT_IF(lval.isUndefined() || lval.isNull(), *equal);
@@ -157,17 +153,16 @@ bool js::LooselyEqual(JSContext* cx, JS:
       (rval.isString() || rval.isNumber() || rval.isSymbol())) {
     JS::Rooted<JS::Value> lvalue(cx, lval);
     if (!ToPrimitive(cx, &lvalue)) {
       return false;
     }
     return js::LooselyEqual(cx, lvalue, rval, result);
   }
 
-#ifdef ENABLE_BIGINT
   if (lval.isBigInt()) {
     JS::Rooted<JS::BigInt*> lbi(cx, lval.toBigInt());
     bool tmpResult;
     JS_TRY_VAR_OR_RETURN_FALSE(cx, tmpResult,
                                JS::BigInt::looselyEqual(cx, lbi, rval));
     *result = tmpResult;
     return true;
   }
@@ -175,17 +170,16 @@ bool js::LooselyEqual(JSContext* cx, JS:
   if (rval.isBigInt()) {
     JS::Rooted<JS::BigInt*> rbi(cx, rval.toBigInt());
     bool tmpResult;
     JS_TRY_VAR_OR_RETURN_FALSE(cx, tmpResult,
                                JS::BigInt::looselyEqual(cx, rbi, lval));
     *result = tmpResult;
     return true;
   }
-#endif
 
   // Step 12.
   *result = false;
   return true;
 }
 
 JS_PUBLIC_API bool JS::LooselyEqual(JSContext* cx, Handle<Value> value1,
                                     Handle<Value> value2, bool* equal) {
--- a/js/src/vm/GlobalObject.cpp
+++ b/js/src/vm/GlobalObject.cpp
@@ -6,19 +6,17 @@
 
 #include "vm/GlobalObject.h"
 
 #include "jsdate.h"
 #include "jsexn.h"
 #include "jsfriendapi.h"
 
 #include "builtin/AtomicsObject.h"
-#ifdef ENABLE_BIGINT
-#  include "builtin/BigInt.h"
-#endif
+#include "builtin/BigInt.h"
 #include "builtin/DataViewObject.h"
 #include "builtin/Eval.h"
 #include "builtin/MapObject.h"
 #include "builtin/ModuleObject.h"
 #include "builtin/Object.h"
 #include "builtin/Promise.h"
 #include "builtin/RegExp.h"
 #include "builtin/SelfHostingDefines.h"
@@ -99,20 +97,18 @@ TypedObjectModuleObject& js::GlobalObjec
     case JSProto_ReadableStream:
     case JSProto_ReadableStreamDefaultReader:
     case JSProto_ReadableStreamDefaultController:
     case JSProto_ReadableByteStreamController:
     case JSProto_ByteLengthQueuingStrategy:
     case JSProto_CountQueuingStrategy:
       return !cx->realm()->creationOptions().getStreamsEnabled();
 
-#ifdef ENABLE_BIGINT
     case JSProto_BigInt:
       return !cx->realm()->creationOptions().getBigIntEnabled();
-#endif
 
     // Return true if the given constructor has been disabled at run-time.
     case JSProto_Atomics:
     case JSProto_SharedArrayBuffer:
       return !cx->realm()->creationOptions().getSharedMemoryAndAtomicsEnabled();
     default:
       return false;
   }
--- a/js/src/vm/Initialization.cpp
+++ b/js/src/vm/Initialization.cpp
@@ -21,19 +21,17 @@
 #include "jit/ExecutableAllocator.h"
 #include "jit/Ion.h"
 #include "jit/JitCommon.h"
 #include "js/Utility.h"
 #if ENABLE_INTL_API
 #  include "unicode/uclean.h"
 #  include "unicode/utypes.h"
 #endif  // ENABLE_INTL_API
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/DateTime.h"
 #include "vm/HelperThreads.h"
 #include "vm/Runtime.h"
 #include "vm/Time.h"
 #include "vm/TraceLogging.h"
 #include "vtune/VTuneWrapper.h"
 #include "wasm/WasmProcess.h"
 
--- a/js/src/vm/Interpreter-inl.h
+++ b/js/src/vm/Interpreter-inl.h
@@ -385,21 +385,19 @@ static MOZ_ALWAYS_INLINE bool NegOperati
     res.setInt32(-i);
     return true;
   }
 
   if (!ToNumeric(cx, val)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (val.isBigInt()) {
     return BigInt::neg(cx, val, res);
   }
-#endif
 
   res.setNumber(-val.toNumber());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool IncOperation(JSContext* cx,
                                            MutableHandleValue val,
                                            MutableHandleValue res) {
@@ -718,39 +716,35 @@ static MOZ_ALWAYS_INLINE bool LessThanIm
     int32_t result;
     if (!CompareStrings(cx, l, r, &result)) {
       return false;
     }
     res = mozilla::Some(result < 0);
     return true;
   }
 
-#ifdef ENABLE_BIGINT
   // Step 4a.
   if (lhs.isBigInt() && rhs.isString()) {
     return BigInt::lessThan(cx, lhs, rhs, res);
   }
 
   // Step 4b.
   if (lhs.isString() && rhs.isBigInt()) {
     return BigInt::lessThan(cx, lhs, rhs, res);
   }
-#endif
 
   // Steps 4c and 4d.
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   // Steps 4e-j.
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::lessThan(cx, lhs, rhs, res);
   }
-#endif
 
   // Step 4e for Number operands.
   MOZ_ASSERT(lhs.isNumber() && rhs.isNumber());
   double lhsNum = lhs.toNumber();
   double rhsNum = rhs.toNumber();
 
   if (mozilla::IsNaN(lhsNum) || mozilla::IsNaN(rhsNum)) {
     res = mozilla::Maybe<bool>(mozilla::Nothing());
@@ -860,126 +854,112 @@ static MOZ_ALWAYS_INLINE bool GreaterTha
 }
 
 static MOZ_ALWAYS_INLINE bool BitNot(JSContext* cx, MutableHandleValue in,
                                      MutableHandleValue out) {
   if (!ToInt32OrBigInt(cx, in)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (in.isBigInt()) {
     return BigInt::bitNot(cx, in, out);
   }
-#endif
 
   out.setInt32(~in.toInt32());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool BitXor(JSContext* cx, MutableHandleValue lhs,
                                      MutableHandleValue rhs,
                                      MutableHandleValue out) {
   if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::bitXor(cx, lhs, rhs, out);
   }
-#endif
 
   out.setInt32(lhs.toInt32() ^ rhs.toInt32());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool BitOr(JSContext* cx, MutableHandleValue lhs,
                                     MutableHandleValue rhs,
                                     MutableHandleValue out) {
   if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::bitOr(cx, lhs, rhs, out);
   }
-#endif
 
   out.setInt32(lhs.toInt32() | rhs.toInt32());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool BitAnd(JSContext* cx, MutableHandleValue lhs,
                                      MutableHandleValue rhs,
                                      MutableHandleValue out) {
   if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::bitAnd(cx, lhs, rhs, out);
   }
-#endif
 
   out.setInt32(lhs.toInt32() & rhs.toInt32());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool BitLsh(JSContext* cx, MutableHandleValue lhs,
                                      MutableHandleValue rhs,
                                      MutableHandleValue out) {
   if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::lsh(cx, lhs, rhs, out);
   }
-#endif
 
   out.setInt32(lhs.toInt32() << (rhs.toInt32() & 31));
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool BitRsh(JSContext* cx, MutableHandleValue lhs,
                                      MutableHandleValue rhs,
                                      MutableHandleValue out) {
   if (!ToInt32OrBigInt(cx, lhs) || !ToInt32OrBigInt(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::rsh(cx, lhs, rhs, out);
   }
-#endif
 
   out.setInt32(lhs.toInt32() >> (rhs.toInt32() & 31));
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool UrshOperation(JSContext* cx,
                                             MutableHandleValue lhs,
                                             MutableHandleValue rhs,
                                             MutableHandleValue out) {
-#ifdef ENABLE_BIGINT
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
   if (lhs.isBigInt() || rhs.isBigInt()) {
     JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                               JSMSG_BIGINT_TO_NUMBER);
     return false;
   }
-#endif
 
   uint32_t left;
   int32_t right;
   if (!ToUint32(cx, lhs, &left) || !ToInt32(cx, rhs, &right)) {
     return false;
   }
   left >>= right & 31;
   out.setNumber(uint32_t(left));
--- a/js/src/vm/Interpreter.cpp
+++ b/js/src/vm/Interpreter.cpp
@@ -30,19 +30,17 @@
 #include "jit/BaselineJIT.h"
 #include "jit/Ion.h"
 #include "jit/IonAnalysis.h"
 #include "jit/Jit.h"
 #include "js/CharacterEncoding.h"
 #include "util/StringBuffer.h"
 #include "vm/AsyncFunction.h"
 #include "vm/AsyncIteration.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/BytecodeUtil.h"
 #include "vm/Debugger.h"
 #include "vm/EqualityOperations.h"  // js::StrictlyEqual
 #include "vm/GeneratorObject.h"
 #include "vm/Iteration.h"
 #include "vm/JSAtom.h"
 #include "vm/JSContext.h"
 #include "vm/JSFunction.h"
@@ -886,21 +884,19 @@ JSType js::TypeOfValue(const Value& v) {
     return JSTYPE_UNDEFINED;
   }
   if (v.isObject()) {
     return TypeOfObject(&v.toObject());
   }
   if (v.isBoolean()) {
     return JSTYPE_BOOLEAN;
   }
-#ifdef ENABLE_BIGINT
   if (v.isBigInt()) {
     return JSTYPE_BIGINT;
   }
-#endif
   MOZ_ASSERT(v.isSymbol());
   return JSTYPE_SYMBOL;
 }
 
 bool js::CheckClassHeritageOperation(JSContext* cx, HandleValue heritage) {
   if (IsConstructor(heritage)) {
     return true;
   }
@@ -1435,75 +1431,67 @@ static MOZ_ALWAYS_INLINE bool AddOperati
     res.setString(str);
     return true;
   }
 
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::add(cx, lhs, rhs, res);
   }
-#endif
 
   res.setNumber(lhs.toNumber() + rhs.toNumber());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool SubOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            MutableHandleValue rhs,
                                            MutableHandleValue res) {
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::sub(cx, lhs, rhs, res);
   }
-#endif
 
   res.setNumber(lhs.toNumber() - rhs.toNumber());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool MulOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            MutableHandleValue rhs,
                                            MutableHandleValue res) {
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::mul(cx, lhs, rhs, res);
   }
-#endif
 
   res.setNumber(lhs.toNumber() * rhs.toNumber());
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool DivOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            MutableHandleValue rhs,
                                            MutableHandleValue res) {
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::div(cx, lhs, rhs, res);
   }
-#endif
 
   res.setNumber(NumberDiv(lhs.toNumber(), rhs.toNumber()));
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool ModOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            MutableHandleValue rhs,
@@ -1515,39 +1503,35 @@ static MOZ_ALWAYS_INLINE bool ModOperati
     res.setInt32(mod);
     return true;
   }
 
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::mod(cx, lhs, rhs, res);
   }
-#endif
 
   res.setNumber(NumberMod(lhs.toNumber(), rhs.toNumber()));
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool PowOperation(JSContext* cx,
                                            MutableHandleValue lhs,
                                            MutableHandleValue rhs,
                                            MutableHandleValue res) {
   if (!ToNumeric(cx, lhs) || !ToNumeric(cx, rhs)) {
     return false;
   }
 
-#ifdef ENABLE_BIGINT
   if (lhs.isBigInt() || rhs.isBigInt()) {
     return BigInt::pow(cx, lhs, rhs, res);
   }
-#endif
 
   res.setNumber(ecmaPow(lhs.toNumber(), rhs.toNumber()));
   return true;
 }
 
 static MOZ_ALWAYS_INLINE bool SetObjectElementOperation(
     JSContext* cx, HandleObject obj, HandleId id, HandleValue value,
     HandleValue receiver, bool strict, JSScript* script = nullptr,
@@ -4321,23 +4305,21 @@ static MOZ_NEVER_INLINE JS_HAZ_JSNATIVE_
 
     CASE(JSOP_TONUMERIC) {
       if (!ToNumeric(cx, REGS.stackHandleAt(-1))) {
         goto error;
       }
     }
     END_CASE(JSOP_TONUMERIC)
 
-#ifdef ENABLE_BIGINT
     CASE(JSOP_BIGINT) {
       PUSH_COPY(script->getConst(GET_UINT32_INDEX(REGS.pc)));
       MOZ_ASSERT(REGS.sp[-1].isBigInt());
     }
     END_CASE(JSOP_BIGINT)
-#endif
 
     DEFAULT() {
       char numBuf[12];
       SprintfLiteral(numBuf, "%d", *REGS.pc);
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                 JSMSG_BAD_BYTECODE, numBuf);
       goto error;
     }
@@ -4420,18 +4402,17 @@ bool js::GetProperty(JSContext* cx, Hand
     // Fast path for strings, arrays and arguments.
     if (GetLengthProperty(v, vp)) {
       return true;
     }
   }
 
   // Optimize common cases like (2).toString() or "foo".valueOf() to not
   // create a wrapper object.
-  if (v.isPrimitive() && !v.isNullOrUndefined() &&
-      IF_BIGINT(!v.isBigInt(), true)) {
+  if (v.isPrimitive() && !v.isNullOrUndefined() && !v.isBigInt()) {
     NativeObject* proto;
     if (v.isNumber()) {
       proto = GlobalObject::getOrCreateNumberPrototype(cx, cx->global());
     } else if (v.isString()) {
       proto = GlobalObject::getOrCreateStringPrototype(cx, cx->global());
     } else if (v.isBoolean()) {
       proto = GlobalObject::getOrCreateBooleanPrototype(cx, cx->global());
     } else {
--- a/js/src/vm/JSAtom.cpp
+++ b/js/src/vm/JSAtom.cpp
@@ -1085,26 +1085,24 @@ static JSAtom* ToAtomSlow(
   if (v.isSymbol()) {
     MOZ_ASSERT(!cx->helperThread());
     if (allowGC) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                 JSMSG_SYMBOL_TO_STRING);
     }
     return nullptr;
   }
-#ifdef ENABLE_BIGINT
   if (v.isBigInt()) {
     RootedBigInt i(cx, v.toBigInt());
     JSAtom* atom = BigIntToAtom<allowGC>(cx, i);
     if (!allowGC && !atom) {
       cx->recoverFromOutOfMemory();
     }
     return atom;
   }
-#endif
   MOZ_ASSERT(v.isUndefined());
   return cx->names().undefined;
 }
 
 template <AllowGC allowGC>
 JSAtom* js::ToAtom(JSContext* cx,
                    typename MaybeRooted<Value, allowGC>::HandleType v) {
   if (!v.isString()) {
--- a/js/src/vm/JSContext-inl.h
+++ b/js/src/vm/JSContext-inl.h
@@ -7,19 +7,17 @@
 #ifndef vm_JSContext_inl_h
 #define vm_JSContext_inl_h
 
 #include "vm/JSContext.h"
 
 #include "builtin/Object.h"
 #include "jit/JitFrames.h"
 #include "proxy/Proxy.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/HelperThreads.h"
 #include "vm/Interpreter.h"
 #include "vm/Iteration.h"
 #include "vm/Realm.h"
 #include "vm/SymbolType.h"
 
 namespace js {
 
@@ -100,33 +98,28 @@ class ContextChecks {
       checkAtom(&str->asAtom(), argIndex);
     } else {
       check(str->zone(), argIndex);
     }
   }
 
   void check(JS::Symbol* symbol, int argIndex) { checkAtom(symbol, argIndex); }
 
-#ifdef ENABLE_BIGINT
   void check(JS::BigInt* bi, int argIndex) { check(bi->zone(), argIndex); }
-#endif
 
   void check(const js::Value& v, int argIndex) {
     if (v.isObject()) {
       check(&v.toObject(), argIndex);
     } else if (v.isString()) {
       check(v.toString(), argIndex);
     } else if (v.isSymbol()) {
       check(v.toSymbol(), argIndex);
-    }
-#ifdef ENABLE_BIGINT
-    else if (v.isBigInt()) {
+    } else if (v.isBigInt()) {
       check(v.toBigInt(), argIndex);
     }
-#endif
   }
 
   // Check the contents of any container class that supports the C++
   // iteration protocol, eg GCVector<jsid>.
   template <typename Container>
   typename mozilla::EnableIf<
       mozilla::IsSame<decltype(((Container*)nullptr)->begin()),
                       decltype(((Container*)nullptr)->end())>::value>::Type
--- a/js/src/vm/JSObject.cpp
+++ b/js/src/vm/JSObject.cpp
@@ -20,19 +20,17 @@
 #include "jsapi.h"
 #include "jsexn.h"
 #include "jsfriendapi.h"
 #include "jsnum.h"
 #include "jstypes.h"
 #include "jsutil.h"
 
 #include "builtin/Array.h"
-#ifdef ENABLE_BIGINT
-#  include "builtin/BigInt.h"
-#endif
+#include "builtin/BigInt.h"
 #include "builtin/Eval.h"
 #include "builtin/Object.h"
 #include "builtin/String.h"
 #include "builtin/Symbol.h"
 #include "frontend/BytecodeCompiler.h"
 #include "gc/Policy.h"
 #include "jit/BaselineJIT.h"
 #include "js/CharacterEncoding.h"
@@ -3305,29 +3303,23 @@ JSObject* js::PrimitiveToObject(JSContex
     return StringObject::create(cx, str);
   }
   if (v.isNumber()) {
     return NumberObject::create(cx, v.toNumber());
   }
   if (v.isBoolean()) {
     return BooleanObject::create(cx, v.toBoolean());
   }
-#ifdef ENABLE_BIGINT
   if (v.isSymbol()) {
     RootedSymbol symbol(cx, v.toSymbol());
     return SymbolObject::create(cx, symbol);
   }
   MOZ_ASSERT(v.isBigInt());
   RootedBigInt bigInt(cx, v.toBigInt());
   return BigIntObject::create(cx, bigInt);
-#else
-  MOZ_ASSERT(v.isSymbol());
-  RootedSymbol symbol(cx, v.toSymbol());
-  return SymbolObject::create(cx, symbol);
-#endif
 }
 
 /*
  * Invokes the ES5 ToObject algorithm on vp, returning the result. If vp might
  * already be an object, use ToObject. reportScanStack controls how null and
  * undefined errors are reported.
  *
  * Callers must handle the already-object case.
@@ -4210,20 +4202,18 @@ bool js::Unbox(JSContext* cx, HandleObje
   } else if (obj->is<NumberObject>()) {
     vp.setNumber(obj->as<NumberObject>().unbox());
   } else if (obj->is<StringObject>()) {
     vp.setString(obj->as<StringObject>().unbox());
   } else if (obj->is<DateObject>()) {
     vp.set(obj->as<DateObject>().UTCTime());
   } else if (obj->is<SymbolObject>()) {
     vp.setSymbol(obj->as<SymbolObject>().unbox());
-#ifdef ENABLE_BIGINT
   } else if (obj->is<BigIntObject>()) {
     vp.setBigInt(obj->as<BigIntObject>().unbox());
-#endif
   } else {
     vp.setUndefined();
   }
 
   return true;
 }
 
 #ifdef DEBUG
--- a/js/src/vm/JSScript.cpp
+++ b/js/src/vm/JSScript.cpp
@@ -95,19 +95,17 @@ XDRResult js::XDRScriptConst(XDRState<mo
     SCRIPT_DOUBLE,
     SCRIPT_ATOM,
     SCRIPT_TRUE,
     SCRIPT_FALSE,
     SCRIPT_NULL,
     SCRIPT_OBJECT,
     SCRIPT_VOID,
     SCRIPT_HOLE,
-#ifdef ENABLE_BIGINT
     SCRIPT_BIGINT
-#endif
   };
 
   ConstTag tag;
   if (mode == XDR_ENCODE) {
     if (vp.isInt32()) {
       tag = SCRIPT_INT;
     } else if (vp.isDouble()) {
       tag = SCRIPT_DOUBLE;
@@ -118,23 +116,19 @@ XDRResult js::XDRScriptConst(XDRState<mo
     } else if (vp.isFalse()) {
       tag = SCRIPT_FALSE;
     } else if (vp.isNull()) {
       tag = SCRIPT_NULL;
     } else if (vp.isObject()) {
       tag = SCRIPT_OBJECT;
     } else if (vp.isMagic(JS_ELEMENTS_HOLE)) {
       tag = SCRIPT_HOLE;
-    }
-#ifdef ENABLE_BIGINT
-    else if (vp.isBigInt()) {
+    } else if (vp.isBigInt()) {
       tag = SCRIPT_BIGINT;
-    }
-#endif
-    else {
+    } else {
       MOZ_ASSERT(vp.isUndefined());
       tag = SCRIPT_VOID;
     }
   }
 
   MOZ_TRY(xdr->codeEnum32(&tag));
 
   switch (tag) {
@@ -204,31 +198,29 @@ XDRResult js::XDRScriptConst(XDRState<mo
         vp.set(UndefinedValue());
       }
       break;
     case SCRIPT_HOLE:
       if (mode == XDR_DECODE) {
         vp.setMagic(JS_ELEMENTS_HOLE);
       }
       break;
-#ifdef ENABLE_BIGINT
     case SCRIPT_BIGINT: {
       RootedBigInt bi(cx);
       if (mode == XDR_ENCODE) {
         bi = vp.toBigInt();
       }
 
       MOZ_TRY(XDRBigInt(xdr, &bi));
 
       if (mode == XDR_DECODE) {
         vp.setBigInt(bi);
       }
       break;
     }
-#endif
     default:
       // Fail in debug, but only soft-fail in release
       MOZ_ASSERT(false, "Bad XDR value kind");
       return xdr->fail(JS::TranscodeResult_Failure_BadDecode);
   }
   return Ok();
 }
 
@@ -4059,32 +4051,28 @@ bool js::detail::CopyScript(JSContext* c
   AutoValueVector consts(cx);
   if (nconsts != 0) {
     RootedValue val(cx);
     RootedValue clone(cx);
     for (const GCPtrValue& elem : src->consts()) {
       val = elem.get();
       if (val.isDouble()) {
         clone = val;
-      }
-#ifdef ENABLE_BIGINT
-      else if (val.isBigInt()) {
+      } else if (val.isBigInt()) {
         if (cx->zone() == val.toBigInt()->zone()) {
           clone.setBigInt(val.toBigInt());
         } else {
           RootedBigInt b(cx, val.toBigInt());
           BigInt* copy = BigInt::copy(cx, b);
           if (!copy) {
             return false;
           }
           clone.setBigInt(copy);
         }
-      }
-#endif
-      else {
+      } else {
         MOZ_ASSERT_UNREACHABLE("bad script consts() element");
       }
 
       if (!consts.append(clone)) {
         return false;
       }
     }
   }
--- a/js/src/vm/MemoryMetrics.cpp
+++ b/js/src/vm/MemoryMetrics.cpp
@@ -8,19 +8,17 @@
 
 #include "gc/GC.h"
 #include "gc/Heap.h"
 #include "gc/Nursery.h"
 #include "gc/PublicIterators.h"
 #include "jit/BaselineJIT.h"
 #include "jit/Ion.h"
 #include "vm/ArrayObject.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/HelperThreads.h"
 #include "vm/JSObject.h"
 #include "vm/JSScript.h"
 #include "vm/Realm.h"
 #include "vm/Runtime.h"
 #include "vm/Shape.h"
 #include "vm/StringType.h"
 #include "vm/SymbolType.h"
@@ -490,25 +488,23 @@ static void StatsCellCallback(JSRuntime*
       }
       break;
     }
 
     case JS::TraceKind::Symbol:
       zStats->symbolsGCHeap += thingSize;
       break;
 
-#ifdef ENABLE_BIGINT
     case JS::TraceKind::BigInt: {
       JS::BigInt* bi = static_cast<BigInt*>(thing);
       zStats->bigIntsGCHeap += thingSize;
       zStats->bigIntsMallocHeap +=
           bi->sizeOfExcludingThis(rtStats->mallocSizeOf_);
       break;
     }
-#endif
 
     case JS::TraceKind::BaseShape: {
       JS::ShapeInfo info;  // This zeroes all the sizes.
       info.shapesGCHeapBase += thingSize;
       // No malloc-heap measurements.
 
       zStats->shapeInfo.add(info);
       break;
--- a/js/src/vm/Opcodes.h
+++ b/js/src/vm/Opcodes.h
@@ -2532,25 +2532,24 @@
     MACRO(JSOP_TONUMERIC, 236, "tonumeric", NULL, 1, 1, 1, JOF_BYTE) \
     /*
      * Pushes a BigInt constant onto the stack.
      *   Category: Literals
      *   Type: Constants
      *   Operands: uint32_t constIndex
      *   Stack: => val
      */ \
-    IF_BIGINT(MACRO(JSOP_BIGINT, 237, "bigint", NULL, 5, 0, 1, JOF_BIGINT),)
+    MACRO(JSOP_BIGINT, 237, "bigint", NULL, 5, 0, 1, JOF_BIGINT)
 // clang-format on
 
 /*
  * In certain circumstances it may be useful to "pad out" the opcode space to
  * a power of two.  Use this macro to do so.
  */
 #define FOR_EACH_TRAILING_UNUSED_OPCODE(MACRO) \
-  IF_BIGINT(, MACRO(237))                      \
   MACRO(238)                                   \
   MACRO(239)                                   \
   MACRO(240)                                   \
   MACRO(241)                                   \
   MACRO(242)                                   \
   MACRO(243)                                   \
   MACRO(244)                                   \
   MACRO(245)                                   \
--- a/js/src/vm/StringType.cpp
+++ b/js/src/vm/StringType.cpp
@@ -2158,27 +2158,23 @@ JSString* js::ToStringSlow(
     str = cx->names().null;
   } else if (v.isSymbol()) {
     MOZ_ASSERT(!cx->helperThread());
     if (allowGC) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
                                 JSMSG_SYMBOL_TO_STRING);
     }
     return nullptr;
-  }
-#ifdef ENABLE_BIGINT
-  else if (v.isBigInt()) {
+  } else if (v.isBigInt()) {
     if (!allowGC) {
       return nullptr;
     }
     RootedBigInt i(cx, v.toBigInt());
     str = BigInt::toString<CanGC>(cx, i, 10);
-  }
-#endif
-  else {
+  } else {
     MOZ_ASSERT(v.isUndefined());
     str = cx->names().undefined;
   }
   return str;
 }
 
 template JSString* js::ToStringSlow<CanGC>(JSContext* cx, HandleValue arg);
 
--- a/js/src/vm/StructuredClone.cpp
+++ b/js/src/vm/StructuredClone.cpp
@@ -41,19 +41,17 @@
 #include "jsapi.h"
 #include "jsdate.h"
 
 #include "builtin/DataViewObject.h"
 #include "builtin/MapObject.h"
 #include "js/Date.h"
 #include "js/GCHashTable.h"
 #include "js/Wrapper.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/JSContext.h"
 #include "vm/RegExpObject.h"
 #include "vm/SavedFrame.h"
 #include "vm/SharedArrayObject.h"
 #include "vm/TypedArrayObject.h"
 #include "vm/WrapperObject.h"
 #include "wasm/WasmJS.h"
 
@@ -397,19 +395,17 @@ struct JSStructuredCloneReader {
 
   bool readHeader();
   bool readTransferMap();
 
   template <typename CharT>
   JSString* readStringImpl(uint32_t nchars);
   JSString* readString(uint32_t data);
 
-#ifdef ENABLE_BIGINT
   BigInt* readBigInt(uint32_t data);
-#endif
 
   bool checkDouble(double d);
   MOZ_MUST_USE bool readTypedArray(uint32_t arrayType, uint32_t nelems,
                                    MutableHandleValue vp, bool v1Read = false);
   MOZ_MUST_USE bool readDataView(uint32_t byteLength, MutableHandleValue vp);
   MOZ_MUST_USE bool readArrayBuffer(uint32_t nbytes, MutableHandleValue vp);
   MOZ_MUST_USE bool readSharedArrayBuffer(MutableHandleValue vp);
   MOZ_MUST_USE bool readSharedWasmMemory(uint32_t nbytes,
@@ -491,32 +487,29 @@ struct JSStructuredCloneWriter {
   JSStructuredCloneWriter(const JSStructuredCloneWriter&) = delete;
 
   JSContext* context() { return out.context(); }
 
   bool writeHeader();
   bool writeTransferMap();
 
   bool writeString(uint32_t tag, JSString* str);
+  bool writeBigInt(uint32_t tag, BigInt* bi);
   bool writeArrayBuffer(HandleObject obj);
   bool writeTypedArray(HandleObject obj);
   bool writeDataView(HandleObject obj);
   bool writeSharedArrayBuffer(HandleObject obj);
   bool writeSharedWasmMemory(HandleObject obj);
   bool startObject(HandleObject obj, bool* backref);
   bool startWrite(HandleValue v);
   bool traverseObject(HandleObject obj, ESClass cls);
   bool traverseMap(HandleObject obj);
   bool traverseSet(HandleObject obj);
   bool traverseSavedFrame(HandleObject obj);
 
-#ifdef ENABLE_BIGINT
-  bool writeBigInt(uint32_t tag, BigInt* bi);
-#endif
-
   bool reportDataCloneError(uint32_t errorId);
 
   bool parseTransferable();
   bool transferOwnership();
 
   inline void checkStack();
 
   SCOutput out;
@@ -1140,32 +1133,30 @@ bool JSStructuredCloneWriter::writeStrin
   }
 
   JS::AutoCheckCannotGC nogc;
   return linear->hasLatin1Chars()
              ? out.writeChars(linear->latin1Chars(nogc), length)
              : out.writeChars(linear->twoByteChars(nogc), length);
 }
 
-#ifdef ENABLE_BIGINT
 bool JSStructuredCloneWriter::writeBigInt(uint32_t tag, BigInt* bi) {
   bool signBit = bi->isNegative();
   size_t length = bi->digitLength();
   // The length must fit in 31 bits to leave room for a sign bit.
   if (length > size_t(INT32_MAX)) {
     return false;
   }
   uint32_t lengthAndSign = length | (static_cast<uint32_t>(signBit) << 31);
 
   if (!out.writePair(tag, lengthAndSign)) {
     return false;
   }
   return out.writeArray(bi->digits().data(), length);
 }
-#endif
 
 inline void JSStructuredCloneWriter::checkStack() {
 #ifdef DEBUG
   // To avoid making serialization O(n^2), limit stack-checking at 10.
   const size_t MAX = 10;
 
   size_t limit = Min(counts.length(), MAX);
   MOZ_ASSERT(objs.length() == counts.length());
@@ -1621,23 +1612,19 @@ bool JSStructuredCloneWriter::startWrite
   } else if (v.isDouble()) {
     return out.writeDouble(v.toDouble());
   } else if (v.isBoolean()) {
     return out.writePair(SCTAG_BOOLEAN, v.toBoolean());
   } else if (v.isNull()) {
     return out.writePair(SCTAG_NULL, 0);
   } else if (v.isUndefined()) {
     return out.writePair(SCTAG_UNDEFINED, 0);
-  }
-#ifdef ENABLE_BIGINT
-  else if (v.isBigInt()) {
+  } else if (v.isBigInt()) {
     return writeBigInt(SCTAG_BIGINT, v.toBigInt());
-  }
-#endif
-  else if (v.isObject()) {
+  } else if (v.isObject()) {
     RootedObject obj(context(), &v.toObject());
 
     bool backref;
     if (!startObject(obj, &backref)) {
       return false;
     }
     if (backref) {
       return true;
@@ -1700,25 +1687,23 @@ bool JSStructuredCloneWriter::startWrite
         }
         return out.writePair(SCTAG_DATE_OBJECT, 0) &&
                out.writeDouble(unboxed.toNumber());
       }
       case ESClass::Set:
         return traverseSet(obj);
       case ESClass::Map:
         return traverseMap(obj);
-#ifdef ENABLE_BIGINT
       case ESClass::BigInt: {
         RootedValue unboxed(context());
         if (!Unbox(context(), obj, &unboxed)) {
           return false;
         }
         return writeBigInt(SCTAG_BIGINT_OBJECT, unboxed.toBigInt());
       }
-#endif
       case ESClass::Promise:
       case ESClass::MapIterator:
       case ESClass::SetIterator:
       case ESClass::Arguments:
       case ESClass::Error:
         break;
 
       case ESClass::Other: {
@@ -2057,34 +2042,32 @@ JSString* JSStructuredCloneReader::readS
 
 JSString* JSStructuredCloneReader::readString(uint32_t data) {
   uint32_t nchars = data & JS_BITMASK(31);
   bool latin1 = data & (1 << 31);
   return latin1 ? readStringImpl<Latin1Char>(nchars)
                 : readStringImpl<char16_t>(nchars);
 }
 
-#ifdef ENABLE_BIGINT
 BigInt* JSStructuredCloneReader::readBigInt(uint32_t data) {
   size_t length = data & JS_BITMASK(31);
   bool isNegative = data & (1 << 31);
   if (length == 0) {
     return BigInt::zero(context());
   }
   RootedBigInt result(
       context(), BigInt::createUninitialized(context(), length, isNegative));
   if (!result) {
     return nullptr;
   }
   if (!in.readArray(result->digits().data(), length)) {
     return nullptr;
   }
   return result;
 }
-#endif
 
 static uint32_t TagToV1ArrayType(uint32_t tag) {
   MOZ_ASSERT(tag >= SCTAG_TYPED_ARRAY_V1_MIN &&
              tag <= SCTAG_TYPED_ARRAY_V1_MAX);
   return tag - SCTAG_TYPED_ARRAY_V1_MIN;
 }
 
 bool JSStructuredCloneReader::readTypedArray(uint32_t arrayType,
@@ -2424,32 +2407,25 @@ bool JSStructuredCloneReader::startRead(
       if (!PrimitiveToObject(context(), vp)) {
         return false;
       }
       break;
     }
 
     case SCTAG_BIGINT:
     case SCTAG_BIGINT_OBJECT: {
-#ifdef ENABLE_BIGINT
       RootedBigInt bi(context(), readBigInt(data));
       if (!bi) {
         return false;
       }
       vp.setBigInt(bi);
       if (tag == SCTAG_BIGINT_OBJECT && !PrimitiveToObject(context(), vp)) {
         return false;
       }
       break;
-#else
-      JS_ReportErrorNumberASCII(context(), GetErrorMessage, nullptr,
-                                JSMSG_SC_BAD_SERIALIZED_DATA,
-                                "BigInt unsupported");
-      return false;
-#endif
     }
 
     case SCTAG_DATE_OBJECT: {
       double d;
       if (!in.readDouble(&d) || !checkDouble(d)) {
         return false;
       }
       JS::ClippedTime t = JS::TimeClip(d);
--- a/js/src/vm/TypeInference-inl.h
+++ b/js/src/vm/TypeInference-inl.h
@@ -175,20 +175,18 @@ inline TypeFlags PrimitiveTypeFlag(JSVal
     case JSVAL_TYPE_INT32:
       return TYPE_FLAG_INT32;
     case JSVAL_TYPE_DOUBLE:
       return TYPE_FLAG_DOUBLE;
     case JSVAL_TYPE_STRING:
       return TYPE_FLAG_STRING;
     case JSVAL_TYPE_SYMBOL:
       return TYPE_FLAG_SYMBOL;
-#ifdef ENABLE_BIGINT
     case JSVAL_TYPE_BIGINT:
       return TYPE_FLAG_BIGINT;
-#endif
     case JSVAL_TYPE_MAGIC:
       return TYPE_FLAG_LAZYARGS;
     default:
       MOZ_CRASH("Bad JSValueType");
   }
 }
 
 inline JSValueType TypeFlagPrimitive(TypeFlags flags) {
@@ -202,20 +200,18 @@ inline JSValueType TypeFlagPrimitive(Typ
     case TYPE_FLAG_INT32:
       return JSVAL_TYPE_INT32;
     case TYPE_FLAG_DOUBLE:
       return JSVAL_TYPE_DOUBLE;
     case TYPE_FLAG_STRING:
       return JSVAL_TYPE_STRING;
     case TYPE_FLAG_SYMBOL:
       return JSVAL_TYPE_SYMBOL;
-#ifdef ENABLE_BIGINT
     case TYPE_FLAG_BIGINT:
       return JSVAL_TYPE_BIGINT;
-#endif
     case TYPE_FLAG_LAZYARGS:
       return JSVAL_TYPE_MAGIC;
     default:
       MOZ_CRASH("Bad TypeFlags");
   }
 }
 
 /*
--- a/js/src/vm/TypeInference.cpp
+++ b/js/src/vm/TypeInference.cpp
@@ -102,20 +102,18 @@ const char* js::TypeIdStringImpl(jsid id
       case JSVAL_TYPE_INT32:
         return "int";
       case JSVAL_TYPE_DOUBLE:
         return "float";
       case JSVAL_TYPE_STRING:
         return "string";
       case JSVAL_TYPE_SYMBOL:
         return "symbol";
-#ifdef ENABLE_BIGINT
       case JSVAL_TYPE_BIGINT:
         return "BigInt";
-#endif
       case JSVAL_TYPE_MAGIC:
         return "lazyargs";
       default:
         MOZ_CRASH("Bad type");
     }
   }
   if (type.isUnknown()) {
     return "unknown";
@@ -386,20 +384,18 @@ bool TypeSet::mightBeMIRType(jit::MIRTyp
       return baseFlags() & TYPE_FLAG_INT32;
     case jit::MIRType::Float32:  // Fall through, there's no JSVAL for Float32.
     case jit::MIRType::Double:
       return baseFlags() & TYPE_FLAG_DOUBLE;
     case jit::MIRType::String:
       return baseFlags() & TYPE_FLAG_STRING;
     case jit::MIRType::Symbol:
       return baseFlags() & TYPE_FLAG_SYMBOL;
-#ifdef ENABLE_BIGINT
     case jit::MIRType::BigInt:
       return baseFlags() & TYPE_FLAG_BIGINT;
-#endif
     case jit::MIRType::MagicOptimizedArguments:
       return baseFlags() & TYPE_FLAG_LAZYARGS;
     case jit::MIRType::MagicHole:
     case jit::MIRType::MagicIsConstructing:
       // These magic constants do not escape to script and are not observed
       // in the type sets.
       //
       // The reason we can return false here is subtle: if Ion is asking the
@@ -821,21 +817,19 @@ void TypeSet::print(FILE* fp) {
     fprintf(fp, " float");
   }
   if (flags & TYPE_FLAG_STRING) {
     fprintf(fp, " string");
   }
   if (flags & TYPE_FLAG_SYMBOL) {
     fprintf(fp, " symbol");
   }
-#ifdef ENABLE_BIGINT
   if (flags & TYPE_FLAG_BIGINT) {
     fprintf(fp, " BigInt");
   }
-#endif
   if (flags & TYPE_FLAG_LAZYARGS) {
     fprintf(fp, " lazyargs");
   }
 
   uint32_t objectCount = baseObjectCount();
   if (objectCount) {
     fprintf(fp, " object[%u]", objectCount);
 
@@ -1708,20 +1702,18 @@ static inline jit::MIRType GetMIRTypeFro
     case TYPE_FLAG_INT32:
       return jit::MIRType::Int32;
     case (TYPE_FLAG_INT32 | TYPE_FLAG_DOUBLE):
       return jit::MIRType::Double;
     case TYPE_FLAG_STRING:
       return jit::MIRType::String;
     case TYPE_FLAG_SYMBOL:
       return jit::MIRType::Symbol;
-#ifdef ENABLE_BIGINT
     case TYPE_FLAG_BIGINT:
       return jit::MIRType::BigInt;
-#endif
     case TYPE_FLAG_LAZYARGS:
       return jit::MIRType::MagicOptimizedArguments;
     case TYPE_FLAG_ANYOBJECT:
       return jit::MIRType::Object;
     default:
       return jit::MIRType::Value;
   }
 }
--- a/js/src/vm/TypeSet.h
+++ b/js/src/vm/TypeSet.h
@@ -78,39 +78,29 @@ class TypeZone;
 enum : uint32_t {
   TYPE_FLAG_UNDEFINED = 0x1,
   TYPE_FLAG_NULL = 0x2,
   TYPE_FLAG_BOOLEAN = 0x4,
   TYPE_FLAG_INT32 = 0x8,
   TYPE_FLAG_DOUBLE = 0x10,
   TYPE_FLAG_STRING = 0x20,
   TYPE_FLAG_SYMBOL = 0x40,
-#ifdef ENABLE_BIGINT
   TYPE_FLAG_BIGINT = 0x80,
   TYPE_FLAG_LAZYARGS = 0x100,
   TYPE_FLAG_ANYOBJECT = 0x200,
-#else
-  TYPE_FLAG_LAZYARGS = 0x80,
-  TYPE_FLAG_ANYOBJECT = 0x100,
-#endif
 
   /* Mask containing all primitives */
   TYPE_FLAG_PRIMITIVE = TYPE_FLAG_UNDEFINED | TYPE_FLAG_NULL |
                         TYPE_FLAG_BOOLEAN | TYPE_FLAG_INT32 | TYPE_FLAG_DOUBLE |
                         TYPE_FLAG_STRING | TYPE_FLAG_SYMBOL |
-                        IF_BIGINT(TYPE_FLAG_BIGINT, 0),
+                        TYPE_FLAG_BIGINT,
 
 /* Mask/shift for the number of objects in objectSet */
-#ifdef ENABLE_BIGINT
   TYPE_FLAG_OBJECT_COUNT_MASK = 0x3c00,
   TYPE_FLAG_OBJECT_COUNT_SHIFT = 10,
-#else
-  TYPE_FLAG_OBJECT_COUNT_MASK = 0x3e00,
-  TYPE_FLAG_OBJECT_COUNT_SHIFT = 9,
-#endif
   TYPE_FLAG_OBJECT_COUNT_LIMIT = 7,
   TYPE_FLAG_DOMOBJECT_COUNT_LIMIT =
       TYPE_FLAG_OBJECT_COUNT_MASK >> TYPE_FLAG_OBJECT_COUNT_SHIFT,
 
   /* Whether the contents of this type set are totally unknown. */
   TYPE_FLAG_UNKNOWN = 0x00004000,
 
   /* Mask of normal type flags on a type set. */
@@ -391,19 +381,17 @@ class TypeSet {
 
   static inline Type UndefinedType() { return Type(JSVAL_TYPE_UNDEFINED); }
   static inline Type NullType() { return Type(JSVAL_TYPE_NULL); }
   static inline Type BooleanType() { return Type(JSVAL_TYPE_BOOLEAN); }
   static inline Type Int32Type() { return Type(JSVAL_TYPE_INT32); }
   static inline Type DoubleType() { return Type(JSVAL_TYPE_DOUBLE); }
   static inline Type StringType() { return Type(JSVAL_TYPE_STRING); }
   static inline Type SymbolType() { return Type(JSVAL_TYPE_SYMBOL); }
-#ifdef ENABLE_BIGINT
   static inline Type BigIntType() { return Type(JSVAL_TYPE_BIGINT); }
-#endif
   static inline Type MagicArgType() { return Type(JSVAL_TYPE_MAGIC); }
   static inline Type AnyObjectType() { return Type(JSVAL_TYPE_OBJECT); }
   static inline Type UnknownType() { return Type(JSVAL_TYPE_UNKNOWN); }
 
   static inline Type PrimitiveType(JSValueType type) {
     MOZ_ASSERT(type < JSVAL_TYPE_UNKNOWN);
     return Type(type);
   }
--- a/js/src/vm/TypedArrayObject-inl.h
+++ b/js/src/vm/TypedArrayObject-inl.h
@@ -609,17 +609,17 @@ class ElementSpecific {
     MOZ_ASSERT(!v.isMagic());
 
     if (MOZ_LIKELY(canConvertInfallibly(v))) {
       *result = infallibleValueToNative(v);
       return true;
     }
 
     double d;
-    MOZ_ASSERT(v.isString() || v.isObject() || v.isSymbol() || IF_BIGINT(v.isBigInt(), false));
+    MOZ_ASSERT(v.isString() || v.isObject() || v.isSymbol() || v.isBigInt());
     if (!(v.isString() ? StringToNumber(cx, v.toString(), &d)
                        : ToNumber(cx, v, &d))) {
       return false;
     }
 
     *result = doubleToNative(d);
     return true;
   }
--- a/js/src/vm/UbiNode.cpp
+++ b/js/src/vm/UbiNode.cpp
@@ -18,19 +18,17 @@
 #include "jit/IonCode.h"
 #include "js/Debug.h"
 #include "js/TracingAPI.h"
 #include "js/TypeDecls.h"
 #include "js/UbiNodeUtils.h"
 #include "js/Utility.h"
 #include "js/Vector.h"
 #include "util/Text.h"
-#ifdef ENABLE_BIGINT
-#  include "vm/BigIntType.h"
-#endif
+#include "vm/BigIntType.h"
 #include "vm/Debugger.h"
 #include "vm/EnvironmentObject.h"
 #include "vm/GlobalObject.h"
 #include "vm/JSContext.h"
 #include "vm/JSObject.h"
 #include "vm/JSScript.h"
 #include "vm/Scope.h"
 #include "vm/Shape.h"
@@ -174,23 +172,19 @@ Value Node::exposeToJS() const {
       v.setUndefined();
     } else {
       v.setObject(obj);
     }
   } else if (is<JSString>()) {
     v.setString(as<JSString>());
   } else if (is<JS::Symbol>()) {
     v.setSymbol(as<JS::Symbol>());
-  }
-#ifdef ENABLE_BIGINT
-  else if (is<BigInt>()) {
+  } else if (is<BigInt>()) {
     v.setBigInt(as<BigInt>());
-  }
-#endif
-  else {
+  } else {
     v.setUndefined();
   }
 
   ExposeValueToActiveJS(v);
 
   return v;
 }
 
@@ -264,19 +258,17 @@ JS::Zone* TracerConcrete<Referent>::zone
 template JS::Zone* TracerConcrete<JSScript>::zone() const;
 template JS::Zone* TracerConcrete<js::LazyScript>::zone() const;
 template JS::Zone* TracerConcrete<js::Shape>::zone() const;
 template JS::Zone* TracerConcrete<js::BaseShape>::zone() const;
 template JS::Zone* TracerConcrete<js::ObjectGroup>::zone() const;
 template JS::Zone* TracerConcrete<js::RegExpShared>::zone() const;
 template JS::Zone* TracerConcrete<js::Scope>::zone() const;
 template JS::Zone* TracerConcrete<JS::Symbol>::zone() const;
-#ifdef ENABLE_BIGINT
 template JS::Zone* TracerConcrete<BigInt>::zone() const;
-#endif
 template JS::Zone* TracerConcrete<JSString>::zone() const;
 
 template <typename Referent>
 UniquePtr<EdgeRange> TracerConcrete<Referent>::edges(JSContext* cx,
                                                      bool wantNames) const {
   auto range = js::MakeUnique<SimpleEdgeRange>();
   if (!range) {
     return nullptr;
@@ -305,20 +297,18 @@ template UniquePtr<EdgeRange> TracerConc
 template UniquePtr<EdgeRange> TracerConcrete<js::ObjectGroup>::edges(
     JSContext* cx, bool wantNames) const;
 template UniquePtr<EdgeRange> TracerConcrete<js::RegExpShared>::edges(
     JSContext* cx, bool wantNames) const;
 template UniquePtr<EdgeRange> TracerConcrete<js::Scope>::edges(
     JSContext* cx, bool wantNames) const;
 template UniquePtr<EdgeRange> TracerConcrete<JS::Symbol>::edges(
     JSContext* cx, bool wantNames) const;
-#ifdef ENABLE_BIGINT
 template UniquePtr<EdgeRange> TracerConcrete<BigInt>::edges(
     JSContext* cx, bool wantNames) const;
-#endif
 template UniquePtr<EdgeRange> TracerConcrete<JSString>::edges(
     JSContext* cx, bool wantNames) const;
 
 template <typename Referent>
 JS::Compartment* TracerConcreteWithRealm<Referent>::compartment() const {
   return TracerBase::get().compartment();
 }
 
@@ -375,19 +365,17 @@ JS::Compartment* Concrete<JSObject>::com
 
 Realm* Concrete<JSObject>::realm() const {
   // Cross-compartment wrappers are shared by all realms in the compartment,
   // so we return nullptr in that case.
   return JS::GetObjectRealmOrNull(&Concrete::get());
 }
 
 const char16_t Concrete<JS::Symbol>::concreteTypeName[] = u"JS::Symbol";
-#ifdef ENABLE_BIGINT
 const char16_t Concrete<BigInt>::concreteTypeName[] = u"JS::BigInt";
-#endif
 const char16_t Concrete<JSScript>::concreteTypeName[] = u"JSScript";
 const char16_t Concrete<js::LazyScript>::concreteTypeName[] = u"js::LazyScript";
 const char16_t Concrete<js::jit::JitCode>::concreteTypeName[] =
     u"js::jit::JitCode";
 const char16_t Concrete<js::Shape>::concreteTypeName[] = u"js::Shape";
 const char16_t Concrete<js::BaseShape>::concreteTypeName[] = u"js::BaseShape";
 const char16_t Concrete<js::ObjectGroup>::concreteTypeName[] =
     u"js::ObjectGroup";
--- a/js/xpconnect/src/XPCJSContext.cpp
+++ b/js/xpconnect/src/XPCJSContext.cpp
@@ -744,26 +744,22 @@ bool xpc::ShouldDiscardSystemSource() { 
 static mozilla::Atomic<bool> sExtraWarningsForSystemJS(false);
 bool xpc::ExtraWarningsForSystemJS() { return sExtraWarningsForSystemJS; }
 #else
 bool xpc::ExtraWarningsForSystemJS() { return false; }
 #endif
 
 static mozilla::Atomic<bool> sSharedMemoryEnabled(false);
 static mozilla::Atomic<bool> sStreamsEnabled(false);
-#ifdef ENABLE_BIGINT
 static mozilla::Atomic<bool> sBigIntEnabled(false);
-#endif
 
 void xpc::SetPrefableRealmOptions(JS::RealmOptions& options) {
   options.creationOptions()
       .setSharedMemoryAndAtomicsEnabled(sSharedMemoryEnabled)
-#ifdef ENABLE_BIGINT
       .setBigIntEnabled(sBigIntEnabled)
-#endif
       .setStreamsEnabled(sStreamsEnabled);
 }
 
 static void ReloadPrefsCallback(const char* pref, XPCJSContext* xpccx) {
   JSContext* cx = xpccx->Context();
 
   bool useBaseline = Preferences::GetBool(JS_OPTIONS_DOT_STR "baselinejit");
   bool useIon = Preferences::GetBool(JS_OPTIONS_DOT_STR "ion");
@@ -805,19 +801,17 @@ static void ReloadPrefsCallback(const ch
   int32_t ionFrequentBailoutThreshold = Preferences::GetInt(
       JS_OPTIONS_DOT_STR "ion.frequent_bailout_threshold", -1);
 
   sDiscardSystemSource =
       Preferences::GetBool(JS_OPTIONS_DOT_STR "discardSystemSource");
 
   bool useAsyncStack = Preferences::GetBool(JS_OPTIONS_DOT_STR "asyncstack");
 
-#ifdef ENABLE_BIGINT
   sBigIntEnabled = Preferences::GetBool(JS_OPTIONS_DOT_STR "bigint");
-#endif
 
   bool throwOnDebuggeeWouldRun =
       Preferences::GetBool(JS_OPTIONS_DOT_STR "throw_on_debuggee_would_run");
 
   bool dumpStackOnDebuggeeWouldRun = Preferences::GetBool(
       JS_OPTIONS_DOT_STR "dump_stack_on_debuggee_would_run");
 
   bool werror = Preferences::GetBool(JS_OPTIONS_DOT_STR "werror");
--- a/modules/libpref/init/StaticPrefList.h
+++ b/modules/libpref/init/StaticPrefList.h
@@ -1013,24 +1013,22 @@ VARCACHE_PREF(
 
 // Streams API
 VARCACHE_PREF(
   "javascript.options.streams",
    javascript_options_streams,
   RelaxedAtomicBool, false
 )
 
-#ifdef ENABLE_BIGINT
 // BigInt API
 VARCACHE_PREF(
   "javascript.options.bigint",
    javascript_options_bigint,
   RelaxedAtomicBool, false
 )
-#endif
 
 
 //---------------------------------------------------------------------------
 // Media prefs
 //---------------------------------------------------------------------------
 
 // These prefs use camel case instead of snake case for the getter because one
 // reviewer had an unshakeable preference for that.