Тестирование NeverD

Тесты NeverD отвечают на три разных вопроса: имеет ли представление ожидаемую форму, работает ли полный маршрут с бинарным fixture и сохраняет ли сгенерированный код поведение. Выберите минимальный набор, отвечающий на вопрос изменения, а перед рискованным pull request запустите более широкий агрегат.

Настройка тестовой сборки

Тесты отключены, если не включён BUILD_TESTING. Для полного набора обычно выбирается Release; Debug сохраняет assertions и пошаговое выполнение, но намеренно не оптимизирован и не отражает производительность декодирования.

cmake -S . -B build-release -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_TESTING=ON
cmake --build build-release --parallel 4

Полный набор fixture требует clang для кросс-компиляции и LLVM linker (ld.lld и lld-link) в PATH. CMake всегда создаёт множество перемещаемых fixture и слинкованные ELF/PE fixture при наличии соответствующего linker. Тест, пропущенный из-за невозможности собрать или слинковать fixture на хосте, означает неисполненное покрытие, а не успешную проверку цели.

Клонирование, профили сборки и готовый LLVM для macOS описаны в CONTRIBUTING.md.

Проверки восстановления интерпретатора

cmake --build build-release --target NeverDInterpreterSpecializationTests \
  NeverDDevirtualizationSourceTests --parallel 4
ctest --test-dir build-release -L '^NeverD(InterpreterSpecialization|DevirtualizationSource)Tests$' \
  --output-on-failure

cmake --build build-release --target NeverDLowIRUndefinedIndependenceTests \
  NeverDOriginalBinaryUndefinedIndependenceTests \
  NeverDX86UndefinedEffectsTests NeverDX86CarryArithmeticFlagTests \
  NeverDX86LogicIdentityTests NeverDX86NoIndexAddressTests --parallel 4
build-release/bin/NeverDLowIRUndefinedIndependenceTests
build-release/bin/NeverDOriginalBinaryUndefinedIndependenceTests \
  --gtest_filter='OriginalBinaryUndefinedIndependence.*'
build-release/bin/NeverDX86UndefinedEffectsTests
build-release/bin/NeverDX86CarryArithmeticFlagTests
build-release/bin/NeverDX86LogicIdentityTests
build-release/bin/NeverDX86NoIndexAddressTests

Тесты API проверяют значения по умолчанию v1/v2/v3, явные бюджеты, усечённые структуры, все поля reserved и будущие хвосты. Тесты CLI проверяют исчерпание и успешное восстановление для обеих ABI и бэкендов, отклоняют неверные десятичные пределы и требуют --devirtualize. При исчерпании нельзя публиковать исходник или неполный остаточный граф.

Тесты v4 фиксируют размеры и заполнение префиксов, отклоняют усечённые структуры и неизвестные флаги, сохраняют старые/будущие форматы и границы в C без отчёта. Независимые CLI-примеры требуют цепочек для корреляций и границ для беззнакового сравнения стека; оба C-бэкенда запускаются с O0/O2 и ловушками неопределённого поведения. Отключение обнаружения должно менять зависимый от него результат. Парсер проверяет ноль, целочисленные пределы, переполнение, неверные диапазоны и отсутствующие предпосылки. Python проверяет раскладку, флаги, сигнатуры и владение отчётами об отказе.

NeverDByteMemoryForwardingTests проверяет перекрывающиеся последние записи, оба порядка байтов, кратные восьми ширины до i128, определённые значения, согласованные снимки undef/poison и частичные перезаписи. Отрицательные случаи сохраняют чтения при неизвестных алиасах, преобразованиях адресных пространств, вызовах, упорядоченных доступах, изменениях времени жизни, отсутствующих байтах, динамических или неверных смещениях, ветвлениях и циклах. Также проверяются PHI с множеством входов, нулевые, точные и исчерпанные бюджеты и запрет снимков по умолчанию. Исходный и преобразованный LLVM выполняются при O0/O2 с независимым арифметическим эталоном; существующие наборы MBA, LLVMC и исходного кода интерпретаторов защищают совместимость.

Дополнительные регрессии сохраняют чистые битовые intrinsic в обоих режимах памяти и порядках байтов. Обычные вызовы, operand bundle, convergent, изменения времени жизни, эффекты памяти и traps остаются барьерами. Исходный и преобразованный код выполняется при O0/O2 с traps неопределённого поведения и независимым эталоном, проверяющим числовой адрес в результате и каждый байт буфера.

Регрессии побайтовой живости проверяют непересекающиеся чтения, частично наблюдаемые записи и совместное покрытие несколькими записями. Проверки адресов под условием охватывают AND/OR/XOR, 32/64 бита, оба порядка байтов, неверные корни, неполные маски, слияния с обходом проверки и все границы бюджета. Независимые оракулы O0/O2 проверяют оба исхода ветвления, все шестнадцать остатков адреса и каждый байт буфера.

Регрессии адресных отношений проверяют целочисленные и указательные PHI/select, оба порядка байтов и разрядности указателей, постоянные и меняющиеся обратные рёбра, undef/freeze, циклы без входного основания, соседние лимиты работы и вывода, а также отмену анализа при изменении только адреса. Циклы O0/O2 сравнивают результат и каждый байт буфера с независимым пошаговым эталоном, включая меняющийся адрес, который нельзя считать постоянным.

Числовые тесты проверяют полную и частичную передачу от одного писателя, undef/poison без новых снимков, оба порядка байтов, 32/64 бита, модульные отрицательные смещения, частичные перекрытия, алиасы корней и alloca, исключения, циклы, соседние границы бюджетов и сброс анализов при удалении только store. При O0/O2 исходный и изменённый IR сравниваются с независимым эталоном по возвращаемому значению и каждому байту буфера с алиасами.

NeverDMedMutableSourceTests и NeverDLLVMCValueTests выполняют при O0/O2 независимо написанные циклы, перестановки блоков, обратные рёбра к входу, арифметику стека, прежние чтения, слияния ветвей, частичные алиасы, логические значения и подсчёт битов, включая ноль. Отрицательные случаи отклоняют до генерации некорректные входы, усечённые цели, неоднозначные носители и исчерпанные бюджеты. CLI-пример сверх лимита SSA требует исполняемый LLVMC и явный отказ HighC. Повторные обновления и цепочки сохранённых выражений между блоками также проверяют размер и выполнение сгенерированного C.

Дополнительные регрессионные тесты ограничивают число частных чтений и записей до продвижения LLVM и размер C. При O0/O2 выполняются длинные смешанные арифметические цепочки, переставленные блоки SSA, перекрывающиеся записи памяти и возвраты нуля. Ключевые примеры проходят фактический конвейер оптимизации LLVM; также проверяется повторное использование генератора после отказа в создании модуля.

Регрессии составных условий при O0/O2 проверяют конъюнкции и дизъюнкции с равенством ненулевой константе, беззнаковыми сравнениями, знаковыми сравнениями в обоих порядках операндов, расширенными логическими значениями и всеми сочетаниями отрицания. Код C должен сохранять полную таблицу истинности и не разыменовывать отсутствующий операнд сравнения с нулём. Запись целочисленных адресов проверяет выровненные и невыровненные значения 32/64/128 бит. Байтовые массивы сохраняют явное выравнивание и точные обращения к началу и частям массива без скалярного присваивания массиву и алиасов через несовместимые типы.

NeverDLowIRRefinementTests проверяет реально восстановленные графы, конечные циклы разной структуры и нулевые итерации, динамические источники, условные выборы, перекрывающиеся входы, корреляцию копий и сохранений, свидетельства неизменяемого чтения с обеих сторон, системные флаги и сохранность возврата. Ошибочные кандидаты, лишние записи, неполные или бесконечные пути, устаревшие свидетельства, пересечения временной памяти и исчерпанные общие бюджеты должны отклонять сертификат. Проверки независимости по-прежнему отклоняют наблюдаемые произвольные значения.

В той же цели LowIRLoopRefinement.* и BinaryLowIRLoopRefinement.* проверяют произвольные 64-битные счётчики, вложенные лексикографические ранги, реальные машинные остаточные программы, входные префиксы, перекрывающиеся представления и связанные сохранения. Отрицательные тесты отвергают неверные тела, суженный входной домен, неубывающие ранги, беззнаковое переполнение, забытые прежние записи, пропущенные точки, некорректные шаблоны и исчерпание общих бюджетов. Успех конечной соседней ветви не разрешает неполный индуктивный сертификат.

LowIRLoopInference.* и BinaryLowIRLoopInference.* используют независимо написанные счётчики, сохранения в стеке, ранние возвраты, нативные вызовы и упакованные флаги. Проверяются расширение узкой арифметики и семантически равные флаги с разными выражениями. Некорректные графы, отсутствующие или поддельные источники, бесконечные циклы, модульное переполнение и исчерпание бюджетов не должны давать сертификат.

Регрессии нулевого префикса проверяют группировку, необычные ширины и все пары байтов, сохраняя неизвестные и ненулевые биты. Независимые циклы кадра проверяют раздельную запись младших значений и старших нулей при обоих порядках байтов, узкие ширины, ошибочные вычисления и заполнение, точные/недостаточные бюджеты вывода и отдельный бюджет запросов полного доказательства.

Регрессии с общим заголовком и блоком обратного перехода охватывают 32-битные счётчики с нулевым расширением и полные 64-битные, скалярные ранги с неединичным шагом, неверные результаты, пути без прогресса и с модульным переполнением, точные и исчерпанные бюджеты скалярного и кортежного поиска. LowIRLoopInference.SharedHeaderAndLatchNeedLexicographicRanks. Дополнительные регрессии увеличения и сброса требуют сходимости без разворачивания одного бита счётчика за раунд и отклоняют отсутствие прогресса и беззнаковое переполнение. Регрессии планирования охватывают аккумуляторы с неединичным шагом, единичные счётчики с возможным переполнением рядом с допустимым скалярным рангом другого шага и три счётчика, чей успешный кортеж находится за ранним окном. Точный бюджет рангов и бюджет на одну попытку меньше проверяют детерминированное продолжение без повторных предложений.

LowIRLoopPlanPairing.* в той же цели проверяет переименование регистров, разные арифметические тела, отдельные снимки префиксов, сохранение предикатов, общие входы памяти кадра, вложенные точки разреза и независимые бюджеты доказательства. Отсутствующие связи, неверные записи, неправильные привязки временных значений, неполные сопоставления и исчерпанные лимиты метаданных не должны приводить к сертификату.

LowIRLoopAlignment.* проверяет независимо написанные обычные и ротированные циклы со счётчиками в кадре: стандартные планы доказываются по отдельности, первое сопоставление отклоняется, а другая точка сечения кандидата доказывает отношение. Регрессии охватывают перестановки нескольких сечений, неверные результаты и записи в кадр, отсутствующие или устаревшие исходные записи, явные witness неопределённых значений, неубывающие и переполняющиеся счётчики, некорректные графы, накопление запросов после неудач, точный общий бюджет и исчерпание лимитов поиска. Отказ не должен содержать сертификат. Дополнительные случаи проверяют раздельные фазы сброса и продвижения, эквивалентный перенос условий выхода с перекрёстным сопоставлением семейств, кеш без повторного вывода и суммарное превышение метаданных. Следующий независимый цикл проверяет полное покрытие с явным пределом 16384 запросов вывода. Пустые и дублирующие семейства не используют символьные запросы; недостаточные сечения отклоняются. Проверяются точные общие бюджеты и бюджеты на попытку меньше, неверные результаты, отсутствие продвижения, исходные свидетельства и witness неопределённых значений. Регрессии фильтра проверяют нейтральные арифметические ромбы, локальное схождение и схождение только на границе, а также достижимый узел схождения, который можно обойти к выходу или границе цикла. Проверяются фильтрованный кандидат при дублирующем исходном семействе, повторное использование уже полученного фильтрованного плана перед поздней полной попыткой, точный, на единицу меньший и нулевой MaxCutSelectionWork, накопленный неудачный CutSelectionWork и отсутствие нового символьного вывода после исчерпания общей работы с графом. Полное покрытие циклов проверяется для обоих семейств ветвей; для ромба заданы явные пределы запросов вывода и доказательства.

Регрессии охватывают части фрейма и регистра, оба направления, младшие/средние/старшие позиции, необычные ширины, оба порядка байтов и трёхбайтовые слова фрейма. Проверяются позднее обнаружение, изменения сохранённых битов, отсутствие прогресса и переполнение без условия, недопустимые дополнительные входы, точные/недостаточные бюджеты и прежний поиск с одним сечением.

Регрессии начальной фазы охватывают два и три последовательных цикла с повторным использованием одного слова обратного счёта, сочетание с фазами вложенных циклов, точные и уменьшенные на одну попытку бюджеты рангов и запросов, циклы без прогресса и сбросы с возвратом к предыдущей фазе. Ошибочные константы фазы той же ширины, неверные результаты и записи во фрейм должны отвергаться полным проверяющим без сертификата; отсутствие исходных свидетельств по-прежнему не поддерживается.

InterpreterMachineStateModel.* в NeverDLowIRRefinementTests использует независимые примеры LowIR для проверки исходных входных флагов, статуса отдельно от гостевого RAX, всех 17 слов, частей регистров, упакованных флагов, сохранения динамического отказа, записей в гостевой кадр, обеих ветвей и вывода циклического шаблона с последующим новым доказательством. Ошибочные выходы, потеря статуса, изменение памяти, устаревшие записи инструкций, неверные входы и исчерпанные бюджеты должны приводить к отказу. Существующие тесты исходного кода также выполняют оба пути C при O0/O2; одни тесты модели не сертифицируют скомпилированный C.

NeverDLLVMInterpreterModelTests сравнивает независимый LLVM с полными эталонами LowIR: разрядности, параллельные PHI, switch, гостевая память, отдельный статус, условия poison, диапазоны встроенных функций, отвергаемые контракты и четыре бюджета. Проверяется полное доказательство обратного счёта произвольного слова и отклонение изменённого статуса. Независимый C после O1/O2 должен сохранять те же наблюдения. Тесты проверяют поддерживаемую модель; автоматический поиск инвариантов и корректность компилятора остаются отдельными обязательствами. Тесты переменных сдвигов охватывают все четыре разрядности, счётчики с ограничением маской или ветвлением, граничные и чрезмерные значения, флаги запрета переполнения и точности, строгий отказ при poison и C, скомпилированный с O1/O2.

NeverDLLVMScalarEquivalenceTests проверяет полные области циклов, ноль итераций, одновременный обмен PHI, switch, старшие входные биты, контрпримеры последнего разбиения, дополнительные обновления с poison, диапазоны результата, неподдерживаемые контракты и точные, уменьшенные на единицу и нулевые бюджеты. Независимые эталоны двойной разрядности и переполнения проверяют границы funnel shift и умножение с ограничениями для всех поддерживаемых разрядностей; независимые вложенные циклы C при O1/O2 проверяют профиль входа компилятора. Набор модели состояния также проверяет границы. SymExpr.ConstantWindowSharesActualWorkWithoutRelaxingQueryCeilings проверяет суммарный учёт и неизменность локальных пределов.

LLVMScalarDecision.* проверяет глубокие обязательства точных сдвигов и расширений, постоянные ветвления, обе обратные дуги цикла, сохранение старших битов, поздние неопределённые операции, незавершение, изменения уже проверенных функций и точные, недостаточные на единицу и локальные бюджеты. LLVMScalarDecisionCompiled.DeepOneAndTwoBackedgeOracles сравнивает независимо написанные рекуррентные вычисления с одной и двумя обратными дугами с беззнаковым C-оракулом при O0/O2 за 32 768 вызовов. Это проверки скалярной модели, а не нативного ABI или восстановления всего бинарного файла.

LLVMScalarDemand.* доказывает эквивалентность разных нелинейных циклов с фиксированным бюджетом, сохраняет все 16 разбиений и свободные старшие биты, отклоняет ошибки результата и определённости в последнем разбиении, проверяет точный/недостаточный бюджет и предел узлов. LLVMScalarDemandCompiled.* сравнивает оба тела с независимым беззнаковым арифметическим эталоном при O0/O2 за 262 144 вызова. Исходные операции и область входов не сокращаются.

SymKnownBitsTests проверяет факты на всех парах байтовых входов и граничных значениях произвольной точности: расширения, суммы без переполнения, разные корни и всюду определённые сдвиги. Проверяются точные и уменьшенные на единицу бюджеты, стоимость кеша, его ёмкость, отдельные контексты, глубина, число операндов и неподдерживаемые разрядности. SymExprExtensionTests проверяет старшие биты констант и полную величину сдвига. Регрессии эквивалентности сохраняют символические данные при доказательстве ограничений диапазона, отклоняют различия в последнем разбиении и выполненный poison, проверяя бюджет полного доказательства. SymMBAExtensionTests требует обоснования выводом при отключённой проверке на выборках, проверяет все пары байтов и сохраняет границы знака, узкого переноса, дополнения и исчерпания работы.

NeverDLLVMScalarLoopRecoveryTests проверяет префиксы, состояния предшественников, нулевые итерации, самозамкнутые циклы, аффинные состояния, равенство при модульном переполнении, poison от дополнительного обновления, старшие биты данных и неподдерживаемые контракты. Точный суммарный бюджет и бюджет на единицу меньше проверяют атомарный отказ. Независимые арифметические эталоны исполняют исходный и восстановленный LLVM при O0/O2 для всех байтовых управляющих входов. Это не доказательство восстановления нативного ABI или вывода C по умолчанию.

Регрессии проверяют PHI на 8/16/32/64 бита, перестановку сравнений и полярность ветвей, знаковое/нулевое расширение, разные начальные значения и наблюдения входов, несколько обратных рёбер, символические контрпримеры, отказ от усечения, исходные poison/незавершение и атомарный отказ при лимитах построения, доказательства, кандидатов и преобразований. Независимые беззнаковые эталоны сравнивают исходный и восстановленный LLVM при O0/O2 за 458 752 вызова с ловушками неопределённого поведения. Источник и родительский модуль неизменны.

Регрессии проверяют модульные условия на 8/16/32/64 бита, убывающий шаг, полярности, ноль итераций, общие выходы, ошибочные соседние границы, совпадающие только на нулевых данных, недостижимые границы, большие срезы, poison, отсутствующие листья и атомарные бюджеты. Сорок неиспользуемых аргументов не должны вытеснять полезное начальное значение. Независимые беззнаковые эталоны выполняют исходный и восстановленный LLVM при O0/O2 за 458 752 вызова с ловушками неопределённого поведения.

Та же цель проверяет recoverLLVMScalarSource: подготовку до поиска, очистку без изменения циклов, неиспользуемое полноразрядное состояние, обязательства мёртвого переполнения, exact-сдвига, деления и assume, неподдерживаемые эффекты, точный и уменьшенный на единицу суммарный бюджет и ограниченное продолжение. Независимые арифметические эталоны исполняют исходный и подготовленный LLVM при O0/O2 для всех байтовых управляющих значений и детерминированных полноразрядных состояний. Исходная функция и родительский модуль неизменны при успехе и отказе.

Тесты проверяют аннотированные модульные тождества, эквивалентные выражения разных предшественников, разные значения ветвей, отклонение исходных переполнений/exact-сдвигов/усечений/расширений и точные либо недостаточные бюджеты. Независимые беззнаковые эталоны сравнивают исходные и подготовленные тела при O0/O2 за 131 072 вызова с ловушками неопределённого поведения. Существующие семантические тесты сохраняют проверку отказов самостоятельного прохода.

Регрессии масок охватывают переставленные операнды, нулевые поля, сохранение старших входных битов, альтернативу после неудачи полного доказательства, все обратные рёбра, отказ при циклическом переходе/переполнении, пакеты более 32 элементов и атомарный отказ при точном либо на единицу меньшем бюджете. Независимые арифметические эталоны LLVM и C при O0/O2 проверяют сочетание с восстановлением разрядности. Проверки объекта с самим собой сохраняют полный управляющий домен, отказ для poison/undef и неподдерживаемых контрактов, незавершение, локальные пределы и точный учёт работы; изменение той же функции отменяет прежний результат. Это покрытие скалярного LLVM, а не сертификация нативного ABI.

Тесты включения масок перебирают все пары байтов, проверяют несмежные маски и ширины до 128 бит, сохраняют неизвестные/старшие биты и ограничивают рост узлов за пределами лимитов. Символьный цикл с двумя обратными рёбрами должен доказать маскированную XOR-рекуррентность относительно независимой замкнутой формы. Тесты зависимостей учитывают нормализованное хранение величин сдвига, сохраняя точные/уменьшенные бюджеты и консервативную обработку широких значений.

Регрессии разрядности проверяют ненулевые константы, неизменные сигнатуры, более широкие входы и intrinsic, наблюдаемые старшие биты, знаковый порядок, новые переполнения и точные/недостаточные бюджеты. Одинаковые скалярные кандидаты проверяются с тройками x86-64, AArch64, big-endian AArch64 и ARM32; это покрытие LLVM, а не сертификация нативного ABI. Независимые арифметические оракулы выполняют исходный/восстановленный LLVM и полученный C при O0/O2 с ловушками неопределённого поведения C.

Регрессии охватывают все внешние входы, несколько обратных рёбер, скрытые старшие данные, poison, параллельные обмены, разделение групп, более 32 переменных и атомарные бюджеты. Скалярные доказательства отличают завершённый неопределённый запрос от глобального исчерпания и доказывают безопасные сдвиги без перебора битов данных. Символьные тесты перебирают байтовые значения, маски и счётчики, сохраняя наблюдаемые биты, идентичность источников и большие счётчики. Представления разной разрядности используют полное числовое значение счётчика. Проверки не сертифицируют нативный ABI.

Дополнительные регрессии охватывают переполнение узкого последнего индекса, отдельные блоки body/latch, обе полярности условий, перестановку операндов равенства, переставленные и убывающие переменные с единичным шагом, различия старших битов на пустом пути, новый выполняемый poison и ошибочные границы. Точные и уменьшенные на единицу бюджеты построения и доказательства, а также исчерпание кандидатов сохраняют атомарный отказ. Исходный LLVM и полученный C выполняются при O0/O2 с независимыми арифметическими оракулами.

NeverDLLVMCScalarLoopRecoveryTests проверяет полный и выборочный вывод по умолчанию, продолжение после очистки возвратов, идентичность и атрибуты, вызывающие функции, старые/новые интринсики и конфликты, общие бюджеты, вызовы с эффектами, отсутствие гарантии определённости входов, метаданные, образы, внешние адреса блоков и выбор чужой функции. Независимые арифметические и ротационные эталоны исполняют C при O0/O2 с ловушками неопределённого поведения. Арифметика также сравнивается с отдельно скомпилированным исходным LLVM для всех байтовых управляющих входов, границ и детерминированных полноразрядных данных.

SymSimplifyPredicates.* также сравнивает правила отдельного этапа и полного прохода, сообщаемые затраты, точный бюджет и бюджет на единицу меньше, отключённый этап и функции с отметкой обфускации. Регрессии скалярного исходного кода охватывают арифметически закодированные условия завершения циклов для 8/32/64 бит, отказ при знаковом переполнении и общие лимиты построения между раундами и функциями. При отказе публикации исходный IR сохраняется; сгенерированный C выполняется при O0/O2 и сравнивается с независимо скомпилированным исходным LLVM и арифметическим оракулом.

SymKnownBits.* проверяет маски без потерь и прямой/обратный знаковый сдвиг полным перебором байтовых пар: отрицательные значения, другие источники, удалённые неизвестные биты, несовпадающие множители/счётчики и широкие чрезмерные сдвиги. До 128 бит проверяются точный бюджет и бюджет на единицу меньше, а также отсутствие роста DAG. Тесты скалярных решений добавляют положительные и отрицательные обновления на разных обратных рёбрах, отказ при устаревших фактах и переполнении, символические старшие биты и 16 384 вызова O0/O2 в сравнении с независимым беззнаковым оракулом.

SymKnownBits.* также проверяет все байтовые пары для порядка кратных и произведений разных разрядностей, отвергая переполнение, неверные коэффициенты или кратности факторов и перенос узкого переполнения в более широкое слово. До 128 бит сохраняются проверки точного бюджета, бюджета на единицу меньше и отсутствия роста DAG. Скалярные тесты доказывают повторное сложение и умножение без перебора битов данных, сохраняют все обязательства по переполнению циклов и выполняют 16 384 вызова O0/O2 в сравнении с независимым оракулом.

LLVMScalarAssume* проверяет полные области циклов, отказы в последнем разбиении, недостижимые и достигнутые ложные условия, накопление обязательств для всех байтовых входов, точный бюджет и бюджет на единицу меньше, изменения IR и неподдерживаемые контракты вызова. Четыре целевых triple проверяют общую модель; 8 192 вызова O0/O2 сравниваются с независимым беззнаковым оракулом. Набор тестов модели состояния отдельно проверяет то же обязательство и отказ при пакетах операндов.

LLVMScalarProjection.* проверяет вложенные поля, окна, сохранение неиспользуемых аргументов, несколько возвратов, обратные рёбра, невыбранные обязательства overflow/shift/assume, сбой последнего разбиения, незавершение, неизвестные контракты, изменённый вход и точный/уменьшенный на единицу бюджет. Четыре целевых триплета проверяют общую семантику. LLVMScalarProjectionCompiled.* сравнивает исходный агрегат через мост массива LLVM и проекции с независимой беззнаковой арифметикой при O0/O2. SymExpr.RightShift* перебирает пары байтов и проверяет знаковое расширение, переносы, сохранённые старшие биты, полные счётчики и ограничения поиска.

LLVMScalarInputs.* проверяет упорядоченные соответствия разной разрядности, интерфейсы без аргументов и имён, потребности мёртвой арифметики и assume, изменённые результаты, неизвестные контракты, отказ от упаковки и точные либо недостаточные суммарные бюджеты. Доказательства восстанавливают полную сигнатуру, не фиксируя пропущенные входы. LLVMScalarInputsCompiled.* сравнивает исходные и сокращённые циклы с независимым беззнаковым эталоном при O0/O2, меняя все пропущенные аргументы.

NeverDLLVMScalarStateProjectionTests проверяет перекрывающиеся/невыровненные окна, ячейки 8/16/32/64 бит, циклы, маски входа, изменения исходника, диапазоны статуса, сохранение poison, отказ для внешней памяти и точные/недостаточные бюджеты. Исходные функции памяти и агрегатные мосты LLVM выполняют 172 032 сравнения O0/O2 с независимыми эталонами; скалярные доказательства проверяются отдельно. SymKnownBits.* исчерпывает пары байтов и проверяет 128 бит, другие факторы, расширенные маски, переполнение сумм и бюджеты. LLVMCIntrinsicSemantics.AssumeEvaluatesItsConditionAndRefusesBundles проверяет однократное вычисление O0/O2 и отказ для bundle.

Регрессионные тесты метаданных сравнивают счётные циклы с независимой формулой во всех разбиениях управления при точном бюджете и бюджете на единицу меньше. Большой или нулевой счётчик peeling не скрывает ошибочные результаты, незавершение или poison. Некорректные метаданные создаются через API для отдельной проверки отказа импортёра, без смешения с разбором LLVM assembly; тесты состояния машины сохраняют эффекты состояния и ограничения входов.

Регрессии охватывают частичные и разделённые диапазоны, фиксированные алиасы, обе ветви, каждый возврат, чтение на первой итерации и запись перед чтением в цикле. Чтение до записи, пропущенные или гостевые записи, неизвестные алиасы, особые доступы, диапазоны вне объекта и исчерпанные бюджеты должны приводить к отказу. Независимый пример C с выходным словом состояния компилируется при O1/O2, сохраняет точные атрибуты LLVM и проходит новое составное доказательство от нативного кода до LLVM.

Тесты защищённого обратного счёта проверяют повтор после отклонения шаблона тела, полное доказательство в заголовке для произвольного слова, общие бюджеты точек и запросов и немедленное отклонение реального нарушения входного контракта.

NeverDInterpreterLLVMRefinementTests проверяет новые составные доказательства, точную привязку текста/функции, независимые бюджеты, все наблюдения и расширенную область исходного кода. Изменённые байты, остаточный код, результаты, флаги, статус, записи, poison и неверные/устаревшие планы должны исключать составное свидетельство. Счётчик произвольной разрядности требует обеих индуктивных предпосылок; независимые примеры C при O1/O2 проверяют фактический сериализованный LLVM. Регрессии отклоняют скрытые обратные рёбра ко входу и ограничивают корни без копирования вспомогательных данных происхождения.

cmake --build build-release --target NeverDLLVMCScalarLoopRecoveryTests --parallel 4
build-release/bin/NeverDLLVMCScalarLoopRecoveryTests
cmake --build build-release --target NeverDLLVMScalarLoopRecoveryTests --parallel 4
build-release/bin/NeverDLLVMScalarLoopRecoveryTests
cmake --build build-release --target NeverDLLVMScalarEquivalenceTests --parallel 4
build-release/bin/NeverDLLVMScalarEquivalenceTests
cmake --build build-release --target NeverDLLVMScalarResultProjectionTests --parallel 4
build-release/bin/NeverDLLVMScalarResultProjectionTests
cmake --build build-release --target NeverDLLVMScalarStateProjectionTests --parallel 4
build-release/bin/NeverDLLVMScalarStateProjectionTests
cmake --build build-release --target NeverDLLVMScalarInputProjectionTests --parallel 4
build-release/bin/NeverDLLVMScalarInputProjectionTests
cmake --build build-release --target NeverDLLVMInterpreterModelTests --parallel 4
build-release/bin/NeverDLLVMInterpreterModelTests
cmake --build build-release --target NeverDInterpreterLLVMRefinementTests --parallel 4
build-release/bin/NeverDInterpreterLLVMRefinementTests

Кэшированные условия выхода по равенству в циклах двух и трёх уровней проверяют связанные операнды, изменяемые границы, сбросы счётчика и испорченные копирования.

Регрессии кешированных сравнений проверяют равенство и неравенство, входные проверки и постоянную инициализацию, поля, обнаруженные после расширения, и биты 7/31/63 в кеше размером 1/4/8 байт. Изменение только соседнего бита при сохранении проверяемого также должно отвергаться сравнением всего состояния. Нулевой шаг, движущиеся границы, сбросы и исчерпанные бюджеты отвергаются.

Регрессии охватывают объединённые входы, первый свидетель без итераций, скрытые различия регистров/кадра, неканонические булевы предикаты, нативные условия trap, коррелированные записи в стек и неверные либо исчерпавшие бюджет планы. Независимые двух-/трёхуровневые счётчики с выходом по равенству и нативные байты проверяют беззнаковые границы, нулевые/максимальные входы, неединичные шаги и неверные исходные инструкции. Вывод и итоговое доказательство отвергают неполные результаты.

Независимые регрессии с альтернативными циклами проверяют оба направления ветвления, неверные тела, незавершающуюся соседнюю ветвь и исчерпание общих бюджетов поиска/доказательства. LowIRLoopInference.AlternativeLoopsReachBothPrefixesWithinSharedBudgets.

Регрессии охватывают два и три уровня вложенности, возрастающие и убывающие счётчики, выведенные фазы и разрезы в настоящих нативных телах. Недостижимые или непересекающиеся области префиксов, неверные тела, бесконечные или переполняющиеся переходы и исчерпанные общие бюджеты поиска/доказательства должны отклоняться. Свидетельство префикса не заменяет полного покрытия сегментов.

cmake --build build-release --target NeverDLowIRRefinementTests --parallel 4
build-release/bin/NeverDLowIRRefinementTests

NeverDLowIRUndefinedIndependenceTests проверяет независимость двух выполнений полного ациклического графа LowIR. Обычные входные значения общие; каждое новое архитектурно неопределённое значение сохраняет связи между копиями, перекрывающимися записями, сохранением в стек и повторной загрузкой. Условия управления проверяются до добавления предположений о пути. Сертификат требует метаданных эффектов Complete, точно привязанных к полным границам каждой инструкции и хешу её операций. Недостаток доказательств, достижимые циклы, вызовы, неизвестные алиасы и исчерпание бюджета приводят к отказу. Результат ограничен явно заданными наблюдениями и контрактом безошибочного доступа к кадру; это не полное доказательство эквивалентности нативного кода и C.

