Method readMemory_impl

lifter/memory/FileReader.hpp:155–206

  }

  bool readMemory_impl(uint64_t addr, unsigned byteSize, uint64_t& value) {
    // Guard against buffer overflow: memcpy into uint64_t is only safe for
    // reads up to 8 bytes. Wider loads (SSE/AVX 128/256/512-bit) must not
    // reach this path — they require vector-aware memory handling.
    if (byteSize > sizeof(uint64_t)) {
      fprintf(stderr, "readMemory: wide load rejected (byteSize=%u > 8)\n", byteSize);
      return 0;
    }
    uint64_t mappedAddr = address_to_mapped_address(addr);
    if (mappedAddr > 0) {
      uint64_t tempValue = 0;
      std::memcpy(&tempValue, reinterpret_cast<const void*>(mappedAddr),
                  byteSize);
      value = tempValue;
      return 1;
    }

    // Handle zero-initialized virtual tails (BSS) and raw->BSS boundary reads.
    uint64_t rva64 = addr - imageBase;
    if (rva64 > UINT32_MAX)
      return 0;
    uint32_t rva = static_cast<uint32_t>(rva64);

    auto it =
        std::upper_bound(sections.begin(), sections.end(), rva,
                         [](uint32_t val, const win::section_header_t& s) {
                           return val < s.virtual_address;
                         });
    if (it == sections.begin())
      return 0;
    --it;

    if (rva >= it->virtual_address + it->virtual_size)
      return 0;

    uint32_t offset_in_section = rva - it->virtual_address;
    if (offset_in_section + byteSize > it->virtual_size)
      return 0;

    uint64_t tempValue = 0;
    if (offset_in_section < it->size_raw_data) {
      uint32_t rawAvailable =
          std::min<uint32_t>(byteSize, it->size_raw_data - offset_in_section);
      std::memcpy(&tempValue,
                  reinterpret_cast<const void*>(FileBase + it->ptr_raw_data +
                                               offset_in_section),
                  rawAvailable);
    }

    value = tempValue;
    return 1;
  }

  const char* getName_impl(uint64_t offset) {
    auto rvaOffset = RvaToFileOffset(offset);