Major CC Updates and Fixes

bugs.md

@@ -0,0 +1,104 @@
+# pcc Bug Log — CPython Build Campaign
+
+## Status: CPython 3.12.9 builds and runs with pcc at -O0. Sym pseudo liveness fix — eval loop frame 118KB→61KB. 456/458 tests pass (ulimit -s unlimited). test_threading passes with default 8MB stack.
+
+### Bugs A-N, P, Q, 1-6: ALL FIXED (see git history)
+
+### Bug S: Floating-point codegen bugs — FIXED
+- **Root cause 1:** XMM registers not spilled across function calls. x86-64 SysV ABI says ALL XMM regs are caller-saved, but the register allocator didn't check `crosses_call` for FP values. Float/double values in XMM8-XMM13 were silently clobbered by intervening calls.
+- **Fix:** In `regalloc.rs`, spill FP values to stack when `crosses_call` is true.
+- **Root cause 2:** `emit_cbr()` used `FpSize::Single` (ucomiss, 32-bit) for all float-to-bool conditions including doubles. Values like 0.5 have zero in their lower 32 bits, so `if(0.5)` evaluated to false.
+- **Fix:** Derive `FpSize` from the condition type's bit width in both x86-64 and aarch64 backends.
+- **Tests:** `codegen_xmm_spill_across_calls`, `codegen_double_to_bool`
+
+### Bug T: chr()/string literals with bytes >= 0x80 — FIXED
+- **Root cause:** pcc stored C string bytes as Rust `char` values in a Rust `String`. For bytes >= 0x80, Rust UTF-8 encodes them (e.g., `\x80` → 2-byte `\xC2\x80`), corrupting assembly output, sizeof, and zero-fill calculations.
+- **Fix (5 locations):**
+  - `escape_string()` in `cc/arch/codegen.rs`: emit single octal byte for chars 0-255
+  - `emit_initializer_data()` in `cc/arch/codegen.rs`: use `chars().count()` for zero-fill
+  - `sizeof` in `cc/parse/expression.rs`: use `chars().count()` for array size
+  - Null terminator offsets in `cc/ir/linearize.rs` (2 places): use `chars().count()`
+- **Test:** `codegen_string_literal_high_bytes`
+
+### Bug U: unsigned long to double + XMM param spill — FIXED
+- **Fixed:** `cvtsi2sdq` treated unsigned 64-bit values as signed. Values >= 2^63 produced negative doubles. Now uses the correct shift-convert-double sequence.
+- **Fixed:** XMM function parameters not spilled to stack at function entry. Any float computation that reused the same XMM register would clobber the parameter.
+- `int(37.5)` and `math.floor(37.5)` now work correctly in CPython.
+- **Tests:** `codegen_unsigned_long_to_double`
+
+### Bug W: FP compare Xmm0 clobber — FIXED
+- **Root cause:** `emit_fp_compare()` loaded src1 into Xmm0, but if src2 was allocated to Xmm0, src2 was clobbered. Result: `ucomisd %xmm0, %xmm0` (self-compare, always equal), causing `d < -(double)_PyTime_MIN` to always be false.
+- **Symptom:** `time.sleep(0.001)` raised `OverflowError: timestamp out of range for platform time_t`
+- **Fix:** In `emit_fp_compare()`, check if src2 is in Xmm0 before loading src1; if so, save src2 to Xmm15 first.
+- **Test:** `codegen_fp_compare_xmm0_clobber`
+
+### Bug X: Inline asm 64-bit register constraints — FIXED
+- **Root cause:** `format_reg_default()` in `AsmOperandFormatter` hardcoded 32-bit register names for all inline asm operands. For `uintptr_t` with `"+r"` constraint, `xchg %edx, (%r8)` was emitted instead of `xchg %rdx, (%r8)`, truncating 64-bit values to 32 bits.
+- **Symptom:** CPython's `_Py_atomic_store` (seq_cst via xchg) truncated pointers. Signal handlers in `_PySignal_Fini` had corrupted addresses → segfault during finalization.
+- **Fix:** Pass operand size through `substitute_asm_operands` → `format_reg_default(reg, size_bits)`. Select register width (b/w/k/q) based on operand type's bit width.
+- **Test:** `codegen_inline_asm_64bit_constraint`
+
+### Bug Y: XMM-to-GPR movd truncation — FIXED
+- **Root cause:** `emit_move()` for `Loc::Xmm → Reg` hardcoded `OperandSize::B32` (movd) instead of using `op_size`. For doubles (64-bit), `movd %xmm, %r10d` copied only lower 32 bits. For `1.0` (0x3FF0000000000000), lower 32 bits = 0x00000000 → result 0.0.
+- **Symptom:** `1/1` returned `0.0` in CPython (integer true division). Conditional select of double values (ternary, if/else returning double) produced 0.0.
+- **Fix:** Use `op_size` instead of hardcoded `B32` in `MovXmmGp` instruction.
+- **Test:** `codegen_double_xmm_to_gpr_movq`
+
+### Bug Z: Ternary function pointer call return type — FIXED
+- **Root cause:** `parse_conditional_expr()` used `self.types.pointer_to()` for function-to-pointer decay, but `pointer_to()` only does a lookup and falls back to `void*` when the type isn't in the table. This caused `(cond ? func_a : func_b)(arg)` to have type `void*`, and the Call expression handler couldn't determine the function return type, defaulting to `int` (32-bit).
+- **Fix:** Use `self.types.intern(Type::pointer(...))` instead of `self.types.pointer_to(...)` in ternary decay, ensuring the pointer-to-function type is created if not found.
+- **Symptom:** `string.Formatter().format()` segfaulted; indirect calls through ternary-selected function pointers returned truncated 32-bit values for pointer return types.
+- **Test:** `codegen_ternary_fptr_return_type`
+
+### Bug AA: Character literal signedness — FIXED
+- **Root cause:** `'\x80'` produced 128 (unsigned) instead of -128 (signed). pcc cast `char` to `i64` via Rust `char` (unsigned), bypassing sign-extension. GCC treats `'\x80'` as -128 per implementation-defined behavior.
+- **Fix:** Use `*c as u8 as i8 as i64` in all 4 CharLit-to-integer conversions (linearize.rs x3, parser.rs x1).
+- **Symptom:** CPython's `_pickle` module failed — `enum { PROTO = '\x80' }` was 128, but `switch((enum)char_val)` saw -128. All opcodes >= 0x80 were unmatchable.
+- **Test:** `codegen_char_literal_signedness`
+
+### Bug AB: Static local struct variables on stack — FIXED
+- **Root cause:** `linearize_local_decl()` checked `self.types.modifiers(typ)` for STATIC, but storage class modifiers are in `declarator.storage_class`, not the type system. For struct types, STATIC was never in the type, so static structs were allocated on the stack.
+- **Fix:** Check `declarator.storage_class.contains(TypeModifiers::STATIC)` instead.
+- **Symptom:** CPython's `_PyArg_Parser` structs (declared `static` in clinic-generated code) lived on the stack. When the function returned, the linked list in `_PyRuntime.getargs.static_parsers` contained dangling stack pointers → segfault in `_PyArg_Fini()` during finalization.
+- **Test:** `codegen_static_local_struct`
+
+### Bug R5/O: Previously listed bugs — FIXED by above fixes
+
+### Bug AC: IEEE 754 NaN comparison — FIXED
+- **Root cause:** `ucomisd` sets PF=1 for NaN, but `sete`/`setb`/`setbe`/`setne` don't check PF. All NaN comparisons gave wrong results.
+- **Fix:** For ordered ==, <, <=: emit `setcc + setnp + AND`. For !=: `setne + setp + OR`. Added `CondCode::Np`/`P`.
+- **Test:** `codegen_nan_comparison`, `codegen_nan_comparison_comprehensive`
+
+### Bug AD: PreInc on dereferenced PostInc (++*s++) — FIXED
+- **Root cause:** `++*s++` re-evaluated `s++` when storing back the incremented value, causing the store to go to the wrong address (s+1 instead of s). The deref operand's side effects were executed twice.
+- **Fix:** Pre-compute the lvalue address via `linearize_lvalue` before loading the value, avoiding re-evaluation of PostInc side effects.
+- **Symptom:** `_Py_dg_dtoa` (float-to-string) produced wrong digit strings. `'%.0f' % 1.5` returned "12" instead of "2", causing memset crash.
+- **Test:** `codegen_preinc_deref_postinc`
+
+### Bug AE: 2-SSE struct ABI param/return mismatch — PARTIALLY FIXED
+- **Root cause:** struct { double, double } was passed via hidden pointer but returned in XMM0+XMM1. Crashes when return value passed directly as argument.
+- **Fix:** Implemented 2-XMM parameter passing at call sites and function entry.
+- **Remaining:** When a 2-SSE struct is the FIRST param followed by integer params, the callee's function entry code assigns integer args to the wrong registers (off by one). `powu(Complex x, long n)` reads `n` from rsi instead of rdi.
+- **Workaround:** Complex tests work when struct is not first param, or with unlimited stack.
+
+### Bug AF: Stack overflow from excessive frame sizes — FIXED
+- `_PyEval_EvalFrameDefault` frame reduced from 118KB to 83KB to 61KB via stack slot reuse
+- Stack coloring reuses slots for non-loop-spanning pseudos with non-overlapping intervals
+- Sym pseudo liveness fix: kill Sym pseudos at their declaration blocks before gen/kill scan, preventing block-scoped locals from appearing simultaneously live across switch/case/computed-goto dispatch
+- test_threading now passes without `ulimit -s unlimited` (previously SIGSEGV from thread stack overflow)
+- 17 additional CPython tests now passing
+
+### Bug AG-AK: See git log for recent fixes (small struct return, FP binop clobber, va_start overflow, long double narrowing, XMM cross-block spill)
+
+### Test status: CPython 3.12.9 make test at -O0 (ulimit -s unlimited)
+- 491 tests run (test_decimal skipped, hangs at -O0)
+- 456 PASS, 2 FAIL (baseline was 70 FAIL, 68 tests fixed)
+- Remaining 2: test.test_gdb.test_pretty_print (GCC-specific, expected), test_tools (parallel flake, passes individually)
+- test_threading and test_statistics pass without `ulimit -s unlimited`
+
+### CPython build setup at -O0
+- configure CC=/tmp/pcc-bin/pcc, then fix pyconfig.h GETPGRP/SETPGRP
+- Frozen deepfreeze.c generated by gcc build first, saved to /tmp
+- Makefile: OPT= -DNDEBUG -g -O0 -Wall
+- After make clean: restore deepfreeze.c, then make -j nproc
+- Must delete all .pyc files after pcc rebuild