Следующее поведение использует строгий контракт аудита по умолчанию. NeverDOriginalBinaryUndefinedIndependenceTests использует независимые байты x64 с фиксированными отображениями для проверки физических CALL/RET, изменённых адресов возврата, полных конечных множеств косвенных целей и чтений неизменяемых данных. Та же цель проверяет полный сбор прямых ветвей, точную привязку байтов/эффектов/отображений/свидетельств чтения, сохранение входного RSP и ячейки возврата при внешнем возврате и разделение кадра с образом. Отсутствующие или перекрывающиеся инструкции, непроверенные ветви вне точных правил ловушек и проекции с явным профилем, незавершающиеся циклы или превышение бюджета, неполный перебор, несовместимые профили/контракты и исчерпанные бюджеты требуют отказа без сертификата и остаточного кода. Все выполнимые нативные пути должны завершиться. Эта необязательная проверка не сертифицирует инварианты циклов, исключения, выполнение с CET или эквивалентность нативного кода C; обычное восстановление остаётся отдельным. Эта цель также проверяет терминальные границы строго поднятых INT3/UD2 и привязку всех их байтов и дайджестов операций. Статус sidecar неопределённых выходов Missing должен оставаться Missing; в сертификат могут входить только ловушки с доказанной символическим исполнением недостижимостью, а любой выполнимый путь к ловушке должен возвращать ContractViolation без сертификата и остаточного кода. Продолжение после ловушек и возврат из исключений не моделируются, codeFollowsTrap не используется, поддержка статического API LowIR не меняется.

Регрессии физического возврата проверяют прямые и косвенные вызовы с пропуском неверных встроенных байтов, достижимые неверные продолжения, полное перечисление целей и точные либо недостаточные бюджеты. Отношение полного состояния отклоняет изменённые результаты. Независимый C после O1/O2 обязан сохранить всю запись кадра; одинаковый результат не скрывает изменение байта в слоте возврата.

Явные тесты нативных перекрытий проверяют реальные переходы x64 внутрь непосредственных операндов, результаты обеих допустимых ветвей и косвенные входы возврата внутри предыдущих инструкций. Синтетические поставщики проверяют вложенные диапазоны в обоих порядках сбора, конфликт байтов на невыполняемой прямой ветви, согласованность кода и чтений в обоих порядках и чтения кандидата. Точный и недостаточный бюджеты учитывают повторные байты через косвенные переходы. Изменённые результаты, статические или циклические API и противоречивые свидетельства должны исключать сертификат; изменение параметра или предела меняет хеши.

Тесты явных границ охватывают недостижимые RCL, XADD с памятью и LOCK и REP MOVS, символические противоречия путей, ветвления по произвольным значениям и точные отказы при достижении через вход, косвенный переход, CALL и RET. Проверяются независимые входы в достижимый суффикс, совпадения адресов кандидата и оригинала, повреждённые или частичные свидетельства, исчерпание ресурсов, отказ статических/циклических API и все три слоя дайджестов уточнения. Изменение недостижимой инструкции или включение опции без сохранённых границ меняет дайджесты сертификата. Тесты проверяют заявленную конечную область доказательства, а не семантику неаудированных инструкций.

Тесты охватывают все комбинации скалярных входных флагов, маски привилегий, TF/AC в обоих исполнениях, разные источники неопределённости, коррелированные копии, нативные вызовы, состояния соседних ветвей, обязательное наблюдение итогового состояния, некорректные доказательства и лимиты ресурсов. Все допустимые входные пути конечных циклов должны завершиться; безопасная ветвь не скрывает бесконечный или усечённый путь. RDSSPD/RDSSPQ проверяет 16 регистров общего назначения обеих ширин, сохранение старших битов и метаданных Missing, отказ при подделке проекции. Тесты состояния машины сравнивают оба пути C при O0/O2 с ловушками неопределённого поведения с независимым оракулом пользовательских флагов и проверяют сохранение признака нарушения профиля. Тесты INCSSPD/INCSSPQ охватывают обе ширины и все регистры общего назначения, сохранение недостижимых границ, достижимые ловушки после завершения соседней ветви, нулевые операнды и поддельные доказательства ловушек.

NeverDX86DecodeDetailTests проверяет три пути декодирования, обе ширины адреса x64, знаковые границы, обязательные префиксы, i386 disp16, moffs, усечённые входы и повторное использование без деталей. Привязываются только точные поля релокации; неверная ширина, позиция или значение не подходят. Нативные проверки независимости и уточнения сохраняют все записи кадра и отклоняют наблюдаемые произвольные флаги и изменённый кандидат сдвига.

NeverDX86UndefinedEffectsTests проверяет метаданные неопределённых битов, определённые и сохраняемые флаги, а также отказ при устаревшем сертификате. NeverDX86CarryArithmeticFlagTests сравнивает вспомогательный перенос ADC/SBB для регистровых форм и форм с памятью с арифметическим эталоном. NeverDX86LogicIdentityTests проверяет, что AND с одинаковыми операндами при записи в 32-битное назначение в 64-битном режиме по-прежнему обнуляет биты 63:32 соответствующего 64-битного регистра и сохраняет незаписанные биты при более узких записях.

X86RotateUndefinedEffects.* сверяет все исходные счётчики, ширины, перекрытия CL, псевдонимы старшего байта и назначения в памяти со скалярным арифметическим эталоном. X86BitTestUndefinedEffects.* проверяет регистровые/непосредственные индексы, перекрытие источника и назначения, расширенные регистры, определённые флаги и запись старших частей. Контроли метаданных отвергают изменённые операнды, кодировки и неподдерживаемые формы. Нативные доказательства различают коррелированные чтения и независимые произвольные флаги, проверяют точный/недостаточный бюджет генераторов и отвергают наблюдаемый неопределённый OF. Уточнение полного состояния принимает выбранное свидетельство и отвергает нулевое свидетельство или изменённый кандидат.

X86XaddAudit.* проверяет все 65,536 пар байтовых операндов, граничные значения флагов для больших разрядностей, перекрытия регистров/старших байтов, обе записи, ограничения байтовой ширины REX и сохранение полных регистров по беззнаковому арифметическому эталону. Нативные проверки требуют отсутствия новых произвольных битов при сохранении прежних зависимостей. Оба свидетеля принимают неизменённый XADD и отклоняют изменения суммы, обменённого источника или определённого флага. Алиас /6 проходит полную матрицу счётчиков сдвига; изменённые группы/декодированные ID отклоняются. Тесты памяти также перебирают все пары байтов и проверяют изменение размера адреса, расширения, адресацию относительно IP и i386 16 бит, знаковые смещения, соседние байты и устаревшие детали. Нативные проверки всего кадра сохраняют прежние произвольные зависимости и точные/недостаточные бюджеты; изменение адреса записи нарушает контракт слота возврата.

X86DoubleShiftUndefinedEffects.* проверяет каждый байтовый счётчик при 16/32/64 битах независимыми побитовыми переносами, включая перекрытия источника/назначения/CL и точные условия. Нативные проверки отбрасывают RAX для изоляции флагов, различают 16 и 17, сохраняют прежние зависимости и точные/недостаточные бюджеты. Полные отношения отклоняют изменения определённых частей и нулевого свидетеля; произвольное младшее слово не разрешает очищать определённые старшие биты. Некорректные формы не публикуют частичных свидетельств.

*Deferred* проверяет недостижимые цели и продолжения, отсутствующий/некорректный код, противоречивые символические условия, произвольное управление, свидетели и изменения полного состояния. Синтетические провайдеры не запрашивают мёртвые ветви и отклоняют достигнутые некорректные метаданные. Точные/недостаточные бюджеты инструкций, операций, посещений и запросов, достижимые ошибочные альтернативы и бесконечные циклы не сертифицируют префиксы. Политика меняет хеши; статические и цикловые API отклоняют параметр.

NeverDPEFixedImageTests использует независимо созданные PE-файлы для проверки релокированных инструкций, неизменяемых данных, записей импорта, повреждённых заголовков/таблиц, наложений и изменённой информации о происхождении. Доказательства от машинного кода к LowIR и точному LLVM принимают соответствующие кандидаты и отвергают изменённые результаты, статусы или исходные байты. Исчерпание бюджета подготовки сохраняет отдельную классификацию и допускает повтор с явно увеличенными лимитами; обычная загрузка также принимает 40000 корректных релокаций сверх стандартного бюджета анализа.

FrameOffsets.*, NativeStackSpecialization.* и OriginalBinaryUndefinedIndependence.* проверяют все остатки выравниваний 2/4/8/16/32, свободные старшие биты, сохранение через вызовы, циклы обратного отсчёта, повреждение через алиасы, неверную диспетчеризацию, ненужные большие маски, необходимые расширения разбиения и точные бюджеты либо бюджеты на единицу меньше. Отдельные нативные контроли проверяют условное выравнивание, внутреннюю беззнаковую очистку, неверную очистку и возвраты с префиксами. Эти тесты не устанавливают автоматическую доказательную полноту native-to-LLVM для разбитых циклов.

Машинные регрессии проверяют 64 выровненных чтения с бюджетом одного, бюджет на единицу меньше, изменённые адреса вне кадра и одинаковый адрес при разных предикатах после возврата одного пути. Тесты изменения состояния, ключей и ёмкости остаются обязательными.

Регрессии повторной достижимости сохраняют все 130 машинных инструкций при бюджете запросов для двух линейных инструкций. Бюджеты запросов/инструкций на единицу меньше, достижимые ловушки после изменения ветвей или входных областей, исчерпание вентилей решателя и изменения состояния кандидата отклоняются.

Регрессии проверяют 558 сочетаний ширины среза, выравнивания, остатка и смещения при бюджете вентилей, недостаточном для вычитания полных корней. Проверяются разные источники/смещения срезов, свободные разреженные маски, модульные переносы и переполнения, вложенные маски и исчерпание узлов/запросов. Нативные тесты проверяют записи через частично выровненные указатели и отклоняют отсутствие выравнивания, выход за кадр и изменённые записываемые значения в полном уточнении состояния.

Тесты охватывают все остатки для 1/2/4/16, два корня, свободные старшие биты, неверные области, противоречивые константы, границы, промежутки исключений, сохранение и точный/уменьшенный на один бюджет запросов. Индуктивные шаблоны сохраняют входной предикат. Новые нативные и LLVM-проверки отвергают разные области и изменённый статус; дайджесты связывают обе области. Независимые примеры не выводят выравнивание из ABI или запуска. Независимый C с входной проверкой компилируется без изменений при O1/O2 и доказывается против настоящих нативных инструкций для двух остатков; те же артефакты должны отвергаться при другом остатке.

Регрессии покрывают оба порядка байтов, высокие базы кадра, перезаписанные и перекрывающиеся поля, поздние рёбра, расширенные предшественники, нативные CALL/RET и точные либо меньшие на единицу бюджеты. Оба C-пути исполняют четыре случая памяти при O0/O2. Нативные проверки отдельно фиксируют два значения селектора и не доказывают неограниченные входы. Независимый LLVM-пример проверяет, включая PHI-копии и записи, что перенос ложной ветви перед общим слиянием не приводит к её исполнению после истинной.

Регрессии охватывают более мелкие разбиения, все разрешённые остатки, разные старшие биты, сбой последнего случая и точные бюджеты либо нехватку единицы. Оба C-бэкенда проверяются при O0/O2 с недоступными отклонёнными гостевыми адресами и неверными флагами: статус 2 обязан сохранить все байты состояния. Модель и C/Python проверяют также раскладку v5, владение и старые или будущие расширения. Нативные доказательства отвергают несвязанные области выравнивания.

StringTransfer.* и регрессии повторного копирования проверяют перекрытие, нулевой счётчик, изоляцию временных значений, пределы ёмкости и бюджета, инвалидирование указателей. MachineStringSourceTests.cpp сравнивает нативное исполнение и оба пути C при O0/O2 с независимым эталоном всех регистров, флагов и байтов стека для четырёх размеров и обоих направлений.

ControlDiscovery.* и NativeStackSpecialization.* проверяют условия на младшие биты корня, зависимости от старших битов и всего корня, неполные обходы, точно достаточные и недостаточные бюджеты обхода, а также сохранение свидетельств конечных неизменяемых адресов.

Тесты условий перед неразрешёнными целями проверяют недостижимую ошибочную фазу, неизвестную цель, достижимую при входе или после обратного ребра, точные пределы уточнения и соседние успешный и исчерпанный бюджеты обнаружения. При отказе не публикуются остаточный код, происхождение и свидетельства чтения. Необязательная работа после полного восстановления не задаёт нижнюю границу необходимого бюджета.

Регрессионные тесты востребованной проекции кадра охватывают автоматически найденные и существующие регистры, высокие корневые адреса и модульное переполнение, условия лишь на младший байт, конфликтующие или отсутствующие факты соседних рёбер, соседние бюджеты запросов и ответ решателя unknown. Узкий запрос не превращает частичное доказательство указателя в доказательство полной разрядности; отказ не публикует остаточный код или свидетельства.

Регрессии конечных подполей охватывают селекторы в обеих половинах, наблюдаемые произвольные данные, регистры и слоты кадра, оба порядка байтов, узкие поля, последующее расширение диапазона, непересекающиеся маски и отсутствие фактов. При отсутствующей достижимой цели, свободном селекторе, исчерпании общего бюджета или результате unknown решателя нельзя публиковать остаточный код и свидетельства. Также проверяются автоматическое обнаружение при запросе всего слова, неиспользуемые ручные подсказки, данные от корня и начальные постоянные окна.

Тесты публичных бюджетов проверяют значения по умолчанию и 32-битные максимумы, независимое исчерпание вычислений и обнаружения, обе ABI исходного кода и C-бэкенда, а также неверные значения CLI. Проверки размещения C/Python охватывают v7, унаследованную валидацию и игнорирование будущих хвостов в v1–v6. Отказ по бюджету не публикует код или свидетельства; счётчик вычислений не должен оборачиваться на максимуме.

Тесты необязательной границы цепочки сравнивают простые и вложенные циклы при одном бюджете операций, выполняют остаточные циклы, различают режимы декодирования и проверяют неизменность поведения при нулевом лимите цепочки. Контрпример корреляции должен успешно восстанавливаться по умолчанию и отказываться от публикации с опцией. Повторные нативные вызовы и слоты возврата, повторный анализ зависимостей и поздние предшественники проверяются в обоих режимах. Публичные тесты охватывают обе ABI и бэкенды, стандартные и неизвестные флаги, старые API, игнорирующие расширение, и булево поле отчёта.

NativeStackSpecialization.NarrowAddressDemandRetainsCompletePointer проверяет условные слияния указателей в регистрах и слотах кадра, оба порядка байтов, модульное переполнение и высокие адреса корня, восстановление стека и 120 байтов кадра. Сопутствующие отрицательные тесты отклоняют повреждённые указатели и проверяют точные и уменьшенные на единицу бюджеты запросов, операций, вычислений и уточнений, а также исчерпание лимитов обнаружения и контекстов.

Тесты наблюдателя охватывают ранний отказ, константы, пустые проекции и заключительный запрос UNSAT. Регрессионные тесты сохраняют чтение во время исполнения после контрпримера, повторно проверяют кэшированные адреса для другого размера чтения и отклоняют некорректные сертификаты без публикации частичных свидетельств.

Тесты аффинного управления охватывают условия на младшие биты при бюджете в восемь запросов, регистры и слоты кадра с обоими порядками байтов, модульное переполнение, наблюдение байтов кадра и восстановление стека. Противоречивое условие, не являющееся литеральной константой, должно отсекать неподдерживаемую ветвь; два корня с одинаковыми младшими 32 битами и различными старшими битами должны сохранять обе цели косвенного перехода.

FiniteQueryCache.* проверяет точный лимит хранения и лимит на единицу меньше, обновление порядка при попадании, вытеснение нескольких записей разных размеров, повторные вытеснения и запросы с переименованными переменными. Повторные записи, промахи, некорректные результаты и слишком большие кандидаты не меняют порядок. Возвращённые копии доказательств остаются действительными после вытеснения соответствующих записей кэша.

ControlStateRecovery.*Marginal* проверяет независимые множества целей и прикладных данных, произведение которых превышает общий предел, конкретные результаты остаточной программы, позднего предшественника с новой целью после расширения отношения, отсутствие достижимых целей и полное удаление множеств при переполнении или неполном переборе. Эти самостоятельно созданные примеры проверяют повторный анализ при изменении множества и отсутствие публикации частичного графа после ошибки. Вариант со слотом кадра проверяет аннулирование из-за алиасной записи после расширения отношения для обоих порядков байтов.

InterpreterTransferChain.* проверяет связанные значения, однозначные и динамические ветви, поздних предшественников, границы кадра, отказ при алиасах и бюджеты. Дополнительные нативные тесты CALL/RET проверяют повторные вхождения, байты адресов возврата и восстановление стека. Воспроизведение источников и проверки native-to-LLVM охватывают несовпадение контрактов, изменение подтверждений, неверные результаты и пропущенные записи в стек.

NeverDX86NoIndexAddressTests проверяет адресацию x86 SIB без индекса при 32- и 64-битной ширине адреса: игнорируемые биты масштаба, ширину назначения, загрузки/записи, полные метаданные неопределённых выходов, смещения сегментов и происхождение адресов. Псевдорегистры в роли базы или индекса неверной ширины отклоняются; реальные индексы R12, выбранные REX.X, сохраняются. Тесты EVEX для широковещательных загрузок и маскированных перемещений также проверяют эти формы, подавление неактивных обращений к памяти и противоречивые метаданные SIB.

Регрессии сдвигов охватывают все восьмибитные счётчики, сочетания флагов при нуле, оба режима x86, все ширины, перекрытия CL, AH/CH/DH/BH, расширенные регистры и память. Побайтовое символьное исполнение сравнивается с повторной однобитной арифметикой. Реляционные тесты проверяют копии и новые флаги, сохранения, итерации, счётчики из неопределённых значений, ветвления, неверные формы, хеши и бюджеты. Конечные чтения проверяют 1/2/4/8 байт, выбор по входу, единственный адрес на пути, полные свидетельства и пределы; зависимые, отсутствующие, изменяемые, не подкреплённые файлом, релокированные и неограниченные кандидаты отклоняются.

Тесты ядра проверяют разделение контекстов, слияние до неподвижной точки, динамические циклы, перекрывающиеся регистры, инвалидирование при алиасинге, конечные цели и отказ без частичной замены. Тесты исходного кода ассемблируют оригинальные регистровые, стековые и конечно-адресные машины x64, восстанавливают оба маршрута C, компилируют с O0/O2 и ловушками неопределённого поведения и сравнивают выполнение с независимыми эталонами беззнаковой арифметики и памяти. Fixture с конечными адресами проверяют выбираемые по входу записи и связанные поля указателя/ключа; нативные проверки охватывают SysV/Win64. Также проверяются публичный CLI, бюджеты и отчёты об отказах. Требуются кросс-компилятор Clang и LLD; выполнение исходного ELF требует хоста x64 Linux. Отсутствие инструментов или неподходящий хост означает пропуск покрытия, а не успех.

ControlStateRecovery.LongTransparentLoop* проверяет независимо написанный цикл из 20 фаз, динамические арифметические эталоны, отказ при неизвестном селекторе и исчерпание бюджетов. LongTransparentPhasesKeepExactBitDemands проверяет, что посторонние биты в байте селектора остаются наблюдаемыми данными времени выполнения и не становятся запросами управления. ProducerClosureChargesWorkBeforeAnotherRestart проверяет учёт общей работы обратного поиска и повторного вычисления до запуска нового графа, без публикации частичных результатов.

X86ShiftCarry.* проверяет перенос при арифметическом сдвиге узких целых вправо, маскирование счётчика, регистры назначения APX и подавление флагов сравнением с последовательными сдвигами на один бит. NarrowArithmeticShiftCarrySurvivesBothSourceBackends выполняет оба варианта C при O0/O2 с ловушками неопределённого поведения для всех значений байта и исходных счётчиков. NeverDLLVMCIntrinsicSemanticTests также выполняет знаковые и беззнаковые целочисленные min/max для i1/8/16/32/64/128 при O0/O2, проверяя присваиваемые и встроенные результаты, порядок вычисления операндов и однократное вычисление. Неподдерживаемые скалярные разрядности и некорректные операнды должны явно отклоняться.

Проверки управления и вызовов в структурированном C

HighControlFlowSemantics.* проверяет сохранение меток, на которые ссылаются другие переходы, при переносе выходов или хвостов циклов. Прямой вход в выходы в начале и конце цикла и замена break проверяются выполнением сгенерированного C при O0/O2 с независимыми ожидаемыми результатами.

HighCPointerAddresses.Required* / UnknownConditionsFailOnlyWhenRead проверяет сохранение неизвестных конечных позиций обязательных регистровых аргументов. Вычисление неизвестного обязательного аргумента или условия должно явно вызывать trap; пропущенные, пустые и вложенные операнды нельзя молча заменять нулём. Известные значения и дополнительные операнды, отсутствие чтения которых доказано, остаются исполняемыми. Trap обозначает диагностическую границу, а не доказательство эквивалентности восстановленного поведения.

Проверки выполнения CPU

NeverDIntegerABITests собирает оригинальные Clang-fixture для Windows x64, Linux x64 и Linux ARM64. Реальные функции с десятью аргументами проверяют регистры, стек и кадры вызовов. В матрице Unicorn/KVM/WHP недоступные сочетания хост/ISA явно пропускаются; пропуск не является успехом. NeverDExecutionBudgetTests проверяет общие бюджеты продолжений, резервирования и абсолютный deadline без временных задержек.

NeverDCPUEmulationTests охватывает инструкции ARM64, управление, загрузки, контексты, алиасы, инвалидацию кэша и ограниченные циклы; software-профиль также исполняет FP/SIMD и TLS. NeverDUserExecutionTests проверяет права CPL3/EL0, алиасы, ошибки защиты, контексты и смену пространства. NeverDServiceRequestTests подтверждает перехват SYSCALL/SVC до транспорта, сохранение состояния и однократное потребление запроса. Это протокол передачи управления, не полная модель служб ОС. NeverDExecutionConfigurationTests проверяет общий resolver, отделение поддержки сборки от live probe и fail-closed отклонение неподдерживаемых настроек. Публичные тесты SDK/CLI не требуют модели Windows. NeverDThreadPointerTests проверяет FS-base, TPIDR_EL0, восстановление контекста и права. NeverDKvmCancellationTests использует не завершающегося x64-гостя для проверки прерывания активного KVM-входа, возобновления и неизменности сигналов вызывающего процесса; без KVM тест явно пропускается.

cmake --build build-cpu --target NeverDKvmRunTests NeverDKvmCancellationTests --parallel 4
ctest --test-dir build-cpu -L '^NeverDKvm(Run|Cancellation)Tests$' --output-on-failure

cmake --build build-cpu --target NeverDIntegerABITests NeverDExecutionBudgetTests NeverDCPUEmulationTests NeverDUserExecutionTests NeverDServiceRequestTests NeverDExecutionConfigurationTests --parallel 4
ctest --test-dir build-cpu -L '^NeverD(IntegerABI|ExecutionBudget|CPUEmulation|UserExecution|ServiceRequest|ExecutionConfiguration)Tests$' --output-on-failure

Отсутствие ARM64-оборудования или гипервизора означает пропуск нативного покрытия, а не успешную проверку. Unicorn и кросс-компиляция не подтверждают нативное KVM/WHP.

NeverDParallelExecutionTests проверяет перекрывающиеся вызовы, отмену ожидающей записи, независимые CPU, конкуренцию через алиасы и частный транспорт. NeverDRunControlTests проверяет две одновременные независимые аренды WHP и сериализацию общего кэша. NeverDMMIOAtomicTests сравнивает устройство/RAM для исходных x64 atomic/update и всех ARM64 LSE, обе широкие записи, устаревшие превью, ошибки и гонки commit/stop. KernelMMIOFailure покрывает алиасы, одинаковые записи, повторный commit, питание, unmap и уничтожение владельца. Недоступные платформы явно пропускаются. Барьер обёртки доказывает одновременные вызовы, а не одновременный retirement оборудования. ARM64 KVM/WHP требует соответствующий хост.

cmake --build build-cpu --target NeverDParallelExecutionTests NeverDMMIOAtomicTests NeverDRunControlTests --parallel 4
ctest --test-dir build-cpu/unittests/emulation -L '^NeverD(ParallelExecution|MMIOAtomic|RunControl)Tests$' --output-on-failure

Тесты профиля Linux-процессов

Независимые тесты процессов собирают реальные ELF-fixture x64/AArch64. NeverDLinuxProcessTests проверяет запуск, политику program headers, продолжение служб, двоичный вывод, гостевые ошибки и ресурсные остановки. NeverDProcessPublicTests проверяет C API/CLI без изменения образа анализа. NeverDExecutionSessionTests проверяет два CPU с общей памятью/бюджетом и однократное потребление запросов/ошибок. NeverDX64MemoryUpdateTests проверяет арифметику памяти, SETcc, BT, XMM/MXCSR, наблюдатели записи, границы REP и подготовленные чтения устройств. DriverBackendParityTests.cpp запускает исходные и перемещённые WDK-fixture и сравнивает полный наблюдаемый отчёт с Unicorn; отсутствующие образы/backend явно пропускаются.

Проверенный x64 также допускает маскированные legacy-формы SS, SD, PS, PD инструкций ADD, SUB, MUL, DIV, SQRT, MIN, MAX. X64SSEInstructions.def централизует ширины, выравнивание и допуск. MaskedSSEArithmeticMatchesIndependentHostExecution сравнивает регистры/RAM с независимым эталоном CPU хоста: четыре режима округления, FTZ, знаковые нули, субнормальные числа и NaN. SSEMemoryObserverStopsBeforeResultAndStatusChanges проверяет остановку до эффектов. Немаскированные исключения, x87 и AVX остаются исключёнными.

X64PackedIntegerTests.cpp использует оригинальные кодировки и 180 фиксированных результатов из X64PackedIntegerCases.def, независимо сверяемых с intrinsic-функциями нативного компилятора x64. Регистровые случаи и RAM-псевдонимы в конце страницы сохраняют остальные XMM, целочисленные контрольные значения, FLAGS, MXCSR и исходные байты. Остановки/ошибки наблюдателя и исправимые сбои чтения сохраняют состояние; после исправления выполняется повтор. Невыровненные адреса вызывают #GP(0); MMX, LOCK и MMIO по-прежнему отклоняются до обратных вызовов. Нативная CI требует оба уровня привилегий WHP.

X64PackedShiftTests.cpp и собственные примеры X64PackedShiftCases.def сравнивают десять сдвигов с независимыми скалярными вычислениями и нативными SSE2 intrinsics для 16 непосредственных и 21 переменного счётчика. Проверяются совпадение счётчика и назначения, игнорирование старших битов, выравнивание, наблюдатели, восстановимые сбои и отказ для устройств. X64VectorTestSupport.h разделяет проверки регистров и RAM с тестами упакованной арифметики. Нативная CI требует оба режима привилегий WHP.

X64VectorMaskTests.cpp сравнивает независимые машинные кодировки со скалярным извлечением битов и нативными SSE intrinsics: каждый исходный бит и все сочетания 16 GPR × 16 XMM при обоих значениях REX.W. Снимки всех публичных регистров, RAM и наблюдатели проверяют нулевое расширение и сохранение состояния. Остановка, ошибка callback и неподдерживаемая форма не публикуют побочные эффекты. Нативная проверка KVM/WHP требует оба уровня привилегий.

X64ShuffleTests.cpp использует независимые кодировки из X64ShuffleCases.def и сравнивает скалярный выбор элементов с нативными intrinsic. Проверяются все 256 управляющих значений с регистрами, совпадающим источником и алиасом в конце страницы, все пары XMM, полное публичное состояние CPU и RAM, остановки и исключения наблюдателей, права, ошибки выравнивания и повторное выполнение. MMX, VEX/EVEX, LOCK и операнды устройств должны отклоняться без эффектов. Нативная приёмка KVM/WHP требует эти случаи на обоих уровнях привилегий; недоступные пары хост/ISA явно пропускаются. Случаи UNPCKLPS, UNPCKHPS, UNPCKLPD и UNPCKHPD используют ту же матрицу состояний и ошибок и независимые скалярные и нативные проверки. Также проверяется каждый регистр результата XMM с источником в памяти.

X64PartialMoveTests.cpp и X64PartialMoveCases.def сравнивают независимые скалярные/нативные эталоны загрузки и записи, все 16 регистров XMM и исходные биты NaN/субнормальных чисел. Полное состояние CPU и две страницы RAM проверяются при невыровненных обращениях, алиасах, межстраничных ошибках, восстановлении прав, остановках/сбоях наблюдателей и повторе. На конце страницы достаточно восьми байт; запись не требует права чтения. Отдельно проверяются регистровые алиасы, запрещённые формы и callbacks устройств; нативные случаи KVM/WHP обязательны на обоих уровнях привилегий.

X64IntegerFloatTests.cpp использует независимые кодировки X64IntegerFloatCases.def, эталон APFloat и нативные инструкции с сохранением/восстановлением FP. Проверяются обе ширины целого, четыре округления, накопленный статус точности, FTZ, каждая пара GPR/XMM и полное состояние CPU/RAM. Невыровненные, межстраничные и конечные источники, восстановление прав, остановки/сбои наблюдателей и повторы сохраняют точные диапазоны доступа. Нативные случаи KVM/WHP обязательны на обоих уровнях привилегий.

X64FloatIntegerTests.cpp проверяет округление и усечение с независимыми кодировками X64FloatIntegerCases.def, APFloat и нативными инструкциями для регистров/памяти. Для обеих ширин целого покрыты знаковые границы, половинные значения, NaN, бесконечности, субнормальные числа, все округления, накопленные статусы и FTZ. Проверяются все пары GPR/XMM, полное состояние CPU/RAM, точное чтение у конца страницы, восстанавливаемые межстраничные ошибки и отмена/повтор наблюдателей. Нативные результаты KVM/WHP обязательны на обоих уровнях привилегий.

X64SSEComparisonTests.cpp использует независимые кодировки X64SSEComparisonCases.def, порядок APFloat и нативные инструкции с сохранением/восстановлением FLAGS и FP хоста. Все пары из 21 входного значения покрывают приоритет NaN/денормальных чисел, нули, бесконечности и соседние значения. Проверяются все пары XMM и совпадающие регистры, накопленный MXCSR, независимость от округления, сохранение DF, полное состояние CPU/RAM, точное чтение у конца/границы страницы и отмена/повтор наблюдателей. Нативные результаты KVM/WHP обязательны на обоих уровнях привилегий.

X64SSEPredicateTests.cpp использует независимые предикаты из X64SSEPredicateCases.def, общие исходные значения из X64SSEComparisonCases.def, порядок APFloat и оригинальные нативные инструкции. Покрыты все пары, приоритет исключений смешанных полос, старшие скалярные полосы, псевдонимы XMM, полное состояние CPU/RAM, чтение у конца/через границу страницы, приоритет выравнивания и повторы после наблюдателя/ошибки. Прямые проверки Capstone охватывают все управляющие байты, оба синтаксиса и API, режимы 32/64 бит. Нативные KVM/WHP обязательны на обоих уровнях привилегий; резервные значения, VEX/EVEX и операнды устройств исключены. Матрицы значений разделены по инструкции и предикату, матрицы округления и управления — по инструкции. NativeCPUTests.def сохраняет все исходные комбинации обязательными; сроки гостя и 15-секундный предел CTest не меняются. Проверки при компиляции требуют каждую пару инструкции и предиката ровно один раз.

X64SSEPrecisionTests.cpp сочетает независимые кодировки из X64SSEPrecisionCases.def, округление APFloat и оригинальные нативные инструкции. Диапазон проверяется с неограниченной экспонентой, включая направленное переполнение к конечному значению и малые результаты, округляемые до нормальных. Покрыты оба знака, данные NaN, все округления/FTZ/накопленные флаги, объединение полос, псевдонимы XMM, полное CPU/RAM, точные ширины, приоритет выравнивания, ошибки страниц и отмена/повтор наблюдателей. KVM/WHP обязательны на обоих уровнях привилегий.

