[wasm] Add support and unittests for decoding signed LEB128.

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 "src/base/smart-pointers.h"
 #include "src/flags.h"
 #include "src/signature.h"
@@ skipping 81 matching lines @@
     byte b = 0;
     uint32_t result = 0;
     while (ptr < end) {
       b = *ptr++;
       result = result | ((b & 0x7F) << shift);
       if ((b & 0x80) == 0) break;
       shift += 7;
     }
     DCHECK_LE(ptr - (base + offset), kMaxDiff);
     *length = static_cast<int>(ptr - (base + offset));
-    if (ptr == end && (b & 0x80)) {
-      error(base, ptr, msg);
-      return 0;
+    if (ptr == end) {
+      if (*length == kMaxDiff && (b & 0xF0) != 0) {
+        error(base, ptr, "extra bits in LEB128");
+        return 0;
+      }
+      if ((b & 0x80) != 0) {
+        error(base, ptr, msg);
+        return 0;
+      }
     }
     return result;
   }
 
+  // Reads a variable-length signed integer (little endian).
+  int32_t checked_read_i32v(const byte* base, int offset, int* length,
+                            const char* msg = "expected SLEB128") {
+    uint32_t result = checked_read_u32v(base, offset, length, msg);
+    if (*length == 5) return bit_cast<int32_t>(result);
+    if (*length > 0) {
+      int shift = 32 - 7 * *length;
+      return bit_cast<int32_t>(result << shift) >> shift;
+    }
+    return 0;
+  }
+
   // Reads a single 16-bit unsigned integer (little endian).
   inline uint16_t read_u16(const byte* ptr) {
     DCHECK(ptr >= start_ && (ptr + 2) <= end_);
 #if V8_TARGET_LITTLE_ENDIAN && UNALIGNED_ACCESS_OK
     return *reinterpret_cast<const uint16_t*>(ptr);
 #else
     uint16_t b0 = ptr[0];
     uint16_t b1 = ptr[1];
     return (b1 << 8) | b0;
 #endif
@@ skipping 106 matching lines @@
   // Check that at least {size} bytes exist between {pc_} and {limit_}.
   bool checkAvailable(int size) {
     if (pc_ < start_ || (pc_ + size) > limit_) {
       error(pc_, nullptr, "expected %d bytes, fell off end", size);
       return false;
     } else {
       return true;
     }
   }
 
-  bool RangeOk(const byte* pc, int length) {
-    if (pc < start_ || pc_ >= limit_) return false;
-    if ((pc + length) >= limit_) return false;
-    return true;
-  }
-
   void error(const char* msg) { error(pc_, nullptr, msg); }
 
   void error(const byte* pc, const char* msg) { error(pc, nullptr, msg); }
 
   // Sets internal error state.
   void error(const byte* pc, const byte* pt, const char* format, ...) {
     if (ok()) {
 #if DEBUG
       if (FLAG_wasm_break_on_decoder_error) {
         base::OS::DebugBreak();
@@ skipping 29 matching lines @@
 
   // Converts the given value to a {Result}, copying the error if necessary.
   template <typename T>
   Result<T> toResult(T val) {
     Result<T> result;
     if (error_pc_) {
       result.error_code = kError;
       result.start = start_;
       result.error_pc = error_pc_;
       result.error_pt = error_pt_;
-      result.error_msg = error_msg_;
-      error_msg_.Reset(nullptr);
+      // transfer ownership of the error to the result.
+      result.error_msg.Reset(error_msg_.Detach());
     } else {
       result.error_code = kSuccess;
     }
     result.val = 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(nullptr);
   }
 
   bool ok() const { return error_pc_ == nullptr; }
   bool failed() const { return error_pc_ != nullptr; }
 
+  const byte* start() { return start_; }
+  const byte* pc() { return pc_; }
+
  protected:
   const byte* start_;
   const byte* pc_;
   const byte* limit_;
   const byte* end_;
   const byte* error_pc_;
   const byte* error_pt_;
   base::SmartArrayPointer<char> error_msg_;
 };
 
 #undef TRACE
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_DECODER_H_