asmdiff 0.1.6__tar.gz → 0.1.7__tar.gz

{asmdiff-0.1.6 → asmdiff-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asmdiff
-Version: 0.1.6
+Version: 0.1.7
 Summary: Compare per-function assembly between paired C implementations
 Project-URL: Homepage, https://github.com/rt-rtos/asmdiff
 Project-URL: Repository, https://github.com/rt-rtos/asmdiff
@@ -30,7 +30,7 @@ Description-Content-Type: text/markdown
 does the compiler actually emit - before and after?** It compiles a small
 harness file across a matrix of compilers, extracts each variant function's
 assembly, and prints side-by-side listings plus a summary of instruction
-counts, outbound calls, and loop spans.
+counts, loop spans, and outbound calls.
 
 Compilers and flags are configured per project through named targets in an
 `asmdiff.toml` file, and any GNU-as ELF assembly is parsed.
@@ -94,9 +94,9 @@ endbr64                                      | endbr64
 mulss   .LC0(%rip), %xmm0                    | movl    $-5, %edi
 ret                                          | jmp     ldexpf@PLT
 
-function   role       insns  calls   loop spans
-old_scale  baseline   3      -       -
-new_scale  candidate  3      ldexpf  -
+function   role       insns  loop spans  calls
+old_scale  baseline   3      -           -
+new_scale  candidate  3      -           ldexpf
 ```
 
 Read the `calls` column first: `-` means the construct lowered to inline
@@ -157,9 +157,9 @@ call8   __udivdi3                            |
 mov.n   a2, a10                              |
 retw.n                                       |
 
-function        role       insns  calls      loop spans
-old_elapsed_ms  baseline   10     __udivdi3  -
-new_elapsed_ms  candidate  6      -          -
+function        role       insns  loop spans  calls
+old_elapsed_ms  baseline   10     -           __udivdi3
+new_elapsed_ms  candidate  6      -           -
 ```
 
 The candidate is six inline instructions ending in a multiply-high by
@@ -216,8 +216,8 @@ apply_gain:
 .L1:
         retw.n
 
-function    insns  calls  loop spans
-apply_gain  13     -      .L3_LEND:4
+function    insns  loop spans  calls
+apply_gain  13     .L3_LEND:4  -
 ```
 
 The span `.L3_LEND:4` is the four-instruction body of the Xtensa
@@ -246,11 +246,11 @@ $ asmdiff build/S3-Amysynth.elf --filter '^render_' # stats table only
 ```
 
 ```
-function                    insns  calls               loop spans
-render_lut_cub              98     -                   .L32:74
-render_lut                  51     -                   .L7e_LEND:32
-render_external_audio_in    32     -                   .L52_LEND:10
-render_partial              112    exp2f, __divsf3, ...  .L66:31
+function                    insns  loop spans    calls
+render_lut_cub              98     .L32:74       -
+render_lut                  51     .L7e_LEND:32  -
+render_external_audio_in    32     .L52_LEND:10  -
+render_partial              112    .L66:31       exp2f, __divsf3, ...
 ```
 
 (Four of the eleven matched rows shown.) The columns are the same as
@@ -280,10 +280,10 @@ one row scan.
 ```
 $ asmdiff build/S3-Amysynth.elf --filter 'sequencer_(process_tick|recompute|timer_callback)'
 
-function                             insns  calls                                                           loop spans
-sequencer_timer_callback$lto_priv$0  77     __divsf3, __udivdi3                                             .L21:41
-sequencer_recompute                  46     __extendsfdf2, __divdf3, __muldf3, __fixunsdfsi, __divsf3       -
-sequencer_process_tick$lto_priv$0    117    xQueueSemaphoreTake, xQueueGenericSend, add_delta_to_queue, a8  .L2e:96 .L48:85 .L8d:6
+function                             insns  loop spans              calls
+sequencer_timer_callback$lto_priv$0  77     .L21:41                 __divsf3, __udivdi3
+sequencer_recompute                  46     -                       __extendsfdf2, __divdf3, __muldf3, __fixunsdfsi, __divsf3
+sequencer_process_tick$lto_priv$0    117    .L2e:96 .L48:85 .L8d:6  xQueueSemaphoreTake, xQueueGenericSend, add_delta_to_queue, a8
 ```
 
 A timer callback pays a software float divide *and* a 64-bit
@@ -625,14 +625,14 @@ $ asmdiff old/delay.c new/delay.c
 
 -- old/delay.c --
 
-function         insns  calls        loop spans
-stereo_reverb    437    -            .L108:327
+function         insns  loop spans  calls
+stereo_reverb    437    .L108:327   -
 ...
-TOTAL (13 functions)  956   malloc_caps, free, ...  -
+TOTAL (13 functions)  956   -   malloc_caps, free, ...
 
 -- new/delay.c --
 ...
-TOTAL (13 functions)  1028  malloc_caps, free, ...  -
+TOTAL (13 functions)  1028  -   malloc_caps, free, ...
 ```
 
 The TOTAL row is a coarse sanity check — did this refactor move the file's
@@ -643,8 +643,13 @@ measurement, and per-function rows are where the real information is.
 Only labels the assembler types as functions are listed — global data
 (string constants, state structs, lookup tables) gets column-0 labels too
 but is not code. A `calls` list longer than 8 symbols is truncated to
-`..., +N more`; real firmware dispatch functions call dozens of distinct
-symbols and would otherwise make rows thousands of characters wide.
+`..., Total Calls:N`; real firmware dispatch functions call dozens of
+distinct symbols and would otherwise make rows thousands of characters
+wide. When stdout is a terminal, rows are additionally trimmed to the
+terminal width: callees are dropped from the end of the `calls` column
+(never the first one) behind the same `Total Calls:N` summary, so every
+row stays on one line. Piped or redirected output skips the width trim
+and keeps the full capped list, so it stays stable and greppable.
 
 ## Comparing the same function across two builds (`--across`)
 
@@ -705,9 +710,9 @@ movl    %r14d, %r11d                         | sarl    $11, %ebp
 call    SMULR6                               | leal    1024(%rax), %edx
   [... 60 rows omitted ...]
 
-function                     role       insns  calls   loop spans
-dsps_biquad_f32_ansi [cc#1]  baseline   59     SMULR6  .L27:32
-dsps_biquad_f32_ansi [cc#2]  candidate  89     -       .L26:54
+function                     role       insns  loop spans  calls
+dsps_biquad_f32_ansi [cc#1]  baseline   59     .L27:32     SMULR6
+dsps_biquad_f32_ansi [cc#2]  candidate  89     .L26:54     -
 ```
 
 (The listing is abridged here; the tool prints all 92 rows. The columns
@@ -743,9 +748,9 @@ call    ldexpf@PLT                           |
 leave                                        |
 ret                                          |
 
-function       role       insns  calls   loop spans
-new_rt [cc#1]  baseline   13     ldexpf  -
-new_rt [cc#2]  candidate  2      ldexpf  -
+function       role       insns  loop spans  calls
+new_rt [cc#1]  baseline   13     -           ldexpf
+new_rt [cc#2]  candidate  2      -           ldexpf
 ```
 
 **Two files** — before/after versions of a source file (e.g. from a git

{asmdiff-0.1.6 → asmdiff-0.1.7}/README.md

@@ -12,7 +12,7 @@
 does the compiler actually emit - before and after?** It compiles a small
 harness file across a matrix of compilers, extracts each variant function's
 assembly, and prints side-by-side listings plus a summary of instruction
-counts, outbound calls, and loop spans.
+counts, loop spans, and outbound calls.
 
 Compilers and flags are configured per project through named targets in an
 `asmdiff.toml` file, and any GNU-as ELF assembly is parsed.
@@ -76,9 +76,9 @@ endbr64                                      | endbr64
 mulss   .LC0(%rip), %xmm0                    | movl    $-5, %edi
 ret                                          | jmp     ldexpf@PLT
 
-function   role       insns  calls   loop spans
-old_scale  baseline   3      -       -
-new_scale  candidate  3      ldexpf  -
+function   role       insns  loop spans  calls
+old_scale  baseline   3      -           -
+new_scale  candidate  3      -           ldexpf
 ```
 
 Read the `calls` column first: `-` means the construct lowered to inline
@@ -139,9 +139,9 @@ call8   __udivdi3                            |
 mov.n   a2, a10                              |
 retw.n                                       |
 
-function        role       insns  calls      loop spans
-old_elapsed_ms  baseline   10     __udivdi3  -
-new_elapsed_ms  candidate  6      -          -
+function        role       insns  loop spans  calls
+old_elapsed_ms  baseline   10     -           __udivdi3
+new_elapsed_ms  candidate  6      -           -
 ```
 
 The candidate is six inline instructions ending in a multiply-high by
@@ -198,8 +198,8 @@ apply_gain:
 .L1:
         retw.n
 
-function    insns  calls  loop spans
-apply_gain  13     -      .L3_LEND:4
+function    insns  loop spans  calls
+apply_gain  13     .L3_LEND:4  -
 ```
 
 The span `.L3_LEND:4` is the four-instruction body of the Xtensa
@@ -228,11 +228,11 @@ $ asmdiff build/S3-Amysynth.elf --filter '^render_' # stats table only
 ```
 
 ```
-function                    insns  calls               loop spans
-render_lut_cub              98     -                   .L32:74
-render_lut                  51     -                   .L7e_LEND:32
-render_external_audio_in    32     -                   .L52_LEND:10
-render_partial              112    exp2f, __divsf3, ...  .L66:31
+function                    insns  loop spans    calls
+render_lut_cub              98     .L32:74       -
+render_lut                  51     .L7e_LEND:32  -
+render_external_audio_in    32     .L52_LEND:10  -
+render_partial              112    .L66:31       exp2f, __divsf3, ...
 ```
 
 (Four of the eleven matched rows shown.) The columns are the same as
@@ -262,10 +262,10 @@ one row scan.
 ```
 $ asmdiff build/S3-Amysynth.elf --filter 'sequencer_(process_tick|recompute|timer_callback)'
 
-function                             insns  calls                                                           loop spans
-sequencer_timer_callback$lto_priv$0  77     __divsf3, __udivdi3                                             .L21:41
-sequencer_recompute                  46     __extendsfdf2, __divdf3, __muldf3, __fixunsdfsi, __divsf3       -
-sequencer_process_tick$lto_priv$0    117    xQueueSemaphoreTake, xQueueGenericSend, add_delta_to_queue, a8  .L2e:96 .L48:85 .L8d:6
+function                             insns  loop spans              calls
+sequencer_timer_callback$lto_priv$0  77     .L21:41                 __divsf3, __udivdi3
+sequencer_recompute                  46     -                       __extendsfdf2, __divdf3, __muldf3, __fixunsdfsi, __divsf3
+sequencer_process_tick$lto_priv$0    117    .L2e:96 .L48:85 .L8d:6  xQueueSemaphoreTake, xQueueGenericSend, add_delta_to_queue, a8
 ```
 
 A timer callback pays a software float divide *and* a 64-bit
@@ -607,14 +607,14 @@ $ asmdiff old/delay.c new/delay.c
 
 -- old/delay.c --
 
-function         insns  calls        loop spans
-stereo_reverb    437    -            .L108:327
+function         insns  loop spans  calls
+stereo_reverb    437    .L108:327   -
 ...
-TOTAL (13 functions)  956   malloc_caps, free, ...  -
+TOTAL (13 functions)  956   -   malloc_caps, free, ...
 
 -- new/delay.c --
 ...
-TOTAL (13 functions)  1028  malloc_caps, free, ...  -
+TOTAL (13 functions)  1028  -   malloc_caps, free, ...
 ```
 
 The TOTAL row is a coarse sanity check — did this refactor move the file's
@@ -625,8 +625,13 @@ measurement, and per-function rows are where the real information is.
 Only labels the assembler types as functions are listed — global data
 (string constants, state structs, lookup tables) gets column-0 labels too
 but is not code. A `calls` list longer than 8 symbols is truncated to
-`..., +N more`; real firmware dispatch functions call dozens of distinct
-symbols and would otherwise make rows thousands of characters wide.
+`..., Total Calls:N`; real firmware dispatch functions call dozens of
+distinct symbols and would otherwise make rows thousands of characters
+wide. When stdout is a terminal, rows are additionally trimmed to the
+terminal width: callees are dropped from the end of the `calls` column
+(never the first one) behind the same `Total Calls:N` summary, so every
+row stays on one line. Piped or redirected output skips the width trim
+and keeps the full capped list, so it stays stable and greppable.
 
 ## Comparing the same function across two builds (`--across`)
 
@@ -687,9 +692,9 @@ movl    %r14d, %r11d                         | sarl    $11, %ebp
 call    SMULR6                               | leal    1024(%rax), %edx
   [... 60 rows omitted ...]
 
-function                     role       insns  calls   loop spans
-dsps_biquad_f32_ansi [cc#1]  baseline   59     SMULR6  .L27:32
-dsps_biquad_f32_ansi [cc#2]  candidate  89     -       .L26:54
+function                     role       insns  loop spans  calls
+dsps_biquad_f32_ansi [cc#1]  baseline   59     .L27:32     SMULR6
+dsps_biquad_f32_ansi [cc#2]  candidate  89     .L26:54     -
 ```
 
 (The listing is abridged here; the tool prints all 92 rows. The columns
@@ -725,9 +730,9 @@ call    ldexpf@PLT                           |
 leave                                        |
 ret                                          |
 
-function       role       insns  calls   loop spans
-new_rt [cc#1]  baseline   13     ldexpf  -
-new_rt [cc#2]  candidate  2      ldexpf  -
+function       role       insns  loop spans  calls
+new_rt [cc#1]  baseline   13     -           ldexpf
+new_rt [cc#2]  candidate  2      -           ldexpf
 ```
 
 **Two files** — before/after versions of a source file (e.g. from a git

{asmdiff-0.1.6 → asmdiff-0.1.7}/asmdiff.py

@@ -3,8 +3,8 @@
 
 Compiles a harness C file across a matrix of compilers, extracts each
 variant function's assembly from the -S output, and prints side-by-side
-listings plus a summary of instruction counts, outbound calls, and loop
-spans (instructions between a local label and its last backward branch).
+listings plus a summary of instruction counts, loop spans (instructions
+between a local label and its last backward branch), and outbound calls.
 Automates fold-vs-libcall analysis when evaluating micro-optimisations
 (e.g. "does this still compile to one instruction, or is it a libcall?").
 
@@ -1050,14 +1050,54 @@ def side_by_side(left, right, ltitle, rtitle, width=44):
     return "\n".join(rows)
 
 
-def render_table(rows):
-    """Column-aligned text for a list of equal-length string tuples."""
+TOTAL_CALLS_RE = re.compile(r"Total Calls:\d+")
+
+
+def _fit_calls(cell, budget):
+    """Trim a comma-joined callee cell to at most budget columns by
+    dropping whole callees from the end, closing with a Total Calls:N
+    summary (N is always the full callee count, preserved from an
+    existing summary when the cell was already capped). The first
+    callee is never dropped; a cell that still overflows just wraps."""
+    if len(cell) <= budget:
+        return cell
+    items = cell.split(", ")
+    if TOTAL_CALLS_RE.fullmatch(items[-1]):
+        items, summary = items[:-1], items[-1]
+    else:
+        summary = f"Total Calls:{len(items)}"
+    if len(items) < 2:
+        return cell
+    for keep in range(len(items) - 1, 0, -1):
+        cand = ", ".join(items[:keep]) + ", " + summary
+        if len(cand) <= budget:
+            return cand
+    return items[0] + ", " + summary
+
+
+def render_table(rows, max_width=None):
+    """Column-aligned text for a list of equal-length string tuples.
+
+    max_width (terminal columns) keeps each row on one line by
+    trimming the last column's cells (see _fit_calls); the other
+    columns are never touched. None renders untrimmed."""
+    if max_width is not None:
+        fixed = [max(len(row[i]) for row in rows)
+                 for i in range(len(rows[0]) - 1)]
+        budget = max_width - sum(fixed) - 2 * len(fixed)
+        rows = [row[:-1] + (_fit_calls(row[-1], budget),) for row in rows]
     widths = [max(len(row[i]) for row in rows) for i in range(len(rows[0]))]
     return "\n".join(
         "  ".join(cell.ljust(w) for cell, w in zip(row, widths)).rstrip()
         for row in rows)
 
 
+def table_width():
+    """Width budget for summary tables: the terminal width when stdout
+    is a tty, else None so piped output keeps every callee greppable."""
+    return shutil.get_terminal_size().columns if sys.stdout.isatty() else None
+
+
 def format_spans(spans):
     return " ".join(f"{label}:{n}" for label, n in spans) or "-"
 
@@ -1068,27 +1108,31 @@ MAX_CALLS_SHOWN = 8
 
 
 def format_calls(calls):
-    """Comma-joined callee list, capped at MAX_CALLS_SHOWN for readability."""
+    """Comma-joined callee list; longer lists keep the first
+    MAX_CALLS_SHOWN callees and close with a Total Calls:N summary."""
     if not calls:
         return "-"
     if len(calls) > MAX_CALLS_SHOWN:
         return (", ".join(calls[:MAX_CALLS_SHOWN])
-                + f", +{len(calls) - MAX_CALLS_SHOWN} more")
+                + f", Total Calls:{len(calls)}")
     return ", ".join(calls)
 
 
-def summary_table(pairs, funcs):
-    """Instruction counts, outbound calls, and loop spans per pair member."""
-    rows = [("function", "role", "insns", "calls", "loop spans")]
+def summary_table(pairs, funcs, max_width=None):
+    """Instruction counts, loop spans, and outbound calls per pair
+    member. Calls come last: the one unbounded column stays ragged
+    right so the counts and spans keep their alignment."""
+    rows = [("function", "role", "insns", "loop spans", "calls")]
     for old, new in pairs:
         for name, role in ((old, "baseline"), (new, "candidate")):
             insns, calls = analyze(funcs[name])
-            rows.append((name, role, str(insns), format_calls(calls),
-                         format_spans(loop_spans(funcs[name]))))
-    return render_table(rows)
+            rows.append((name, role, str(insns),
+                         format_spans(loop_spans(funcs[name])),
+                         format_calls(calls)))
+    return render_table(rows, max_width)
 
 
-def file_summary_table(funcs):
+def file_summary_table(funcs, max_width=None):
     """Per-function counts plus a whole-file total row.
 
     The total sums instruction counts over every function parsed from
@@ -1096,7 +1140,7 @@ def file_summary_table(funcs):
     check, not a code-size measurement (literal pools, data, and
     alignment are not included).
     """
-    rows = [("function", "insns", "calls", "loop spans")]
+    rows = [("function", "insns", "loop spans", "calls")]
     total_insns, all_calls = 0, []
     for name, lines in funcs.items():
         insns, calls = analyze(lines)
@@ -1104,11 +1148,11 @@ def file_summary_table(funcs):
         for sym in calls:
             if sym not in all_calls:
                 all_calls.append(sym)
-        rows.append((name, str(insns), format_calls(calls),
-                     format_spans(loop_spans(lines))))
+        rows.append((name, str(insns),
+                     format_spans(loop_spans(lines)), format_calls(calls)))
     rows.append((f"TOTAL ({len(funcs)} functions)", str(total_insns),
-                 format_calls(all_calls), "-"))
-    return render_table(rows)
+                 "-", format_calls(all_calls)))
+    return render_table(rows, max_width)
 
 
 def listing(name, lines):
@@ -1119,15 +1163,16 @@ def listing(name, lines):
     return "\n".join([f"{name}:"] + body)
 
 
-def inspect_table(fn_names, funcs):
+def inspect_table(fn_names, funcs, max_width=None):
     """Stats rows for the inspected functions only - no pair roles and
     no whole-file total, unlike summary_table/file_summary_table."""
-    rows = [("function", "insns", "calls", "loop spans")]
+    rows = [("function", "insns", "loop spans", "calls")]
     for name in fn_names:
         insns, calls = analyze(funcs[name])
-        rows.append((name, str(insns), format_calls(calls),
-                     format_spans(loop_spans(funcs[name]))))
-    return render_table(rows)
+        rows.append((name, str(insns),
+                     format_spans(loop_spans(funcs[name])),
+                     format_calls(calls)))
+    return render_table(rows, max_width)
 
 
 def file_tags(a, b):
@@ -1158,7 +1203,7 @@ def report_across(fn_names, left_funcs, right_funcs, left_tag, right_tag):
     for lt, rt in pairs:
         print(side_by_side(decorated[lt], decorated[rt], lt, rt))
         print()
-    print(summary_table(pairs, decorated))
+    print(summary_table(pairs, decorated, table_width()))
 
 
 def run_across(sources, matrix, fn_names, extra_flags, tmp):
@@ -1228,7 +1273,7 @@ def run_summary(sources, matrix, extra_flags, tmp):
             if len(sections) > 1:
                 print(f"\n-- {tag} --")
             print()
-            print(file_summary_table(funcs) if funcs
+            print(file_summary_table(funcs, table_width()) if funcs
                   else "(no functions found)")
     if not ran_any:
         sys.exit("error: no usable compiler in the matrix")
@@ -1256,7 +1301,7 @@ def run_pairs(source, matrix, pair_specs, extra_flags, tmp):
                       'declare the pairs extern "C" or use --pair with the '
                       'mangled names', file=sys.stderr)
             print(f"\n== {cc_cmd} ==\n")
-            print(file_summary_table(funcs) if funcs
+            print(file_summary_table(funcs, table_width()) if funcs
                   else "(no functions found)")
             continue
         missing = sorted({n for p in pairs for n in p if n not in funcs})
@@ -1268,7 +1313,7 @@ def run_pairs(source, matrix, pair_specs, extra_flags, tmp):
         for old, new in pairs:
             print(side_by_side(funcs[old], funcs[new], old, new))
             print()
-        print(summary_table(pairs, funcs))
+        print(summary_table(pairs, funcs, table_width()))
     if not ran_any:
         sys.exit("error: no usable compiler in the matrix")
     return 0
@@ -1316,7 +1361,7 @@ def run_inspect(source, matrix, fn_names, layout, extra_flags, tmp):
             print()
             print(listing(name, funcs[name]))
         print()
-        print(inspect_table(fn_names, funcs))
+        print(inspect_table(fn_names, funcs, table_width()))
     return 0
 
 
@@ -1379,7 +1424,7 @@ def run_elf(elf, fn_names, filter_regex, objdump):
         print()
         print(listing(name, funcs[name]))
     print()
-    print(inspect_table(selected, funcs))
+    print(inspect_table(selected, funcs, table_width()))
     return 0
 
 

{asmdiff-0.1.6 → asmdiff-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "asmdiff"
-version = "0.1.6"
+version = "0.1.7"
 description = "Compare per-function assembly between paired C implementations"
 readme = "README.md"
 license = "MIT"

{asmdiff-0.1.6 → asmdiff-0.1.7}/test_asmdiff.py

@@ -1189,11 +1189,72 @@ class TestFormatCalls(unittest.TestCase):
     def test_long_list_capped(self):
         calls = [f"fn{i}" for i in range(12)]
         out = asmdiff.format_calls(calls)
-        self.assertTrue(out.endswith("+4 more"))
+        self.assertTrue(out.endswith("Total Calls:12"))
         self.assertIn("fn7", out)
         self.assertNotIn("fn8,", out)
 
 
+class TestTableMaxWidth(unittest.TestCase):
+    """render_table(max_width=) fits rows to the terminal by trimming
+    the last column only, whole callees at a time, replacing the tail
+    with (or preserving) a Total Calls:N summary."""
+
+    def test_no_max_width_keeps_long_cells(self):
+        rows = [("function", "calls"),
+                ("f", "alpha, bravo, charlie, delta")]
+        out = asmdiff.render_table(rows)
+        self.assertIn("alpha, bravo, charlie, delta", out)
+
+    def test_trims_to_fit_with_total_summary(self):
+        rows = [("function", "insns", "calls"),
+                ("f", "5", "alpha, bravo, charlie, delta")]
+        out = asmdiff.render_table(rows, max_width=37)
+        self.assertIn("alpha, Total Calls:4", out)
+        self.assertNotIn("bravo", out)
+        self.assertTrue(all(len(l) <= 37 for l in out.splitlines()))
+
+    def test_fitting_cell_left_alone(self):
+        rows = [("function", "calls"), ("f", "alpha, bravo")]
+        out = asmdiff.render_table(rows, max_width=80)
+        self.assertIn("alpha, bravo", out)
+        self.assertNotIn("Total Calls", out)
+
+    def test_merges_existing_total_summary(self):
+        rows = [("fn", "calls"), ("f", "a, b, c, Total Calls:12")]
+        out = asmdiff.render_table(rows, max_width=21)
+        self.assertIn("a, Total Calls:12", out)
+        self.assertNotIn("b", out.splitlines()[1])
+
+    def test_single_callee_never_dropped(self):
+        rows = [("fn", "calls"), ("f", "very_long_single_symbol_name")]
+        out = asmdiff.render_table(rows, max_width=10)
+        self.assertIn("very_long_single_symbol_name", out)
+
+    def test_dash_cell_untouched(self):
+        rows = [("function_with_a_very_long_header", "calls"), ("f", "-")]
+        out = asmdiff.render_table(rows, max_width=10)
+        self.assertRegex(out.splitlines()[1], r"f\s+-")
+
+    def test_inspect_table_passes_max_width(self):
+        funcs = {"f": ["call\talpha", "call\tbravo",
+                       "call\tcharlie", "call\tdelta", "ret"]}
+        out = asmdiff.inspect_table(["f"], funcs, max_width=49)
+        self.assertIn("alpha, Total Calls:4", out)
+        self.assertNotIn("bravo", out)
+
+    def test_table_width_is_terminal_width_on_tty(self):
+        with mock.patch.object(asmdiff.sys.stdout, "isatty",
+                               return_value=True), \
+             mock.patch.object(asmdiff.shutil, "get_terminal_size",
+                               return_value=os.terminal_size((100, 24))):
+            self.assertEqual(asmdiff.table_width(), 100)
+
+    def test_table_width_is_none_when_piped(self):
+        with mock.patch.object(asmdiff.sys.stdout, "isatty",
+                               return_value=False):
+            self.assertIsNone(asmdiff.table_width())
+
+
 class TestDiscoveredCompileCommands(unittest.TestCase):
     """compile_commands = true in a target / bare --compile-commands."""
 
@@ -1341,15 +1402,16 @@ class TestRendering(unittest.TestCase):
         lines = out.splitlines()
         self.assertIn("function", lines[0])
         self.assertIn("loop spans", lines[0])
+        self.assertTrue(lines[0].endswith("calls"))
         self.assertRegex(lines[1], r"old_c\s+baseline\s+2\s+-\s+-")
-        self.assertRegex(lines[2], r"new_c\s+candidate\s+1\s+ldexpf\s+-")
+        self.assertRegex(lines[2], r"new_c\s+candidate\s+1\s+-\s+ldexpf")
 
     def test_summary_table_loop_spans_column(self):
         funcs = {"a": [".L2:", "addl\t$1, %eax", "jne\t.L2"],
                  "b": ["ret"]}
         out = asmdiff.summary_table([("a", "b")], funcs)
         lines = out.splitlines()
-        self.assertRegex(lines[1], r"a\s+baseline\s+2\s+-\s+\.L2:2")
+        self.assertRegex(lines[1], r"a\s+baseline\s+2\s+\.L2:2\s+-")
         self.assertRegex(lines[2], r"b\s+candidate\s+1\s+-\s+-")
 
     def test_file_summary_totals_and_call_union(self):
@@ -1358,10 +1420,10 @@ class TestRendering(unittest.TestCase):
                        "call\tmalloc", "call\tfree", "ret"]}
         out = asmdiff.file_summary_table(funcs)
         lines = out.splitlines()
-        self.assertRegex(lines[1], r"f\s+2\s+malloc\s+-")
-        self.assertRegex(lines[2], r"g\s+5\s+malloc, free\s+\.L2:2")
+        self.assertRegex(lines[1], r"f\s+2\s+-\s+malloc")
+        self.assertRegex(lines[2], r"g\s+5\s+\.L2:2\s+malloc, free")
         self.assertRegex(lines[3],
-                         r"TOTAL \(2 functions\)\s+7\s+malloc, free\s+-")
+                         r"TOTAL \(2 functions\)\s+7\s+-\s+malloc, free")
 
 
 class TestInspectRendering(unittest.TestCase):
@@ -1379,13 +1441,13 @@ class TestInspectRendering(unittest.TestCase):
         lines = out.splitlines()
         self.assertIn("function", lines[0])
         self.assertEqual(len(lines), 2)      # header + the one function
-        self.assertRegex(lines[1], r"new_const\s+2\s+ldexpf\s+-")
+        self.assertRegex(lines[1], r"new_const\s+2\s+-\s+ldexpf")
         self.assertNotIn("TOTAL", out)
 
     def test_inspect_table_loop_spans(self):
         funcs = asmdiff.extract_functions(LOOP_ASM)
         out = asmdiff.inspect_table(["looper"], funcs)
-        self.assertRegex(out.splitlines()[1], r"looper\s+5\s+-\s+\.L2:3")
+        self.assertRegex(out.splitlines()[1], r"looper\s+5\s+\.L2:3\s+-")
 
 
 class TestRunInspect(unittest.TestCase):