X64PackedFloatTests.cpp использует независимые кодировки X64PackedFloatCases.def, знаковые эталоны APFloat и исходные нативные инструкции. Проверяются все пары входов, целочисленные границы, середины округления, режимы, накопленный статус и FTZ. Псевдонимы, все пары XMM, полное CPU/RAM, каждый разрыв m64 по страницам, концы страниц, приоритет выравнивания и повторы после наблюдений/ошибок покрывают оба уровня привилегий. Все случаи KVM/WHP обязательны.

X64PackedFloatIntegerTests.cpp сочетает независимые кодировки X64PackedFloatIntegerCases.def, входы X64FloatIntegerCases.def, APFloat/APSInt и исходные нативные инструкции. Все пары из 43 входов покрывают границы signed32, соседей середин округления, NaN, бесконечности и субнормальные значения. Отдельные матрицы независимо меняют точные, неточные, недопустимые и субнормальные полосы. Проверены все округления/FTZ/накопленные флаги, псевдонимы XMM, полное CPU/RAM, выровненные концы страниц, приоритет и повтор после наблюдений/ошибок. KVM/WHP обязательны на обоих уровнях привилегий.

DAZBackends дополняет матрицы сравнений, предикатов, скалярных и упакованных преобразований целых чисел, чисел с плавающей точкой и точности проверками с включённым DAZ. X64DAZTestSupport.h независимо нормализует входы через APFloat и проверяет MXCSR_MASK хоста перед выполнением исходных инструкций для эталона. Тесты сравнивают знаковые нули, субнормальные числа, NaN, смешанные элементы, все режимы округления, FTZ и накопленные флаги состояния, проверяя сохранность исходных байтов, остальных регистров, FLAGS и всей RAM. Для регистровых операндов, алиасов и границ страниц сохраняются проверки наблюдений доступа. KVM/WHP требуют все случаи DAZ на обоих уровнях привилегий и 17 эталонных случаев с исходными инструкциями хоста; в переносимых запусках неподдерживаемые хосты явно пропускаются. Существующие случаи без DAZ и ограничения времени сохранены.

X64AlignmentTests.cpp проверяет, что невыровненные операнды разрешённых инструкций aligned SSE сообщают восстанавливаемый или терминальный #GP(0) до наблюдателей данных, проверки прав и вызовов устройства. Полный публичный контекст регистров x64, PC и RAM сохраняется. Усечение по ширине адреса предшествует добавлению FS/GS; исправление адреса позволяет повторить исходную инструкцию. Прямые машинные тесты KVM/WHP независимо проверяют аппаратную границу. Windows ring3 доставляет классифицированные ошибки operand_alignment; другие причины #GP пока не поддерживаются.

X64SIMDExceptionTests.cpp обходит допуск checked и проверяет нативную передачу #XM в KVM/WHP на обоих уровнях привилегий. Восемь оригинальных случаев в X64SIMDExceptionCases.def охватывают шесть типов исключений, включая точные малые результаты и переполнение с точным результатом при неограниченном показателе. Регистровые формы и формы RAM сохраняют при сбое всё состояние GPR, XMM, x87, FLAGS, FS/GS и гостевой памяти, кроме заданных флагов MXCSR. Маскирование позволяет повторить исходную инструкцию; исправление операндов с сохранением накопленных флагов проверяет, что старые флаги не вызывают исключение заново. Публичные контракты checked и драйверов тоже исполняют исходные случаи ошибок и повторов. WindowsSIMDExecutionTests.cpp исполняет реальную нативную ошибку, гостевые инструкции VEH/VCH и продолжение с пропуском, маскированием или исправлением операндов. Активное состояние управления и сохранённый контекст проверяются отдельно. Отрицательные проверки запуска отклоняют отсутствие ошибки, неверный вектор и изменённый результат без публикации возможностей.

check_windows_simd.py собирает независимую оригинальную программу Windows x64 из WindowsSIMDCases.def и скалярных случаев. 6 144 наблюдения охватывают операнды регистр/RAM, все маски исключений, сброшенные или полностью установленные накопленные флаги и три продолжения: пропуск, маскирование с повтором или исправление операндов с повтором без изменения масок. Ассемблерные точки входа записывают текущие состояния MXCSR и x87 обработчиков VEH/VCH отдельно от сохранённого CONTEXT. Проверяются точный PC ошибки, сохранность состояния, исправленный контекст и результат до восстановления хоста. CI сохраняет исходные записи и хеши кода. --build-only подтверждает только компиляцию. Наблюдения не включают немаскированный SIMD checked и не подтверждают нативное выполнение ARM64.

WindowsSIMDStatusCases.def фиксирует все 63 непустые комбинации активных состояний, наблюдавшиеся в нативной Windows. WindowsSIMDMappingTests.cpp проверяет точные коды и параметры, отклоняет несогласованные сбои и недопустимые управляющие значения и внедряет границу сбоя для проверки записей, обоих управляющих полей CONTEXT и продолжения с масками. Оригинальная программа Windows CI независимо проверяет фиксированные результаты. Внедрённый тест не доказывает доставку исключений Unicorn и не включает немаскированный SIMD в режиме checked.

cmake --build build-cpu --target NeverDLinuxProcessTests NeverDExecutionSessionTests NeverDX64MemoryUpdateTests NeverDThreadPointerTests --parallel 4
ctest --test-dir build-cpu -L '^NeverD(LinuxProcess|ExecutionSession|X64MemoryUpdate|ThreadPointer)Tests$' --output-on-failure

Недоступные бэкенды явно пропускаются. Кросс-компиляция и Unicorn ARM64 не доказывают нативное KVM/WHP.

Проверки эмуляции драйверов

Включите NEVERD_ENABLE_DRIVER_EMULATION=ON вместе с BUILD_TESTING=ON, чтобы собрать специализированный набор тестов выполнения и проверки общего C API/CLI:

cmake --build build-release --target \
  NeverDDriverEmulationTests NeverDDriverEmulationPublicTests --parallel 4
ctest --test-dir build-release -L '^NeverDDriverEmulation' --output-on-failure

Fixture проверяют гостевую инициализацию, успешные и ошибочные возвраты, неподдерживаемое поведение, ошибки памяти, строгий разбор сценариев, ограниченное выполнение, а также синхронный buffered/direct ввод-вывод, READ/WRITE, независимое время жизни файлов, права MDL, динамическое разрешение экспортов, гостевые переменные аргументы и структурированные ошибки CPU через create, передачи, cleanup, close и unload. Для проверки JSON и кодов завершения процесса используйте CLI emulate-driver. Производственные сборки могут включать эту функцию с BUILD_TESTING=OFF; libneverd не должна требовать настройки Unicorn, предназначенной только для тестов.

Дополнительные тесты проверяют MDL драйвера для невыгружаемого пула, независимое время жизни дескриптора и буфера, структуры запросов реестра и короткие буферы, права дескрипторов, удаление и утечки, а также все 64 бита information_hex для IOCTL без вывода. Внешняя проверка также охватывает синхронное прямое чтение/запись и запросы статистики Zero.

Тесты проверяют полные контексты CPU (регистры, флаги, SIMD, FPU, CR8), общую память и отказ от чужих контекстов или контекстов после сбоя. Скомпилированные фикстуры driver_dispatcher.c исполняют реальные DPC и рабочие вызовы, сроки таймеров, объекты уведомления/синхронизации, не-alertable ожидания KernelMode с причиной Executive, таймаут/задержку, несколько заблокированных стеков, сохранение пробуждения после set/reset, аргументы и ошибки IRQL/времени жизни. Сохраняются проверки pending/завершения, очередей, зависаний и общих бюджетов. Это доказательство описанного подмножества, не полной асинхронности Windows.

driver_context_limits.c: Пределы IRQL заданы в KernelAPIIRQL.def; зависимые от аргументов правила проверяет соответствующая модель. DPC не может вызывать API реестра, выделять, освобождать или читать/писать страничный пул. Unicode-преобразования DbgPrint требуют PASSIVE_LEVEL, поддерживаемые ANSI-вывод и операции с нестраничной памятью доступны на DISPATCH_LEVEL. Стеки ограничены: вышедший за границы указатель не может попасть в стек другого заблокированного рабочего потока. Активные таймеры в расширении устройства запрещают преждевременное освобождение устройства. Общие изменения IRQL не предоставляются.

KernelDeviceStackTests.cpp проверяет независимые графы владения/присоединения, выбор вершины, атомарность ошибок, ёмкость, непрозрачные поля, счётчик дескрипторов, удержание работ/запросов после отсоединения/удаления и различие идентичности файла и диспетчеризации. Оригинальный driver_wdm_stack.c использует настоящие заголовки WDK и inline Copy/Skip/SetCompletion; необязательные пути NEVERD_WDM_STACK_FIXTURE/NEVERD_WDM_STACK_CFG_FIXTURE задают обычные образы/активный CFG. DriverWDMStackTests.cpp покрывает перемещение базы, нижний статус, порядок/флаги завершения, позднюю передачу pending, worker/DPC, ожидания, STATUS_MORE_PROCESSING_REQUIRED, удержание прямого MDL, вложенное завершение и некорректные курсоры/управление. DriverScenarioPublicTests.cpp проверяет передачу C API/CLI и удержанное/вложенное завершение C API, включая настроенные CFG-образы. Отсутствующие артефакты явно пропускаются. Проверки Linux подтверждают лишь стек одного драйвера, а не PDO/PnP/питание. KernelIRPStackTests.cpp проверяет счётные курсоры, полные inline-префиксы Copy, обнуление использованных позиций, передачу статуса/pending, MPR и вложенное завершение, владельцев продолжений и удержанные маршруты. Настоящие READ/WRITE и жизненный цикл файла также проверяют inline Copy.

DriverPnpScenarioTests.cpp проверяет согласованность JSON/нативного preflight, явные исходные факты, пределы ID/количества, запрещённые поля, конечные статусы шины и nullable-наблюдения. KernelPnpDeviceTests.cpp, KernelPnpRequestTests.cpp, KernelPnpCompletionTests.cpp проверяют владение провайдера, успех/ошибки/утечки AddDevice, начальные IRP, доступ к файлам, откат состояния, задержки, MPR/вложенные/ожидающие продолжения и атомарность ошибок. Оригинальный driver_wdm_pnp.c с настоящим WDK использует необязательные NEVERD_WDM_PNP_FIXTURE/NEVERD_WDM_PNP_CFG_FIXTURE. DriverWDMPnpTests.cpp исполняет обычные/активные CFG-образы с перемещённой базой: AddDevice, файловый I/O, штатное удаление, отложенный start/remove, ошибки start/query и чистые/протекающие ошибки AddDevice. Отсутствующие артефакты явно пропускаются. Свидетельства выполнения относятся только к Linux и документированному PnP без ресурсов. DriverScenarioPublicTests.cpp также проверяет отчёты отложенного PnP из семи запросов через C API и CLI для обычных/активных CFG-образов.

Тесты schema V9 проверяют восемь имён minor-функций и общий контроль конечного статуса; QueryStop 0x119 отклоняется до загрузки образа. Модели и настоящие fixtures проверяют откат query-stop, cancel-stop, stop/restart, surprise-removal, точные успешные статусы, программный I/O при остановке/ожидании удаления, гостевой отказ после surprise, идентичность устройств и смешанные результаты AddDevice. DriverScenarioPublicTests.cpp исполняет 16 запросов через C API/CLI на обычном/активном CFG, сохраняя успешные байты IOCTL, гостевую ошибку после surprise и окончательные cleanup/close/remove. Исполнитель последователен: удерживаемая IRP без текущего источника завершения не может ждать последующего start/cleanup сценария. Условия дренирования перед Remove — границы профиля, не общая политика Windows I/O. Свидетельства ограничены Linux.

KernelRemoveLocksTests.cpp проверяет независимых владельцев, NULL/повторные Tags, размеры retail/DBG, немедленное/отложенное дренирование, обязательства после отказа, атомарность, лимиты и освобождение. KernelRemoveLockBridgeTests.cpp проверяет инициализацию до attach, границы расширения, непрозрачность, IRQL и отказ опасных Delete/Detach до изменения. Подлинный driver_wdm_remove_lock.c имеет retail/DBG и обычные/active-CFG варианты через NEVERD_WDM_REMOVE_LOCK_FIXTURE, NEVERD_WDM_REMOVE_LOCK_CFG_FIXTURE, NEVERD_WDM_REMOVE_LOCK_DBG_FIXTURE, NEVERD_WDM_REMOVE_LOCK_DBG_CFG_FIXTURE. DriverWDMRemoveLockTests.cpp проверяет release после освобождения пакета, завершение шины после drain, готовность до возврата callback, ожидания worker и чистый отказ AddDevice. C API/CLI используют прежнюю схему PnP и различают приём, завершение и teardown. Артефакты при отсутствии явно пропускаются; Linux-доказательства не означают полный Driver Verifier или общее параллельное дренирование.

DriverResourceScenarioTests.cpp проверяет явные факты JSON/C++, ширину целых, количества, пересечения физических диапазонов/регистров, выравнивание, ID, пустые банки и сериализацию конфигурации. KernelMMIOTests.cpp, KernelMMIOFailureTests.cpp, KernelResourceBridgeTests.cpp и UnicornMMIOTests.cpp охватывают владение банками/отображениями, алиасы, поколения, срок жизни упакованных списков, моменты действий провайдера, сохранение при перезапуске, доступ после внезапного удаления/смены питания, точные транзакции CPU/API и атомарность ошибок. Оригинальный driver_wdm_resources.c, собранный настоящим WDK, использует NEVERD_WDM_RESOURCE_FIXTURE / NEVERD_WDM_RESOURCE_CFG_FIXTURE; DriverWDMResourceTests.cpp исполняет реальные скалярные и REP-обращения, перенос обычного образа/образа с активным CFG, алиасы поддиапазонов, отображения конца страницы, STOP/перезапуск и недопустимые обращения. C API/CLI отклоняют неверные факты до загрузки образа и выполняют одинаковый сценарий из 14 запросов с сохраняемым результатом IOCTL и точным числом map/unmap. Общий driver-register-bank-scenario.json требует протокола регистров/IOCTL этого образца. Отсутствующие артефакты явно пропускаются; данные получены только на Linux, без физической памяти хоста или универсального backend устройств.

DriverInterruptScenarioTests.cpp покрывает явные исходные/преобразованные дескрипторы, смешанные назначения и назначения только прерываний, строгие поля/число событий, исходную идентичность и независимые наблюдения BOOLEAN. KernelInterruptsTests.cpp, KernelInterruptBridgeTests.cpp и SchedulerInterruptTests.cpp проверяют исключительное совпадение кортежей, непрозрачные токены, захват поколения/подключения, жизнь событий, точные выбранные поля Ex, восстановление общей блокировки/IRQL, владение callbacks, приоритет ISR одного момента и отказ по вместимости до изменений. KernelFrameworkRequestTests.cpp проверяет чистое предвычисление отмены и вместимость пакета токенов без публикации вызовов или расходования ссылок. Оригинальный driver_wdm_interrupts.c с настоящим WDK использует NEVERD_WDM_INTERRUPT_FIXTURE / NEVERD_WDM_INTERRUPT_CFG_FIXTURE; DriverWDMInterruptTests.cpp проверяет обычную/активную CFG-релокацию, старый ABI одиннадцати аргументов, Ex 1/2/4, реальное завершение ISR→DPC, FALSE в младшем AL, синхронизацию/ручные блокировки, независимые PDO, поколения перезапуска и неверные аппаратные факты. Тесты C API/CLI отклоняют неверные объявления до загрузки образа и исполняют семь запросов driver-interrupt-scenario.json, проверяя байты pending IOCTL и отдельные наблюдения доставки. Отсутствующие образы явно пропускаются; свидетельства остаются Linux-only и не подтверждают разделяемые/уровневые/MSI-прерывания или вытеснение на уровне инструкций.

DriverDMAScenarioTests.cpp проверяет явные возможности, логические домены, ограничения байтов/числа/времени, строгие направления и раздельные конфигурацию/наблюдения. KernelPhysicalMemoryTests.cpp и BackendBackingTests.cpp проверяют границы выделений на общих страницах, фиксацию памяти, неизменность прав CPU, запрет MMIO/повторного входа и атомарность ошибок всего диапазона; KernelRequestMDLTests.cpp проверяет PFN только для чтения и алиасы построенных дескрипторов с общей физической идентичностью. KernelDMATests.cpp, KernelDMABridgeTests.cpp и SchedulerDMATests.cpp проверяют реальные байты RAM, вызовы таблиц конкретных адаптеров, немедленное/очередное владение FIFO, раздельные сроки callbacks/отображений, фрагменты страниц, ошибочные направления, предварительную проверку освобождения, независимые домены PDO и сбои эпохи/питания. Оригинальный WDK-образец driver_wdm_dma.c использует NEVERD_WDM_DMA_FIXTURE / NEVERD_WDM_DMA_CFG_FIXTURE; DriverWDMDMATests.cpp и C API/CLI исполняют настоящие указатели, память common/SG и отдельно заданные события DMA/прерываний. Общий driver-dma-scenario.json требует протокол этого образца. Отсутствующие артефакты явно пропускаются; Linux-проверки не доказывают DMA реального хоста, PCI или универсальный механизм устройства. pluginsdk/python/tests/test_driver_dma_integration.py использует существующую привязку с явным владением JSON и NEVERD_TEST_LIBNEVERD / NEVERD_TEST_WDM_DMA_FIXTURE / NEVERD_TEST_WDM_DMA_CFG_FIXTURE, проверяя байты, порядок callbacks и наблюдения ошибок.

KernelSEHTests.cpp проверяет чистые планы раскрутки, порядок областей, восстановление невольатильных регистров общего назначения, ограниченные стеки и явное отклонение неподдерживаемых метаданных; KernelExceptionTests.cpp проверяет точное число аргументов API, младшие 32 бита состояния, типизированные исключения, ограничения IRQL и неизменность состояния модели/CPU. Оригинальный образец driver_wdm_seh.c с настоящим WDK и /GS- использует необязательные NEVERD_WDM_SEH_FIXTURE / NEVERD_WDM_SEH_CFG_FIXTURE; DriverWDMSEHTests.cpp запускает обычные, активные CFG и перемещённые образы с прямыми исключениями и вызовами из helper, вложенными обработчиками, повторными исключениями из обработчиков, реальными фильтрами, finally при раскрутке, порядком поиска, стабильными записями исключений, поддерживаемым продолжением после сбоев CPU и полным восстановлением состояния CPU. Вложенные фильтры и конфликтующие finally используют связанные логические стеки; остальные сбои CPU явно отклоняются. C API/CLI исполняет driver-seh-scenario.json, проверяя null в результатах API и реальные сообщения гостевого обработчика. pluginsdk/python/tests/test_driver_seh_integration.py использует NEVERD_TEST_LIBNEVERD, NEVERD_TEST_WDM_SEH_FIXTURE и NEVERD_TEST_WDM_SEH_CFG_FIXTURE. Отсутствующие внешние образы явно пропускаются; результаты относятся только к Linux и не подтверждают поддержку пользовательских буферов или общего SEH.

KernelDMAChannelTests.cpp, KernelDMAChannelBridgeTests.cpp и общий SchedulerDMATests.cpp проверяют смешанную FIFO, ширину возвращаемых значений, чистые проверки принятия/освобождения, повторное использование регистров, непрерывные фрагменты страниц, flush всей операции, снимки CurrentIrp и сроки жизни пакетов/MDL/устройств. Оригинальный WDK-образец driver_wdm_dma_channel.c использует необязательные NEVERD_WDM_DMA_CHANNEL_FIXTURE / NEVERD_WDM_DMA_CHANNEL_CFG_FIXTURE; DriverWDMDMAChannelTests.cpp исполняет normal/active-CFG и перебазированные драйверы с настоящими MapTransfer/FlushAdapterBuffers, общей квотой common/SG/каналов, явными транзакциями, завершением IRQ/DPC, последовательными операциями, двумя PDO и ошибками. C API/CLI запускает семь запросов driver-dma-channel-scenario.json, включая одну транзакцию через оба фрагмента. pluginsdk/python/tests/test_driver_dma_channel_integration.py использует NEVERD_TEST_LIBNEVERD, NEVERD_TEST_WDM_DMA_CHANNEL_FIXTURE и NEVERD_TEST_WDM_DMA_CHANNEL_CFG_FIXTURE для того же публичного JSON-интерфейса. Отсутствующие артефакты явно пропускаются; Linux-проверки не устанавливают поддержку системных DMA-контроллеров или произвольных схем HAL mapping/flush.

DriverPowerScenarioTests.cpp проверяет обязательные факты, паритет JSON/native, непрозрачный32-битный context, предел FIFO и отдельные детские отчёты. KernelPowerRequestTests.cpp и KernelPowerCompletionTests.cpp проверяют layout, флаги маршрута, различие жизненного цикла и уведомлений, FIFO, владение терминальным callback, MPR, ожидания и освобождение. Оригинальный driver_wdm_power.c с подлинным WDK использует необязательные NEVERD_WDM_POWER_FIXTURE/NEVERD_WDM_POWER_CFG_FIXTURE. DriverWDMPowerTests.cpp охватывает обычную/active-CFG релокацию, прямые/вложенные Query/Set, независимое отложенное завершение, S0 до D0, пятиаргументный снимок через ожидание, детей из worker, null-callback, отказ query, отдельные начальные состояния/FIFO PDO и отсутствие явных фактов. DriverScenarioPublicTests.cpp добавляет неверный ввод и цикл сна/возврата с6 сценарными и3 дочерними запросами через C API/CLI. Отсутствующие артефакты явно пропускаются; доказательства только Linux и только для описанного pageable-профиля без ресурсов.

KernelUsbIdleTests.cpp проверяет владение, D2, заимствование и первую причину; KernelUsbIdleBridgeTests.cpp / KernelUsbIdleReceiptTests.cpp — реальные IRP, отмену, ёмкость группы и порядок получения/завершения; DriverUsbIdleScenarioTests.cpp — вход/отчёты. DriverWdmUsbIdleTests.cpp использует настоящий driver_wdm_usb_idle.c с NEVERD_WDM_USB_IDLE_FIXTURE / NEVERD_WDM_USB_IDLE_CFG_FIXTURE для idle, D0/D3, wake, отмены, повторной регистрации/старта, независимых/составных функций и PDO/FDO. DriverWdmUsbIdlePublicTests.cpp запускает USB-сценарий через C API/CLI, normal/active-CFG, исходные/перемещённые базы. Отсутствующие артефакты явно пропускаются; доказательства только Linux и не означают поддержку USB KMDF.

KernelFrameworkUsbIdleTests.cpp, KernelFrameworkUsbIdleStorageTests.cpp и KernelFrameworkUsbIdleBridgeTests.cpp проверяют политику, хранение и типизированное планирование. Настоящий driver_kmdf_usb_idle.c не отправляет собственный idle IRP. DriverKMDFUsbIdleTests.cpp охватывает отсутствие разрешения, управляемый I/O с задержанными D2/D0, StopIdle до/во время callback, ошибку arm, явный Maximum, wake и составные группы. DriverKMDFUsbIdlePublicTests.cpp выполняет сценарий KMDF USB с NEVERD_KMDF_USB_IDLE_FIXTURE / NEVERD_KMDF_USB_IDLE_CFG_FIXTURE, C API/CLI, normal/active-CFG, исходными/перемещёнными базами. Недостающие артефакты явно пропускаются; доказательства только Linux. Тесты модели проверяют, что исчерпание памяти после успешного callback arm вызывает настоящий callback disarm и отменяет WAIT_WAKE, не расходуя ответ D2.

DriverKMDFUsbPoFxTests.cpp проверяет начальное SystemManaged/WithHint, два разрешения, отмену D0, отложенные D2/D0 и подтверждение F0 настоящим worker, StopIdle, пробуждение до READ, ошибку arm, удаление и перезапуск. DriverKMDFUsbPoFxPublicTests.cpp выполняет сценарий USB PoFx через C API/CLI, оба режима, normal/active-CFG и предпочтительную/перемещённую базу. DriverKMDFUsbIdleTests.cpp сохраняет перенаправление и проверяет прямой READ после D0Entry. KernelFrameworkRequestTests.cpp проверяет отображения, владение caller-context, ручные/остановленные очереди и IRQL. Исчерпание памяти и независимые барьеры доказывают тесты модельного моста, не настоящий драйвер. Отсутствующие образы явно пропускаются; исполнение подтверждено только на Linux. KernelFrameworkUsbPoFxBridge.RemovalPowerUpFailureAcknowledgesRequiredWithoutReleasingIdleWait отдельно проверяет реальную ошибку D0Entry при RemovePending: точное подтверждение Required и quiesce позволяют очистку без F0/ActiveCondition. Это не доказывает общие отказы SET_POWER или самостоятельный surprise removal.

KernelPowerCompletionTests.cpp, KernelProviderWaitWakeTests.cpp, KernelWdmWakeEventTests.cpp, DriverWdmWaitWakeTests.cpp: Нативный сценарий WAIT_WAKE использует настоящий WDK fixture driver_wdm_wait_wake.c через NEVERD_WDM_WAIT_WAKE_FIXTURE / NEVERD_WDM_WAIT_WAKE_CFG_FIXTURE. Проверяются отправка во время START, аргументы, пробуждение без неявного D0, перевыпуск, отмена, MPR, отмена в DPC с D0 из worker, точный захват и независимые поставщики. Выполнение обычных/active-CFG образов по исходному/перемещённому адресу подтверждено только в Linux; отсутствующие файлы явно пропускаются.

KernelPowerCompletionTests.cpp проверяет APC/DPC, атомарный отказ ёмкости и повтор, поставщика без FDO с синхронным/отложенным завершением с/без callback, удержание маршрута и MPR. Настоящий DriverWdmWaitWakeTests.cpp проверяет прямой D0 из отмены DPC, APC/DPC Query/Set, сохранение IRQL/CR8, возврат до PASSIVE и отказ повышенного WAIT_WAKE. Повышенный сценарий идёт через DriverWdmWaitWakePublicTests.cpp, C API/CLI, обычные/active-CFG образы и исходные/перемещённые базы; доказательства только Linux.

DriverGuardTests.cpp и четыре оригинальных варианта driver_guard.c проверяют активный/неактивный CFG, изменение базы загрузки, ABI check/dispatch и некорректные цели. KernelFrameworkTests.cpp, KernelFrameworkControlTests.cpp, KernelFrameworkQueueTests.cpp и KernelFrameworkRequestTests.cpp проверяют привязки, транзакционное создание устройств, маршрутизацию очередей, логические длины буферов и сроки жизни при очистке, завершении IRP и уничтожении контекстов. Оригинальные driver_kmdf_lifecycle.c и driver_kmdf_control.c при наличии внешних зависимостей компилируются с настоящими заголовками WDK 1.33 и связываются через реальную библиотеку FxDriverEntry. Задайте пути в кэше CMake NEVERD_KMDF_FIXTURE / NEVERD_KMDF_CFG_FIXTURE для образов жизненного цикла и NEVERD_KMDF_CONTROL_FIXTURE / NEVERD_KMDF_CONTROL_CFG_FIXTURE для обычных образов управляющего устройства и образов с активным CFG. Отсутствующие внешние артефакты явно пропускаются. DriverKMDFLifecycleTests.cpp, DriverKMDFControlTests.cpp и случаи C API/CLI в DriverScenarioPublicTests.cpp проверяют реальные callback-вызовы, буферизованный/прямой ввод-вывод, завершение ожидающих запросов рабочими элементами, статусы ошибок, выгрузку и выполнение CFG после изменения базы. Доказательства по-прежнему ограничены Linux и не подтверждают полную поддержку KMDF, PnP или управления питанием.

Тесты старого API отмены сохраняют продолжение API через отмену, вложенную очистку и окончательное уничтожение; Ex по-прежнему возвращает отмену без обработчика для уже отменённых запросов. KernelFrameworkRequestAccessorTests.cpp и KernelRequestMDLTests.cpp проверяют общий 64-битный Information, длина при завершении, идентичность исходной очереди/IRP, NULL файлового WDF, getter сохранённых дескрипторов, кэш MDL и ByteCount первого направления, прямой MDL и отложенное отображение, аннулирование и запрет обхода через WDM. Режимы L, M, D и C настоящего управляющего fixture выполняют отмену через старый API, буферизованные MDL/Information, прямые MDL READ/WRITE и доступ после завершения в обычных образах и с активным CFG.

Тесты отмены проверяют виртуальные сроки только для передач и поля отчёта, предшествующее завершение, уже отменённые запросы, отметку/снятие, право завершения при очереди и доставке, ожидание обработчиков и внутренние ссылки. Тесты планировщика отдельно проверяют порядок DPC/отмена/рабочий элемент, ёмкость, разделение идентичностей и приостановку/возобновление. Отмена WDM остаётся явной ошибкой модели.

Структура тестов

add_neverd_unittest создаёт один исполняемый GoogleTest и назначает каждому обнаруженному случаю метку CTest с именем этой исполняемой цели.

Область исходников	Цель и метка CTest	Покрытие
`unittests/TestProcessTests.cpp`	`NeverDTestProcessTests`	Кросс-платформенные дочерние процессы, quoting, перенаправления и коды выхода
`unittests/libc`	`NeverDLibCTests`	Известные имена libc и классификация
`unittests/safety`	`NeverDSafetyTests`, `NeverDSafetyIntegrationTests`	Каталог стоков, приоритет идентичности, предфильтр аргументов, охота на переполнение копий, аудит жизни кучи и обязательная шестиячеечная матрица PE/ELF/Mach-O × x86-64/AArch64
`unittests/lift`	`NeverDLiftTests`	Формы LowIR decoder/lifter, стадии IR, loader, relocation, fixture форматов, декомпиляция и представительные patch-маршруты
Большинство файлов `unittests/semantic`	`NeverDSemanticTests`	Дифференциальная семантика инструкций, ABI, управления, выражений C и lift/recompile
`unittests/evm`	`NeverDEVMOpcodeTests`, `NeverDEVMBytecodeTests`, `NeverDEVMLoaderTests`, `NeverDEVMABITests`, `NeverDEVMAnalyzerTests`, `NeverDEVMDecoderPropertyTests`, `NeverDEVMProxyTests`, `NeverDEVMCallTests`, `NeverDEVMSemanticTests`, `NeverDEVMEmitterTests`, `NeverDEVMIntegrationTests`	Metadata hardfork, нормализация, неоднозначность ABI/signature, CFG/SSA/recovery, полный перебор границ decoder и враждебных inputs, факты proxy/call, семантика interpreter, differential LLVM/C/Solidity и публичный API
`unittests/sbf`	`NeverDSBFMetadataTests`, `NeverDSBFProgramImageTests`, `NeverDSBFLoaderTests`, `NeverDSBFAnalyzerTests`, `NeverDSBFVerifierTests`, `NeverDSBFISAConformanceTests`, `NeverDSBFAgaveConformanceTests`, `NeverDSBFSemanticTests`, `NeverDSBFEmitterTests`, `NeverDSBFLLVMEmitterTests`, `NeverDSBFLLVMDifferentialTests`, `NeverDSBFSourceDifferentialTests`, `NeverDSBFMalformedCorpusTests`, `NeverDSBFUpstreamConformanceTests`, `NeverDSBFExternalOracleTests`, `NeverDSBFSolanaModelTests`, `NeverDSBFIntegrationTests`	Метаданные v0-v4 и компоновки ELF, строгая работа verifier/loader, 23 закреплённых ELF-артефакта, независимый официальный oracle, полный охват opcode, враждебные входы, CFG/восстановление и исполняемые различия LLVM/C/Rust
`PatchFullSubstRTTests.cpp`	`NeverDPatchFullTests`	Эквивалентность переписывания/обфускации для четырёх ISA и трёх объектных форматов
Целевые файлы преобразований в `unittests/semantic`	`NeverDSwitchXformTests`, `NeverDIndCallXformTests`, `NeverDCFGLoopXformTests`, `NeverDTwoTableXformTests`, `NeverDAvxUpperXformTests`	Быстро перелинковываемые проверки отдельно от большого семантического бинарника
`unittests/corpus` (подмодуль)	`NeverDWindowsEHCorpusTests`, `NeverDRustEHCorpusTests`, `NeverDGoEHCorpusTests`, `NeverDCxxItaniumEHCorpusTests`, `NeverDObjCEHCorpusTests`, `NeverDAdaDEHCorpusTests`	Метаданные исключений и рантайма, прочитанные из 545 зафиксированных настоящих бинарников; для каждого манифест объявляет нижние границы, которые восстановление обязано преодолеть

