[cc] many bug fixes, and associated unit tests

Author: jgarzik

cc/arch/regalloc.rs

@@ -341,7 +341,10 @@ where
             }
         })
         .collect();
-    result.sort_by_key(|i| i.start);
+    // Sort by (start, pseudo) to ensure deterministic ordering
+    // This is critical when multiple intervals have the same start position
+    // (e.g., all arguments start at 0), as HashMap iteration is non-deterministic
+    result.sort_by_key(|i| (i.start, i.pseudo.0));
     (result, constraint_points)
 }
 

cc/arch/x86_64/codegen.rs

@@ -82,6 +82,14 @@ impl X86_64CodeGen {
                     offset: -adjusted,
                 })
             }
+            Loc::IncomingArg(offset) => {
+                // Incoming stack argument: at [rbp + offset] (positive offset)
+                // No callee_saved_offset adjustment needed - these are above the return address
+                GpOperand::Mem(MemAddr::BaseOffset {
+                    base: Reg::Rbp,
+                    offset: *offset,
+                })
+            }
             Loc::Imm(v) => GpOperand::Imm(*v),
             Loc::FImm(_, _) => GpOperand::Imm(0), // FP immediates handled separately
             Loc::Xmm(_) => GpOperand::Imm(0),     // XMM handled separately
@@ -616,6 +624,16 @@ impl X86_64CodeGen {
                     }),
                 });
             }
+            Loc::IncomingArg(offset) => {
+                self.push_lir(X86Inst::Cmp {
+                    size: op_size,
+                    src: GpOperand::Imm(0),
+                    dst: GpOperand::Mem(MemAddr::BaseOffset {
+                        base: Reg::Rbp,
+                        offset: *offset,
+                    }),
+                });
+            }
             Loc::Imm(v) => {
                 let target = if *v != 0 { insn.bb_true } else { insn.bb_false };
                 if let Some(target) = target {
@@ -1002,6 +1020,17 @@ impl X86_64CodeGen {
                     dst: GpOperand::Reg(dst),
                 });
             }
+            Loc::IncomingArg(offset) => {
+                // LIR: memory-to-register move from incoming stack arg
+                self.push_lir(X86Inst::Mov {
+                    size: op_size,
+                    src: GpOperand::Mem(MemAddr::BaseOffset {
+                        base: Reg::Rbp,
+                        offset,
+                    }),
+                    dst: GpOperand::Reg(dst),
+                });
+            }
             Loc::Imm(v) => {
                 // x86-64: movl sign-extends to 64-bit, movq only works with 32-bit signed immediates
                 // For values outside 32-bit signed range, use movabsq
@@ -2274,6 +2303,9 @@ impl X86_64CodeGen {
                 let adjusted = offset + self.callee_saved_offset;
                 format!("-{}(%rbp)", adjusted)
             }
+            Loc::IncomingArg(offset) => {
+                format!("{}(%rbp)", offset)
+            }
             Loc::Imm(v) => format!("${}", v),
             Loc::Xmm(xmm) => xmm.name().to_string(),
             Loc::FImm(_, _) => {

cc/arch/x86_64/float.rs

@@ -730,6 +730,16 @@ impl X86_64CodeGen {
                     dst: XmmOperand::Reg(dst),
                 });
             }
