asmdiff 0.4.0__tar.gz → 0.4.1__tar.gz

asmdiff-0.4.0/README.md → asmdiff-0.4.1/PKG-INFO

@@ -1,3 +1,21 @@
+Metadata-Version: 2.5
+Name: asmdiff
+Version: 0.4.1
+Summary: Per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
+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: arm,assembly,cfg,clang,cli,codegen,compiler,devtools,diff,disassembly,dsp,embedded,firmware,gcc,loop-analysis,objdump,riscv,static-analysis,xtensa
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Debuggers
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
 # [asmdiff](https://pypi.org/project/asmdiff/) 
 ## per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
 
@@ -321,11 +339,11 @@ everywhere else; two things are ELF-specific:
   targets, not labels, so in-function targets are rewritten to
   `.L<hex-offset>` labels (the offset from the function start - stable
   across rebuilds of an unchanged function, unlike link addresses). An
-  Xtensa zero-overhead loop's end address becomes `.L<off>_LEND`, so a
-  hardware loop is distinguishable from a branch loop in the `loop
-  spans` column at a glance: `render_lut` shipped its 32-instruction
-  body as a ZOL, `render_lut_cub` fell back to a 74-instruction
-  branch loop.
+  Xtensa zero-overhead loop's end address (a pi32v2 `rep` block's too)
+  becomes `.L<off>_LEND`, so a hardware loop is distinguishable from a
+  branch loop in the `loop spans` column at a glance: `render_lut`
+  shipped its 32-instruction body as a ZOL, `render_lut_cub` fell back
+  to a 74-instruction branch loop.
 - **`-mlongcalls` calls are resolved.** An out-of-range call survives
   linking as `l32r a8, <lit>` + `callx8 a8`, which has no callee name
   of its own. When the disassembly annotates the literal with its
@@ -397,6 +415,22 @@ cue to pass a matching target.
 A whole firmware has over a thousand functions, so a bare ELF with no
 function names and no `--filter` is an error, not a thousand-row table.
 
+**Other toolchains.** Besides GNU objdump output, the JieLi pi32v2
+objdump's dialect is read (the AC79 family, e.g. the M-VAVE FM-1 and
+its open firmwares): bare `name:` headers, the space-padded byte column,
+`<sym+0x96 : addr >` targets and the decimal displacement before
+`call`/`goto` are normalised into the GNU shape, `.rodata` dumps are
+skipped, and the algebraic instruction form (`r5_r4 = r4 * r14 (s)`,
+`[r6+0] += r4`) is bucketed by shape for `--span-stats`. The
+toolchain's objdump sits beside its clang, so the bundled `pi32v2`
+profile (or any `--cc` naming that clang by path) derives it; otherwise
+pass `--objdump`. Compile mode works with
+`--cc '$JIELI_TOOLCHAIN/pi32v2/bin/clang -target pi32v2 -Os'`. The
+compiler does not emit the `rep` hardware loop from C, but vendor inline
+asm uses it (`rep n rN { ... }`); a `rep` block gets a span over its
+body, named `.L<off>_LEND` in ELF input like an Xtensa zero-overhead
+loop.
+
 If the question behind the sweep is "did my hot loops ship as
 zero-overhead loops", the empirical rules (verified on esp-gcc 15.2,
 `-O2`) are worth knowing before blaming the compiler:
