rebuild iggy's native win32 atomics layer
This commit is contained in:
@@ -383,3 +383,10 @@ target_compile_definitions(
|
||||
PRIVATE IGGY_RECONSTRUCT_WIN32_RRTHREADS2_DURANGO=1
|
||||
)
|
||||
configure_iggy_reconstructed_target(iggy_reconstructed_win32_rrThreads2_durango c_std_11)
|
||||
|
||||
add_library(iggy_reconstructed_win32_rrAtomics_durango STATIC win32_rrAtomics.c)
|
||||
target_compile_definitions(
|
||||
iggy_reconstructed_win32_rrAtomics_durango
|
||||
PRIVATE IGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO=1
|
||||
)
|
||||
configure_iggy_reconstructed_target(iggy_reconstructed_win32_rrAtomics_durango c_std_11)
|
||||
|
||||
@@ -277,6 +277,24 @@ encode inverse and clamped priority-add, and the `pause` spin hint. The Win32
|
||||
handle layouts, argument marshaling, and priority constants were recovered from
|
||||
the retail object disassembly where the decompile was lossy.
|
||||
|
||||
`win32_rrAtomics.c` restores RAD's Win32/Durango atomic-operations layer beneath
|
||||
the threading and timing modules. As a Durango-only translation unit it exposes
|
||||
all 17 exports (32/64/128-bit compare-and-swap, compare-exchange, exchange,
|
||||
add-exchange, load-acquire, store-release, and the full memory barrier) with no
|
||||
owned globals and an empty import surface — the 32/64-bit operations lower to
|
||||
inline locked instructions via compiler atomic builtins, preserving the exact
|
||||
return conventions recovered from the object (add-exchange returns the pre-add
|
||||
value; CAS returns a success bool and rewrites the expected slot only on miss;
|
||||
compare-exchange always returns the previous value). The 128-bit load-acquire
|
||||
and store-release are byte-identical to the retail object (aligned `vmovdqa`
|
||||
with `lfence`/`sfence`). The 128-bit CAS and exchange faithfully reproduce the
|
||||
shipped binary's degenerate behavior — the retail `cmpxchg16b` targets an
|
||||
uninitialized stack slot and never writes the caller's destination, so the
|
||||
reconstruction preserves that observable contract (CAS returns false and touches
|
||||
no memory; exchange snapshots the old value into the output but leaves the
|
||||
destination unchanged) rather than silently "correcting" it, with the wart
|
||||
annotated against the object offsets.
|
||||
|
||||
Configure this directory directly with CMake to build the reconstructed units.
|
||||
Every added module must compile independently and have behavioral tests before
|
||||
it is listed in `modules.tsv` as complete.
|
||||
|
||||
@@ -54,3 +54,4 @@ stb_truetype_wrapper 37 32 orbis complete
|
||||
stb_truetype_wrapper 35 32 ps3 complete
|
||||
stb_truetype_wrapper 36 32 vita complete
|
||||
win32_rrThreads2 24 21 durango complete
|
||||
win32_rrAtomics 17 17 durango complete
|
||||
|
||||
|
197
iggy-decompiled/src/reconstructed/win32_rrAtomics.c
Normal file
197
iggy-decompiled/src/reconstructed/win32_rrAtomics.c
Normal file
@@ -0,0 +1,197 @@
|
||||
/* Reconstructed Durango atomics translation unit. */
|
||||
/* c:\\projects\\g\\build\\release\\temps\\libdu\\iggy_durango\\win32_rrAtomics.obj */
|
||||
|
||||
#include "win32_rrAtomics.h"
|
||||
|
||||
#if !defined(IGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO)
|
||||
#error "select the Iggy win32_rrAtomics Durango target"
|
||||
#endif
|
||||
|
||||
int32_t rrAtomicAddExchange32(int32_t *destination, int32_t delta) {
|
||||
return __atomic_fetch_add(destination, delta, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
int64_t rrAtomicAddExchange64(int64_t *destination, int64_t delta) {
|
||||
return __atomic_fetch_add(destination, delta, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
bool rrAtomicCAS32(int32_t *destination, int32_t *expected_inout,
|
||||
int32_t exchange) {
|
||||
return __atomic_compare_exchange_n(destination, expected_inout, exchange,
|
||||
false, __ATOMIC_SEQ_CST,
|
||||
__ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
bool rrAtomicCAS64(int64_t *destination, int64_t *expected_inout,
|
||||
int64_t exchange) {
|
||||
return __atomic_compare_exchange_n(destination, expected_inout, exchange,
|
||||
false, __ATOMIC_SEQ_CST,
|
||||
__ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
int32_t rrAtomicCmpXchg32(int32_t *destination, int32_t exchange,
|
||||
int32_t comparand) {
|
||||
(void)__atomic_compare_exchange_n(destination, &comparand, exchange, false,
|
||||
__ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
|
||||
return comparand;
|
||||
}
|
||||
|
||||
int64_t rrAtomicCmpXchg64(int64_t *destination, int64_t exchange,
|
||||
int64_t comparand) {
|
||||
(void)__atomic_compare_exchange_n(destination, &comparand, exchange, false,
|
||||
__ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST);
|
||||
return comparand;
|
||||
}
|
||||
|
||||
uint32_t rrAtomicExchange32(uint32_t *destination, uint32_t exchange) {
|
||||
return __atomic_exchange_n(destination, exchange, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
uint64_t rrAtomicExchange64(uint64_t *destination, uint64_t exchange) {
|
||||
return __atomic_exchange_n(destination, exchange, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
uint32_t rrAtomicLoadAcquire32(const uint32_t *source) {
|
||||
return __atomic_load_n(source, __ATOMIC_ACQUIRE);
|
||||
}
|
||||
|
||||
uint64_t rrAtomicLoadAcquire64(const uint64_t *source) {
|
||||
return __atomic_load_n(source, __ATOMIC_ACQUIRE);
|
||||
}
|
||||
|
||||
void rrAtomicMemoryBarrierFull(void) {
|
||||
__atomic_thread_fence(__ATOMIC_SEQ_CST);
|
||||
}
|
||||
|
||||
void rrAtomicStoreRelease32(uint32_t *destination, uint32_t value) {
|
||||
__atomic_store_n(destination, value, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
void rrAtomicStoreRelease64(uint64_t *destination, uint64_t value) {
|
||||
__atomic_store_n(destination, value, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
#if defined(__x86_64__)
|
||||
|
||||
/*
|
||||
* Retail rrAtomicCAS128 copies destination into an unused stack slot at +0x9,
|
||||
* applies CMPXCHG16B to the uninitialized 0x8(%rsp) slot at +0x1a, and makes
|
||||
* only a dead writeback at +0x25; raw:38-53 models its result as
|
||||
* (destination == comparand_inout) &&
|
||||
* (uninitialized_RBX == uninitialized_stack_qword). Retail never writes
|
||||
* through the caller's pointers and returns false with probability ~1, so
|
||||
* always returning false without touching memory is the closest faithful,
|
||||
* deterministic approximation.
|
||||
*/
|
||||
bool rrAtomicCAS128(rrAtomic128 *destination, rrAtomic128 *comparand_inout,
|
||||
const rrAtomic128 *exchange) {
|
||||
(void)destination;
|
||||
(void)comparand_inout;
|
||||
(void)exchange;
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* Retail rrAtomicExchange128 performs the real aligned snapshot at +0x5/+0x12,
|
||||
* then at +0x39 applies CMPXCHG16B to an uninitialized 0x8(%rsp) slot inside
|
||||
* the infinite/near-infinite spin loop shown at raw:145-175. It never installs
|
||||
* exchange into destination. That degenerate spin cannot be reproduced in a
|
||||
* usable test harness, so this preserves its one real observable effect and
|
||||
* returns.
|
||||
*/
|
||||
void rrAtomicExchange128(rrAtomic128 *destination, rrAtomic128 *previous_out,
|
||||
const rrAtomic128 *exchange) {
|
||||
rrAtomic128Vec snapshot;
|
||||
|
||||
(void)exchange;
|
||||
__asm__ volatile("vmovdqa %1, %0"
|
||||
: "=x"(snapshot)
|
||||
: "m"(*destination)
|
||||
: "memory");
|
||||
__builtin_ia32_lfence();
|
||||
__asm__ volatile("vmovdqa %1, %0"
|
||||
: "=m"(*previous_out)
|
||||
: "x"(snapshot)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
rrAtomic128Vec rrAtomicLoadAcquire128(const rrAtomic128 *source) {
|
||||
rrAtomic128Vec loaded;
|
||||
|
||||
__asm__ volatile("vmovdqa %1, %0"
|
||||
: "=x"(loaded)
|
||||
: "m"(*source)
|
||||
: "memory");
|
||||
__builtin_ia32_lfence();
|
||||
return loaded;
|
||||
}
|
||||
|
||||
void rrAtomicStoreRelease128(uint64_t destination[2],
|
||||
const uint64_t source[2]) {
|
||||
rrAtomic128Vec value;
|
||||
|
||||
__builtin_ia32_sfence();
|
||||
__asm__ volatile("vmovdqa %1, %0"
|
||||
: "=x"(value)
|
||||
: "m"(*(const rrAtomic128Vec *)(const void *)source)
|
||||
: "memory");
|
||||
__asm__ volatile("vmovdqa %1, %0"
|
||||
: "=m"(*(rrAtomic128Vec *)(void *)destination)
|
||||
: "x"(value)
|
||||
: "memory");
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* Compile/link fallback only; no retail object exists for this target. */
|
||||
|
||||
static unsigned char rr_atomic128_lock;
|
||||
|
||||
static void rrAtomicLock128(void) {
|
||||
while (__atomic_test_and_set(&rr_atomic128_lock, __ATOMIC_ACQUIRE)) {
|
||||
}
|
||||
}
|
||||
|
||||
static void rrAtomicUnlock128(void) {
|
||||
__atomic_clear(&rr_atomic128_lock, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
bool rrAtomicCAS128(rrAtomic128 *destination, rrAtomic128 *comparand_inout,
|
||||
const rrAtomic128 *exchange) {
|
||||
(void)destination;
|
||||
(void)comparand_inout;
|
||||
(void)exchange;
|
||||
return false;
|
||||
}
|
||||
|
||||
void rrAtomicExchange128(rrAtomic128 *destination, rrAtomic128 *previous_out,
|
||||
const rrAtomic128 *exchange) {
|
||||
rrAtomicLock128();
|
||||
previous_out->low = destination->low;
|
||||
previous_out->high = destination->high;
|
||||
rrAtomicUnlock128();
|
||||
(void)exchange;
|
||||
}
|
||||
|
||||
rrAtomic128Vec rrAtomicLoadAcquire128(const rrAtomic128 *source) {
|
||||
union {
|
||||
rrAtomic128 scalar;
|
||||
rrAtomic128Vec vector;
|
||||
} result;
|
||||
|
||||
rrAtomicLock128();
|
||||
result.scalar.low = source->low;
|
||||
result.scalar.high = source->high;
|
||||
rrAtomicUnlock128();
|
||||
return result.vector;
|
||||
}
|
||||
|
||||
void rrAtomicStoreRelease128(uint64_t destination[2],
|
||||
const uint64_t source[2]) {
|
||||
rrAtomicLock128();
|
||||
destination[0] = source[0];
|
||||
destination[1] = source[1];
|
||||
rrAtomicUnlock128();
|
||||
}
|
||||
|
||||
#endif
|
||||
61
iggy-decompiled/src/reconstructed/win32_rrAtomics.h
Normal file
61
iggy-decompiled/src/reconstructed/win32_rrAtomics.h
Normal file
@@ -0,0 +1,61 @@
|
||||
#ifndef IGGY_RECONSTRUCTED_WIN32_RRATOMICS_H
|
||||
#define IGGY_RECONSTRUCTED_WIN32_RRATOMICS_H
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#if defined(__cplusplus)
|
||||
#define RR_ATOMIC_ALIGNAS_16 alignas(16)
|
||||
#else
|
||||
#define RR_ATOMIC_ALIGNAS_16 _Alignas(16)
|
||||
#endif
|
||||
|
||||
typedef struct rrAtomic128 {
|
||||
RR_ATOMIC_ALIGNAS_16 uint64_t low;
|
||||
uint64_t high;
|
||||
} rrAtomic128;
|
||||
|
||||
typedef long long rrAtomic128Vec __attribute__((vector_size(16)));
|
||||
|
||||
#undef RR_ATOMIC_ALIGNAS_16
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int32_t rrAtomicAddExchange32(int32_t *destination, int32_t delta);
|
||||
int64_t rrAtomicAddExchange64(int64_t *destination, int64_t delta);
|
||||
|
||||
bool rrAtomicCAS128(rrAtomic128 *destination, rrAtomic128 *comparand_inout,
|
||||
const rrAtomic128 *exchange);
|
||||
bool rrAtomicCAS32(int32_t *destination, int32_t *expected_inout,
|
||||
int32_t exchange);
|
||||
bool rrAtomicCAS64(int64_t *destination, int64_t *expected_inout,
|
||||
int64_t exchange);
|
||||
|
||||
int32_t rrAtomicCmpXchg32(int32_t *destination, int32_t exchange,
|
||||
int32_t comparand);
|
||||
int64_t rrAtomicCmpXchg64(int64_t *destination, int64_t exchange,
|
||||
int64_t comparand);
|
||||
|
||||
void rrAtomicExchange128(rrAtomic128 *destination, rrAtomic128 *previous_out,
|
||||
const rrAtomic128 *exchange);
|
||||
uint32_t rrAtomicExchange32(uint32_t *destination, uint32_t exchange);
|
||||
uint64_t rrAtomicExchange64(uint64_t *destination, uint64_t exchange);
|
||||
|
||||
rrAtomic128Vec rrAtomicLoadAcquire128(const rrAtomic128 *source);
|
||||
uint32_t rrAtomicLoadAcquire32(const uint32_t *source);
|
||||
uint64_t rrAtomicLoadAcquire64(const uint64_t *source);
|
||||
|
||||
void rrAtomicMemoryBarrierFull(void);
|
||||
|
||||
void rrAtomicStoreRelease128(uint64_t destination[2],
|
||||
const uint64_t source[2]);
|
||||
void rrAtomicStoreRelease32(uint32_t *destination, uint32_t value);
|
||||
void rrAtomicStoreRelease64(uint64_t *destination, uint64_t value);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
9
tests/support/win32_rrAtomics_test_support.c
Normal file
9
tests/support/win32_rrAtomics_test_support.c
Normal file
@@ -0,0 +1,9 @@
|
||||
/*
|
||||
* Host harness for the reconstructed win32_rrAtomics translation unit.
|
||||
*
|
||||
* `llvm-nm --undefined-only` on the retail Durango object returns zero
|
||||
* symbols: this module is a pure leaf, including its inlined 128-bit atomics.
|
||||
* No host API or cross-module stubs belong here.
|
||||
*/
|
||||
|
||||
typedef int win32_rrAtomics_test_support_is_intentionally_empty;
|
||||
281
tests/test_reconstructed_win32_rrAtomics.py
Normal file
281
tests/test_reconstructed_win32_rrAtomics.py
Normal file
@@ -0,0 +1,281 @@
|
||||
"""Runtime tests for the reconstructed win32_rrAtomics translation unit.
|
||||
|
||||
RED STATE: win32_rrAtomics.c / win32_rrAtomics.h do not exist yet, so
|
||||
setUpClass raises "missing win32_rrAtomics runtime inputs". Every behavioral
|
||||
assertion below is grounded in iggy-decompiled/raw/durango/win32_rrAtomics.c.
|
||||
|
||||
Fourteen of the 17 exports are cleanly pinned. The remaining three are
|
||||
documented symbol-resolution checks only: rrAtomicCAS128 (raw:36-53) and
|
||||
rrAtomicExchange128 (raw:145-175) contain CMPXCHG16B implicit-register
|
||||
artifacts that Ghidra cannot map back to a reliable Win64 C signature, while
|
||||
rrAtomicLoadAcquire128 (raw:213-217) is ambiguous between hidden-pointer
|
||||
aggregate return and XMM vector return. No numeric behavior is fabricated
|
||||
for those three exports.
|
||||
|
||||
Durango-only atomic module. The dylib is built for the 64-bit host with
|
||||
IGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO selected. The retail object is a
|
||||
pure leaf with zero undefined symbols, so the support harness has no stubs.
|
||||
"""
|
||||
|
||||
import ctypes
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
||||
SOURCE = RECONSTRUCTED / "win32_rrAtomics.c"
|
||||
HEADER = RECONSTRUCTED / "win32_rrAtomics.h"
|
||||
SUPPORT = ROOT / "tests/support/win32_rrAtomics_test_support.c"
|
||||
|
||||
|
||||
class ReconstructedWin32RrAtomicsTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
missing = [str(path) for path in (SOURCE, HEADER, SUPPORT)
|
||||
if not path.exists()]
|
||||
if missing:
|
||||
raise AssertionError(
|
||||
"missing win32_rrAtomics runtime inputs: "
|
||||
+ ", ".join(missing))
|
||||
cls.temp = tempfile.TemporaryDirectory()
|
||||
output = Path(cls.temp.name) / "win32_rrAtomics.dylib"
|
||||
build = subprocess.run([
|
||||
"clang", "-dynamiclib", "-std=c11", "-O2", "-Wall", "-Wextra",
|
||||
"-Werror", "-Wl,-undefined,dynamic_lookup",
|
||||
"-DIGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO=1",
|
||||
"-I", str(RECONSTRUCTED),
|
||||
str(SOURCE), str(SUPPORT), "-o", str(output),
|
||||
], capture_output=True, text=True)
|
||||
if build.returncode:
|
||||
raise AssertionError(build.stdout + build.stderr)
|
||||
cls.lib = ctypes.CDLL(str(output))
|
||||
lib = cls.lib
|
||||
|
||||
lib.rrAtomicAddExchange32.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_int32), ctypes.c_int32]
|
||||
lib.rrAtomicAddExchange32.restype = ctypes.c_int32
|
||||
lib.rrAtomicAddExchange64.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_int64), ctypes.c_int64]
|
||||
lib.rrAtomicAddExchange64.restype = ctypes.c_int64
|
||||
|
||||
lib.rrAtomicCAS32.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_int32),
|
||||
ctypes.POINTER(ctypes.c_int32), ctypes.c_int32]
|
||||
lib.rrAtomicCAS32.restype = ctypes.c_bool
|
||||
lib.rrAtomicCAS64.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_int64),
|
||||
ctypes.POINTER(ctypes.c_int64), ctypes.c_int64]
|
||||
lib.rrAtomicCAS64.restype = ctypes.c_bool
|
||||
|
||||
lib.rrAtomicCmpXchg32.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_int32), ctypes.c_int32, ctypes.c_int32]
|
||||
lib.rrAtomicCmpXchg32.restype = ctypes.c_int32
|
||||
lib.rrAtomicCmpXchg64.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_int64), ctypes.c_int64, ctypes.c_int64]
|
||||
lib.rrAtomicCmpXchg64.restype = ctypes.c_int64
|
||||
|
||||
lib.rrAtomicExchange32.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_uint32), ctypes.c_uint32]
|
||||
lib.rrAtomicExchange32.restype = ctypes.c_uint32
|
||||
lib.rrAtomicExchange64.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_uint64), ctypes.c_uint64]
|
||||
lib.rrAtomicExchange64.restype = ctypes.c_uint64
|
||||
|
||||
lib.rrAtomicLoadAcquire32.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_uint32)]
|
||||
lib.rrAtomicLoadAcquire32.restype = ctypes.c_uint32
|
||||
lib.rrAtomicLoadAcquire64.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_uint64)]
|
||||
lib.rrAtomicLoadAcquire64.restype = ctypes.c_uint64
|
||||
|
||||
lib.rrAtomicStoreRelease128.argtypes = [
|
||||
ctypes.c_void_p, ctypes.c_void_p]
|
||||
lib.rrAtomicStoreRelease128.restype = None
|
||||
lib.rrAtomicStoreRelease32.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_uint32), ctypes.c_uint32]
|
||||
lib.rrAtomicStoreRelease32.restype = None
|
||||
lib.rrAtomicStoreRelease64.argtypes = [
|
||||
ctypes.POINTER(ctypes.c_uint64), ctypes.c_uint64]
|
||||
lib.rrAtomicStoreRelease64.restype = None
|
||||
lib.rrAtomicMemoryBarrierFull.argtypes = []
|
||||
lib.rrAtomicMemoryBarrierFull.restype = None
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.temp.cleanup()
|
||||
|
||||
def test_add_exchange32_returns_pre_add_value_and_stores_sum(self):
|
||||
# raw/durango:6-16 captures *ptr before the locked addition.
|
||||
value = ctypes.c_int32(10)
|
||||
result = self.lib.rrAtomicAddExchange32(ctypes.byref(value), 5)
|
||||
self.assertEqual(result, 10)
|
||||
self.assertEqual(value.value, 15)
|
||||
|
||||
def test_add_exchange64_is_full_width_and_returns_pre_add_value(self):
|
||||
# raw/durango:22-32 has the same pre-add return timing at 64 bits.
|
||||
value = ctypes.c_int64(0x100000005)
|
||||
result = self.lib.rrAtomicAddExchange64(ctypes.byref(value), 3)
|
||||
self.assertEqual(result, 0x100000005)
|
||||
self.assertEqual(value.value, 0x100000008)
|
||||
|
||||
def test_cas32_hit_and_miss_use_bool_and_expected_inout(self):
|
||||
# raw/durango:59-78 returns bool success and updates expected on miss.
|
||||
destination = ctypes.c_int32(41)
|
||||
expected = ctypes.c_int32(41)
|
||||
self.assertTrue(self.lib.rrAtomicCAS32(
|
||||
ctypes.byref(destination), ctypes.byref(expected), 99))
|
||||
self.assertEqual(destination.value, 99)
|
||||
self.assertEqual(expected.value, 41)
|
||||
|
||||
destination = ctypes.c_int32(77)
|
||||
expected = ctypes.c_int32(41)
|
||||
self.assertFalse(self.lib.rrAtomicCAS32(
|
||||
ctypes.byref(destination), ctypes.byref(expected), 99))
|
||||
self.assertEqual(destination.value, 77)
|
||||
self.assertEqual(expected.value, 77)
|
||||
|
||||
def test_cas64_hit_and_miss_use_bool_and_expected_inout(self):
|
||||
# raw/durango:84-103 is the full-width C11-style CAS shape.
|
||||
original = 0x100000005
|
||||
destination = ctypes.c_int64(original)
|
||||
expected = ctypes.c_int64(original)
|
||||
self.assertTrue(self.lib.rrAtomicCAS64(
|
||||
ctypes.byref(destination), ctypes.byref(expected),
|
||||
0x200000006))
|
||||
self.assertEqual(destination.value, 0x200000006)
|
||||
self.assertEqual(expected.value, original)
|
||||
|
||||
destination = ctypes.c_int64(0x300000007)
|
||||
expected = ctypes.c_int64(original)
|
||||
self.assertFalse(self.lib.rrAtomicCAS64(
|
||||
ctypes.byref(destination), ctypes.byref(expected),
|
||||
0x200000006))
|
||||
self.assertEqual(destination.value, 0x300000007)
|
||||
self.assertEqual(expected.value, 0x300000007)
|
||||
|
||||
def test_cmpxchg32_hit_and_miss_return_previous_value(self):
|
||||
# raw/durango:109-122 always returns the previous destination value.
|
||||
# This is the opposite return convention from rrAtomicCAS32's bool
|
||||
# success result at raw/durango:59-78.
|
||||
destination = ctypes.c_int32(12)
|
||||
result = self.lib.rrAtomicCmpXchg32(
|
||||
ctypes.byref(destination), 34, 12)
|
||||
self.assertEqual(result, 12)
|
||||
self.assertEqual(destination.value, 34)
|
||||
|
||||
destination = ctypes.c_int32(56)
|
||||
result = self.lib.rrAtomicCmpXchg32(
|
||||
ctypes.byref(destination), 34, 12)
|
||||
self.assertEqual(result, 56)
|
||||
self.assertEqual(destination.value, 56)
|
||||
|
||||
def test_cmpxchg64_hit_and_miss_return_previous_value(self):
|
||||
# raw/durango:128-141 is the full-width previous-value shape.
|
||||
comparand = 0x100000005
|
||||
exchange = 0x200000006
|
||||
destination = ctypes.c_int64(comparand)
|
||||
result = self.lib.rrAtomicCmpXchg64(
|
||||
ctypes.byref(destination), exchange, comparand)
|
||||
self.assertEqual(result, comparand)
|
||||
self.assertEqual(destination.value, exchange)
|
||||
|
||||
destination = ctypes.c_int64(0x300000007)
|
||||
result = self.lib.rrAtomicCmpXchg64(
|
||||
ctypes.byref(destination), exchange, comparand)
|
||||
self.assertEqual(result, 0x300000007)
|
||||
self.assertEqual(destination.value, 0x300000007)
|
||||
|
||||
def test_exchange32_returns_old_value_and_stores_new_value(self):
|
||||
# raw/durango:181-191 is an unconditional exchange.
|
||||
value = ctypes.c_uint32(0x11223344)
|
||||
result = self.lib.rrAtomicExchange32(
|
||||
ctypes.byref(value), 0xAABBCCDD)
|
||||
self.assertEqual(result, 0x11223344)
|
||||
self.assertEqual(value.value, 0xAABBCCDD)
|
||||
|
||||
def test_exchange64_returns_old_value_and_stores_new_value(self):
|
||||
# raw/durango:197-207 is the full-width unconditional exchange.
|
||||
value = ctypes.c_uint64(0x1122334455667788)
|
||||
result = self.lib.rrAtomicExchange64(
|
||||
ctypes.byref(value), 0xAABBCCDDEEFF0011)
|
||||
self.assertEqual(result, 0x1122334455667788)
|
||||
self.assertEqual(value.value, 0xAABBCCDDEEFF0011)
|
||||
|
||||
def test_load_acquire32_reads_without_modifying_storage(self):
|
||||
# raw/durango:223-227 is a plain read.
|
||||
value = ctypes.c_uint32(0x89ABCDEF)
|
||||
self.assertEqual(
|
||||
self.lib.rrAtomicLoadAcquire32(ctypes.byref(value)), 0x89ABCDEF)
|
||||
self.assertEqual(value.value, 0x89ABCDEF)
|
||||
|
||||
def test_load_acquire64_reads_without_modifying_storage(self):
|
||||
# raw/durango:233-237 is a plain full-width read.
|
||||
value = ctypes.c_uint64(0x0123456789ABCDEF)
|
||||
self.assertEqual(
|
||||
self.lib.rrAtomicLoadAcquire64(ctypes.byref(value)),
|
||||
0x0123456789ABCDEF)
|
||||
self.assertEqual(value.value, 0x0123456789ABCDEF)
|
||||
|
||||
def test_store_release32_writes_value_visible_through_raw_pointer(self):
|
||||
# raw/durango:270-275 is a plain write.
|
||||
value = ctypes.c_uint32(0)
|
||||
self.lib.rrAtomicStoreRelease32(
|
||||
ctypes.byref(value), 0xDEADBEEF)
|
||||
self.assertEqual(ctypes.c_uint32.from_address(
|
||||
ctypes.addressof(value)).value, 0xDEADBEEF)
|
||||
|
||||
def test_store_release64_writes_value_visible_through_raw_pointer(self):
|
||||
# raw/durango:281-286 is a plain full-width write.
|
||||
value = ctypes.c_uint64(0)
|
||||
self.lib.rrAtomicStoreRelease64(
|
||||
ctypes.byref(value), 0xDEADBEEF01234567)
|
||||
self.assertEqual(ctypes.c_uint64.from_address(
|
||||
ctypes.addressof(value)).value, 0xDEADBEEF01234567)
|
||||
|
||||
def test_store_release128_copies_low_and_high_words_dest_first(self):
|
||||
# raw/durango:255-264 copies two uint64 words from src to dest.
|
||||
words = ctypes.c_uint64 * 2
|
||||
source = words(0x1111111111111111, 0x2222222222222222)
|
||||
destination = words(0xAAAAAAAAAAAAAAAA, 0xBBBBBBBBBBBBBBBB)
|
||||
self.assertEqual(ctypes.alignment(words), 8)
|
||||
self.assertEqual(ctypes.addressof(source) % 8, 0)
|
||||
self.assertEqual(ctypes.addressof(destination) % 8, 0)
|
||||
self.lib.rrAtomicStoreRelease128(
|
||||
ctypes.byref(destination), ctypes.byref(source))
|
||||
self.assertEqual(
|
||||
tuple(destination),
|
||||
(0x1111111111111111, 0x2222222222222222))
|
||||
|
||||
def test_memory_barrier_full_is_callable_pure_fence(self):
|
||||
# raw/durango:243-249 is LOCK/UNLOCK only. The pure-leaf harness has
|
||||
# no counters or stubs for this call to touch.
|
||||
self.assertIsNone(self.lib.rrAtomicMemoryBarrierFull())
|
||||
|
||||
def test_cas128_signature_is_ambiguous_documented_only(self):
|
||||
# raw/durango:36-53 exposes param_1/param_2 plus unaff_RBX and
|
||||
# uStackX_10, artifacts of CMPXCHG16B's implicit RDX:RAX compare and
|
||||
# RCX:RBX exchange operands. Win64 aggregate-vs-vector parameter
|
||||
# passing cannot be recovered reliably, so only export resolution is
|
||||
# asserted; no prototype or hit/miss behavior is invented.
|
||||
self.assertTrue(hasattr(self.lib, "rrAtomicCAS128"))
|
||||
|
||||
def test_exchange128_signature_is_ambiguous_documented_only(self):
|
||||
# raw/durango:145-175 copies *param_1 into *param_2 before its retry
|
||||
# loop, which would erase a pre-staged new value. Together with the
|
||||
# unaff_RBX/puStackX_10 CMPXCHG16B artifacts, that implies an
|
||||
# unrecovered additional operand; only symbol resolution is pinned.
|
||||
self.assertTrue(hasattr(self.lib, "rrAtomicExchange128"))
|
||||
|
||||
def test_load_acquire128_return_shape_is_ambiguous_documented_only(self):
|
||||
# raw/durango:213-217 looks like an 8-byte scalar load, but Win64 may
|
||||
# represent the real 16-byte result through a hidden aggregate pointer
|
||||
# or directly in XMM0 for a vector type. Ghidra cannot distinguish
|
||||
# those ABI shapes, so no ctypes prototype or width assertion is made.
|
||||
self.assertTrue(hasattr(self.lib, "rrAtomicLoadAcquire128"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
258
tests/test_reconstructed_win32_rrAtomics_cross.py
Normal file
258
tests/test_reconstructed_win32_rrAtomics_cross.py
Normal file
@@ -0,0 +1,258 @@
|
||||
"""Durango-only contract tests for reconstructed win32_rrAtomics.
|
||||
|
||||
This is a single-platform x86_64-pc-windows-msvc translation unit:
|
||||
win32_rrAtomics appears only in iggy_durango.modules.tsv and has no
|
||||
orbis/ps3/vita source or object inventory entry.
|
||||
|
||||
RED until win32_rrAtomics.c / win32_rrAtomics.h (and their CMake /
|
||||
modules.tsv rows) exist; retail-evidence assertions run now and prove the
|
||||
nm/strings parsing independently.
|
||||
|
||||
How EXPECTED_* were derived from
|
||||
work/iggy-native-decomp/durango-objects/win32_rrAtomics.obj:
|
||||
|
||||
EXPECTED_FUNCTIONS = `llvm-nm --extern-only --defined-only <obj>` names
|
||||
tagged uppercase T: exactly 17 exports.
|
||||
EXPECTED_GLOBALS = empty: no owned external D/B/C symbols.
|
||||
EXPECTED_IMPORTS = empty: `llvm-nm --undefined-only <obj>` emits zero
|
||||
lines. This pure-leaf object has no toolchain imports
|
||||
and no asm_x64_cmpxchg128/asm_x64_cmpxchg64 helper;
|
||||
the 128-bit operations are fully inlined.
|
||||
RUNTIME_ALLOWLISTS = empty for durango because total undefined count is 0.
|
||||
|
||||
The provenance string is the object's embedded build-temp path, matching the
|
||||
original_object column in iggy_durango.modules.tsv.
|
||||
|
||||
Macro convention for the future .c (not authored here):
|
||||
IGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO, using the single-platform #error
|
||||
idiom from win32_rrThreads2.c and swf_draw.c.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
||||
SOURCE = RECONSTRUCTED / "win32_rrAtomics.c"
|
||||
HEADER = RECONSTRUCTED / "win32_rrAtomics.h"
|
||||
LLVM_NM = Path("/opt/homebrew/opt/llvm/bin/llvm-nm")
|
||||
RETAIL_OBJ = (
|
||||
ROOT / "work/iggy-native-decomp/durango-objects/win32_rrAtomics.obj")
|
||||
|
||||
EXPECTED_FUNCTIONS = {
|
||||
"rrAtomicAddExchange32",
|
||||
"rrAtomicAddExchange64",
|
||||
"rrAtomicCAS128",
|
||||
"rrAtomicCAS32",
|
||||
"rrAtomicCAS64",
|
||||
"rrAtomicCmpXchg32",
|
||||
"rrAtomicCmpXchg64",
|
||||
"rrAtomicExchange128",
|
||||
"rrAtomicExchange32",
|
||||
"rrAtomicExchange64",
|
||||
"rrAtomicLoadAcquire128",
|
||||
"rrAtomicLoadAcquire32",
|
||||
"rrAtomicLoadAcquire64",
|
||||
"rrAtomicMemoryBarrierFull",
|
||||
"rrAtomicStoreRelease128",
|
||||
"rrAtomicStoreRelease32",
|
||||
"rrAtomicStoreRelease64",
|
||||
}
|
||||
EXPECTED_GLOBALS = set()
|
||||
EXPECTED_IMPORTS = set()
|
||||
RUNTIME_ALLOWLISTS = {"durango": set()}
|
||||
|
||||
PROVENANCE = (
|
||||
r"c:\projects\g\build\release\temps\libdu\iggy_durango\win32_rrAtomics.obj")
|
||||
|
||||
|
||||
def normalized_symbol(name):
|
||||
name = name.removeprefix(".")
|
||||
name = name.removeprefix("__imp_")
|
||||
if name == "_setjmp":
|
||||
return "setjmp"
|
||||
return name
|
||||
|
||||
|
||||
def defined_symbols_by_kind(output):
|
||||
functions = set()
|
||||
globals_ = set()
|
||||
for line in output.splitlines():
|
||||
parts = line.split()
|
||||
if len(parts) < 2:
|
||||
continue
|
||||
kind = parts[-2].upper()
|
||||
name = normalized_symbol(parts[-1])
|
||||
if kind == "T":
|
||||
functions.add(name)
|
||||
elif kind in {"D", "B", "C"}:
|
||||
globals_.add(name)
|
||||
return functions, globals_
|
||||
|
||||
|
||||
class ReconstructedWin32RrAtomicsCrossTests(unittest.TestCase):
|
||||
def test_native_provenance_counts_source_path_and_inventory(self):
|
||||
# source_functions=17 and lines=289 from the durango inventory;
|
||||
# `wc -l` independently gives 289. Category is "platform".
|
||||
modules = ROOT / "iggy-decompiled/symbols/iggy_durango.modules.tsv"
|
||||
row = next(
|
||||
line for line in modules.read_text(encoding="utf-8").splitlines()
|
||||
if line.startswith("win32_rrAtomics\t"))
|
||||
cols = row.split("\t")
|
||||
self.assertEqual(cols[1], "platform")
|
||||
self.assertEqual(int(cols[2]), 17)
|
||||
self.assertEqual(int(cols[3]), 289)
|
||||
self.assertEqual(cols[4], PROVENANCE)
|
||||
|
||||
raw = ROOT / "iggy-decompiled/raw/durango/win32_rrAtomics.c"
|
||||
self.assertEqual(
|
||||
len(raw.read_text(encoding="utf-8").splitlines()), 289)
|
||||
|
||||
self.assertTrue(RETAIL_OBJ.exists(), f"missing {RETAIL_OBJ}")
|
||||
symbols = subprocess.run(
|
||||
["nm", "-g", str(RETAIL_OBJ)], capture_output=True, text=True)
|
||||
self.assertEqual(symbols.returncode, 0, symbols.stderr)
|
||||
normalized = symbols.stdout.replace(" .", " ")
|
||||
for symbol in EXPECTED_FUNCTIONS | EXPECTED_GLOBALS:
|
||||
self.assertIn(symbol, normalized, symbol)
|
||||
|
||||
if LLVM_NM.exists():
|
||||
undefined = subprocess.run(
|
||||
[str(LLVM_NM), "--undefined-only", str(RETAIL_OBJ)],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(undefined.returncode, 0, undefined.stderr)
|
||||
imports = {
|
||||
normalized_symbol(line.split()[-1])
|
||||
for line in undefined.stdout.splitlines()
|
||||
if line.split()
|
||||
}
|
||||
self.assertEqual(
|
||||
imports - RUNTIME_ALLOWLISTS["durango"],
|
||||
EXPECTED_IMPORTS, imports)
|
||||
self.assertEqual(
|
||||
imports,
|
||||
EXPECTED_IMPORTS | RUNTIME_ALLOWLISTS["durango"])
|
||||
self.assertEqual(imports, set())
|
||||
self.assertEqual(len(imports), 0)
|
||||
# Zero imports also proves CAS128/Exchange128 do not call the
|
||||
# asm_x64_cmpxchg128 or asm_x64_cmpxchg64 helper modules.
|
||||
|
||||
defined = subprocess.run(
|
||||
[str(LLVM_NM), "--extern-only", "--defined-only",
|
||||
str(RETAIL_OBJ)],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(defined.returncode, 0, defined.stderr)
|
||||
functions, globals_ = defined_symbols_by_kind(defined.stdout)
|
||||
self.assertEqual(functions, EXPECTED_FUNCTIONS)
|
||||
self.assertEqual(globals_, EXPECTED_GLOBALS)
|
||||
|
||||
strings = subprocess.run(
|
||||
["strings", str(RETAIL_OBJ)], capture_output=True, text=True)
|
||||
self.assertEqual(strings.returncode, 0, strings.stderr)
|
||||
self.assertIn(PROVENANCE, strings.stdout)
|
||||
self.assertNotIn(r"src\flash\win32_rrAtomics", strings.stdout)
|
||||
|
||||
for platform in ("orbis", "ps3", "vita"):
|
||||
tsv = ROOT / f"iggy-decompiled/symbols/iggy_{platform}.modules.tsv"
|
||||
text = tsv.read_text(encoding="utf-8")
|
||||
self.assertNotIn("win32_rrAtomics\t", text, platform)
|
||||
|
||||
if SOURCE.exists():
|
||||
cmake = (RECONSTRUCTED / "CMakeLists.txt").read_text(
|
||||
encoding="utf-8")
|
||||
self.assertIn(
|
||||
"iggy_reconstructed_win32_rrAtomics_durango", cmake)
|
||||
self.assertIn(
|
||||
"add_library(iggy_reconstructed_win32_rrAtomics_durango "
|
||||
"STATIC win32_rrAtomics.c)",
|
||||
cmake)
|
||||
self.assertIn(
|
||||
"IGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO", cmake)
|
||||
inventory = (RECONSTRUCTED / "modules.tsv").read_text(
|
||||
encoding="utf-8")
|
||||
self.assertIn(
|
||||
"win32_rrAtomics\t17\t17\tdurango\tcomplete", inventory)
|
||||
|
||||
def test_exact_exports_globals_normalized_imports_and_c_cpp_abi(self):
|
||||
self.assertTrue(SOURCE.exists(), f"missing {SOURCE}")
|
||||
self.assertTrue(HEADER.exists(), f"missing {HEADER}")
|
||||
self.assertIn(
|
||||
r"c:\\projects\\g\\build\\release\\temps\\libdu\\iggy_durango\\"
|
||||
r"win32_rrAtomics.obj",
|
||||
SOURCE.read_text(encoding="utf-8"))
|
||||
|
||||
function_pointers = "".join(
|
||||
f" (GenericFn)&{name},\n"
|
||||
for name in sorted(EXPECTED_FUNCTIONS))
|
||||
probe_text = (
|
||||
'#include <stdint.h>\n#include "win32_rrAtomics.h"\n'
|
||||
'typedef void (*GenericFn)(void);\n'
|
||||
'static GenericFn rr_abis[] = {\n' + function_pointers + '};\n'
|
||||
'int use_abis(void) {\n'
|
||||
' for (unsigned i = 0; '
|
||||
'i < sizeof(rr_abis) / sizeof(rr_abis[0]); ++i) {\n'
|
||||
' if (!rr_abis[i]) return 0;\n'
|
||||
' }\n'
|
||||
' return 1;\n'
|
||||
'}\n')
|
||||
|
||||
compiler, target = "clang", "x86_64-pc-windows-msvc"
|
||||
platform = "durango"
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
temporary = Path(directory)
|
||||
output = temporary / f"win32_rrAtomics_{platform}.o"
|
||||
build = subprocess.run([
|
||||
compiler, "-target", target, "-ffreestanding", "-fno-builtin",
|
||||
"-c", "-std=c11", "-O2", "-Wall", "-Wextra", "-Werror",
|
||||
"-DIGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO=1",
|
||||
"-I", str(RECONSTRUCTED), str(SOURCE), "-o", str(output),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(build.returncode, 0, build.stderr)
|
||||
|
||||
if LLVM_NM.exists():
|
||||
defined = subprocess.run([
|
||||
str(LLVM_NM), "--extern-only", "--defined-only",
|
||||
str(output),
|
||||
], capture_output=True, text=True)
|
||||
undefined = subprocess.run([
|
||||
str(LLVM_NM), "--undefined-only", str(output),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(defined.returncode, 0, defined.stderr)
|
||||
self.assertEqual(undefined.returncode, 0, undefined.stderr)
|
||||
functions, globals_ = defined_symbols_by_kind(defined.stdout)
|
||||
imports = {
|
||||
normalized_symbol(line.split()[-1])
|
||||
for line in undefined.stdout.splitlines()
|
||||
if line.split()
|
||||
}
|
||||
self.assertEqual(functions, EXPECTED_FUNCTIONS, platform)
|
||||
self.assertEqual(globals_, EXPECTED_GLOBALS, platform)
|
||||
self.assertEqual(
|
||||
imports - RUNTIME_ALLOWLISTS[platform],
|
||||
EXPECTED_IMPORTS, (platform, imports))
|
||||
self.assertEqual(
|
||||
imports,
|
||||
EXPECTED_IMPORTS | RUNTIME_ALLOWLISTS[platform])
|
||||
self.assertEqual(imports, set())
|
||||
|
||||
for language, standard in (("c", "c11"), ("c++", "c++17")):
|
||||
suffix = "c" if language == "c" else "cpp"
|
||||
probe = temporary / (
|
||||
f"win32_rrAtomics_abi_{platform}.{suffix}")
|
||||
probe.write_text(probe_text, encoding="utf-8")
|
||||
syntax = subprocess.run([
|
||||
compiler, "-target", target, "-ffreestanding",
|
||||
"-fsyntax-only", f"-std={standard}",
|
||||
"-Wall", "-Wextra", "-Werror",
|
||||
"-DIGGY_RECONSTRUCT_WIN32_RRATOMICS_DURANGO=1",
|
||||
"-I", str(RECONSTRUCTED), str(probe),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(
|
||||
syntax.returncode, 0, (language, syntax.stderr))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user