Revert of [wasm] Update {i32,i64}.const to use 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 62 matching lines @@
 
   // Reads 64-bit word, reporting an error if out of bounds.
   inline uint64_t checked_read_u64(const byte* base, int offset,
                                    const char* msg = "expected 8 bytes") {
     return check(base, offset, 8, msg) ? read_u64(base + offset) : 0;
   }
 
   // Reads a variable-length unsigned integer (little endian).
   uint32_t checked_read_u32v(const byte* base, int offset, int* length,
                              const char* msg = "expected LEB32") {
-    return checked_read_leb<uint32_t, false>(base, offset, length, msg);
+    return checked_read_leb<uint32_t>(base, offset, length, msg);
   }
 
   // Reads a variable-length signed integer (little endian).
   int32_t checked_read_i32v(const byte* base, int offset, int* length,
                             const char* msg = "expected SLEB32") {
-    uint32_t result =
-        checked_read_leb<uint32_t, true>(base, offset, length, msg);
+    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;
       // Perform sign extension.
       return bit_cast<int32_t>(result << shift) >> shift;
     }
     return 0;
   }
 
   // Reads a variable-length unsigned integer (little endian).
   uint64_t checked_read_u64v(const byte* base, int offset, int* length,
                              const char* msg = "expected LEB64") {
-    return checked_read_leb<uint64_t, false>(base, offset, length, msg);
+    return checked_read_leb<uint64_t>(base, offset, length, msg);
   }
 
   // Reads a variable-length signed integer (little endian).
   int64_t checked_read_i64v(const byte* base, int offset, int* length,
                             const char* msg = "expected SLEB64") {
-    uint64_t result =
-        checked_read_leb<uint64_t, true>(base, offset, length, msg);
+    uint64_t result = checked_read_u64v(base, offset, length, msg);
     if (*length == 10) return bit_cast<int64_t>(result);
     if (*length > 0) {
       int shift = 64 - 7 * *length;
       // Perform sign extension.
       return bit_cast<int64_t>(result << shift) >> shift;
     }
     return 0;
   }
 
   // Reads a single 16-bit unsigned integer (little endian).
@@ skipping 213 matching lines @@
  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_;
 
  private:
-  template <typename IntType, bool is_signed>
+  template <typename IntType>
   IntType checked_read_leb(const byte* base, int offset, int* 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_;
     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);
     *length = static_cast<int>(ptr - (base + offset));
     if (ptr == end) {
       // Check there are no bits set beyond the bitwidth of {IntType}.
       const int kExtraBits = (1 + kMaxLength * 7) - (sizeof(IntType) * 8);
-      const byte kExtraBitsMask = static_cast<byte>(0xFF << (8 - kExtraBits));
-      int extra_bits_value;
-      if (is_signed) {
-        // A signed-LEB128 must sign-extend the final byte, excluding its
-        // most-signifcant bit. e.g. for a 32-bit LEB128:
-        //   kExtraBits = 4
-        //   kExtraBitsMask = 0xf0
-        // If b is 0x0f, the value is negative, so extra_bits_value is 0x70.
-        // If b is 0x03, the value is positive, so extra_bits_value is 0x00.
-        extra_bits_value = (static_cast<int8_t>(b << kExtraBits) >> 8) &
-                           kExtraBitsMask & ~0x80;
-      } else {
-        extra_bits_value = 0;
-      }
-      if (*length == kMaxLength && (b & kExtraBitsMask) != extra_bits_value) {
+      const byte kExtraBitsMask =
+          static_cast<byte>((0xFF << (8 - kExtraBits)) & 0xFF);
+      if (*length == kMaxLength && (b & kExtraBitsMask) != 0) {
         error(base, ptr, "extra bits in varint");
         return 0;
       }
       if ((b & 0x80) != 0) {
         error(base, ptr, msg);
         return 0;
       }
     }
     return result;
   }
 };
 
 #undef TRACE
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_WASM_DECODER_H_