@@ -1400,6 +1434,9 @@ names its *end* label, forward:
     retw.n
 ```
 
+pi32v2's `rep` hardware loop (`rep .Ltmp8 r7` in `-S` output, `rep 6 r7 {`
+in objdump) is the same case, with its body ending at the named label.
+
 That is the entire mechanism. There is no CFG, no trip count, and no
 notion of "the" loop: a backward `goto` produces a span exactly like a
 `for` loop, and an unrolled loop's span is the unrolled body. The column

asmdiff-0.4.0/PKG-INFO → asmdiff-0.4.1/README.md

@@ -1,21 +1,3 @@
-Metadata-Version: 2.5
-Name: asmdiff
-Version: 0.4.0
-Summary: Per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
-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: arm,assembly,cfg,clang,cli,codegen,compiler,devtools,diff,disassembly,dsp,embedded,firmware,gcc,loop-analysis,objdump,riscv,static-analysis,xtensa
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Software Development :: Compilers
-Classifier: Topic :: Software Development :: Debuggers
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
 # [asmdiff](https://pypi.org/project/asmdiff/) 
 ## per-function assembly inspection and comparison, across a compiler matrix or from a shipped ELF
 
@@ -339,11 +321,11 @@ everywhere else; two things are ELF-specific:
   targets, not labels, so in-function targets are rewritten to
   `.L<hex-offset>` labels (the offset from the function start - stable
   across rebuilds of an unchanged function, unlike link addresses). An
-  Xtensa zero-overhead loop's end address becomes `.L<off>_LEND`, so a
-  hardware loop is distinguishable from a branch loop in the `loop
-  spans` column at a glance: `render_lut` shipped its 32-instruction
-  body as a ZOL, `render_lut_cub` fell back to a 74-instruction
-  branch loop.
+  Xtensa zero-overhead loop's end address (a pi32v2 `rep` block's too)
+  becomes `.L<off>_LEND`, so a hardware loop is distinguishable from a
+  branch loop in the `loop spans` column at a glance: `render_lut`
+  shipped its 32-instruction body as a ZOL, `render_lut_cub` fell back
+  to a 74-instruction branch loop.
 - **`-mlongcalls` calls are resolved.** An out-of-range call survives
   linking as `l32r a8, <lit>` + `callx8 a8`, which has no callee name
   of its own. When the disassembly annotates the literal with its
@@ -415,6 +397,22 @@ cue to pass a matching target.
 A whole firmware has over a thousand functions, so a bare ELF with no
 function names and no `--filter` is an error, not a thousand-row table.
 
+**Other toolchains.** Besides GNU objdump output, the JieLi pi32v2
+objdump's dialect is read (the AC79 family, e.g. the M-VAVE FM-1 and
+its open firmwares): bare `name:` headers, the space-padded byte column,
+`<sym+0x96 : addr >` targets and the decimal displacement before
+`call`/`goto` are normalised into the GNU shape, `.rodata` dumps are
+skipped, and the algebraic instruction form (`r5_r4 = r4 * r14 (s)`,
+`[r6+0] += r4`) is bucketed by shape for `--span-stats`. The
+toolchain's objdump sits beside its clang, so the bundled `pi32v2`
+profile (or any `--cc` naming that clang by path) derives it; otherwise
+pass `--objdump`. Compile mode works with
+`--cc '$JIELI_TOOLCHAIN/pi32v2/bin/clang -target pi32v2 -Os'`. The
+compiler does not emit the `rep` hardware loop from C, but vendor inline
+asm uses it (`rep n rN { ... }`); a `rep` block gets a span over its
+body, named `.L<off>_LEND` in ELF input like an Xtensa zero-overhead
+loop.
+
 If the question behind the sweep is "did my hot loops ship as
 zero-overhead loops", the empirical rules (verified on esp-gcc 15.2,
 `-O2`) are worth knowing before blaming the compiler:
@@ -1418,6 +1416,9 @@ names its *end* label, forward:
     retw.n
 ```
 
+pi32v2's `rep` hardware loop (`rep .Ltmp8 r7` in `-S` output, `rep 6 r7 {`
+in objdump) is the same case, with its body ending at the named label.
+
 That is the entire mechanism. There is no CFG, no trip count, and no
 notion of "the" loop: a backward `goto` produces a span exactly like a
 `for` loop, and an unrolled loop's span is the unrolled body. The column

{asmdiff-0.4.0 → asmdiff-0.4.1}/asmdiff.example.toml

@@ -143,3 +143,12 @@ flags = ["-O2", "-mcpu=cortex-m4", "-mthumb"]
 [rp2350]
 cc = "riscv64-unknown-elf-gcc"
 flags = ["-O2", "-march=rv32imac_zicsr_zifencei", "-mabi=ilp32"]
+
+# JieLi pi32v2 (the AC79 family: M-VAVE FM-1 and other JieLi-based
+# devices).  The vendor's clang 4.0.1 fork comes as one tarball from
+# pkgman.jieliapp.com/s/linux-toolchain; unpack it anywhere and point
+# JIELI_TOOLCHAIN at the directory holding pi32v2/ and common/.  Its
+# objdump sits beside clang, so ELF input needs no --objdump.
+[pi32v2]
+cc = "$JIELI_TOOLCHAIN/pi32v2/bin/clang"
+flags = ["-target", "pi32v2", "-Os"]

{asmdiff-0.4.0 → asmdiff-0.4.1}/asmdiff.py

@@ -46,8 +46,10 @@ Four modes, plus the no-flag whole-file summary:
                   listed in full; --filter matches are summarized
                   only, unless -l list asks for their listings too.
                   objdump comes from
-                  --objdump PATH or the first gcc in the matrix
-                  (trailing gcc swapped for objdump); Xtensa
+                  --objdump PATH, the first gcc in the matrix
+                  (trailing gcc swapped for objdump), or an objdump
+                  beside a clang given by path.  GNU and JieLi
+                  pi32v2 objdump output are both read; Xtensa
                   -mlongcalls call sequences are resolved to their
                   real callees when the disassembly names them,
                   and report as indirect(<reg>) when it does not.
@@ -173,7 +175,7 @@ except ModuleNotFoundError:
 
 # Single source of truth for the package version: pyproject.toml reads
 # it from here (hatchling dynamic version).
-__version__ = "0.4.0"
+__version__ = "0.4.1"
 
 DEFAULT_COMPILERS = ["gcc", "clang"]
 FALLBACK_FLAGS = "-O3"
@@ -330,6 +332,15 @@ flags = ["-O2", "-mcpu=cortex-m4", "-mthumb"]
 [rp2350]
 cc = "riscv64-unknown-elf-gcc"
 flags = ["-O2", "-march=rv32imac_zicsr_zifencei", "-mabi=ilp32"]
