runtime/vm/coff.cc

// Copyright (c) 2026, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

#include "vm/coff.h"

#if defined(DART_PRECOMPILER)

#include "include/dart_api.h"
#include "platform/unaligned.h"
#include "platform/utils.h"
#include "vm/codeview.h"
#include "vm/dwarf.h"
#include "vm/image_snapshot.h"
#include "vm/os.h"

namespace dart {

namespace {

static constexpr intptr_t kCoffRelocationOverflowThreshold = 0xffff;
static constexpr uint16_t kCoffRelocationCountOverflowSentinel = 0xffff;

bool UsesRelocationCountOverflow(intptr_t relocation_count) {
  return relocation_count >= kCoffRelocationOverflowThreshold;
}

uint16_t EncodedRelocationCount(intptr_t relocation_count) {
  if (UsesRelocationCountOverflow(relocation_count)) {
    return kCoffRelocationCountOverflowSentinel;
  }
  return static_cast<uint16_t>(relocation_count);
}

intptr_t RelocationRecordCountOnDisk(intptr_t relocation_count) {
  return relocation_count +
         (UsesRelocationCountOverflow(relocation_count) ? 1 : 0);
}

struct ParsedUnwindPrologue {
  uint32_t stack_size = 0;
  uint8_t prologue_size = 0;
};

struct FunctionUnwindRange {
  uint32_t begin = 0;
  uint32_t end = 0;
  ParsedUnwindPrologue prologue;
};

struct SharedUnwindInfo {
  ParsedUnwindPrologue prologue;
  uint32_t xdata_offset = 0;
};

int CompareFunctionUnwindRange(const FunctionUnwindRange* a,
                               const FunctionUnwindRange* b) {
  if (a->begin < b->begin) return -1;
  if (a->begin > b->begin) return 1;
  if (a->end < b->end) return -1;
  if (a->end > b->end) return 1;
  return 0;
}

}  // namespace

// -----------------------------------------------------------------------------
// Construction
// -----------------------------------------------------------------------------

CoffWriter::CoffWriter(Zone* zone,
                       BaseWriteStream* stream,
                       Type type,
                       Dwarf* dwarf)
    : SharedObjectWriter(zone, stream, type, dwarf),
      all_sections_(zone, 8),
      label_to_symbol_index_(zone),
      static_symbol_usage_count_(zone),
      text_portions_(zone, 4) {
  symbols_ = new (zone) ZoneGrowableArray<CoffSym>(zone, 32);
  string_table_ = new (zone) ZoneGrowableArray<uint8_t>(zone, 128);
}

const GrowableArray<const Code*>& CoffWriter::debug_codes() {
  ASSERT(dwarf() != nullptr);
  return dwarf()->codes();
}

const GrowableArray<const Script*>& CoffWriter::debug_scripts() {
  ASSERT(dwarf() != nullptr);
  return dwarf()->scripts();
}

const Trie<const char>* CoffWriter::debug_deobfuscation_trie() {
  ASSERT(dwarf() != nullptr);
  return dwarf()->deobfuscation_trie();
}

intptr_t CoffWriter::LookupDebugCodeLabel(const Code& code) {
  ASSERT(dwarf() != nullptr);
  return dwarf()->LookupCodeLabel(code);
}

intptr_t CoffWriter::LookupDebugScript(const Script& script) {
  ASSERT(dwarf() != nullptr);
  return dwarf()->LookupScript(script);
}

// -----------------------------------------------------------------------------
// String table
// -----------------------------------------------------------------------------

uint32_t CoffWriter::InternString(const char* str) {
  // COFF string table starts at offset 4 (the first 4 bytes hold the size).
  const uint32_t offset = static_cast<uint32_t>(string_table_->length()) + 4;
  const intptr_t len = strlen(str);
  for (intptr_t i = 0; i <= len; i++) {  // include trailing NUL
    string_table_->Add(static_cast<uint8_t>(str[i]));
  }
  return offset;
}

// -----------------------------------------------------------------------------
// Section helpers
// -----------------------------------------------------------------------------

CoffWriter::Section* CoffWriter::GetOrCreateSection(SectionKind kind,
                                                    const char* name,
                                                    uint32_t characteristics,
                                                    intptr_t alignment_log2,
                                                    bool is_bss) {
  if (by_kind_[kind] != nullptr) {
    return by_kind_[kind];
  }
  auto* const section = new (zone_) Section(zone_);
  ASSERT(strlen(name) <= 8);
  for (intptr_t i = 0; i < 8 && name[i] != '\0'; i++) {
    section->name[i] = name[i];
  }
  section->characteristics = characteristics;
  section->alignment_log2 = alignment_log2;
  section->is_bss = is_bss;
  section->relocs = new (zone_) ZoneGrowableArray<Reloc>(zone_, 8);
  by_kind_[kind] = section;
  all_sections_.Add(section);
  return section;
}

void CoffWriter::PadToAlignment(Section* section,
                                intptr_t alignment,
                                uint8_t pad_byte) {
  ASSERT(section != nullptr);
  ASSERT(!section->is_bss);
  ASSERT(Utils::IsPowerOfTwo(alignment));
  section->data.Align(alignment, /*offset=*/0, pad_byte);
}

intptr_t CoffWriter::AppendToSection(
    SectionKind kind,
    const uint8_t* bytes,
    intptr_t size,
    const SharedObjectWriter::RelocationArray* relocations,
    intptr_t owning_label) {
  using R = SharedObjectWriter::Relocation;
  Section* const section = by_kind_[kind];
  ASSERT(section != nullptr);
  ASSERT(!section->is_bss);
  const intptr_t start = section->data.Position();
  section->data.bytes(bytes, size);
  if (relocations != nullptr) {
    for (const auto& vm_reloc : *relocations) {
      // Adjust section_offset to account for any data already in the section.
      SharedObjectWriter::Relocation translated = vm_reloc;
      translated.section_offset += start;
      // The Dart image writer expresses many text relocations as
      // `target_label - owning_label`, where `owning_label` is the headline
      // symbol for the current AddText portion (always at offset `start`
      // within the section).  COFF cannot express `sym1 - sym2` directly,
      // but this form is semantically a self-relative reloc once we shift
      // the reference point from `owning_label` to the relocation site.
      //
      // Rewrite: source_label_addr + source_offset == reloc_addr + new_offset
      //          new_offset = (start + source_offset) - reloc_addr
      // After this rewrite the standard kSelfRelative codepath handles it.
      if (owning_label > 0 && translated.source_label == owning_label) {
        translated.source_offset =
            start + translated.source_offset - translated.section_offset;
        translated.source_label = R::kSelfRelative;
      }
      // Same normalization for target_label == owning_label (rare: e.g.
      // `(.) - other_label` form).
      if (owning_label > 0 && translated.target_label == owning_label) {
        translated.target_offset =
            start + translated.target_offset - translated.section_offset;
        translated.target_label = R::kSelfRelative;
      }
      TranslateAndApply(section, translated);
    }
  }
  return start;
}

// -----------------------------------------------------------------------------
// Public API
// -----------------------------------------------------------------------------

void CoffWriter::AddText(const char* name,
                         intptr_t label,
                         const uint8_t* bytes,
                         intptr_t size,
                         const SharedObjectWriter::RelocationArray* relocations,
                         const SharedObjectWriter::SymbolDataArray* symbols) {
  // First text portion creates the section. 64-byte alignment matches
  // ImageWriter::kTextAlignment (= kObjectStartAlignment); the runtime's
  // VerifyAlignment refuses to load a snapshot whose instructions image is
  // not aligned to kObjectStartAlignment (64).
  GetOrCreateSection(kSecText, ".text",
                     coff::PE_SCN_CNT_CODE | coff::PE_SCN_MEM_EXECUTE |
                         coff::PE_SCN_MEM_READ | coff::PE_SCN_ALIGN_64BYTES,
                     /*alignment_log2=*/6, /*is_bss=*/false);

  // Pad to 64-byte alignment before each text portion so _kDartSnapshotText
  // lands on an object-start boundary. Use 0xCC (int3) as the padding byte so
  // any accidental jump into the gap fails fast.
  PadToAlignment(by_kind_[kSecText], kObjectStartAlignment, 0xCC);

  const intptr_t offset = AppendToSection(kSecText, bytes, size, relocations,
                                          /*owning_label=*/label);

  TextPortion portion;
  portion.symbol_name = name;
  portion.label = label;
  portion.offset_in_text = offset;
  portion.size = size;
  text_portions_.Add(portion);

  // The Code/Stub container symbol itself. This is the headline label
  // (_kDartSnapshotText) that other code resolves against, so it has to be in
  // the symbol table.
  if (name != nullptr) {
    AddExternalSymbol(name, label, kTextSectionNumber, /*value=*/offset);
  }

  if (symbols != nullptr) {
    for (const auto& s : *symbols) {
      AddStaticSymbol(s.name, s.label, kTextSectionNumber,
                      /*value=*/offset + s.offset);
    }
  }
}

void CoffWriter::AddROData(
    const char* name,
    intptr_t label,
    const uint8_t* bytes,
    intptr_t size,
    const SharedObjectWriter::RelocationArray* relocations,
    const SharedObjectWriter::SymbolDataArray* symbols) {
  GetOrCreateSection(kSecRData, ".rdata",
                     coff::PE_SCN_CNT_INITIALIZED_DATA | coff::PE_SCN_MEM_READ |
                         coff::PE_SCN_ALIGN_64BYTES,
                     /*alignment_log2=*/6, /*is_bss=*/false);

  // Match ImageWriter::kRODataAlignment (= kObjectStartAlignment = 64) so
  // each snapshot-data blob's headline symbol falls on an object-start
  // boundary, satisfying ImageReader::VerifyAlignment.
  PadToAlignment(by_kind_[kSecRData], kObjectStartAlignment, 0x00);

  const intptr_t offset = AppendToSection(kSecRData, bytes, size, relocations,
                                          /*owning_label=*/label);

  if (name != nullptr) {
    AddExternalSymbol(name, label, kRDataSectionNumber, /*value=*/offset);
  }
  if (symbols != nullptr) {
    for (const auto& s : *symbols) {
      AddStaticSymbol(s.name, s.label, kRDataSectionNumber,
                      /*value=*/offset + s.offset);
    }
  }
}

// -----------------------------------------------------------------------------
// Relocation translation
// -----------------------------------------------------------------------------

void CoffWriter::TranslateAndApply(
    Section* section,
    const SharedObjectWriter::Relocation& reloc) {
  using R = SharedObjectWriter::Relocation;

  intptr_t target_label = reloc.target_label;
  const intptr_t source_label = reloc.source_label;
  const intptr_t target_offset = reloc.target_offset;
  const intptr_t source_offset = reloc.source_offset;
  const size_t size_in_bytes = reloc.size_in_bytes;
  const intptr_t inline_offset = reloc.section_offset;

  ASSERT(size_in_bytes == 4 || size_in_bytes == 8);

  auto write_inline = [&](int64_t value) {
    const intptr_t end = section->data.Position();
    ASSERT(inline_offset + static_cast<intptr_t>(size_in_bytes) <= end);
    section->data.SetPosition(inline_offset);
    section->data.bytes(&value, size_in_bytes);
    section->data.SetPosition(end);
  };

  auto emit_reloc = [&](uint16_t type) {
    Reloc r;
    r.virtual_address = static_cast<uint32_t>(inline_offset);
    r.symbol_label = target_label;
    r.type = type;
    section->relocs->Add(r);
  };

  // Both sides are constants (snapshot-absolute). Just bake the difference.
  if (source_label == R::kSnapshotRelative &&
      target_label == R::kSnapshotRelative) {
    write_inline(static_cast<int64_t>(target_offset - source_offset));
    return;
  }

  // Self-relative both -- difference is independent of layout.
  if (source_label == R::kSelfRelative && target_label == R::kSelfRelative) {
    write_inline(static_cast<int64_t>(target_offset - source_offset));
    return;
  }

  if (target_label == kBuildIdLabel &&
      !label_to_symbol_index_.HasKey(kBuildIdLabel)) {
    write_inline(0);
    return;
  }

  // Relocation value is relocated address of the target plus an offset.
  if (source_label == R::kSnapshotRelative) {
    // Special-case kBuildIdLabel during stripped builds: emit the sentinel.
    // (Image::kNoRelocatedAddress is private to Image; its value is 0.)
    int64_t addend = static_cast<int64_t>(target_offset - source_offset);
    if (target_label == R::kSelfRelative) {
      target_label = kSelfSectionSymbolLabel;
      addend += inline_offset;
    }
    ASSERT(target_label > 0 || target_label == kSelfSectionSymbolLabel);
    write_inline(addend);
    if (size_in_bytes == 8) {
      emit_reloc(coff::PE_REL_AMD64_ADDR64);
    } else {
      emit_reloc(coff::PE_REL_AMD64_ADDR32);
    }
    return;
  }

  // Relocation value is a relative offset to the target from the current
  // address.
  if (source_label == R::kSelfRelative && target_label > 0) {
    // COFF REL32 computes:  inline + sym - (reloc_addr + 4)
    // Dart   semantics:     target_offset + sym - source_offset - reloc_addr
    // So:    inline = target_offset - source_offset + 4
    int64_t addend = static_cast<int64_t>(target_offset - source_offset + 4);
    if (size_in_bytes == 8) {
      // COFF x64 has no 64-bit PC-relative relocation. The linker patches the
      // low 32 bits, so the encoded addend must fit in signed 32 bits and the
      // upper 32 bits stay zero for snapshot-internal positive offsets.
      RELEASE_ASSERT(Utils::IsInt(32, addend));
      addend &= 0xffffffff;
    }
    write_inline(addend);
    emit_reloc(coff::PE_REL_AMD64_REL32);
    return;
  }

  // Less common: label - constant.  We can still resolve if the label is
  // self-relative (PC-relative) and target is a constant.  Bake target_offset
  // - source PC.  But we don't know PC at write time, so emit relocation form.
  if (source_label > 0 && target_label == R::kSnapshotRelative) {
    // ADDR64(-source).  COFF: inline + sym.  Dart: target_offset - sym -
    // source_offset.  So:  inline = target_offset - source_offset, then we
    // need to negate the symbol contribution -- which COFF cannot do.
    FATAL("CoffWriter: unsupported relocation form (label - snapshot)");
  }

  if (source_label > 0 && target_label > 0) {
    FATAL("CoffWriter: unsupported relocation form (label - label)");
  }

  FATAL("CoffWriter: unhandled relocation (src=%" Pd ", tgt=%" Pd ")",
        source_label, target_label);
}

// -----------------------------------------------------------------------------
// Symbol helpers
// -----------------------------------------------------------------------------

intptr_t CoffWriter::AddExternalSymbol(const char* name,
                                       intptr_t label,
                                       int16_t section_number,
                                       int32_t value) {
  CoffSym sym;
  sym.name = name;
  sym.value = value;
  sym.section_number = section_number;  // patched at AssignSectionNumbers
  sym.type = coff::PE_SYM_TYPE_NULL;
  sym.storage_class = coff::PE_SYM_CLASS_EXTERNAL;
  sym.label = label;
  symbols_->Add(sym);
  const intptr_t index = symbols_->length();  // 1-based when read at write time
  if (label != 0) {
    label_to_symbol_index_.Insert(label, index);
  }
  return index;
}

intptr_t CoffWriter::AddStaticSymbol(const char* name,
                                     intptr_t label,
                                     int16_t section_number,
                                     int32_t value) {
  CoffSym sym;
  sym.name = DisambiguateStaticSymbolName(name);
  sym.value = value;
  sym.section_number = section_number;
  sym.type = coff::PE_SYM_TYPE_NULL;
  sym.storage_class = coff::PE_SYM_CLASS_STATIC;
  sym.label = label;
  symbols_->Add(sym);
  const intptr_t index = symbols_->length();
  if (label != 0) {
    label_to_symbol_index_.Insert(label, index);
  }
  return index;
}

const char* CoffWriter::DisambiguateStaticSymbolName(const char* name) {
  if (name == nullptr) {
    return nullptr;
  }
  auto* const pair = static_symbol_usage_count_.Lookup(name);
  if (pair == nullptr) {
    static_symbol_usage_count_.Insert({name, 1});
    return name;
  }
  return OS::SCreate(zone_, "%s (#%" Pd ")", name, ++pair->value);
}

intptr_t CoffWriter::SymbolIndexForLabel(intptr_t label) const {
  ASSERT(label != 0);
  ASSERT(label_to_symbol_index_.HasKey(label));
  return label_to_symbol_index_.Lookup(label);
}

intptr_t CoffWriter::SymbolIndexForLabelOrZero(intptr_t label) {
  if (label_to_symbol_index_.HasKey(label)) {
    return label_to_symbol_index_.Lookup(label);
  }
  return 0;
}

void CoffWriter::CreateSectionSymbol(Section* section) {
  ASSERT(section->section_number != 0);
  CoffSym sym;
  sym.value = 0;
  sym.section_number = static_cast<int16_t>(section->section_number);
  sym.type = coff::PE_SYM_TYPE_NULL;
  sym.storage_class = coff::PE_SYM_CLASS_STATIC;
  sym.num_aux = 1;
  sym.name = OS::SCreate(zone_, "%s", section->name);
  // Auxiliary record holds section data.
  sym.aux = new (zone_) ZoneGrowableArray<uint8_t>(zone_, 18);
  coff::ImageAuxSymbolSection aux = {};
  aux.Length = section->is_bss
                   ? static_cast<uint32_t>(section->bss_size)
                   : static_cast<uint32_t>(section->data.bytes_written());
  aux.NumberOfRelocations = EncodedRelocationCount(section->relocs->length());
  aux.NumberOfLinenumbers = 0;
  aux.CheckSum = 0;
  aux.Number = static_cast<int16_t>(section->section_number);
  aux.Selection = 0;
  for (size_t i = 0; i < sizeof(aux); i++) {
    sym.aux->Add(reinterpret_cast<uint8_t*>(&aux)[i]);
  }
  symbols_->Add(sym);
  section->section_symbol = symbols_->length();
}

// -----------------------------------------------------------------------------
// BSS sections (mirror ElfWriter::CreateBSS)
// -----------------------------------------------------------------------------

void CoffWriter::EmitBssSections() {
  if (text_portions_.is_empty()) return;

  Section* const bss = GetOrCreateSection(
      kSecBss, ".bss",
      coff::PE_SCN_CNT_UNINITIALIZED_DATA | coff::PE_SCN_MEM_READ |
          coff::PE_SCN_MEM_WRITE | coff::PE_SCN_ALIGN_16BYTES,
      /*alignment_log2=*/4, /*is_bss=*/true);
  AddStaticSymbol(kSnapshotBssAsmSymbol, kIsolateBssLabel, kBssSectionNumber,
                  /*value=*/0);
  bss->bss_size = BSS::kIsolateGroupEntryCount * compiler::target::kWordSize;
}

// -----------------------------------------------------------------------------
// SEH .pdata / .xdata
// -----------------------------------------------------------------------------

void CoffWriter::EmitUnwindData() {
  Section* const text = by_kind_[kSecText];
  if (text == nullptr) return;

  Section* const pdata =
      GetOrCreateSection(kSecPdata, ".pdata",
                         coff::PE_SCN_CNT_INITIALIZED_DATA |
                             coff::PE_SCN_MEM_READ | coff::PE_SCN_ALIGN_4BYTES,
                         /*alignment_log2=*/2, /*is_bss=*/false);
  Section* const xdata =
      GetOrCreateSection(kSecXdata, ".xdata",
                         coff::PE_SCN_CNT_INITIALIZED_DATA |
                             coff::PE_SCN_MEM_READ | coff::PE_SCN_ALIGN_4BYTES,
                         /*alignment_log2=*/2, /*is_bss=*/false);

  auto read_u32 = [](const DebugInfoStream* in, intptr_t offset) -> uint32_t {
    return LoadUnaligned(
        reinterpret_cast<const uint32_t*>(in->buffer() + offset));
  };

  auto parse_standard_prologue = [&](uint32_t begin,
                                     ParsedUnwindPrologue* prologue) -> bool {
    const intptr_t length = text->data.Position();
    if (begin + 4 > static_cast<uint32_t>(length)) return false;
    if (text->data.LoadU1(begin) != 0x55 ||  // push rbp
        text->data.LoadU1(begin + 1) != 0x48 ||
        text->data.LoadU1(begin + 2) != 0x89 ||
        text->data.LoadU1(begin + 3) != 0xe5) {  // mov rbp, rsp
      return false;
    }

    uint32_t cursor = begin + 4;
    uint32_t stack_size = 0;
    if (cursor + 4 <= static_cast<uint32_t>(length) &&
        text->data.LoadU1(cursor) == 0x48 &&
        text->data.LoadU1(cursor + 1) == 0x83 &&
        text->data.LoadU1(cursor + 2) == 0xec) {
      stack_size = text->data.LoadU1(cursor + 3);
      cursor += 4;
    } else if (cursor + 7 <= static_cast<uint32_t>(length) &&
               text->data.LoadU1(cursor) == 0x48 &&
               text->data.LoadU1(cursor + 1) == 0x81 &&
               text->data.LoadU1(cursor + 2) == 0xec) {
      stack_size = read_u32(&text->data, cursor + 3);
      cursor += 7;
    }

    if ((stack_size % 8) != 0) return false;
    prologue->stack_size = stack_size;
    prologue->prologue_size = static_cast<uint8_t>(cursor - begin);
    return true;
  };

  auto has_standard_epilogue = [&](uint32_t begin, uint32_t end) -> bool {
    const uint32_t length = static_cast<uint32_t>(text->data.Position());
    end = Utils::Minimum<uint32_t>(end, length);
    if (end <= begin) return false;

    for (uint32_t cursor = begin; cursor + 4 <= end; cursor++) {
      if (text->data.LoadU1(cursor + 0) != 0x48 ||
          text->data.LoadU1(cursor + 1) != 0x89 ||
          text->data.LoadU1(cursor + 2) != 0xec ||
          text->data.LoadU1(cursor + 3) != 0x5d) {
        continue;
      }
      if (cursor + 4 >= end) return false;
      switch (text->data.LoadU1(cursor + 4)) {
        case 0xc3:  // ret
        case 0xe9:  // jmp rel32
        case 0xeb:  // jmp rel8
        case 0xff:  // jmp r/m64
          return true;
        default:
          break;
      }
    }
    return false;
  };

  ZoneGrowableArray<FunctionUnwindRange> functions(zone_, 128);
  auto add_function = [&](uint32_t begin, uint32_t size) {
    if (size == 0 || begin >= static_cast<uint32_t>(text->data.Position())) {
      return;
    }
    FunctionUnwindRange range;
    range.begin = begin;
    range.end = Utils::Minimum<uint32_t>(
        begin + size, static_cast<uint32_t>(text->data.Position()));
    if (range.end <= range.begin) return;
    if (!parse_standard_prologue(range.begin, &range.prologue)) return;
    if (!has_standard_epilogue(range.begin, range.end)) return;
    for (intptr_t i = 0; i < functions.length(); i++) {
      if (functions[i].begin == range.begin) return;
    }
    functions.Add(range);
  };

  if (dwarf() != nullptr && symbols_ != nullptr) {
    const auto& codes = dwarf()->codes();
    for (intptr_t i = 0; i < codes.length(); i++) {
      const Code& code = *(codes[i]);
      const intptr_t label = dwarf()->LookupCodeLabel(code);
      if (label <= 0 || !label_to_symbol_index_.HasKey(label)) continue;
      const intptr_t sym_idx = label_to_symbol_index_.Lookup(label);
      ASSERT(sym_idx > 0 && sym_idx <= symbols_->length());
      const auto& sym = (*symbols_)[sym_idx - 1];
      ASSERT(sym.section_number == kTextSectionNumber);
      add_function(static_cast<uint32_t>(sym.value),
                   static_cast<uint32_t>(code.Size()));
    }
  }

  if (functions.length() == 0) return;
  functions.Sort(CompareFunctionUnwindRange);

  auto append_unwind_code = [&](uint8_t code_offset, uint8_t unwind_op,
                                uint8_t op_info) {
    xdata->data.u1(code_offset);
    xdata->data.u1(static_cast<uint8_t>((op_info << 4) | (unwind_op & 0x0f)));
  };

  auto emit_unwind_info =
      [&](const ParsedUnwindPrologue& prologue) -> uint32_t {
    const uint32_t xdata_offset = static_cast<uint32_t>(xdata->data.Position());
    xdata->data.u1(coff::kUnwindVersion);
    xdata->data.u1(prologue.prologue_size);
    const intptr_t code_count_offset = xdata->data.Position();
    xdata->data.u1(0);              // CountOfCodes, patched below.
    xdata->data.u1(coff::kRegRbp);  // FrameRegister=RBP.

    uint8_t code_count = 0;
    if (prologue.stack_size > 0) {
      const uint32_t stack_size_words = prologue.stack_size / 8;
      if (Utils::IsUint(4, stack_size_words - 1)) {
        append_unwind_code(prologue.prologue_size, coff::UWOP_ALLOC_SMALL,
                           static_cast<uint8_t>(stack_size_words - 1));
        code_count += 1;
      } else if (Utils::IsUint(16, stack_size_words)) {
        append_unwind_code(prologue.prologue_size, coff::UWOP_ALLOC_LARGE, 0);
        xdata->data.u2(static_cast<uint16_t>(stack_size_words));
        code_count += 2;
      } else {
        append_unwind_code(prologue.prologue_size, coff::UWOP_ALLOC_LARGE, 1);
        xdata->data.u4(prologue.stack_size);
        code_count += 3;
      }
    }
    append_unwind_code(4, coff::UWOP_SET_FPREG, 0);
    code_count += 1;
    append_unwind_code(1, coff::UWOP_PUSH_NONVOL, coff::kRegRbp);
    code_count += 1;

    xdata->data.StoreU1(code_count_offset, code_count);
    xdata->data.Align(4);
    return xdata_offset;
  };

  ZoneGrowableArray<SharedUnwindInfo> shared_unwind_infos(zone_, 16);
  auto unwind_info_for = [&](const ParsedUnwindPrologue& prologue) -> uint32_t {
    for (intptr_t i = 0; i < shared_unwind_infos.length(); i++) {
      const SharedUnwindInfo& shared = shared_unwind_infos[i];
      if (shared.prologue.stack_size == prologue.stack_size &&
          shared.prologue.prologue_size == prologue.prologue_size) {
        return shared.xdata_offset;
      }
    }

    SharedUnwindInfo shared;
    shared.prologue = prologue;
    shared.xdata_offset = emit_unwind_info(prologue);
    shared_unwind_infos.Add(shared);
    return shared.xdata_offset;
  };

  auto u4_with_reloc = [](Section* section, intptr_t label, uint16_t type,
                          uint32_t value) {
    const intptr_t offset = section->data.Position();
    section->relocs->Add({static_cast<uint32_t>(offset), label, type});
    section->data.u4(value);
  };

  for (intptr_t i = 0; i < functions.length(); i++) {
    const FunctionUnwindRange& fn = functions[i];
    const uint32_t xdata_offset = unwind_info_for(fn.prologue);
    u4_with_reloc(pdata, kTextSectionSymbolLabel, coff::PE_REL_AMD64_ADDR32NB,
                  fn.begin);
    u4_with_reloc(pdata, kTextSectionSymbolLabel, coff::PE_REL_AMD64_ADDR32NB,
                  fn.end);
    u4_with_reloc(pdata, kXdataSectionSymbolLabel, coff::PE_REL_AMD64_ADDR32NB,
                  xdata_offset);
  }
}

// -----------------------------------------------------------------------------
// .drectve
// -----------------------------------------------------------------------------

void CoffWriter::EmitDrectve() {
  if (type_ != Type::Snapshot) return;
  Section* const dr =
      GetOrCreateSection(kSecDrectve, ".drectve",
                         coff::PE_SCN_LNK_INFO | coff::PE_SCN_LNK_REMOVE |
                             coff::PE_SCN_ALIGN_1BYTES,
                         /*alignment_log2=*/0, /*is_bss=*/false);

  // Export the snapshot data symbols directly. GetProcAddress can resolve data
  // exports, so no getter thunks are needed.
  const char* const directives = " /EXPORT:" kSnapshotDataCSymbol
                                 ",DATA"
                                 " /EXPORT:" kSnapshotTextCSymbol ",DATA";
  const intptr_t len = strlen(directives);
  dr->data.bytes(directives, len);
}

// -----------------------------------------------------------------------------
// CodeView (Phase 7)
// -----------------------------------------------------------------------------

void CoffWriter::EmitCodeView() {
  if (dwarf_ == nullptr) return;
  Section* const debug_s = GetOrCreateSection(
      kSecDebugS, ".debug$S",
      coff::PE_SCN_CNT_INITIALIZED_DATA | coff::PE_SCN_MEM_READ |
          coff::PE_SCN_MEM_DISCARDABLE | coff::PE_SCN_ALIGN_1BYTES,
      /*alignment_log2=*/0, /*is_bss=*/false);
  Section* const debug_t = GetOrCreateSection(
      kSecDebugT, ".debug$T",
      coff::PE_SCN_CNT_INITIALIZED_DATA | coff::PE_SCN_MEM_READ |
          coff::PE_SCN_MEM_DISCARDABLE | coff::PE_SCN_ALIGN_1BYTES,
      /*alignment_log2=*/0, /*is_bss=*/false);
  codeview_ =
      new (zone_) CodeViewBuilder(zone_, this, &debug_s->data, &debug_t->data);
  codeview_->Build();
}

// -----------------------------------------------------------------------------
// Section number / section symbol assignment
// -----------------------------------------------------------------------------

void CoffWriter::AssignSectionNumbersAndSymbols() {
  // Section numbers are 1-based.  Patch all symbols that referenced a section
  // via the negative-sentinel scheme.
  for (intptr_t i = 0; i < all_sections_.length(); i++) {
    all_sections_[i]->section_number = i + 1;
  }
  Section* text = by_kind_[kSecText];
  Section* rdata = by_kind_[kSecRData];
  Section* bss = by_kind_[kSecBss];

  for (intptr_t i = 0; i < symbols_->length(); i++) {
    auto& s = (*symbols_)[i];
    if (s.section_number == kTextSectionNumber && text != nullptr) {
      s.section_number = static_cast<int16_t>(text->section_number);
    } else if (s.section_number == kRDataSectionNumber && rdata != nullptr) {
      s.section_number = static_cast<int16_t>(rdata->section_number);
    } else if (s.section_number == kBssSectionNumber && bss != nullptr) {
      s.section_number = static_cast<int16_t>(bss->section_number);
    }
  }

  // Create section symbols and append them to the symbol table.
  for (intptr_t i = 0; i < all_sections_.length(); i++) {
    CreateSectionSymbol(all_sections_[i]);
  }

  // Resolve sentinel section labels used inside our own emitters by inserting
  // them into the label map after section symbols are created.
  if (by_kind_[kSecText] != nullptr) {
    label_to_symbol_index_.Insert(kTextSectionSymbolLabel,
                                  by_kind_[kSecText]->section_symbol);
  }
  if (by_kind_[kSecXdata] != nullptr) {
    label_to_symbol_index_.Insert(kXdataSectionSymbolLabel,
                                  by_kind_[kSecXdata]->section_symbol);
  }
}

// -----------------------------------------------------------------------------
// Layout + write
// -----------------------------------------------------------------------------

void CoffWriter::ComputeLayoutAndWrite() {
  // Compute file offsets:
  //  file_header
  //  section_headers[]
  //  per section: raw data (if !is_bss), then relocations
  //  symbol_table
  //  string_table
  const intptr_t num_sections = all_sections_.length();
  intptr_t cursor = sizeof(coff::ImageFileHeader) +
                    num_sections * sizeof(coff::ImageSectionHeader);

  for (auto* s : all_sections_) {
    if (!s->is_bss) {
      // Section raw data alignment within the file is 4 (LLVM convention).
      cursor = Utils::RoundUp(cursor, 4);
      s->raw_data_offset = cursor;
      cursor += s->data.bytes_written();
    } else {
      s->raw_data_offset = 0;
    }
    if (s->relocs->length() > 0) {
      cursor = Utils::RoundUp(cursor, 4);
      s->reloc_offset = cursor;
      cursor += RelocationRecordCountOnDisk(s->relocs->length()) *
                sizeof(coff::ImageRelocation);
    } else {
      s->reloc_offset = 0;
    }
  }

  cursor = Utils::RoundUp(cursor, 4);
  const intptr_t symtab_offset = cursor;
  // Each symbol entry (and each aux entry) is 18 bytes.
  intptr_t symbol_count = 0;
  // parent1_to_disk0[i] gives the 0-based on-disk symbol-table index for the
  // symbol stored at parent-only index i (0-based) in symbols_.  Values tracked
  // elsewhere (label_to_symbol_index_ entries, Section::section_symbol)
  // are 1-based parent-only indices; convert via parent1_to_disk0[v - 1] when
  // writing a SymbolTableIndex into a relocation.  The two diverge whenever a
  // symbol with num_aux>0 (i.e. our section symbols) precedes the lookup.
  ZoneGrowableArray<uint32_t> parent1_to_disk0(zone_, symbols_->length());
  for (intptr_t i = 0; i < symbols_->length(); i++) {
    parent1_to_disk0.Add(static_cast<uint32_t>(symbol_count));
    symbol_count += 1 + (*symbols_)[i].num_aux;
  }
  cursor += symbol_count * 18;
  auto disk_index_of = [&](intptr_t parent1) -> uint32_t {
    ASSERT(parent1 >= 1 && parent1 <= symbols_->length());
    return parent1_to_disk0[parent1 - 1];
  };
  // String table begins immediately after symbol table; size prefix is
  // included in the size word itself.

  // --- Write file header ---
  coff::ImageFileHeader fh = {};
  fh.Machine = coff::PE_FILE_MACHINE_AMD64;
  fh.NumberOfSections = static_cast<uint16_t>(num_sections);
  fh.TimeDateStamp = 0;
  fh.PointerToSymbolTable = static_cast<uint32_t>(symtab_offset);
  fh.NumberOfSymbols = static_cast<uint32_t>(symbol_count);
  fh.SizeOfOptionalHeader = 0;
  fh.Characteristics = coff::PE_FILE_LARGE_ADDRESS_AWARE;
  unwrapped_stream_->WriteBytes(&fh, sizeof(fh));

  // --- Write section headers ---
  for (auto* s : all_sections_) {
    coff::ImageSectionHeader sh = {};
    for (intptr_t i = 0; i < 8; i++) {
      sh.Name[i] = s->name[i];
    }
    sh.VirtualSize = 0;
    sh.VirtualAddress = 0;
    if (s->is_bss) {
      sh.SizeOfRawData = static_cast<uint32_t>(s->bss_size);
      sh.PointerToRawData = 0;
    } else {
      sh.SizeOfRawData = static_cast<uint32_t>(s->data.bytes_written());
      sh.PointerToRawData = static_cast<uint32_t>(s->raw_data_offset);
    }
    sh.PointerToRelocations = static_cast<uint32_t>(s->reloc_offset);
    sh.PointerToLinenumbers = 0;
    const bool has_relocation_overflow =
        UsesRelocationCountOverflow(s->relocs->length());
    sh.NumberOfRelocations = EncodedRelocationCount(s->relocs->length());
    sh.NumberOfLinenumbers = 0;
    sh.Characteristics = s->characteristics;
    if (has_relocation_overflow) {
      sh.Characteristics |= coff::PE_SCN_LNK_NRELOC_OVFL;
    }
    unwrapped_stream_->WriteBytes(&sh, sizeof(sh));
  }

  // --- Write each section's body + reloc table ---
  intptr_t written = unwrapped_stream_->Position();
  for (auto* s : all_sections_) {
    if (!s->is_bss) {
      unwrapped_stream_->Align(4);
      written = unwrapped_stream_->Position();
      ASSERT(written == s->raw_data_offset);
      unwrapped_stream_->WriteBytes(s->data.buffer(), s->data.bytes_written());
      written += s->data.bytes_written();
    }
    if (s->relocs->length() > 0) {
      unwrapped_stream_->Align(4);
      written = unwrapped_stream_->Position();
      ASSERT(written == s->reloc_offset);
      if (UsesRelocationCountOverflow(s->relocs->length())) {
        coff::ImageRelocation overflow = {};
        // The overflow count includes this synthetic relocation itself. COFF
        // readers skip it and expose VirtualAddress - 1 real relocations.
        ASSERT(s->relocs->length() <= static_cast<intptr_t>(kMaxUint32) - 1);
        overflow.VirtualAddress =
            static_cast<uint32_t>(s->relocs->length() + 1);
        unwrapped_stream_->WriteBytes(&overflow, sizeof(overflow));
        written += sizeof(overflow);
      }
      for (const auto& r : *s->relocs) {
        coff::ImageRelocation cr;
        cr.VirtualAddress = r.virtual_address;
        // Special sentinel: kSelfSectionSymbolLabel means "the section symbol
        // for the section this relocation lives in".  Used by snapshot-
        // relative-to-self relocs that need to reference their own section
        // without knowing its index at AppendToSection time.
        if (r.symbol_label == kSelfSectionSymbolLabel) {
          cr.SymbolTableIndex = disk_index_of(s->section_symbol);
        } else {
          cr.SymbolTableIndex =
              disk_index_of(SymbolIndexForLabel(r.symbol_label));
        }
        cr.Type = r.type;
        unwrapped_stream_->WriteBytes(&cr, sizeof(cr));
        written += sizeof(cr);
      }
    }
  }

  // Align before symbol table.
  unwrapped_stream_->Align(4);
  written = unwrapped_stream_->Position();
  ASSERT(written == symtab_offset);

  // --- Write symbol table ---
  for (const auto& s : *symbols_) {
    coff::ImageSymbol is = {};
    const char* name = s.name;
    if (name == nullptr || strlen(name) <= 8) {
      // Inline name in the 8-byte field.
      memset(is.N.ShortName, 0, 8);
      if (name != nullptr) {
        for (intptr_t i = 0; i < 8 && name[i] != '\0'; i++) {
          is.N.ShortName[i] = name[i];
        }
      }
    } else {
      is.N.LongName.Zeroes = 0;
      is.N.LongName.Offset = InternString(name);
    }
    is.Value = s.value;
    is.SectionNumber = s.section_number;
    is.Type = s.type;
    is.StorageClass = s.storage_class;
    is.NumberOfAuxSymbols = s.num_aux;
    unwrapped_stream_->WriteBytes(&is, sizeof(is));
    written += sizeof(is);
    if (s.aux != nullptr) {
      ASSERT(s.aux->length() == 18 * s.num_aux);
      unwrapped_stream_->WriteBytes(&(*s.aux)[0], s.aux->length());
      written += s.aux->length();
    }
  }

  // --- Write string table ---
  uint32_t str_table_size = static_cast<uint32_t>(string_table_->length()) + 4;
  unwrapped_stream_->WriteFixed(str_table_size);
  if (string_table_->length() > 0) {
    unwrapped_stream_->WriteBytes(&(*string_table_)[0],
                                  string_table_->length());
  }
}

// -----------------------------------------------------------------------------
// Finalize
// -----------------------------------------------------------------------------

void CoffWriter::Finalize() {
  EmitBssSections();
  EmitUnwindData();
  EmitDrectve();
  EmitCodeView();

  AssignSectionNumbersAndSymbols();

  // If CodeView builder accumulated relocations that needed the .text section
  // symbol, those got resolved when we inserted the section symbol into the
  // label map.  Nothing else to do here.

  ComputeLayoutAndWrite();
}

}  // namespace dart

#endif  // DART_PRECOMPILER