Class EncodingWriter

lib/Bytecode/Writer/BytecodeWriter.cpp:61–159

//===----------------------------------------------------------------------===//
namespace {
class EncodingWriter {
public:
  EncodingWriter(raw_ostream &stream, uint64_t alignment = 1)
      : stream(stream), requiredAlignment(alignment) {}

  void writeByte(uint8_t byte) { stream.write(static_cast<char>(byte)); }

  template <typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  void writeByte(Enum value) {
    writeByte(static_cast<uint8_t>(value));
  }

  void writeVarInt(uint64_t value) {
    uint8_t bytes[10]; // Supports up to 64 bits
    size_t index = 0;

    do {
      uint8_t byte = value & 0x7F; // Lower 7 bits
      value >>= 7;
      if (value != 0)
        byte |= 0x80; // Set continuation bit
      bytes[index++] = byte;
    } while (value != 0 && index < sizeof(bytes));

    stream.write(reinterpret_cast<char *>(bytes), index);
  }

  template <typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  void writeVarInt(Enum value) {
    writeVarInt(static_cast<uint64_t>(value));
  }

  /// Emit a signed variable length integer. Signed varints are encoded using
  /// a varint with zigzag encoding, meaning that we use the low bit of the
  /// value to indicate the sign of the value. This allows for more efficient
  /// encoding of negative values by limiting the number of active bits
  void writeSignedVarInt(uint64_t value) {
    writeVarInt((value << 1) ^ (uint64_t)((int64_t)value >> 63));
  }

  template <typename T>
  std::enable_if_t<std::is_integral<T>::value, void> writeLE(T value) {
    for (size_t i = 0; i < sizeof(T); ++i) {
      writeByte(value & 0xFF);
      // Only shift if there are more bytes to process
      if (sizeof(T) > 1 && i < sizeof(T) - 1)
        value >>= 8;
    }
  }

  template <typename T>
  void writeLE(ArrayRef<T> values) {
    for (T value : values)
      writeLE<T>(value);
  }

  template <typename T>
  void writeLEVarSize(ArrayRef<T> values) {