Fix several wasm warnings an a use after free.

src/wasm/ast-decoder.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/signature.h"
 
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone-containers.h"
@@ skipping 30 matching lines @@
 };
 
 
 // A production represents an incomplete decoded tree in the LR decoder.
 struct Production {
   Tree* tree;  // the root of the syntax tree.
   int index;   // the current index into the children of the tree.
 
   WasmOpcode opcode() const { return static_cast<WasmOpcode>(*pc()); }
   const byte* pc() const { return tree->pc; }
-  bool done() const { return index >= tree->count; }
+  bool done() const { return index >= static_cast<int>(tree->count); }
   Tree* last() const { return index > 0 ? tree->children[index - 1] : nullptr; }
 };
 
 
 // An SsaEnv environment carries the current local variable renaming
 // as well as the current effect and control dependency in the TF graph.
 // It maintains a control state that tracks whether the environment
 // is reachable, has reached a control end, or has been merged.
 struct SsaEnv {
   enum State { kControlEnd, kUnreachable, kReached, kMerged };
@@ skipping 542 matching lines @@
     return length;
   }
 
   void AddImplicitReturnAtEnd() {
     int retcount = static_cast<int>(function_env_->sig->return_count());
     if (retcount == 0) {
       BUILD0(ReturnVoid);
       return;
     }
 
-    if (trees_.size() < retcount) {
+    if (static_cast<int>(trees_.size()) < retcount) {
       error(limit_, nullptr,
             "ImplicitReturn expects %d arguments, only %d remain", retcount,
             static_cast<int>(trees_.size()));
       return;
     }
 
     TRACE("wasm-decode implicit return of %d args\n", retcount);
 
     TFNode** buffer = BUILD(Buffer, retcount);
     for (int index = 0; index < retcount; index++) {
@@ skipping 366 matching lines @@
         if (!sig) break;
         if (p->index > 0) {
           TypeCheckLast(p, sig->GetParam(p->index - 1));
         }
         if (p->done() && build()) {
           uint32_t count = p->tree->count + 1;
           TFNode** buffer = builder_->Buffer(count);
           FunctionSig* sig = FunctionSigOperand(p->pc(), &index, &len);
           USE(sig);
           buffer[0] = nullptr;  // reserved for code object.
-          for (int i = 1; i < count; i++) {
+          for (uint32_t i = 1; i < count; i++) {
             buffer[i] = p->tree->children[i - 1]->node;
           }
           p->tree->node = builder_->CallDirect(index, buffer);
         }
         break;
       }
       case kExprCallIndirect: {
         int len;
         uint32_t index;
         FunctionSig* sig = SigOperand(p->pc(), &index, &len);
         if (p->index == 1) {
           TypeCheckLast(p, kAstI32);
         } else {
           TypeCheckLast(p, sig->GetParam(p->index - 2));
         }
         if (p->done() && build()) {
           uint32_t count = p->tree->count;
           TFNode** buffer = builder_->Buffer(count);
-          for (int i = 0; i < count; i++) {
+          for (uint32_t i = 0; i < count; i++) {
             buffer[i] = p->tree->children[i]->node;
           }
           p->tree->node = builder_->CallIndirect(index, buffer);
         }
         break;
       }
       default:
         break;
     }
   }
@@ skipping 131 matching lines @@
         if (!builder_) break;
         TFNode* merge = to->control;
         // Extend the existing merge.
         builder_->AppendToMerge(merge, from->control);
         // Merge effects.
         if (builder_->IsPhiWithMerge(to->effect, merge)) {
           builder_->AppendToPhi(merge, to->effect, from->effect);
         } else if (to->effect != from->effect) {
           uint32_t count = builder_->InputCount(merge);
           TFNode** effects = builder_->Buffer(count);
-          for (int j = 0; j < count - 1; j++) effects[j] = to->effect;
+          for (uint32_t j = 0; j < count - 1; j++) {
+            effects[j] = to->effect;
+          }
           effects[count - 1] = from->effect;
           to->effect = builder_->EffectPhi(count, effects, merge);
         }
         // Merge locals.
         for (int i = EnvironmentCount() - 1; i >= 0; i--) {
           TFNode* tnode = to->locals[i];
           TFNode* fnode = from->locals[i];
           if (builder_->IsPhiWithMerge(tnode, merge)) {
             builder_->AppendToPhi(merge, tnode, fnode);
           } else if (tnode != fnode) {
             uint32_t count = builder_->InputCount(merge);
             TFNode** vals = builder_->Buffer(count);
-            for (int j = 0; j < count - 1; j++) vals[j] = tnode;
+            for (uint32_t j = 0; j < count - 1; j++) {
+              vals[j] = tnode;
+            }
             vals[count - 1] = fnode;
             to->locals[i] = builder_->Phi(function_env_->GetLocalType(i), count,
                                           vals, merge);
           }
         }
         break;
       }
       default:
         UNREACHABLE();
     }
     return from->Kill();
   }
 
   TFNode* CreateOrMergeIntoPhi(LocalType type, TFNode* merge, TFNode* tnode,
                                TFNode* fnode) {
     if (builder_->IsPhiWithMerge(tnode, merge)) {
       builder_->AppendToPhi(merge, tnode, fnode);
     } else if (tnode != fnode) {
       uint32_t count = builder_->InputCount(merge);
       TFNode** vals = builder_->Buffer(count);
-      for (int j = 0; j < count - 1; j++) vals[j] = tnode;
+      for (uint32_t j = 0; j < count - 1; j++) vals[j] = tnode;
       vals[count - 1] = fnode;
       return builder_->Phi(type, count, vals, merge);
     }
     return tnode;
   }
 
   void BuildInfiniteLoop() {
     if (ssa_env_->go()) {
       PrepareForLoop(ssa_env_);
       SsaEnv* cont_env = ssa_env_;
@@ skipping 206 matching lines @@
 }
 
 
 std::ostream& operator<<(std::ostream& os, const Tree& tree) {
   if (tree.pc == nullptr) {
     os << "null";
     return os;
   }
   PrintF("%s", WasmOpcodes::OpcodeName(tree.opcode()));
   if (tree.count > 0) os << "(";
-  for (int i = 0; i < tree.count; i++) {
+  for (uint32_t i = 0; i < tree.count; i++) {
     if (i > 0) os << ", ";
     os << *tree.children[i];
   }
   if (tree.count > 0) os << ")";
   return os;
 }
 
 
 ReadUnsignedLEB128ErrorCode ReadUnsignedLEB128Operand(const byte* pc,
                                                       const byte* limit,
@@ skipping 120 matching lines @@
 #define DECLARE_OPCODE_CASE(name, opcode, sig) \
   case kExpr##name:                            \
     return kArity_##sig;
 
       FOREACH_LOAD_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_STORE_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_MISC_MEM_OPCODE(DECLARE_OPCODE_CASE)
       FOREACH_SIMPLE_OPCODE(DECLARE_OPCODE_CASE)
 #undef DECLARE_OPCODE_CASE
   }
+  UNREACHABLE();
+  return 0;
 }
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8