Источники регистрации: unittests/CMakeLists.txt, unittests/lift/CMakeLists.txt и unittests/semantic/CMakeLists.txt, unittests/evm/CMakeLists.txt и unittests/sbf/CMakeLists.txt и unittests/safety/CMakeLists.txt.

Зафиксированный бинарный corpus

Каждый другой набор сам собирает то, что проверяет. Corpus — нет: это подмодуль с бинарниками, которые выпустили настоящие тулчейны, на хостах и для целей, недоступных этому репозиторию; каждый зафиксирован по дайджесту, а рядом лежит манифест с нижними границами, которые обязано преодолеть восстановление. Это единственное место, где утверждение о том, что NeverD читает, скажем, из обрезанного -O2 разделяемого объекта armv7, получает ответ, а не спор.

Наборы собираются, только если шаг configure получил указание их искать, поэтому именно этот флаг и удерживает их под проверкой:

cmake -S . -B build-corpus -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_TESTING=ON \
  -DNEVERD_ENABLE_BINARY_CORPUS_TESTS=ON
cmake --build build-corpus --target check-neverd-corpus --parallel 4

check-neverd-corpus запускает все линии; check-neverd-windows-eh-corpus, check-neverd-rust-eh-corpus, check-neverd-go-eh-corpus, check-neverd-cxx-itanium-eh-corpus, check-neverd-objc-eh-corpus и check-neverd-ada-d-eh-corpus — по одной. Все три хоста CI выполняют configure с этим флагом и прогоняют все шесть линий: байты везде одинаковы, а то, что их читает, — нет, и прогон corpus на одном хосте ничего не доказывает про два других. scripts/audit_ci_test_inventory.py отклоняет инвентарь, в котором не хватает хотя бы одной из шести меток, потому что сборка, тихо переставшая читать corpus, — это регрессия, которую не поймает ни один тест: пропало как раз то, что проверяло.

Live-аудит opcodes EVM запускается так:

python3 scripts/audit_evm_opcode_metadata.py

Локально и в CI стандартный путь принудительно выполняет git fetch --depth=1 --force с официального URL https://github.com/ethereum/go-ethereum.git и проверяет в detached worktree только точный SHA, только что полученный из удалённого HEAD default branch. Каждый запуск использует приватный временный bare repository с непредсказуемым именем, сохраняет authority ref official fetch и точный SHA на время detached worktree, затем уничтожает repository и worktree вместе. Общего постоянного Git repository или cache нет. local_docs, готовый checkout и submodule не являются путями аудита: закреплённый submodule устарел бы именно тогда, когда требуется обнаружить live drift.

Каждая команда Git сначала удаляет все унаследованные GIT_*, включая GIT_CONFIG_*, и устанавливает только проверенные значения. GIT_CONFIG_NOSYSTEM и GIT_CONFIG_GLOBAL отключают system/global config; GIT_ATTR_NOSYSTEM и command-scoped core.attributesFile отключают system/global attributes, а core.hooksPath — hooks. Неожиданная private-repository config, grafts, objects/info/alternates или refs/replace приводят к отказу проверки; GIT_NO_REPLACE_OBJECTS отключает replacement lookup.

Probe отражает все экспортированные bool-поля params.Rules, вызывает LookupInstructionSet(params.Rules) и сканирует все 256 slots. EVMUpstreamOpcodePolicy.def хранит aliases и типизированные исторические/незапланированные EOF-исключения; EVMUpstreamSemanticsPolicy.def хранит закрытый Rules inventory, mappings forks, base-stack exceptions и dynamic-immediate families.

CI выполняет тот же live audit только при push в dev, pull request, ручном запуске и ежедневно. Go-probe вызывает открытый API LookupInstructionSet(params.Rules) для каждого сопоставленного fork. Публичная CLI предоставляет только --manifest-output; закрытый manifest использует schema 3 и не позволяет выбирать источник, ref, checkout или toolchain. EVMUpstreamOpcodePolicy.def хранит alias и проверенные исторические/незапланированные EOF исключения; независимый EVMUpstreamSemanticsPolicy.def — правила fork и исключения stack semantics. Закрытый manifest проверяет точную revision, activation, byte/name, base_min_stack и net_stack_delta и отвергает неизвестные или повторные поля, forks, имена и bytes. Allocation определяется только operation.undefined; HasCost — лишь проверка стоимости, поскольку false возвращается и для определённых zero-cost операций. Каждый slot defined && !HasCost должен точно соответствовать EVM_GETH_ACTIVE_WITHOUT_COST с объявленного fork. Undefined slot со стоимостью, непроверенный defined slot или утрата marker приводят к закрытому отказу. Отсутствующие, выходящие за диапазон или синтаксически неиспользованные объявления также отвергаются: каждый .def parser отказывается от partial policy. При сбое CI revision, manifest и log загружаются как artifact. Parser и диагностика имеют независимые Python unit tests:

EVMUpstreamSemanticsPolicy.def относит каждое экспортированное булево поле params.Rules одной записью EVM_GETH_RULE_FIELD к MappedForkSelector, NoOpcodeAllocation или ExcludedSelectorExpectedError. Probe включает поля по одному через LookupInstructionSet: первые две категории требуют nil error, третья — error, а полный fingerprint 256 opcode/stack slots должен равняться ExpectedFork. IsEIP155, IsEIP2929, IsEIP4762 и IsPetersburg сейчас no-allocation поля с Frontier fingerprint; IsUBT обязан дать error и Cancun.

EVMUpstreamSemanticsPolicy.def объявляет динамические семьи EIP-8024, виды операций и допустимые stack deltas; EVMEIP8024Immediates.def отдельно владеет decode immediate и классифицирует 256 bytes single/pair. Через go -overlay аудит получает настоящие private handlers operation.execute и проходит по canonical fork jump tables и mainnet active/scheduled jump tables таблица за таблицей. Семья inactive записывается явно, partial семья отвергается. Каждая активная таблица проверяет DUPN, SWAPN и EXCHANGE со всеми immediate (3x256) и 3 missing-operand cases по тем же декларативным источникам.

У EVM_HARDFORK_LATEST одна canonical цель. Закрытый EVMUpstreamForkAliases.def задаёт Prague→Pectra, Osaka и BPO1–BPO5→Fusaka и identity для Paris/Shanghai/Cancun/Amsterdam/Bogota; неизвестные имена дают закрытый отказ. Записанный audit_unix_time управляет проверкой MainnetChainConfig.LatestFork(time) (обязан совпасть с NeverD latest) и alias/probe проверкой LatestFork(max uint64); обе instruction set сравниваются полностью. Manifest фиксирует authority=official-fresh-fetch, официальный URL, запрошенный HEAD и SHA. Probe использует GOTOOLCHAIN=local.

Go-probe и Python-контроллер применяют input/collection/string hard limits; чрезмерные inputs, collections или strings приводят к закрытому отказу. Для bounded diagnostic output чрезмерно длинное отображение получает полный digest и explicit truncated marker. Вывод и срок каждого child ограничены; превышение завершает всю process group/process tree и осушает pipes.

Текущий receipt schema 3 фиксирует schema_version=3, audit_unix_time=1787534659, authority=official-fresh-fetch, remote=https://github.com/ethereum/go-ethereum.git, ref=HEAD, revision 02b73d4ea7181464175e0a6cbecc0a3a2655a562, локальный Go 1.24.0, stack_limit=1024 и diagnostics=[]. Он охватывает 21 fork tables и 20 Rules probes с 15 mapped/4 no-op/1 expected-error. Обе записи mainnet active/scheduled сообщают upstream BPO2, закрыто отображённый в NeverD Fusaka. Из 23 table targets только Amsterdam/Bogota активны: 1536 candidate executions и 6 missing-operand cases. three handler symbols совпадают на обеих активных целях. Python audit прошёл 67/67, а C++ Opcode 10/10. Реальный macOS run прошёл под sandbox-exec, финальный go run был offline; Linux workflow принудительно применяет bubblewrap.

Все Go stages — go env, go mod init, go mod edit, go mod tidy, go mod download и go run — проходят через filesystem sandbox capability-root. Он читает только private probe, fresh geth, проверенный resolved GOROOT и точно необходимые system runtime roots и пишет только в isolated environment roots. Сеть выдаётся лишь необходимым dependency stages, финальный run offline. Тесты требуют отказа для sentinels в host HOME/workspace и отсутствия их содержимого в output. Linux проверяет изоморфный bubblewrap без / broad bind.

python3 -m unittest -v scripts.tests.test_audit_evm_opcode_metadata

Одиннадцать целей EVM, сейчас зарегистрированных в CMake:

NeverDEVMOpcodeTests
NeverDEVMBytecodeTests
NeverDEVMLoaderTests
NeverDEVMABITests
NeverDEVMAnalyzerTests
NeverDEVMDecoderPropertyTests
NeverDEVMProxyTests
NeverDEVMCallTests
NeverDEVMSemanticTests
NeverDEVMEmitterTests
NeverDEVMIntegrationTests

NeverDEVMDecoderPropertyTests перебирает все двухбайтовые входы для каждого fork, меняющего decoder, сравнивает полный decode и точные границы JUMPDEST, а также прогоняет через все forks детерминированные враждебные входы ограниченной длины.

При изменении управления EVM сначала запустите контракт fixed point и домена высот:

cmake --build build --target NeverDEVMAnalyzerTests --parallel 4
build/bin/NeverDEVMAnalyzerTests \
  --gtest_filter='EVMAnalyzer.StackHeightDomain*:EVMAnalyzer.WholeProgram*'

Эти случаи покрывают межблочные returns, конечные multi-target merges, сходимость, детерминированный порядок edges, path-sensitive lanes полного стека, сохранение корреляции, неизвестные jumps, точные недопустимые цели, fail-loud budgets и stack faults. MayReachable сохраняет только кандидата CFG и не создаёт достоверных фактов. Затем запустите все одиннадцать целей EVM и live upstream audit.

При изменении dataflow MedIR/HighIR запустите также контракты constant-phi, selector, typed-operand, malformed-graph и deep-chain:

build/bin/NeverDEVMAnalyzerTests \
  --gtest_filter='EVMAnalyzer.MediumIR*:EVMAnalyzer.HighIR*:EVMAnalyzer.*Selector*:EVMAnalyzer.*MedIR*:EVMAnalyzer.RecoversStorageAndEventFactsFromTypedOperands:EVMAnalyzer.RecoversComputedCalldataArgumentOffset:EVMAnalyzer.*Return*:EVMAnalyzer.*Receive*'

Эти случаи доказывают равные и конфликтующие циклические phi, несмежные и межблочные выражения selector, оба порядка операндов равенства, точные проверки ширины ABI, типизированные операнды storage/event/calldata, детерминированную обработку malformed MedIR и итеративный producer walk по 16 384 значениям.

Создание fixture

Fixture подъёма и форматов

unittests/lift/CMakeLists.txt кросс-компилирует исходники C и assembly во время сборки. Целевые triple Clang создают ELF-объекты x86-64, i386, AArch64 и ARM32, PE/COFF-объекты и слинкованные образы, а также PIC/no-PIC Mach-O i386-объекты. При наличии LLD выбранные объекты также линкуются в исполняемые файлы для patch- тестов. NeverDLiftTests зависит от цели lift-test-objects, поэтому обычная сборка тестового бинарника обновляет сгенерированные fixture.

Большинство lift-тестов используют NeverDLiftFixture.h, чтобы вызвать собранный CLI neverd и проверить LowIR, MedIR, HighIR, LLVM IR, сгенерированный C или переписанный бинарник. Переменная окружения NEVERD может переопределить путь CLI для целевого ручного эксперимента; обычные запуски CTest используют встроенный CMake исполняемый файл.

Fixture безопасности памяти

unittests/safety/fixtures/binaries содержит зафиксированные образы PE, ELF и Mach-O для x86-64 и AArch64 вместе со спутником PDB или dSYM, который даёт каждый формат, и компоновочным MAP для каждого образа. MAP — единственное, что всё ещё поставляет обрезанная сборка, поэтому каждая ячейка дополнительно анализируется с явно указанным MAP: это фиксирует, что находка вправе утверждать, когда не осталось ни типов, ни строк исходника. NeverDSafetyIntegrationTests выполняет все шесть ячеек на каждом хосте; конфигурация завершается ошибкой, если отсутствует любой требуемый образ или спутник, и у набора нет пути пропуска из-за инструментов хоста.

Равнозначные двоичные файлы происходят из одного исходного файла. Пересоберите родную для хоста smoke-fixture командой make либо перегенерируйте полную зафиксированную матрицу так:

make -C unittests/safety/fixtures matrix

Рецепту матрицы нужны кросс-цели Clang для Linux и Windows, COFF-инструменты LLD, обе архитектуры Darwin и dsymutil. Его отладочные пути переотображаются, а запись командной строки CodeView отключена, чтобы зафиксированные спутники не сохраняли абсолютный путь рабочего пространства разработчика.

Реконструкция исключений Windows

Изменения табличных исключений Windows требуют как тестов представления, так и patch-теста связанного PE. Целевой фильтр набора lift охватывает нормализованную модель unwind/SEH/C++, обработку повреждённых входов, исключительные рёбра CFG, HighIR, генерацию LLVM WinEH, замену каталога исключений и реконструкцию Guard CF/EH continuation:

cmake --build build --target NeverDLiftTests --parallel 4
build/bin/NeverDLiftTests \
  --gtest_filter='COFFException*:*PatchCOFF_X64.ReconstructsGuardedSEHAndContinuationTable:*PatchCOFF_X64.ReconstructsNativeFH3StateGraph:*PatchCOFF_X64.RejectsInteriorExceptionDirectoryPadding:*PatchCOFF_X64.RebuildsSortedExceptionDirectoryInAppendedSection'

Защищённой x64 assembly fixture нужны Windows-target Clang и lld-link; её CMake-link использует /guard:cf и /guard:ehcont. Skip из-за отсутствующего cross-linker не является доказательством для пути final-image. Успешный интеграционный тест доказывает, что переписанный PE можно повторно загрузить, а его таблицы runtime-function, unwind, load-config, Guard CF и Guard EH continuation остаются отсортированными, присутствуют в файле и указывают только на исполняемые цели.

Связанная FH3 fixture независимо проверяет нативное C++-замыкание: фиксированные таблицы состояний, аннотации HighC, сохранение personality, созданные catch-цели и повторно загруженный граф IP-to-state.

См. Реконструкцию исключений Windows для матрицы поддержки анализа/нативной генерации и fail-closed-контракта patch.

Языковые модели исключений

Всё, что не относится к табличной модели Windows, собрано в одной сфокусированной цели. NeverDLanguageEHTests покрывает цепочку кадров DWARF, языковую область данных Itanium, ARM EHABI, Darwin compact unwind, метаданные кадров рантайма Go, механику паники Rust и три рантайма Objective-C:

cmake --build build --target NeverDLanguageEHTests --parallel 4
build/bin/NeverDLanguageEHTests --gtest_filter='ObjC*'

Таблицы этого набора собираются побайтно, а не компилируются: большинство проверяемых сочетаний не выдаёт совместно ни один тулчейн. Objective-C — наиболее показательный случай: все три рантайма выдают Itanium LSDA и различаются только тем, что лежит в ячейке таблицы типов, и это различие полное, а не количественное. Ячейка Apple адресует objc_typeinfo, первые два поля которого намеренно повторяют std::type_info; ячейка Objective-C++ у GNUstep адресует настоящего наследника std::type_info; а ячейка рантайма GNU вообще не указатель, а сама строка с именем класса. Применение соглашения одного рантайма к таблице другого не приводит к ошибке — оно сообщает имя класса, прочитанное из середины чего-то постороннего. Поэтому рантайм устанавливается по personality кадра до чтения любой ячейки.

Тот же набор фиксирует два различия, которые легко слить и ошибочно сливать. @catch(id) и @catch(...) — разные обработчики: первый принимает любой объект Objective-C и пропускает чужое исключение мимо, — и каждый рантайм записывает их по-своему; декодер, сообщающий об обоих как о catch-all, вешает обработчик на исключения, которые на деле пролетели бы мимо. А таблица call-site в модели setjmp/longjmp индексирует точки вызова, а не адреса: чтец, не распознавший одну из personality SJLJ, не падает, а выдумывает защищённые диапазоны и landing pad, которых программа никогда не называла.

Распознать эту форму — не то же самое, что отказаться её читать. Запись SJLJ — это пара значений ULEB128 (селектор диспетчеризации и смещение действия), и это смещение означает здесь ровно то же, что и в адресной форме, так что цепочка действий, перехватываемые типы и спецификации исключений целиком читаются из таблицы, которая не называет никакого кода. Неизвестной остаётся только область, которую охраняет каждая запись, потому что о ней говорят записи, которые сама функция делает в свой слот call-site, а не что-либо в таблице. Набор закрепляет и тот единственный байт, которому здесь нельзя доверять: GCC пишет в качестве кодировки call-site DW_EH_PE_uleb128, LLVM пишет DW_EH_PE_udata4, оба затем всё равно выдают ULEB128, и ни одна personality его не читает — значит, не должен и декодер.

Рядом закрепляется и то, какая это personality, потому что именно это решает, как читается каждая из таблиц выше. GNAT называет свою процедуру теми же тремя способами, какими GCC называет процедуру каждого фронтенда — _v0, _sj0, _seh0, — а под Windows регистрирует один символ, переадресуя на другой, так что все четыре написания обязаны сойтись на Ada. D — зеркальный случай: три компилятора, три имени одной процедуры и один и тот же набор таблиц за ними.

Дифференциальные циклы Unicorn

Семантический fixture проверяет поведение, а не текстовую форму:

Написать небольшой случай C/assembly или построить LLVM IR.
Скомпилировать его Clang/LLVM для требуемой цели.
Исполнить исходный машинный код в Unicorn и получить ожидаемый возврат или другое заданное fixture состояние.
Загрузить и поднять в NeverD, вывести LLVM IR и снова скомпилировать результат в машинный код.
Исполнить восстановленный код с теми же ABI, входами, раскладкой памяти и моделью CPU.
Сравнить наблюдаемые результаты.

Основная реализация находится в SemanticRoundTripFixture.h. Patch-full fixture использует Codegen::compileForRewrite, тот же backend переписывания, что и операции patch, а затем сравнивает исходный и преобразованный код по полной сетке ISA/формат 4×3.

Детерминированная семантическая ошибка NeverD должна проваливать тест. Skips допустимы только для явной границы внешних возможностей; читайте их причину. Зелёный итог без cross-linker не доказывает исполнение маршрута формата.

Дифференциальные бэкенды EVM

Тесты interpreter дают детерминированный 256-bit oracle. Suite emitter компилирует и исполняет LLVM, переводит C23 через Clang в тот же host harness и, при наличии solc, anvil, cast и jq, разворачивает generated Solidity локально. Сравниваются status, storage и trace count. Отдельный raw corpus исполняет pre-Fusaka ALU, calldata/memory copy, перекрывающийся MCOPY, Keccak и return data в native EVM Anvil.

Тесты Low/Med сохраняют path-sensitive whole-stack execution lanes и lane identity для phi; исчерпание budget, включая MaxAbstractInstructionTransfers, является hard error. Strict отвергает unknown/fork-inactive opcode только на доказанной Reachable lane; MayReachable не создаёт определённых фактов. HighIR ограничивает selector/receive/fallback root lane и успешными terminals. Общий selector не даёт независимого свидетельства стандарта: variant и return list выбираются только по стандартной KnownFunctionVariantInfo и точной return shape, согласованной всеми успешными terminals.

Interpreter выполняет типизированный stack preflight до любого эффекта opcode. EVMForkSemantics.def определяет byte 0x44 как DIFFICULTY до Paris и PREVRANDAO начиная с Paris. REVERT, faults, step limit и resource exhaustion откатывают состояние транзакции. Ошибка allocation имеет вид ExecutionFaultKind::ResourceExhausted; если не создан даже входной snapshot, HasPersistentStateSnapshot равен false и commit невозможен.

Регрессии публичных границ и бюджетов EVM

Тесты публичного API независимо изменяют канонические Code/Fork/Instructions/JumpDestinations и каждую LowIR table, range, ID, lane и edge reference. execute обязан вернуть llvm::Error до lookup инструкции, а lowerToMedIR — отвергнуть весь malformed или over-budget LowIR до построения индексов или пропорционального input выделения. Для lowerToMedIR tests требуют проверки options, resources и structure до field-by-field canonical decode replay и до lowerCanonicalLowToMedIR. Публичный HighIR recovery replay-проверяет внешние LowIR/MedIR; только analyze использует lowerCanonicalLowToMedIR и recoverCanonicalHighIR для собственного canonical IR без рекурсивного/повторного replay, но со всеми HighIR option/resource budgets. Затем интерпретатор проверяет точную границу и +1 для всех пределов EVMInterpreterLimits.def: MaxSteps сохраняет отдельный StepLimit; исчерпание MaxMemoryBytes, MaxTraceEntries, MaxLogEntries, aggregate MaxLogDataBytes или runtime MaxPersistentStateEntries возвращает ResourceExhausted и откатывает эффекты транзакции. Слишком большой начальный aggregate MaxHostReturnDataBytes или persistent state является API error. MaxCalldataBytes, aggregate MaxHostEnvironmentEntries для BlockHashes, Balances, CodeHashes, ExternalCode, BlobHashes и aggregate MaxExternalCodeBytes также дают API error. const execute preflight отвергает их до копирования environment, snapshot или result. Views return-data ArrayRef и lower_bound по отсортированной таблице покрыты без копии buffer или PC map.

Отдельные LowIR boundary tests покрывают aggregate diagnostic limits MaxLowDiagnostics и MaxLowDiagnosticBytes: linear decode и построение CFG заранее учитывают точное число/итоговые bytes и отвергают ноль. Тесты безопасности HighIR покрывают отсортированный по lane домен Any/Exact/Excluded, match/exclusion равенства, false-edge match и true-edge mismatch сырого XOR(selector, constant), уточнение zero word/calldata size/call value и fail-closed unknown conditions. Их тесты точной границы и -1 покрывают из EVMAnalysisLimits.def MaxHighDispatchCandidates, aggregate MaxHighRecoveredArguments, MaxHighDiagnostics, MaxHighDiagnosticBytes, MaxHighReferenceVisits, MaxHighMemoryTransferCells и MaxHighMemoryValueVisits. Каждая output diagnostic, включая фиксированную malformed diagnostic, должна учесть количество и финальные bytes до allocation. LowIR и HighIR diagnostic budgets проверяются независимо; default root CFG region обязана тарифицировать MaxHighRegionBlockReferences до reserve или копирования block PC. Регрессии function scope покрывают back-jump через EQ и raw XOR в общий dispatcher. Они гарантируют, что другая функция не загрязняет arguments, mutability, return shape или region, а общие bodies и tail calls остаются достижимыми. Внешние CALL/CREATE outcomes проверяются как недетерминированные результаты host по обоим точным CFG-рёбрам, сохраняя восстановление fallback ERC-1167. Нечитаемое selector condition остаётся Unknown и не может создать fallback или function facts.

CFG tests выводят InvalidJumpDestination из EVMLowFaultKinds.def для end-of-code JUMPI: definitely true с invalid target не имеет successful tail и даёт definite fault; definitely false успешен; unknown сохраняет возможно успешный false path, не помечая всю lane definite fault.

ABI-тесты применяют точную границу и +1 к grammar limits из EVMABIParserLimits.def и cardinality/text limits публичных таблиц из EVMABITableLimits.def. Они также отвергают неверные kind/standard/evidence enums, несовпадающую metadata, неканонические signature/return lists, ошибочно independent общие selectors, dangling/duplicate variants и event-topic APInt неверной word width до indexed selector или sorted topic lookup.

NeverDEVMOpcodeTests также обеспечивает metadata architecture: каждый назначенный opcode проходит encoding/typed-value roundtrip; проверяются family boundaries, hardfork aliases и derived stack/host maxima.

Дифференциальные бэкенды Solana SBF

Тесты метаданных SBF проверяют все свойства версий, границы коллизий опкодов, Murmur3-хеши syscall, релокации, константы ELF machine, регистров и VM-адресов. Fixture загрузчика без включения сторонних бинарников генерируют как устаревшие секционные компоновки v0-v2, так и строгие бессекционные компоновки v3/v4 на основе program headers.

NeverDSBFISAConformanceTests проверяет каждый байтовый encoding для каждой версии v0-v4 по независимо аудированному типизированному manifest. NeverDSBFExternalOracleTests затем сравнивает решения об активации и границах с отдельно собранным официальным процессом Anza. NeverDSBFUpstreamConformanceTests назначает явный исход всем 23 ELF на закреплённой ревизии Anza.

NeverDSBFSemanticTests напрямую исполняет проверенные байты инструкций и не использует MedIR, поэтому изменение или повреждение нормализованного IR не может случайно согласовать исходный oracle с бэкендом. Покрыты немонотонная семантика v2, память, syscalls, внутренние call frames, faults, traces и ограничения ресурсов. Модули LLVM проходят проверку; сгенерированный C компилируется с предупреждениями как ошибками, а Rust — с -D warnings. Тесты публичного API проходят все стадии IR, дизассемблирование, CFG, метаданные, LLVM, C и Rust, начиная со сгенерированного строгого SBF ELF.

Однокомандные цели

Пользовательские цели собирают зависимости, а затем запускают CTest с параллелизмом, рассчитанным по CPU хоста:

Цель CMake	Выборка
`check-neverd`	Все зарегистрированные тесты
`check-neverd-semantic`	Только `NeverDSemanticTests`
`check-neverd-sbf`	Все цели/случаи `NeverDSBF*Tests`
`check-neverd-patch-full`	Только `NeverDPatchFullTests`
`check-neverd-switch-xform`	Только `NeverDSwitchXformTests`
`check-neverd-cfgloop-xform`	Только `NeverDCFGLoopXformTests`
`check-neverd-twotable-xform`	Только `NeverDTwoTableXformTests`

cmake --build build-release --target check-neverd
cmake --build build-release --target check-neverd-semantic
cmake --build build-release --target check-neverd-sbf

У NeverDIndCallXformTests и NeverDAvxUpperXformTests сейчас нет удобной цели check-neverd-*. Соберите их и выберите по метке, как показано ниже. check-neverd-semantic также не включает отдельные бинарники преобразований или patch-full; для полного агрегата используйте check-neverd.

Инкрементальный процесс CTest

Сначала соберите принадлежащий набору исполняемый файл, затем выберите его метку. Так не придётся перелинковывать посторонние большие семантические цели.

# Lifter, loader, and format tests
cmake --build build-release --target NeverDLiftTests --parallel 4
ctest --test-dir build-release --build-config Release \
  -L '^NeverDLiftTests$' --output-on-failure --parallel 4

# Main semantic binary
cmake --build build-release --target NeverDSemanticTests --parallel 4
ctest --test-dir build-release --build-config Release \
  -L '^NeverDSemanticTests$' --output-on-failure --parallel 4

# A label-only focused transform binary
cmake --build build-release --target NeverDIndCallXformTests --parallel 4
ctest --test-dir build-release --build-config Release \
  -L '^NeverDIndCallXformTests$' --output-on-failure --parallel 4

# Все целевые тесты/цели EVM
cmake --build build-release --target \
  NeverDEVMOpcodeTests NeverDEVMBytecodeTests NeverDEVMLoaderTests \
  NeverDEVMABITests NeverDEVMAnalyzerTests NeverDEVMDecoderPropertyTests \
  NeverDEVMProxyTests NeverDEVMCallTests NeverDEVMSemanticTests \
  NeverDEVMEmitterTests \
  NeverDEVMIntegrationTests --parallel 4
ctest --test-dir build-release --build-config Release \
  -R 'EVM' --output-on-failure --parallel 4

# Все целевые тесты/цели Solana SBF
cmake --build build-release --target check-neverd-sbf --parallel 4

Используйте имя CTest, полученное из GoogleTest, для одной регрессии:

ctest --test-dir build-release --build-config Release -N \
  -L '^NeverDLiftTests$'
ctest --test-dir build-release --build-config Release \
  -R '^COFFARMPipeline\.ARM32ThumbLiftAndDecompile$' \
  --output-on-failure

Полезные селекторы:

Команда	Назначение
`ctest --test-dir build-release -N`	Показать обнаруженные случаи без запуска
`ctest --test-dir build-release -L '<regex>'`	Выбрать метку тестового бинарника
`ctest --test-dir build-release -R '<regex>'`	Выбрать имена случаев
`ctest --test-dir build-release --output-on-failure`	Показывать диагностику только при ошибках
`ctest --test-dir build-release --stop-on-failure`	Остановиться после первой ошибки
`ctest --test-dir build-release --parallel 4`	Запускать до четырёх случаев параллельно

Обнаружение GoogleTest использует DISCOVERY_MODE PRE_TEST, поэтому соответствующий тестовый бинарник должен существовать до перечисления CTest. Таймауты случая и отдельного обнаружения определены в cmake/AddNeverD.cmake и могут увеличиваться только для наборов с измеренными тяжёлыми случаями.

Какие тесты должны меняться вместе с кодом?

Область изменения	Начать с	Затем рассмотреть
Lifter архитектуры или decode	Именованный случай в `NeverDLiftTests`	Семантический цикл соответствующей ISA
LowIR CFG, обнаружение функций, таблицы переходов	Случаи lift CFG/switch	`NeverDSwitchXformTests`, `NeverDCFGLoopXformTests` или `NeverDTwoTableXformTests`
MedIR, ABI, флаги, типы, SSA	Случаи lift MedIR/соглашения вызовов	Межархитектурные случаи `NeverDSemanticTests`
HighIR или структурированный C	Случаи HighIR/decompile	`NeverDCFGLoopXformTests` и проверка компиляции сгенерированного C
Loader PE/ELF/Mach-O или входной relocation	Соответствующий fixture формата в `unittests/lift`	Полностадийная проверка загрузки/декомпиляции ячейки
Rewrite codegen или выходной relocation	Случаи `RewriteCodegenRTTests`	`NeverDPatchFullTests` и слинкованный patch fixture при наличии
Преобразование LLVM IR для patch	Целевой бинарник преобразования	Сетка составных проходов `NeverDPatchFullTests`
C API или CLI	Прямой SDK/query-тест и `unittests/semantic/CLIEndToEndTests.cpp`	Соответствующий набор pipeline/формата
EVM loader, opcode, IR или backend	Минимальная ответственная цель `NeverDEVM*Tests`	Все цели EVM и компиляция сгенерированных C/Solidity
SBF loader, ISA, IR или backend	Минимальная ответственная цель `NeverDSBF*Tests`	Все цели SBF и компиляция сгенерированных C/Rust
Распознавание libc	`NeverDLibCTests`	Семантические случаи call/ABI при изменении поведения
Аудит жизни кучи или охота на переполнение копий	`NeverDSafetyTests`	Все шесть ячеек `NeverDSafetyIntegrationTests`
Запуск процессов или quoting	`NeverDTestProcessTests`	Один затронутый CLI/семантический случай на каждом поддерживаемом хосте

Тесты должны выражать контракт на самой низкой стабильной границе. Проверка формы LowIR полезна для привязки к lifter; семантический цикл обязателен, если две правдоподобные формы IR могут вести себя по-разному. Не используйте golden- дампы целых функций, когда достаточно небольшого утверждения об opcode, CFG или наблюдаемом состоянии.

Связь с CI

CI собирает Release с тестами на Linux, macOS и Windows, проверяет обнаруженный инвентарь, а затем применяет платформенные исключения меток. Профили определены в .github/workflows/ci.yml и scripts/audit_ci_test_inventory.py. NeverDSafetyTests и NeverDSafetyIntegrationTests обязательны на каждом хосте матрицы; каждый запуск читает одни и те же зафиксированные PE-, ELF- и Mach-O-fixtures для x86-64 и AArch64. Поскольку ни один shard матрицы не представляет все дорогие наборы, локальный check-neverd остаётся самым ясным полным сигналом перед merge на машине со всеми необходимыми cross-инструментами.

Текущий профиль соответствия и sanitizer для Solana SBF

