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

src/wasm/decoder.h

 // 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.
 
 #ifndef V8_WASM_DECODER_H_
 #define V8_WASM_DECODER_H_
 
 #include <memory>
 
 #include "src/base/compiler-specific.h"
@@ skipping 16 matching lines @@
 #define TRACE(...)
 #endif
 
 // A helper utility to decode bytes, integers, fields, varints, etc, from
 // a buffer of bytes.
 class Decoder {
  public:
   Decoder(const byte* start, const byte* end)
       : start_(start),
         pc_(start),
-        limit_(end),
         end_(end),
         error_pc_(nullptr),
         error_pt_(nullptr) {}
 
   virtual ~Decoder() {}
 
   inline bool check(const byte* base, unsigned offset, unsigned length,
                     const char* msg) {
     DCHECK_GE(base, start_);
-    if ((base + offset + length) > limit_) {
+    if ((base + offset + length) > end_) {
       error(base, base + offset, "%s", msg);
       return false;
     }
     return true;
   }
 
   // Reads a single 8-bit byte, reporting an error if out of bounds.
   inline uint8_t checked_read_u8(const byte* base, unsigned offset,
                                  const char* msg = "expected 1 byte") {
     return check(base, offset, 1, msg) ? base[offset] : 0;
@@ skipping 125 matching lines @@
     return consume_leb<int32_t, true>(name);
   }
 
   // Consume {size} bytes and send them to the bit bucket, advancing {pc_}.
   void consume_bytes(uint32_t size, const char* name = "skip") {
     TRACE("  +%d  %-20s: %d bytes\n", static_cast<int>(pc_ - start_), name,
           size);
     if (checkAvailable(size)) {
       pc_ += size;
     } else {
-      pc_ = limit_;
+      pc_ = end_;
     }
   }
 
-  // Check that at least {size} bytes exist between {pc_} and {limit_}.
+  // Check that at least {size} bytes exist between {pc_} and {end_}.
   bool checkAvailable(int size) {
     intptr_t pc_overflow_value = std::numeric_limits<intptr_t>::max() - size;
     if (size < 0 || (intptr_t)pc_ > pc_overflow_value) {
       error(pc_, nullptr, "reading %d bytes would underflow/overflow", size);
       return false;
-    } else if (pc_ < start_ || limit_ < (pc_ + size)) {
+    } else if (pc_ < start_ || end_ < (pc_ + size)) {
       error(pc_, nullptr, "expected %d bytes, fell off end", size);
       return false;
     } else {
       return true;
     }
   }
 
   void error(const char* msg) { error(pc_, nullptr, "%s", msg); }
 
   void error(const byte* pc, const char* msg) { error(pc, nullptr, "%s", msg); }
@@ skipping 20 matching lines @@
     }
   }
 
   // Behavior triggered on first error, overridden in subclasses.
   virtual void onFirstError() {}
 
   // Debugging helper to print bytes up to the end.
   template <typename T>
   T traceOffEnd() {
     T t = 0;
-    for (const byte* ptr = pc_; ptr < limit_; ptr++) {
+    for (const byte* ptr = pc_; ptr < end_; ptr++) {
       TRACE("%02x ", *ptr);
     }
     TRACE("<end>\n");
-    pc_ = limit_;
+    pc_ = end_;
     return t;
   }
 
   // Converts the given value to a {Result}, copying the error if necessary.
   template <typename T>
   Result<T> toResult(T val) {
     Result<T> result;
     if (failed()) {
       TRACE("Result error: %s\n", error_msg_.get());
       result.error_code = kError;
       result.start = start_;
       result.error_pc = error_pc_;
       result.error_pt = error_pt_;
       // transfer ownership of the error to the result.
       result.error_msg.reset(error_msg_.release());
     } else {
       result.error_code = kSuccess;
     }
     result.val = std::move(val);
     return result;
   }
 
   // Resets the boundaries of this decoder.
   void Reset(const byte* start, const byte* end) {
     start_ = start;
     pc_ = start;
-    limit_ = end;
     end_ = end;
     error_pc_ = nullptr;
     error_pt_ = nullptr;
     error_msg_.reset();
   }
 
   bool ok() const { return error_msg_ == nullptr; }
   bool failed() const { return !ok(); }
-  bool more() const { return pc_ < limit_; }
+  bool more() const { return pc_ < end_; }
 
   const byte* start() { return start_; }
   const byte* pc() { return pc_; }
   uint32_t pc_offset() { return static_cast<uint32_t>(pc_ - start_); }
 
  protected:
   const byte* start_;
   const byte* pc_;
-  const byte* limit_;
   const byte* end_;
   const byte* error_pc_;
   const byte* error_pt_;
   std::unique_ptr<char[]> error_msg_;
 
  private:
   template <typename IntType, bool is_signed>
   IntType checked_read_leb(const byte* base, unsigned offset, unsigned* length,
                            const char* msg) {
     if (!check(base, offset, 1, msg)) {
       *length = 0;
       return 0;
     }
 
     const int kMaxLength = (sizeof(IntType) * 8 + 6) / 7;
     const byte* ptr = base + offset;
     const byte* end = ptr + kMaxLength;
-    if (end > limit_) end = limit_;
+    if (end > end_) end = end_;
     int shift = 0;
     byte b = 0;
     IntType result = 0;
     while (ptr < end) {
       b = *ptr++;
       result = result | (static_cast<IntType>(b & 0x7F) << shift);
       if ((b & 0x80) == 0) break;
       shift += 7;
     }
     DCHECK_LE(ptr - (base + offset), kMaxLength);
@@ skipping 29 matching lines @@
   }
 
   template <typename IntType, bool is_signed>
   IntType consume_leb(const char* name = nullptr) {
     TRACE("  +%d  %-20s: ", static_cast<int>(pc_ - start_),
           name ? name : "varint");
     if (checkAvailable(1)) {
       const int kMaxLength = (sizeof(IntType) * 8 + 6) / 7;
       const byte* pos = pc_;
       const byte* end = pc_ + kMaxLength;
-      if (end > limit_) end = limit_;
+      if (end > end_) end = end_;
 
       IntType result = 0;
       int shift = 0;
       byte b = 0;
       while (pc_ < end) {
         b = *pc_++;
         TRACE("%02x ", b);
         result = result | (static_cast<IntType>(b & 0x7F) << shift);
         shift += 7;
         if ((b & 0x80) == 0) break;
@@ skipping 19 matching lines @@
     return traceOffEnd<uint32_t>();
   }
 };
 
 #undef TRACE
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_DECODER_H_