kvs/kvs_pass1.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
Первый проход КВС (однопроходная версия с заглушками)
Генерирует CSV-таблицу напрямую из AST
- Неизвестные метки заменяются заглушками (0xCC) с пометкой в колонке 'уводящий_адрес'
- В колонке 'приводящая_метка' записываются имена меток, находящихся по данному адресу (через запятую)
- Колонка 'команда_со_значениями' оставлена пустой (для второго прохода)
- Колонки 'рассчитанный_уводящий_адрес' и 'рассчитанный_байт' оставлены для второго прохода
- Колонка 'виртуальный_адрес' содержит виртуальный адрес байта (для pass4)
"""

import sys
import csv
import struct  # <--- НОВЫЙ ИМПОРТ

sys.path.insert(0, '.')
from kvs_data import (
    PAGE_SIZE, text_vaddr_base, align_up,
    ALWAYS_STUB_INSTRUCTIONS
)
from kvs_encoder import encode_instruction

# ========== ГЛОБАЛЬНОЕ СОСТОЯНИЕ ==========
entries = []
current_address = 0
current_segment = '.header'
last_segment = None

vaddr_text = text_vaddr_base
vaddr_data = None
vaddr_bnd = None

text_buffer = bytearray()
data_buffer = bytearray()
bnd_size = 0

labels = {}
label_sections = {}
symbols = {}

pending_labels = []

text_pos = 0
data_pos = 0

entry_point = "_start"
relocations = []


def reset_state():
    global entries, current_address, current_segment, last_segment
    global text_buffer, data_buffer, bnd_size, vaddr_data, vaddr_bnd
    global labels, label_sections, symbols, text_pos, data_pos, entry_point, relocations
    global pending_labels
    
    entries = []
    current_address = 0
    current_segment = '.header'
    last_segment = None
    text_buffer = bytearray()
    data_buffer = bytearray()
    bnd_size = 0
    vaddr_data = None
    vaddr_bnd = None
    labels = {}
    label_sections = {}
    symbols = {}
    text_pos = 0
    data_pos = 0
    entry_point = "_start"
    relocations = []
    pending_labels = []


def set_segment(segment: str):
    global current_segment
    current_segment = segment


def get_virtual_address():
    """Возвращает виртуальный адрес для текущей позиции"""
    if current_segment == '.text':
        return vaddr_text + (current_address - 0x1000)
    elif current_segment == '.data':
        if vaddr_data is None:
            return current_address
        return vaddr_data + (current_address - 0x2000)
    else:
        return current_address


def add_byte(value: int, source: str = "", target=None, labels_list=None):
    global current_address, last_segment, pending_labels
    
    effective_labels = ""
    if labels_list is not None and labels_list:
        effective_labels = ','.join(labels_list)
    elif pending_labels:
        effective_labels = ','.join(pending_labels)
    
    show_segment = current_segment if current_segment != last_segment else None
    if show_segment:
        last_segment = current_segment
    
    virt_addr = get_virtual_address()
    byte_val = value & 0xFF
    
    entries.append((
        show_segment if show_segment else "",
        current_address,
        f"0x{virt_addr:08x}",
        f"0x{byte_val:02x}",
        target if target else "",
        source,
        effective_labels,
        "",
        "",
        f"0x{byte_val:02x}"
    ))
    current_address += 1
    
    if pending_labels:
        pending_labels = []


def add_bytes(values, source: str = "", target=None):
    for i, v in enumerate(values):
        add_byte(v, source if i == 0 else "", target if i == 0 else None)


# ========== РЕФАКТОРИНГ: ИСПОЛЬЗУЕМ struct.pack ==========

def add_word16(value: int, source: str = "", target=None):
    """Добавляет 16-битное значение (little-endian)"""
    add_bytes(struct.pack('<H', value & 0xFFFF), source, target)


def add_word32(value: int, source: str = "", target=None):
    """Добавляет 32-битное значение (little-endian)"""
    add_bytes(struct.pack('<I', value & 0xFFFFFFFF), source, target)


def add_word64(value: int, source: str = "", target=None):
    """Добавляет 64-битное значение (little-endian)"""
    add_bytes(struct.pack('<Q', value & 0xFFFFFFFFFFFFFFFF), source, target)


def add_dwords(values: list, source: str = "", target=None):
    """Добавляет несколько 32-битных значений"""
    for val in values:
        add_word32(val, source, target)


def add_qwords(values: list, source: str = "", target=None):
    """Добавляет несколько 64-битных значений"""
    for val in values:
        add_word64(val, source, target)


def align_to(alignment: int):
    global current_address, pending_labels
    padding = (alignment - (current_address % alignment)) % alignment
    if padding > 0:
        pending_labels = []
        current_address += padding


def unescape_string(s):
    result = []
    i = 0
    while i < len(s):
        if s[i] == '\\' and i + 1 < len(s):
            if s[i + 1] == 'n':
                result.append('\n')
            elif s[i + 1] == 't':
                result.append('\t')
            elif s[i + 1] == 'r':
                result.append('\r')
            else:
                result.append(s[i + 1])
            i += 2
        else:
            result.append(s[i])
            i += 1
    return ''.join(result)


def generate_elf_header():
    """Генерирует заголовок ELF (64 байта)"""
    # ELF magic
    add_bytes([0x7F, 0x45, 0x4C, 0x46], "ELF magic")
    add_byte(2, "ELFCLASS64")
    add_byte(1, "ELFDATA2LSB")
    add_byte(1, "ELF version")
    add_byte(0, "OS ABI")
    add_byte(0, "ABI version")
    add_bytes([0] * 7, "Padding")
    
    # e_type, e_machine, e_version
    add_word16(2, "e_type = ET_EXEC")
    add_word16(62, "e_machine = EM_X86_64")
    add_word32(1, "e_version")
    
    # e_entry (stub - будет заполнен позже)
    add_word64(0, "e_entry (stub)")
    
    # e_phoff, e_shoff
    add_word64(64, "e_phoff")
    add_word64(0, "e_shoff = 0")
    
    # e_flags, e_ehsize, e_phentsize
    add_word32(0, "e_flags")
    add_word16(64, "e_ehsize")
    add_word16(56, "e_phentsize")
    
    # e_phnum, e_shentsize, e_shnum, e_shstrndx
    add_word16(2, "e_phnum = 2")
    add_word16(0, "e_shentsize = 0")
    add_word16(0, "e_shnum = 0")
    add_word16(0, "e_shstrndx")


def generate_program_headers():
    """Генерирует два программных заголовка (PT_LOAD)"""
    # === Первый заголовок: TEXT (RX) ===
    add_word32(1, "p_type = PT_LOAD")
    add_word32(5, "p_flags = RX")
    add_word64(0, "p_offset (text stub)")      # будет заполнено позже
    add_word64(vaddr_text, "p_vaddr (text)")
    add_word64(vaddr_text, "p_paddr (text)")
    add_word64(0, "p_filesz (text stub)")      # будет заполнено позже
    add_word64(0, "p_memsz (text stub)")       # будет заполнено позже
    add_word64(PAGE_SIZE, "p_align")
    
    # === Второй заголовок: DATA (RW) ===
    add_word32(1, "p_type = PT_LOAD")
    add_word32(6, "p_flags = RW")
    add_word64(0, "p_offset (data stub)")      # будет заполнено позже
    add_word64(0, "p_vaddr (data stub)")       # будет заполнено позже
    add_word64(0, "p_paddr (data stub)")       # будет заполнено позже
    add_word64(0, "p_filesz (data stub)")      # будет заполнено позже
    add_word64(0, "p_memsz (data stub)")       # будет заполнено позже
    add_word64(PAGE_SIZE, "p_align")


def read_ast(input_file):
    with open(input_file, 'r', encoding='utf-8') as f:
        return [line.strip() for line in f]


def parse_ast_line(line):
    if not line:
        return None, {}
    
    line_type = line.split(':')[0]
    
    if line_type == "INSTR":
        first = line.find(':')
        second = line.find(':', first + 1)
        third = line.find(':', second + 1)
        
        if first == -1 or second == -1 or third == -1:
            return "INSTR", {}
        
        mnemonic = line[first + 1:second]
        section = line[second + 1:third]
        operands_str = line[third + 1:]
        operands = operands_str.split(',') if operands_str else []
        
        return "INSTR", {
            'mnemonic': mnemonic,
            'section': section,
            'operands': operands
        }
    
    elif line_type == "DIRECTIVE":
        parts = line.split(':')
        directive = parts[1] if len(parts) > 1 else ""
        
        if directive in ('.текст', '.данные', '.бнд'):
            return "DIRECTIVE", {'directive': directive}
        elif directive == '.глобал':
            return "DIRECTIVE", {'directive': directive, 'label': parts[2] if len(parts) > 2 else ""}
        elif directive in ('.строка', '.строка_нуль'):
            return "DIRECTIVE", {
                'directive': directive,
                'section': parts[2] if len(parts) > 2 else "",
                'string': parts[3] if len(parts) > 3 else ""
            }
        elif directive == '.константа':
            return "DIRECTIVE", {
                'directive': directive,
                'name': parts[2] if len(parts) > 2 else "",
                'value': parts[3] if len(parts) > 3 else ""
            }
        elif directive == '.байт':
            return "DIRECTIVE", {
                'directive': directive,
                'section': parts[2] if len(parts) > 2 else "",
                'bytes': parts[3] if len(parts) > 3 else ""
            }
        elif directive in ('.резб', '.резс', '.рездс', '.резкс'):
            return "DIRECTIVE", {
                'directive': directive,
                'section': parts[2] if len(parts) > 2 else "",
                'count': parts[3] if len(parts) > 3 else "0"
            }
        else:
            return "DIRECTIVE", {'directive': directive}
    
    elif line_type == "LABEL":
        parts = line.split(':')
        return "LABEL", {
            'name': parts[1] if len(parts) > 1 else "",
            'section': parts[2] if len(parts) > 2 else ""
        }
    
    return line_type, {}


def get_stub_size(mnemonic, operands):
    if mnemonic in ("переход", "вызвать"):
        return 5
    elif mnemonic == "короткий_переход":
        return 2
    elif mnemonic.startswith("переход_если") and not mnemonic.startswith("короткий"):
        return 6
    elif mnemonic.startswith("короткий_переход_если"):
        return 2
    elif mnemonic == "цикл":
        return 2
    elif mnemonic == "переместить_имм" and len(operands) >= 2:
        reg = operands[0]
        if reg in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                   'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15'):
            return 10
        elif reg in ('еаикс', 'ебикс', 'есикс', 'едикс'):
            return 7
        else:
            return 2
    elif mnemonic in ("загрузить", "сохранить", "загрузить_адрес"):
        return 7
    elif mnemonic == "сравнить_с":
        return 7
    elif mnemonic in ("прибавить_непосредственно", "вычесть_непосредственно"):
        return 7
    elif mnemonic in ("переместить_с_нулями", "переместить_со_знаком"):
        return 7
    return 1


def extract_label_from_operands(operands):
    """Извлекает первую метку из операндов инструкции"""
    for op in operands:
        if not op:
            continue
        # Пропускаем регистры
        if op in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                  'еаикс', 'ебикс', 'есикс', 'едикс',
                  'аикс', 'бикс', 'сикс', 'дикс',
                  'ал', 'бл', 'кл', 'дл',
                  'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15'):
            continue
        # Пропускаем числа
        if op.isdigit() or (op.startswith('0x') and len(op) > 2):
            continue
        # Пропускаем косвенную адресацию через регистр
        if op.startswith('MEM:reg_indirect:'):
            continue
        # Извлекаем метку из [метка]
        if op.startswith('[') and op.endswith(']'):
            inner = op[1:-1]
            if inner not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай'):
                if not inner.isdigit() and not inner.startswith('0x'):
                    return inner
        # Обычная метка
        elif op not in symbols:
            return op
    return None


def has_unresolved_labels(operands, mnemonic=""):
    if mnemonic in ALWAYS_STUB_INSTRUCTIONS:
        for op in operands:
            if op and not op.isdigit() and not op.startswith('0x'):
                if op not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                              'еаикс', 'ебикс', 'есикс', 'едикс',
                              'аикс', 'бикс', 'сикс', 'дикс',
                              'ал', 'бл', 'кл', 'дл'):
                    return True
    
    for op in operands:
        if not op:
            continue
        if op in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                  'еаикс', 'ебикс', 'есикс', 'едикс',
                  'аикс', 'бикс', 'сикс', 'дикс',
                  'ал', 'бл', 'кл', 'дл',
                  'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15',
                  'р8д', 'р9д', 'р10д', 'р11д', 'р12д', 'р13д', 'р14д', 'р15д',
                  'р8в', 'р9в', 'р10в', 'р11в', 'р12в', 'р13в', 'р14в', 'р15в',
                  'р8б', 'р9б', 'р10б', 'р11б', 'р12б', 'р13б', 'р14б', 'р15б',
                  'спл', 'бпл', 'сил', 'дил'):
            continue
        if op.startswith('MEM:reg_indirect:'):
            continue
        if op.startswith('[') and op.endswith(']'):
            inner = op[1:-1]
            if inner in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай'):
                continue
            if inner.isdigit() or (inner.startswith('0x') and len(inner) > 2):
                continue
            if inner not in labels:
                return True
            continue
        if op.isdigit() or (op.startswith('0x') and len(op) > 2):
            continue
        if op in symbols:
            continue
        if op not in labels:
            return True
    
    return False


def get_unresolved_labels(operands):
    unresolved = []
    for op in operands:
        if not op:
            continue
        if op.startswith('[') and op.endswith(']'):
            inner = op[1:-1]
            if inner not in labels and not inner.isdigit() and not (inner.startswith('0x')):
                if inner not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай'):
                    if inner not in symbols:
                        unresolved.append(inner)
        elif op not in labels and not op.isdigit() and not (op.startswith('0x')):
            if op not in ('раикс', 'рбикс', 'рсикс', 'рдикс', 'рсипи', 'рбипи', 'рсиай', 'рдиай',
                          'еаикс', 'ебикс', 'есикс', 'едикс',
                          'аикс', 'бикс', 'сикс', 'дикс',
                          'ал', 'бл', 'кл', 'дл',
                          'р8', 'р9', 'р10', 'р11', 'р12', 'р13', 'р14', 'р15'):
                if op not in symbols:
                    unresolved.append(op)
    return unresolved


def process_ast_line(line):
    global text_pos, data_pos, vaddr_data, vaddr_bnd, bnd_size
    global text_buffer, data_buffer, entry_point, symbols, pending_labels
    
    line_type, fields = parse_ast_line(line)
    
    if line_type == "DIRECTIVE":
        directive = fields.get('directive', '')
        
        if directive == '.текст':
            set_segment('.text')
        
        elif directive == '.данные':
            set_segment('.data')
            align_to(PAGE_SIZE)
        
        elif directive == '.бнд':
            set_segment('.bss')
        
        elif directive == '.глобал':
            entry_point = fields.get('label', '_start')
        
        elif directive == '.константа':
            name = fields.get('name', '')
            value_str = fields.get('value', '')
            if value_str.startswith('0x') or value_str.startswith('0X'):
                value = int(value_str, 16)
            else:
                value = int(value_str)
            symbols[name] = value
            print(f"  константа: {name} = {value}")
        
        elif directive in ('.строка', '.строка_нуль'):
            s = fields.get('string', '')
            real_s = unescape_string(s)
            bstring = real_s.encode('utf-8')
            if directive == '.строка_нуль':
                bstring += b'\x00'
            
            source = f'{directive} "{s}"'
            
            for i, byte in enumerate(bstring):
                labels_list = pending_labels if i == 0 else None
                add_byte(byte, source if i == 0 else "", None, labels_list)
                data_buffer.append(byte)
                if labels_list:
                    pending_labels = []
            data_pos += len(bstring)
        
        elif directive == '.байт':
            bytes_str = fields.get('bytes', '')
            if bytes_str:
                byte_values = bytes_str.split(',')
                source = f'.байт {bytes_str}'
                bstring = bytearray()
                for byte_str in byte_values:
                    byte_str = byte_str.strip()
                    if byte_str.startswith('0x'):
                        val = int(byte_str, 16)
                    else:
                        val = int(byte_str)
                    bstring.append(val & 0xFF)
                
                for i, byte in enumerate(bstring):
                    labels_list = pending_labels if i == 0 else None
                    add_byte(byte, source if i == 0 else "", None, labels_list)
                    data_buffer.append(byte)
                    if labels_list:
                        pending_labels = []
                data_pos += len(bstring)
        
        elif directive in ('.резб', '.резс', '.рездс', '.резкс'):
            count = int(fields.get('count', '0'))
            multiplier = {'резб': 1, 'резс': 2, 'рездс': 4, 'резкс': 8}
            bnd_size += count * multiplier.get(directive, 1)
    
    elif line_type == "LABEL":
        label_name = fields.get('name', '')
        sec = fields.get('section', '')
        
        if sec == '.text':
            addr = vaddr_text + text_pos
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
        
        elif sec == '.data':
            if vaddr_data is None:
                vaddr_data = align_up(vaddr_text + text_pos, PAGE_SIZE)
            addr = vaddr_data + data_pos
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
        
        elif sec == '.бнд':
            if vaddr_bnd is None:
                vaddr_bnd = align_up(vaddr_data + data_pos, PAGE_SIZE)
            addr = vaddr_bnd + bnd_size
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
        
        else:
            addr = current_address
            labels[label_name] = addr
            label_sections[label_name] = sec
            if label_name not in pending_labels:
                pending_labels.append(label_name)
    
    elif line_type == "INSTR":
        mnemonic = fields.get('mnemonic', '')
        sec = fields.get('section', '')
        operands = fields.get('operands', [])
        
        source = f"{mnemonic} {', '.join(operands)}" if operands else mnemonic
        
        need_stub = has_unresolved_labels(operands, mnemonic)
        
        if need_stub:
            stub_size = get_stub_size(mnemonic, operands)
            unresolved = get_unresolved_labels(operands)
            
            if unresolved:
                reloc_text = f"ЗАГЛУШКА {', '.join(unresolved)}"
            else:
                label_from_op = extract_label_from_operands(operands)
                if label_from_op:
                    reloc_text = f"ЗАГЛУШКА {label_from_op}"
                else:
                    reloc_text = "ЗАГЛУШКА (неизвестная метка)"
            
            relocations.append({
                'address': current_address,
                'size': stub_size,
                'labels': unresolved if unresolved else [label_from_op] if label_from_op else [],
                'source': source,
                'mnemonic': mnemonic
            })
            
            for i in range(stub_size):
                labels_list = pending_labels if i == 0 else None
                add_byte(0xCC, source if i == 0 else "", reloc_text if i == 0 else None, labels_list)
                if labels_list:
                    pending_labels = []
            
            if sec == '.text':
                text_buffer.extend([0xCC] * stub_size)
                text_pos += stub_size
            else:
                data_buffer.extend([0xCC] * stub_size)
                data_pos += stub_size
        else:
            try:
                if sec == '.text':
                    current_pos = text_pos
                else:
                    current_pos = data_pos
                
                encoded = encode_instruction(
                    mnemonic, operands, labels, label_sections, symbols,
                    vaddr_text, vaddr_data if vaddr_data else 0,
                    current_pos, vaddr_bnd if vaddr_bnd else 0
                )
                
                for i, byte in enumerate(encoded):
                    labels_list = pending_labels if i == 0 else None
                    add_byte(byte, source if i == 0 else "", None, labels_list)
                    if labels_list:
                        pending_labels = []
                
                if sec == '.text':
                    text_buffer.extend(encoded)
                    text_pos += len(encoded)
                else:
                    data_buffer.extend(encoded)
                    data_pos += len(encoded)
                    
            except Exception as e:
                print(f"Ошибка кодирования {source}: {e}", file=sys.stderr)
                labels_to_attach = pending_labels.copy()
                add_byte(0xCC, source, f"ОШИБКА: {e}", labels_to_attach)
                pending_labels.clear()
                
                if sec == '.text':
                    text_buffer.append(0xCC)
                    text_pos += 1
                else:
                    data_buffer.append(0xCC)
                    data_pos += 1


def finalize_headers():
    global entries
    
    text_offset = 0x1000
    data_offset = 0x2000
    
    text_filesz = len(text_buffer)
    text_memsz = len(text_buffer)
    
    data_filesz = len(data_buffer)
    data_memsz = len(data_buffer) + bnd_size
    
    vaddr_data_final = align_up(vaddr_text + text_filesz, PAGE_SIZE)
    entry_point_addr = labels.get(entry_point, vaddr_text)
    
    i = 0
    while i < len(entries):
        segment, addr, virt_addr, byte_str, target, source, label, cmd_with_values, calc_target, calc_byte = entries[i]
        
        if 'e_entry (stub)' in source:
            # Вставляем 8 байт (uint64_t)
            new_bytes = struct.pack('<Q', entry_point_addr)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{entry_point_addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"e_entry = 0x{entry_point_addr:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_offset (text stub)' in source:
            new_bytes = struct.pack('<Q', text_offset)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_offset (text) = 0x{text_offset:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_filesz (text stub)' in source:
            new_bytes = struct.pack('<Q', text_filesz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_filesz (text) = {text_filesz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_memsz (text stub)' in source:
            new_bytes = struct.pack('<Q', text_memsz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_memsz (text) = {text_memsz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_offset (data stub)' in source:
            new_bytes = struct.pack('<Q', data_offset)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_offset (data) = 0x{data_offset:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_vaddr (data stub)' in source:
            new_bytes = struct.pack('<Q', vaddr_data_final)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{vaddr_data_final + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_vaddr (data) = 0x{vaddr_data_final:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_paddr (data stub)' in source:
            new_bytes = struct.pack('<Q', vaddr_data_final)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{vaddr_data_final + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_paddr (data) = 0x{vaddr_data_final:x}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_filesz (data stub)' in source:
            new_bytes = struct.pack('<Q', data_filesz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_filesz (data) = {data_filesz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        elif 'p_memsz (data stub)' in source:
            new_bytes = struct.pack('<Q', data_memsz)
            for j, nb in enumerate(new_bytes):
                virt = f"0x{addr + j:08x}"
                byte_hex = f"0x{nb:02x}"
                entries[i + j] = (segment, addr + j, virt, byte_hex, target, 
                                  f"p_memsz (data) = {data_memsz}", 
                                  label if j == 0 else "", 
                                  "", "", byte_hex)
            i += 8
            continue
        
        i += 1


def save_to_csv(filename: str):
    with open(filename, 'w', newline='', encoding='utf-8') as f:
        writer = csv.writer(f, delimiter=';')
        writer.writerow(['сегмент', 'адрес', 'виртуальный_адрес', 'байт', 'приводящая_метка', 
                         'уводящий_адрес', 'исходная_команда', 'команда_со_значениями',
                         'рассчитанный_уводящий_адрес', 'рассчитанный_байт'])
        
        for segment, addr, virt_addr, byte_str, target, source, label, cmd_with_values, calc_target, calc_byte in entries:
            writer.writerow([
                segment,
                f"0x{addr:08x}",
                virt_addr,
                byte_str,
                label,
                target,
                source,
                cmd_with_values,
                calc_target,
                calc_byte
            ])


def main():
    if len(sys.argv) != 3:
        print("Использование: python kvs_pass1.py <вход.аст> <выход.csv>")
        sys.exit(1)
    
    ast_file = sys.argv[1]
    csv_file = sys.argv[2]
    
    reset_state()
    
    set_segment('.header')
    generate_elf_header()
    generate_program_headers()
    align_to(PAGE_SIZE)
    
    ast_lines = read_ast(ast_file)
    for line in ast_lines:
        process_ast_line(line)
    
    finalize_headers()
    save_to_csv(csv_file)
    
    vaddr_data_final = align_up(vaddr_text + len(text_buffer), PAGE_SIZE)
    vaddr_bnd_final = align_up(vaddr_data_final + len(data_buffer), PAGE_SIZE)
    
    print(f"\n=== Первый проход ===")
    print(f"  .text: {len(text_buffer)} байт, vaddr=0x{vaddr_text:x}")
    print(f"  .data: {len(data_buffer)} байт, vaddr=0x{vaddr_data_final:x}")
    print(f"  .bnd:  {bnd_size} байт, vaddr=0x{vaddr_bnd_final:x}")
    print(f"  точка входа: {entry_point} = 0x{labels.get(entry_point, vaddr_text):x}")
    print(f"  меток: {len(labels)}")
    print(f"  констант: {len(symbols)}")
    print(f"  релокаций: {len(relocations)}")
    print(f"  записей: {len(entries)}")
    print(f"  CSV: {csv_file}")


if __name__ == "__main__":
    main()