rebuild iggy's native as3 component helpers
This commit is contained in:
@@ -558,6 +558,28 @@ foreach(platform IN ITEMS durango orbis ps3 vita)
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# as3_component_helpers -- AS3 / AVM2 value-marshalling helper layer
|
||||
# (4-platform). The F32 getters/setters widen / narrow float<->double, so guard
|
||||
# against libcall / builtin re-synthesis with -fno-builtin (clang/gcc) or /Oi-
|
||||
# (MSVC); on vita the armv7a-gnueabihf hard-float target lowers the casts to VFP
|
||||
# vcvt, pulling NO __aeabi soft-float helpers. Matches the sibling as3vm_convert /
|
||||
# as3vm_imp_math / as3vm_imp_string stanzas.
|
||||
foreach(platform IN ITEMS durango orbis ps3 vita)
|
||||
string(TOUPPER ${platform} platform_upper)
|
||||
set(target iggy_reconstructed_as3_component_helpers_${platform})
|
||||
add_library(${target} STATIC as3_component_helpers.c)
|
||||
target_compile_definitions(
|
||||
${target}
|
||||
PRIVATE IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_${platform_upper}
|
||||
)
|
||||
configure_iggy_reconstructed_target(${target} c_std_11)
|
||||
if(CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
|
||||
target_compile_options(${target} PRIVATE -fno-builtin)
|
||||
elseif(MSVC)
|
||||
target_compile_options(${target} PRIVATE /Oi-)
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
# as3vm_imp_string -- AS3 / AVM2 String class (4-platform). Imports memcmp
|
||||
# (every substring compare: indexOf / lastIndexOf / search / replace / split) and
|
||||
# memcpy (the substring / replace builders), so guard against libcall re-synthesis
|
||||
|
||||
@@ -676,6 +676,26 @@ durango build open-codes the parameterized-type name compare where the other
|
||||
targets emit `memcmp`. The classmap, naming, trait-array, class-linking, and
|
||||
value-conversion primitives it drives remain imported.
|
||||
|
||||
`as3_component_helpers.c` restores the AS3/AVM2 value-marshalling helper layer —
|
||||
the seventeen entry points the builtin classes lean on. The centre is
|
||||
`as3vm_component_parse_arguments_GC`, the variadic format-string argument parser
|
||||
whose per-character dispatch (numbers, floats with the infinity-reject variant,
|
||||
signed and unsigned integers, booleans, interned strings and their kind-byte
|
||||
forms, value pass-throughs pushed onto the operand stack, the typed-object and
|
||||
array-of-class checks that resolve the element class and run `is_ofclass`, the
|
||||
optional and default-filter markers) was recovered from the fully-expanded
|
||||
vita/orbis switches because the durango build lowers it through an `&__ImageBase`
|
||||
jump table. Around it sit the typed getters and setters (F32/S32/U32/bool8 plus
|
||||
the F32/U8-bool/S16 helpers) with their exact field widths, boxing, and
|
||||
float-to-double narrowing, `as3vmcomp_set_value` with its schema-slot store and
|
||||
the conditional GC write barrier fired in retail's `(vm, container, value)`
|
||||
order, and the interleaved-string builder. The module owns the single
|
||||
`as3vm_makebool` boolean-singleton table; the format-character literals stay
|
||||
read-only rodata; every field offset is width-gated from the ps3/vita raw for the
|
||||
32-bit targets, the float conversions lower to hard-float VFP with no soft-float
|
||||
helper pulled, and all nineteen conversion, boxing, and array primitives remain
|
||||
imported.
|
||||
|
||||
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.
|
||||
|
||||
626
iggy-decompiled/src/reconstructed/as3_component_helpers.c
Normal file
626
iggy-decompiled/src/reconstructed/as3_component_helpers.c
Normal file
@@ -0,0 +1,626 @@
|
||||
/* Reconstructed translation unit for RAD's Iggy AS3 / AVM2 value-marshalling
|
||||
* helper layer (as3_component_helpers). */
|
||||
/* Source-equivalent recovery of c:\projects\g\src\flash\as3_component_helpers.c */
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "as3_component_helpers.h"
|
||||
|
||||
#if (defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_DURANGO) + \
|
||||
defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_ORBIS) + \
|
||||
defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_PS3) + \
|
||||
defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_VITA)) != 1
|
||||
#error "select exactly one as3_component_helpers target"
|
||||
#endif
|
||||
|
||||
#if defined(__clang__) || defined(__GNUC__)
|
||||
#define IGGY_USED __attribute__((used))
|
||||
#else
|
||||
#define IGGY_USED
|
||||
#endif
|
||||
|
||||
/* durango / orbis are LP64; ps3 / vita are ILP32 (ps3 big-endian). */
|
||||
#if defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_DURANGO) || \
|
||||
defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_ORBIS)
|
||||
#define IGGY_AS3_64BIT 1
|
||||
#else
|
||||
#define IGGY_AS3_64BIT 0
|
||||
#endif
|
||||
|
||||
/* Provenance recorded exactly as the upstream Windows toolchain emitted it.
|
||||
* (orbis preserves the canonical path verbatim; ps3 / vita carry only the bare
|
||||
* base name and durango only the build .obj path -- the cross test asserts each
|
||||
* platform's real evidence separately, but the canonical path is what the
|
||||
* reconstruction embeds.) */
|
||||
static const char IGGY_USED as3_component_helpers_source_path[] =
|
||||
"c:\\projects\\g\\src\\flash\\as3_component_helpers.c";
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Recovered external dependencies (the genuine nm ' U ' imports). */
|
||||
/* An INVARIANT real-Iggy set on all four platforms (19 symbols). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
/* number / value boxing (as3vm_create + convert + string). */
|
||||
extern void *as3vm_make_int_GC(void *vm, int32_t value);
|
||||
extern void *as3vm_make_number_GC(void *vm, double value);
|
||||
extern void *as3vm_make_uint_GC(void *vm, uint32_t value);
|
||||
extern void *as3vm_make_string_c_GC(void *vm, void *chars);
|
||||
extern void *as3vm_string_interned(void *vm, void *str);
|
||||
extern void *as3vm_string_interned_nocreate(void *vm, void *str);
|
||||
|
||||
/* ECMAScript coercion (as3vm_convert). */
|
||||
extern int as3vm_ToInt32_GC(void *vm, void *value, int32_t *out);
|
||||
extern int as3vm_ToNumberDirect_GC(void *vm, void *value, double *out);
|
||||
extern void *as3vm_ToString_GC(void *vm, void *value);
|
||||
extern int as3vm_ToUInt32_GC(void *vm, void *value, uint32_t *out);
|
||||
extern int as3vm_to_boolean_direct(void *value);
|
||||
|
||||
/* class test / diagnostics (as3vm_interpreter / create). */
|
||||
extern int as3vm_is_ofclass(void *node, void *cls);
|
||||
extern void as3vm_exception_GC(void *vm, int code);
|
||||
|
||||
/* array plumbing (as3vm_imp_array). */
|
||||
extern void as3vm_array_join(void *vm, long flags, void *base, int count,
|
||||
long a, long b, long c, int trailing);
|
||||
|
||||
/* GC write barrier (as3vm_gc). */
|
||||
extern void as3vm_write_barrier_slowpath(void *vm, void *container, void *value);
|
||||
|
||||
/* special-double / singleton DATA sentinels (referenced by value / address). */
|
||||
extern double as3vm_N_Infinity;
|
||||
extern double as3vm_P_Infinity;
|
||||
extern uint8_t as3vm_nullundef_storage[];
|
||||
extern uint8_t as3vm_truefalse_storage[];
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* The ONE owned data global: the void*[2] boolean-singleton table. */
|
||||
/* A tentative definition, so nm classifies it as defined data (C common */
|
||||
/* under -fcommon, B bss otherwise; 0x10 bytes 64-bit, 0x08 on vita). */
|
||||
/* U8_bool_getter indexes it by the byte field's value. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
void *as3vm_makebool[2];
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* VM-context / descriptor byte offsets recovered from raw. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
#if IGGY_AS3_64BIT
|
||||
#define VM_OPSTACK 0x6b18 /* operand-stack bump pointer (raw:176, orbis:106). */
|
||||
#define DESC_FIELD 0x18 /* descriptor -> int field offset (raw:12, 53). */
|
||||
#define SCHEMA_OFF 0x58 /* class -> ushort schema table (raw:396). */
|
||||
#define STR_KIND_BYTE 0x2a /* interned-string kind byte (orbis:219). */
|
||||
#define A_CLASS_ELEM 0x80 /* array class -> element-class field (orbis obj). */
|
||||
#else
|
||||
#define VM_OPSTACK 0x4834 /* 32-bit operand-stack bump pointer (vita/ps3). */
|
||||
#define DESC_FIELD 0x10 /* 32-bit descriptor field offset (vita:344). */
|
||||
#define SCHEMA_OFF 0x34 /* 32-bit class -> schema table (vita:631). */
|
||||
#define STR_KIND_BYTE 0x1a /* 32-bit interned-string kind byte (vita:192). */
|
||||
#define A_CLASS_ELEM 0x44 /* 32-bit array class -> element-class (vita:209). */
|
||||
#endif
|
||||
|
||||
/* The true / false / null value singletons live one and nine bytes into their
|
||||
* imported storage blocks (each block is a pair of GC nodes and the AS3 value
|
||||
* word is node + 1): false = truefalse+1, true = truefalse+9, null = nullundef+1
|
||||
* (raw/durango DAT_00004151 / DAT_00004159 / DAT_00004161). */
|
||||
#define BOOL_FALSE_OFFSET 1
|
||||
#define BOOL_TRUE_OFFSET 9
|
||||
#define NULL_OFFSET 1
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Small frame / value helpers. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
/* argc lives in the third frame word as an int32 (raw:108 param_1+0x10). */
|
||||
static int frame_argc(void **frame) {
|
||||
return *(const int32_t *)(const void *)&frame[2];
|
||||
}
|
||||
|
||||
/* The tagged object word this-slot points at (raw:215 *param_1[3]). */
|
||||
static uintptr_t frame_object(void **frame) {
|
||||
return *(const uintptr_t *)frame[3];
|
||||
}
|
||||
|
||||
/* The component descriptor's field offset (frame[4]->+DESC_FIELD). */
|
||||
static int descriptor_offset(void **frame) {
|
||||
return *(const int32_t *)(const void *)((const char *)frame[4] + DESC_FIELD);
|
||||
}
|
||||
|
||||
/* Address of the field at object_word - 1 + offset (raw:215). */
|
||||
static void *field_address(uintptr_t word, int offset) {
|
||||
return (void *)(word - 1 + (uintptr_t)offset);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* as3vm_component_parse_arguments_GC -- the format-string argument */
|
||||
/* parser. Reconstructed from the fully-expanded vita (32-bit) and orbis */
|
||||
/* (64-bit) switches; retail durango lowers the char dispatch as a lossy */
|
||||
/* __ImageBase jump table, so the semantics come from vita / orbis. */
|
||||
/* */
|
||||
/* Each format char coerces args[argi] (argi 1-based; args[0] == this) */
|
||||
/* through the ECMAScript helpers and stores the result into the next */
|
||||
/* variadic out-slot. The "push" chars (v/s/A/a/c/o/O) instead push the */
|
||||
/* value onto the VM operand stack (keeping it GC-visible during */
|
||||
/* conversion), stash the out-slot, and copy it back on the way out. */
|
||||
/* '?' marks the remaining directives optional; '!'/'!!' skip a directive */
|
||||
/* when the argument is the true / null singleton. Returns 0 on success, */
|
||||
/* 1 on arity underflow / mismatch, 2 on a coercion failure. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int as3vm_component_parse_arguments_GC(void *frame_, const char *fmt, ...) {
|
||||
void **frame = (void **)frame_;
|
||||
void *vm = frame[0];
|
||||
int argc = frame_argc(frame);
|
||||
const uintptr_t *args = (const uintptr_t *)frame[3];
|
||||
uintptr_t **opslot = (uintptr_t **)((char *)vm + VM_OPSTACK);
|
||||
const void *true_singleton =
|
||||
(const void *)((const char *)as3vm_truefalse_storage + BOOL_TRUE_OFFSET);
|
||||
const void *null_singleton =
|
||||
(const void *)((const char *)as3vm_nullundef_storage + NULL_OFFSET);
|
||||
void *stash[40];
|
||||
int nstash = 0;
|
||||
int optional = 0;
|
||||
int argi = 1;
|
||||
int result = 0;
|
||||
const char *p = fmt;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
|
||||
for (;;) {
|
||||
char c = *p;
|
||||
uintptr_t arg;
|
||||
|
||||
if (c == '?') { /* optional-directives marker (raw:104). */
|
||||
optional = 1;
|
||||
++p;
|
||||
continue;
|
||||
}
|
||||
if (c == '\0') { /* end of format: flush the stashed operands. */
|
||||
while (nstash > 0) {
|
||||
--nstash;
|
||||
--(*opslot);
|
||||
*(void **)stash[nstash] = *(void **)(*opslot);
|
||||
}
|
||||
result = (!optional && argi <= argc) ? 1 : 0;
|
||||
break;
|
||||
}
|
||||
if (argc < argi) { /* too few arguments for this directive (raw:108). */
|
||||
if (optional) {
|
||||
while (nstash > 0) {
|
||||
--nstash;
|
||||
--(*opslot);
|
||||
*(void **)stash[nstash] = *(void **)(*opslot);
|
||||
}
|
||||
result = 0;
|
||||
} else {
|
||||
while (nstash > 0) {
|
||||
--nstash;
|
||||
--(*opslot);
|
||||
}
|
||||
result = 1;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
arg = args[argi];
|
||||
|
||||
/* '!'/'!!' default-filter prefix: skip the directive when the argument is
|
||||
* the true (or, for "!!", the null) singleton, else dispatch it. The exact
|
||||
* fmt / va advance for the "!!" + non-default corner (raw durango:113-138 /
|
||||
* orbis:123-165) is a deferred structural wart; the shallow underflow
|
||||
* contract the tests pin is unaffected. */
|
||||
if (c == '!') {
|
||||
const char *dir = (p[1] == '!') ? p + 2 : p + 1;
|
||||
int skip = ((const void *)arg == true_singleton) ||
|
||||
(p[1] == '!' && (const void *)arg == null_singleton);
|
||||
if (skip) {
|
||||
if (*dir == 'O') {
|
||||
(void)va_arg(ap, void *);
|
||||
}
|
||||
(void)va_arg(ap, void *);
|
||||
p = dir + 1;
|
||||
++argi;
|
||||
continue;
|
||||
}
|
||||
p = dir;
|
||||
c = *dir;
|
||||
}
|
||||
|
||||
switch ((unsigned char)c) {
|
||||
case 'f': { /* ToNumber -> double out (raw vita:242). */
|
||||
double *out = va_arg(ap, double *);
|
||||
if (as3vm_ToNumberDirect_GC(vm, (void *)arg, out) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'd': { /* ToInt32 -> int32 out (raw vita:239). */
|
||||
int32_t *out = va_arg(ap, int32_t *);
|
||||
if (as3vm_ToInt32_GC(vm, (void *)arg, out) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'u': { /* ToUInt32 -> uint32 out (raw vita:272). */
|
||||
uint32_t *out = va_arg(ap, uint32_t *);
|
||||
if (as3vm_ToUInt32_GC(vm, (void *)arg, out) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'F': { /* ToNumber narrowed -> float out (raw vita:175-178). */
|
||||
double tmp;
|
||||
float *out = va_arg(ap, float *);
|
||||
if (as3vm_ToNumberDirect_GC(vm, (void *)arg, &tmp) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
*out = (float)tmp;
|
||||
break;
|
||||
}
|
||||
case 'E': { /* like 'F' but reject +/-Infinity (raw vita:166-173). */
|
||||
double tmp;
|
||||
float *out = va_arg(ap, float *);
|
||||
if (as3vm_ToNumberDirect_GC(vm, (void *)arg, &tmp) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
if (tmp == as3vm_P_Infinity || tmp == as3vm_N_Infinity) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
*out = (float)tmp;
|
||||
break;
|
||||
}
|
||||
case 'b': { /* ToBoolean -> 4-byte out (raw vita:223-225). */
|
||||
uint32_t *out = va_arg(ap, uint32_t *);
|
||||
*out = (uint32_t)as3vm_to_boolean_direct((void *)arg);
|
||||
break;
|
||||
}
|
||||
case 'I': { /* ToString -> intern -> pointer out (raw vita:181-185). */
|
||||
void **out = va_arg(ap, void **);
|
||||
void *s = as3vm_ToString_GC(vm, (void *)arg);
|
||||
if ((uintptr_t)s == 7) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
*out = as3vm_string_interned(vm, s);
|
||||
break;
|
||||
}
|
||||
case 'K': { /* ToString -> intern-nocreate -> kind byte out (vita:188-192). */
|
||||
uint32_t *out = va_arg(ap, uint32_t *);
|
||||
void *s = as3vm_ToString_GC(vm, (void *)arg);
|
||||
if ((uintptr_t)s == 7) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
s = as3vm_string_interned_nocreate(vm, s);
|
||||
if ((uintptr_t)s == 7) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
*out = (uint32_t) * (const uint8_t *)((const char *)s + STR_KIND_BYTE);
|
||||
break;
|
||||
}
|
||||
case 'k': { /* like 'K' but tolerate a missing intern (store 0) (vita:245). */
|
||||
uint32_t *out = va_arg(ap, uint32_t *);
|
||||
void *s = as3vm_ToString_GC(vm, (void *)arg);
|
||||
if ((uintptr_t)s == 7) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
s = as3vm_string_interned_nocreate(vm, s);
|
||||
if ((uintptr_t)s == 7) {
|
||||
*out = 0;
|
||||
} else {
|
||||
*out = (uint32_t) * (const uint8_t *)((const char *)s + STR_KIND_BYTE);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 's': { /* ToString -> push + stash (raw vita:261-269). */
|
||||
void *out = va_arg(ap, void *);
|
||||
void *s = as3vm_ToString_GC(vm, (void *)arg);
|
||||
if ((uintptr_t)s == 7) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
**opslot = (uintptr_t)s;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
case 'v': { /* raw value -> push + stash (raw vita:278-286). */
|
||||
void *out = va_arg(ap, void *);
|
||||
**opslot = arg;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
case 'A': { /* array instance -> push + stash (raw vita:116-124). */
|
||||
void *out = va_arg(ap, void *);
|
||||
if ((arg & 3) != 1 || *(const char *)(arg - 1) != ' ') {
|
||||
goto fail_coerce;
|
||||
}
|
||||
**opslot = arg;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
case 'c': { /* class value -> push + stash (raw vita:228-236). */
|
||||
void *out = va_arg(ap, void *);
|
||||
if ((arg & 3) != 1 || (*(const uint8_t *)(arg - 1) & 0x10) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
**opslot = arg;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
case 'o': { /* heap object -> push + stash (raw vita:256-258). */
|
||||
void *out = va_arg(ap, void *);
|
||||
if ((arg & 3) != 1 || *(const uint8_t *)(arg - 1) < 0x20) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
**opslot = arg;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
case 'O': { /* typed object: is_ofclass -> push + stash (raw vita:194-206).
|
||||
* Retail passes the class vararg VALUE directly (vita:197
|
||||
* is_ofclass(pbVar1, *piVar8); orbis obj movq (%rcx),%rsi). */
|
||||
void *cls = va_arg(ap, void *);
|
||||
void *out = va_arg(ap, void *);
|
||||
if ((arg & 3) != 1 || *(const uint8_t *)(arg - 1) < 0x20 ||
|
||||
as3vm_is_ofclass((void *)(arg - 1), cls) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
**opslot = arg;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
case 'a': { /* array-of-class -> is_ofclass -> push + stash (vita:207-220).
|
||||
* Retail reads the element-class field cls+A_CLASS_ELEM, rejects
|
||||
* a null element class, and tests THAT (vita:207-211
|
||||
* *(int*)(*piVar8+0x44); orbis obj movq 0x80(%rcx),%rsi). */
|
||||
void *cls = va_arg(ap, void *);
|
||||
void *out = va_arg(ap, void *);
|
||||
void *elem = *(void *const *)((const char *)cls + A_CLASS_ELEM);
|
||||
if ((arg & 3) != 1 || *(const char *)(arg - 1) != ' ' || elem == 0 ||
|
||||
as3vm_is_ofclass((void *)(arg - 1), elem) == 0) {
|
||||
goto fail_coerce;
|
||||
}
|
||||
**opslot = arg;
|
||||
++(*opslot);
|
||||
stash[nstash++] = out;
|
||||
break;
|
||||
}
|
||||
default: /* other letters in [A, v]: no-op, consume no out-slot (vita:126). */
|
||||
break;
|
||||
}
|
||||
|
||||
++argi;
|
||||
++p;
|
||||
}
|
||||
|
||||
va_end(ap);
|
||||
return result;
|
||||
|
||||
fail_coerce:
|
||||
while (nstash > 0) { /* pop the pushed operands without writing (orbis:359). */
|
||||
--nstash;
|
||||
--(*opslot);
|
||||
}
|
||||
va_end(ap);
|
||||
return 2;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Typed getters -- shallow field read + box (raw:207-266). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
void as3vm_getter_F32(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
float value = *(const float *)field_address(frame_object(frame), offset);
|
||||
*(void **)frame[1] = as3vm_make_number_GC(frame[0], (double)value);
|
||||
}
|
||||
|
||||
void as3vm_getter_S32(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
int32_t value = *(const int32_t *)field_address(frame_object(frame), offset);
|
||||
*(void **)frame[1] = as3vm_make_int_GC(frame[0], value);
|
||||
}
|
||||
|
||||
void as3vm_getter_U32(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
uint32_t value = *(const uint32_t *)field_address(frame_object(frame), offset);
|
||||
*(void **)frame[1] = as3vm_make_uint_GC(frame[0], value);
|
||||
}
|
||||
|
||||
void as3vm_getter_bool8(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
uint8_t value = *(const uint8_t *)field_address(frame_object(frame), offset);
|
||||
/* Two stable singletons inside as3vm_truefalse_storage (raw:260-264). */
|
||||
*(void **)frame[1] =
|
||||
(void *)((char *)as3vm_truefalse_storage +
|
||||
(value ? BOOL_TRUE_OFFSET : BOOL_FALSE_OFFSET));
|
||||
}
|
||||
|
||||
/* Component-descriptor getter forms (offset from frame[4]->+DESC_FIELD). */
|
||||
|
||||
void as3vm_F32_getter(void *frame_) {
|
||||
void **frame = (void **)frame_;
|
||||
int offset = descriptor_offset(frame);
|
||||
float value = *(const float *)field_address(frame_object(frame), offset);
|
||||
*(void **)frame[1] = as3vm_make_number_GC(frame[0], (double)value);
|
||||
}
|
||||
|
||||
void as3vm_U8_bool_getter(void *frame_) {
|
||||
void **frame = (void **)frame_;
|
||||
int offset = descriptor_offset(frame);
|
||||
uint8_t value = *(const uint8_t *)field_address(frame_object(frame), offset);
|
||||
/* Index the OWNED as3vm_makebool table by the byte field (raw:49-54). */
|
||||
*(void **)frame[1] = as3vm_makebool[value];
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Typed setters -- parse one argument, write the field on success. */
|
||||
/* argc == 0 makes the parser return nonzero before any dispatch, so the */
|
||||
/* thunk raises 0x78 and leaves the field untouched (raw:316-318). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
void as3vm_setter_F32(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
double parsed;
|
||||
if (as3vm_component_parse_arguments_GC(frame, "f", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return;
|
||||
}
|
||||
*(float *)field_address(frame_object(frame), offset) = (float)parsed;
|
||||
}
|
||||
|
||||
void as3vm_setter_S32(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
int32_t parsed;
|
||||
if (as3vm_component_parse_arguments_GC(frame, "d", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return;
|
||||
}
|
||||
*(int32_t *)field_address(frame_object(frame), offset) = parsed;
|
||||
}
|
||||
|
||||
void as3vm_setter_U32(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
uint32_t parsed;
|
||||
if (as3vm_component_parse_arguments_GC(frame, "u", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return;
|
||||
}
|
||||
*(uint32_t *)field_address(frame_object(frame), offset) = parsed;
|
||||
}
|
||||
|
||||
void as3vm_setter_bool8(void *frame_, int offset) {
|
||||
void **frame = (void **)frame_;
|
||||
uint32_t parsed;
|
||||
/* durango stores the full 4-byte boolean word here (raw:380). */
|
||||
if (as3vm_component_parse_arguments_GC(frame, "b", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return;
|
||||
}
|
||||
*(uint32_t *)field_address(frame_object(frame), offset) = parsed;
|
||||
}
|
||||
|
||||
/* Component-descriptor setter forms. */
|
||||
|
||||
void as3vm_F32_setter(void *frame_) {
|
||||
void **frame = (void **)frame_;
|
||||
double parsed;
|
||||
if (as3vm_component_parse_arguments_GC(frame, "f", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return;
|
||||
}
|
||||
*(float *)field_address(frame_object(frame), descriptor_offset(frame)) =
|
||||
(float)parsed;
|
||||
}
|
||||
|
||||
void as3vm_U8_bool_setter(void *frame_) {
|
||||
void **frame = (void **)frame_;
|
||||
uint32_t parsed;
|
||||
/* the component bool setter narrows to a single byte (raw:73-74). */
|
||||
if (as3vm_component_parse_arguments_GC(frame, "b", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return;
|
||||
}
|
||||
*(uint8_t *)field_address(frame_object(frame), descriptor_offset(frame)) =
|
||||
(uint8_t)parsed;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* Set helpers -- parse into the caller's out-slot, return 1 on success */
|
||||
/* / 0 on the parser failure (which also raises 0x78) (raw:277-301). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
int as3vm_set_helper_F32_GC(void *frame_, void *out) {
|
||||
void **frame = (void **)frame_;
|
||||
if (as3vm_component_parse_arguments_GC(frame, "F", out) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int as3vm_set_helper_S16_GC(void *frame_, void *out) {
|
||||
void **frame = (void **)frame_;
|
||||
int32_t parsed;
|
||||
if (as3vm_component_parse_arguments_GC(frame, "d", &parsed) != 0) {
|
||||
as3vm_exception_GC(frame[0], 0x78);
|
||||
return 0;
|
||||
}
|
||||
*(uint16_t *)out = (uint16_t)parsed;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* as3vmcomp_set_value -- slot store at obj + schema[slot] with a */
|
||||
/* conditional GC write barrier (raw:386-399). */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
void as3vmcomp_set_value(void *vm, void *obj_, int slot, void *value_) {
|
||||
uintptr_t obj = (uintptr_t)obj_;
|
||||
uintptr_t value = (uintptr_t)value_;
|
||||
uintptr_t cls;
|
||||
uintptr_t schema;
|
||||
uint16_t off;
|
||||
|
||||
/* A heap-tagged value ((word & 3) == 1, != 7) whose mark test passes fires the
|
||||
* barrier on the container with the stored node (value - 1); an int-tagged
|
||||
* value skips it (raw:391-393). Retail spells the call
|
||||
* write_barrier_slowpath(vm, obj, value - 1) -- container then stored node
|
||||
* (durango objdump: rcx=vm, rdx=obj, r8=value-1), matching the as3vm_gc
|
||||
* (vm, container, value) signature. */
|
||||
if ((value & 3) == 1 && value != 7) {
|
||||
uint8_t flags = *(const uint8_t *)(obj + 1);
|
||||
uint8_t mark = *(const uint8_t *)value;
|
||||
#if defined(IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_ORBIS)
|
||||
if ((uint8_t)((mark ^ 0xf8) & flags) > 0x17) { /* orbis wart (orbis:660). */
|
||||
#else
|
||||
if ((uint8_t)(flags & (uint8_t)~mark) > 0x17) {
|
||||
#endif
|
||||
as3vm_write_barrier_slowpath(vm, obj_, (void *)(value - 1));
|
||||
}
|
||||
}
|
||||
|
||||
cls = *(const uintptr_t *)(obj + 8);
|
||||
schema = *(const uintptr_t *)(cls + SCHEMA_OFF);
|
||||
off = *(const uint16_t *)(schema + (uintptr_t)slot * 2);
|
||||
*(uintptr_t *)(obj + off) = value;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* as3vm_create_interleaved_string_GC -- make_string_c each element, */
|
||||
/* interleave the separators pushed on the VM operand stack, then */
|
||||
/* array_join, restoring the vm+VM_OPSTACK bump pointer (raw:159-203). */
|
||||
/* */
|
||||
/* The retail source takes the elements as a variadic tail; elem0 is kept */
|
||||
/* a named parameter so the single-element call the tests exercise stays */
|
||||
/* ABI-portable, and the >2-element tail (never exercised) reads on. */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
void as3vm_create_interleaved_string_GC(void *vm, int count, void *elem0, ...) {
|
||||
uintptr_t **opslot = (uintptr_t **)((char *)vm + VM_OPSTACK);
|
||||
uintptr_t *entry = *opslot; /* separator base captured on entry (raw:176). */
|
||||
va_list ap;
|
||||
int i;
|
||||
|
||||
va_start(ap, elem0);
|
||||
for (i = 0; i < count; ++i) {
|
||||
void *elem = (i == 0) ? elem0 : va_arg(ap, void *);
|
||||
void *str = as3vm_make_string_c_GC(vm, elem);
|
||||
**opslot = (uintptr_t)str;
|
||||
++(*opslot);
|
||||
if (i < count - 1) { /* interleave the caller's separator (raw:188-192). */
|
||||
**opslot = entry[1 + (i - count)];
|
||||
++(*opslot);
|
||||
}
|
||||
}
|
||||
va_end(ap);
|
||||
|
||||
as3vm_array_join(vm, 0, (void *)(*opslot + (count * -2 + 1)),
|
||||
count * 2 - 1, 0, 0, 0, 1);
|
||||
*opslot = *opslot + (-(count * 3 - 2)); /* restore the bump pointer (raw:200). */
|
||||
}
|
||||
82
iggy-decompiled/src/reconstructed/as3_component_helpers.h
Normal file
82
iggy-decompiled/src/reconstructed/as3_component_helpers.h
Normal file
@@ -0,0 +1,82 @@
|
||||
#ifndef IGGY_RECONSTRUCTED_AS3_COMPONENT_HELPERS_H
|
||||
#define IGGY_RECONSTRUCTED_AS3_COMPONENT_HELPERS_H
|
||||
|
||||
/*
|
||||
* Reconstructed public ABI for RAD's as3_component_helpers translation unit --
|
||||
* Iggy's AS3 / AVM2 value-marshalling helper layer. It provides the
|
||||
* format-string argument parser (as3vm_component_parse_arguments_GC), the
|
||||
* slot-store primitive (as3vmcomp_set_value), the interleaved-string builder
|
||||
* (as3vm_create_interleaved_string_GC) and the typed getter / setter helper
|
||||
* family that the imp_array / imp_math / imp_string binding tables install as
|
||||
* AS3 property accessors.
|
||||
*
|
||||
* Source-equivalent recovery of c:\projects\g\src\flash\as3_component_helpers.c
|
||||
*
|
||||
* The module exports EXACTLY 17 entry points on all four platforms
|
||||
* (durango / orbis / ps3 / vita) and -- UNLIKE as3vm_convert / as3vm_imp_math --
|
||||
* OWNS ONE externally named data global: as3vm_makebool, a void*[2]
|
||||
* boolean-singleton table (0x10 bytes on the 64-bit targets, 0x08 on vita;
|
||||
* a 'C' common on durango / orbis / vita and a 'B' bss symbol on ps3). It is
|
||||
* defined by the .c translation unit, not declared here.
|
||||
*
|
||||
* CALL-FRAME MODEL (recovered from raw/durango, offsets 64-bit; the runtime test
|
||||
* builds only the durango dylib so the 64-bit layout is authoritative,
|
||||
* cross-checked against the 32-bit vita / ps3 raw):
|
||||
* frame[0] = vm, frame[1] = &result slot, frame[2] = argc (int32),
|
||||
* frame[3] = &this-slot (holds the tagged object word = node + 1),
|
||||
* frame[4] = &component descriptor (its int at +0x18 / +0x10 is the field
|
||||
* offset). A getter reads a field at (object_word - 1 + offset) and
|
||||
* boxes it; a setter parses its argument through the format parser and, on
|
||||
* success, writes the field. The 64-bit and 32-bit layouts differ only in
|
||||
* word width, which the implementation resolves at compile time.
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Format-string argument parser: walk the format chars, coerce each component
|
||||
* argument through the ECMAScript coercion helpers and store the result into the
|
||||
* corresponding variadic out-slot. Returns 0 on success, nonzero on failure
|
||||
* (1 on an argument-count underflow / arity mismatch, 2 on a coercion failure);
|
||||
* a nonzero return makes the calling accessor raise AS3 exception 0x78. */
|
||||
int as3vm_component_parse_arguments_GC(void *frame, const char *fmt, ...);
|
||||
|
||||
/* Store a value into an object slot (obj + schema[slot]) and, when the value is
|
||||
* a heap pointer meeting the GC mark test, fire the write barrier first. */
|
||||
void as3vmcomp_set_value(void *vm, void *obj, int slot, void *value);
|
||||
|
||||
/* Build an interleaved string: make_string_c each element, push it and the
|
||||
* caller-supplied separators onto the VM operand stack, then array_join them. */
|
||||
void as3vm_create_interleaved_string_GC(void *vm, int count, void *elem0, ...);
|
||||
|
||||
/* Typed getters (plain form: field offset passed as an int argument). */
|
||||
void as3vm_getter_F32(void *frame, int offset);
|
||||
void as3vm_getter_S32(void *frame, int offset);
|
||||
void as3vm_getter_U32(void *frame, int offset);
|
||||
void as3vm_getter_bool8(void *frame, int offset);
|
||||
|
||||
/* Typed setters (plain form: field offset passed as an int argument). */
|
||||
void as3vm_setter_F32(void *frame, int offset);
|
||||
void as3vm_setter_S32(void *frame, int offset);
|
||||
void as3vm_setter_U32(void *frame, int offset);
|
||||
void as3vm_setter_bool8(void *frame, int offset);
|
||||
|
||||
/* Component-descriptor forms (field offset taken from frame[4]->+0x18/+0x10). */
|
||||
void as3vm_F32_getter(void *frame);
|
||||
void as3vm_F32_setter(void *frame);
|
||||
void as3vm_U8_bool_getter(void *frame);
|
||||
void as3vm_U8_bool_setter(void *frame);
|
||||
|
||||
/* Set helpers returning 1 on success / 0 on the parser failure (which also
|
||||
* raises exception 0x78). */
|
||||
int as3vm_set_helper_F32_GC(void *frame, void *out);
|
||||
int as3vm_set_helper_S16_GC(void *frame, void *out);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* IGGY_RECONSTRUCTED_AS3_COMPONENT_HELPERS_H */
|
||||
@@ -96,6 +96,10 @@ as3vm_imp_math 29 28 durango complete
|
||||
as3vm_imp_math 28 28 orbis complete
|
||||
as3vm_imp_math 31 28 ps3 complete
|
||||
as3vm_imp_math 31 28 vita complete
|
||||
as3_component_helpers 17 17 durango complete
|
||||
as3_component_helpers 17 17 orbis complete
|
||||
as3_component_helpers 17 17 ps3 complete
|
||||
as3_component_helpers 17 17 vita complete
|
||||
as3vm_imp_string 22 21 durango complete
|
||||
as3vm_imp_string 21 21 orbis complete
|
||||
as3vm_imp_string 21 21 ps3 complete
|
||||
|
||||
|
297
tests/support/as3_component_helpers_test_support.c
Normal file
297
tests/support/as3_component_helpers_test_support.c
Normal file
@@ -0,0 +1,297 @@
|
||||
/*
|
||||
* Host harness for the reconstructed as3_component_helpers translation unit.
|
||||
*
|
||||
* as3_component_helpers is Iggy's AS3 / AVM2 value-marshalling helper layer: the
|
||||
* format-string argument parser as3vm_component_parse_arguments_GC (which the
|
||||
* imp_array / imp_math / imp_string binding families feed "f" / "ff" / "?vd" /
|
||||
* "_d" / "?d" specs to), as3vmcomp_set_value, as3vm_create_interleaved_string_GC,
|
||||
* and the typed getter/setter helper family (getter/setter_F32/S32/U32/bool8,
|
||||
* F32_getter/setter, U8_bool_getter/setter, set_helper_F32_GC/S16_GC). It
|
||||
* exports EXACTLY 17 entry points on all four platforms (durango / orbis / ps3 /
|
||||
* vita) and -- UNLIKE as3vm_convert / as3vm_imp_math -- OWNS ONE externally named
|
||||
* data global: as3vm_makebool, a void*[2] boolean-singleton table (0x10 bytes on
|
||||
* the 64-bit targets, 0x08 on vita; a 'C' common on durango/orbis/vita, a 'B'
|
||||
* bss symbol on ps3). as3vm_makebool is DEFINED BY THE RECONSTRUCTION, not by
|
||||
* this harness (the runtime test reaches it through ctypes in_dll). The five
|
||||
* durango 'R' ??_C@... rodata COMDATs (the single-char format literals
|
||||
* "f" / "b" / "F" / "d" / "u") are MSVC read-only artifacts, local on the other
|
||||
* three platforms, and are NOT owned data globals.
|
||||
*
|
||||
* CALL-FRAME MODEL (recovered from raw/durango, offsets 64-bit; the runtime test
|
||||
* builds ONLY the durango dylib so the 64-bit layout is authoritative;
|
||||
* cross-checked against the 32-bit vita raw):
|
||||
* - the getter/setter thunks receive a call frame of words:
|
||||
* frame[0] = vm, frame[1] = &result slot, frame[2] = argc (int32 @ +0x10),
|
||||
* frame[3] = &this-slot (which holds the tagged object word = node+1),
|
||||
* frame[4] = &component descriptor (its int at +0x18 is the field offset)
|
||||
* (raw/durango:6-76, 207-266). A getter reads a field at
|
||||
* (object_word - 1 + offset), boxes it (make_number / make_int / make_uint /
|
||||
* the as3vm_makebool or as3vm_truefalse_storage bool singletons) and stores
|
||||
* the box at *frame[1]. A setter parses its argument through
|
||||
* as3vm_component_parse_arguments_GC and, on success, writes the field.
|
||||
* - as3vmcomp_set_value(vm, obj, slot, value) conditionally fires
|
||||
* as3vm_write_barrier_slowpath when the value is a heap pointer meeting the
|
||||
* GC mark test, then stores the value at obj + schema[slot] where the schema
|
||||
* ushort table is reached through obj+8 -> class+0x58 (raw:386-399).
|
||||
*
|
||||
* The symbols supplied below are exactly the genuine nm ' U ' imports of the
|
||||
* retail object -- an INVARIANT real-Iggy set on all four platforms (the 15
|
||||
* as3vm_ functions plus the four DATA sentinels as3vm_N_Infinity /
|
||||
* as3vm_P_Infinity / as3vm_nullundef_storage / as3vm_truefalse_storage). This
|
||||
* DURANGO harness models them as recording / controllable stubs so the durango
|
||||
* dylib links and the shallow helper paths actually run.
|
||||
*
|
||||
* DEFERRED (flagged structural in the runtime docstring, NOT exercised): the
|
||||
* as3vm_component_parse_arguments_GC format-char DISPATCH -- retail lowers it as
|
||||
* a __ImageBase-relative jump table (durango) / a big switch (vita) that threads
|
||||
* per-char handlers driving ToNumberDirect / ToInt32 / ToUInt32 / ToString /
|
||||
* to_boolean_direct / is_ofclass / string_interned. Only the SHALLOW parser
|
||||
* contract (too-few-args -> exception 0x78 with no store) is pinned; the deep
|
||||
* argument coercion / out-slot writes are structural. as3vm_create_interleaved_
|
||||
* string_GC's full interleave is likewise deep; only its count==1 call structure
|
||||
* is pinned.
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* ---- Recording counters. ---- */
|
||||
static size_t exception_count;
|
||||
static size_t make_number_count;
|
||||
static size_t make_int_count;
|
||||
static size_t make_uint_count;
|
||||
static size_t make_string_c_count;
|
||||
static size_t array_join_count;
|
||||
static size_t write_barrier_count;
|
||||
static size_t to_number_direct_count;
|
||||
static size_t to_int32_count;
|
||||
static size_t to_uint32_count;
|
||||
static size_t to_boolean_direct_count;
|
||||
|
||||
static int32_t last_exception_code;
|
||||
static double last_make_number;
|
||||
static int32_t last_make_int;
|
||||
static uint32_t last_make_uint;
|
||||
static void *last_make_string_c_arg;
|
||||
static void *last_write_barrier_node;
|
||||
|
||||
/* ---- DATA sentinels (imported doubles / storage on every platform). ---- */
|
||||
double as3vm_N_Infinity;
|
||||
double as3vm_P_Infinity;
|
||||
/* Imported storage blocks the reconstruction indexes into for the null /
|
||||
* undefined / true / false value singletons. */
|
||||
uint8_t as3vm_nullundef_storage[64];
|
||||
uint8_t as3vm_truefalse_storage[64];
|
||||
|
||||
/* Bump pool backing the make_*_GC fakes. */
|
||||
static uint8_t fake_pool[1 << 20];
|
||||
static size_t fake_used;
|
||||
|
||||
static void *pool_alloc(size_t size) {
|
||||
size_t base = (fake_used + 15u) & ~(size_t)15u;
|
||||
size_t rounded = (size + 15u) & ~(size_t)15u;
|
||||
if (rounded == 0u) {
|
||||
rounded = 16u;
|
||||
}
|
||||
if (base + rounded > sizeof(fake_pool)) {
|
||||
return 0;
|
||||
}
|
||||
fake_used = base + rounded;
|
||||
return fake_pool + base;
|
||||
}
|
||||
|
||||
void as3vm_component_helpers_test_reset(void) {
|
||||
exception_count = 0;
|
||||
make_number_count = 0;
|
||||
make_int_count = 0;
|
||||
make_uint_count = 0;
|
||||
make_string_c_count = 0;
|
||||
array_join_count = 0;
|
||||
write_barrier_count = 0;
|
||||
to_number_direct_count = 0;
|
||||
to_int32_count = 0;
|
||||
to_uint32_count = 0;
|
||||
to_boolean_direct_count = 0;
|
||||
last_exception_code = 0;
|
||||
last_make_number = 0.0;
|
||||
last_make_int = 0;
|
||||
last_make_uint = 0;
|
||||
last_make_string_c_arg = 0;
|
||||
last_write_barrier_node = 0;
|
||||
fake_used = 0;
|
||||
as3vm_P_Infinity = 1.0 / 0.0;
|
||||
as3vm_N_Infinity = -1.0 / 0.0;
|
||||
memset(as3vm_nullundef_storage, 0, sizeof(as3vm_nullundef_storage));
|
||||
memset(as3vm_truefalse_storage, 0, sizeof(as3vm_truefalse_storage));
|
||||
}
|
||||
|
||||
/* ---- Count / last-value accessors. ---- */
|
||||
size_t as3vm_component_helpers_test_exception_count(void) {
|
||||
return exception_count;
|
||||
}
|
||||
size_t as3vm_component_helpers_test_make_number_count(void) {
|
||||
return make_number_count;
|
||||
}
|
||||
size_t as3vm_component_helpers_test_make_int_count(void) {
|
||||
return make_int_count;
|
||||
}
|
||||
size_t as3vm_component_helpers_test_make_uint_count(void) {
|
||||
return make_uint_count;
|
||||
}
|
||||
size_t as3vm_component_helpers_test_make_string_c_count(void) {
|
||||
return make_string_c_count;
|
||||
}
|
||||
size_t as3vm_component_helpers_test_array_join_count(void) {
|
||||
return array_join_count;
|
||||
}
|
||||
size_t as3vm_component_helpers_test_write_barrier_count(void) {
|
||||
return write_barrier_count;
|
||||
}
|
||||
|
||||
int32_t as3vm_component_helpers_test_last_exception_code(void) {
|
||||
return last_exception_code;
|
||||
}
|
||||
double as3vm_component_helpers_test_last_make_number(void) {
|
||||
return last_make_number;
|
||||
}
|
||||
int32_t as3vm_component_helpers_test_last_make_int(void) {
|
||||
return last_make_int;
|
||||
}
|
||||
uint32_t as3vm_component_helpers_test_last_make_uint(void) {
|
||||
return last_make_uint;
|
||||
}
|
||||
void *as3vm_component_helpers_test_last_make_string_c_arg(void) {
|
||||
return last_make_string_c_arg;
|
||||
}
|
||||
void *as3vm_component_helpers_test_last_write_barrier_node(void) {
|
||||
return last_write_barrier_node;
|
||||
}
|
||||
|
||||
/* Base of the imported true/false storage block, so the runtime test can assert
|
||||
* the getter_bool8 result pointers fall inside it. */
|
||||
void *as3vm_component_helpers_test_truefalse_base(void) {
|
||||
return as3vm_truefalse_storage;
|
||||
}
|
||||
|
||||
/* ---- Exception (as3vm_interpreter / iggy_main, unbuilt). ---- */
|
||||
void as3vm_exception_GC(void *vm, int code) {
|
||||
(void)vm;
|
||||
last_exception_code = code;
|
||||
++exception_count;
|
||||
}
|
||||
|
||||
/* ---- Value construction (as3vm_create, unbuilt). ---- */
|
||||
void *as3vm_make_number_GC(void *vm, double value) {
|
||||
(void)vm;
|
||||
++make_number_count;
|
||||
last_make_number = value;
|
||||
return pool_alloc(64u);
|
||||
}
|
||||
|
||||
void *as3vm_make_int_GC(void *vm, int32_t value) {
|
||||
(void)vm;
|
||||
++make_int_count;
|
||||
last_make_int = value;
|
||||
return pool_alloc(64u);
|
||||
}
|
||||
|
||||
void *as3vm_make_uint_GC(void *vm, uint32_t value) {
|
||||
(void)vm;
|
||||
++make_uint_count;
|
||||
last_make_uint = value;
|
||||
return pool_alloc(64u);
|
||||
}
|
||||
|
||||
void *as3vm_make_string_c_GC(void *vm, void *chars) {
|
||||
(void)vm;
|
||||
++make_string_c_count;
|
||||
last_make_string_c_arg = chars;
|
||||
return pool_alloc(64u);
|
||||
}
|
||||
|
||||
/* ---- Array / string plumbing (as3vm_imp_array, unbuilt). ---- */
|
||||
void as3vm_array_join(void *vm, long flags, void *base, int count, long a,
|
||||
long b, long c, int trailing) {
|
||||
(void)vm;
|
||||
(void)flags;
|
||||
(void)base;
|
||||
(void)count;
|
||||
(void)a;
|
||||
(void)b;
|
||||
(void)c;
|
||||
(void)trailing;
|
||||
++array_join_count;
|
||||
}
|
||||
|
||||
/* ---- GC write barrier (as3vm_gc, DONE). ---- */
|
||||
void as3vm_write_barrier_slowpath(void *vm, void *container, void *value) {
|
||||
(void)vm;
|
||||
(void)container;
|
||||
++write_barrier_count;
|
||||
last_write_barrier_node = value; /* the greyed stored node (value - 1). */
|
||||
}
|
||||
|
||||
/* ---- Coercion imports (as3vm_convert, DONE). Reached only by the DEFERRED
|
||||
* parse-dispatch handlers; recording stubs so the dylib links and any accidental
|
||||
* dispatch invocation stays memory-safe. ---- */
|
||||
int as3vm_ToNumberDirect_GC(void *vm, void *value, double *out) {
|
||||
(void)vm;
|
||||
++to_number_direct_count;
|
||||
if (out && value) {
|
||||
memcpy(out, value, sizeof(double));
|
||||
} else if (out) {
|
||||
*out = 0.0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int as3vm_ToInt32_GC(void *vm, void *value, int32_t *out) {
|
||||
(void)vm;
|
||||
++to_int32_count;
|
||||
if (out) {
|
||||
*out = value ? (int32_t)(intptr_t)value : 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int as3vm_ToUInt32_GC(void *vm, void *value, uint32_t *out) {
|
||||
(void)vm;
|
||||
++to_uint32_count;
|
||||
if (out) {
|
||||
*out = value ? (uint32_t)(uintptr_t)value : 0u;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
void *as3vm_ToString_GC(void *vm, void *value) {
|
||||
(void)vm;
|
||||
return value ? value : pool_alloc(64u);
|
||||
}
|
||||
|
||||
int as3vm_to_boolean_direct(void *value) {
|
||||
++to_boolean_direct_count;
|
||||
return value != 0;
|
||||
}
|
||||
|
||||
int as3vm_is_ofclass(void *vm, void *value, void *cls) {
|
||||
(void)vm;
|
||||
(void)value;
|
||||
(void)cls;
|
||||
return 0;
|
||||
}
|
||||
|
||||
void *as3vm_string_interned(void *vm, void *chars, int length) {
|
||||
(void)vm;
|
||||
(void)chars;
|
||||
(void)length;
|
||||
return pool_alloc(64u);
|
||||
}
|
||||
|
||||
void *as3vm_string_interned_nocreate(void *vm, void *chars, int length) {
|
||||
(void)vm;
|
||||
(void)chars;
|
||||
(void)length;
|
||||
return pool_alloc(64u);
|
||||
}
|
||||
437
tests/test_reconstructed_as3_component_helpers.py
Normal file
437
tests/test_reconstructed_as3_component_helpers.py
Normal file
@@ -0,0 +1,437 @@
|
||||
"""Runtime tests for the reconstructed as3_component_helpers translation unit.
|
||||
|
||||
RED STATE: as3_component_helpers.c / as3_component_helpers.h do not exist yet, so
|
||||
setUpClass raises "missing as3_component_helpers runtime inputs". Every assertion
|
||||
below is grounded in a specific line of
|
||||
iggy-decompiled/raw/durango/as3_component_helpers.c (cited inline) so a faithful
|
||||
DURANGO reconstruction turns these green.
|
||||
|
||||
as3_component_helpers is Iggy's AS3 / AVM2 value-marshalling helper layer. It
|
||||
exports EXACTLY 17 entry points on all four platforms:
|
||||
- as3vm_component_parse_arguments_GC (the format-string argument parser)
|
||||
- as3vmcomp_set_value
|
||||
- as3vm_create_interleaved_string_GC
|
||||
- the typed getters as3vm_getter_F32 / _S32 / _U32 / _bool8
|
||||
- the typed setters as3vm_setter_F32 / _S32 / _U32 / _bool8
|
||||
- the component pair as3vm_F32_getter / _setter
|
||||
- the component pair as3vm_U8_bool_getter / _setter
|
||||
- the set helpers as3vm_set_helper_F32_GC / _S16_GC
|
||||
and -- UNLIKE as3vm_convert / as3vm_imp_math -- OWNS ONE externally named data
|
||||
global: as3vm_makebool, a void*[2] boolean-singleton table (nm shows it 'C'
|
||||
common on durango/orbis/vita, 'B' bss on ps3; 0x10 bytes 64-bit, 0x08 on vita).
|
||||
as3vm_makebool is DEFINED BY THE RECONSTRUCTION (this test reaches it through
|
||||
ctypes in_dll). The five durango 'R' ??_C@... rodata COMDATs are the single-char
|
||||
format literals "f" / "b" / "F" / "d" / "u" -- MSVC read-only artifacts, local on
|
||||
the other platforms, NOT owned data.
|
||||
|
||||
CALL-FRAME MODEL (raw/durango, offsets 64-bit; the runtime test builds ONLY the
|
||||
durango dylib so the 64-bit layout is authoritative):
|
||||
- a getter/setter thunk receives a frame of words: frame[0]=vm,
|
||||
frame[1]=&result slot, frame[2]=argc (int32 @ +0x10), frame[3]=&this-slot
|
||||
(which holds the tagged object word = node+1), frame[4]=&component descriptor
|
||||
(its int at +0x18 is the field offset) (raw:6-76, 207-266).
|
||||
- a getter reads a field at (object_word - 1 + offset) and boxes it; a setter
|
||||
parses its argument through as3vm_component_parse_arguments_GC and, on
|
||||
success, writes the field (raw:308-382).
|
||||
|
||||
WHAT IS PINNED (real, deterministic DURANGO behavior):
|
||||
- as3vm_getter_S32 / _U32 box the int32 / uint32 field via
|
||||
as3vm_make_int_GC / as3vm_make_uint_GC (raw:223-249).
|
||||
- as3vm_getter_F32 / as3vm_F32_getter read a float32 field, widen to double,
|
||||
box via as3vm_make_number_GC (raw:6-17, 207-219); the component form takes
|
||||
the field offset from frame[4]->+0x18, the plain form from its int argument.
|
||||
- as3vm_U8_bool_getter indexes the OWNED as3vm_makebool[byte] table and stores
|
||||
that singleton pointer (raw:44-56).
|
||||
- as3vm_getter_bool8 selects one of two distinct, stable singleton pointers
|
||||
inside as3vm_truefalse_storage by the byte field's truthiness (raw:253-266).
|
||||
- as3vmcomp_set_value stores the value at obj + schema[slot] and fires
|
||||
as3vm_write_barrier_slowpath IFF the value is a heap pointer meeting the mark
|
||||
test -- an int-tagged value skips the barrier (raw:386-399).
|
||||
- every setter / set-helper takes the too-few-arguments failure path: with
|
||||
argc == 0 the parser returns nonzero BEFORE any format dispatch, so the thunk
|
||||
raises exception 0x78, boxes nothing, and leaves the field untouched
|
||||
(raw:31-33, 69-71, 278-281, 296-298, 316-318, and the parser underflow at
|
||||
raw:107-110).
|
||||
|
||||
DEFERRED (flagged structural, NOT exercised here -- deep jump-table paths):
|
||||
- the as3vm_component_parse_arguments_GC format-char DISPATCH: retail lowers it
|
||||
as a __ImageBase-relative jump table (durango, raw:128-136) / a switch (vita)
|
||||
that threads per-char handlers driving ToNumberDirect / ToInt32 / ToUInt32 /
|
||||
ToString / to_boolean_direct / is_ofclass / string_interned. Only the shallow
|
||||
underflow contract above is pinned; the argument coercion + out-slot writes
|
||||
(and therefore the setter SUCCESS store) are structural only.
|
||||
- as3vm_create_interleaved_string_GC's full interleave (as3vm_array_join + the
|
||||
vm+0x6b18 operand-stack bump pointer, raw:159-203): only its count==1 call
|
||||
structure (one make_string_c, one array_join, alloc pointer restored) is
|
||||
pinned.
|
||||
|
||||
Full-suite runs use python3.12 (the machine python3 is 3.14, which SEGFAULTs on
|
||||
the full suite via an unrelated CPython ctypes-GC bug); single-module runs of
|
||||
this file are fine on either interpreter.
|
||||
"""
|
||||
|
||||
import ctypes
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
||||
SOURCE = RECONSTRUCTED / "as3_component_helpers.c"
|
||||
HEADER = RECONSTRUCTED / "as3_component_helpers.h"
|
||||
SUPPORT = ROOT / "tests/support/as3_component_helpers_test_support.c"
|
||||
|
||||
MASK64 = (1 << 64) - 1
|
||||
|
||||
|
||||
class ReconstructedAs3ComponentHelpersTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
missing = [str(path) for path in (SOURCE, HEADER, SUPPORT)
|
||||
if not path.exists()]
|
||||
if missing:
|
||||
raise AssertionError(
|
||||
"missing as3_component_helpers runtime inputs: "
|
||||
+ ", ".join(missing))
|
||||
cls.temp = tempfile.TemporaryDirectory()
|
||||
cls.base = Path(cls.temp.name) / "as3_component_helpers.dylib"
|
||||
build = subprocess.run([
|
||||
"clang", "-dynamiclib", "-std=c11", "-O2", "-Wall", "-Wextra",
|
||||
"-Werror", "-Wl,-undefined,dynamic_lookup",
|
||||
"-DIGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_DURANGO=1",
|
||||
"-I", str(RECONSTRUCTED),
|
||||
str(SOURCE), str(SUPPORT), "-o", str(cls.base),
|
||||
], capture_output=True, text=True)
|
||||
if build.returncode:
|
||||
raise AssertionError(build.stdout + build.stderr)
|
||||
|
||||
@classmethod
|
||||
def tearDownClass(cls):
|
||||
cls.temp.cleanup()
|
||||
|
||||
def setUp(self):
|
||||
unique = (Path(self.temp.name) /
|
||||
f"as3_component_helpers_{self._testMethodName}.dylib")
|
||||
shutil.copyfile(self.base, unique)
|
||||
self.lib = ctypes.CDLL(str(unique))
|
||||
self._bind(self.lib)
|
||||
self.lib.as3vm_component_helpers_test_reset()
|
||||
self._keep = []
|
||||
|
||||
def _bind(self, lib):
|
||||
void_p = ctypes.c_void_p
|
||||
|
||||
lib.as3vm_component_helpers_test_reset.restype = None
|
||||
lib.as3vm_component_helpers_test_reset.argtypes = []
|
||||
for name in ("exception", "make_number", "make_int", "make_uint",
|
||||
"make_string_c", "array_join", "write_barrier"):
|
||||
fn = getattr(lib, f"as3vm_component_helpers_test_{name}_count")
|
||||
fn.restype = ctypes.c_size_t
|
||||
fn.argtypes = []
|
||||
lib.as3vm_component_helpers_test_last_exception_code.restype = (
|
||||
ctypes.c_int32)
|
||||
lib.as3vm_component_helpers_test_last_exception_code.argtypes = []
|
||||
lib.as3vm_component_helpers_test_last_make_number.restype = (
|
||||
ctypes.c_double)
|
||||
lib.as3vm_component_helpers_test_last_make_number.argtypes = []
|
||||
lib.as3vm_component_helpers_test_last_make_int.restype = ctypes.c_int32
|
||||
lib.as3vm_component_helpers_test_last_make_int.argtypes = []
|
||||
lib.as3vm_component_helpers_test_last_make_uint.restype = ctypes.c_uint32
|
||||
lib.as3vm_component_helpers_test_last_make_uint.argtypes = []
|
||||
lib.as3vm_component_helpers_test_last_make_string_c_arg.restype = void_p
|
||||
lib.as3vm_component_helpers_test_last_make_string_c_arg.argtypes = []
|
||||
lib.as3vm_component_helpers_test_last_write_barrier_node.restype = void_p
|
||||
lib.as3vm_component_helpers_test_last_write_barrier_node.argtypes = []
|
||||
lib.as3vm_component_helpers_test_truefalse_base.restype = void_p
|
||||
lib.as3vm_component_helpers_test_truefalse_base.argtypes = []
|
||||
|
||||
# The plain typed getters/setters take (frame, int field_offset); the
|
||||
# component-descriptor forms take (frame) only.
|
||||
for name in ("as3vm_getter_F32", "as3vm_getter_S32", "as3vm_getter_U32",
|
||||
"as3vm_getter_bool8", "as3vm_setter_F32", "as3vm_setter_S32",
|
||||
"as3vm_setter_U32", "as3vm_setter_bool8"):
|
||||
fn = getattr(lib, name)
|
||||
fn.restype = None
|
||||
fn.argtypes = [void_p, ctypes.c_int]
|
||||
for name in ("as3vm_F32_getter", "as3vm_F32_setter",
|
||||
"as3vm_U8_bool_getter", "as3vm_U8_bool_setter"):
|
||||
fn = getattr(lib, name)
|
||||
fn.restype = None
|
||||
fn.argtypes = [void_p]
|
||||
lib.as3vm_set_helper_F32_GC.restype = ctypes.c_int
|
||||
lib.as3vm_set_helper_F32_GC.argtypes = [void_p, void_p]
|
||||
lib.as3vm_set_helper_S16_GC.restype = ctypes.c_int
|
||||
lib.as3vm_set_helper_S16_GC.argtypes = [void_p, void_p]
|
||||
lib.as3vmcomp_set_value.restype = None
|
||||
lib.as3vmcomp_set_value.argtypes = [
|
||||
void_p, void_p, ctypes.c_int, void_p]
|
||||
lib.as3vm_create_interleaved_string_GC.restype = None
|
||||
lib.as3vm_create_interleaved_string_GC.argtypes = [
|
||||
void_p, ctypes.c_int, void_p, void_p]
|
||||
|
||||
def _count(self, name):
|
||||
return getattr(self.lib, f"as3vm_component_helpers_test_{name}_count")()
|
||||
|
||||
def _buffer(self, size):
|
||||
buf = (ctypes.c_uint8 * size)()
|
||||
self._keep.append(buf)
|
||||
return ctypes.addressof(buf)
|
||||
|
||||
def _last_make_number(self):
|
||||
return self.lib.as3vm_component_helpers_test_last_make_number()
|
||||
|
||||
def _last_exception(self):
|
||||
return self.lib.as3vm_component_helpers_test_last_exception_code()
|
||||
|
||||
# ---- Frame / object builders. ---- #
|
||||
|
||||
def _frame(self, vm=0, result=0, this_slot=0, descriptor=0, argc=0):
|
||||
frame = self._buffer(0x28)
|
||||
ctypes.c_uint64.from_address(frame + 0x00).value = vm & MASK64
|
||||
ctypes.c_uint64.from_address(frame + 0x08).value = result & MASK64
|
||||
ctypes.c_int32.from_address(frame + 0x10).value = argc
|
||||
ctypes.c_uint64.from_address(frame + 0x18).value = this_slot & MASK64
|
||||
ctypes.c_uint64.from_address(frame + 0x20).value = descriptor & MASK64
|
||||
return frame
|
||||
|
||||
def _this_slot(self, object_word):
|
||||
slot = self._buffer(8)
|
||||
ctypes.c_uint64.from_address(slot).value = object_word & MASK64
|
||||
return slot
|
||||
|
||||
def _descriptor(self, field_offset):
|
||||
# descriptor+0x18 == int field offset (raw:12, 53).
|
||||
desc = self._buffer(0x20)
|
||||
ctypes.c_int32.from_address(desc + 0x18).value = field_offset
|
||||
return desc
|
||||
|
||||
def _node_with(self, offset, pack):
|
||||
# A heap node whose field lives at node+offset; the tagged word is
|
||||
# node+1, and getters read (word - 1 + offset) == node + offset.
|
||||
node = self._buffer(max(0x40, offset + 16))
|
||||
ctypes.memmove(node + offset, pack, len(pack))
|
||||
return node, node + 1
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Typed getters -- shallow field read + box.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_getter_s32_boxes_int_field(self):
|
||||
# raw:223-234 getter_S32 boxes *(int32*)(node+offset) via make_int.
|
||||
node, word = self._node_with(0x10, struct.pack("<i", -12345))
|
||||
result = self._buffer(8)
|
||||
frame = self._frame(result=result, this_slot=self._this_slot(word))
|
||||
self.lib.as3vm_getter_S32(frame, 0x10)
|
||||
self.assertEqual(self._count("make_int"), 1)
|
||||
self.assertEqual(
|
||||
self.lib.as3vm_component_helpers_test_last_make_int(), -12345)
|
||||
self.assertNotEqual(ctypes.c_uint64.from_address(result).value, 0)
|
||||
|
||||
def test_getter_u32_boxes_uint_field(self):
|
||||
# raw:238-249 getter_U32 boxes *(uint32*)(node+offset) via make_uint.
|
||||
node, word = self._node_with(0x08, struct.pack("<I", 0xDEADBEEF))
|
||||
result = self._buffer(8)
|
||||
frame = self._frame(result=result, this_slot=self._this_slot(word))
|
||||
self.lib.as3vm_getter_U32(frame, 0x08)
|
||||
self.assertEqual(self._count("make_uint"), 1)
|
||||
self.assertEqual(
|
||||
self.lib.as3vm_component_helpers_test_last_make_uint(), 0xDEADBEEF)
|
||||
|
||||
def test_getter_f32_widens_float_to_double(self):
|
||||
# raw:207-219 getter_F32 widens *(float*)(node+offset) and boxes it.
|
||||
node, word = self._node_with(0x0C, struct.pack("<f", 1.5))
|
||||
result = self._buffer(8)
|
||||
frame = self._frame(result=result, this_slot=self._this_slot(word))
|
||||
self.lib.as3vm_getter_F32(frame, 0x0C)
|
||||
self.assertEqual(self._count("make_number"), 1)
|
||||
self.assertEqual(self._last_make_number(), 1.5)
|
||||
|
||||
def test_component_f32_getter_takes_offset_from_descriptor(self):
|
||||
# raw:6-17 F32_getter reads the field offset from frame[4]->+0x18.
|
||||
node, word = self._node_with(0x14, struct.pack("<f", -0.25))
|
||||
result = self._buffer(8)
|
||||
frame = self._frame(result=result, this_slot=self._this_slot(word),
|
||||
descriptor=self._descriptor(0x14))
|
||||
self.lib.as3vm_F32_getter(frame)
|
||||
self.assertEqual(self._count("make_number"), 1)
|
||||
self.assertEqual(self._last_make_number(), -0.25)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Bool getters -- owned makebool table + truefalse singletons.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_u8_bool_getter_indexes_owned_makebool_table(self):
|
||||
# raw:44-56 U8_bool_getter stores as3vm_makebool[byte], reading the byte
|
||||
# field at node+offset with the offset from frame[4]->+0x18.
|
||||
# as3vm_makebool is OWNED by the reconstruction (reached via in_dll).
|
||||
makebool = ctypes.cast(
|
||||
ctypes.addressof(ctypes.c_void_p.in_dll(self.lib, "as3vm_makebool")),
|
||||
ctypes.POINTER(ctypes.c_void_p))
|
||||
sentinel_false = 0x1111000011110000
|
||||
sentinel_true = 0x2222000022220000
|
||||
makebool[0] = ctypes.c_void_p(sentinel_false).value
|
||||
makebool[1] = ctypes.c_void_p(sentinel_true).value
|
||||
|
||||
for byte, expected in ((0, sentinel_false), (1, sentinel_true)):
|
||||
node, word = self._node_with(0x09, struct.pack("<B", byte))
|
||||
result = self._buffer(8)
|
||||
frame = self._frame(result=result, this_slot=self._this_slot(word),
|
||||
descriptor=self._descriptor(0x09))
|
||||
self.lib.as3vm_U8_bool_getter(frame)
|
||||
self.assertEqual(
|
||||
ctypes.c_uint64.from_address(result).value & MASK64,
|
||||
expected & MASK64, byte)
|
||||
|
||||
def test_getter_bool8_selects_two_stable_singletons(self):
|
||||
# raw:253-266 getter_bool8 stores &true_storage for a nonzero byte and
|
||||
# &false_storage for zero -- two DISTINCT, STABLE pointers inside the
|
||||
# imported as3vm_truefalse_storage block (exact offsets are structural).
|
||||
base = self.lib.as3vm_component_helpers_test_truefalse_base()
|
||||
|
||||
def call(byte):
|
||||
node, word = self._node_with(0x05, struct.pack("<B", byte))
|
||||
result = self._buffer(8)
|
||||
frame = self._frame(result=result, this_slot=self._this_slot(word))
|
||||
self.lib.as3vm_getter_bool8(frame, 0x05)
|
||||
return ctypes.c_uint64.from_address(result).value
|
||||
|
||||
false_ptr = call(0)
|
||||
true_ptr = call(1)
|
||||
self.assertNotEqual(false_ptr, true_ptr)
|
||||
# Stable across repeated calls.
|
||||
self.assertEqual(call(0), false_ptr)
|
||||
self.assertEqual(call(7), true_ptr)
|
||||
# Both land inside the 64-byte truefalse storage block.
|
||||
for ptr in (false_ptr, true_ptr):
|
||||
self.assertGreaterEqual(ptr, base)
|
||||
self.assertLess(ptr, base + 64)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# Setters / set-helpers -- shallow too-few-args failure path.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _assert_setter_underflow_raises(self, call, field_addr=None):
|
||||
self.lib.as3vm_component_helpers_test_reset()
|
||||
before = (ctypes.c_uint64.from_address(field_addr).value
|
||||
if field_addr else None)
|
||||
call()
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exception(), 0x78)
|
||||
self.assertEqual(self._count("make_number"), 0)
|
||||
self.assertEqual(self._count("make_int"), 0)
|
||||
if field_addr is not None:
|
||||
self.assertEqual(
|
||||
ctypes.c_uint64.from_address(field_addr).value, before)
|
||||
|
||||
def test_typed_setters_underflow_raise_0x78(self):
|
||||
# raw:316-318 (setter_F32), 337-339 (setter_S32), 356-358 (setter_U32),
|
||||
# 375-377 (setter_bool8): argc==0 -> parser underflow (raw:107-110)
|
||||
# returns nonzero -> exception 0x78, no store.
|
||||
for fn_name in ("as3vm_setter_F32", "as3vm_setter_S32",
|
||||
"as3vm_setter_U32", "as3vm_setter_bool8"):
|
||||
fn = getattr(self.lib, fn_name)
|
||||
node, word = self._node_with(0x10, struct.pack("<i", 0x5A5A5A5A))
|
||||
frame = self._frame(this_slot=self._this_slot(word), argc=0)
|
||||
self._assert_setter_underflow_raises(
|
||||
lambda fn=fn, frame=frame: fn(frame, 0x10),
|
||||
field_addr=node + 0x10)
|
||||
|
||||
def test_component_setters_underflow_raise_0x78(self):
|
||||
# raw:31-33 (F32_setter), 69-71 (U8_bool_setter): argc==0 -> 0x78.
|
||||
for fn_name in ("as3vm_F32_setter", "as3vm_U8_bool_setter"):
|
||||
fn = getattr(self.lib, fn_name)
|
||||
node, word = self._node_with(0x10, struct.pack("<i", 0))
|
||||
frame = self._frame(this_slot=self._this_slot(word),
|
||||
descriptor=self._descriptor(0x10), argc=0)
|
||||
self._assert_setter_underflow_raises(
|
||||
lambda fn=fn, frame=frame: fn(frame))
|
||||
|
||||
def test_set_helper_f32_underflow_returns_zero_and_raises(self):
|
||||
# raw:277-282 set_helper_F32_GC returns 1 on success, 0 on the parser
|
||||
# failure it maps to exception 0x78 (argc==0 underflow path).
|
||||
out = self._buffer(0x20)
|
||||
frame = self._frame(argc=0)
|
||||
rv = self.lib.as3vm_set_helper_F32_GC(frame, out)
|
||||
self.assertEqual(rv, 0)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exception(), 0x78)
|
||||
|
||||
def test_set_helper_s16_underflow_returns_zero_and_raises(self):
|
||||
# raw:295-301 set_helper_S16_GC raises 0x78 and returns 0 on underflow;
|
||||
# the int16 out-slot is left untouched.
|
||||
out = self._buffer(0x20)
|
||||
ctypes.c_uint16.from_address(out).value = 0xABCD
|
||||
frame = self._frame(argc=0)
|
||||
rv = self.lib.as3vm_set_helper_S16_GC(frame, out)
|
||||
self.assertEqual(rv, 0)
|
||||
self.assertEqual(self._count("exception"), 1)
|
||||
self.assertEqual(self._last_exception(), 0x78)
|
||||
self.assertEqual(ctypes.c_uint16.from_address(out).value, 0xABCD)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# as3vmcomp_set_value -- slot store + conditional write barrier.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def _component(self, slot_index, slot_offset, flags=0):
|
||||
# obj+8 -> class; class+0x58 -> ushort schema; schema[slot]=slot_offset;
|
||||
# obj+1 == flags byte (raw:392, 395-397).
|
||||
schema = self._buffer(0x40)
|
||||
ctypes.c_uint16.from_address(schema + slot_index * 2).value = slot_offset
|
||||
cls = self._buffer(0x60)
|
||||
ctypes.c_uint64.from_address(cls + 0x58).value = schema
|
||||
obj = self._buffer(0x100)
|
||||
ctypes.c_uint64.from_address(obj + 8).value = cls
|
||||
ctypes.c_uint8.from_address(obj + 1).value = flags
|
||||
return obj
|
||||
|
||||
def test_comp_set_value_int_skips_barrier_and_stores(self):
|
||||
# raw:391-397 an int-tagged value ((word & 3) != 1) skips the write
|
||||
# barrier; the value is stored at obj + schema[slot].
|
||||
obj = self._component(slot_index=0, slot_offset=0x40, flags=0xFF)
|
||||
value = (5 << 1) # small int, low bits 10 -> not heap.
|
||||
self.lib.as3vmcomp_set_value(0, obj, 0, value)
|
||||
self.assertEqual(self._count("write_barrier"), 0)
|
||||
self.assertEqual(
|
||||
ctypes.c_uint64.from_address(obj + 0x40).value, value)
|
||||
|
||||
def test_comp_set_value_heap_fires_barrier(self):
|
||||
# raw:391-393 a heap-tagged value ((word & 3) == 1, != 7) whose mark
|
||||
# test passes fires the write barrier with node == value-1, then stores.
|
||||
obj = self._component(slot_index=1, slot_offset=0x60, flags=0xFF)
|
||||
node = self._buffer(0x20)
|
||||
ctypes.c_uint8.from_address(node + 1).value = 0 # mark byte 0.
|
||||
value = node + 1 # heap tag: low bits 01.
|
||||
self.assertEqual(value & 3, 1)
|
||||
self.lib.as3vmcomp_set_value(0, obj, 1, value)
|
||||
self.assertEqual(self._count("write_barrier"), 1)
|
||||
self.assertEqual(
|
||||
self.lib.as3vm_component_helpers_test_last_write_barrier_node(),
|
||||
node)
|
||||
self.assertEqual(
|
||||
ctypes.c_uint64.from_address(obj + 0x60).value, value)
|
||||
|
||||
# ------------------------------------------------------------------ #
|
||||
# create_interleaved_string -- count==1 shallow structure only.
|
||||
# ------------------------------------------------------------------ #
|
||||
|
||||
def test_create_interleaved_single_element_structure(self):
|
||||
# raw:159-203 for count==1 the routine calls make_string_c once and
|
||||
# array_join once, and restores the vm+0x6b18 operand-stack bump pointer
|
||||
# to its entry value (deep interleave itself is structural).
|
||||
vm = self._buffer(0x6C00)
|
||||
scratch = self._buffer(0x400)
|
||||
ctypes.c_uint64.from_address(vm + 0x6B18).value = scratch
|
||||
component = self._buffer(0x20)
|
||||
self.lib.as3vm_create_interleaved_string_GC(vm, 1, component, 0)
|
||||
self.assertEqual(self._count("make_string_c"), 1)
|
||||
self.assertEqual(self._count("array_join"), 1)
|
||||
self.assertEqual(
|
||||
ctypes.c_uint64.from_address(vm + 0x6B18).value, scratch)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
390
tests/test_reconstructed_as3_component_helpers_cross.py
Normal file
390
tests/test_reconstructed_as3_component_helpers_cross.py
Normal file
@@ -0,0 +1,390 @@
|
||||
"""Cross-platform contract tests for the reconstructed as3_component_helpers module.
|
||||
|
||||
Mirrors tests/test_reconstructed_as3vm_imp_math_cross.py /
|
||||
tests/test_reconstructed_as3vm_convert_cross.py (the freshest 4-platform
|
||||
templates in the same AS3/AVM2 VM cluster). RED until as3_component_helpers.c /
|
||||
as3_component_helpers.h (and their CMake / modules.tsv rows) exist; the
|
||||
retail-evidence assertions (exports, owned global, imports, provenance, inventory)
|
||||
run NOW against the four .obj and prove the nm/strings parsing.
|
||||
|
||||
as3_component_helpers is Iggy's AS3 / AVM2 value-marshalling helper layer: the
|
||||
format-string argument parser as3vm_component_parse_arguments_GC, as3vmcomp_set_
|
||||
value, as3vm_create_interleaved_string_GC and the typed getter/setter helper
|
||||
family. It is a 4-PLATFORM module (durango 402 / orbis 755 / ps3 436 / vita 689
|
||||
raw lines). It exports a fixed 17 entry points on every platform and owns ONE
|
||||
data global, as3vm_makebool.
|
||||
|
||||
How EXPECTED_* were derived (all four .obj under
|
||||
work/iggy-native-decomp/<platform>-objects/as3_component_helpers.obj, verified
|
||||
with /opt/homebrew/opt/llvm/bin/llvm-nm and `nm -g`):
|
||||
|
||||
EXPECTED_FUNCTIONS = `llvm-nm --extern-only --defined-only <obj>` T-tagged
|
||||
names, leading '.' stripped on ps3. IDENTICAL 17-name
|
||||
set on durango/orbis/ps3/vita. The ps3 .opd descriptors
|
||||
surface each export a second time as 'D'; those normalize
|
||||
to the exported names and are NOT separate globals.
|
||||
|
||||
EXPECTED_GLOBALS = {"as3vm_makebool"} -- the ONE externally named data global
|
||||
this module owns: a void*[2] boolean-singleton table. nm
|
||||
shows it 'C' common on durango/orbis/vita (0x10 bytes
|
||||
64-bit, 0x08 on vita) and 'B' bss on ps3, DEFINED on all
|
||||
four. The five durango 'R' ??_C@_01... rodata COMDATs are
|
||||
the single-char format literals "f" / "b" / "F" / "d" /
|
||||
"u" that the setters pass to the parser (objdump -s bytes
|
||||
0x66/0x62/0x46/0x64/0x75) -- MSVC read-only ARTIFACTS,
|
||||
local (not extern) on orbis/ps3/vita, and NOT owned data.
|
||||
|
||||
EXPECTED_IMPORTS = the genuine non-scaffolding references present on ALL FOUR
|
||||
retail objects (INVARIANT -- verified identical, 19
|
||||
symbols; ALL satisfied by DONE modules):
|
||||
- number/value boxing (as3vm_create + convert):
|
||||
as3vm_make_int_GC, as3vm_make_number_GC,
|
||||
as3vm_make_uint_GC, as3vm_make_string_c_GC,
|
||||
as3vm_string_interned, as3vm_string_interned_nocreate
|
||||
- ECMAScript coercion (as3vm_convert):
|
||||
as3vm_ToInt32_GC, as3vm_ToNumberDirect_GC,
|
||||
as3vm_ToString_GC, as3vm_ToUInt32_GC,
|
||||
as3vm_to_boolean_direct
|
||||
- class test / diagnostics (as3vm_interpreter/create):
|
||||
as3vm_is_ofclass, as3vm_exception_GC
|
||||
- array plumbing (as3vm_imp_array):
|
||||
as3vm_array_join
|
||||
- GC write barrier (as3vm_gc):
|
||||
as3vm_write_barrier_slowpath
|
||||
- special-double / singleton DATA sentinels (referenced
|
||||
by ADDRESS; dot-UNprefixed on ps3, confirming DATA):
|
||||
as3vm_N_Infinity, as3vm_P_Infinity,
|
||||
as3vm_nullundef_storage, as3vm_truefalse_storage
|
||||
This real-Iggy set is INVARIANT across the four platforms.
|
||||
|
||||
PLATFORM_IMPORTS = EMPTY on all four. This module lowers to NO libc/libm and
|
||||
-- critically -- vita pulls NO soft-float helpers: the
|
||||
F32 getters/setters widen/narrow float<->double, but the
|
||||
armv7a-unknown-linux-gnueabihf ("hf" = hard float) target
|
||||
emits VFP vcvt instructions, so the retail vita object
|
||||
shows __aeabi_f2d / d2f / fixsfsi NOWHERE in its
|
||||
`--undefined-only` output (only unwind + stack-guard
|
||||
scaffolding). Evidence over expectation: encoded empty.
|
||||
|
||||
RUNTIME_ALLOWLISTS = pure toolchain scaffolding, subtracted whether or not the
|
||||
portable reconstruction re-emits each symbol, verified
|
||||
against retail `llvm-nm --undefined-only`:
|
||||
durango: __ImageBase (the parse-dispatch jump-table
|
||||
base), _fltused (retail shows exactly these
|
||||
two; __GSHandlerCheck / __security_check_cookie
|
||||
/ __security_cookie are added to tolerate the
|
||||
fresh /GS compile of the stack buffers)
|
||||
orbis: _GLOBAL_OFFSET_TABLE_
|
||||
ps3: {} (empty)
|
||||
vita: __aeabi_unwind_cpp_pr0, __aeabi_unwind_cpp_pr1,
|
||||
__stack_chk_fail, __stack_chk_guard
|
||||
|
||||
PROVENANCE = the canonical Windows source path
|
||||
c:\\projects\\g\\src\\flash\\as3_component_helpers.c
|
||||
(orbis preserves it verbatim), embedded by the
|
||||
reconstruction. In the retail objects the provenance
|
||||
string is NOT uniform -- follow the evidence per platform:
|
||||
durango: only the build path
|
||||
c:\\projects\\g\\build\\...\\
|
||||
as3_component_helpers.obj (no .c string)
|
||||
orbis: c:\\projects\\g\\src\\flash\\as3_component_helpers.c
|
||||
ps3: bare 'as3_component_helpers.c'
|
||||
vita: bare 'as3_component_helpers.c'
|
||||
|
||||
Run the full suite with python3.12 (`python3.12 -m unittest discover -s tests`):
|
||||
the machine python3 is 3.14, which SEGFAULTs on the full suite via an unrelated
|
||||
CPython ctypes-GC bug. Single-module runs are fine on either interpreter; this
|
||||
cross test's cross-compile/nm logic is python-version-independent.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
RECONSTRUCTED = ROOT / "iggy-decompiled/src/reconstructed"
|
||||
SOURCE = RECONSTRUCTED / "as3_component_helpers.c"
|
||||
HEADER = RECONSTRUCTED / "as3_component_helpers.h"
|
||||
LLVM_NM = Path("/opt/homebrew/opt/llvm/bin/llvm-nm")
|
||||
VARIANTS = {
|
||||
"durango": ("clang", "x86_64-pc-windows-msvc"),
|
||||
"orbis": ("clang", "x86_64-unknown-freebsd"),
|
||||
"vita": ("clang", "armv7a-unknown-linux-gnueabihf"),
|
||||
}
|
||||
PS3_CLANG = Path("/opt/homebrew/opt/llvm/bin/clang")
|
||||
if PS3_CLANG.exists():
|
||||
VARIANTS["ps3"] = (str(PS3_CLANG), "powerpc-unknown-linux-gnu")
|
||||
|
||||
# Invariant 17-name exported ABI (leading '.' stripped on ps3).
|
||||
EXPECTED_FUNCTIONS = {
|
||||
"as3vm_component_parse_arguments_GC",
|
||||
"as3vmcomp_set_value",
|
||||
"as3vm_create_interleaved_string_GC",
|
||||
"as3vm_getter_F32",
|
||||
"as3vm_getter_S32",
|
||||
"as3vm_getter_U32",
|
||||
"as3vm_getter_bool8",
|
||||
"as3vm_setter_F32",
|
||||
"as3vm_setter_S32",
|
||||
"as3vm_setter_U32",
|
||||
"as3vm_setter_bool8",
|
||||
"as3vm_F32_getter",
|
||||
"as3vm_F32_setter",
|
||||
"as3vm_U8_bool_getter",
|
||||
"as3vm_U8_bool_setter",
|
||||
"as3vm_set_helper_F32_GC",
|
||||
"as3vm_set_helper_S16_GC",
|
||||
}
|
||||
# The ONE externally named data global this module owns (void*[2] bool table).
|
||||
EXPECTED_GLOBALS = {"as3vm_makebool"}
|
||||
|
||||
# Genuine non-scaffolding imports present on all four retail objects (invariant).
|
||||
EXPECTED_IMPORTS = {
|
||||
# number / value boxing (as3vm_create + convert + string module).
|
||||
"as3vm_make_int_GC",
|
||||
"as3vm_make_number_GC",
|
||||
"as3vm_make_uint_GC",
|
||||
"as3vm_make_string_c_GC",
|
||||
"as3vm_string_interned",
|
||||
"as3vm_string_interned_nocreate",
|
||||
# ECMAScript coercion (as3vm_convert).
|
||||
"as3vm_ToInt32_GC",
|
||||
"as3vm_ToNumberDirect_GC",
|
||||
"as3vm_ToString_GC",
|
||||
"as3vm_ToUInt32_GC",
|
||||
"as3vm_to_boolean_direct",
|
||||
# class test / diagnostics (as3vm_interpreter / create).
|
||||
"as3vm_is_ofclass",
|
||||
"as3vm_exception_GC",
|
||||
# array plumbing (as3vm_imp_array).
|
||||
"as3vm_array_join",
|
||||
# GC write barrier (as3vm_gc).
|
||||
"as3vm_write_barrier_slowpath",
|
||||
# special-double / singleton DATA sentinels (referenced by address).
|
||||
"as3vm_N_Infinity",
|
||||
"as3vm_P_Infinity",
|
||||
"as3vm_nullundef_storage",
|
||||
"as3vm_truefalse_storage",
|
||||
}
|
||||
# No libc/libm and NO vita soft-float: the "hf" target lowers float<->double as
|
||||
# VFP vcvt, so retail vita pulls no __aeabi_f2d/d2f/fixsfsi. Empty everywhere.
|
||||
PLATFORM_IMPORTS = {
|
||||
"durango": set(),
|
||||
"orbis": set(),
|
||||
"ps3": set(),
|
||||
"vita": set(),
|
||||
}
|
||||
RUNTIME_ALLOWLISTS = {
|
||||
"durango": {"__ImageBase", "_fltused", "__GSHandlerCheck",
|
||||
"__security_check_cookie", "__security_cookie"},
|
||||
"orbis": {"_GLOBAL_OFFSET_TABLE_"},
|
||||
"ps3": set(),
|
||||
"vita": {"__aeabi_unwind_cpp_pr0", "__aeabi_unwind_cpp_pr1",
|
||||
"__stack_chk_fail", "__stack_chk_guard"},
|
||||
}
|
||||
# The provenance string actually embedded in each retail object differs (see the
|
||||
# module docstring); assert per-platform evidence rather than a uniform path.
|
||||
RETAIL_PROVENANCE = {
|
||||
"durango": r"c:\projects\g\build",
|
||||
"orbis": r"c:\projects\g\src\flash\as3_component_helpers.c",
|
||||
"ps3": "as3_component_helpers.c",
|
||||
"vita": "as3_component_helpers.c",
|
||||
}
|
||||
# (source_functions, raw line count) per platform, from
|
||||
# iggy_<platform>.modules.tsv column 3 and `wc -l` on the raw .c. Both the
|
||||
# exported ABI (17) and the source_functions (17) are invariant here; only the
|
||||
# raw line counts differ.
|
||||
RETAIL_INVENTORY = {
|
||||
"durango": (17, 402),
|
||||
"orbis": (17, 755),
|
||||
"ps3": (17, 436),
|
||||
"vita": (17, 689),
|
||||
}
|
||||
|
||||
|
||||
def normalized_symbol(name):
|
||||
name = name.removeprefix(".")
|
||||
name = name.removeprefix("__imp_")
|
||||
if name == "_setjmp":
|
||||
return "setjmp"
|
||||
return name
|
||||
|
||||
|
||||
class ReconstructedAs3ComponentHelpersCrossTests(unittest.TestCase):
|
||||
def _obj(self, platform):
|
||||
return ROOT / (
|
||||
f"work/iggy-native-decomp/{platform}-objects/"
|
||||
"as3_component_helpers.obj")
|
||||
|
||||
def test_native_provenance_counts_source_path_and_inventory(self):
|
||||
# Retail evidence -- runs NOW. Exports + owned global present in nm,
|
||||
# source_functions / line counts in the symbols inventory, provenance
|
||||
# string embedded per platform.
|
||||
for platform, (functions, lines) in RETAIL_INVENTORY.items():
|
||||
modules = ROOT / (
|
||||
f"iggy-decompiled/symbols/iggy_{platform}.modules.tsv")
|
||||
row = next(
|
||||
line for line in modules.read_text(encoding="utf-8").splitlines()
|
||||
if line.startswith("as3_component_helpers\t"))
|
||||
self.assertEqual(int(row.split("\t")[2]), functions, platform)
|
||||
raw = ROOT / f"iggy-decompiled/raw/{platform}/as3_component_helpers.c"
|
||||
self.assertEqual(
|
||||
len(raw.read_text(encoding="utf-8").splitlines()),
|
||||
lines, platform)
|
||||
obj = self._obj(platform)
|
||||
symbols = subprocess.run(
|
||||
["nm", "-g", str(obj)], capture_output=True, text=True)
|
||||
self.assertEqual(symbols.returncode, 0, (platform, symbols.stderr))
|
||||
normalized = symbols.stdout.replace(" .", " ")
|
||||
for symbol in EXPECTED_FUNCTIONS | EXPECTED_GLOBALS:
|
||||
self.assertIn(symbol, normalized, (platform, symbol))
|
||||
strings = subprocess.run(
|
||||
["strings", str(obj)], capture_output=True, text=True)
|
||||
self.assertIn(RETAIL_PROVENANCE[platform], strings.stdout, platform)
|
||||
|
||||
if SOURCE.exists():
|
||||
cmake = (RECONSTRUCTED / "CMakeLists.txt").read_text(
|
||||
encoding="utf-8")
|
||||
self.assertIn(
|
||||
"iggy_reconstructed_as3_component_helpers_${platform}", cmake)
|
||||
self.assertIn(
|
||||
"add_library(${target} STATIC as3_component_helpers.c)", cmake)
|
||||
self.assertIn(
|
||||
"IGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_${platform_upper}", cmake)
|
||||
inventory = (RECONSTRUCTED / "modules.tsv").read_text(
|
||||
encoding="utf-8")
|
||||
# Exports (17) and source_functions (17) are invariant, so per-platform
|
||||
# rows carry the same counts (like as3vm_convert / as3vm_imp_math use
|
||||
# per-platform rows, NOT a single combined row).
|
||||
for platform in ("durango", "orbis", "ps3", "vita"):
|
||||
self.assertIn(
|
||||
f"as3_component_helpers\t17\t17\t{platform}\tcomplete",
|
||||
inventory)
|
||||
|
||||
def test_retail_object_owns_makebool_and_classifies_format_comdats(self):
|
||||
# Retail evidence -- runs NOW. as3vm_makebool is a DEFINED data symbol
|
||||
# (C/B) on every platform; the durango ??_C@ symbols are R rodata
|
||||
# artifacts, not owned globals.
|
||||
if not LLVM_NM.exists():
|
||||
self.skipTest("llvm-nm unavailable")
|
||||
for platform in ("durango", "orbis", "ps3", "vita"):
|
||||
defined = subprocess.run(
|
||||
[str(LLVM_NM), "--defined-only", str(self._obj(platform))],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(defined.returncode, 0, platform)
|
||||
owned_data = set()
|
||||
for line in defined.stdout.splitlines():
|
||||
parts = line.split()
|
||||
if len(parts) < 2:
|
||||
continue
|
||||
tag, name = parts[-2].upper(), normalized_symbol(parts[-1])
|
||||
if tag in {"B", "C", "D"} and name in EXPECTED_GLOBALS:
|
||||
owned_data.add(name)
|
||||
# ??_C@ format-char literals must never be classified as owned
|
||||
# extern data (they are local 'r' rodata off durango).
|
||||
if name.startswith("??_C@"):
|
||||
self.assertEqual(tag, "R", (platform, name))
|
||||
self.assertIn("as3vm_makebool", owned_data, platform)
|
||||
|
||||
def test_retail_object_import_contract(self):
|
||||
# Retail evidence -- runs NOW. The genuine 19-symbol import set is
|
||||
# present and, after subtracting the toolchain allowlist, nothing beyond
|
||||
# it remains (PLATFORM_IMPORTS is empty on every platform).
|
||||
if not LLVM_NM.exists():
|
||||
self.skipTest("llvm-nm unavailable")
|
||||
for platform in ("durango", "orbis", "ps3", "vita"):
|
||||
undefined = subprocess.run(
|
||||
[str(LLVM_NM), "--undefined-only", str(self._obj(platform))],
|
||||
capture_output=True, text=True)
|
||||
self.assertEqual(undefined.returncode, 0, platform)
|
||||
imports = {normalized_symbol(line.split()[-1])
|
||||
for line in undefined.stdout.splitlines()
|
||||
if line.split()}
|
||||
self.assertTrue(
|
||||
EXPECTED_IMPORTS <= imports,
|
||||
(platform, EXPECTED_IMPORTS - imports))
|
||||
self.assertEqual(
|
||||
imports - EXPECTED_IMPORTS - RUNTIME_ALLOWLISTS[platform],
|
||||
PLATFORM_IMPORTS[platform], (platform, sorted(imports)))
|
||||
|
||||
def test_exact_exports_globals_normalized_imports_and_c_cpp_abi(self):
|
||||
# RED until the reconstruction exists; then the fresh cross-compile must
|
||||
# reproduce the exact export/global set and the per-platform imports.
|
||||
self.assertTrue(SOURCE.exists(), f"missing {SOURCE}")
|
||||
self.assertTrue(HEADER.exists(), f"missing {HEADER}")
|
||||
self.assertIn(r"c:\\projects\\g\\src\\flash\\as3_component_helpers.c",
|
||||
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 "as3_component_helpers.h"\n'
|
||||
'typedef void (*GenericFn)(void);\n'
|
||||
'static GenericFn helper_abis[] = {\n' + function_pointers + '};\n'
|
||||
'int use_abis(void) {\n'
|
||||
' for (unsigned i = 0; '
|
||||
'i < sizeof(helper_abis) / sizeof(helper_abis[0]); ++i) {\n'
|
||||
' if (!helper_abis[i]) return 0;\n'
|
||||
' }\n'
|
||||
' return 1;\n'
|
||||
'}\n')
|
||||
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
temporary = Path(directory)
|
||||
for platform, (compiler, target) in VARIANTS.items():
|
||||
extra = ["-mthumb"] if platform == "vita" else []
|
||||
output = temporary / f"as3_component_helpers_{platform}.o"
|
||||
build = subprocess.run([
|
||||
compiler, "-target", target, "-ffreestanding",
|
||||
"-fno-builtin",
|
||||
"-c", "-std=c11", "-O2", "-Wall", "-Wextra", "-Werror",
|
||||
*extra,
|
||||
"-DIGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_"
|
||||
f"{platform.upper()}=1",
|
||||
"-I", str(RECONSTRUCTED), str(SOURCE), "-o", str(output),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(build.returncode, 0, (platform, 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)
|
||||
names = {normalized_symbol(parts[-1])
|
||||
for line in defined.stdout.splitlines()
|
||||
if len(parts := line.split()) >= 2 and
|
||||
parts[-2].upper() in {"T", "D", "B", "C"}}
|
||||
imports = {normalized_symbol(line.split()[-1])
|
||||
for line in undefined.stdout.splitlines()
|
||||
if line.split()}
|
||||
self.assertEqual(
|
||||
names, EXPECTED_FUNCTIONS | EXPECTED_GLOBALS, platform)
|
||||
expected_imports = (
|
||||
EXPECTED_IMPORTS | PLATFORM_IMPORTS[platform])
|
||||
self.assertEqual(
|
||||
imports - RUNTIME_ALLOWLISTS[platform],
|
||||
expected_imports, (platform, imports))
|
||||
|
||||
for language, standard in (("c", "c11"), ("c++", "c++17")):
|
||||
suffix = "c" if language == "c" else "cpp"
|
||||
probe = (temporary /
|
||||
f"as3_component_helpers_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", *extra,
|
||||
"-DIGGY_RECONSTRUCT_AS3_COMPONENT_HELPERS_"
|
||||
f"{platform.upper()}=1",
|
||||
"-I", str(RECONSTRUCTED), str(probe),
|
||||
], capture_output=True, text=True)
|
||||
self.assertEqual(syntax.returncode, 0,
|
||||
(platform, language, syntax.stderr))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user