+
+# JieLi pi32v2 (the AC79 family: M-VAVE FM-1 and other JieLi-based
+# devices).  The vendor's clang 4.0.1 fork comes as one tarball from
+# pkgman.jieliapp.com/s/linux-toolchain; unpack it anywhere and point
+# JIELI_TOOLCHAIN at the directory holding pi32v2/ and common/.  Its
+# objdump sits beside clang, so ELF input needs no --objdump.
+[pi32v2]
+cc = "$JIELI_TOOLCHAIN/pi32v2/bin/clang"
+flags = ["-target", "pi32v2", "-Os"]
 """
 
 # Preprocessor flags lifted from a compile_commands.json entry so a project
@@ -669,6 +680,10 @@ 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*:")
+# clang annotates local labels in the target's comment syntax
+# (".LBB2_1:   ; =>This Inner Loop Header: Depth=1" - '#' on x86, '@' on
+# ARM, ';' on pi32v2); the loop-span scan keys on lines ending in ':'.
+LABEL_COMMENT = re.compile(r"^(\.?[\w$.]+:)\s*(?:;|#|@|//).*$")
 # 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")
@@ -714,29 +729,59 @@ def extract_functions(asm_text):
             current = None
             continue
         line = raw.strip()
-        if not line or line.startswith(("#", "//")):
+        if not line or line.startswith(("#", "//", ";", "@")):
             continue
         if NOISE.match(line) or NOISE_LABEL.match(line) or DATA.match(line):
             continue
+        line = LABEL_COMMENT.sub(r"\1", line)
+        if line == "}":                     # pi32v2 predicated-block close
+            continue
+        if line == "dummy":                 # pi32v2 rep-end filler, no bytes
+            continue
         funcs[current].append(line)
     return funcs
 
 
 # `objdump -d` function header: "40370400 <render_lut>:".
 OBJDUMP_HEADER = re.compile(r"^([0-9a-f]+) <([^>]+)>:\s*$")
+# JieLi's pi32v2 objdump writes the header as a bare label ("rev_hall:");
+# the function's address is its first instruction's.
+OBJDUMP_BARE_HEADER = re.compile(r"^([A-Za-z_][\w$.]*):\s*$")
 # `objdump -d` instruction line: address, one byte-dump field (hex digits
-# and spaces; "004136" is the encoding, not the mnemonic), then the
-# mnemonic and operands.
+# and spaces; "004136" is the encoding, not the mnemonic), a tab, then
+# the mnemonic and operands.  GNU separates the fields with tabs; JieLi's
+# pads the byte field with spaces before the tab.  A data line (JieLi's
+# objdump dumps .rodata too) ends in an ASCII column with no tab after
+# the bytes, so it does not match.
 OBJDUMP_INSN = re.compile(
-    r"^\s*([0-9a-f]+):\t[0-9a-f ]+\t\s*(\S+)[ \t]*(.*?)\s*$")
+    r"^\s*([0-9a-f]+):\s*[0-9a-f][0-9a-f ]*\t\s*(\S+)[ \t]*(.*?)\s*$")
+# Section banner; data sections are skipped (GNU -d never prints them,
+# JieLi's does, as bare-label symbols over byte dumps).
+OBJDUMP_SECTION = re.compile(r"^Disassembly of section (\S+):")
 # An "addr <annotation>" operand: branch, loop or call target.
 OBJDUMP_TARGET = re.compile(r"\b([0-9a-f]+) <([^>]+)>")
+# pi32v2 hardware loop as objdump prints it: "rep 6 r7 {" or
+# "rep 20 16 {" - the body length in bytes (decimal), then the repeat
+# count (register or immediate).  The body starts at the next
+# instruction; the closing "}" line has no address and is ignored.
+OBJDUMP_REP = re.compile(r"^(\d+)\s+(\S+)\s*\{?$")
+# JieLi's objdump annotates a target as "<sym+0x96 : 2039318 >" (GNU:
+# "2039318 <sym+0x96>") and puts the decimal displacement before it
+# ("call 762 <fm1_fatal_common : 2000458 >", "goto -26 <...>").  Both are
+# rewritten to the GNU shape so the relabel and call detection apply.
+JIELI_TARGET = re.compile(r"<\s*([^<>:]+?)\s*:\s*([0-9a-f]+)\s*>")
+JIELI_DISP = re.compile(r"(^|goto |call )(-?\d+)\s+(?=[0-9a-f]+ <)")
+
+
+def _normalize_targets(ops):
+    ops = JIELI_TARGET.sub(r"\2 <\1>", ops)
+    return JIELI_DISP.sub(r"\1", ops)
 # A nearest-symbol offset annotation ("<_etext+0x100>"): objdump's name
 # for an address that is not a symbol start.  For addresses outside the
 # current function the base symbol is usually unrelated (a literal-pool
 # word or data landing after some other object), so the annotation is
 # misleading, not informative.
-OFFSET_ANNOT = re.compile(r"[+-]0x[0-9a-f]+$")
+OFFSET_ANNOT = re.compile(r"[+-]0x[0-9a-f]+$", re.IGNORECASE)
 
 
 def extract_functions_objdump(dump_text):
@@ -749,8 +794,11 @@ def extract_functions_objdump(dump_text):
     synthetic local labels (.L<hex-offset>) inserted at the target
     instruction; an Xtensa zero-overhead loop's end address becomes
     .L<off>_LEND, keeping the ZOL-vs-branch naming convention -S output
-    has.  Targets outside the function keep a bare-symbol annotation,
-    so calls still name their callee; offset-form annotations of other
+    has.  A pi32v2 "rep <bytes> <count> {" block is rewritten to the
+    shape its -S output has ("rep .L<off>_LEND <count>"), with the
+    label at the address the body ends on.  Targets outside the
+    function keep a bare-symbol annotation, so calls still name their
+    callee; offset-form annotations of other
     symbols are nearest-symbol noise and become raw hex addresses (see
     _relabel_objdump).  Offset-form headers
     (``<sym+0x..>``/``<sym-0x..>``: literal pools and other symbol-less
@@ -758,23 +806,43 @@ def extract_functions_objdump(dump_text):
     """
     funcs = {}
     current = None
