/*
 * Copyright 2016 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/literal.h"

#include <cassert>
#include <cerrno>
#include <cinttypes>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <limits>
#include <type_traits>

namespace wabt {

namespace {

template <typename T>
struct FloatTraitsBase {};

// The "PlusOne" values are used because normal IEEE floats have an implicit
// leading one, so they have an additional bit of precision.

template <>
struct FloatTraitsBase<float> {
  using Uint = uint32_t;
  static constexpr int kBits = sizeof(Uint) * 8;
  static constexpr int kSigBits = 23;
  static constexpr float kHugeVal = HUGE_VALF;
  static constexpr int kMaxHexBufferSize = WABT_MAX_FLOAT_HEX;

  static float Strto(const char* s, char** endptr) { return strtof(s, endptr); }
};

template <>
struct FloatTraitsBase<double> {
  using Uint = uint64_t;
  static constexpr int kBits = sizeof(Uint) * 8;
  static constexpr int kSigBits = 52;
  static constexpr float kHugeVal = HUGE_VAL;
  static constexpr int kMaxHexBufferSize = WABT_MAX_DOUBLE_HEX;

  static double Strto(const char* s, char** endptr) {
    return strtod(s, endptr);
  }
};

template <typename T>
struct FloatTraits : FloatTraitsBase<T> {
  using Uint = typename FloatTraitsBase<T>::Uint;
  using FloatTraitsBase<T>::kBits;
  using FloatTraitsBase<T>::kSigBits;

  static constexpr int kExpBits = kBits - kSigBits - 1;
  static constexpr int kSignShift = kBits - 1;
  static constexpr Uint kSigMask = (Uint(1) << kSigBits) - 1;
  static constexpr int kSigPlusOneBits = kSigBits + 1;
  static constexpr Uint kSigPlusOneMask = (Uint(1) << kSigPlusOneBits) - 1;
  static constexpr int kExpMask = (1 << kExpBits) - 1;
  static constexpr int kMaxExp = 1 << (kExpBits - 1);
  static constexpr int kMinExp = -kMaxExp + 1;
  static constexpr int kExpBias = -kMinExp;
  static constexpr Uint kQuietNanTag = Uint(1) << (kSigBits - 1);
};

template <typename T>
class FloatParser {
 public:
  using Traits = FloatTraits<T>;
  using Uint = typename Traits::Uint;
  using Float = T;

  static Result Parse(LiteralType,
                      const char* s,
                      const char* end,
                      Uint* out_bits);

 private:
  static bool StringStartsWith(const char* start,
                               const char* end,
                               const char* prefix);
  static Uint Make(bool sign, int exp, Uint sig);
  static Uint ShiftAndRoundToNearest(Uint significand,
                                     int shift,
                                     bool seen_trailing_non_zero);

  static Result ParseFloat(const char* s, const char* end, Uint* out_bits);
  static Result ParseNan(const char* s, const char* end, Uint* out_bits);
  static Result ParseHex(const char* s, const char* end, Uint* out_bits);
  static void ParseInfinity(const char* s, const char* end, Uint* out_bits);
};

template <typename T>
class FloatWriter {
 public:
  using Traits = FloatTraits<T>;
  using Uint = typename Traits::Uint;

  static void WriteHex(char* out, size_t size, Uint bits);
};

// Return 1 if the non-NULL-terminated string starting with |start| and ending
// with |end| starts with the NULL-terminated string |prefix|.
template <typename T>
// static
bool FloatParser<T>::StringStartsWith(const char* start,
                                      const char* end,
                                      const char* prefix) {
  while (start < end && *prefix) {
    if (*start != *prefix) {
      return false;
    }
    start++;
    prefix++;
  }
  return *prefix == 0;
}

// static
template <typename T>
Result FloatParser<T>::ParseFloat(const char* s,
                                  const char* end,
                                  Uint* out_bits) {
  // Here is the normal behavior for strtof/strtod:
  //
  // input     | errno  |   output   |
  // ---------------------------------
  // overflow  | ERANGE | +-HUGE_VAL |
  // underflow | ERANGE |        0.0 |
  // otherwise |      0 |      value |
  //
  // So normally we need to clear errno before calling strto{f,d}, and check
  // afterward whether it was set to ERANGE.
  //
  // glibc seems to have a bug where
  // strtof("340282356779733661637539395458142568448") will return HUGE_VAL,
  // but will not set errno to ERANGE. Since this function is only called when
  // we know that we have parsed a "normal" number (i.e. not "inf"), we know
  // that if we ever get HUGE_VAL, it must be overflow.
  //
  // The WebAssembly spec also ignores underflow, so we don't need to check for
  // ERANGE at all.

  // WebAssembly floats can contain underscores, but strto* can't parse those,
  // so remove them first.
  assert(s <= end);
  const size_t kBufferSize = end - s + 1;  // +1 for \0.
  char* buffer = static_cast<char*>(alloca(kBufferSize));
  auto buffer_end =
      std::copy_if(s, end, buffer, [](char c) -> bool { return c != '_'; });
  assert(buffer_end < buffer + kBufferSize);
  *buffer_end = 0;

  char* endptr;
  Float value = Traits::Strto(buffer, &endptr);
  if (endptr != buffer_end ||
      (value == Traits::kHugeVal || value == -Traits::kHugeVal)) {
    return Result::Error;
  }

  memcpy(out_bits, &value, sizeof(value));
  return Result::Ok;
}

// static
template <typename T>
typename FloatParser<T>::Uint FloatParser<T>::Make(bool sign,
                                                   int exp,
                                                   Uint sig) {
  assert(exp >= Traits::kMinExp && exp <= Traits::kMaxExp);
  assert(sig <= Traits::kSigMask);
  return (Uint(sign) << Traits::kSignShift) |
         (Uint(exp + Traits::kExpBias) << Traits::kSigBits) | sig;
}

// static
template <typename T>
typename FloatParser<T>::Uint FloatParser<T>::ShiftAndRoundToNearest(
    Uint significand,
    int shift,
    bool seen_trailing_non_zero) {
  assert(shift > 0);
  // Round ties to even.
  if ((significand & (Uint(1) << shift)) || seen_trailing_non_zero) {
    significand += Uint(1) << (shift - 1);
  }
  significand >>= shift;
  return significand;
}

// static
template <typename T>
Result FloatParser<T>::ParseNan(const char* s,
                                const char* end,
                                Uint* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(StringStartsWith(s, end, "nan"));
  s += 3;

  Uint tag;
  if (s != end) {
    tag = 0;
    assert(StringStartsWith(s, end, ":0x"));
    s += 3;

    for (; s < end; ++s) {
      if (*s == '_') {
        continue;
      }
      uint32_t digit;
      CHECK_RESULT(ParseHexdigit(*s, &digit));
      tag = tag * 16 + digit;
      // Check for overflow.
      if (tag > Traits::kSigMask) {
        return Result::Error;
      }
    }

    // NaN cannot have a zero tag, that is reserved for infinity.
    if (tag == 0) {
      return Result::Error;
    }
  } else {
    tag = Traits::kQuietNanTag;
  }

  *out_bits = Make(is_neg, Traits::kMaxExp, tag);
  return Result::Ok;
}

// static
template <typename T>
Result FloatParser<T>::ParseHex(const char* s,
                                const char* end,
                                Uint* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(StringStartsWith(s, end, "0x"));
  s += 2;

  // Loop over the significand; everything up to the 'p'.
  // This code is a bit nasty because we want to support extra zeroes anywhere
  // without having to use many significand bits.
  // e.g.
  // 0x00000001.0p0 => significand = 1, significand_exponent = 0
  // 0x10000000.0p0 => significand = 1, significand_exponent = 28
  // 0x0.000001p0 => significand = 1, significand_exponent = -24
  bool seen_dot = false;
  bool seen_trailing_non_zero = false;
  Uint significand = 0;
  int significand_exponent = 0;  // Exponent adjustment due to dot placement.
  for (; s < end; ++s) {
    uint32_t digit;
    if (*s == '_') {
      continue;
    } else if (*s == '.') {
      seen_dot = true;
    } else if (Succeeded(ParseHexdigit(*s, &digit))) {
      if (Traits::kBits - Clz(significand) <= Traits::kSigPlusOneBits) {
        significand = (significand << 4) + digit;
        if (seen_dot) {
          significand_exponent -= 4;
        }
      } else {
        if (!seen_trailing_non_zero && digit != 0) {
          seen_trailing_non_zero = true;
        }
        if (!seen_dot) {
          significand_exponent += 4;
        }
      }
    } else {
      break;
    }
  }

  if (significand == 0) {
    // 0 or -0.
    *out_bits = Make(is_neg, Traits::kMinExp, 0);
    return Result::Ok;
  }

  int exponent = 0;
  bool exponent_is_neg = false;
  if (s < end) {
    assert(*s == 'p' || *s == 'P');
    s++;
    // Exponent is always positive, but significand_exponent is signed.
    // significand_exponent_add is negated if exponent will be negative, so it
    // can be easily summed to see if the exponent is too large (see below).
    int significand_exponent_add = 0;
    if (*s == '-') {
      exponent_is_neg = true;
      significand_exponent_add = -significand_exponent;
      s++;
    } else if (*s == '+') {
      s++;
      significand_exponent_add = significand_exponent;
    }

    for (; s < end; ++s) {
      if (*s == '_') {
        continue;
      }

      uint32_t digit = (*s - '0');
      assert(digit <= 9);
      exponent = exponent * 10 + digit;
      if (exponent + significand_exponent_add >= Traits::kMaxExp) {
        break;
      }
    }
  }

  if (exponent_is_neg) {
    exponent = -exponent;
  }

  int significand_bits = Traits::kBits - Clz(significand);
  // -1 for the implicit 1 bit of the significand.
  exponent += significand_exponent + significand_bits - 1;

  if (exponent <= Traits::kMinExp) {
    // Maybe subnormal.
    auto update_seen_trailing_non_zero = [&](int shift) {
      assert(shift > 0);
      auto mask = (Uint(1) << (shift - 1)) - 1;
      seen_trailing_non_zero |= (significand & mask) != 0;
    };

    // Normalize significand.
    if (significand_bits > Traits::kSigBits) {
      int shift = significand_bits - Traits::kSigBits;
      update_seen_trailing_non_zero(shift);
      significand >>= shift;
    } else if (significand_bits < Traits::kSigBits) {
      significand <<= (Traits::kSigBits - significand_bits);
    }

    int shift = Traits::kMinExp - exponent;
    if (shift <= Traits::kSigBits) {
      if (shift) {
        update_seen_trailing_non_zero(shift);
        significand =
            ShiftAndRoundToNearest(significand, shift, seen_trailing_non_zero) &
            Traits::kSigMask;
      }
      exponent = Traits::kMinExp;

      if (significand != 0) {
        *out_bits = Make(is_neg, exponent, significand);
        return Result::Ok;
      }
    }

    // Not subnormal, too small; return 0 or -0.
    *out_bits = Make(is_neg, Traits::kMinExp, 0);
  } else {
    // Maybe Normal value.
    if (significand_bits > Traits::kSigPlusOneBits) {
      significand = ShiftAndRoundToNearest(
          significand, significand_bits - Traits::kSigPlusOneBits,
          seen_trailing_non_zero);
      if (significand > Traits::kSigPlusOneMask) {
        exponent++;
      }
    } else if (significand_bits < Traits::kSigPlusOneBits) {
      significand <<= (Traits::kSigPlusOneBits - significand_bits);
    }

    if (exponent >= Traits::kMaxExp) {
      // Would be inf or -inf, but the spec doesn't allow rounding hex-floats to
      // infinity.
      return Result::Error;
    }

    *out_bits = Make(is_neg, exponent, significand & Traits::kSigMask);
  }

  return Result::Ok;
}

// static
template <typename T>
void FloatParser<T>::ParseInfinity(const char* s,
                                   const char* end,
                                   Uint* out_bits) {
  bool is_neg = false;
  if (*s == '-') {
    is_neg = true;
    s++;
  } else if (*s == '+') {
    s++;
  }
  assert(StringStartsWith(s, end, "inf"));
  *out_bits = Make(is_neg, Traits::kMaxExp, 0);
}

// static
template <typename T>
Result FloatParser<T>::Parse(LiteralType literal_type,
                             const char* s,
                             const char* end,
                             Uint* out_bits) {
#if COMPILER_IS_MSVC
  if (literal_type == LiteralType::Int && StringStartsWith(s, end, "0x")) {
    // Some MSVC crt implementation of strtof doesn't support hex strings
    literal_type = LiteralType::Hexfloat;
  }
#endif
  switch (literal_type) {
    case LiteralType::Int:
    case LiteralType::Float:
      return ParseFloat(s, end, out_bits);

    case LiteralType::Hexfloat:
      return ParseHex(s, end, out_bits);

    case LiteralType::Infinity:
      ParseInfinity(s, end, out_bits);
      return Result::Ok;

    case LiteralType::Nan:
      return ParseNan(s, end, out_bits);
  }

  WABT_UNREACHABLE;
}

// static
template <typename T>
void FloatWriter<T>::WriteHex(char* out, size_t size, Uint bits) {
  static constexpr int kNumNybbles = Traits::kBits / 4;
  static constexpr int kTopNybbleShift = Traits::kBits - 4;
  static constexpr Uint kTopNybble = Uint(0xf) << kTopNybbleShift;
  static const char s_hex_digits[] = "0123456789abcdef";

  char buffer[Traits::kMaxHexBufferSize];
  char* p = buffer;
  bool is_neg = (bits >> Traits::kSignShift);
  int exp = ((bits >> Traits::kSigBits) & Traits::kExpMask) - Traits::kExpBias;
  Uint sig = bits & Traits::kSigMask;

  if (is_neg) {
    *p++ = '-';
  }
  if (exp == Traits::kMaxExp) {
    // Infinity or nan.
    if (sig == 0) {
      strcpy(p, "inf");
      p += 3;
    } else {
      strcpy(p, "nan");
      p += 3;
      if (sig != Traits::kQuietNanTag) {
        strcpy(p, ":0x");
        p += 3;
        // Skip leading zeroes.
        int num_nybbles = kNumNybbles;
        while ((sig & kTopNybble) == 0) {
          sig <<= 4;
          num_nybbles--;
        }
        while (num_nybbles) {
          Uint nybble = (sig >> kTopNybbleShift) & 0xf;
          *p++ = s_hex_digits[nybble];
          sig <<= 4;
          --num_nybbles;
        }
      }
    }
  } else {
    bool is_zero = sig == 0 && exp == Traits::kMinExp;
    strcpy(p, "0x");
    p += 2;
    *p++ = is_zero ? '0' : '1';

    // Shift sig up so the top 4-bits are at the top of the Uint.
    sig <<= Traits::kBits - Traits::kSigBits;

    if (sig) {
      if (exp == Traits::kMinExp) {
        // Subnormal; shift the significand up, and shift out the implicit 1.
        Uint leading_zeroes = Clz(sig);
        if (leading_zeroes < Traits::kSignShift) {
          sig <<= leading_zeroes + 1;
        } else {
          sig = 0;
        }
        exp -= leading_zeroes;
      }

      *p++ = '.';
      while (sig) {
        int nybble = (sig >> kTopNybbleShift) & 0xf;
        *p++ = s_hex_digits[nybble];
        sig <<= 4;
      }
    }
    *p++ = 'p';
    if (is_zero) {
      strcpy(p, "+0");
      p += 2;
    } else {
      if (exp < 0) {
        *p++ = '-';
        exp = -exp;
      } else {
        *p++ = '+';
      }
      if (exp >= 1000) {
        *p++ = '1';
      }
      if (exp >= 100) {
        *p++ = '0' + (exp / 100) % 10;
      }
      if (exp >= 10) {
        *p++ = '0' + (exp / 10) % 10;
      }
      *p++ = '0' + exp % 10;
    }
  }

  size_t len = p - buffer;
  if (len >= size) {
    len = size - 1;
  }
  memcpy(out, buffer, len);
  out[len] = '\0';
}

}  // end anonymous namespace

Result ParseHexdigit(char c, uint32_t* out) {
  if (static_cast<unsigned int>(c - '0') <= 9) {
    *out = c - '0';
    return Result::Ok;
  } else if (static_cast<unsigned int>(c - 'a') < 6) {
    *out = 10 + (c - 'a');
    return Result::Ok;
  } else if (static_cast<unsigned int>(c - 'A') < 6) {
    *out = 10 + (c - 'A');
    return Result::Ok;
  }
  return Result::Error;
}

Result ParseUint64(const char* s, const char* end, uint64_t* out) {
  if (s == end) {
    return Result::Error;
  }
  uint64_t value = 0;
  if (*s == '0' && s + 1 < end && s[1] == 'x') {
    s += 2;
    if (s == end) {
      return Result::Error;
    }
    constexpr uint64_t kMaxDiv16 = UINT64_MAX / 16;
    constexpr uint64_t kMaxMod16 = UINT64_MAX % 16;
    for (; s < end; ++s) {
      uint32_t digit;
      if (*s == '_') {
        continue;
      }
      CHECK_RESULT(ParseHexdigit(*s, &digit));
      // Check for overflow.
      if (value > kMaxDiv16 || (value == kMaxDiv16 && digit > kMaxMod16)) {
        return Result::Error;
      }
      value = value * 16 + digit;
    }
  } else {
    constexpr uint64_t kMaxDiv10 = UINT64_MAX / 10;
    constexpr uint64_t kMaxMod10 = UINT64_MAX % 10;
    for (; s < end; ++s) {
      if (*s == '_') {
        continue;
      }
      uint32_t digit = (*s - '0');
      if (digit > 9) {
        return Result::Error;
      }
      // Check for overflow.
      if (value > kMaxDiv10 || (value == kMaxDiv10 && digit > kMaxMod10)) {
        return Result::Error;
      }
      value = value * 10 + digit;
    }
  }
  if (s != end) {
    return Result::Error;
  }
  *out = value;
  return Result::Ok;
}

Result ParseInt64(const char* s,
                  const char* end,
                  uint64_t* out,
                  ParseIntType parse_type) {
  bool has_sign = false;
  if (*s == '-' || *s == '+') {
    if (parse_type == ParseIntType::UnsignedOnly) {
      return Result::Error;
    }
    if (*s == '-') {
      has_sign = true;
    }
    s++;
  }
  uint64_t value = 0;
  Result result = ParseUint64(s, end, &value);
  if (has_sign) {
    // abs(INT64_MIN) == INT64_MAX + 1.
    if (value > static_cast<uint64_t>(INT64_MAX) + 1) {
      return Result::Error;
    }
    value = UINT64_MAX - value + 1;
  }
  *out = value;
  return result;
}

namespace {
uint32_t AddWithCarry(uint32_t x, uint32_t y, uint32_t* carry) {
  // Increments *carry if the addition overflows, otherwise leaves carry alone.
  if ((0xffffffff - x) < y) {
    ++*carry;
  }
  return x + y;
}

void Mul10(v128* v) {
  // Multiply-by-10 decomposes into (x << 3) + (x << 1). We implement those
  // operations with carrying from smaller quads of the v128 to the larger
  // quads.

  constexpr uint32_t kTopThreeBits = 0xe0000000;
  constexpr uint32_t kTopBit = 0x80000000;

  uint32_t carry_into_v1 =
      ((v->u32(0) & kTopThreeBits) >> 29) + ((v->u32(0) & kTopBit) >> 31);
  v->set_u32(0, AddWithCarry(v->u32(0) << 3, v->u32(0) << 1, &carry_into_v1));
  uint32_t carry_into_v2 =
      ((v->u32(1) & kTopThreeBits) >> 29) + ((v->u32(1) & kTopBit) >> 31);
  v->set_u32(1, AddWithCarry(v->u32(1) << 3, v->u32(1) << 1, &carry_into_v2));
  v->set_u32(1, AddWithCarry(v->u32(1), carry_into_v1, &carry_into_v2));
  uint32_t carry_into_v3 =
      ((v->u32(2) & kTopThreeBits) >> 29) + ((v->u32(2) & kTopBit) >> 31);
  v->set_u32(2, AddWithCarry(v->u32(2) << 3, v->u32(2) << 1, &carry_into_v3));
  v->set_u32(2, AddWithCarry(v->u32(2), carry_into_v2, &carry_into_v3));
  v->set_u32(3, v->u32(3) * 10 + carry_into_v3);
}
}  // namespace

Result ParseUint128(const char* s, const char* end, v128* out) {
  if (s == end) {
    return Result::Error;
  }

  out->set_zero();

  while (true) {
    uint32_t digit = (*s - '0');
    if (digit > 9) {
      return Result::Error;
    }

    uint32_t carry_into_v1 = 0;
    uint32_t carry_into_v2 = 0;
    uint32_t carry_into_v3 = 0;
    uint32_t overflow = 0;
    out->set_u32(0, AddWithCarry(out->u32(0), digit, &carry_into_v1));
    out->set_u32(1, AddWithCarry(out->u32(1), carry_into_v1, &carry_into_v2));
    out->set_u32(2, AddWithCarry(out->u32(2), carry_into_v2, &carry_into_v3));
    out->set_u32(3, AddWithCarry(out->u32(3), carry_into_v3, &overflow));
    if (overflow) {
      return Result::Error;
    }

    ++s;

    if (s == end) {
      break;
    }

    Mul10(out);
  }
  return Result::Ok;
}

template <typename U>
Result ParseInt(const char* s,
                const char* end,
                U* out,
                ParseIntType parse_type) {
  using S = typename std::make_signed<U>::type;
  uint64_t value;
  bool has_sign = false;
  if (*s == '-' || *s == '+') {
    if (parse_type == ParseIntType::UnsignedOnly) {
      return Result::Error;
    }
    if (*s == '-') {
      has_sign = true;
    }
    s++;
  }
  CHECK_RESULT(ParseUint64(s, end, &value));

  if (has_sign) {
    // abs(INTN_MIN) == INTN_MAX + 1.
    if (value > static_cast<uint64_t>(std::numeric_limits<S>::max()) + 1) {
      return Result::Error;
    }
    value = std::numeric_limits<U>::max() - value + 1;
  } else {
    if (value > static_cast<uint64_t>(std::numeric_limits<U>::max())) {
      return Result::Error;
    }
  }
  *out = static_cast<U>(value);
  return Result::Ok;
}

Result ParseInt8(const char* s,
                 const char* end,
                 uint8_t* out,
                 ParseIntType parse_type) {
  return ParseInt(s, end, out, parse_type);
}

Result ParseInt16(const char* s,
                  const char* end,
                  uint16_t* out,
                  ParseIntType parse_type) {
  return ParseInt(s, end, out, parse_type);
}

Result ParseInt32(const char* s,
                  const char* end,
                  uint32_t* out,
                  ParseIntType parse_type) {
  return ParseInt(s, end, out, parse_type);
}

Result ParseFloat(LiteralType literal_type,
                  const char* s,
                  const char* end,
                  uint32_t* out_bits) {
  return FloatParser<float>::Parse(literal_type, s, end, out_bits);
}

Result ParseDouble(LiteralType literal_type,
                   const char* s,
                   const char* end,
                   uint64_t* out_bits) {
  return FloatParser<double>::Parse(literal_type, s, end, out_bits);
}

void WriteFloatHex(char* buffer, size_t size, uint32_t bits) {
  return FloatWriter<float>::WriteHex(buffer, size, bits);
}

void WriteDoubleHex(char* buffer, size_t size, uint64_t bits) {
  return FloatWriter<double>::WriteHex(buffer, size, bits);
}

void WriteUint128(char* buffer, size_t size, v128 bits) {
  uint64_t digits;
  uint64_t remainder;
  char reversed_buffer[40];
  size_t len = 0;
  do {
    remainder = bits.u32(3);

    for (int i = 3; i != 0; --i) {
      digits = remainder / 10;
      remainder = ((remainder - digits * 10) << 32) + bits.u32(i - 1);
      bits.set_u32(i, digits);
    }

    digits = remainder / 10;
    remainder = remainder - digits * 10;
    bits.set_u32(0, digits);

    char remainder_buffer[21];
    snprintf(remainder_buffer, 21, "%" PRIu64, remainder);
    int remainder_buffer_len = strlen(remainder_buffer);
    assert(len + remainder_buffer_len < sizeof(reversed_buffer));
    memcpy(&reversed_buffer[len], remainder_buffer, remainder_buffer_len);
    len += remainder_buffer_len;
  } while (!bits.is_zero());
  size_t truncated_tail = 0;
  if (len >= size) {
    truncated_tail = len - size + 1;
    len = size - 1;
  }
  std::reverse_copy(reversed_buffer + truncated_tail,
                    reversed_buffer + len + truncated_tail, buffer);
  buffer[len] = '\0';
}

}  // namespace wabt