--- a/js/src/wasm/WasmIonCompile.cpp
+++ b/js/src/wasm/WasmIonCompile.cpp
@@ -1173,22 +1173,16 @@ class FunctionCompiler
   private:
     static bool hasPushed(MBasicBlock* block)
     {
         uint32_t numPushed = block->stackDepth() - block->info().firstStackSlot();
         MOZ_ASSERT(numPushed == 0 || numPushed == 1);
         return numPushed;
     }
 
-    static MDefinition* peekPushedDef(MBasicBlock* block)
-    {
-        MOZ_ASSERT(hasPushed(block));
-        return block->getSlot(block->stackDepth() - 1);
-    }
-
   public:
     void pushDef(MDefinition* def)
     {
         if (inDeadCode())
             return;
         MOZ_ASSERT(!hasPushed(curBlock_));
         if (def && def->type() != MIRType::None)
             curBlock_->push(def);
@@ -1545,17 +1539,19 @@ class FunctionCompiler
     /************************************************************ DECODING ***/
 
     uint32_t readCallSiteLineOrBytecode() {
         if (!func_.callSiteLineNums().empty())
             return func_.callSiteLineNums()[lastReadCallSite_++];
         return iter_.lastOpcodeOffset();
     }
 
+#if DEBUG
     bool done() const { return iter_.done(); }
+#endif
 
     /*************************************************************************/
   private:
     bool newBlock(MBasicBlock* pred, MBasicBlock** block)
     {
         *block = MBasicBlock::New(mirGraph(), info(), pred, MBasicBlock::NORMAL);
         if (!*block)
             return false;

--- a/js/src/wasm/WasmTextToBinary.cpp
+++ b/js/src/wasm/WasmTextToBinary.cpp
@@ -601,22 +601,16 @@ class WasmTokenStream
         return false;
     }
     AstName getIfName() {
         WasmToken token;
         if (getIf(WasmToken::Name, &token))
             return token.name();
         return AstName();
     }
-    AstName getIfText() {
-        WasmToken token;
-        if (getIf(WasmToken::Text, &token))
-            return token.text();
-        return AstName();
-    }
     bool getIfRef(AstRef* ref) {
         WasmToken token = peek();
         if (token.kind() == WasmToken::Name || token.kind() == WasmToken::Index)
             return matchRef(ref, nullptr);
         return false;
     }
     bool getIfOpcode(WasmToken* token) {
         *token = peek();
@@ -1478,20 +1472,16 @@ struct WasmParseContext
 
     WasmParseContext(const char16_t* text, LifoAlloc& lifo, UniqueChars* error)
       : ts(text, error),
         lifo(lifo),
         error(error),
         dtoaState(NewDtoaState())
     {}
 
-    bool fail(const char* message) {
-        error->reset(js_strdup(message));
-        return false;
-    }
     ~WasmParseContext() {
         DestroyDtoaState(dtoaState);
     }
 };
 
 } // end anonymous namespace
 
 static AstExpr*
@@ -3386,24 +3376,16 @@ class Resolver
         if (!p) {
             if (!map.add(p, name, index))
                 return false;
         } else {
             return false;
         }
         return true;
     }
-    bool resolveName(AstNameMap& map, AstName name, size_t* index) {
-        AstNameMap::Ptr p = map.lookup(name);
-        if (p) {
-            *index = p->value();
-            return true;
-        }
-        return false;
-    }
     bool resolveRef(AstNameMap& map, AstRef& ref) {
         AstNameMap::Ptr p = map.lookup(ref.name());
         if (p) {
             ref.setIndex(p->value());
             return true;
         }
         return false;
     }
@@ -3442,17 +3424,16 @@ class Resolver
 
 #define REGISTER(what, map)                                    \
     bool register##what##Name(AstName name, size_t index) {    \
         return name.empty() || registerName(map, name, index); \
     }
 
     REGISTER(Sig, sigMap_)
     REGISTER(Func, funcMap_)
-    REGISTER(Import, importMap_)
     REGISTER(Var, varMap_)
     REGISTER(Global, globalMap_)
     REGISTER(Table, tableMap_)
     REGISTER(Memory, memoryMap_)
 
 #undef REGISTER
 
     bool pushTarget(AstName name) {
@@ -3468,17 +3449,16 @@ class Resolver
         MOZ_ASSERT(!ref.isInvalid());                     \
         if (!ref.name().empty() && !resolveRef(map, ref)) \
             return failResolveLabel(#label, ref.name());  \
         return true;                                      \
     }
 
     RESOLVE(sigMap_, Signature)
     RESOLVE(funcMap_, Function)
-    RESOLVE(importMap_, Import)
     RESOLVE(varMap_, Local)
     RESOLVE(globalMap_, Global)
     RESOLVE(tableMap_, Table)
     RESOLVE(memoryMap_, Memory)
 
 #undef RESOLVE
 
     bool resolveBranchTarget(AstRef& ref) {