+    in_code = True
     for raw in dump_text.splitlines():
+        s = OBJDUMP_SECTION.match(raw)
+        if s:
+            in_code = not s.group(1).startswith((".rodata", ".data", ".bss"))
+            current = None
+            continue
+        if not in_code:
+            continue
         h = OBJDUMP_HEADER.match(raw)
         if h:
-            name = h.group(2)
+            name, start = h.group(2), int(h.group(1), 16)
+        else:
+            h = OBJDUMP_BARE_HEADER.match(raw)
+            if h:
+                name, start = h.group(1), None
+        if h:
             if OFFSET_ANNOT.search(name):
                 current = None          # symbol-less gap, not a function
             else:
                 current = []
-                funcs[name] = (int(h.group(1), 16), current)
+                funcs[name] = (start, current)
             continue
         if current is None:
             continue
         m = OBJDUMP_INSN.match(raw)
         if m:
-            current.append((int(m.group(1), 16), m.group(2), m.group(3)))
-    return {name: _relabel_objdump(name, start, _resolve_longcalls(insns))
-            for name, (start, insns) in funcs.items()}
+            current.append((int(m.group(1), 16), m.group(2),
+                            _normalize_targets(m.group(3))))
+    out = {}
+    for name, (start, insns) in funcs.items():
+        if start is None:
+            if not insns:
+                continue                # bare-label data symbol in a code section
+            start = insns[0][0]
+        out[name] = _relabel_objdump(name, start, _resolve_longcalls(insns))
+    return out
 
 
 # The value annotation objdump appends to an l32r whose literal resolves
@@ -833,7 +901,14 @@ def _relabel_objdump(name, start, insns):
     rendered as the raw hex address instead."""
     addrs = {addr for addr, _, _ in insns}
     labels = {}
-    for _, mnem, ops in insns:
+    reps = {}                               # rep addr -> (end addr, count)
+    for k, (addr, mnem, ops) in enumerate(insns):
+        r = OBJDUMP_REP.match(ops) if mnem == "rep" else None
+        if r and k + 1 < len(insns):
+            end = insns[k + 1][0] + int(r.group(1))
+            if end in addrs:
+                reps[addr] = (end, r.group(2))
+                labels[end] = ".L%x_LEND" % (end - start)
         for m in OBJDUMP_TARGET.finditer(ops):
             taddr = int(m.group(1), 16)
             if taddr not in addrs:
@@ -856,7 +931,10 @@ def _relabel_objdump(name, start, insns):
     for addr, mnem, ops in insns:
         if addr in labels:
             lines.append(labels[addr] + ":")
-        ops = OBJDUMP_TARGET.sub(target_name, ops)
+        if addr in reps:
+            ops = "%s %s" % (labels[reps[addr][0]], reps[addr][1])
+        else:
+            ops = OBJDUMP_TARGET.sub(target_name, ops)
         lines.append(mnem + "\t" + ops if ops else mnem)
     return lines
 
@@ -944,8 +1022,9 @@ def loop_span_ranges(lines):
     A span is the run of instructions from a local label to the last
     instruction that references it from below — a backward branch, which
     is what a compiled loop looks like on every target the tool parses.
-    Xtensa zero-overhead loops (loop/loopnez/loopgt) reference their END
-    label instead; there the span is the instructions the loop encloses.
+    Xtensa zero-overhead loops (loop/loopnez/loopgt) and pi32v2's rep
+    reference their END label instead; there the span is the
+    instructions the loop encloses.
     Spans are reported in order of appearance, one per label; nested
     labels yield nested spans.
     """
@@ -962,8 +1041,8 @@ def loop_span_ranges(lines):
             j = label_at[ref]
             if j < i:                       # label above: backward branch
                 lo, hi = j, i
-            elif mnem.startswith("loop"):   # Xtensa: end label below
-                lo, hi = i + 1, j - 1
+            elif mnem.startswith("loop") or mnem == "rep":
+                lo, hi = i + 1, j - 1       # Xtensa/pi32v2: end label below
             else:
                 continue
             if ref in spans:                # several edges to one label
@@ -1051,6 +1130,33 @@ _BRANCH_MNEMONICS = frozenset("""
 """.split())
 
 
+# pi32v2 (JieLi) assembly is algebraic: "r4 = h[r3++=2] (s)", "[r6+0] += r4",
+# "r5_r4 = r4 * r14 (s)", "if (--r2 != 0) goto .L1".  No mnemonic table
+# fits, so the shape of the line picks the bucket: memory on the left of
+# the assignment is a store (push and read-modify-write included), on
+# the right a load (pop included), a product or quotient on the right is
+# mul or div, and the if/goto/return forms are branches.
+_ALGEBRAIC = re.compile(
+    r"^(?:[hbwd]?\[|\{|(?:r\d+(?:_r\d+)?(?:\.[lh])?|sp|psr|icfg)\s*[-+*/|&^<>]*="
+    r"|(?:ifs?|goto|rts|ret[iex]|rets|rep)\b)")
+_ALGEBRAIC_BRANCH = frozenset("if ifs goto rts reti rete retx rets rep".split())
+
+
+def _classify_algebraic(line, mnem):
+    if mnem in _ALGEBRAIC_BRANCH:
+        return "branch"
+    lhs, _, rhs = line.partition("=")
+    if "[" in lhs:
+        return "store"
+    if "[" in rhs:
+        return "load"
+    if "*" in rhs:
+        return "mul"
+    if "/" in rhs:
+        return "div"
+    return "other"
+
+
 def classify_insn(line):
     """Bucket one cleaned instruction: load/store/mul/div/branch/other.
 
@@ -1059,11 +1165,14 @@ def classify_insn(line):
     mnemonics no table knows, an AT&T-style memory operand decides
     load (source side) vs store (destination, the last operand);
     lea and alignment nops are excluded from that heuristic first.
+    pi32v2's algebraic lines are bucketed by shape (_classify_algebraic).
     """
     parts = line.split(None, 1)
     mnem = parts[0].lower()
     rest = parts[1] if len(parts) > 1 else ""
     base = mnem.split(".", 1)[0]
