asmdiff 0.1.0__tar.gz → 0.1.1__tar.gz

asmdiff-0.1.1/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(python3 test_asmdiff.py)"
+    ]
+  }
+}

{asmdiff-0.1.0 → asmdiff-0.1.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: asmdiff
-Version: 0.1.0
+Version: 0.1.1
 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
 Author: Rasmus Tikkanen
 License-Expression: MIT
 License-File: LICENSE
-Keywords: assembly,clang,codegen,compiler,disassembly,gcc
+Keywords: arm,assembly,cfg,clang,cli,codegen,compiler,devtools,diff,disassembly,dsp,embedded,firmware,gcc,loop-analysis,riscv,static-analysis,xtensa
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
@@ -19,7 +19,12 @@ Description-Content-Type: text/markdown
 # asmdiff 
 ## per-function assembly comparison for paired C implementations
 
-> asmdiff is a command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for investigating compiler code generation rather than benchmarking runtime performance.
+> asmdiff is a stdlib only command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for investigating compiler code generation rather than benchmarking runtime performance.
+
+### Try it yourself:
+
+`$ uvx asmdiff` / `$ pipx asmdiff`
+--- 
 
 `asmdiff.py` answers one question fast: **when I rewrite a C construct, what
 does the compiler actually emit - before and after?** It compiles a small
@@ -28,12 +33,9 @@ assembly, and prints side-by-side listings plus a summary of instruction
 counts, outbound calls, and loop spans.
 
 Compilers and flags are configured per project through named targets in an
-`asmdiff.toml` file — the tool itself has no project-specific defaults and
-parses any GNU-as ELF assembly.
+`asmdiff.toml` file  and parses any GNU-as ELF assembly.
   
-Its home use case: checking whether an expression that used to constant-fold
-(e.g. `x * exp2f(5)` → one multiply) turns into a library call (e.g.
-`ldexpf(x, 5)` → `jmp ldexpf@PLT`) after a "cleanup". That distinction is
+Whether something constant folds or turns into a libcall is a distinction that is
 invisible in source review and decisive on hot paths.
 
 ## Quick start

{asmdiff-0.1.0 → asmdiff-0.1.1}/README.md

@@ -1,7 +1,12 @@
 # asmdiff 
 ## per-function assembly comparison for paired C implementations
 
-> asmdiff is a command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for investigating compiler code generation rather than benchmarking runtime performance.
+> asmdiff is a stdlib only command-line tool for comparing the generated assembly of individual C functions across implementations, compiler flags, compiler versions, and source revisions. It is intended for investigating compiler code generation rather than benchmarking runtime performance.
+
+### Try it yourself:
+
+`$ uvx asmdiff` / `$ pipx asmdiff`
+--- 
 
 `asmdiff.py` answers one question fast: **when I rewrite a C construct, what
 does the compiler actually emit - before and after?** It compiles a small
@@ -10,12 +15,9 @@ assembly, and prints side-by-side listings plus a summary of instruction
 counts, outbound calls, and loop spans.
 
 Compilers and flags are configured per project through named targets in an
-`asmdiff.toml` file — the tool itself has no project-specific defaults and
-parses any GNU-as ELF assembly.
+`asmdiff.toml` file  and parses any GNU-as ELF assembly.
   
-Its home use case: checking whether an expression that used to constant-fold
-(e.g. `x * exp2f(5)` → one multiply) turns into a library call (e.g.
-`ldexpf(x, 5)` → `jmp ldexpf@PLT`) after a "cleanup". That distinction is
+Whether something constant folds or turns into a libcall is a distinction that is
 invisible in source review and decisive on hot paths.
 
 ## Quick start

{asmdiff-0.1.0 → asmdiff-0.1.1}/asmdiff.py

@@ -60,6 +60,15 @@ NOISE = re.compile(
 )
 # Compiler-generated bracketing labels that add nothing (.LFB0:, .Lfunc_end0:).
 NOISE_LABEL = re.compile(r"^\.(LFB|LFE|Lfunc_begin|Lfunc_end)\d*:")
+# Data emitted *inside* a function body: switch jump tables (.long/.word
+# entries), inline constants, strings.  These are not instructions, so they
+# must not be counted; and a self-relative table entry (".long .L5-.L4")
+# references its base label from below, which the loop-span scan would
+# otherwise read as a backward branch and report as a phantom loop.
+DATA = re.compile(
+    r"^\.(long|quad|word|hword|short|byte|[248]byte|value|zero|octa|"
+    r"string|ascii|asciz|single|double|float|dc(\.[abwlq])?)\b"
+)
 
 
 def extract_functions(asm_text):
@@ -67,9 +76,10 @@ def extract_functions(asm_text):
 
     A function body runs from its column-0 label to the matching .size
     directive (gcc and clang both emit one on ELF) or the next function
-    label.  Comment lines, CFI/section/alignment directives, and
-    compiler bracketing labels are dropped; instructions and meaningful
-    local labels (loop targets) are kept, whitespace-stripped.
+    label.  Comment lines, CFI/section/alignment directives, compiler
+    bracketing labels, and inline data (switch jump tables, constants) are
+    dropped; instructions and meaningful local labels (loop targets) are
+    kept, whitespace-stripped.
     """
     funcs = {}
     current = None
@@ -87,7 +97,7 @@ def extract_functions(asm_text):
         line = raw.strip()
         if not line or line.startswith(("#", "//")):
             continue
-        if NOISE.match(line) or NOISE_LABEL.match(line):
+        if NOISE.match(line) or NOISE_LABEL.match(line) or DATA.match(line):
             continue
         funcs[current].append(line)
     return funcs

{asmdiff-0.1.0 → asmdiff-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "asmdiff"
-version = "0.1.0"
+version = "0.1.1"
 description = "Compare per-function assembly between paired C implementations"
 readme = "README.md"
 license = "MIT"
@@ -13,7 +13,11 @@ requires-python = ">=3.8"
 authors = [
     { name = "Rasmus Tikkanen" },
 ]
-keywords = ["assembly", "compiler", "gcc", "clang", "codegen", "disassembly"]
+keywords = [
+    "assembly", "compiler", "gcc", "clang", "disassembly", "codegen",
+    "diff", "static-analysis", "embedded", "firmware", "dsp", 
+    "xtensa", "arm", "riscv", "cli", "devtools", "loop-analysis", "cfg"
+]
 classifiers = [
     "Environment :: Console",
     "Intended Audience :: Developers",

{asmdiff-0.1.0 → asmdiff-0.1.1}/test_asmdiff.py

@@ -74,6 +74,77 @@ looper:
 \t.size\tlooper, .-looper
 """
 
+# A switch lowered to a jump table, faithful to `gcc -O2 -S`.  The table is
+# emitted *inside* the function body (between the label and `.size`) via a
+# .rodata/.text toggle, with self-relative entries `.long .Lx-.L4` — data,
+# not instructions, and their .L4 operand must not read as a backward branch.
+SWITCH_ASM = """\
+\t.globl\tsel
+\t.type\tsel, @function
+sel:
+.LFB0:
+\t.cfi_startproc
+\tendbr64
+\tcmpl\t$4, %edi
+\tja\t.L9
+\tleaq\t.L4(%rip), %rcx
+\tmovl\t%edi, %edi
+\tmovslq\t(%rcx,%rdi,4), %rax
+\taddq\t%rcx, %rax
+\tnotrack jmp\t*%rax
+\t.section\t.rodata
+\t.align 4
+.L4:
+\t.long\t.L8-.L4
+\t.long\t.L7-.L4
+\t.long\t.L6-.L4
+\t.long\t.L5-.L4
+\t.long\t.L3-.L4
+\t.text
+\t.p2align 4,,10
+.L5:
+\tmovl\t%esi, %eax
+\txorl\t%edx, %eax
+\tret
+.L3:
+\tmovl\t%esi, %eax
+\torl\t%edx, %eax
+\tret
+.L8:
+\tleal\t(%rsi,%rdx), %eax
+\tret
+.L7:
+\tmovl\t%esi, %eax
+\tsubl\t%edx, %eax
+\tret
+.L6:
+\tmovl\t%esi, %eax
+\timull\t%edx, %eax
+\tret
+\t.cfi_endproc
+\t.size\tsel, .-sel
+"""
+
+# Jump tables on other targets use plain (non-self-relative) label entries,
+# plus stray inline constants; all are data directives, none are branches.
+DATA_DIRECTIVES_ASM = """\
+\t.type\ttbl, @function
+tbl:
+\t.cfi_startproc
+\tjx\ta8
+.Ltab:
+\t.word\t.La
+\t.word\t.Lb
+\t.byte\t3
+\t.quad\t0
+.La:
+\tadd.n\ta2, a2, a2
+\tretw.n
+.Lb:
+\tretw.n
+\t.size\ttbl, .-tbl
+"""
+
 
 class TestExtractFunctions(unittest.TestCase):
     def test_gcc_functions_found(self):
@@ -173,6 +244,37 @@ class TestLoopSpans(unittest.TestCase):
         self.assertEqual(asmdiff.loop_spans(lines), [])
 
 
+class TestJumpTableData(unittest.TestCase):
+    """Inline data (switch jump tables, constants) emitted inside a function
+    body is not counted as instructions and never reads as a loop span."""
+
+    def test_table_entries_stripped_from_body(self):
+        body = asmdiff.extract_functions(SWITCH_ASM)["sel"]
+        self.assertFalse(any(".long" in line for line in body))
+        self.assertIn(".L4:", body)  # the table's anchor label is kept
+
+    def test_table_entries_not_counted_as_instructions(self):
+        body = asmdiff.extract_functions(SWITCH_ASM)["sel"]
+        insns, calls = asmdiff.analyze(body)
+        self.assertEqual(insns, 22)   # 27 before the fix (5 .long entries)
+        self.assertEqual(calls, [])   # notrack jmp *%rax is not a call
+
+    def test_self_relative_table_is_not_a_phantom_span(self):
+        # `.long .L5-.L4` references the table base .L4 from below; without
+        # stripping, that reads as a backward branch and invents a loop.
+        body = asmdiff.extract_functions(SWITCH_ASM)["sel"]
+        self.assertEqual(asmdiff.loop_spans(body), [])
+
+    def test_various_data_directives_stripped(self):
+        # .word/.byte/.quad jump tables and constants on other targets.
+        body = asmdiff.extract_functions(DATA_DIRECTIVES_ASM)["tbl"]
+        for directive in (".word", ".byte", ".quad"):
+            self.assertFalse(any(directive in line for line in body), directive)
+        insns, _ = asmdiff.analyze(body)
+        self.assertEqual(insns, 4)    # 8 before the fix (4 data entries)
+        self.assertEqual(asmdiff.loop_spans(body), [])
+
+
 class TestAutoPairs(unittest.TestCase):
     def test_pairs_by_convention(self):
         names = ["old_const", "new_const", "old_rt", "new_rt", "helper"]

asmdiff-0.1.0/.claude/settings.local.json

@@ -1,8 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Read(//home/fatta/esp-idf/amy/tools/**)",
-      "Read(//home/fatta/esp-idf/amy/**)"
-    ]
-  }
-}