Этот актуальный список заменяет сокращённый SBF-список выше. Suite source differential требует rustc помимо clang; пропуск compiler означает отсутствие coverage. Полный aggregate включает NeverDSBFProgramImageTests, NeverDSBFMalformedCorpusTests, NeverDSBFISAConformanceTests, NeverDSBFUpstreamConformanceTests, NeverDSBFLLVMDifferentialTests и NeverDSBFSourceDifferentialTests, а также targets metadata, loader, analyzer, semantic, emitter и integration. Интегрированный профиль записывает именованные targets и результаты, а не быстро меняющийся итог.

Sanitizer-профиль собирается отдельно в build-sbf-asan-ubsan. Prebuilt package, закреплённый на конкретной ревизии, содержит нужный fork-only header, поэтому integration идёт в том же fail-fast ASan/UBSan-профиле.

cmake --build build-sbf-asan-ubsan --parallel 4 --target \
  NeverDSBFMetadataTests NeverDSBFProgramImageTests NeverDSBFLoaderTests \
  NeverDSBFAnalyzerTests NeverDSBFISAConformanceTests \
  NeverDSBFVerifierTests NeverDSBFAgaveConformanceTests \
  NeverDSBFSemanticTests NeverDSBFEmitterTests NeverDSBFLLVMEmitterTests \
  NeverDSBFLLVMDifferentialTests NeverDSBFSourceDifferentialTests \
  NeverDSBFMalformedCorpusTests NeverDSBFUpstreamConformanceTests \
  NeverDSBFSolanaModelTests NeverDSBFIntegrationTests

ASAN_OPTIONS=abort_on_error=1:detect_leaks=0:strict_string_checks=1 \
UBSAN_OPTIONS=halt_on_error=1:print_stacktrace=1 \
NEVERD_SBPF_ROOT=/path/to/sbpf \
NEVERD_AGAVE_CONFORMANCE_ROOT=/path/to/firedancer-test-vectors \
NEVERD_AGAVE_CONFORMANCE_REVISION=68bb4af40235562e8852fa23d5727e49c2a0b862 \
ctest --test-dir build-sbf-asan-ubsan --output-on-failure --parallel 4 \
  -L '^NeverDSBF'

Закреплённый snapshot SBF-свидетельств (2026-08-24)

Gate фиксирует Anza sbpf на 2510663bb8d894e8e3094be351e4bb4b604f1f84, Agave на ef210d67f2fabeee1730498188fa78854260c679 и Solana SDK на 122f32e571ce39face4beffaccea733e37c207fd. Официальный ELF manifest проходит 23/23; NeverDSBFExternalOracleTests сравнивает 1,411 opcode/boundary-случаев через SBFOfficialOracleProtocol.def, SBFOfficialVerifierCases.def и SBFOfficialExecutionConstants.def. SBFOfficialELFMutations.def — табличный контракт malformed ELF; его меняющийся итог не фиксируется. Отдельный 41-case strict ELF differential прогоняет всю матрицу strict-v3 через официальный verify-elf-batch и NeverD; эти 41 случай не входят в итог 1,411.

Дополнительная официальная матрица исполнения остаётся отдельной: ровно 508 активных случаев (Version,Opcode) плюс 58 граничных случаев дают 566 случаев точного исполнения. Она не заменяет 1,411 verifier probes или 41-case strict ELF differential и не входит в их итоги. NeverDSBFAgaveConformanceTests аутентифицирует Firedancer test-vectors 68bb4af40235562e8852fa23d5727e49c2a0b862 и сверяет все 1,955 sol_compat_elf_loader_v1 fixture loader (1,399 приняты, 556 отклонены). Для каждого принятого ELF он сравнивает entry_pc, text_off, text_cnt, rodata_hash и calldests_hash. Этот gate не запускает последующий verifier инструкций. Linux Release CI использует --print-pinned-revision, --print-test-vectors-revision и --print-toolchain, экспортируя NEVERD_SBPF_ORACLE и NEVERD_AGAVE_CONFORMANCE_ROOT, поэтому оба внешних gate обязательны. Локально без явного oracle/corpus env случаи обнаруживаются, но могут быть пропущены.

SBF_RUNTIME_VERSION делает RuntimeVersionPolicy::ChainProfile зависимым от исторического cluster/slot: официальные feature accounts продвигают максимум ISA от V0 к V1, V2 и V3; сейчас он остаётся V3. Явный v4 использует RuntimeVersionPolicy::UpstreamToolchain для offline-анализа. Текущий предел 10 MiB равен ровно 10'485'760 байтам; 65,536 — лишь исторический provenance/test. SBFFaultCodes.def задаёт стабильные значения execution fault, а SBFSourceStatuses.def отдельно владеет ABI source.

Fixtures масштаба 10,000 защищают worklist, function ownership и multi-latch, не фиксируя машинное время. Строки cluster/account/slot позволяют RPC activation audit, сохраняя обычные тесты детерминированными и offline.

Производительность инвентаризации классов Android

Соберите NeverDMobileTests в Release и запустите его метку перед измерением neverd mobile INPUT --list-classes. Тесты средства чтения покрывают разреженные метаданные, Unicode, неверные ссылки, неподдерживаемые тела методов, контрольные суммы и бюджеты; тесты архивов различают полное извлечение и запросы выбранного содержимого. Тесты CLI проверяют фильтрацию по префиксу, границы JSON-отчёта, сохранность вывода и атомарность ошибок multidex.

Независимый инструмент генерации fixture и измерения проверяет полный инвентарь дескрипторов каждого процесса перед принятием временного образца:

python3 -m unittest scripts.tests.test_benchmark_mobile_inventory -v
python3 scripts/benchmark_mobile_inventory.py \
  --output-dir /tmp/neverd-inventory-benchmark \
  --class-count 6000 --dex-count 3 --code-units 64 \
  --extra-string-bytes 8388608 --resource-bytes 16777216 \
  --repetitions 7 --neverd build-release/bin/neverd

Для каждого запуска используйте новый каталог вывода. --generate-only записывает fixture и их манифест без измерений времени. --workload выбирает общие типы входа для необязательного --peer-command 'tool {input} {prefix}'; подготовка входа не входит в измеряемую команду. Отчёты сохраняют хеши, команды, все образцы новых процессов, допущения о прогретом кеше и, на Linux с GNU time, максимальный RSS дочернего процесса. Этот RSS не является совокупным пиком многопроцессного инструмента. Синтетические APK — контейнеры запросов, а не устанавливаемые приложения. Скорость инвентаризации не доказывает ни скорость поиска ссылок, ни качество восстановления Java.

На гибридных CPU закрепляйте инструмент и наследующие его настройки дочерние процессы за одним разрешённым CPU (например, taskset -c 4 python3 ... на Linux), чтобы не смешивать производительные и энергоэффективные ядра. Отчёт записывает унаследованную привязку к CPU.

Производительность поиска ссылок в коде Android

Запросы ссылок совместно используют границы инструкций и проверку кода средства чтения для восстановления. После изменения этой границы запускайте мобильный набор тестов. Тесты чтения покрывают виды пулов операндов, режимы сопоставления, принадлежность методов и общий код, похожие на ссылки payload/непосредственные значения, некорректные входы и ограничения ресурсов. Общие потоки отладки проверяются относительно кадра, протяжённости и параметров каждого тела-владельца. В покрытии лимитов памяти сохраняйте и большие инвентари членов, и тела с множеством переходов; постоянные индексы и рост временных контейнеров имеют разные сроки жизни. Также проверяйте переставленные и пересекающиеся элементы, общий код с несовместимыми прототипами одинаковой ширины, невыровненное размещение входа и подстроки, пересекающие границы поисковых блоков. Оптимизации внутренних данных декодера должны сохранять полные модели восстановления с собственными данными и мультимножества вхождений ссылок, включая ошибки на неподдерживаемых метаданных восстановления. Отличайте независимо сформированные ожидания от совпадения результатов разных инструментов на реальных входах.

Независимый инструмент для ссылок записывает ожидаемые вхождения при генерации инструкций. Он проверяет полные идентификаторы методов, PC в единицах кода, опкоды, идентификаторы целей, единицы UTF-16 и кратность при каждом измеряемом запуске. Он также проверяет независимо определённые ожидаемые счётчики покрытия NeverD и code_scan_complete:

NEVERD_REFERENCE_TEST_BINARY="$PWD/build-release/bin/neverd" \
  python3 -m unittest scripts.tests.test_benchmark_mobile_references -v
python3 scripts/benchmark_mobile_references.py \
  --output-dir /tmp/neverd-reference-benchmark \
  --class-count 500 --methods-per-class 64 --matching-methods 2 \
  --dex-count 3 --resource-bytes 16777216 \
  --repetitions 7 --neverd build-release/bin/neverd

Выбирайте случаи через --kind и --workload. --extra-strings 65536 проверяет настоящие 32-битные индексы строк. Ложные приманки в payload включены по умолчанию; --no-payload-lookalikes сохраняет ту же структуру и настоящие ссылки, заменяя значения приманок для сравнения на общих входах. Сохраняйте результаты проверки корректности и измерений времени. Запрос с ложными ссылками на payload или пропущенными настоящими ссылками не проходит проверку и не получает принятого временного измерения.

Необязательный --peer-command принимает шаблон argv с {input}, {kind} и {query}. Явно адаптируйте синтаксис запроса, если другой инструмент использует иную семантику, и сравнивайте полные мультимножества вхождений. Его заявленные границы проверки сохраняются без утверждения о полном сканировании кода. Действуют те же оговорки о новом каталоге, привязке к CPU, новых процессах, прогретом кеше и RSS, что и для инвентаризации. Необязательный модульный тест CLI пропускается, если NEVERD_REFERENCE_TEST_BINARY не указывает на собранный исполняемый файл; сообщайте об этом пропуске.

Свидетельства экспорта мобильных SDK

Ручной процесс Mobile SDK Export Evidence запускает collect_mobile_ios_sdk_declarations.py --exports-only для закреплённых SDK Xcode. Он сохраняет без изменений карты компоновщика Foundation, CoreFoundation и UIKit из SDK iOS для устройств и симулятора, записывая целевую платформу, версию SDK, хеш настроек SDK, размер файла и SHA-256. Обычный сборщик объявлений также сохраняет эти карты. Отсутствующие, пустые, слишком большие файлы и файлы вне SDK приводят к ошибке сбора; уже полученные свидетельства сохраняются. Карты подтверждают экспорт символов, но не доказывают ABI вызова или восстановление метода.

Доказательства ABI мобильных строк Swift

Ручной процесс Mobile Swift String ABI Evidence компилирует фиксированные пробы равенства и порядка на Swift и пробу C с swiftcall с помощью Xcode 26.5 для устройств iOS и симуляторов arm64. collect_mobile_swift_string_abi.py сохраняет исходники, LLVM IR, ассемблер, идентификацию компиляторов, настройки SDK и libswiftCore.tbd вместе с хешами. Оба языка должны показать точный импорт сравнения с пятью аргументами и результатом i1; C должен явно расширять этот результат до байта. Неверные цели, изменённые сигнатуры, ошибки команд и тайм-ауты сохраняют частичные доказательства и завершают сбор с ошибкой. Эти данные не устанавливают объявление среды выполнения и не доказывают восстановление методов. Проверка сборщика без SDK: python3 -m unittest scripts.tests.test_mobile_swift_string_abi.

Модульное упрощение MBA

SymSimplifyFinite.* проверяет полные двухзначные области шириной от 8 до 512 бит, стоимость общих использований, все поддерживаемые аннотации, способные создавать poison, независимые чтения volatile и freeze, явные undef/poison, глубокий итеративный обход, бюджеты и метку обфускации. Исходный и упрощённый IR выполняются при O0/O2 с независимой проверкой всех байтовых входов и случайных входов полной ширины. Тесты объектов трансляции требуют различных идентификаторов кеша для различных бюджетов конечных значений.

Тесты объединённых областей покрывают вложенные select, ромбовидные PHI и циклы копирования на 8–512 бит; конфликтующие обратные рёбра, неопределённые условия, компоненты без источника, независимые наблюдения PHI/freeze и сохранение источников с флагами; точные границы узлов, рёбер и работы. Эталоны O0/O2 перебирают все пары байтов и меняют полноразрядные операнды для выбора, слияния и ограниченных циклов состояния.

Тесты двух значений также проверяют вложенные маски конъюнкций на 8–512 бит, перестановку операндов, отказ для OR/undef, ограниченный глубокий поиск, отдельный учёт работы, метку обфускации и точный бюджет первой замены. Эталоны перебирают все пары байтов и меняют посторонние 64-битные данные, сравнивая исходный и упрощённый IR при O0/O2.

SymSimplifyPredicates.* полностью перебирает четырёхбитные смещения, знаки и входы, проверяет булевы комбинации интервалов и несвязные множества, запускает независимые байтовые и полноразрядные оракулы при O0/O2. Покрыты аннотации poison, скрытые неопределённые входы слияний, независимые чтения/freeze, сохранённые PHI циклов, выгода общих использований, суммарный бюджет, большое число использований, предел рекурсии и метка обфускации. Оба ключа кеша различают бюджеты анализа предикатов.

SymExpr.* проверяет постоянные срезы выше младшего бита полным перебором четырёхбитных входов и масок, а также широкие значения, вложенные структуры, сборку известных и неизвестных байтов и контрпримеры с переносом. Бюджетные тесты помещают широкий узел на границу рекурсии и запрещают копирование слишком большой константы. Неизвестные срезы должны оставаться символическими без расширения DAG. SymState.* также различает выведенные скалярные константы и литеральные факты областей памяти для обоих порядков байтов, не увеличивая DAG и не меняя целые сохранённые слова.

SymReadability.* проверяет запись вычитания и дополнения, стоимость ассоциативных операторов, однобитные и широкие литералы, насыщение общих деревьев, выбор кандидатов с бюджетом и полный перебор трёхбитной эквивалентности без выборки. SymMBASample.* сравнивает узкую и произвольно-точную проверку с вычислителем AP для всех операторов, детерминированных присваиваний и неиспользуемых широких входов. При сравнении качества между версиями оценки оба результата нужно пересчитать одной метрикой; версионные счётчики размера SDK служат только диагностике.

Матрица тестов ARM32 и продвижения значений кадра

cmake --build build-release --target NeverDSymbolicTests \
  NeverDSymSimplifyGuardTests NeverDLiftTests NeverDMBASourceTests \
  NeverDHighCStoreForwardingTests NeverDMetadataJSONTests --parallel 4
build-release/bin/NeverDSymbolicTests
build-release/bin/NeverDSymSimplifyGuardTests
build-release/bin/NeverDLiftTests \
  --gtest_filter='HighSymSimplify.*:HighFrameStoreForwarding.*:ELFARM32ModeTest.*'
build-release/bin/NeverDHighCStoreForwardingTests
build-release/bin/NeverDMBASourceTests
build-release/bin/NeverDMetadataJSONTests --gtest_filter='ELFARM32ModeCAPITest.*'

Матрица spill охватывает также x86-32 (ELF/COFF/Mach-O), ARM32 (ARM и Thumb ELF) и AArch64 (ELF/COFF/Mach-O) в обоих C-бэкендах. Повторные чтения из приватного кадра должны сводиться к сложению или вычитанию и правильно исполняться для пар байтов, границ слов и детерминированных случайных слов на обоих уровнях оптимизации. Проверки Clang AST просматривают функции целиком на оставшиеся MBA-операторы, отличая допустимые адресные выражения. HighFrameStoreForwarding проверяет ширины доступа, изменения локальных переменных, записи памяти, псевдонимы, перекрытия, упорядоченную память, некорректные графы и бюджеты развёртки. HighCStoreForwarding сохраняет определения кешированных значений живыми для четырёх архитектур, в том числе при интерпретации как float; SymSimplifyGuard проверяет идентичность и порядок загрузок, volatile/atomic и границы poison. ELFARM32ModeTest проверяет выбор ARM/Thumb, нормализацию адресов, смешанные метаданные и отказ при противоречии. ELFARM32ModeCAPITest проверяет явные ошибки SDK и восстановление декодера после повторной загрузки Thumb; InstructionMode охватывает границы декодера, указателей на код, ветвлений и кодогенерации. Отсутствие кросс-целевого Clang означает пропуск, а не доказательство поддержки формата.

HighBoundPrivateFrameCopies.* в NeverDHighControlFlowTests проверяет копирование через приватные слоты стека без утечки адресов после привязки ABI вызовов, включая ветвления, повторное использование слотов и согласованность фактов в разных контекстах условий. Сгенерированный C для x64 и AArch64 выполняется с -O0 и -O2, с ловушками для неопределённого поведения и независимыми арифметическими проверками. Негативные случаи требуют сохранить исходную функцию при утечке адресов кадра, неизвестном ABI, отсутствующих или противоречивых псевдонимах кадра, перезаписи входных параметров, перекрывающихся обращениях, упорядоченной или атомарной памяти, некорректных операторах, циклах и исчерпании бюджета. Обычные преобразования значений не должны становиться копиями PHI.

После этой очистки проекция исходного кода также повторно проверяет списки объектов переменной длины: пустые привязки к адресам инструкций допускаются, скрытые эффекты и переходы управления отклоняются. Синхронизированная очистка допускает одно представление int64_t или uint64_t того же сохранённого получателя; сужение, преобразования с плавающей точкой, адресная арифметика и повторные присваивания по-прежнему отклоняются. Множества объектов Foundation и трассы обычного и исключительного снятия блокировки выполняются при -O0 и -O2.

Нативные синхронные исключения x64

Checked x64 выполняет DIV/IDIV с реальными результатами процессора и #DE. KVM использует закрытые supervisor IDT/IST, WHP — явную маску исключений; исходный контекст и доступные коды отделены от ошибок транспорта. ОС получает восстанавливаемое событие перед установкой продолжения. Windows-драйверы преобразуют деление на ноль и переполнение частного в STATUS_INTEGER_DIVIDE_BY_ZERO, выполняя настоящие SEH-фильтры, __finally и повтор инструкции. NeverDX64ExceptionTests собирается без Unicorn; DriverWDMCPUException проверяет исходные WDK-примеры. Недоступные ARM64-хосты явно пропускаются.

Подготовленные эффекты RAM

RAMTransaction сохраняет только физическое объединение заявленных диапазонов записи инструкции под блокировкой выполнения. До вызова наблюдателей результата исходная RAM восстанавливается; отмена, ошибка транспорта или исключение наблюдателя не публикуют частичные изменения RAM и регистров. После отката RAM ошибки CPU сохраняют архитектурное состояние исключения. Одиночные и парные записи ARM64 используют тот же механизм. x64 выполняет XCHG, XADD и CMPXCHG шириной 8/16/32/64 бит; формы с LOCK или неявной блокировкой требуют естественного выравнивания. NeverDRAMTransactionTests сравнивает результаты с CPU хоста и проверяет откат, алиасы и права; недоступные платформы явно пропускаются. Устройства и параллельный SMP не входят в контракт. Снимки CPU не откатывают уже подтверждённую RAM.

CMPXCHG8B и CMPXCHG16B исполняют исходные инструкции в KVM, WHP и checked Unicorn в профилях драйвера и пользователя. При любом результате сравнения нужны права чтения и записи; ошибки доступа классифицируются как запись. CMPXCHG16B проверяет выравнивание на 16 байт до обращения к памяти и при нарушении сообщает #GP(0). Два уведомления о результате принадлежат одной транзакции RAM: остановка или исключение в любом из них не публикует изменения регистров и памяти. CMPXCHG8B без блокировки может пересекать страницы; заблокированные операнды по-прежнему требуют естественного выравнивания. X64WideAtomicTests.cpp сравнивает исходное исполнение на хосте и прямые аппаратные ошибки, проверяет псевдонимы, префиксы, адресацию, исправление и отмену. Собственные фикстуры драйвера Windows и PE ring3 исполняют обе ширины; фикстура WDK также исполняет _InterlockedCompareExchange128. Модель CPU должна поддерживать CMPXCHG16B.

Полное состояние x87

NeverDEmulationArch владеет контрактами ISA, таблицами страниц и форматом FP, общим для нативных транспортов и Unicorn. Контексты x64 сохраняют управление, статус, TOP, физические теги, код операции, указатели инструкций/данных и восемь 80-битных регистров. FP0–FP7 используют RegisterValue; скалярный доступ отвергает усечение. FPTag — физическая маска непустых регистров. NeverDX64FPTests проверяет все TOP, точные операции по FXSAVE/FXRSTOR хоста и восстановление. Это не разрешает инструкции x87 в checked и не доказывает всю семантику округления. Недоступные нативные хосты явно пропускаются.

driver-strict поддерживает KVM на совместимых хостах Linux x64 и WHP на Windows x64; auto выбирает этот нативный транспорт, а другая ISA использует Unicorn. Явный Unicorn и прежний API V1 сохраняют переносимый программный профиль. Нативное выполнение проверяет канонические адреса и эффекты до входа; недоступное оборудование вызывает ошибку без подмены. Неподдерживаемые инструкции и поведение OS завершаются явной ошибкой. Нативная CI для Windows x64 с отключённым Unicorn проходит все 359 обязательные проверки: 131 проверок CPU, 224 результата драйверов из 26 встроенных образов, 46 образов WDK и 40 сценарных вариантов по предпочтительным и перемещённым адресам, а также четыре проверки границ SEH (9d4c130c). Нативные свидетельства ARM64 ещё отсутствуют; совместимость произвольных драйверов или Android/Darwin не установлена.

Приведённая выше нативная проверка охватывает объявленные точки входа драйверов и опубликованные сценарии. Для описанных ниже подробных проверок отдельных функций и C API/CLI/Python свидетельства по-прежнему ограничены Linux, если выполнение в Windows не указано явно; успешное прохождение нативного корпуса не подтверждает все варианты тестов в Windows.

Выбранный профиль можно запросить через executionCapabilities(Contract, ISA, Backend). NativeLegacyX64 описывает нативное выполнение драйверов x64. NeverDNativeDriverTests проверяет существующий набор драйверов и работает также в сборке без Unicorn.

Существующий workflow CI выполняет все тесты эмуляции до общих профилей и сохраняет список обнаруженных тестов, результаты JUnit и журнал CTest в emulation-focused. Ошибка другого модуля не препятствует этому запуску. Недоступное оборудование и отсутствующие необязательные драйверы явно отмечаются как пропущенные; успешная программная эмуляция или компиляция не доказывает нативное выполнение.

В Linux NeverDUnicornDeadlineTests с помощью управляемого планирования pthread завершает настоящий поток таймера до входа в гостевой код. Для x64, ARM32 и ARM64 он проверяет отсутствие гостевых эффектов после предварительной отмены и независимый бюджет следующего запуска. Используются публичные API без изменения внутреннего состояния движка.

X64StateTransition в NeverDX64ExceptionTests выполняет независимые чтения RAM и CR8 на нативном CPU. Он чередует базы TLS и уровень привилегий, возобновляет исполнение после повторных ошибок деления и меняет TLS после отменённого входа. После изменения передачи нативного состояния запускайте соответствующую метку CTest вместе с проверками переназначения алиасов, контекстов CPU, состояния FP и результатов исходных драйверов. Недоступный транспорт KVM/WHP остаётся явным пропуском.

NeverDKvmRunTests проверяет заимствованные функции передачи в KvmRunControl без /dev/kvm. StateTransfersUseTheEntryThreadAndPrepareOnceAcrossRetries проверяет общий поток подготовки, чтения и перехваченного входа на хосте, а также однократную подготовку при повторах после прерываний. Другие случаи проверяют ошибку подготовки без входа, ошибку чтения, остановку при подготовке и отмену активного входа; следующий запуск не должен повторно использовать старые функции. Сохраните в проверке наборы реальной отмены, отката RAM, исключений и исходных драйверов. SequentialEntriesReuseWorkerWithoutRetainingPriorTransfers проверяет, что несколько входов с одним сроком повторно используют поток, выполняют каждую передачу один раз и не меняют предыдущие пакеты состояния.

KvmHandoffPolicy ограничивает каждое активное ожидание 8 μs, после двух неудач подряд переходит к блокирующему ожиданию и повторяет попытку через 256 передач. Вызывающий и рабочий потоки адаптируются независимо; вызывающий поток также соблюдает исходный срок и токен остановки. Атомарные флаги готовности служат лишь подсказками планировщику: пакеты, время жизни обратных вызовов и подтверждение отмены по-прежнему защищены мьютексом. NeverDKvmRunTests проверяет ограничение бесполезного опроса, восстановление, изменение задержек и отмену до повторного использования пакетов.

KVM x64/ARM64 использует KvmRunControl для подготовки, входа в KVM_RUN и захвата состояния на одном выделенном потоке vCPU. Подготовка выполняется один раз даже при EINTR; отмена и ошибка чтения запрещают публикацию. KvmAArch64Machine.cpp выполняет обслуживание трансляции и полные скалярные/векторные передачи с одним сроком шага. Вызывающий поток публикует после подтверждения и владеет декодированием ISA, транзакциями RAM, политикой ОС и наблюдателями. Нативные свидетельства ARM64 ещё отсутствуют.

ReusesCapturedStateAndInstallsHostChangesAcrossFaultsAndStops проверяет продолжение и реальные записи CPU после изменения хостом общих регистров, первого и последнего XMM, MXCSR и управления x87. Реальные байты FXSAVE64 проверяют все физические 80-битные регистры, TOP, теги, код операции и указатели после остановленного входа; повторные ошибки деления тоже запрещают повторное использование. Эти машинные тесты не разрешают дополнительные инструкции x87 в профилях checked.

NeverDKvmStateTransferTests внедряет ошибку чтения регистров или XSAVE после реального исполнения KVM и повторяет неизменённый ввод. Независимые целочисленные результаты и результаты упакованных байтов доказывают, что неудачное чтение не использует уже продвинувшееся нативное состояние. Только этот тестовый файл оборачивает ioctl; недоступные нативные хосты явно пропускаются.

NeverDKvmStateTransferTests проверяет на реальном KVM отсутствие, отдельную и совместную поддержку наборов KVM_CAP_SYNC_REGS, а также сбой запроса. SynchronizedCapturesRemoveOnlySupportedReadIoctls считает реальные чтения и проверяет всё состояние CPU после последовательных шагов. CancelledWarmEntryRequiresFreshSpecialStateOnRetry требует нового чтения специальных регистров после отмены. Сбои захвата, повторные целочисленные/SIMD операции, откат спекулятивной RAM и приоритет исключений проверяются в той же матрице; недоступные нативные проверки явно пропускаются.

Checked ARM64 использует единую границу полного состояния. Registers.def задаёт 39 скалярных полей и 32 вектора по 128 бит; captureAArch64State сначала читает всё, применяет ширины и нормализацию NZCV, затем публикует один раз. Unicorn, KVM, WHP и HVF передают один набор, включая TPIDR_EL0, TPIDRRO_EL0, TPIDR_EL1, FPCR и FPSR. Нативные адаптеры включают FP/SIMD через CPACR_EL1. Ошибка чтения или отмена входа сохраняет всё состояние вызывающей стороны.

Запуск ARM64 KVM/WHP/HVF выполняет частную программу AArch64MachineProbe.def: NOP, сложение FP32 с округлением к положительной бесконечности и сложение SIMD в двух каналах. Каждый шаг сравнивает все 39 скалярных полей и 32 вектора, включая TLS, NZCV, обнуление верхних битов результата и сохранённое/накопленное состояние FPCR/FPSR. Проверка использует только память монитора supervisor и один общий срок. Проверки подтверждают только ограниченную инициализацию. Проверка нагрузок Linux ARM64 KVM и Windows ARM64 WHP ещё не завершена; нативные результаты macOS приведены в руководстве HVF. Программа также включает подпись и аутентификацию адресов возврата A/B при отключённых ключах и все четыре формы BTI на незащищённых страницах.

Проверка также дважды выполняет MRS CTR_EL0, затем DC CVAU, DSB ISH, IC IVAU и ISB, проверяя стабильность геометрии кэша и полное состояние. Checked EL0/EL1 допускает исходные инструкции, все именованные базовые варианты DSB и только ISB SY. CTR считывается из выбранного виртуального CPU и может различаться между транспортами. Цели должны указывать на обычную RAM, доступную для чтения с текущими правами; допустимы невыровненные адреса и алиасы, остальные цели отклоняются как неподдерживаемые. Обслуживание кэша не создаёт событий чтения/записи данных. Проекция сохраняет когерентность исполнения, не моделируя частные кэши или параллельный аппаратный SMP. NeverDAArch64CacheTests проверяет состояние, концы страниц только для чтения, отказы, остановки, контексты, бюджеты и обновление гостевого кода через RW/RX-алиасы на двух страницах. Недоступные KVM/WHP явно пропускаются.

Нативная инициализация x64 KVM/WHP/HVF исполняет X64MachineProbe.def в закрытых supervisor-страницах. Единый срок охватывает NOP, FP32-сложение с округлением к положительной бесконечности, двухполосное SIMD-сложение, загрузки FS/GS и чтения CS/SS/CR8; каждый шаг сравнивает полное скалярное состояние, XMM, физические x87 и управляющие поля. Проверки x64 и ARM64 требуют исключительного права исполнения физической памяти. MemoryProjection владеет идентичностью кеша (ISA, адресное пространство, поколение отображений, привилегия и вариант монитора) и историей подтверждённых корней для каждой ISA. Перед перезаписью кеш инвалидируется: неудачная замена не использует частично записанные таблицы, а вызывающая сторона не передаёт устаревшие корни. Проверки подтверждают только ограниченную инициализацию. Проверка нагрузок Linux ARM64 KVM и Windows ARM64 WHP ещё не завершена; нативные результаты macOS приведены в руководстве HVF.

Общий декодер XSAVE различает начальное состояние SSE в стандартном и компактном форматах. При сброшенном XSTATE_BV[1] оба формата инициализируют XMM; стандартный по-прежнему читает и проверяет MXCSR, а компактный инициализирует MXCSR. X64XsaveCases.def содержит независимые схемы пакетов и оригинальные программы XRSTOR для хоста. X64XsaveTests.cpp проверяет атомарный отказ и сравнивает оба формата с реальным выполнением, сохраняя FP/SSE вызывающей стороны. При неподходящей архитектуре или отсутствии нужной функции инструкций проверка на хосте явно пропускается.

X64FPState.def задаёт компактные транспортные схемы AVX, AVX-512, CET_U/CET_S и AMX с выравниванием компонентов на 64 байта. Присутствующие данные расширений должны соответствовать нулевому начальному состоянию; отсутствующие компоненты и заполнение не определяют состояние. Биты схемы задают смещения; неизвестная схема, неначальные данные или неверная длина отвергаются до публикации. CompactedOffsetsFollowLayoutRatherThanPresentBits, WideLayoutIgnoresAbsentComponentsAndAlignmentPadding, InitialCETComponentsDoNotHideFPState и InitialWideComponentsDoNotHideFPState проверяют пакеты WHP на 872 и 10752 байта. Такой транспорт не разрешает выполнение инструкций расширений.

WhpXsaveRegisters.def дополняет полные пакеты XSAVE именованными регистрами управления x87/SSE. Последний код операции и указатели инструкции/данных явно записываются и считываются с хоста. Нулевые поля пакета можно дополнить; конфликт ненулевых метаданных или общих управляющих полей вызывает ошибку до публикации. NamedMetadataRestoresOmittedPacketFields проверяет пропущенные поля, сохраняя все данные FP.

Нативные FOP/FIP/FDP следуют правилам сохранения x87 хоста. AMD может обнулять их без ожидающего немаскированного исключения; снимки сохраняют наблюдаемые значения. X64MachineProbe.def и точные тесты NOP/контекста задают согласованное ожидающее исключение, чтобы сравнивать все действительные поля без маскирования различий. Эталон FXRSTOR64/FXSAVE64 в процессе хоста проверяет оба состояния; бэкенды никогда не подменяют результаты хоста входными метаданными.

NativeGuestRAMDistinguishesEntryFromCaptureLoss сравнивает полное состояние FP/SSE, сохранённое гостевой FXSAVE64 в RAM, с результатом XSAVE хоста. Обе API проверяют прямую установку и гостевую FXRSTOR64 с настройкой сохранения указателей по умолчанию и явно выбранной поддерживаемой настройкой хоста. Тест различает вход, выполнение и захват, не исправляя значения; расхождение остаётся ошибкой. Матрица также проверяет ожидающее немаскированное исключение x87 и записывает эталон FXRSTOR64/FXSAVE64 из процесса хоста и производителя процессора, различая условное сохранение указателей и поведение транспорта WHP.

