[wasm] Decoder had 2 representations for "end".

src/wasm/function-body-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/signature.h"
 
 #include "src/bit-vector.h"
 #include "src/flags.h"
 #include "src/handles.h"
 #include "src/zone/zone-containers.h"
@@ skipping 579 matching lines @@
     // Initialize {local_type_vec} from signature.
     if (sig_) {
       local_type_vec_.reserve(sig_->parameter_count());
       for (size_t i = 0; i < sig_->parameter_count(); ++i) {
         local_type_vec_.push_back(sig_->GetParam(i));
       }
     }
     // Decode local declarations, if any.
     uint32_t entries = consume_u32v("local decls count");
     TRACE("local decls count: %u\n", entries);
-    while (entries-- > 0 && pc_ < limit_) {
+    while (entries-- > 0 && pc_ < end_) {
       uint32_t count = consume_u32v("local count");
       if ((count + local_type_vec_.size()) > kMaxNumWasmLocals) {
         error(pc_ - 1, "local count too large");
         return;
       }
       byte code = consume_u8("local type");
       ValueType type;
       switch (code) {
         case kLocalI32:
           type = kWasmI32;
@@ skipping 16 matching lines @@
       }
       local_type_vec_.insert(local_type_vec_.end(), count, type);
     }
     total_locals_ = local_type_vec_.size();
   }
 
   // Decodes the body of a function.
   void DecodeFunctionBody() {
     TRACE("wasm-decode %p...%p (module+%d, %d bytes) %s\n",
           reinterpret_cast<const void*>(start_),
-          reinterpret_cast<const void*>(limit_), baserel(pc_),
-          static_cast<int>(limit_ - start_), builder_ ? "graph building" : "");
+          reinterpret_cast<const void*>(end_), baserel(pc_),
+          static_cast<int>(end_ - start_), builder_ ? "graph building" : "");
 
     {
       // Set up initial function block.
       SsaEnv* break_env = ssa_env_;
       SetEnv("initial env", Steal(break_env));
       PushBlock(break_env);
       Control* c = &control_.back();
       c->merge.arity = static_cast<uint32_t>(sig_->return_count());
 
       if (c->merge.arity == 1) {
         c->merge.vals.first = {pc_, nullptr, sig_->GetReturn(0)};
       } else if (c->merge.arity > 1) {
         c->merge.vals.array = zone_->NewArray<Value>(c->merge.arity);
         for (unsigned i = 0; i < c->merge.arity; i++) {
           c->merge.vals.array[i] = {pc_, nullptr, sig_->GetReturn(i)};
         }
       }
     }
 
-    if (pc_ >= limit_) return;  // Nothing to do.
+    if (pc_ >= end_) return;  // Nothing to do.
 
     while (true) {  // decoding loop.
       unsigned len = 1;
       WasmOpcode opcode = static_cast<WasmOpcode>(*pc_);
       if (!WasmOpcodes::IsPrefixOpcode(opcode)) {
         TRACE("  @%-8d #%02x:%-20s|", startrel(pc_), opcode,
               WasmOpcodes::ShortOpcodeName(opcode));
       }
 
       FunctionSig* sig = WasmOpcodes::Signature(opcode);
@@ skipping 570 matching lines @@
               break;
             }
             default:
               break;
           }
         }
         PrintF("\n");
       }
 #endif
       pc_ += len;
-      if (pc_ >= limit_) {
+      if (pc_ >= end_) {
         // End of code reached or exceeded.
-        if (pc_ > limit_ && ok()) error("Beyond end of code");
+        if (pc_ > end_ && ok()) error("Beyond end of code");
         return;
       }
     }  // end decode loop
   }
 
   void EndControl() { ssa_env_->Kill(SsaEnv::kControlEnd); }
 
   void SetBlockType(Control* c, BlockTypeOperand& operand) {
     c->merge.arity = operand.arity;
     if (c->merge.arity == 1) {
@@ skipping 554 matching lines @@
     result->locals = nullptr;
     return result;
   }
 
   int EnvironmentCount() {
     if (builder_) return static_cast<int>(local_type_vec_.size());
     return 0;  // if we aren't building a graph, don't bother with SSA renaming.
   }
 
   virtual void onFirstError() {
-    limit_ = start_;     // Terminate decoding loop.
+    end_ = start_;       // Terminate decoding loop.
     builder_ = nullptr;  // Don't build any more nodes.
     TRACE(" !%s\n", error_msg_.get());
   }
   BitVector* AnalyzeLoopAssignment(const byte* pc) {
-    if (pc >= limit_) return nullptr;
+    if (pc >= end_) return nullptr;
     if (*pc != kExprLoop) return nullptr;
 
     BitVector* assigned =
         new (zone_) BitVector(static_cast<int>(local_type_vec_.size()), zone_);
     int depth = 0;
     // Iteratively process all AST nodes nested inside the loop.
-    while (pc < limit_ && ok()) {
+    while (pc < end_ && ok()) {
       WasmOpcode opcode = static_cast<WasmOpcode>(*pc);
       unsigned length = 1;
       switch (opcode) {
         case kExprLoop:
         case kExprIf:
         case kExprBlock:
         case kExprTry:
           length = OpcodeLength(pc);
           depth++;
           break;
@@ skipping 222 matching lines @@
 BitVector* AnalyzeLoopAssignmentForTesting(Zone* zone, size_t num_locals,
                                            const byte* start, const byte* end) {
   FunctionBody body = {nullptr, nullptr, start, end};
   WasmFullDecoder decoder(zone, body);
   return decoder.AnalyzeLoopAssignmentForTesting(start, num_locals);
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8