cc/README.md

@@ -82,13 +82,8 @@ Supported:
 
 Not yet implemented (features we want to add):
 - -fverbose-asm
-- top builtins to implement:
-  __builtin_expect
-  __sync_synchronize
-  __sync_fetch_and_add (and maybe a couple of its siblings)
 - assembly peephole optimizations
-- C11 atomics (_Atomic operations)
-- Other C11 features: _Generic, anonymous structs
+- C11 `_Generic` type-generic selection
 
 ## Code Quality
 

cc/abi/aapcs64.rs

@@ -184,6 +184,14 @@ impl Abi for Aapcs64Abi {
             return ArgClass::Extend { signed, size_bits };
         }
 
+        // 128-bit integer types: two consecutive GP registers, 16-byte aligned
+        if kind == TypeKind::Int128 {
+            return ArgClass::Direct {
+                classes: vec![RegClass::Integer, RegClass::Integer],
+                size_bits,
+            };
+        }
+
         // Integer and pointer types - pass in X registers
         if is_integer(kind) || is_pointer(kind) {
             return ArgClass::Direct {
@@ -273,6 +281,14 @@ impl Abi for Aapcs64Abi {
             return ArgClass::Ignore;
         }
 
+        // 128-bit integer types: return in X0+X1
+        if kind == TypeKind::Int128 {
+            return ArgClass::Direct {
+                classes: vec![RegClass::Integer, RegClass::Integer],
+                size_bits,
+            };
+        }
+
         // Integer and pointer types - return in X0
         if is_integer(kind) || is_pointer(kind) {
             return ArgClass::Direct {

cc/abi/mod.rs

@@ -219,6 +219,7 @@ fn is_integer(kind: TypeKind) -> bool {
             | TypeKind::Int
             | TypeKind::Long
             | TypeKind::LongLong
+            | TypeKind::Int128
             | TypeKind::Bool
             | TypeKind::Enum
     )

cc/abi/sysv_amd64.rs

@@ -14,7 +14,7 @@
 // Key rules:
 // - Arguments passed in RDI, RSI, RDX, RCX, R8, R9 (INTEGER) and XMM0-XMM7 (SSE)
 // - Return values in RAX, RDX (INTEGER) or XMM0, XMM1 (SSE)
-// - Structs > 16 bytes use sret (hidden pointer in RDI)
+// - Structs > 16 bytes: returned via sret (hidden pointer in RDI), passed by value on stack
 // - Structs 9-16 bytes may use two registers
 // - Each eightbyte is classified independently, then merged
 //
@@ -196,6 +196,14 @@ impl Abi for SysVAmd64Abi {
             return ArgClass::Extend { signed, size_bits };
         }
 
+        // 128-bit integer types: two GP registers
+        if kind == TypeKind::Int128 {
+            return ArgClass::Direct {
+                classes: vec![RegClass::Integer, RegClass::Integer],
+                size_bits,
+            };
+        }
+
         // Integer and pointer types
         if is_integer(kind) || is_pointer(kind) {
             return ArgClass::Direct {
@@ -274,6 +282,14 @@ impl Abi for SysVAmd64Abi {
             return ArgClass::Ignore;
         }
 
+        // 128-bit integer types: return in RAX+RDX
+        if kind == TypeKind::Int128 {
+            return ArgClass::Direct {
+                classes: vec![RegClass::Integer, RegClass::Integer],
+                size_bits,
+            };
+        }
+
         // Integer and pointer types - return in RAX
         if is_integer(kind) || is_pointer(kind) {
             return ArgClass::Direct {