Общий кодек encodeX64XsaveState / decodeX64XsaveState владеет стандартными и уплотнёнными FP/SSE-пакетами, физическим вращением TOP, начальным состоянием отсутствующих компонентов и атомарной проверкой. WHP использует полные XSAVE API, предпочитая WHvGetVirtualProcessorState / WHvSetVirtualProcessorState, а прежние XSAVE API оставляет для совместимости. Отдельные старые регистры x87 не заменяют полные пакеты. Расширенные компоненты не в начальном состоянии, неверные заголовки, управляющие значения и усечённые результаты явно отклоняются. Ошибки отображений WHP сохраняют HRESULT, GPA и размер для диагностики.

CheckedX64Instructions.def допускает беззнаковое MUL шириной 8/16/32/64 бита и CBW/CWDE/CDQE/CWD/CDQ/CQO через существующий транспорт CPU. NeverDX64IntegerTests использует независимые кодировки и ожидаемые значения из X64IntegerCases.def на обоих уровнях привилегий: сохранение незатронутых частей регистров, расширение нулями при 32-битной записи, обе половины произведения, определённые CF/OF и неизменность флагов при знаковом расширении. Умножение в обычной RAM сохраняет проверку прав всего диапазона и наблюдателей чтения; ошибка или остановка наблюдателем сохраняет неявные выходные регистры и PC. Операнды устройств не поддерживаются. Эти случаи также выполняются в checked Unicorn; недоступные нативные транспорты явно пропускаются.

X64BitInstructions.def допускает BT/BTS/BTR/BTC для регистров и обычной RAM разрядностью 16/32/64 бита. Регистровый индекс трактуется как знаковое значение ширины операнда и выбирает целое слово; непосредственный индекс остаётся в базовом слове. Усечение до ширины адреса выполняется перед прибавлением базы FS/GS. Процессор формирует CF и записываемые значения; RAMTransaction не публикует результат до принятия наблюдателями. Права проверяются для всего диапазона, включая отдельно выделенные страницы и псевдонимы. Остановка, ошибка callback или отказ в доступе сохраняют исходные CPU и RAM. LOCK ограничен естественно выровненными изменениями памяти; MMIO и параллельный аппаратный SMP не поддерживаются. X64BitStringTests.cpp сравнивает независимые кодировки с реальным исполнением на x64 и проверяет отрицательные индексы, усечение ширины, границы страниц, отмену и недопустимые формы LOCK. См. справочник Intel.

X64StringInstructions.def задаёт MOVS/STOS/LODS для обычной RAM шириной 8/16/32/64 бита; CLD/STD меняет только флаг направления. Каждый элемент REP проверяет весь операнд до вызовов наблюдателей и фиксируется на границе возобновления. Последующий сбой сохраняет завершённые элементы; остановка или исключение наблюдателя не меняет текущий элемент. FS/GS прибавляется только к источнику после усечения адреса. Загрузка AL/AX сохраняет старшие биты, EAX обнуляет их. При нулевом счётчике REP и 32-битной адресации старшие биты счётчика, а для MOVS/STOS также используемых адресов, должны быть нулевыми: иначе реальные процессоры дают разные результаты. REPNE для MOVS/STOS/LODS и обращения STOS/LODS к устройствам пока не поддерживаются. X64StringTransferTests.cpp сравнивает ширины, направление, перекрытия и нулевые счётчики с независимыми инструкциями хоста, проверяя также права, псевдонимы, циклическую адресацию, сбои и возобновление. Оригинальный драйвер ресурсов WDK выполняет все четыре ширины STOS/LODS через driver_resource_strings.def.

X64StringInstructions.def также задаёт CMPS/SCAS для обычной RAM шириной 8/16/32/64 бита с REPE/REPNE. Каждый элемент проверяет все чтения до наблюдателей, обновляет шесть арифметических флагов и останавливается при первом условии завершения. Ошибка данных восстанавливает флаги начала непрерывного REP, сохраняя изменения указателей и счётчика завершённых элементов; публичное возобновление начинается с опубликованного состояния CPU. Остановка и исключения наблюдателей не меняют текущий элемент, досрочное завершение не читает следующий. FS/GS действует только на источник CMPS; SCAS сохраняет аккумулятор и неиспользуемый регистр источника. Устройства и неоднозначные старшие биты при нулевом 32-битном счётчике исключены. X64StringComparisonTests.cpp сравнивает независимые инструкции хоста, флаги, направление, псевдонимы, циклическую адресацию, права и восстановление; сигнальный тест Linux x64 фиксирует регистры реального сбоя. Оригинальный драйвер WDK выполняет оба условных повтора во всех четырёх ширинах через driver_resource_strings.def. См. справочник Intel. Нативный оракул Linux проверяет ошибки до и после первого элемента. Он различает восстановление исходных flags на Intel и flags последнего сравнения, наблюдавшиеся на AMD EPYC 7763 под Hyper-V (нативные наблюдения); неизвестный производитель CPU вызывает явную ошибку. Checked-гости восстанавливают исходные flags на всех бэкендах.

Существующие CPU WHP используют один нативный раздел; его окончательное закрытие и повторное создание защищены общей блокировкой реестра. WhpResourceCache.h повторно использует кооперативный VP 0; перед сменой логического CPU этот VP и его отображения удаляются. Параллельные CPU сохраняют отдельные VP и диапазоны GPA. Передача регистров, XSAVE и отмена адресуются своему VP. x64 сохраняет стандартный набор XSAVE хоста и проверяет фактическую конфигурацию через WHvGetPartitionProperty. По умолчанию планирование остаётся кооперативным.

NeverDX64FPTests проверяет все 79 позиций повреждения и нативно исполняет независимо собранные инструкции X64ProbeCases.def с единым сроком и неизменной гостевой RAM. NeverDProjectionCacheTests охватывает смену вызывающей стороны, порядок ISA, историю корней, варианты привилегий/монитора, поколения, идентичность пространств и неудачную замену. NeverDRunControlTests включает WhpXsaveTests.cpp для новых и прежних API-пакетов, каждого TOP, границ размера и неизменного состояния при ошибках; такие проверки протокола в памяти не подтверждают нативный WHP. Недоступные нативные транспорты явно пропускаются.

Диагностика XSAVE различает запрос размера, локальную подготовку и декодирование полученного пакета. Она сохраняет имя API, число возвращённых байтов, ёмкость и ограниченные поля заголовка и управления; независимые ожидания находятся в WhpHostFailureCases.def, содержимое регистров гостя не выводится. InvalidInputReportsPreparationWithoutHostMutation также проверяет, что недопустимый ввод не вызывает хост и не меняет его пакет. Общий кодек ISA остаётся единственным источником правил валидации.

Ошибки хоста WHP при запросах возможностей, настройке разделов/виртуальных CPU, передаче регистров/XSAVE и выполнении сохраняют HRESULT и имя API из WhpProtocol.def; неудачные запросы возможностей сохраняют типизированный результат недоступности. WhpHostFailureCases.def задаёт независимые ожидания для ошибок хоста одновременно с отменой, а также ошибок запроса, установки и захвата состояния через новые и прежние API XSAVE. Специализированный Windows CI требует 210 нативных успехов: 16 проверок отображения, две запуска, десять FP/контекста, семь общих CPU, восемь целочисленных и оба варианта API NativeInstallRetainsFPStateBeforeAnyGuestExecution. Последние сравнивают полное FP/SSE и отдельно прочитанные метаданные до исполнения гостевого кода. Отсутствие регистрации, пропуск, отключение или невыполнение теста приводит к провалу аудита нативных свидетельств. Дополнительные 26 проверок охватывают все случаи из X64BitStringTests.cpp на обоих уровнях привилегий. Windows PE64 требует 67 проверки процессов WHP и одиннадцать независимых сравнений с нативным Windows.

NeverDMemoryLifecycleTests собирается независимо от Unicorn, в том числе в конфигурациях только с нативными бэкендами. Специальные программные проверки проекций и устройств явно пропускаются при отключённом Unicorn; проверки совместного использования CPU на соответствующем хосте остаются зарегистрированными. WhpMemoryTests.cpp изолирует нативный API памяти с помощью 16 случаев из WhpMemoryCases.def: размер страницы или проекции, общие или отдельные выделения, нетронутые или резидентные байты, наличие или отсутствие первого виртуального процессора. Каждый случай сохраняет двух логических владельцев, многократно переключает их отображённый раздел, удаляет неактивного владельца и проверяет работу оставшегося отображения без повторного создания. Реальные ошибки сохраняют HRESULT и приводят к провалу теста; это свидетельство работы API памяти, а не доказательство исполнения инструкций.

X64MachineProbe.def указывает сбойную инструкцию запуска и все различия скаляров, TLS, привилегий, управляющих полей x87, физических каналов FP и слов XMM с ожидаемыми и полученными значениями. DiagnosticIdentifiesStepFieldAndBothValues проверяет независимые эталонные сообщения. Сравнение остаётся точным: диагностика отделяет потерю при передаче от ошибки исполнения и не засчитывает неудачную нативную проверку как успешную.

WhpResourceTests.cpp проверяет повторное использование, удаление до замены, восстановление после ошибок и гонки с отменой или сроком. LogicalCPUSwitchingRestoresPhysicalFPAndTLS чередует две машины в обоих режимах привилегий, проверяет независимые физические состояния x87/XMM и FS/GS и возобновляет оставшуюся машину после удаления другой. Windows CI требует оба случая WHP.

NEVERD_ENABLE_SEMANTIC_TESTS по умолчанию равен ON и управляет группой в unittests/semantic и её агрегатными целями. Чтобы собрать нативные тесты CPU без Unicorn, оставьте BUILD_TESTING=ON и задайте NEVERD_ENABLE_SEMANTIC_TESTS=OFF вместе с NEVERD_EMULATION_BACKEND_UNICORN=OFF. Нативные тесты KVM/WHP остаются доступны, в том числе для Windows ARM64/MSVC с подходящими заголовками SDK. Для Unicorn на Windows ARM64 по-прежнему требуется инструментарий ARM64 LLVM-MinGW. Это разделение сборки не подтверждает нативное исполнение ARM64.

CI нативного CPU инициализирует исходники Capstone фиксированной ревизии и использует проверенный готовый пакет LLVM. При NEVERD_ENABLE_SEMANTIC_TESTS=OFF и отключённом адаптере Unicorn настройка, сборка и компоновка тестов CPU не требуют исходников Unicorn. Подписи и внешний корпус также не нужны. Стандартный CI сохраняет полную группу семантических тестов.

Ручной профиль native_cpu_only в ci.yml выбирает Windows x64 через native_cpu_backend=whp (по умолчанию) или Ubuntu x64 через native_cpu_backend=kvm. NativeCPUTests.def объединяет требования CPU/процессов и отдельно объявляет цели и случаи конкретного транспорта. run_native_cpu_ci.py --require-whp или --require-kvm проверяет хост, собирает все цели до CTest и сохраняет инвентарь, JUnit, журналы и число результатов каждого типа. Отсутствующие или пропущенные обязательные случаи приводят к ошибке даже при успешном завершении CTest. CI отключает Unicorn; --with-drivers требует тот же корпус по исходным и перемещённым адресам на выбранном транспорте. Компиляция и проверки инициализации не доказывают выполнение гостя или приёмку ARM64. Профиль Ubuntu использует подписанные пакеты Clang/LLD 21 от проекта LLVM; объявления CR8 в Clang 18/19 несовместимы с закреплёнными заголовками WDK. Нативная проверка Linux использует CMake 4.2.3, чтобы комментарии параметров GoogleTest не попадали в имена тестов CTest.

Приёмка KVM требует отмены настоящего vCPU без самостоятельного выхода и 48 результатов передачи состояния из KvmStateTransferCases.def, включая чтение через ioctl и ошибки запросов необязательных возможностей. Дополнительные режимы синхронизированных регистров выполняются при поддержке хоста, иначе явно пропускаются. Стабильные имена параметров не зависят от номеров ioctl и формата кортежей. Протокольные тесты дополняют нативное выполнение, но не заменяют его.

native-host-probe.yml запускает отдельный probe_native_host.py на размещённых runner Linux и Windows x64/ARM64. NativeHostProbe.def задаёт порядок проверки возможностей, создания VM/vCPU и освобождения ресурсов. Отчёты сохраняют хеши исходников/бинарников, нативную ISA и коды состояния всех операций. setup_ready подтверждает только настройку; гостевые инструкции не выполняются. Отсутствующие возможности API/устройства дают unavailable; ошибки сборки, настройки, освобождения, тайм-ауты и неверный формат свидетельств проваливают задание. Доступность ARM64 проверяется при каждом запуске; эта проба не подтверждает приёмку нагрузок ARM64. Оба workflow Linux используют prepare_kvm_ci.py, предоставляя доступ к существующему символьному устройству KVM только текущему аккаунту размещённого runner и сохраняя идентификатор и права устройства. Локальные и собственные runner отклоняются; отсутствующее устройство не создаётся.

windows-alignment-oracle.yml использует check_windows_alignment.py и WindowsAlignmentCases.def для сбора 72 независимых наблюдений исключений Windows x64: девять выровненных форм SSE, каждая в семи случаях невыровненного адреса/прав доступа и одном контрольном случае выровненного адреса на недоступной странице. Сохраняются коды, параметры, PC сбоя, контексты, исходный вывод и хеши исходников/бинарных файлов; проверяется неизменность входных данных и RAM. Это свидетельства поведения ОС, а не подтверждение выполнения KVM/WHP или расширение поддержки SEH.

При native_cpu_only=true параметр native_driver_tests=true включает NeverDNativeDriverTests без Unicorn. Перед конфигурацией build_wdk_driver_fixtures.py проверяет полный SHA-256 официальных пакетов Microsoft WDK/SDK 10.0.26100.6584 и заново собирает 46 обычных/CFG/DBG образов драйверов из исходных текстов. WDKDriverFixtures.def задаёт пакеты, аргументы компилятора и компоновщика и привязки фикстур. Неизменённые файлы Microsoft и лицензии остаются в локальных каталогах сборки/кэша; CI публикует только метаданные и журналы сборки. Манифест сохраняет версии инструментов, команды, хэши исходников/заголовков и полученных образов.

NativeDriverTests.def требует 224 результата WHP для всех 112 нагрузок из DriverBuiltinImages.def и DriverBackendParityCases.def: 26 встроенных образов, 46 образов WDK и 40 сценариев запросов, по исходным и перемещённым адресам. Вместе с 4884 проверками CPU и 17 регрессиями SEH и 53 проверками планирования обязательны 5178 результатов. Фиксированные образы сохраняют ожидаемый отказ в перемещении. Отсутствие или пропуск образа либо сценария WDK приводит к отказу этой необязательной задачи CI; в обычных локальных сборках внешние фикстуры остаются необязательными. run_native_cpu_ci.py --with-drivers записывает настроенные тестовые цели и полные свидетельства инвентаризации/JUnit. Сборка образов не доказывает нативное исполнение Windows или ARM64. Следующие команды воспроизводят сборку локально; созданный кэш можно также загрузить в существующую сборку эмуляции. 4884 CPU + 224 WHP + 17 SEH + 53 scheduling = 5178.

InterruptionRetainsPhaseCauseDeadlineAndLease вводит истечение срока, остановку и обе причины перед двумя разными стартовыми инструкциями. Проверяются точная фаза, собственное время жизни текста ошибки, тип и биты причин, единый неизменный срок и освобождение владения памятью. Реальные ошибки транспорта и несовпадения состояния по-прежнему различаются. Бюджет начальной проверки нативного x64 составляет 5 s; сроки гостя и допуск одиночного шага не меняются.

X64PopFlagsTests.cpp проверяет оба уровня привилегий и driver-strict: 256 допустимых образов флагов с двумя начальными состояниями, девять кодировок, все 64 входных бита, псевдонимы только для чтения и исполнения, межстраничные ошибки и исправление, остановку/ошибки наблюдателей, отказ для стеков устройств и границы следующих нативных инструкций. X64PopFlagsOracle независимо выполняет исходные инструкции на x64 и проверяет CPL3/IOPL0 и точный расход стека. driver_resource_flags.def заставляет исходный ресурсный драйвер WDK устанавливать, очищать и восстанавливать флаги с обеими ширинами. Полное целочисленное/управляющее/x87/SSE-состояние сохраняется; это не означает поддержку гостевых TF/NT/AC/ID или подтверждение нативного ARM64.

X64StatusFlagsTests.cpp проверяет CLC/STC/CMC, LAHF/SAHF, все 256 значений AH и допустимые комбинации флагов, все REX, полное состояние CPU, неизменную память, остановки/ошибки наблюдателя, контексты и нативное продолжение ADC/записи. Недопустимый LOCK отклоняется без эффектов. Независимый оракул проверяет 24 префикса после проверки CPUID. Оригинальные драйверы ресурсов WDK исполняют все пять команд, добавляя 22 обязательных нативных результата. Недоступные хосты/ISA явно пропускаются. Переносимый профиль Unicorn выполняет те же семь случаев; прямые тесты зависимости проверяют AH и LOCK в 16/32/64 битах, явные регистры REX и отказ при отсутствии функции в длинном режиме.

X64DoubleShiftTests.cpp проверяет все допустимые счётчики imm8/CL, совпадающие/расширенные регистры, определённые флаги, RAM на границе страниц, отмену, ошибки прав/отображения/устройства, отказ для LOCK/неопределённых счётчиков, контексты и нативное продолжение ADC. Независимый оракул проверяет 5 184 оригинальных исполнения; двенадцать проб WDK покрывают регистры и RAM. Добавлены 145 обязательных нативных результатов.

X64ScalarShiftTests.cpp проверяет все байтовые значения счётчика, оба входных значения переноса, нулевые, единичные и знаковые битовые шаблоны, неявный сдвиг на один, псевдонимы AH/SPL и регистра счётчика, полное состояние CPU, точные диапазоны RAM, откат наблюдателей, исключения и продолжение контекста. Независимый нативный эталон проверяет 65,536 исполнений. В ресурсный драйвер WDK добавлены 72 собственных пробы. Проверка KVM/WHP требует 769 результатов для этого семейства. Сохранение всех флагов гарантирует только нулевой счётчик после маскирования. Полный оборот кольца переноса RCL/RCR при ненулевом счётчике сохраняет операнд и CF, но оставляет OF неопределённым; эталон исключает только этот неопределённый бит.

X64LoopTests.cpp проверяет 21 оригинальную кодировку, переполнение счётчиков, знаковые относительные цели выше 4 GiB, сохранение полного состояния CPU/RAM, отмену наблюдателями, инструкции на независимо отображённых страницах, ошибки выборки цели и восстановление контекста. Неполные инструкции отклоняются до исполнения; ошибка выборки цели сохраняет счётчик и PC уже выполненного перехода. Ресурсный драйвер WDK добавляет 12 оригинальных проб. KVM/WHP требуют 379 результатов этого семейства в контрактах супервизора, пользователя и драйвера. Эталон исходных инструкций хоста выполняет до 1,008 случаев и сообщает их число. Выполненные переходы AMD с 66H направлены в низкую память, зарезервированную ОС хоста; эти формы запускаются в гостевой матрице с явно отображёнными низкими целями. Отдельно проверяются ширины целей Intel/AMD и приоритет REX.W.

X64BranchTests.cpp проверяет все 16 условий Jcc и относительный JMP, девять последовательностей префиксов, короткие/ближние формы, знаковые относительные цели выше 4 GiB, полное состояние CPU/RAM, остановки/ошибки наблюдателей, декодирование через границы страниц, ошибки выборки цели и восстановление контекста. Независимый эталон Intel выполняет 9,792 исходных инструкции; формы AMD с низкой целью проверяются в госте. Оба декодера проверяют полные/усечённые байты, нативные пробы — отказ публикации. Четыре оригинальные пробы WDK проверяют политику драйверов. Каждый допуск KVM/WHP получает 274 обязательных результата. Проверка программной модели AMD не доказывает нативное выполнение AMD или ARM64.

X64StackTests.cpp проверяет 42 кодировки в девяти группах: ширины, адресацию, полное состояние, порядок наблюдений, отмену, права, границы страниц, физические псевдонимы, исправление сбоев, отказ устройствам и восстановление контекста. Независимый эталон хоста выполняет исходные инструкции; шесть проб WDK проверяют путь драйвера. Каждый нативный допуск KVM/WHP получает 1135 обязательных результатов. Недоступные механизмы явно пропускаются вне собственного обязательного нативного допуска.

X64FrameExitTests.cpp проверяет 14 кодировок LEAVE, эффективный порядок префиксов, полную адресацию RBP, все регистры, алиасы только для чтения, сбои и восстановление кадров на границах страниц, привилегии, наблюдателей, неверные адреса, отказ от устройств и повтор контекста. Независимый оракул хоста выполняет 42 исходные инструкции; пять проб WDK проверяют выполнение драйверов. Каждая нативная проверка добавляет 379 обязательных результатов.

X64FrameEntryTests.cpp проверяет 14 кодировок, вложенность, перекрытия, физические алиасы, проверку памяти только для записи, межстраничные ошибки и исправление, отмену наблюдателями, права, отклонение префиксов и повтор контекста. Независимые проверки на хосте сравнивают байты стека и регистры для 882 успешных инструкций и 84 ошибок в Linux x64. Два теста с внедрённым транспортом различают откат при отмене/сбое и фиксацию архитектурной ошибки. Шесть проб WDK выполняют исходные инструкции в драйвере. Обязательные нативные результаты увеличены на 508 для KVM и 507 для WHP.

DriverSIMDSEHTests.cpp выполняет восемь исходных SSE-ошибок с четырьмя поддерживаемыми решениями и отклонением изменения x87, двумя нативными контрактами, обычными/CFG-образами WDK и двумя адресами. Обязательны десять результатов на backend и три чистые проверки SSE-записей ядра. driver_seh_simd.def задаёт случаи и режимы; асинхронные таблицы раскрутки покрывают функцию с ошибкой. Ядро Microsoft 10.0.26100.9549 даёт независимую основу: 107,744 классификации и 8,192 восстановления при изолированном исполнении путей инструкций. Это не запуск драйвера в полном ядре Windows; нативные ARM64 KVM/WHP ещё не проверены.

Диапазоны C SEH остаются полуоткрытыми. Допустимая точка перехода __C_specific_handler может находиться внутри защищённого диапазона: LLVM 20.1.8 записывает EndLabel + 1 как конечную границу. Модель Windows сохраняет исходные границы и отдельно проверяет исполнимость цели, принадлежность функции и совпадение адреса продолжения, включая перенос образа. KernelSEHContinuationCases.def сохраняет расположение исходной фикстуры; ScopeEndLabelMayOverlapTheHandlerLandingPad проверяет постоянные обработчики и фильтры. Дополнительные тесты проверяют исключение конечной границы и отклонение неверных целей без изменения состояния диспетчеризации. Эти чистые проверки выполняются в NeverDNativeDriverTests при отключённом Unicorn.

При раскрутке к цели также используется исходная конечная граница: область finally не покидается, если её диапазон ещё содержит цель обработчика. FinallyRespectsRawScopeEndAtHandlerTarget проверяет обе стороны границы и на Windows x64 напрямую сравнивает их с ntdll.dll!__C_specific_handler. NeverD не исправляет диапазоны, созданные компилятором. Сборки исходной фикстуры Clang 20/21 возвращают гостевую ошибку в режимах T и J, поскольку смещённая граница включает выбранную цель; Clang 23 выполняет обе очистки. Изменение LLVM #144745 удаляет прежнее смещение +1. Такие результаты компилятора учитываются отдельно от сбоев бэкенда.

Инвентарь сборки охватывает все оригинальные C-программы WDM/KMDF и все необязательные пути WDK в CMake. Для каждого опубликованного driver-*-scenario.json в DriverBackendParityCases.def есть обычный вариант и CFG; отсутствие связи с исходником, сборкой или сценарием приводит к провалу тестов инвентаря. Original сбрасывает адрес из сценария и проверяет предпочтительную базу образа; Rebased проверяет объявленную базу перемещения. Сценарий IRP, принадлежащего драйверу, намеренно отменяет дочерний запрос, поэтому DriverNativeOutcomes.def сохраняет ожидаемый отрицательный общий результат после корректного завершения.

python3 scripts/build_wdk_driver_fixtures.py \
  --output build-driver-fixtures --cache build-driver-packages
cmake -S . -B build-native -G Ninja \
  -C build-driver-fixtures/fixtures.cmake \
  -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=ON \
  -DNEVERD_ENABLE_DRIVER_EMULATION=ON \
  -DNEVERD_ENABLE_SEMANTIC_TESTS=OFF \
  -DNEVERD_EMULATION_BACKEND_UNICORN=OFF

NeverDAArch64StateTests проверяет повреждение каждого скалярного поля и обоих слов каждого вектора, изменение привилегии, отсутствие выполнения FP и сохранение диагностики транспорта. NeverDAArch64FPTests выполняет OriginalProgramChecksCompleteStateAndOneDeadline на обоих уровнях через реальные транспорты с независимо собранными инструкциями AArch64ProbeCases.def. Тест переносит независимые от PC слова в гостевой код, не открывая пользователю страницы монитора. Unicorn и явные пропуски нативных путей не заменяют доказательство нативного запуска ARM64.

CheckedAArch64Instructions.def и AArch64InstructionEffects допускают в EL0/EL1 ограниченную базовую арифметику FP32/FP64, сравнения, пересылки и SIMD фиксированной ширины. FPCR сохраняет четыре режима округления, FZ и DN; FPSR сохраняет накопленные флаги и QC. Неподдерживаемые биты отклоняются до изменений. Арифметика FP16, SVE/SME, немаскированные исключения, дополнительные расширения и неперечисленные формы явно завершаются ошибкой. Загрузка драйверов Windows ARM64 и другие среды ОС не добавлены.

AArch64InstructionEffects владеет скалярными и FP/SIMD диапазонами одиночных/парных операций RAM до 128 бит на операнд. Общее адресное пространство проверяет каждую страницу до входа; RAMTransaction публикует только полные заявленные физические записи. Наблюдатель 128-битной записи получает два упорядоченных 64-битных слова до эффектов. Остановки и ошибки сохраняют RAM, векторы и обновление адреса. Совпадение номера Xn/Vn допустимо; оборачивающиеся парные диапазоны отклоняются. NeverDAArch64MemoryTests использует независимые AArch64CrossPageCases.def и AArch64VectorMemoryCases.def.

NeverDAArch64StateTests проверяет все 71 чтение полного состояния на обоих уровнях, ширины, отсутствующих читателей и повтор. NeverDAArch64FPTests выполняет исходные инструкции AArch64FPCases.def: все векторные части, упакованная арифметика, скалярные/векторные FP, четыре округления, FZ/DN, накопленный FPSR, контексты и отказы. NeverDAArch64MemoryTests проверяет каждый переход страницы, порядок/остановки наблюдателей, права, алиасы и восстановленные векторы. NeverDUnicornStateTransferTests (UnicornStateTransferCases.def, CapturesDeclaredWidthsWithoutStaleUpperBits) вводит каждую ошибку скалярного/векторного чтения после реального выполнения. Недоступные нативные транспорты явно пропускаются; это не заменяет нативные ARM64 KVM/WHP свидетельства.

NeverDAArch64MemoryTests проверяет 18 скалярных/парных форм с Unicorn, KVM и WHP при обоих уровнях привилегий: каждое смещение через границу, знак и ширину, порядок наблюдателей, запрещённую/отсутствующую вторую страницу, явное принятие ошибки и повтор, повторные физические алиасы и восстановление контекста после замены алиасов. Прежний отказ допустимого межстраничного чтения воспроизведён до изменения. Недоступные транспорты явно пропускаются; Unicorn и кросс-компиляция не заменяют нативные доказательства ARM64 KVM/WHP.

NeverDDriverGuardMetadataTests (DriverGuardCases.def) проверяет неактивные метаданные CFG с нулевыми флагами, неизменные резервные указатели при обоих адресах загрузки, неверные слоты/цели и отсутствующие релокации. Исполнение явно выбирает Unicorn/KVM/WHP с driver-strict и checked-x64-v1; недоступные движки пропускаются отдельно. DriverPublicCLICases.def задаёт --backend unicorn для сравнения CLI с совместимым C API v1. Нативный и auto выбор сохраняют отдельные публичные тесты и никогда не переключают движок молча при недоступном API хоста.

Проверенный Unicorn использует MachineRunControl: один временной допуск охватывает обслуживание ARM64, выполнение гостя и полный захват состояния. UC_HOOK_CODE проверяет заимствованный токен остановки и срок на входе в инструкцию. Синхронный вызов движка освобождает ссылку hook перед возвратом, но машинный шаг сохраняет управление до публикации. Unicorn и WHP сначала сохраняют полное состояние CPU приватно и проверяют тот же контроль перед публикацией успешного шага. WHP создаёт допуск один раз до подготовки. Подтверждённое исключение CPU x64 имеет приоритет над остановкой во время захвата. Проверенная транзакция RAM отбрасывает спекулятивные записи при отмене захвата; неограниченный программный контракт не меняется. MachineInterruptedError отличает подтверждённую отмену от ошибки хоста или захвата. Общая проверенная CPU возвращает Stopped или Deadline, сохраняет CPU/RAM и допускает повтор; реальные ошибки остаются BackendFailure даже при одновременной остановке.

Регрессионные тесты захвата: NeverDUnicornStateTransferTests, NeverDUnicornMachineControlTests: StopDuringCaptureCannotPublishAndAllowsRetry, ExpiredCaptureCannotPublishAndAllowsRetry, CompletedStoreCannotPublishCancelledCapture, StopDuringCaptureCannotHideRealGuestException. UnicornPublicCapture.CancellationKeepsTypedExitStateAndRAMConsistent; NeverDKvmStateTransferTests: PublicCancellationRetainsStateRAMAndFailurePriority.

NeverDUnicornMachineControlTests выполняет оригинальные инструкции записи из UnicornMachineControlCases.def на реальных движках x64 и ARM64 с обоими уровнями привилегий. RejectedEntryPreservesStateAndRAMAndAllowsRetry проверяет отмену до шага, остановку или истечение срока на реальном входе гостя, сохранение всего входного состояния и RAM, затем одну успешную запись. Тестовая обёртка входа не требует гипервизора и не доказывает нативное выполнение ARM64/WHP.

RunDeadline::invoke отклоняет остановленный или просроченный вход WHP до вызова хоста, сохраняет фактический результат хоста при отмене и подтверждает завершение обработчиков прерывания до освобождения заимствованного токена остановки. KVM и WHP проверяют полностью считанное закрытое состояние в вызывающем потоке, владеющем правом исполнения, до классификации одновременной остановки или истечения срока. Реальные ошибки хоста или чтения состояния и подтверждённые исключения CPU x64 сохраняют приоритет. Обычный успешный результат остаётся закрытым до окончания проверки отмены; подтверждённое прерывание отбрасывает спекулятивные эффекты CPU/RAM и разрешает повтор. Подготовка, нативное исполнение и чтение состояния используют единый допуск на шаг. Управление отменой кооперативное и не гарантирует жёсткую границу реального времени.

NeverDRunControlTests включает переносимые NativeEntryTests.cpp и WhpEntryControlTests.cpp для Windows с WHP. Обработчики хоста в памяти без Hyper-V проверяют отклонённый вход, повтор, позднюю отмену, сохранение ошибок, приоритет результата и подтверждённое время жизни обработчиков. NeverDKvmRunTests проверяет завершение в вызывающем потоке, приоритет ошибок и запрет повторного входа. Реальные NeverDKvmStateTransferTests исполняют исходные инструкции KvmStateTransferCases.def; ActualCPUExceptionOutranksStopDuringCapture и PublicCPUExceptionOutranksStopDuringCapture останавливаются после фактического чтения регистров/XSAVE и сохраняют исключение деления, исходный контекст, RAM и явное восстановление. Переносимые тесты с Windows ABI в Wine доказывают только работу потоков и управления, но не нативное исполнение WHP. Недоступные нативные транспорты явно пропускаются.

