src/leb128.cc - external/github.com/WebAssembly/wabt - Git at Google

 /*
  * Copyright 2017 WebAssembly Community Group participants
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "wabt/leb128.h"

 #include <type_traits>

 #include "wabt/stream.h"

 #define MAX_U32_LEB128_BYTES 5
 #define MAX_U64_LEB128_BYTES 10

 namespace wabt {

 Offset U32Leb128Length(uint32_t value) {
   uint32_t size = 0;
   do {
     value >>= 7;
     size++;
   } while (value != 0);
   return size;
 }

 #define LEB128_LOOP_UNTIL(end_cond) \
   do {                              \
     uint8_t byte = value & 0x7f;    \
     value >>= 7;                    \
     if (end_cond) {                 \
       data[length++] = byte;        \
       break;                        \
     } else {                        \
       data[length++] = byte | 0x80; \
     }                               \
   } while (1)

 Offset WriteFixedU32Leb128At(Stream* stream,
                              Offset offset,
                              uint32_t value,
                              const char* desc) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   Offset length =
       WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
   stream->WriteDataAt(offset, data, length, desc);
   return length;
 }

 void WriteU32Leb128(Stream* stream, uint32_t value, const char* desc) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   Offset length = 0;
   LEB128_LOOP_UNTIL(value == 0);
   stream->WriteData(data, length, desc);
 }

 void WriteFixedU32Leb128(Stream* stream, uint32_t value, const char* desc) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   Offset length =
       WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
   stream->WriteData(data, length, desc);
 }

 // returns the length of the leb128.
 Offset WriteU32Leb128At(Stream* stream,
                         Offset offset,
                         uint32_t value,
                         const char* desc) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   Offset length = 0;
   LEB128_LOOP_UNTIL(value == 0);
   stream->WriteDataAt(offset, data, length, desc);
   return length;
 }

 Offset WriteU32Leb128Raw(uint8_t* dest, uint8_t* dest_end, uint32_t value) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   Offset length = 0;
   LEB128_LOOP_UNTIL(value == 0);
   if (static_cast<Offset>(dest_end - dest) < length) {
     return 0;
   }
   memcpy(dest, data, length);
   return length;
 }

 Offset WriteFixedU32Leb128Raw(uint8_t* data, uint8_t* end, uint32_t value) {
   if (end - data < MAX_U32_LEB128_BYTES) {
     return 0;
   }
   data[0] = (value & 0x7f) | 0x80;
   data[1] = ((value >> 7) & 0x7f) | 0x80;
   data[2] = ((value >> 14) & 0x7f) | 0x80;
   data[3] = ((value >> 21) & 0x7f) | 0x80;
   data[4] = ((value >> 28) & 0x0f);
   return MAX_U32_LEB128_BYTES;
 }

 static void WriteS32Leb128(Stream* stream, int32_t value, const char* desc) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   Offset length = 0;
   if (value < 0) {
     LEB128_LOOP_UNTIL(value == -1 && (byte & 0x40));
   } else {
     LEB128_LOOP_UNTIL(value == 0 && !(byte & 0x40));
   }

   stream->WriteData(data, length, desc);
 }

 static void WriteS64Leb128(Stream* stream, int64_t value, const char* desc) {
   uint8_t data[MAX_U64_LEB128_BYTES];
   Offset length = 0;
   if (value < 0) {
     LEB128_LOOP_UNTIL(value == -1 && (byte & 0x40));
   } else {
     LEB128_LOOP_UNTIL(value == 0 && !(byte & 0x40));
   }

   stream->WriteData(data, length, desc);
 }

 void WriteS32Leb128(Stream* stream, uint32_t value, const char* desc) {
   WriteS32Leb128(stream, Bitcast<int32_t>(value), desc);
 }

 void WriteU64Leb128(Stream* stream, uint64_t value, const char* desc) {
   uint8_t data[MAX_U64_LEB128_BYTES];
   Offset length = 0;
   LEB128_LOOP_UNTIL(value == 0);
   stream->WriteData(data, length, desc);
 }

 void WriteS64Leb128(Stream* stream, uint64_t value, const char* desc) {
   WriteS64Leb128(stream, Bitcast<int64_t>(value), desc);
 }

 void WriteFixedS32Leb128(Stream* stream, uint32_t value, const char* desc) {
   uint8_t data[MAX_U32_LEB128_BYTES];
   data[0] = (value & 0x7f) | 0x80;
   data[1] = ((value >> 7) & 0x7f) | 0x80;
   data[2] = ((value >> 14) & 0x7f) | 0x80;
   data[3] = ((value >> 21) & 0x7f) | 0x80;
   // The last byte needs to be sign-extended.
   data[4] = ((value >> 28) & 0x0f);
   if (static_cast<int32_t>(value) < 0) {
     data[4] |= 0x70;
   }
   stream->WriteData(data, MAX_U32_LEB128_BYTES, desc);
 }

 #undef LEB128_LOOP_UNTIL

 #define BYTE_AT(type, i, shift) ((static_cast<type>(p[i]) & 0x7f) << (shift))

 #define LEB128_1(type) (BYTE_AT(type, 0, 0))
 #define LEB128_2(type) (BYTE_AT(type, 1, 7) | LEB128_1(type))
 #define LEB128_3(type) (BYTE_AT(type, 2, 14) | LEB128_2(type))
 #define LEB128_4(type) (BYTE_AT(type, 3, 21) | LEB128_3(type))
 #define LEB128_5(type) (BYTE_AT(type, 4, 28) | LEB128_4(type))
 #define LEB128_6(type) (BYTE_AT(type, 5, 35) | LEB128_5(type))
 #define LEB128_7(type) (BYTE_AT(type, 6, 42) | LEB128_6(type))
 #define LEB128_8(type) (BYTE_AT(type, 7, 49) | LEB128_7(type))
 #define LEB128_9(type) (BYTE_AT(type, 8, 56) | LEB128_8(type))
 #define LEB128_10(type) (BYTE_AT(type, 9, 63) | LEB128_9(type))

 #define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit))
 #define SIGN_EXTEND(type, value, sign_bit)                       \
   (static_cast<type>((value) << SHIFT_AMOUNT(type, sign_bit)) >> \
    SHIFT_AMOUNT(type, sign_bit))

 size_t ReadU32Leb128(const uint8_t* p,
                      const uint8_t* end,
                      uint32_t* out_value) {
   if (p < end && (p[0] & 0x80) == 0) {
     *out_value = LEB128_1(uint32_t);
     return 1;
   } else if (p + 1 < end && (p[1] & 0x80) == 0) {
     *out_value = LEB128_2(uint32_t);
     return 2;
   } else if (p + 2 < end && (p[2] & 0x80) == 0) {
     *out_value = LEB128_3(uint32_t);
     return 3;
   } else if (p + 3 < end && (p[3] & 0x80) == 0) {
     *out_value = LEB128_4(uint32_t);
     return 4;
   } else if (p + 4 < end && (p[4] & 0x80) == 0) {
     // The top bits set represent values > 32 bits.
     if (p[4] & 0xf0) {
       return 0;
     }
     *out_value = LEB128_5(uint32_t);
     return 5;
   } else {
     // past the end.
     *out_value = 0;
     return 0;
   }
 }

 size_t ReadU64Leb128(const uint8_t* p,
                      const uint8_t* end,
                      uint64_t* out_value) {
   if (p < end && (p[0] & 0x80) == 0) {
     *out_value = LEB128_1(uint64_t);
     return 1;
   } else if (p + 1 < end && (p[1] & 0x80) == 0) {
     *out_value = LEB128_2(uint64_t);
     return 2;
   } else if (p + 2 < end && (p[2] & 0x80) == 0) {
     *out_value = LEB128_3(uint64_t);
     return 3;
   } else if (p + 3 < end && (p[3] & 0x80) == 0) {
     *out_value = LEB128_4(uint64_t);
     return 4;
   } else if (p + 4 < end && (p[4] & 0x80) == 0) {
     *out_value = LEB128_5(uint64_t);
     return 5;
   } else if (p + 5 < end && (p[5] & 0x80) == 0) {
     *out_value = LEB128_6(uint64_t);
     return 6;
   } else if (p + 6 < end && (p[6] & 0x80) == 0) {
     *out_value = LEB128_7(uint64_t);
     return 7;
   } else if (p + 7 < end && (p[7] & 0x80) == 0) {
     *out_value = LEB128_8(uint64_t);
     return 8;
   } else if (p + 8 < end && (p[8] & 0x80) == 0) {
     *out_value = LEB128_9(uint64_t);
     return 9;
   } else if (p + 9 < end && (p[9] & 0x80) == 0) {
     // The top bits set represent values > 64 bits.
     if (p[9] & 0xfe) {
       return 0;
     }
     *out_value = LEB128_10(uint64_t);
     return 10;
   } else {
     // past the end.
     *out_value = 0;
     return 0;
   }
 }

 size_t ReadS32Leb128(const uint8_t* p,
                      const uint8_t* end,
                      uint32_t* out_value) {
   if (p < end && (p[0] & 0x80) == 0) {
     uint32_t result = LEB128_1(uint32_t);
     *out_value = SIGN_EXTEND(int32_t, result, 6);
     return 1;
   } else if (p + 1 < end && (p[1] & 0x80) == 0) {
     uint32_t result = LEB128_2(uint32_t);
     *out_value = SIGN_EXTEND(int32_t, result, 13);
     return 2;
   } else if (p + 2 < end && (p[2] & 0x80) == 0) {
     uint32_t result = LEB128_3(uint32_t);
     *out_value = SIGN_EXTEND(int32_t, result, 20);
     return 3;
   } else if (p + 3 < end && (p[3] & 0x80) == 0) {
     uint32_t result = LEB128_4(uint32_t);
     *out_value = SIGN_EXTEND(int32_t, result, 27);
     return 4;
   } else if (p + 4 < end && (p[4] & 0x80) == 0) {
     // The top bits should be a sign-extension of the sign bit.
     bool sign_bit_set = (p[4] & 0x8);
     int top_bits = p[4] & 0xf0;
     if ((sign_bit_set && top_bits != 0x70) ||
         (!sign_bit_set && top_bits != 0)) {
       return 0;
     }
     uint32_t result = LEB128_5(uint32_t);
     *out_value = result;
     return 5;
   } else {
     // Past the end.
     return 0;
   }
 }

 size_t ReadS64Leb128(const uint8_t* p,
                      const uint8_t* end,
                      uint64_t* out_value) {
   if (p < end && (p[0] & 0x80) == 0) {
     uint64_t result = LEB128_1(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 6);
     return 1;
   } else if (p + 1 < end && (p[1] & 0x80) == 0) {
     uint64_t result = LEB128_2(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 13);
     return 2;
   } else if (p + 2 < end && (p[2] & 0x80) == 0) {
     uint64_t result = LEB128_3(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 20);
     return 3;
   } else if (p + 3 < end && (p[3] & 0x80) == 0) {
     uint64_t result = LEB128_4(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 27);
     return 4;
   } else if (p + 4 < end && (p[4] & 0x80) == 0) {
     uint64_t result = LEB128_5(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 34);
     return 5;
   } else if (p + 5 < end && (p[5] & 0x80) == 0) {
     uint64_t result = LEB128_6(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 41);
     return 6;
   } else if (p + 6 < end && (p[6] & 0x80) == 0) {
     uint64_t result = LEB128_7(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 48);
     return 7;
   } else if (p + 7 < end && (p[7] & 0x80) == 0) {
     uint64_t result = LEB128_8(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 55);
     return 8;
   } else if (p + 8 < end && (p[8] & 0x80) == 0) {
     uint64_t result = LEB128_9(uint64_t);
     *out_value = SIGN_EXTEND(int64_t, result, 62);
     return 9;
   } else if (p + 9 < end && (p[9] & 0x80) == 0) {
     // The top bits should be a sign-extension of the sign bit.
     bool sign_bit_set = (p[9] & 0x1);
     int top_bits = p[9] & 0xfe;
     if ((sign_bit_set && top_bits != 0x7e) ||
         (!sign_bit_set && top_bits != 0)) {
       return 0;
     }
     uint64_t result = LEB128_10(uint64_t);
     *out_value = result;
     return 10;
   } else {
     // Past the end.
     return 0;
   }
 }

 #undef BYTE_AT
 #undef LEB128_1
 #undef LEB128_2
 #undef LEB128_3
 #undef LEB128_4
 #undef LEB128_5
 #undef LEB128_6
 #undef LEB128_7
 #undef LEB128_8
 #undef LEB128_9
 #undef LEB128_10
 #undef SHIFT_AMOUNT
 #undef SIGN_EXTEND

 }  // namespace wabt
	/*
	* Copyright 2017 WebAssembly Community Group participants
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "wabt/leb128.h"

	#include <type_traits>

	#include "wabt/stream.h"

	#define MAX_U32_LEB128_BYTES 5
	#define MAX_U64_LEB128_BYTES 10

	namespace wabt {

	Offset U32Leb128Length(uint32_t value) {
	uint32_t size = 0;
	do {
	value >>= 7;
	size++;
	} while (value != 0);
	return size;
	}

	#define LEB128_LOOP_UNTIL(end_cond) \
	do { \
	uint8_t byte = value & 0x7f; \
	value >>= 7; \
	if (end_cond) { \
	data[length++] = byte; \
	break; \
	} else { \
	data[length++] = byte \| 0x80; \
	} \
	} while (1)

	Offset WriteFixedU32Leb128At(Stream* stream,
	Offset offset,
	uint32_t value,
	const char* desc) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	Offset length =
	WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
	stream->WriteDataAt(offset, data, length, desc);
	return length;
	}

	void WriteU32Leb128(Stream* stream, uint32_t value, const char* desc) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	Offset length = 0;
	LEB128_LOOP_UNTIL(value == 0);
	stream->WriteData(data, length, desc);
	}

	void WriteFixedU32Leb128(Stream* stream, uint32_t value, const char* desc) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	Offset length =
	WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
	stream->WriteData(data, length, desc);
	}

	// returns the length of the leb128.
	Offset WriteU32Leb128At(Stream* stream,
	Offset offset,
	uint32_t value,
	const char* desc) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	Offset length = 0;
	LEB128_LOOP_UNTIL(value == 0);
	stream->WriteDataAt(offset, data, length, desc);
	return length;
	}

	Offset WriteU32Leb128Raw(uint8_t* dest, uint8_t* dest_end, uint32_t value) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	Offset length = 0;
	LEB128_LOOP_UNTIL(value == 0);
	if (static_cast<Offset>(dest_end - dest) < length) {
	return 0;
	}
	memcpy(dest, data, length);
	return length;
	}

	Offset WriteFixedU32Leb128Raw(uint8_t* data, uint8_t* end, uint32_t value) {
	if (end - data < MAX_U32_LEB128_BYTES) {
	return 0;
	}
	data[0] = (value & 0x7f) \| 0x80;
	data[1] = ((value >> 7) & 0x7f) \| 0x80;
	data[2] = ((value >> 14) & 0x7f) \| 0x80;
	data[3] = ((value >> 21) & 0x7f) \| 0x80;
	data[4] = ((value >> 28) & 0x0f);
	return MAX_U32_LEB128_BYTES;
	}

	static void WriteS32Leb128(Stream* stream, int32_t value, const char* desc) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	Offset length = 0;
	if (value < 0) {
	LEB128_LOOP_UNTIL(value == -1 && (byte & 0x40));
	} else {
	LEB128_LOOP_UNTIL(value == 0 && !(byte & 0x40));
	}

	stream->WriteData(data, length, desc);
	}

	static void WriteS64Leb128(Stream* stream, int64_t value, const char* desc) {
	uint8_t data[MAX_U64_LEB128_BYTES];
	Offset length = 0;
	if (value < 0) {
	LEB128_LOOP_UNTIL(value == -1 && (byte & 0x40));
	} else {
	LEB128_LOOP_UNTIL(value == 0 && !(byte & 0x40));
	}

	stream->WriteData(data, length, desc);
	}

	void WriteS32Leb128(Stream* stream, uint32_t value, const char* desc) {
	WriteS32Leb128(stream, Bitcast<int32_t>(value), desc);
	}

	void WriteU64Leb128(Stream* stream, uint64_t value, const char* desc) {
	uint8_t data[MAX_U64_LEB128_BYTES];
	Offset length = 0;
	LEB128_LOOP_UNTIL(value == 0);
	stream->WriteData(data, length, desc);
	}

	void WriteS64Leb128(Stream* stream, uint64_t value, const char* desc) {
	WriteS64Leb128(stream, Bitcast<int64_t>(value), desc);
	}

	void WriteFixedS32Leb128(Stream* stream, uint32_t value, const char* desc) {
	uint8_t data[MAX_U32_LEB128_BYTES];
	data[0] = (value & 0x7f) \| 0x80;
	data[1] = ((value >> 7) & 0x7f) \| 0x80;
	data[2] = ((value >> 14) & 0x7f) \| 0x80;
	data[3] = ((value >> 21) & 0x7f) \| 0x80;
	// The last byte needs to be sign-extended.
	data[4] = ((value >> 28) & 0x0f);
	if (static_cast<int32_t>(value) < 0) {
	data[4] \|= 0x70;
	}
	stream->WriteData(data, MAX_U32_LEB128_BYTES, desc);
	}

	#undef LEB128_LOOP_UNTIL

	#define BYTE_AT(type, i, shift) ((static_cast<type>(p[i]) & 0x7f) << (shift))

	#define LEB128_1(type) (BYTE_AT(type, 0, 0))
	#define LEB128_2(type) (BYTE_AT(type, 1, 7) \| LEB128_1(type))
	#define LEB128_3(type) (BYTE_AT(type, 2, 14) \| LEB128_2(type))
	#define LEB128_4(type) (BYTE_AT(type, 3, 21) \| LEB128_3(type))
	#define LEB128_5(type) (BYTE_AT(type, 4, 28) \| LEB128_4(type))
	#define LEB128_6(type) (BYTE_AT(type, 5, 35) \| LEB128_5(type))
	#define LEB128_7(type) (BYTE_AT(type, 6, 42) \| LEB128_6(type))
	#define LEB128_8(type) (BYTE_AT(type, 7, 49) \| LEB128_7(type))
	#define LEB128_9(type) (BYTE_AT(type, 8, 56) \| LEB128_8(type))
	#define LEB128_10(type) (BYTE_AT(type, 9, 63) \| LEB128_9(type))

	#define SHIFT_AMOUNT(type, sign_bit) (sizeof(type) * 8 - 1 - (sign_bit))
	#define SIGN_EXTEND(type, value, sign_bit) \
	(static_cast<type>((value) << SHIFT_AMOUNT(type, sign_bit)) >> \
	SHIFT_AMOUNT(type, sign_bit))

	size_t ReadU32Leb128(const uint8_t* p,
	const uint8_t* end,
	uint32_t* out_value) {
	if (p < end && (p[0] & 0x80) == 0) {
	*out_value = LEB128_1(uint32_t);
	return 1;
	} else if (p + 1 < end && (p[1] & 0x80) == 0) {
	*out_value = LEB128_2(uint32_t);
	return 2;
	} else if (p + 2 < end && (p[2] & 0x80) == 0) {
	*out_value = LEB128_3(uint32_t);
	return 3;
	} else if (p + 3 < end && (p[3] & 0x80) == 0) {
	*out_value = LEB128_4(uint32_t);
	return 4;
	} else if (p + 4 < end && (p[4] & 0x80) == 0) {
	// The top bits set represent values > 32 bits.
	if (p[4] & 0xf0) {
	return 0;
	}
	*out_value = LEB128_5(uint32_t);
	return 5;
	} else {
	// past the end.
	*out_value = 0;
	return 0;
	}
	}

	size_t ReadU64Leb128(const uint8_t* p,
	const uint8_t* end,
	uint64_t* out_value) {
	if (p < end && (p[0] & 0x80) == 0) {
	*out_value = LEB128_1(uint64_t);
	return 1;
	} else if (p + 1 < end && (p[1] & 0x80) == 0) {
	*out_value = LEB128_2(uint64_t);
	return 2;
	} else if (p + 2 < end && (p[2] & 0x80) == 0) {
	*out_value = LEB128_3(uint64_t);
	return 3;
	} else if (p + 3 < end && (p[3] & 0x80) == 0) {
	*out_value = LEB128_4(uint64_t);
	return 4;
	} else if (p + 4 < end && (p[4] & 0x80) == 0) {
	*out_value = LEB128_5(uint64_t);
	return 5;
	} else if (p + 5 < end && (p[5] & 0x80) == 0) {
	*out_value = LEB128_6(uint64_t);
	return 6;
	} else if (p + 6 < end && (p[6] & 0x80) == 0) {
	*out_value = LEB128_7(uint64_t);
	return 7;
	} else if (p + 7 < end && (p[7] & 0x80) == 0) {
	*out_value = LEB128_8(uint64_t);
	return 8;
	} else if (p + 8 < end && (p[8] & 0x80) == 0) {
	*out_value = LEB128_9(uint64_t);
	return 9;
	} else if (p + 9 < end && (p[9] & 0x80) == 0) {
	// The top bits set represent values > 64 bits.
	if (p[9] & 0xfe) {
	return 0;
	}
	*out_value = LEB128_10(uint64_t);
	return 10;
	} else {
	// past the end.
	*out_value = 0;
	return 0;
	}
	}

	size_t ReadS32Leb128(const uint8_t* p,
	const uint8_t* end,
	uint32_t* out_value) {
	if (p < end && (p[0] & 0x80) == 0) {
	uint32_t result = LEB128_1(uint32_t);
	*out_value = SIGN_EXTEND(int32_t, result, 6);
	return 1;
	} else if (p + 1 < end && (p[1] & 0x80) == 0) {
	uint32_t result = LEB128_2(uint32_t);
	*out_value = SIGN_EXTEND(int32_t, result, 13);
	return 2;
	} else if (p + 2 < end && (p[2] & 0x80) == 0) {
	uint32_t result = LEB128_3(uint32_t);
	*out_value = SIGN_EXTEND(int32_t, result, 20);
	return 3;
	} else if (p + 3 < end && (p[3] & 0x80) == 0) {
	uint32_t result = LEB128_4(uint32_t);
	*out_value = SIGN_EXTEND(int32_t, result, 27);
	return 4;
	} else if (p + 4 < end && (p[4] & 0x80) == 0) {
	// The top bits should be a sign-extension of the sign bit.
	bool sign_bit_set = (p[4] & 0x8);
	int top_bits = p[4] & 0xf0;
	if ((sign_bit_set && top_bits != 0x70) \|\|
	(!sign_bit_set && top_bits != 0)) {
	return 0;
	}
	uint32_t result = LEB128_5(uint32_t);
	*out_value = result;
	return 5;
	} else {
	// Past the end.
	return 0;
	}
	}

	size_t ReadS64Leb128(const uint8_t* p,
	const uint8_t* end,
	uint64_t* out_value) {
	if (p < end && (p[0] & 0x80) == 0) {
	uint64_t result = LEB128_1(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 6);
	return 1;
	} else if (p + 1 < end && (p[1] & 0x80) == 0) {
	uint64_t result = LEB128_2(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 13);
	return 2;
	} else if (p + 2 < end && (p[2] & 0x80) == 0) {
	uint64_t result = LEB128_3(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 20);
	return 3;
	} else if (p + 3 < end && (p[3] & 0x80) == 0) {
	uint64_t result = LEB128_4(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 27);
	return 4;
	} else if (p + 4 < end && (p[4] & 0x80) == 0) {
	uint64_t result = LEB128_5(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 34);
	return 5;
	} else if (p + 5 < end && (p[5] & 0x80) == 0) {
	uint64_t result = LEB128_6(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 41);
	return 6;
	} else if (p + 6 < end && (p[6] & 0x80) == 0) {
	uint64_t result = LEB128_7(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 48);
	return 7;
	} else if (p + 7 < end && (p[7] & 0x80) == 0) {
	uint64_t result = LEB128_8(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 55);
	return 8;
	} else if (p + 8 < end && (p[8] & 0x80) == 0) {
	uint64_t result = LEB128_9(uint64_t);
	*out_value = SIGN_EXTEND(int64_t, result, 62);
	return 9;
	} else if (p + 9 < end && (p[9] & 0x80) == 0) {
	// The top bits should be a sign-extension of the sign bit.
	bool sign_bit_set = (p[9] & 0x1);
	int top_bits = p[9] & 0xfe;
	if ((sign_bit_set && top_bits != 0x7e) \|\|
	(!sign_bit_set && top_bits != 0)) {
	return 0;
	}
	uint64_t result = LEB128_10(uint64_t);
	*out_value = result;
	return 10;
	} else {
	// Past the end.
	return 0;
	}
	}

	#undef BYTE_AT
	#undef LEB128_1
	#undef LEB128_2
	#undef LEB128_3
	#undef LEB128_4
	#undef LEB128_5
	#undef LEB128_6
	#undef LEB128_7
	#undef LEB128_8
	#undef LEB128_9
	#undef LEB128_10
	#undef SHIFT_AMOUNT
	#undef SIGN_EXTEND

	} // namespace wabt