+            Loc::IncomingArg(offset) => {
+                self.push_lir(X86Inst::MovFp {
+                    size: fp_size,
+                    src: XmmOperand::Mem(MemAddr::BaseOffset {
+                        base: Reg::Rbp,
+                        offset,
+                    }),
+                    dst: XmmOperand::Reg(dst),
+                });
+            }
             Loc::FImm(v, imm_size) => {
                 // Use the size from the FImm, not the passed-in size
                 // This ensures float constants are loaded as float, not double

cc/arch/x86_64/regalloc.rs

@@ -404,6 +404,9 @@ pub enum Loc {
     Xmm(XmmReg),
     /// On the stack at [rbp - offset]
     Stack(i32),
+    /// Incoming stack argument at [rbp + offset] (positive offset, above return address)
+    /// Used for function parameters 7+ that are passed on the stack by the caller
+    IncomingArg(i32),
     /// Immediate integer constant
     Imm(i64),
     /// Immediate float constant (value, size in bits)
@@ -527,9 +530,11 @@ impl RegAlloc {
                                 self.free_xmm_regs.retain(|&r| r != fp_arg_regs[fp_arg_idx]);
                                 self.fp_pseudos.insert(pseudo.id);
                             } else {
+                                // Stack-passed FP argument: at [rbp + offset]
+                                // 16 = saved rbp (8) + return address (8)
                                 let offset =
                                     16 + (i - int_arg_regs.len() - fp_arg_regs.len()) as i32 * 8;
-                                self.locations.insert(pseudo.id, Loc::Stack(-offset));
+                                self.locations.insert(pseudo.id, Loc::IncomingArg(offset));
                             }
                             fp_arg_idx += 1;
                         } else {
@@ -538,8 +543,10 @@ impl RegAlloc {
                                     .insert(pseudo.id, Loc::Reg(int_arg_regs[int_arg_idx]));
                                 self.free_regs.retain(|&r| r != int_arg_regs[int_arg_idx]);
                             } else {
-                                let offset = 16 + (i - int_arg_regs.len()) as i32 * 8;
-                                self.locations.insert(pseudo.id, Loc::Stack(-offset));
+                                // Stack-passed integer argument: at [rbp + offset]
+                                // 16 = saved rbp (8) + return address (8)
+                                let offset = 16 + (int_arg_idx - int_arg_regs.len()) as i32 * 8;
+                                self.locations.insert(pseudo.id, Loc::IncomingArg(offset));
                             }
                             int_arg_idx += 1;
                         }

cc/ir/dce.rs

@@ -86,6 +86,11 @@ fn get_uses(insn: &Instruction) -> Vec<PseudoId> {
         }
     }
 
+    // Indirect call target (function pointer)
+    if let Some(indirect) = insn.indirect_target {
+        uses.push(indirect);
+    }
+
     uses
 }
 
@@ -507,4 +512,74 @@ mod tests {
 
         assert_eq!(func.blocks[0].insns[1].op, Opcode::Store);
     }
+
+    #[test]
+    fn test_indirect_call_target_is_use() {
+        // Test that get_uses() includes indirect_target for function pointer calls.
+        // This prevents DCE from eliminating the instruction that computes
+        // the function pointer before an indirect call.
+        let types = TypeTable::new(64);
+        let call_insn = Instruction::call_indirect(
+            Some(PseudoId(0)), // return value target
+            PseudoId(5),       // func_addr (the function pointer)
+            vec![PseudoId(1), PseudoId(2)], // args
+            vec![types.int_id, types.int_id], // arg_types
+            types.int_id,
+            32,
+        );
+
+        let uses = get_uses(&call_insn);
+
+        // Verify indirect_target is in the uses list
+        assert!(
+            uses.contains(&PseudoId(5)),
+            "get_uses should include indirect_target"
+        );
+        // Also verify call arguments are in uses
+        assert!(uses.contains(&PseudoId(1)));
+        assert!(uses.contains(&PseudoId(2)));
+    }
+
+    #[test]
+    fn test_indirect_call_keeps_func_ptr_live() {
+        // Full DCE test: verify an indirect call keeps its function pointer live.
+        let types = TypeTable::new(64);
+        let mut func = Function::new("test", types.int_id);
+
+        func.add_pseudo(Pseudo::reg(PseudoId(0), 0)); // result
+        func.add_pseudo(Pseudo::reg(PseudoId(1), 1)); // func pointer
+        func.add_pseudo(Pseudo::val(PseudoId(2), 42)); // arg
+
+        let mut bb = BasicBlock::new(BasicBlockId(0));
+        bb.add_insn(Instruction::new(Opcode::Entry));
+
+        // %1 = load the function pointer (this should stay live)
+        let mut load = Instruction::new(Opcode::Load);
+        load.target = Some(PseudoId(1));
+        load.src = vec![PseudoId(2)]; // load from some address
+        load.typ = Some(types.pointer_to(types.int_id));
+        load.size = 64;
+        bb.add_insn(load);
+
+        // %0 = call_indirect %1(%2)
+        let call = Instruction::call_indirect(
+            Some(PseudoId(0)),
+            PseudoId(1), // indirect through %1
+            vec![PseudoId(2)], // args
+            vec![types.int_id], // arg_types
+            types.int_id,
+            32,
+        );
+        bb.add_insn(call);
+
+        bb.add_insn(Instruction::ret(Some(PseudoId(0))));
+        func.add_block(bb);
+        func.entry = BasicBlockId(0);
+
+        let changed = run(&mut func);
+
+        // The load instruction that defines %1 (func pointer) should NOT be
+        // eliminated because %1 is used as indirect_target in the call
+        assert!(!changed || func.blocks[0].insns[1].op == Opcode::Load);
+    }
 }