NeverDInstructionFetchTests выполняет checked-программы x64/ARM64 через Unicorn, KVM и WHP в привилегированном и пользовательском режимах. InstructionFetchCases.def проверяет смену форм операндов, относительные переходы, запись гостем и хостом через алиасы кода, восстановление контекста, отзыв прав, раздельную память страниц, чтение у конца страницы, неверные или усечённые кодировки и отказ от рекурсивного входа. Нативная Windows CI требует успеха всех случаев WHP x64. Недоступные пары хост/ISA явно пропускаются; переносимое исполнение ARM64 не доказывает нативную поддержку ARM64.

WhpStateTransferTests.cpp внедряет передачи для обоих поколений XSAVE API: изменённые группы, полный захват, игнорирование заполнения, частичные сбои, отмена, приоритет исключений и замена раздела. ContinuedStepsReuseCapturedRegistersAndFP считает пропущенные установки; PartialTransferFailuresPreserveStateAndForceFullRetry требует полного восстановления. Это проверки протокола; нативные тесты FP, переходов состояния, драйверов и ring3 остаются обязательными.

WhpStateTransferCases.def также проверяет сбои после каждого частичного префикса объединённого чтения 32 регистров и конфликты во всех семи полях метаданных. Оба поколения XSAVE API обязаны сохранять состояние вызывающего кода и полностью восстанавливать его при повторе. Тесты проверяют одно чтение регистров на шаг и восстановление пропущенных XSAVE метаданных из этого чтения.

windows-pe64-v1 поддерживает ограниченные консольные процессы Windows x64/ARM64 с PEB/TEB, статическим и динамическим TLS, DllMain, именованными Win32 API и явно заданными ациклическими графами DLL. Поддерживаются импорты кода/данных по имени и ординалу, DIR64, перенаправленные экспорты и реальные списки загрузчика. LoadLibraryA / LoadLibraryW, FreeLibrary и GetProcAddress используют настроенный каталог. CRT/GUI, SEH ARM64 на основе кадров стека, потоки и общая совместимость с Windows не завершены; нативных свидетельств ARM64 KVM/WHP пока нет.

Суммарные входные байты и размеры образов отдельно ограничены memory_limit; отображения среды тоже входят в бюджет образов. Подготовка делит лимиты 65,536 записей, 64 MiB чтений метаданных, длины имён и общий срок, без жёсткой гарантии времени I/O хоста. Авторский EXE→DLL→DLL проверяет перебазирование, ординалы, общие данные, идентичность API, MEM_IMAGE, списки и attach/detach TLS EXE. NeverDWindowsProcessTests включает нативный Windows-оракул, NeverDPEProgramExportsTests — повреждённые метаданные и бюджеты, NeverDProcessPublicTests — совпадение C ABI/CLI. Недоступные транспорты явно пропускаются.

WindowsProcessLifetime выполняет TLS и затем DllMain DLL в порядке зависимостей, после чего TLS и вход EXE, на одном CPU с общим бюджетом. Каждый модуль получает отдельный индекс TLS и выровненный блок из перемещённого, связанного образа в общей области 64 KiB. Резервный аргумент TLS равен нулю; DllMain при запуске/завершении процесса получает непрозрачное ненулевое значение. Явный выход отсоединяет успешно инициализированные DLL в обратном порядке списка загрузчика, затем TLS EXE, даже до инициализации EXE. Начальный DllMain(FALSE) завершает процесс с 0xc0000142 без detach. Ошибки и исчерпание бюджета не имитируют очистку. Возврат из PE-входа с гостевыми DLL требует неподдерживаемого завершения потока и явно останавливается. Ненулевой SizeOfZeroFill пока не поддержан; нулевые байты фактического TLS-шаблона поддержаны. DLL без входа получают TLS attach, но не уведомления process detach.

WindowsProcessExports использует единое разрешение имён/ординалов для статического импорта и GetProcAddress, включая код, данные, псевдонимы и цепочки перенаправлений. Только используемые стартовые перенаправления добавляют модули каталога и зависимости инициализации; остальные не загружают файлы. Имена чувствительны к регистру; отсутствующее имя возвращает NULL/ошибку 127, непосредственно запрошенный отсутствующий ординал (включая пробелы таблицы) NULL/ошибку 182, а аргумент запроса NULL — ошибку 87, успех сохраняет LastError. Неизвестные дескрипторы модулей не поддерживаются. Точные API-входы поставщик/имя резервируются один раз по ограниченному реестру. Проверяются текущие PE-заголовки и метаданные экспорта каждого образа; изменения и нечитаемые байты отклоняются. Цепочки ограничены 64 элементами, используют остаток общего бюджета метаданных и общий срок выполнения. Перенаправление на пустой элемент возвращает базу целевого образа и сохраняет LastError; на нулевой ординал — ошибку 87. База является адресом данных и не даёт права выполнять заголовки образа. Перенаправления во время исполнения могут загружать настроенные модули и завершать инициализацию до возврата результата. Изменение активных таблиц экспорта не поддерживается.

WindowsProcessLoader загружает базовые ASCII-имена DLL из windows.modules и управляет явными ссылками, общими зависимостями и удержанием стартовых модулей. Повторные запросы перенаправлений не добавляют ссылок. При повторной загрузке слот каталога получает новое поколение резидентности. TLS и DllMain исполняются на том же CPU ниже приостановленных кадров API; восстановление регистров сохраняет записи гостя и использует текущий адрес возврата. Резервные указатели динамических attach/detach равны нулю. Неудачный attach при явной загрузке возвращает 1114 после очистки, сохраняя успешные независимые вложенные загрузки. Выгрузка освобождает образ и TLS, повторная загрузка восстанавливает исходные байты. Внешние изменения списков загрузчика и указателей TLS явно отклоняются. Бюджеты файлов, образов и метаданных остаются накопительными после ошибок и перезагрузок. Системные поставщики используют базы отображённых PE как дескрипторы модулей. Поиск файлов, пути не ASCII, флаги LoadLibraryEx, циклы и повторный вход для переходов того же инициализируемого или выгружаемого модуля не поддерживаются.

GetEnvironmentVariableW, SetEnvironmentVariableW, GetEnvironmentStringsW, FreeEnvironmentStringsW, ExpandEnvironmentStringsW используют текущий блок окружения гостя из параметров процесса PEB. Имена ASCII сравниваются без учёта регистра; значения представлены в UTF-16. Перед изменением проверяются входные данные, ёмкость и права записи. Снимки не зависят от последующих изменений и освобождают гостевую память. Модель ограничивает блок 64 KiB; строки и подстановка ограничены по размеру и проверяют срок выполнения. Неизвестная принадлежность указателей, некорректные блоки, кодовые страницы ANSI и перекрывающиеся буферы подстановки не поддерживаются. WindowsEnvironmentTests.cpp сравнивает оригинальные фикстуры x64/ARM64 на доступных бэкендах; CI требует независимый нативный оракул Windows.

WindowsProcessHeap объединяет выделение, HeapReAlloc, освобождение и запрос размера блоков кучи процесса. Изменение размера сохраняет оставшиеся байты; HEAP_ZERO_MEMORY обнуляет добавленные байты, а HEAP_REALLOC_IN_PLACE_ONLY запрещает перемещение. При неудачном изменении размера старый блок сохраняется, возвращается NULL и устанавливается ERROR_NOT_ENOUGH_MEMORY (8), как в нативных наблюдениях. Независимые страницы возвращают ёмкость при уменьшении и освобождении; подготовка роста и ограниченное копирование проверяют срок выполнения. Собственные кучи, флаги исключений, неизвестная принадлежность и недоступные диапазоны явно останавливают выполнение. WindowsHeapTests.cpp проверяет обе ISA, принудительное перемещение, повторное использование бюджета и атомарность ошибок; CI также запускает тот же оригинальный EXE на нативном Windows. Пакетные PE-тесты используют общий внешний лимит CTest в 120 секунд; каждый гость сохраняет собственный конечный бюджет. Фикстура кучи допускает 20 секунд на процесс для полной проверки данных в WHP.

WindowsSystemModules создаёт ограниченные модельные PE64-образы ntdll.dll, kernelbase.dll и kernel32.dll для обеих ISA. ASCII-запросы GetModuleHandleA / GetModuleHandleW, LoadLibraryA / LoadLibraryW и GetProcAddress используют общие отображённые базы; PEB/LDR и MEM_IMAGE описывают те же образы. Статические импорты, поиск по имени и гостевые перенаправления используют единые API-переходы и разрешение экспортов. Поставщики закреплены в памяти, не имеют гостевых обработчиков инициализации и не мешают возврату из точки входа после выгрузки обычных гостевых DLL. Изменение заголовков или метаданных экспортов останавливает поиск. Неизвестные системе модели имена и ненулевые системные ординалы явно отклоняются; отличие только регистра известного имени и пустое имя возвращают ошибку 127, NULL-запрос — 87. Созданные байты и адреса определяет модель; расположение конкретных версий Windows, нативные ординалы и межмодульные псевдонимы не воспроизводятся. WindowsSystemTests.cpp сравнивает оригинальные x64/ARM64 EXE с нативным Windows, включая восемь независимых наблюдений возврата начального потока.

WindowsProcessExceptions реализует AddVectoredExceptionHandler, RemoveVectoredExceptionHandler и RaiseException на одном CPU с общим бюджетом процесса. Упорядоченные обработчики могут менять регистрации, вызывать вложенные исключения, модельные API, загрузку DLL и завершение процесса. Нарушения доступа к данным x64/ARM64 и ошибки целочисленного деления x64 допускают продолжение после проверки изменений гостя в CONTEXT; сохраняются общие регистры, SIMD и поддерживаемое FP-состояние. Программные исключения продолжаются через настоящую инструкцию возврата модельного поставщика. Пределы: 128 сохраняемых регистраций и 16 вложенных кадров. Неверные результаты, изменённые указатели, неподдерживаемые поля и превышения явно отклоняются. SEH/раскрутка ARM64 по кадрам стека, отладчик и ошибки исполнения/защитных страниц не поддерживаются. WindowsExceptionTests.cpp сравнивает оригинальные EXE/DLL с нативным Windows; нативных доказательств ARM64 KVM/WHP пока нет. Записи программных исключений содержат EXCEPTION_SOFTWARE_ORIGINATE (0x80) независимо от переданного вызывающей стороной флага запрета продолжения; исходный исполняемый файл Windows проверяет точные значения флагов программных и аппаратных исключений.

WindowsProcessContext сохраняет происхождение каждого кадра диспетчеризации. Поддерживаемые ошибки x64 при доступе к данным и делении показывают RF (0x10000) в CONTEXT.EFlags; RaiseException, включая программные коды нарушения доступа, сохраняет текущий контекст. Происхождение сохраняется при VEH/VCH и поиске/раскрутке SEH. Допустимое продолжение восстанавливает логические флаги CPU без RF; изменения RF гостем отклоняются до публикации состояния. Этот ограниченный профиль не моделирует точки останова на инструкциях или управление RF гостем. WindowsExceptionTests.cpp проверяет записи, восстановление и неизменность CPU/RAM при отказе.

По независимым нативным наблюдениям Windows ring3 преобразует ошибки checked x64 operand_alignment в STATUS_ACCESS_VIOLATION с параметрами [read, UINT64_MAX], включая записи. Причину предоставляет слой CPU; Windows не угадывает её по вектору 13 и не декодирует инструкцию повторно. WindowsAlignmentProcessTests.cpp выполняет исходные PE-инструкции в 72 сценариях ошибки и 9 повторах после исправления адреса (72 + 9), проверяя PC, RF, XMM и RAM. Неклассифицированные или противоречивые ошибки отклоняются. Отчёты процессов и драйверов сохраняют nullable-поля cause и шестнадцатеричное error_code, различая отсутствие и ноль. Эта доставка относится к пользовательскому профилю checked x64. После каждой ошибки или повтора с исправленным адресом программа экспортирует всю страницу размером 4096 байт; хост проверяет все 81 снимок и фактические счётчики завершения без изменения ограничения времени гостя. Наблюдения нативных процессов и начальных потоков используют CREATE_DEFAULT_ERROR_MODE: GoogleTest включает наследуемый флаг SEM_NOALIGNMENTFAULTEXCEPT, из-за которого Windows может исправлять измеряемые ошибки. Поэтому оракул проверяет стандартное поведение системы независимо от настроек тестового окружения.

AddVectoredContinueHandler и RemoveVectoredContinueHandler ведут отдельный упорядоченный список; обе группы обработчиков делят предел в 128 сохраняемых регистраций. После согласия векторного обработчика исключения на продолжение обработчики продолжения получают ту же изменяемую запись исключения и CONTEXT. Итоговая проверка контекста выполняется после этих вызовов, включая вложенные исключения и уведомления DLL. Удалять дескрипторы через API другой группы нельзя. WindowsContinuationTests.cpp сравнивает собственные EXE с нативным Windows: порядок, досрочное завершение, изменение регистраций, восстановление контекста, вложенность, вызовы загрузчика и выход процесса. Проверенный векторный путь Windows x64 допускает продолжение при EXCEPTION_NONCONTINUABLE; это не доказывает поведение SEH по кадрам стека. Нативное исполнение ARM64 ещё не проверено.

RtlCaptureContext доступен через kernel32.dll и ntdll.dll для x64 и ARM64. Общие WindowsProcessContext и IntegerABI сохраняют PC/SP вызывающего кода, не меняя состояние CPU и LastError. Нативные наблюдения Windows подтверждают флаги x64 0x10000f, сохранение незаписываемых областей home/отладки/векторов и старые 32-битные поля адресов x87; ARM64 копирует LR в PC и обнуляет X0/LR в записи. Регистры, SIMD и управление плавающей точкой берутся у гостя; селекторы x64 и маска возможностей MXCSR соответствуют настроенному гостевому CPU. Некорректные, невыровненные или частично недоступные буферы отклоняются до записи. WindowsContextTests.cpp проверяет прямой импорт, поиск у поставщика, вызовы VEH, запись через границу страниц и атомарность ошибок. scripts/check_windows_context.py запускает оригинальную программу в Windows x64/ARM64 и отдельный нативный оракул непустого состояния x87. Эти наблюдения ARM64 API не доказывают нативное выполнение KVM/WHP. Восстановление контекста, обход стека и динамические таблицы функций остаются отдельными задачами. WindowsProcessServices.def задаёт точные ограничения по модулям: поиск в kernelbase.dll возвращает ERROR_PROC_NOT_FOUND (127), как и в нативных наблюдениях, без добавления несуществующего экспорта. RtlCaptureContext.

WindowsProcessSEH использует общий X64SEH в os/windows/exception/ (NeverDEmulationWindowsException, доступен без драйверов) для x64 __C_specific_handler и UNWIND_INFO V1. После поиска VEH поддерживаются фильтры, finally, нелокальный переход к обработчику, вложенная/конфликтующая раскрутка и перемещённые кадры EXE/DLL с сохранением сохраняемых GPR/XMM. Продолжение из фильтра вызывает VCH с тем же CONTEXT. WindowsSEHTests.cpp сравнивает 23 собственных сценариев с нативным Windows; KVM/WHP/Unicorn используют общую семантику. Бюджет процесса ограничивает повторную проверку поколений образов, заголовков, байтов раскрутки/областей, кода языкового обработчика и привязок IAT. Изменённые метаданные или выгруженные удерживаемые образы явно отклоняются. Кадровый SEH ARM64, C++ EH, динамические таблицы функций, общие RtlUnwind/NtContinue и раскрутка через границы вызовов загрузчика/VEH/VCH пока не поддерживаются.

Для EXCEPTION_NONCONTINUABLE возврат EXCEPTION_CONTINUE_EXECUTION из фильтра x64 вызывает STATUS_NONCONTINUABLE_EXCEPTION (0xc0000025, флаги 0x81, связанная запись null) с новым контекстом. VEH запускается повторно перед поиском по сохранённому логическому стеку; порядок finally, идентичность кадров EXE/DLL и бюджеты глубины и исполнения сохраняются. Из 23 нативных сценариев 21 завершается успешно, а два приводят к прекращению процесса: согласие VEH/VCH продолжить вторичное исключение оставляет его необработанным даже после восстановления исходного CONTEXT. Модель сообщает об ошибке выполнения. Адрес программного исключения совпадает с сохранённым PC; внутренние адреса диспетчера и раскладка регистров определяются моделью. Windows x64 CI.

WindowsDynamicTests.cpp сравнивает исходные DLL/EXE x64/ARM64 с независимыми наблюдениями Windows: ссылки, общие зависимости, вложенные загрузки, очистка после ошибок, перенаправления, завершение, DLL без точки входа и новый TLS при перезагрузке. Дополнительные проверки отклоняют изменённые метаданные и устаревшие указатели кода, сохраняют накопительные бюджеты и незавершённые результаты прерванных API. Windows CI требует нативный оракул и случаи WHP; кросс-компиляция и Unicorn ARM64 не доказывают нативное исполнение ARM64.

Отсутствие библиотеки в любой позиции цепочки перенаправления GetProcAddress возвращает 127; явный LoadLibrary для отсутствующего в каталоге модуля возвращает 126. Нативный эталон и каждый доступный backend проверяют все 41 объявленных сценариев. В Windows возврат после выгрузки всех DLL наблюдается 16 раз для каждого варианта DLL. Ошибка инициализации через перенаправление GetProcAddress также возвращает 127 после очистки. Обратные вызовы отсоединения процесса сохраняют содержимое стека завершающего вызывающего кода.

WindowsExportTests.cpp использует исходные DLL и EXE x64/ARM64 для проверки перенаправленных вызовов кода/данных/ординалов, псевдонимов, запросов при инициализации, перебазирования, регистра, отсутствующих экспортов, LastError, циклов, нерезидентных целей, неверных указателей и изменений после успешных запросов. Тот же EXE выполняется независимым нативным Windows-оракулом; WHP-тесты обязательны в нативном CI. C ABI/CLI сравнивают полные отчёты. Доказательства на нативном оборудовании ARM64 ещё отсутствуют. Варианты EXE с таблицей экспорта и без неё проверяют оба графа, порядок PEB и detach, а также ошибки имени/ординала/NULL.

WindowsLifetimeTests.cpp сравнивает фиксированные трассы с независимыми нативными Windows-процессами и KVM/WHP/Unicorn: нормальный выход, возврат из входа, оба отказа DLL, четыре ранних выхода и DLL без входа. Проверяются также ошибки callback, общие бюджеты, перемещённые поля TLS и общая ёмкость. Нативная проверка возврата сохраняет дескриптор начального потока и 64 раза проверяет его код завершения и точную последовательность уведомлений потока/процесса. Оставшиеся дочерние потоки завершаются после наблюдения; код процесса не считается значением возврата из входа.

NeverDUnpackTests, NeverDUnpackExecutionTests и NeverDUnpackPublicTests охватывают восстановление упакованных образов; см. распаковку. UnpackGeneratedTests.cpp проверяет правила точки входа на x86-64 и ARM64 на программе, которую тест упаковывает сам. X64ReturnPrefixTests.cpp проверяет двухбайтовый ближний возврат на каждом транспорте и то, что любой другой возврат с префиксом по-прежнему отклоняется. WindowsDeferredTests.cpp проверяет непрозрачные точки входа и наблюдение за остановленным процессом; ExecutionSessionTests.cpp проверяет наблюдения за выполнением.

Виртуальная память Windows поддерживает VirtualAlloc, VirtualFree, VirtualProtect, VirtualQuery и FlushInstructionCache для текущего процесса. Уровень ОС управляет резервированием; AddressSpace остаётся единственным владельцем отображений подтверждённых страниц, прав доступа и физической памяти. Тесты проверяют изменение кода, ошибки доступа и повторное использование лимита памяти.

NeverDEmulationWindowsProcess → os/windows/process/; NeverDWindowsProcessTests + NeverDProcessPublicTests: windows-pe64-v1.

Регрессии проверяют точные и недостаточные бюджеты, части слов, оба порядка байтов, идентичность нетронутой памяти, границы полных аффинных слотов, поздние перезаписи и инвалидирование по умолчанию. C API/CLI проверяют совместимость v6 и недопустимые домены. HighC и LLVMC исполняются с O0/O2 с проверкой результата, памяти, стека и сохраняемого состояния; это не сертификат нативной эквивалентности.

Регрессии проверяют фазы в регистрах и кадре, оба порядка байтов, достижимые недопустимые ветви, поздних предшественников, исчерпанные внутренние условия и соседние пределы поиска. Тесты посещений охватывают арифметические связи, вложенные циклы, режимы, последовательные переходы, общий бюджет и приоритет старого флага. CLI выполняет оба пути C и исходных ABI на O0/O2; C/Python v8 проверяют раскладки, неверные поля и игнорирование будущих хвостов. Регрессии также проверяют, что большие посторонние конечные селекторы оставляют бюджет поиска машинным условиям, а последнее разрешённое уточнение достаётся уже намеченному производителю.

NeverDLLVMCPhiTests выполняет независимые и взаимозависимые обновления циклов при O0/O2, проверяя ноль итераций, граничные числа итераций и случайные полноразрядные начальные значения. Проверки читаемости требуют отсутствия локальных копий для независимых обновлений и только необходимой копии для составных обменов. Существующие тесты ветвлений, switch, перенесённых ветвей и циклического обмена проверяют выбранное ребро и одновременные присваивания.

Пять независимых тестов LLVMCInternalExitRegions охватывают полярности, ноль итераций, параллельные PHI-перестановки, четыре сочетания вложенных выходов и порядок наблюдений. Общие назначения и ранние продолжения проверяют исполняемый резервный вывод; отказ после допустимого цикла не должен публиковать частичную структуру. Вывод модуля и выбранной функции совпадает без изменения LLVM. Исходный LLVM и сгенерированный C сравниваются с независимыми беззнаковыми эталонами при O0/O2 за 294 912 вызовов, для C включены ловушки неопределённого поведения.

NeverDLLVMCPhiTests также проверяет общие выходы циклов: разные пары PHI у преемников, порядок вызовов наблюдателя, выходную память и неизменность IR вызывающей стороны. C для всего модуля и выбранной функции сравнивается с независимыми эталонами при O0/O2. Разные условия выхода и дополнительные предшественники проверяют консервативную обработку.

NeverDLLVMCPhiTests проверяет несколько обратных рёбер независимыми эталонами O0/O2, порядок наблюдателей, снимки значений до изменяющих память вызовов, узкое модульное переполнение и знаковое расширение. Вывод модуля и отдельной функции сохраняет исходный IR. Проверяются конфликтующие рёбра, общие корни, аннотации poison, неопределённые операнды, переменные сдвиги, ограниченные intrinsic, исключения и полный отказ при недостатке бюджета. Вращения объединяются только при совпадении всех входящих операций.

NeverDLLVMCPhiTests выполняет структурированные скалярные области при O0/O2: вложенные циклы с переставленными блоками, ромбы, ноль итераций, модульное переполнение узких целых, наблюдатели в заголовке, обмены PHI, живые внешние значения, общие шаги и границы воронкообразных сдвигов. Проверяются неизменность исходного IR, объединение до трёх локальных переменных и исполняемый откат для графов с несколькими выходами, неприводимых и слишком больших графов. Примеры синтетические и независимые; вывод исходного кода не сертифицирует нативное восстановление.

NeverDLLVMCValueTests сравнивает типизированный C скалярных циклов с независимо и напрямую скомпилированным LLVM при O0/O2, включая ловушки неопределённого поведения для полученного C. Граничные и детерминированные полноразрядные входы проверяют узкое умножение и переполнение перед сдвигом, расширенное умножение и правый сдвиг, логическое усечение, знаковые сравнения и расширения, приоритеты, условные выражения, логическую арифметику, возврат к прежнему пути и материализацию глубоких выражений. Также проверяются неизменность исходного IR и удаление лишних приведений.

NeverDLLVMCPhiTests и NeverDLLVMCValueTests проверяют байтовые счётчики с переполнением при увеличении и уменьшении, объединённые выходные значения, встроенные использования после цикла, живые внешние значения и снимки PHI. Независимые сравнения O0/O2 с ловушками неопределённого поведения проверяют составное сложение, отказ для обратного вычитания, узкое умножение и логические маски. Вложенные области требуют локальных счётчиков циклов, отдельного результата и неизменного исходного LLVM. Исполняемый тест имён создаёт конфликт внешних функций с первоначальными именами результата и счётчика и проверяет сохранение вызовов и наблюдаемых эффектов.

NeverDLLVMCValueTests проверяет обе позиции нейтральной ветви для сложения, вычитания и побитовых обновлений, неизменные основы, встроенные зависимости от старого значения, снимки условий, проверки узких целых, ненейтральные ветви и общие select. Созданный C выполняется при O0/O2 в сравнении с независимо скомпилированным LLVM, с ловушками неопределённого поведения. NeverDLLVMCPhiTests также проверяет параллельные снимки и зависящие от ветвей инициализации, которым нужна общая область видимости. IR вызывающей стороны не меняется.

NeverDUnicornDecodeTests проверяет зарезервированные биты регистровых форм EVEX на моделях CPU AVX-512/APX, приоритет ошибок памяти ROUND, сохранение состояния и возобновление. Независимая программа на Linux x64 подтверждает ошибки выравнивания классической кодировки и страничные ошибки скалярных/VEX-форм. Эти тесты движка не расширяют набор разрешённых инструкций checked и не доказывают нативное исполнение APX.

Измерения CPU ARM64

Используйте сборку CPU Release. Явный HVF требует нативный macOS ARM64; для программного сравнения включите Unicorn. Каждый результат проверяется. Инициализация измеряется отдельно; переключения CPU включают промежуточные API-вызовы и проверки, другие нагрузки исключают подготовку и проверку.

cmake --build build-cpu --target neverd-cpu-bench --parallel 4
build-cpu/bin/neverd-cpu-bench --backend hvf --samples 7 --warmup 1
build-cpu/bin/neverd-cpu-bench --backend unicorn --samples 7 --warmup 1

Сохраните исходный исполняемый файл до пересборки. Python 3.11+ чередует порядок измерений. Храните конфигурацию, метки исходников, хеши бинарников и все выборки; не запускайте параллельно сборки или тесты.

python3 scripts/benchmark_cpu.py \
  --baseline /path/to/before --baseline-label BEFORE_COMMIT \
  --candidate /path/to/after --candidate-label AFTER_COMMIT \
  --pairs 15 --output /path/to/new-comparison.json

Подсчёт входов — отдельная диагностика с дополнительными затратами, включающая стартовые пробы; её время не является показателем производительности. Нагрузки не характеризуют целую ОС или сравнение между ISA.

Воспроизведение · HVF

NeverDLLVMPrivateFrameTests проверяет перекрывающиеся записи, все входы и обратные рёбра, сохранение адресов, пересекающиеся внешние выходы, неинициализированную/упорядоченную/неизвестную память, метаданные и атомарный отказ при точном бюджете и нехватке единицы. Независимые оракулы O0/O2 с ловушками неопределённого поведения сравнивают полные результаты, внешние объекты и байты кадра. Компиляция для x86-64, AArch64, big-endian AArch64 и ARM32 не доказывает нативное восстановление этих архитектур. При изменении общих вспомогательных правил адресов и эффектов повторять NeverDByteMemoryForwardingTests.

cmake --build build-release --target NeverDLLVMPrivateFrameTests NeverDByteMemoryForwardingTests --parallel 4
build-release/bin/NeverDLLVMPrivateFrameTests
build-release/bin/NeverDByteMemoryForwardingTests

NeverDByteCellScalarizationTests проверяет перекрывающиеся слова, два входных пути и два обратных ребра, широкие доступы и ширины не в степени двух, оба порядка байтов, выбор сохраняемых значений и обязательства poison, частичную перезапись poison, отказ по полному графу использований и точные/недостаточные бюджеты нескольких объектов. Обычный конвейер Thin/Deep должен удалять оставшиеся массивы. Независимые оракулы O0/O2 сравнивают все 24 выходных байта, окружающие защитные байты и результат на 8192 входах в трёх версиях: 49152 вызова с ловушками неопределённого поведения. Компиляции x86-64, AArch64, AArch64 big-endian и ARM32 отделены от покрытия нативного исполнения. При изменении общих контрактов памяти запускайте эту цель вместе с тестами побайтовой передачи и приватных кадров.

cmake --build build-release --target NeverDByteCellScalarizationTests --parallel 4
build-release/bin/NeverDByteCellScalarizationTests

AndroidMutexTests.cpp проверяет независимыми программами O0/O2 с обычной/APS2/RELR упаковкой три типа mutex, нескольких ожидающих, повторную конкуренцию, последнее рекурсивное освобождение, errno, события, недоступную память, взаимоблокировки и общий лимит инструкций. Используются Unicorn и доступные KVM/WHP/HVF; остальные явно пропускаются. Это не доказывает эквивалентность устройству Android или параллельному SMP.

HighControlFlowSemantics.DeepStableContainersPreserveEveryReturnPath проверяет 48 уровней блоков, циклов, switch и обработчиков исключений независимым интерпретатором на выполняемых и обходящих путях. Достаточно широкий предел времени выявляет повторные рекурсивные обходы. Это покрытие структурированного HighIR; восстановление методов всего образа по-прежнему требует отдельных полных проверок перечня и зависимостей.

SwiftOnceSources.EarlyReturnsKeepExactObjCOnceThunkProofs проверяет ARM64/x64 thunk с совмещёнными или раздельными вызовами retain. EarlyOnceCopyReturnsRequireTheSameCompleteTail отклоняет изменённые записи, отсутствующие или переставленные retain, упорядоченные загрузки, изменённые результаты и внешние входы. IgnoredNestedReturnCopiesDoNotObserveOnceContext проверяет оба возможных выхода void-callback и поток исходного кода после проекции.

HighControlFlowSemantics.ReturnTailCopyKeepsTheOuterLabelOwner сравнивает пути входа и обхода независимым интерпретатором, когда адрес повторяется во вложенном блоке. ReturnTailCopyIncludesTheFirstChildOfItsLabel сохраняет допустимое совпадение адресов родителя и первого ребёнка вместе с присваиванием. Эти целевые проверки не заменяют полное сравнение методов и нативных зависимостей.

JumpTailCopyKeepsTheOuterLabelOwner проверяет то же правило владельца для хвостов перехода.

EarlyStringGetterReturnsKeepOnlyInertOnceAnchors проверяет пустые якоря инструкций между ранним возвратом и вызовом once и отклоняет промежуточные вызовы или записи.

SwiftOnceSources.ObjCThunkRootsShareTheNestedCallbackProof проверяет общее доказательство корня и отказ после того, как лист начинает наблюдать свой контекст.

SourceABI.SwiftPointActionRequiresTwoDoublesAndContext / ObjCCallHints.CoreGraphicsPointActionsKeepSwiftFloatingCarriers проверяет обе архитектуры и отклоняет изменённых поставщиков, слабые импорты, конфликтующее хранилище и устаревшие носители ABI. HighCSourceCalls.SwiftCoreGraphicsPointActionsKeepCoordinatesContextAndOrder выполняет сгенерированный C при O0/O2 с независимыми проверками носителей Swift: биты координат, включая знаковый ноль, субнормальные числа и NaN, идентичность получателя, порядок вызовов и защитные значения. Это доказывает ABI вызова, но не полное восстановление методов верхнего уровня.

NativeSourceHints.CGContextCGRectMethodKeepsOrdinaryAndSwiftContextInputs проверяет полное дерево метода и точные носители, включая закрытые методы и отклоняемые сигнатуры. SwiftFieldReceiver.CGRectMethodSelfKeepsItsLogicalParameterIdentity и CGRectMethodRejectsChangedEntryAndReceiverParameter проверяют конвейер и повторную проверку публикации, отклоняя изменения индекса self, входа или типа аргумента. Записи компилятора охватывают четыре цели macOS/Mac Catalyst; декларация входа поддерживает только arm64. HighCSourceCalls.SwiftCGRectMethodKeepsContextReceiverAndAllCoordinateBits исполняет сгенерированный C при O0/O2 с независимым эталоном скалярных носителей Swift, проверяя биты всех четырёх координат, разные указатели context/self, единственный вызов и защитные значения памяти.

