feat: implement merge sort for jCC lists to ensure chronological dump order

Author: not-matthias

callgrind/dump.c

@@ -739,6 +739,54 @@ static void fprint_jcc(VgFile *fp, jCC* jcc, AddrPos* curr, AddrPos* last,
 static AddrCost ccSum[2];
 static int currSum;
 
+/*
+ * Merge sort implementation for jCC lists to ensure chronological dump order.
+ * Sorts by creation_seq field to preserve execution order.
+ */
+
+/* Merge two sorted jCC lists */
+static jCC* merge_jcc_lists(jCC* left, jCC* right) {
+    if (!left) return right;
+    if (!right) return left;
+
+    jCC* result = NULL;
+
+    if (left->creation_seq <= right->creation_seq) {
+        result = left;
+        result->next_from = merge_jcc_lists(left->next_from, right);
+    } else {
+        result = right;
+        result->next_from = merge_jcc_lists(left, right->next_from);
+    }
+
+    return result;
+}
+
+/* Sort jCC list using merge sort */
+static jCC* merge_sort_jcc_list(jCC* head) {
+    if (!head || !head->next_from) return head;
+
+    /* Split list into two halves using slow/fast pointer technique */
+    jCC* slow = head;
+    jCC* fast = head->next_from;
+
+    while (fast && fast->next_from) {
+        slow = slow->next_from;
+        fast = fast->next_from->next_from;
+    }
+
+    /* Split at midpoint */
+    jCC* mid = slow->next_from;
+    slow->next_from = NULL;
+
+    /* Recursively sort both halves */
+    jCC* left = merge_sort_jcc_list(head);
+    jCC* right = merge_sort_jcc_list(mid);
+
+    /* Merge sorted halves */
+    return merge_jcc_lists(left, right);
+}
+
 /*
  * Print all costs of a BBCC:
  * - FCCs of instructions
@@ -818,7 +866,10 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
 	    get_debug_pos(bbcc, bb_addr(bb)+instr_info->instr_offset, &(currCost->p));
 	    fprint_apos(fp, &(currCost->p), last, bbcc->cxt->fn[0]->file, bbcc);
 	    something_written = True;
-	    for(jcc=bbcc->jmp[jmp].jcc_list; jcc; jcc=jcc->next_from) {
+
+        // Sort jcc_list by creation sequence to ensure chronological order
+        jCC* sorted_list = merge_sort_jcc_list(bbcc->jmp[jmp].jcc_list);
+	    for(jcc=sorted_list; jcc; jcc=jcc->next_from) {
 		if (((jcc->jmpkind != jk_Call) && (jcc->call_counter >0)) ||
 		    (!CLG_(is_zero_cost)( CLG_(sets).full, jcc->cost )))
 		    fprint_jcc(fp, jcc, &(currCost->p), last, ecounter);
@@ -868,15 +919,17 @@ static Bool fprint_bbcc(VgFile *fp, BBCC* bbcc, AddrPos* last)
       fprint_fcost(fp, currCost, last);
     }
 
-    if (jcc_count > 0)
-	for(jcc=bbcc->jmp[jmp].jcc_list; jcc; jcc=jcc->next_from) {
+    if (jcc_count > 0) {
+	// Sort jcc_list by creation sequence to ensure chronological order
+	jCC* sorted_list = merge_sort_jcc_list(bbcc->jmp[jmp].jcc_list);
+	for(jcc=sorted_list; jcc; jcc=jcc->next_from) {
 	    CLG_ASSERT(jcc->jmp == jmp);
 	    if ( ((jcc->jmpkind != jk_Call) && (jcc->call_counter >0)) ||
 		 (!CLG_(is_zero_cost)( CLG_(sets).full, jcc->cost )))
 
 		fprint_jcc(fp, jcc, &(currCost->p), last, ecounter);
 	}
-  }
+    }
 
   if (CLG_(clo).dump_bbs || CLG_(clo).dump_bb) {
     if (!CLG_(is_zero_cost)( CLG_(sets).full, currCost->cost )) {

callgrind/global.h

@@ -244,6 +244,7 @@ struct _jCC {
   UInt jmp;         /* jump no. in source */
 
   ULong call_counter; /* no wraparound with 64 bit */
+  ULong creation_seq; /* creation order sequence number for correct dump order */
 
   FullCost cost; /* simulator + user counters */
 };

callgrind/jumps.c

@@ -34,6 +34,9 @@
 
 static jcc_hash current_jccs;
 
+/* Global counter for jCC creation sequence to preserve chronological order */
+static ULong jcc_creation_counter = 0;
+
 void CLG_(init_jcc_hash)(jcc_hash* jccs)
 {
    Int i;
@@ -148,6 +151,7 @@ static jCC* new_jcc(BBCC* from, UInt jmp, BBCC* to)
    jcc->to        = to;
    jcc->jmpkind   = jk_Call;
    jcc->call_counter = 0;
+   jcc->creation_seq = jcc_creation_counter++;
    jcc->cost = 0;
 
    /* insert into JCC chain of calling BBCC.