+    if _ALGEBRAIC.match(line):
+        return _classify_algebraic(line, mnem)
     if mnem in _LOAD_MNEMONICS or base in _LOAD_MNEMONICS:
         return "load"
     if mnem in _STORE_MNEMONICS or base in _STORE_MNEMONICS:
@@ -2945,12 +3054,18 @@ def run_inspect(source, matrix, fn_names, layout, extra_flags, tmp,
 def derive_objdump(matrix):
     """Objdump belonging to the first gcc in the matrix: the toolchain
     prefix stays, the tool name swaps (xtensa-esp32s3-elf-gcc ->
-    xtensa-esp32s3-elf-objdump).  None when no entry is gcc-based;
-    clang has no paired cross-objdump to guess at."""
+    xtensa-esp32s3-elf-objdump).  A clang given by path counts when an
+    objdump sits beside it in the same bin directory (JieLi's pi32v2
+    toolchain ships one there).  None otherwise: a bare clang has no
+    paired cross-objdump to guess at."""
     for cc_cmd in matrix:
         cc = shlex.split(cc_cmd)[0]
         if cc == "gcc" or cc.endswith(("-gcc", "/gcc")):
             return cc[:-3] + "objdump"
+        if cc.endswith("/clang"):
+            sibling = cc[:-5] + "objdump"
+            if os.path.exists(sibling):
+                return sibling
     return None
 
 
@@ -3481,7 +3596,8 @@ def main(argv=None):
     parser.add_argument("--objdump", metavar="PATH",
                         help="disassembler for ELF input; default: derived "
                              "from the first gcc in the matrix by swapping "
-                             "the trailing gcc for objdump")
+                             "the trailing gcc for objdump, or an objdump "
+                             "beside a clang given by path")
     parser.add_argument("-t", "--target", action="append", default=[],
                         metavar="NAME",
                         help="named [table], [groups] name, comma-list, or "

{asmdiff-0.4.0 → asmdiff-0.4.1}/test_asmdiff.py

@@ -1006,6 +1006,10 @@ class TestTargetGroups(unittest.TestCase):
     def test_expansion_errors(self):
         for case, config, tokens, present, absent in self.EXPANSION_ERRORS:
             with self.subTest(case=case):
+                # The example-config pointer needs tomllib to read the
+                # example; without it the pointer is omitted (_example_names).
+                if case.startswith("example ") and asmdiff.tomllib is None:
+                    self.skipTest("tomllib requires Python >= 3.11")
                 with self.assertRaises(SystemExit) as ctx:
                     self.expand(*tokens, config=config)
                 msg = str(ctx.exception)
@@ -3780,5 +3784,390 @@ class TestGolden(unittest.TestCase):
                               + diff)
 
 
+
+# JieLi pi32v2 clang -S output: algebraic assembly, ';' comments, labels
+# annotated with a trailing comment, a predicated block closed by '}'.
+PI32V2_S = """\
+\t.section\t.text.dot16,"ax",@progbits
+\t.globl\tdot16
+\t.type\tdot16,@function
+dot16:                                  ; @dot16
+; BB#0:
+\t[--sp] = {rets, r5, r4}
+\tr3 = r0
+\tr0 = 0
+\tifs (r2 < 1) goto .LBB2_2
+.LBB2_1:                                ; =>This Inner Loop Header: Depth=1
+\tr4 = h[r3++=2] (s)
+\tr5 = h[r1++=2] (s)
+\tr4 *= r5
+\tr0 += r4
+\tif (--r2 != 0) goto .LBB2_1
+.LBB2_2:
+\t{pc, r5, r4} = [sp++]
+.Lfunc_end2:
+\t.size\tdot16, .Lfunc_end2-dot16
+\t.section\t.text.add16_sat,"ax",@progbits
+\t.globl\tadd16_sat
+\t.type\tadd16_sat,@function
+add16_sat:                              ; @add16_sat
+; BB#0:
+\tr3 = -32768
+.LBB0_2:                                ; =>This Inner Loop Header: Depth=1
+\tr5 += r4
+\tr4 = 32767
+\tifs (r5 < 32768) {
+\t\tr4 = smax(r5, r3)
+\t}
+\th[r0++=2] = r4
+\tif (--r2 != 0) goto .LBB0_2
+\t{pc, r5, r4} = [sp++]
+.Lfunc_end0:
+\t.size\tadd16_sat, .Lfunc_end0-add16_sat
+"""
+
+# JieLi pi32v2 `objdump -d`: bare-label headers, space-padded byte column,
+# "<sym : addr >" targets with a decimal displacement before them, and a
+# .rodata section dumped as a symbol over byte lines.
+PI32V2_OBJDUMP = """\
+
+build/felucca.elf:\tfile format ELF32-pi32v2
+
+Disassembly of section .text:
+_start:
+ 2000120:    04 81             \tgoto 2 <_start+0x4 : 2000124 >
+ 2000122:    80 00             \trts
+ 2000124:    81 ea 12 77       \tcall 192036 <fm1_cstart : 202ef7a >
+ 2000128:    49 e0 fe 07       \tr9 = 2046 <build/felucca_size.ll+0x7FE : 7fe >
+ 200012c:    80 00             \trts
+fm6_op_run:
+ 203916e:    05 90             \tr5 = [r1+r7<<2]
+ 2039170:    44 d1 0d 00       \tr4 = r12 >> 13
+ 2039174:    45 1c             \tr5_r4 = r4 * r14 (s)
+ 2039176:    b0 20             \t[r6+0] += r4
+ 2039178:    87 f8 e5 1f       \tif (r7 != 32) goto -10 <fm6_op_run : 203916e >
+ 203917c:    7f 05             \t{pc, r14-r4} = [sp++]
+Disassembly of section .rodata:
+SINE:
+ 203b5f4:\t 00 00 24 03 48 06 6c 09         ..$.H.l.
+ 203b5fc:\t 90 0c b3 0f d6 12 f8 15         ........
+"""
+
+
+class TestPi32v2(unittest.TestCase):
+    """JieLi pi32v2 dialect: clang -S with ';' comments and annotated
+    labels, the vendor objdump's header, byte-column and target syntax,
+    and shape-based span-stats buckets for algebraic assembly."""
+
+    def test_s_label_comment_stripped_so_span_is_found(self):
+        funcs = asmdiff.extract_functions(PI32V2_S)
+        self.assertEqual(sorted(funcs), ["add16_sat", "dot16"])
+        self.assertIn(".LBB2_1:", funcs["dot16"])
+        self.assertEqual(asmdiff.loop_spans(funcs["dot16"]), [(".LBB2_1", 5)])
+
+    def test_s_comment_lines_and_block_close_not_counted(self):
+        body = asmdiff.extract_functions(PI32V2_S)["add16_sat"]
+        self.assertNotIn("}", body)
+        self.assertFalse(any(ln.startswith(";") for ln in body))
+        self.assertEqual(asmdiff.loop_spans(body), [(".LBB0_2", 6)])
+
+    def test_objdump_bare_headers_and_data_section(self):
+        funcs = asmdiff.extract_functions_objdump(PI32V2_OBJDUMP)
+        self.assertEqual(sorted(funcs), ["_start", "fm6_op_run"])
+
+    def test_objdump_targets_normalized(self):
+        funcs = asmdiff.extract_functions_objdump(PI32V2_OBJDUMP)
+        self.assertIn("goto\t.L4", funcs["_start"])
+        self.assertIn("call\tfm1_cstart", funcs["_start"])
+        # uppercase nearest-symbol offset: noise, rendered as the raw address
+        self.assertIn("r9\t= 2046 0x7fe", funcs["_start"])
+        self.assertEqual(asmdiff.call_symbol("call\tfm1_cstart"), "fm1_cstart")
+        self.assertEqual(asmdiff.loop_spans(funcs["fm6_op_run"]), [(".L0", 5)])
+
+    def test_objdump_insn_lines_cleaned(self):
+        body = asmdiff.extract_functions_objdump(PI32V2_OBJDUMP)["fm6_op_run"]
+        self.assertEqual(body[1], "r5\t= [r1+r7<<2]")
+        for ln in body:
+            self.assertNotRegex(ln, r"^[0-9a-f]+\s")
+
+    def test_algebraic_buckets(self):
+        cases = {"r5\t= [r1+r7<<2]": "load",
+                 "{pc,\tr14-r4} = [sp++]": "load",
+                 "[r6+0]\t+= r4": "store",
+                 "[--sp]\t= {rets, r5, r4}": "store",
+                 "h[r0++=2]\t= r4": "store",
+                 "r5_r4\t= r4 * r14 (s)": "mul",
+                 "r1_r0\t+= r6 * r5 (s)": "mul",
+                 "r2\t= r2 / r3 (s)": "div",
+                 "if\t(r7 != 32) goto .L0": "branch",
+                 "ifs\t(r5 < 32768) {": "branch",
+                 "goto\t.L4": "branch",
+                 "rts": "branch",
+                 "call\t__mulsf3": "branch",
+                 "r4\t= r12 >> 13": "other",
+                 "r4\t= smax(r5, r3)": "other",
+                 "r12\t= r7  #": "other"}
+        for line, want in cases.items():
+            self.assertEqual(asmdiff.classify_insn(line), want, line)
+
+    def test_gnu_buckets_untouched_by_algebraic_rule(self):
+        self.assertEqual(asmdiff.classify_insn("l32i\ta0, a2, 0"), "load")
+        self.assertEqual(asmdiff.classify_insn("movl\t%eax, (%rdi)"), "store")
+
+    def test_objdump_beside_clang_is_derived(self):
+        with tempfile.TemporaryDirectory() as d:
+            binary = Path(d) / "pi32v2" / "bin"
+            binary.mkdir(parents=True)
+            (binary / "clang").write_text("")
+            self.assertIsNone(asmdiff.derive_objdump([str(binary / "clang")]))
+            (binary / "objdump").write_text("")
+            self.assertEqual(asmdiff.derive_objdump([str(binary / "clang") + " -target pi32v2"]),
+                             str(binary / "objdump"))
+
+
+# JieLi pi32v2 `rep` hardware loops (clang 4.0.1 fork, -Os), assembled from
+# inline asm after fast_i2f in JieLi's jl_fft.c: "rep %1 { ... }" with a
+# register count.  rep_two holds two blocks after a plain C loop,
+# rep_nested one inside a C loop.  In -S the block's "}" is an end label
+# followed by a "dummy" placeholder; objdump prints "rep <body bytes> rN {".
+PI32V2_REP_S = """\
+\t.globl\trep_two
+\t.p2align\t1
+\t.type\trep_two,@function
+rep_two:                                ; @rep_two
+; BB#0:
+\t[--sp] = {rets, r8-r4}
+\tr8 = [sp+24]
+\tifs (r3 < 1) goto .LBB0_3
+; BB#1:
+\tr5 = r3
+\tr6 = r2
+\tr7 = r0
+.LBB0_2:                                ; =>This Inner Loop Header: Depth=1
+\tr4 = [r7++=4] 
+\tr4 += 1
+\t[r6++=4] = r4
+\tif (--r5 != 0) goto .LBB0_2
+.LBB0_3:
+\tr5 = r1
+\tr6 = r8
+\tr7 = r3
+\t;APP
+.Ltmp7:
+\trep .Ltmp8 r7
+
+\tr4 = [r0++=4] 
+
+\tr4 = r4 + r6
+
+\t[r5++=4] = r4
+
+.Ltmp8:
+\tdummy
+
+\tif (r7 > 0) goto .Ltmp7
+
+
+\t;NO_APP
+\t;APP
+.Ltmp9:
+\trep .Ltmp10 r3
+
+\tr0 = [r1++=4] 
+
+\tr0 += r8
+
+\tr0 = r0 << 1
+
+\t[r2++=4] = r0
+
+.Ltmp10:
+\tdummy
+
+\tif (r3 > 0) goto .Ltmp9
+
+
+\t;NO_APP
+\t{pc, r8-r4} = [sp++]
+.Lfunc_end0:
+\t.size\trep_two, .Lfunc_end0-rep_two
+
+\t.globl\trep_nested
+\t.p2align\t1
+\t.type\trep_nested,@function
+rep_nested:                             ; @rep_nested
+; BB#0:
+\t[--sp] = {rets, r10-r4}
+\tifs (r3 < 1) goto .LBB1_3
+; BB#1:
+\tr8 = [sp+32]
+\tr9 = r2 << 2
+.LBB1_2:                                ; =>This Inner Loop Header: Depth=1
+\tr10 = r0
+\tr7 = r8
+\tr4 = r2
+\tr5 = r1
+\t;APP
+.Ltmp20:
+\trep .Ltmp21 r4
+
+\tr6 = [r10++=4]
+
+\tr6 = r6 + r7
+
+\t[r5++=4] = r6
+
+.Ltmp21:
+\tdummy
+
+\tif (r4 > 0) goto .Ltmp20
+
+
+\t;NO_APP
+\tr1 += r9
+\tif (--r3 != 0) goto .LBB1_2
+.LBB1_3:
+\t{pc, r10-r4} = [sp++]
+.Lfunc_end1:
+\t.size\trep_nested, .Lfunc_end1-rep_nested
+
+
+"""
+
+PI32V2_REP_OBJDUMP = """\
+
+rep_demo.o:\tfile format ELF32-pi32v2
+
+Disassembly of section .text:
+rep_two:
+       0:    78 04             \t[--sp] = {rets, r8-r4}
+       2:    d4 e9 18 80       \tr8 = [sp+24]
+       6:    83 fd 08 02       \tifs (r3 < 1) goto 16 <rep_two+0x1A : 1a >
+       a:    35 16             \tr5 = r3
+       c:    26 16             \tr6 = r2
+       e:    07 16             \tr7 = r0
+      10:    74 05             \tr4 = [r7++=4] 
+      12:    c4 21             \tr4 += 1
+      14:    e4 05             \t[r6++=4] = r4
+      16:    05 ea fb ff       \tif (--r5 != 0) goto -10 <rep_two+0x10 : 10 >
+      1a:    15 16             \tr5 = r1
+      1c:    86 16             \tr6 = r8
+      1e:    37 16             \tr7 = r3
+      20:    27 03             \trep 6 r7 {
+      22:    04 05             \t\tr4 = [r0++=4] 
+      24:    c4 1d             \t\tr4 = r4 + r6
+      26:    d4 05             \t\t[r5++=4] = r4
+                               \t}
+      28:    07 fc fa 01       \tif (r7 > 0) goto -12 <rep_two+0x20 : 20 >
+      2c:    33 03             \trep 8 r3 {
+      2e:    10 05             \t\tr0 = [r1++=4] 
+      30:    80 18             \t\tr0 += r8
+      32:    00 a1             \t\tr0 = r0 << 1
+      34:    a0 05             \t\t[r2++=4] = r0
+                               \t}
+      36:    03 fc f9 01       \tif (r3 > 0) goto -14 <rep_two+0x2C : 2c >
+      3a:    58 04             \t{pc, r8-r4} = [sp++]
+
+
+rep_nested:
+      3c:    7a 04             \t[--sp] = {rets, r10-r4}
+      3e:    83 fd 12 02       \tifs (r3 < 1) goto 36 <rep_nested+0x2A : 66 >
+      42:    d4 e9 20 80       \tr8 = [sp+32]
+      46:    c0 e1 22 90       \tr9 = r2 << 2
+      4a:    0a 16             \tr10 = r0
+      4c:    87 16             \tr7 = r8
+      4e:    24 16             \tr4 = r2
+      50:    15 16             \tr5 = r1
+      52:    34 03             \trep 8 r4 {
+      54:    d8 ec a4 60       \t\tr6 = [r10++=4]
+      58:    ee 1d             \t\tr6 = r6 + r7
+      5a:    d6 05             \t\t[r5++=4] = r6
+                               \t}
+      5c:    04 fc f9 01       \tif (r4 > 0) goto -14 <rep_nested+0x16 : 52 >
+      60:    91 18             \tr1 += r9
+      62:    03 ea f2 ff       \tif (--r3 != 0) goto -28 <rep_nested+0xE : 4a >
+      66:    5a 04             \t{pc, r10-r4} = [sp++]
+
+"""
+
+# An immediate count ("rep 20 16 {"), from a second probe object.
+PI32V2_REP_IMM_OBJDUMP = """\
+
+imm.o:\tfile format ELF32-pi32v2
+
+Disassembly of section .text:
+rep_imm:
+       0:    90 8f             \trep 20 16 {
+       2:    02 05             \t\tr2 = [r0++=4] 
+       4:    2a 1c             \t\tr2 = r2 + r1
+       6:    22 a1             \t\tr2 = r2 << 1
+       8:    2a 1c             \t\tr2 = r2 + r1
+       a:    2a 1c             \t\tr2 = r2 + r1
+       c:    2a 1c             \t\tr2 = r2 + r1
+       e:    2a 1c             \t\tr2 = r2 + r1
+      10:    2a 1c             \t\tr2 = r2 + r1
+      12:    2a 1c             \t\tr2 = r2 + r1
+      14:    82 05             \t\t[r0++=4] = r2
+                               \t}
+      16:    80 00             \trts
+
+"""
+
+
+class TestPi32v2Rep(unittest.TestCase):
+    """pi32v2 `rep` hardware loops: the span covers the repeated body,
+    in -S output (rep names its end label) and in objdump output (the
+    body length in bytes becomes a .L<off>_LEND label, as for Xtensa)."""
+
+    spans = staticmethod(asmdiff.loop_spans)
+
+    def test_s_rep_span_is_the_body(self):
+        # Same counts as the ELF of this object: the zero-byte "dummy"
+        # clang puts after a rep end label is not an instruction.
+        body = asmdiff.extract_functions(PI32V2_REP_S)["rep_two"]
+        self.assertNotIn("dummy", body)
+        self.assertEqual(self.spans(body),
+                         [(".LBB0_2", 4), (".Ltmp7", 5), (".Ltmp8", 3),
+                          (".Ltmp9", 6), (".Ltmp10", 4)])
+
+    def test_s_rep_inside_c_loop_nests(self):
+        body = asmdiff.extract_functions(PI32V2_REP_S)["rep_nested"]
+        ranges = asmdiff.loop_span_ranges(body)
+        self.assertEqual(self.spans(body),
+                         [(".LBB1_2", 11), (".Ltmp20", 5), (".Ltmp21", 3)])
+        self.assertEqual(asmdiff.span_depths(ranges),
+                         {".LBB1_2": 0, ".Ltmp20": 1, ".Ltmp21": 2})
+
+    def test_objdump_rep_gets_end_label(self):
+        body = asmdiff.extract_functions_objdump(PI32V2_REP_OBJDUMP)["rep_two"]
+        self.assertIn("rep\t.L28_LEND r7", body)
+        self.assertIn("rep\t.L36_LEND r3", body)
+        self.assertNotIn("}", body)
+        self.assertEqual(body[body.index(".L28_LEND:") + 1],
+                         "if\t(r7 > 0) goto .L20")
+
+    def test_objdump_rep_spans(self):
+        funcs = asmdiff.extract_functions_objdump(PI32V2_REP_OBJDUMP)
+        self.assertEqual(self.spans(funcs["rep_two"]),
+                         [(".L10", 4), (".L20", 5), (".L28_LEND", 3),
+                          (".L2c", 6), (".L36_LEND", 4)])
+        self.assertEqual(self.spans(funcs["rep_nested"]),
+                         [(".Le", 11), (".L16", 5), (".L20_LEND", 3)])
+
+    def test_objdump_rep_immediate_count(self):
+        body = asmdiff.extract_functions_objdump(
+            PI32V2_REP_IMM_OBJDUMP)["rep_imm"]
+        self.assertEqual(body[0], "rep\t.L16_LEND 16")
+        self.assertEqual(self.spans(body), [(".L16_LEND", 10)])
+
+    def test_rep_stays_a_branch(self):
+        self.assertEqual(asmdiff.classify_insn("rep\t.L28_LEND r7"), "branch")
+        self.assertEqual(asmdiff.classify_insn("rep\t.Ltmp8 r7"), "branch")
+
+    def test_x86_rep_prefix_makes_no_span(self):
+        self.assertEqual(asmdiff.loop_span_ranges(
+            ["rep movsb", ".L2:", "addl\t$1, %eax"]), [])
+
+
 if __name__ == "__main__":
     unittest.main()