NeverDLowInstructionBoundaryTests запускает тесты происхождения инструкций LowIR без сборки всех фикстур общего набора поднятия. BackwardSharedReturnEpilogueKeepsReturnAndCallerFrame проверяет выровненное освобождение стека через ADD и постиндексный LDP, включая восстановление регистра связи в вызывающей функции; исходный RET X30 и общий вход остаются независимыми. BackwardSharedReturnEpilogueRejectsChangedReturnAndOwnership отклоняет другой регистр возврата, BR X30, отсутствие или неверное выравнивание освобождения, узкие восстановления, внутренние входы, исправления, записываемые или неоднозначные отображения, перемещаемые входные файлы и другие форматы. Декодирование общего хвоста не доказывает нативный ABI: отсутствие сохранений или выделения стека у вызывающей функции по-прежнему нарушает существующее доказательство кадра.

ObjCCallHints.CIImageAffineValueKeepsProviderAndPhysicalCopyCarrier проверяет поставщика CoreImage, фабрику CIImage, полную логическую структуру из 48 байт и указатель x2; отсутствующие или неверные поставщики, x86_64 и противоречивые декларации отклоняются. ObjCImageValueCopy.OriginalFrameAndCompleteBodyAuthorizePublication отделяет исходный вызов от присваиваний его результата с тем же машинным адресом. RejectsChangedCopyCallBodyAndCurrentImage отклоняет 24 изменения свидетельств, аргументов, записей, кадров, метаданных, импортов, дублируемых вызовов и сохранённого IR, включая согласованные изменения MedIR и HighIR одновременно. GeneratedCExecutesAgainstIndependentPhysicalCopyABI выполняет неизменённый сгенерированный C с O0/O2 на ARM64 против функции с независимо наблюдаемым у компилятора указателем x2; проверяются все шесть битовых шаблонов, идентичность селектора и получателя, однократное вычисление, возвращаемый объект, допустимые записи в копию, неизменность входов и защитные границы. На других платформах этот тест физической ABI пропускается.

ObjCCallHints.CurrentMethodEncodingMustAgreeWithCachedDeclaration отклоняет кешированную ABI, не соответствующую текущей непустой кодировке метода или селектору; клиенты только с декларацией сохраняют прежний контракт.

DarwinIndirectRecordCalls.MatrixFrameEffectsRequireExactCurrentContract охватывает текущие матричные/аффинные контракты и 22 отклоняемых изменения контракта. ObjCAffineImageValueCopy.CurrentProducerInitializesThePublishedCopy доказывает передачу результата SDK в копию CoreImage и независимое восстановление для публикации. RejectsWrongProducerFrameAndSavedIR проверяет двенадцать изменений на производителя: отсутствующие записи входа, результат вне кадра, неверные поставщики или носители ABI и повторное использование потребленного входа Concat. GeneratedCMatchesOriginalMachineAndSDKResults выполняет неизмененный сгенерированный C и исходные слова ARM64 с нативным CoreGraphics при O0/O2 на Apple ARM64: 1000 случаев на производителя сравнивают все 48 байтов результата, оба входа, идентичность селектора и получателя, один вызов, возвращаемые объекты, записи в частную копию и защитные значения. Другие хосты пропускают этот нативный тест SDK.

MatrixFrameEffectsRequireExactCurrentContract также проверяет потребителя CGRect и 22 отклоняемых изменения. ObjCAffineImageValueCopy.CGRectInputUsesTheSameCurrentFrameOwner проверяет вращение → заимствование CGRect → повторное вращение → публикацию CoreImage. CGRectBorrowRejectsExpiredInputsAndChangedABI отклоняет восемь изменений инициализации, границ, импортов и носителей ABI. GeneratedCMatchesOriginalMachineAndSDKResults дополнительно выполняет всю последовательность при O0/O2 в 1000 случаях с исходными словами инструкций и нативным SDK, сравнивая сохраненный угол, все 48 байтов результата, объекты и защитные значения.

FrameMetadataAccessorUsesCurrentCatalogAndABI проверяет общее объявление метаданных, оба регистра ответа и публикацию текущего frame-witness. FrameMetadataAccessorRejectsChangedImportAndBytes отвергает слабые импорты, изменения поставщика/имени/addend, запросы с частными адресами, частичные spill, неверные перезагрузки и изменённые исходные вызовы. Oracle исходного ARM64 и сгенерированного C также вызывает реальный доступ к метаданным Foundation URL: обе ветви выполняют по 2048 случаев при O0/O2, проверяя динамический выбор witness, все выходные байты, сохранность входов, число вызовов и защитные значения. Динамическое выделение стека и эффекты памяти witness этим не доказываются.

AArch64ExclusiveTests.cpp проверяет разрядности, пары, acquire/release, перекрытия регистров, псевдонимы, ошибки, снимки, остановку или сбой наблюдателей и конкуренцию CPU. RAMReservationTests.cpp проверяет одинаковые записи, ABA, повторное выделение, откат и влияние строковых инструкций и ENTER в KVM/Unicorn. Исходные процессы Windows ARM64 выполняют эксклюзивные циклы. scripts/check_aarch64_exclusives.py фиксирует исходные инструкции и исключения выравнивания в Windows ARM64 CI. Эти наблюдения не подтверждают выполнение ARM64-бэкендов KVM/WHP; недоступные профили явно пропускаются. Те же тесты охватывают программный Unicorn, взаимодействие контрактов, одинаковые и ABA-записи, исполняемые псевдонимы в одном запуске, а также DC ZVA и отмену наблюдателями. windows-alignment-oracle.yml также запускает ARM64-пробу: 1 320 наблюдений охватывают все невыровненные смещения, четыре последовательности чтения/записи и доступную для записи, только для чтения, недоступную и пересекающую границу страниц память. Сохраняются полная разрядность начальных значений регистров и частичные записи до ошибки. WindowsExclusiveProcessTests.cpp сравнивает 1 320 исходных наблюдений Windows ARM64 с нативными хешами в WindowsExclusiveNative.def. Нормализуется только размещение кода и данных; значения регистров, метаданные исключений и эффекты RAM сохраняются.

AArch64AtomicTests.cpp проверяет 168 независимо ассемблированных кодировок LSE, наложения регистров, знаковые сравнения, права, отмену, физические резервирования и NZCV. scripts/check_aarch64_atomics.py собирает 1 100 исходных записей Windows ARM64 с полными результатами, контекстом исключений и областью RAM; тесты парсера отвергают неполные и противоречивые доказательства. Нативное исполнение KVM/WHP проверяется отдельно. WindowsAtomicProcessTests.cpp проверяет процесс checked; WindowsAtomicResults.def хранит хеши полных записей.

Структурно константные нативные цели напрямую используют существующее планирование с проверкой достижимости. Единственная символическая цель сохраняет входной предикат только после полного перебора. Регрессии проверяют 128 константных переходов с бюджетом запросов линейного исполнения и 32 вычисляемых перехода с двумя запросами перебора на переход, сохраняя свободные старшие биты адресов и области ветвей. Изменённые полные состояния, отсутствие выравнивания, нулевой лимит целей и недостаточные бюджеты запросов или инструкций отклоняются. Существующие проверки отказа для нескольких целей и неполного перебора остаются обязательными.

Нативная ветвь сохраняет входную область на одном ребре только после завершённого доказательства UNSAT, исключающего другое ребро. Тесты проверяют 32 условных перехода в обоих направлениях при лимите 512 вентилей решателя, точный и уменьшенный на один запрос бюджеты, а также исчерпание вентилей. Изменённое или отсутствующее выравнивание, обратные сравнения и изменённое конечное состояние должны отклоняться; существующие тесты произвольного неопределённого управления и двух достижимых рёбер остаются обязательными.

Кеши битового кодирования и память обхода учитывают только достигнутые узлы выражений и переменные. NeverDSolverTests проверяет большие разреженные идентификаторы, рост контекста между инкрементальными утверждениями, повторное использование сохранённых битов, извлечение моделей и смену предположений. Несвязанные широкие выражения не кодируются; достигнутые нарушения ширины, некорректные корни и исчерпанные бюджеты вентилей по-прежнему отклоняются.

SourceFrameAnalysis.CallStorage* проверяет точные вызовы, достигающие определения, инициализацию, заполнители, утечки, границы и циклы без допуска исходного кода. ObjCFrameBlockBorrows.* проверяет синхронное заимствование в границах дескриптора и 19 изменений импортов, заголовков, ABI и инструкций. Заполнители остаются недоказанными, поля владения без инициализации отклоняются. Построение блока, чтение захватов и замыкание зависимостей callback по-прежнему проверяются отдельно перед публикацией.

Тесты публикации block и копии также проверяют два непересекающихся диапазона по 48 байт, пересечение дескриптора, изменения тел callback, устаревшие машинные инструкции и IR, вызовы вне исходного тела и точный порядок проекций. MixedWidthFrameCopiesMeetEveryInitializedByte и FrameCoverageCannotHideMissingBytesOrPointerJoins проверяют записи по 8/16 байт в обоих порядках слияния, отсутствующие байты, сброс после изменяемого заимствования и идентичности указателя, сохраняющиеся после частичной перезаписи.

Тесты отношений циклов проверяют фиксированные и изменяемые временные значения при произвольном числе итераций, отдельные смещения сторон, парные планы, частичные и невыровненные диапазоны, оба порядка байтов и ранги на временных значениях. При машинной композиции новые слоты остаются только у кандидата. Отсутствие префикса, необъявленные или неопределённые байты, неверные проекции, пропущенные присваивания, изменённое поведение и несовпадающие определения запрещают сертификаты. Точные бюджеты выполнения, запросов и наблюдений проходят, уменьшенные на единицу — нет. Вывод не увеличивает бюджет последующего доказательства. Время жизни связано с дайджестом; обычный машинный ABI не доказывается.

Тесты нативных циклов проверяют отложенный сбор условных ветвей и непроверенные границы отказа при произвольном числе итераций. Ручные и выведенные планы заново проверяют всю входную и индуктивную область; достижимые неверные ветви, изменённые нативные обновления и исчерпанные бюджеты запросов или инструкций запрещают сертификаты. Тесты связывают изменённые байты недостижимых границ, сохраняют строгие значения по умолчанию и отказ для неверных планов, проверяют оба свидетеля и сочетания опций, а также отказ статических API и перекрывающихся инструкций. Семантическая схема 17 связывает этот допуск; обычный нативный ABI и композиция исходника остаются отдельными обязательствами.

ObjCSuperGetterSources проверяет геттеры CGRect с четырьмя носителями, десять отклоняемых изменений данных публикации и вызывающие функции Boolean/CGRect с общим машинным телом. Проверка исполнения при O0 и O2 сравнивает точные биты результата (включая отрицательный ноль, бесконечность и полезную нагрузку NaN), идентичность получателя/класса и загрузку селектора после вызова метаданных. Apple ARM64 исполняет исходный thunk компилятора и сгенерированный C; другие платформы исполняют сгенерированный C с собственным ABI структур.

LowIRLoopInference проверяет проекции 8-, 24- и 32-битных счётчиков с произвольными начальными старшими битами, оба направления, регистры, кадры, временные значения функции и оба порядка байтов. Полные доказательства проходят; изменения результата, отсутствие прогресса, узкое переполнение и пропуск выхода по равенству отвергаются. Точные бюджеты операций, запросов, путей, кандидатов ранга и расширений проходят, уменьшенные на единицу — нет. Бюджеты операций, запросов и наблюдений окончательного доказательства проверяются отдельно.

ObjCCallHints.SDKRecordData* проверяет обе внешние записи, смещение каждого double, обе архитектуры Darwin и псевдонимы поставщика, а также изменённые и слабые импорты, отсутствующие библиотеки, конфликтующие исправления, записываемое хранилище и неполные диапазоны. python3 -m unittest scripts.tests.test_generate_darwin_record_data_declarations scripts.tests.test_generate_darwin_data_declarations проверяет конфликты профилей, альтернативные структуры, неверные размеры/выравнивание, TLS и экспорты для разных архитектур. Каталог воспроизводится через generate_darwin_record_data_declarations.py с закреплёнными SDK, libclang, путём вывода и --check; такая проверка объявлений не доказывает инициализацию косвенного нативного результата или восстановление методов.

LowIRLoopInference.ProjectedBounds* проверяет выходы по равенству с произвольными старшими битами счётчиков и границ, поля 8/24/32 бит, три вида хранения и оба порядка байтов. Доказательства отвергают изменения границ, отсутствие прогресса, пропуск выхода, переполнение и изменения наблюдаемых старших входных байтов. Бюджеты вывода и доказательства раздельны; проверяются точный лимит и лимит на единицу меньше.

LowIRLoopInference.LateCounter* проверяет постоянную инициализацию, при которой поля 8/24/32 бит видны лишь после обобщения: регистры, кадры, временные значения функции, оба порядка байтов и произвольные старшие биты границ. Выходы по равенству проходят полное доказательство; отсутствие прогресса, пропуск выхода, меняющиеся границы и изменения наблюдаемых старших байтов отвергаются. Точные бюджеты и бюджеты на единицу меньше проверяются отдельно для вывода и окончательного доказательства.

LowIRLoopInference.ProjectedComparisonBits* проверяет сохранённое равенство узких полей в заголовках циклов с произвольными старшими битами границ: 8/24/32 бита, три вида хранения, оба порядка байтов, постоянную инициализацию или заполнение старших битов. Доказательства отвергают изменения кэша, наблюдаемых старших байтов и границ, отсутствие прогресса и пропуск выхода. Точный бюджет и бюджет на единицу меньше проверяются отдельно для вывода и окончательного доказательства.

LowIRLoopInference.OrderedComparisonBits* проверяет оба булевых кодирования выходов по беззнаковому порядку: счётчики 8/24/32 бит, три вида хранения и оба порядка байтов. Полные доказательства отвергают незавершающиеся обновления, изменения сравнений, границ и наблюдаемых старших байтов. Точные бюджеты и бюджеты на единицу меньше раздельны. При изменении кодирования тест заново связывает дайджест исходных операций перед доказательством.

LowIRLoopInference.MutablePrefixBounds* охватывает вычисленные границы 8/24/32 бит с изменяющимися старшими битами, три вида хранения счётчика, оба порядка байтов и прямые/кэшированные выходы. Проверяются незавершение, подвижные границы равенства, наблюдаемые изменения старших битов/кэша и точные бюджеты либо на единицу меньше. Подвижная граница беззнакового порядка может завершить цикл при переполнении; отдельный тест проверяет полное доказательство.

LowIRLoopInference.SharedTemplatesFitIndependentOperationBudgets доказывает вложенные частичные счётчики в пределах 1 024 операций вывода и 640 операций независимого доказательства. Одинаковые чистые выражения и неизменяемые чтения префикса переиспользуются только внутри одной перестройки точки разреза с сохранением идентичности операндов, ширины результата и пространства расположения. Тесты наблюдают полные слова счётчиков и границ, отвергают изменённое вычисление префикса и бюджеты, уменьшенные на одну операцию. Существующие случаи для регистров, кадров, временных значений функций, порядка байтов и незавершающихся циклов остаются обязательными.

LowIRLoopInference.CompletedEntailments* проверяет изоляцию сеансов для завершающихся и незавершающихся циклов с кадром при обоих порядках байтов, исчерпание лимитов решателя/узлов и отдельные бюджеты доказательства. Регрессии с изменяемыми границами проверяют точный бюджет логических запросов и бюджет на единицу меньше при попаданиях в кэш; нативные доказательства с повторными контекстами проверяют учёт области при повторном использовании.

LowIRLoopInference.IncrementalEntailmentsKeepRollingBudgets проверяет повторное использование кодировщика в одной области ограничений. При смене области кодировщик удаляется; исчерпание накопленного лимита вентилей допускает лишь одну повторную попытку с новым кодировщиком, расходующую ещё один запрос. Полные слова счётчиков и границ наблюдаются при обоих порядках байтов; проверяются точный бюджет запросов и бюджет на один запрос меньше, отказ при превышении лимитов вентилей, разрядности или поиска и независимый бюджет окончательного доказательства.

LowIRLoopInference.RebuiltCounterLanes* проверяет точно распознанные обновления проекций, когда остальные биты счётчика восстанавливаются из префикса или меняются независимо. Регистры, кадр и временные значения функции проверяются при обоих порядках байтов, счётчиках шириной 1/3/4 байта и прямых либо сохранённых условиях выхода; счётчики, границы и метки наблюдаются целиком. Удаление наблюдаемой старшей метки, нетерминирующие обновления, отсутствие условия выхода и бюджет вывода или доказательства на единицу меньше требуемого должны по-прежнему отклоняться. Структурное распознавание рекуррентности лишь предлагает расширения и ранги; полные доказательства переходов и окончательное доказательство остаются обязательными. Фиксированные бюджеты операций и запросов также проверяют символьные проекции счётчиков без разрастания случайных совпадений в константном префиксе в дополнительные отношения.

LowIRLoopInference.ProjectedCounterCopies* проверяет вложенные циклы, копирующие разрядную полосу счётчика через слово с независимой меткой перед увеличением. 144 проверки полного состояния охватывают регистры, кадры, временные значения функции, оба порядка байтов, полосы по 1/3/4 байта, прямые и сохранённые условия выхода и контрольные копии целых слов. Проецируемые равенства должны выполняться для сохранённых состояний входа и каждого входящего перехода; старшие биты остаются независимыми. Доказательство импликации в области перехода позволяет распознать аддитивную рекуррентность через разные параметры. Потеря старших меток, неверные обновления, отсутствие защитных условий и нехватка одной единицы бюджета вывода или итогового доказательства по-прежнему приводят к отказу.

LowIRLoopInference.TransferredCounters* проверяет счётчик, меняющий место хранения между точками разреза, когда другие циклы могут обходить каждую точку. Точные символические переносы с единичным шагом предлагают ограничения исходного счётчика и запасной ранг с другим местом чтения в одной точке; все ограничения и ранги требуют полного доказательства переходов. 192 проверок полного состояния охватывают регистры, кадры, временные значения функции, оба порядка байтов, счётчики по 1/3/4/8 байт, независимые метки и контрольные случаи без переноса. Изменённые результаты или метки, неверные ранги, нетерминирующие обновления, отсутствующие ограничения и недостаточные бюджеты вывода или итогового доказательства отклоняются. Обход использует существующий лимит символических узлов; бюджет необязательных селекторов графа может оставаться нулевым. Проверяются уменьшение до нуля и увеличение до входной границы. При обнаружении нового счётчика удаление границ и ограничений битового поля откладывается до перестроения шаблонов всех точек разреза; обычное расширение и независимое доказательство продолжаются.

LowIRLoopRefinement.GuardedCuts* и BinaryLowIRLoopRefinement.GuardedCuts* проверяют повторяющиеся PC, регистры/кадр/флаги, оба порядка байтов, невыбранные конечные и циклические пути, пересечения, неверные стороны, обобщение, свидетелей неопределённых значений, метаданные, дайджесты и бюджеты. Независимые нативные тесты доказывают два контекста R10 на одном PC и приоритет непроверенных границ. Сертификация обычного ABI остаётся отдельной задачей.

BinaryLowIRLoopInference.NativeSelectors* проверяет два регистровых контекста, контексты, различимые только по кадру, конъюнкции трёх областей, неразделимые шаблоны, изменения источников и нативного тела, а также независимые точные бюджеты и бюджеты на единицу меньше. Число итераций произвольно, входные константы не добавляются.

DarwinIndirectRecordCalls проверяет текущий контракт MakeScale и 22 изменения импорта/ABI, затем использует полный частный результат размером 48 байт через общее доказательство копирования по значению. Несогласованные по выравниванию, смещённые, пересекающиеся и выходящие за кадр диапазоны результата отклоняются. Удаление эффекта гарантированной записи также приводит к отказу, даже при сохранении полного ABI возврата.

SourceFrameAnalysis.IncomingResultAddressNeedsCompleteEntryIdentity отклоняет десять изменений входа, носителя или записи и отсутствие ABI входа. NativeSourceHints.IndirectResultTailCallRetainsExplicitOutputAddress повторно поднимает прямой хвостовой вызов и проверяет явный выходной параметр, шесть записей и барьер публикации.

NativeSourceHints.FourDoubleCallerDemandNeedsEveryUnchangedCarrier проверяет четыре младшие полосы, независимые старшие записи и девять изменений объявления/управления. FourDoubleReturnRequiresEveryComputedLowLane отклоняет двенадцать случаев неполного результата или устаревшего контракта. DarwinNativeRecordReturns.FourComputedDoublesExecuteAtO0AndO2 сравнивает все 32 байта с независимым арифметическим оракулом на 2048 случаях для каждого уровня оптимизации.

DarwinIndirectRecordCalls.AffineInvertSnapshotsItsCompleteAliasedInput выполняет по 2560 случаев при O0 и O2 с совпадающими, перекрывающимися и раздельными входами/выходами. Проверяются входные биты, один вызов, все 48 байтов результата и весь защищённый буфер. Это оракул физического копирования и снимка, а не исполнение исходной машины или нативного SDK. Тест текущих матричных/аффинных контрактов сохраняет 22 отклонённых изменения на контракт.

DarwinIndirectRecordCalls.AffineTranslatePreservesScalarBitsAndSnapshotsAliasedInput выполняет по 2560 случаев при O0 и O2. Проверяются битовые представления обоих скаляров, все шесть входных полей, один вызов, все выходные байты и защищённая память при одинаковом, перекрывающемся и раздельном размещении. Четыре изменения скалярного ABI и общие 22 изменения импорта/ABI отклоняются. Побитовая заглушка проверяет физические аргументы и предварительную копию; это не математический оракул переноса и не выполнение исходного машинного кода.

NativeFloatingReturnProof.HFAResultFieldsNeedTheExactCompleteDefinedCall проверяет девять вариантов выбора поля и семнадцать отклонённых изменений вызова, носителя, ширины, смещения или SSA. HFAFieldExtractionNeedsADominatingCall отклоняет производителя на соседнем пути. NativeSourceHints.HFAFieldTypeRequiresCurrentCallAndFrameProofForPublication лифтит ARM64-вызывающую функцию из пяти команд, повторно лифтит выведенный скалярный результат и проверяет публикацию; неверный поставщик или отсутствие восстановления LR/SP отклоняется. Проверяется типизация и проекция исходного кода, а не выполнение исходного машинного тела.

Явное вытеснение CPU0, виртуальное время и ограничения описаны в планировании драйверов.

SwiftOnceSources.FoldedObjCGetterTailsExecuteOnceAndRetainsAtO0AndO2 сворачивает реальные хвосты возврата ARM64/x64 с совмещёнными или отдельными retain и отдельными или встроенными предикатами, затем исполняет полученный C со стабами runtime при O0/O2. Проверяются биты результата, однократная инициализация, порядок вызовов и изменённое кешированное значение. FoldedObjCGetterTailsRevalidateCurrentStorageAndCalls отклоняет изменения ширины, упорядочения, intrinsic, хранилища, результата, вызовов и текущих импортов даже с сохранённым планом. Это контролируемые проверки исходника и стабов, а не исполнение исходной машины WMF или нативного runtime Swift.

SourceFrameAnalysis.CompleteOutput* проверяет полные и короткие префиксы, объединения всех возвратов, хвостовые записи SDK, отсутствующие байты, утечки указателей и ограничения носителей ABI. Случаи вызывающей функции отклоняют отсутствующие или короткие сертификаты, неверное выравнивание, выход за кадр и перекрытие сохранённых регистров, алиасы, аннулирование последующей записью и перекрытие живых непрозрачных значений. NativeSourceHints.CompleteNativeOutput* повторно проверяет ассемблированные ARM64-производители и потребители, требует полный входной диапазон SDK и отклоняет устаревшие доказательства кода, CFG, ABI, аудита, поставщика и экземпляра вызова. Это проверки инициализации байтов и допуска исходного кода; они не исполняют исходное машинное тело и не сертифицируют нативный логический возврат.

MedCallingConvValueFlow.FPInputsFollowOnlyAuthenticatedCallPrefixes / NativeSourceHints.PreservedFPPrefixesRetainAllEntryInputsAfterSDKCalls: Регрессии префикса проверяют три допустимых чтения и девятнадцать отклоняемых случаев носителей, префиксов, владельца вызова и неиспользуемых значений. Ассемблированная ARM64-функция сохраняет все четыре входные double-линии через вызов SDK; повторный лифтинг проверяет полный ABI параметров и допуск исходного кода. Неизменённый принятый метод WMF 0x36350 также проходит по 2048 случаев при O0 и O2 против независимого нативного выражения CoreGraphics для отражения, переноса, нормализации, конкатенации и применения: все 32 байта результата, получатель/селектор и защитные области входа, включая нулевые, отрицательные, бесконечные и NaN-размеры. Исходное машинное тело WMF не исполняется.

SourceABI.SwiftEntryCapturesAndReturnsTheErrorRegisterOnEveryPath проверяет захват ARM64/x64, оба пути возврата и отказ при отсутствующих или изменённых доказательствах передачи. NativeSwiftCallsKeepBothResultsAndPostCallErrorBranches сохраняет результат, обновлённый регистр ошибки и последующее условие, включая коллизии внутренних имён и оба порядка вывода. Созданный C выполняется при O0/O2 на нативной цели Darwin и сравнивается с независимыми эталонами успеха и ошибки. SwiftFunctionSymbols.RegularExpressionInitializerRetainsContextAndError отклоняет псевдонимы, изменённые полные символы, входы вне кода и неподдерживаемые форматы образов. Тесты не исполняют исходный конструктор WMF и не доказывают полное восстановление вызывающих методов.

NativeSourceHints.SwiftErrorDeclaration* повторно поднимает ассемблированные точки входа ARM64/x64 после замены скалярного ABI, выведенного из наблюдений, декларацией компилятора. Отсутствующий или неполный текущий аудит запрещает замену; явные исходные контракты в параметрах, MedIR или HighIR сохраняют приоритет. Тесты точек входа также отклоняют отсутствие метки выхода ошибки MedIR или неверную ширину операнда до преобразования в HighIR.

Снимок входного значения остаётся корнем живости, даже если все пути перезаписывают регистр ошибки, в том числе при окончательной очистке исходного представления после связывания once. NativeSourceHints.SwiftErrorCallsRequireCurrentDirectNativeProjection отклоняет отсутствующие, нулевые, изменённые или недоказанные вызываемые функции, изменённые цели, косвенные вызовы, неполные результаты, отсутствующие операнды и несовместимые эффекты.

SwiftFunctionSymbols.RepeatedDeclarationsKeepEveryRecordField проверяет идентичные повторные записи и отклоняет изменённые имена, размеры, происхождение границ или имён. NativeSourceHints.SwiftErrorCallResults* проверяет автоматический вывод для вызывающих функций ARM64/x64 и отклоняет отсутствующие текущие цели, изменённые машинные операции, устаревшие аудиты, неполные ABI и отсутствующие, суженные или посторонние извлечения результатов. Исполнение исходного кода входа также покрывает конфликтующие необязательные отладочные объявления, сохраняя связанную конвенцию и роли ошибки и контекста.

Генераторы Swift witness проверяют CurrentValueSubject: Publisher и Range<Bound: Comparable>: RangeExpression на ARM64/x86-64 для macOS и Mac Catalyst. scripts.tests.test_generate_swift_witness_contracts отвергает изменения обобщённых входов, типов или членов ответа метаданных, прототипов, поставщиков экспортов и неполный поток. ObjCSourceBindings.SwiftWitnessUndefRequiresGenericDescriptorContract и SwiftWitnessUndefRejectsUnprovedInputAndABI проверяют оба дескриптора на обеих архитектурах: по 33 мутации на дескриптор и архитектуру для идентичности runtime/импорта, слабого или конфликтующего хранения, ABI и эффектов. Эти каталоги не предоставляют контрактов размещения или заимствования кадра.

scripts.tests.test_generate_swift_data_declarations проверяет полный запрос дескриптора String.Index и отвергает изменения символических ячеек, байтов или длины рецепта, потока метаданных/кеша, ABI runtime и повторяющиеся или отсутствующие определения. ObjCSourceBindings.SwiftRangeIndexDescriptorKeepsItsCompleteRecipe проверяет не начальный дескриптор со смещением 3 на обеих архитектурах; SwiftRangeIndexDescriptorRejectsStaleIdentityAndRecipe отвергает по 20 мутаций и повторно проверяет опубликованные подсказки адресов и генерацию helper.

ObjCSourceBindings.PrivateFramePointerTailRequiresExactStoreOnEveryPath проверяет циклы объектных переменных после объединения PHI и значение частного кадра в том же цикле. Объектный цикл сохраняет точный перенос указателя через память; значение кадра, частичная перезапись и неизвестная утечка кадра отклоняют доказательство.

ObjCCallHints.FoundationGenericNSRangeKeepsSixPointersAndTwoWords проверяет обе архитектуры, поставщиков и все аргументы и результаты; отклоняет слабые импорты, смещения, чужих поставщиков, устаревшие символы и выдуманные эффекты заимствования.

Читатель String в scripts.tests.test_generate_swift_witness_contracts проверяет полный поток, отклоняет 28 изменений памяти, ABI и потока и семь неоднозначных объявлений, ограничивая входные данные. Тесты привязки охватывают три дескриптора на обеих архитектурах с 33 изменениями для каждой пары. Идентичность не разрешает размещение кадра или заимствование.

PreparedFiniteKeys.* проверяет уничтожение контекста и переименование, порядок и пределы проекций, явную недействительность после перемещения, некорректные и неполные результаты, пустые и неединственные области значений, точные границы ёмкости. Существующие регрессии кэша и кадра также проверяют этот путь.

SourceABI.SwiftPointTransformKeepsTwoFloatingInputsAndResults отклоняет изменения регистров, раскладки, роли контекста и косвенного результата на обеих архитектурах. SourceABI.SwiftPointForwardingPreservesBothIEEECarriers выполняет исходный код передачи при -O0/-O2 и проверяет знаковые нули, субнормальные числа, бесконечности и полезную нагрузку NaN в обоих полях. Тесты деклараций принимают формы компилятора и именованные аргументы, отклоняя изменённые сигнатуры и неоднозначные идентичности.

Navigation Menu

Repository navigation

Тестирование NeverD

Настройка тестовой сборки

Проверки восстановления интерпретатора

Проверки управления и вызовов в структурированном C

Проверки выполнения CPU

Тесты профиля Linux-процессов

Проверки эмуляции драйверов

Структура тестов

Зафиксированный бинарный corpus

Создание fixture

Fixture подъёма и форматов

Fixture безопасности памяти

Реконструкция исключений Windows

Языковые модели исключений

Дифференциальные циклы Unicorn

Дифференциальные бэкенды EVM

Регрессии публичных границ и бюджетов EVM

Дифференциальные бэкенды Solana SBF

Однокомандные цели

Инкрементальный процесс CTest

Какие тесты должны меняться вместе с кодом?

Связь с CI

Текущий профиль соответствия и sanitizer для Solana SBF

Закреплённый snapshot SBF-свидетельств (2026-08-24)

Производительность инвентаризации классов Android

Производительность поиска ссылок в коде Android

Свидетельства экспорта мобильных SDK

Доказательства ABI мобильных строк Swift

Модульное упрощение MBA

Матрица тестов ARM32 и продвижения значений кадра

Нативные синхронные исключения x64

Подготовленные эффекты RAM

Полное состояние x87

Измерения CPU ARM64

FilesExpand file tree

testing.md

Latest commit

History

testing.md

File metadata and controls

Тестирование NeverD

Настройка тестовой сборки

Проверки восстановления интерпретатора

Проверки управления и вызовов в структурированном C

Проверки выполнения CPU

Тесты профиля Linux-процессов

Проверки эмуляции драйверов

Структура тестов

Зафиксированный бинарный corpus

Создание fixture

Fixture подъёма и форматов

Fixture безопасности памяти

Реконструкция исключений Windows

Языковые модели исключений

Дифференциальные циклы Unicorn

Дифференциальные бэкенды EVM

Регрессии публичных границ и бюджетов EVM

Дифференциальные бэкенды Solana SBF

Однокомандные цели

Инкрементальный процесс CTest

Какие тесты должны меняться вместе с кодом?

Связь с CI

Текущий профиль соответствия и sanitizer для Solana SBF

Закреплённый snapshot SBF-свидетельств (2026-08-24)

Производительность инвентаризации классов Android

Производительность поиска ссылок в коде Android

Свидетельства экспорта мобильных SDK

Доказательства ABI мобильных строк Swift

Модульное упрощение MBA

Матрица тестов ARM32 и продвижения значений кадра

Нативные синхронные исключения x64

Подготовленные эффекты RAM

Полное состояние x87

Измерения CPU ARM64