asmdiff 0.1.2__tar.gz → 0.1.3__tar.gz

{asmdiff-0.1.2 → asmdiff-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: asmdiff
-Version: 0.1.2
+Version: 0.1.3
 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
@@ -94,7 +94,7 @@ $ asmdiff.py asmdiff_example.c
 ```
 asmdiff.py SOURCE.c [SOURCE2.c] [--pair OLD:NEW]... [--across FUNC]...
            [--cc 'CC FLAGS']... [--target NAME]... [--config PATH]
-           [--compile-commands [PATH]] [-- EXTRA_FLAGS...]
+           [--compile-commands [PATH]] [-v] [-- EXTRA_FLAGS...]
 ```
 
 | Option | Meaning |
@@ -105,7 +105,8 @@ asmdiff.py SOURCE.c [SOURCE2.c] [--pair OLD:NEW]... [--across FUNC]...
 | `--cc 'CC FLAGS'` | One compiler invocation, command and flags in a single quoted string. Repeatable to build a matrix. |
 | `--target NAME` | A named target from the config file, resolved to a `--cc` entry. Repeatable; appended to the matrix after `--cc` entries. |
 | `--config PATH` | Config file to use. Default search: `asmdiff.toml` next to `SOURCE.c`, then in the current directory, then `~/.config/`. First hit wins. |
-| `--compile-commands [PATH]` | Borrow each source's include/define flags from a `compile_commands.json`; with no `PATH`, search `./`, `./build`, `../`, `../build`. See [below](#borrowing-includes-from-compile_commandsjson). |
+| `--compile-commands [PATH]` | Borrow each source's include/define flags from a `compile_commands.json`; with no `PATH`, walk up from the CWD checking each directory and its `build/` until the repository root. See [below](#borrowing-includes-from-compile_commandsjson). |
+| `-v`, `--verbose` | On compile failure, print the full compiler command and complete error output. Default shows only the compiler, the source, and the first error lines. |
 | `-- FLAGS...` | Everything after a bare `--` is appended to *every* compiler invocation. |
 
 With no `--cc` and no `--target`, the config file's top-level
@@ -207,7 +208,8 @@ compile_commands = "$HOME/myproject/build/compile_commands.json"
 Now `asmdiff.py $HOME/myproject/components/dsp/biquad.c --target esp32s3-idf`
 finds that file's entry in the database and adds the include/define flags
 it recorded — `-I`, `-isystem`, `-iquote`, `-idirafter`, `-include`,
-`-imacros`, `-D`, `-U` — to this target's command. Everything else the
+`-imacros`, `-D`, `-U`, plus the header-environment driver flags `-specs`
+and `--sysroot` — to this target's command. Everything else the
 database records (its own compiler, `-O`/`-std`/`-W` flags, `-c`, `-o`, the
 source) is ignored: **you** own the compiler and optimisation flags via
 `cc`/`flags`; only the header environment is borrowed. That split is the
@@ -219,6 +221,12 @@ Details that make it robust:
 - **Paths are made absolute** against each entry's `directory`, so a
   database full of build-relative `-I../include` flags still resolves when
   asmdiff runs from anywhere.
+- **`@file` response files are expanded.** Build systems park flags in
+  them — ESP-IDF v6 hides `-specs=picolibc.specs` in
+  `build/toolchain/cflags`, and without it every libc header breaks —
+  so the flag scan reads them (nested ones too) instead of skipping the
+  token. A bare specs name is left for the compiler's own search
+  directories; a specs path resolves like any other recorded path.
 - **Per source file.** The lookup keys on the source you pass (matched by
   resolved absolute path), so two files in an `--across`/summary run each
   get their own recorded flags.
@@ -246,12 +254,15 @@ asmdiff.py biquad.c --compile-commands            # same, for any matrix
 asmdiff.py biquad.c --compile-commands path/to/compile_commands.json
 ```
 
-Both search `./`, `./build`, `../`, `../build` — first hit wins — which
-covers running from a project root or from one directory below it (a
-component dir), with the database where CMake/idf.py leaves it. Finding
-nothing is an error: discovery is opt-in, so if you asked for it, silence
-would be a lie. It is never on by default — a target without
-`compile_commands` and no `--compile-commands` flag borrows nothing.
+Both walk up from the current directory, checking each level for
+`compile_commands.json` and then `build/compile_commands.json` (where
+CMake and idf.py leave it) — first hit wins. The walk stops at the
+repository root (the first directory with a `.git`), so running from any
+depth of component directory finds the project database, but an unrelated
+one further up the filesystem is never picked up. Finding nothing is an
+error: discovery is opt-in, so if you asked for it, silence would be a
+lie. It is never on by default — a target without `compile_commands` and
+no `--compile-commands` flag borrows nothing.
 
 The precedence is what you'd hope: a target that names its own
 `compile_commands` path always keeps it; `--compile-commands` (with or
@@ -292,6 +303,12 @@ weight, did a call appear that shouldn't have? It sums parsed function
 bodies only (no literal pools, data, or alignment), so it is not a size
 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.
+
 ## Comparing the same function across two builds (`--across`)
 
 `--pair` needs both variants to coexist in one compilation. Real changes

{asmdiff-0.1.2 → asmdiff-0.1.3}/README.md

@@ -76,7 +76,7 @@ $ asmdiff.py asmdiff_example.c
 ```
 asmdiff.py SOURCE.c [SOURCE2.c] [--pair OLD:NEW]... [--across FUNC]...
            [--cc 'CC FLAGS']... [--target NAME]... [--config PATH]
-           [--compile-commands [PATH]] [-- EXTRA_FLAGS...]
+           [--compile-commands [PATH]] [-v] [-- EXTRA_FLAGS...]
 ```
 
 | Option | Meaning |
@@ -87,7 +87,8 @@ asmdiff.py SOURCE.c [SOURCE2.c] [--pair OLD:NEW]... [--across FUNC]...
 | `--cc 'CC FLAGS'` | One compiler invocation, command and flags in a single quoted string. Repeatable to build a matrix. |
 | `--target NAME` | A named target from the config file, resolved to a `--cc` entry. Repeatable; appended to the matrix after `--cc` entries. |
 | `--config PATH` | Config file to use. Default search: `asmdiff.toml` next to `SOURCE.c`, then in the current directory, then `~/.config/`. First hit wins. |
-| `--compile-commands [PATH]` | Borrow each source's include/define flags from a `compile_commands.json`; with no `PATH`, search `./`, `./build`, `../`, `../build`. See [below](#borrowing-includes-from-compile_commandsjson). |
+| `--compile-commands [PATH]` | Borrow each source's include/define flags from a `compile_commands.json`; with no `PATH`, walk up from the CWD checking each directory and its `build/` until the repository root. See [below](#borrowing-includes-from-compile_commandsjson). |
+| `-v`, `--verbose` | On compile failure, print the full compiler command and complete error output. Default shows only the compiler, the source, and the first error lines. |
 | `-- FLAGS...` | Everything after a bare `--` is appended to *every* compiler invocation. |
 
 With no `--cc` and no `--target`, the config file's top-level
@@ -189,7 +190,8 @@ compile_commands = "$HOME/myproject/build/compile_commands.json"
 Now `asmdiff.py $HOME/myproject/components/dsp/biquad.c --target esp32s3-idf`
 finds that file's entry in the database and adds the include/define flags
 it recorded — `-I`, `-isystem`, `-iquote`, `-idirafter`, `-include`,
-`-imacros`, `-D`, `-U` — to this target's command. Everything else the
+`-imacros`, `-D`, `-U`, plus the header-environment driver flags `-specs`
+and `--sysroot` — to this target's command. Everything else the
 database records (its own compiler, `-O`/`-std`/`-W` flags, `-c`, `-o`, the
 source) is ignored: **you** own the compiler and optimisation flags via
 `cc`/`flags`; only the header environment is borrowed. That split is the
@@ -201,6 +203,12 @@ Details that make it robust:
 - **Paths are made absolute** against each entry's `directory`, so a
   database full of build-relative `-I../include` flags still resolves when
   asmdiff runs from anywhere.
+- **`@file` response files are expanded.** Build systems park flags in
+  them — ESP-IDF v6 hides `-specs=picolibc.specs` in
+  `build/toolchain/cflags`, and without it every libc header breaks —
+  so the flag scan reads them (nested ones too) instead of skipping the
+  token. A bare specs name is left for the compiler's own search
+  directories; a specs path resolves like any other recorded path.
 - **Per source file.** The lookup keys on the source you pass (matched by
   resolved absolute path), so two files in an `--across`/summary run each
   get their own recorded flags.
@@ -228,12 +236,15 @@ asmdiff.py biquad.c --compile-commands            # same, for any matrix
 asmdiff.py biquad.c --compile-commands path/to/compile_commands.json
 ```
 
-Both search `./`, `./build`, `../`, `../build` — first hit wins — which
-covers running from a project root or from one directory below it (a
-component dir), with the database where CMake/idf.py leaves it. Finding
-nothing is an error: discovery is opt-in, so if you asked for it, silence
-would be a lie. It is never on by default — a target without
-`compile_commands` and no `--compile-commands` flag borrows nothing.
+Both walk up from the current directory, checking each level for
+`compile_commands.json` and then `build/compile_commands.json` (where
+CMake and idf.py leave it) — first hit wins. The walk stops at the
+repository root (the first directory with a `.git`), so running from any
+depth of component directory finds the project database, but an unrelated
+one further up the filesystem is never picked up. Finding nothing is an
+error: discovery is opt-in, so if you asked for it, silence would be a
+lie. It is never on by default — a target without `compile_commands` and
+no `--compile-commands` flag borrows nothing.
 
 The precedence is what you'd hope: a target that names its own
 `compile_commands` path always keeps it; `--compile-commands` (with or
@@ -274,6 +285,12 @@ weight, did a call appear that shouldn't have? It sums parsed function
 bodies only (no literal pools, data, or alignment), so it is not a size
 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.
+
 ## Comparing the same function across two builds (`--across`)
 
 `--pair` needs both variants to coexist in one compilation. Real changes

{asmdiff-0.1.2 → asmdiff-0.1.3}/asmdiff.example.toml

@@ -42,8 +42,9 @@ flags = ["-O2", "-mlongcalls", "-DNDEBUG"]
 # never transcribe include paths by hand.  The compiler and -O/-m flags
 # still come from cc/flags; only the header environment is borrowed.
 # A path expands ~ and $VARS; `compile_commands = true` instead searches
-# ./, ./build, ../, ../build at run time (a source missing from a database
-# found that way is compiled without borrowed flags, with a note).
+# at run time: each directory from the CWD up to the repository root,
+# and its build/ subdirectory (a source missing from a database found
+# that way is compiled without borrowed flags, with a note).
 [esp32s3-idf]
 cc = "$HOME/.espressif/tools/xtensa-esp-elf/esp-*/xtensa-esp-elf/bin/xtensa-esp32s3-elf-gcc"
 flags = ["-O2", "-mlongcalls"]

{asmdiff-0.1.2 → asmdiff-0.1.3}/asmdiff.py

@@ -12,7 +12,7 @@ Usage:
     tools/asmdiff/asmdiff.py SOURCE.c [SOURCE2.c] [--pair OLD:NEW]...
                              [--across FUNC]... [--cc 'CC FLAGS']...
                              [--target NAME]... [--config PATH]
-                             [--compile-commands [PATH]]
+                             [--compile-commands [PATH]] [-v]
                              [-- EXTRA_FLAGS...]
 
 Three modes:
@@ -35,9 +35,10 @@ the include/define flags recorded there for the source being compiled are
 added to that target's command, so a real project source resolves its
 headers the way its own build system does (e.g. an ESP-IDF component).
 compile_commands = true in a target — or a bare --compile-commands on the
-command line — instead searches ./, ./build, ../, ../build for the
-database; a source absent from a database found that way is compiled
-without borrowed flags (with a note) rather than being an error.
+command line — instead finds the database by checking each directory from
+the CWD up to the repository root, and its build/ subdirectory; a source
+absent from a database found that way is compiled without borrowed flags
+(with a note) rather than being an error.
 """
 import argparse
 import glob
@@ -73,6 +74,11 @@ CONFIG_NAME = "asmdiff.toml"
 _CC_DB_PATH_FLAGS = ("-I", "-iquote", "-isystem", "-idirafter",
                      "-include", "-imacros", "-isysroot")
 _CC_DB_PLAIN_FLAGS = ("-D", "-U")
+# Driver-level flags that also shape the header environment: a specs file
+# can swap the entire libc header set (ESP-IDF v6 selects picolibc via
+# -specs=picolibc.specs), and --sysroot moves every system include.  Both
+# accept =-glued and split spellings; both are re-emitted =-glued.
+_CC_DB_EQ_FLAGS = ("-specs", "--specs", "--sysroot")
 _DB_CACHE = {}
 _MISS_NOTED = set()
 
@@ -105,6 +111,43 @@ def _abs_against(directory, value):
     return str(p)
 
 
+def _expand_response_files(tokens, directory, depth=0):
+    """Inline GCC @file response files: each @FILE token is replaced by the
+    shlex-split contents of FILE, resolved against the entry's ``directory``
+    (the CWD the driver ran from).  Build systems park header-environment
+    flags there — ESP-IDF v6 hides -specs=picolibc.specs in one — so
+    skipping them silently loses flags this feature exists to borrow.
+    An unreadable file is warned about and dropped; nesting is bounded as
+    a cycle guard.
+    """
+    out = []
+    for tok in tokens:
+        if not tok.startswith("@") or len(tok) == 1:
+            out.append(tok)
+            continue
+        path = _abs_against(directory, tok[1:])
+        try:
+            content = Path(path).read_text()
+        except OSError:
+            print(f"warning: response file {path} not readable; "
+                  "flags inside it are not borrowed", file=sys.stderr)
+            continue
+        inner = shlex.split(content)
+        if depth < 8:
+            inner = _expand_response_files(inner, directory, depth + 1)
+        out += inner
+    return out
+
+
+def _specs_value(directory, value):
+    """A specs argument with a path separator is a file path (resolved like
+    any other); a bare name (picolibc.specs) is looked up in the compiler's
+    own search directories and must pass through untouched."""
+    if "/" in value or os.sep in value:
+        return _abs_against(directory, value)
+    return value
+
+
 def include_flags(tokens, directory):
     """Pick header-search, forced-include, and define flags out of one
     recorded compile command; make relative paths absolute against
@@ -124,6 +167,19 @@ def include_flags(tokens, directory):
                 flags += [f, _abs_against(directory, tok[len(f):])]
                 matched = True
                 break
+        if not matched:
+            for f in _CC_DB_EQ_FLAGS:
+                value = None
+                if tok == f and i + 1 < n:                # -specs file
+                    value, extra = tokens[i + 1], 1
+                elif tok.startswith(f + "="):             # -specs=file
+                    value = tok[len(f) + 1:]
+                if value is not None:
+                    resolve = (_specs_value if f.endswith("specs")
+                               else _abs_against)
+                    flags.append(f + "=" + resolve(directory, value))
+                    matched = True
+                    break
         if not matched:
             for f in _CC_DB_PLAIN_FLAGS:
                 if tok == f and i + 1 < n:                # -D FOO
@@ -138,18 +194,26 @@ def include_flags(tokens, directory):
 
 
 def find_compile_commands():
-    """Locate a compile_commands.json near the current directory.
-
-    Searched in order: ./, ./build, ../, ../build — first hit wins.  This
-    covers running asmdiff from a project root or from one directory below
-    it (a component dir), with the database where CMake/idf.py leaves it.
-    Returns None when nothing is found.
+    """Locate a compile_commands.json by walking up from the current
+    directory.
+
+    Each directory from the CWD upward is checked for the database itself,
+    then for build/compile_commands.json (where CMake and idf.py leave it),
+    so the search works from a project root or from any depth of component
+    directory.  The walk stops at the first directory containing .git (the
+    repository root — checked after that directory's own candidates) or
+    after a bounded number of levels, so an unrelated database further up
+    the filesystem is never picked up.  Returns None when nothing is found.
     """
-    cwd = Path.cwd()
-    for d in (cwd, cwd / "build", cwd.parent, cwd.parent / "build"):
-        candidate = d / "compile_commands.json"
-        if candidate.is_file():
-            return str(candidate)
+    d = Path.cwd()
+    for _ in range(10):
+        for candidate in (d / "compile_commands.json",
+                          d / "build" / "compile_commands.json"):
+            if candidate.is_file():
+                return str(candidate)
+        if (d / ".git").exists() or d.parent == d:
+            return None
+        d = d.parent
     return None
 
 
@@ -159,8 +223,9 @@ def _discovered_db(who):
     not a silent no-op."""
     found = find_compile_commands()
     if found is None:
-        sys.exit(f"error: {who}: no compile_commands.json found in "
-                 "./, ./build, ../, or ../build")
+        sys.exit(f"error: {who}: no compile_commands.json found in the "
+                 "current directory, its build/, or any parent up to the "
+                 "repository root")
     return found
 
 
@@ -212,6 +277,7 @@ def compile_commands_flags(db_path, source, missing_ok=False):
             args = entry.get("arguments")
             tokens = (list(args) if isinstance(args, list)
                       else shlex.split(entry.get("command", "")))
+            tokens = _expand_response_files(tokens, directory)
             return include_flags(tokens, directory)
         if Path(f).name == want.name:
             name_seen = True
@@ -229,10 +295,18 @@ def compile_commands_flags(db_path, source, missing_ok=False):
 
 # A label at column 0 that is not a local (.L*) label starts a function.
 FUNC_LABEL = re.compile(r"^([A-Za-z_][\w$.]*):")
-# Assembler directives that carry no information worth reading.
+# .type NAME, @object|@function — gcc/clang emit this before the label on
+# ELF.  Objects (string constants like __func__, global state, LUTs) get
+# column-0 labels too and must not be reported as functions.  The type
+# marker is @ on x86/Xtensa/RISC-V, % on ARM, # on some targets.
+TYPE_DIRECTIVE = re.compile(r'^\s*\.type\s+([^,\s]+)\s*,\s*[@%#]?(\w+)')
+# Assembler directives that carry no information worth reading.  .local/
+# .comm/.lcomm declare zero-initialised data, .literal/.literal_position
+# are Xtensa literal-pool bookkeeping — none of them is an instruction.
 NOISE = re.compile(
     r"^\s*\.(cfi_|p2align|align\b|loc\b|file\b|text\b|globl\b|global\b|"
-    r"type\b|section\b|ident\b|weak\b|hidden\b|addrsig|build_version)"
+    r"type\b|section\b|ident\b|weak\b|hidden\b|addrsig|build_version|"
+    r"local\b|comm\b|lcomm\b|literal_position|literal\b)"
 )
 # Compiler-generated bracketing labels that add nothing (.LFB0:, .Lfunc_end0:).
 NOISE_LABEL = re.compile(r"^\.(LFB|LFE|Lfunc_begin|Lfunc_end)\d*:")
@@ -252,18 +326,28 @@ 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, compiler
-    bracketing labels, and inline data (switch jump tables, constants) are
-    dropped; instructions and meaningful local labels (loop targets) are
-    kept, whitespace-stripped.
+    label.  Labels typed ``@object`` (string constants, global state,
+    lookup tables) are data, not functions, and are skipped entirely;
+    an untyped label still counts as a function so hand-written asm
+    keeps working.  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
+    data_labels = set()
     for raw in asm_text.splitlines():
+        t = TYPE_DIRECTIVE.match(raw)
+        if t and t.group(2) != "function":
+            data_labels.add(t.group(1))
         m = FUNC_LABEL.match(raw)
         if m:
-            current = m.group(1)
-            funcs[current] = []
+            if m.group(1) in data_labels:
+                current = None
+            else:
+                current = m.group(1)
+                funcs[current] = []
             continue
         if current is None:
             continue
@@ -453,7 +537,7 @@ def target_command(config, name, config_path):
         if not isinstance(db, str):
             sys.exit(f"error: target [{name}]: compile_commands must be a "
                      "path to a compile_commands.json, or true to search "
-                     "./, ./build, ../, ../build")
+                     "upward from the current directory")
         db = os.path.expandvars(os.path.expanduser(db))
     return Target(shlex.join([resolve_cc(cc, name), *flags]), db, discovered)
 
@@ -491,6 +575,31 @@ def build_matrix(cc_args, target_args, config, config_path, db_arg=None):
     return entries
 
 
+# --verbose: print full compiler command lines and untrimmed stderr.
+VERBOSE = False
+# Without --verbose, a failed compile shows this many stderr lines — enough
+# for the include chain plus the first error, which is the actionable part.
+MAX_STDERR_LINES = 20
+
+
+def _compile_failure(cmd, stderr):
+    """Exit for a failed compile.
+
+    A borrowed-flags command runs to hundreds of tokens and a broken
+    header environment produces pages of stderr; dumping both buries the
+    actual error.  Default: compiler + source + the first stderr lines.
+    --verbose restores the complete command and output.
+    """
+    if VERBOSE:
+        sys.exit(f"error: compile failed: {shlex.join(cmd)}\n{stderr}")
+    lines = stderr.splitlines()
+    shown = "\n".join(lines[:MAX_STDERR_LINES])
+    dropped = len(lines) - MAX_STDERR_LINES
+    more = f"\n... {dropped} more stderr lines" if dropped > 0 else ""
+    sys.exit(f"error: {cmd[0]} failed on {cmd[-1]}\n{shown}{more}\n"
+             "(re-run with --verbose for the full command and output)")
+
+
 def asm_output_name(cc_cmd, harness):
     """Filesystem-safe .s name for one (compiler, source) compilation.
 
@@ -527,7 +636,7 @@ def compile_to_asm(cc_cmd, extra_flags, harness, out_dir):
            + ["-S", "-o", str(out_s), str(harness)])
     proc = subprocess.run(cmd, capture_output=True, text=True)
     if proc.returncode != 0:
-        sys.exit(f"error: compile failed: {' '.join(cmd)}\n{proc.stderr}")
+        _compile_failure(cmd, proc.stderr)
     return out_s.read_text()
 
 
@@ -554,14 +663,28 @@ def format_spans(spans):
     return " ".join(f"{label}:{n}" for label, n in spans) or "-"
 
 
+# Real firmware dispatch functions call dozens of distinct symbols; an
+# uncapped list makes summary rows thousands of characters wide.
+MAX_CALLS_SHOWN = 8
+
+
+def format_calls(calls):
+    """Comma-joined callee list, capped at MAX_CALLS_SHOWN for readability."""
+    if not calls:
+        return "-"
+    if len(calls) > MAX_CALLS_SHOWN:
+        return (", ".join(calls[:MAX_CALLS_SHOWN])
+                + f", +{len(calls) - MAX_CALLS_SHOWN} more")
+    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")]
     for old, new in pairs:
         for name, role in ((old, "baseline"), (new, "candidate")):
             insns, calls = analyze(funcs[name])
-            rows.append((name, role, str(insns),
-                         ", ".join(calls) or "-",
+            rows.append((name, role, str(insns), format_calls(calls),
                          format_spans(loop_spans(funcs[name]))))
     return render_table(rows)
 
@@ -582,10 +705,10 @@ def file_summary_table(funcs):
         for sym in calls:
             if sym not in all_calls:
                 all_calls.append(sym)
-        rows.append((name, str(insns), ", ".join(calls) or "-",
+        rows.append((name, str(insns), format_calls(calls),
                      format_spans(loop_spans(lines))))
     rows.append((f"TOTAL ({len(funcs)} functions)", str(total_insns),
-                 ", ".join(all_calls) or "-", "-"))
+                 format_calls(all_calls), "-"))
     return render_table(rows)
 
 
@@ -763,13 +886,20 @@ def main(argv=None):
                         default=None, metavar="PATH",
                         help="borrow each source's include/define flags from "
                              "a compile_commands.json; with no PATH, search "
-                             "./, ./build, ../, ../build.  A target whose "
+                             "each directory (and its build/) from the CWD "
+                             "up to the repository root.  A target whose "
                              "config names its own compile_commands keeps it")
     parser.add_argument("--config", metavar="PATH",
                         help=f"config file; default search: {CONFIG_NAME} "
                              "next to SOURCE.c, in the current directory, "
                              "then in ~/.config/")
+    parser.add_argument("-v", "--verbose", action="store_true",
+                        help="on compile failure, print the full compiler "
+                             "command and complete error output instead of "
+                             "the first lines")
     args = parser.parse_args(argv)
+    global VERBOSE
+    VERBOSE = args.verbose
 
     if len(args.sources) > 2:
         parser.error("at most two source files may be given")

{asmdiff-0.1.2 → asmdiff-0.1.3}/pyproject.toml

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

{asmdiff-0.1.2 → asmdiff-0.1.3}/test_asmdiff.py

@@ -388,6 +388,77 @@ class TestIncludeFlags(unittest.TestCase):
                          ["-isystem", "/s"])
 
 
+class TestSpecsAndSysroot(unittest.TestCase):
+    """Driver flags that change the header environment (-specs, --sysroot)."""
+
+    def test_specs_glued_bare_name_not_resolved(self):
+        # A bare specs name (no path separator) is found in the compiler's
+        # own search dirs; gluing a directory onto it would break it.
+        self.assertEqual(
+            asmdiff.include_flags(["-specs=picolibc.specs"], "/build"),
+            ["-specs=picolibc.specs"])
+
+    def test_specs_with_path_resolved_against_directory(self):
+        self.assertEqual(
+            asmdiff.include_flags(["-specs=./custom/my.specs"], "/build"),
+            ["-specs=/build/custom/my.specs"])
+
+    def test_specs_split_and_double_dash(self):
+        self.assertEqual(
+            asmdiff.include_flags(["-specs", "nano.specs",
+                                   "--specs=nosys.specs"], "/b"),
+            ["-specs=nano.specs", "--specs=nosys.specs"])
+
+    def test_sysroot_glued_and_split(self):
+        self.assertEqual(
+            asmdiff.include_flags(["--sysroot=sr", "--sysroot", "/abs"],
+                                  "/b"),
+            ["--sysroot=/b/sr", "--sysroot=/abs"])
+
+
+class TestResponseFiles(unittest.TestCase):
+    """GCC @file response files inside compile_commands entries."""
+
+    def test_flags_inside_response_file_are_borrowed(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            rsp = Path(tmp) / "toolchain" / "cflags"
+            rsp.parent.mkdir()
+            rsp.write_text("-mlongcalls\n-specs=picolibc.specs\n-Irspinc\n")
+            src = Path(tmp) / "a.c"
+            src.touch()
+            db = Path(tmp) / "compile_commands.json"
+            db.write_text(json.dumps([{
+                "directory": tmp, "file": str(src),
+                "command": f"cc -Iinc @{rsp} -c a.c"}]))
+            asmdiff._DB_CACHE.clear()
+            self.assertEqual(
+                asmdiff.compile_commands_flags(str(db), str(src)),
+                ["-I", f"{tmp}/inc", "-specs=picolibc.specs",
+                 "-I", f"{tmp}/rspinc"])
+
+    def test_relative_response_file_resolves_against_directory(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            (Path(tmp) / "cflags").write_text("-DFROMRSP")
+            self.assertEqual(
+                asmdiff._expand_response_files(["@cflags"], tmp),
+                ["-DFROMRSP"])
+
+    def test_nested_response_files(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            (Path(tmp) / "outer").write_text("@inner -DOUTER")
+            (Path(tmp) / "inner").write_text("-DINNER")
+            self.assertEqual(
+                asmdiff._expand_response_files(["@outer"], tmp),
+                ["-DINNER", "-DOUTER"])
+
+    def test_missing_response_file_warns_and_continues(self):
+        err = io.StringIO()
+        with contextlib.redirect_stderr(err):
+            out = asmdiff._expand_response_files(["-DKEEP", "@/nope/x"], "/b")
+        self.assertEqual(out, ["-DKEEP"])
+        self.assertIn("/nope/x", err.getvalue())
+
+
 class TestCompileCommandsFlags(unittest.TestCase):
     def _db(self, tmp, entries):
         path = Path(tmp) / "compile_commands.json"
@@ -477,15 +548,22 @@ def _inside(directory):
 
 
 class TestFindCompileCommands(unittest.TestCase):
-    """Auto-discovery of compile_commands.json near the current directory."""
+    """Auto-discovery of compile_commands.json by walking up from the CWD."""
 
     def _touch_db(self, directory):
         directory.mkdir(parents=True, exist_ok=True)
         (directory / "compile_commands.json").write_text("[]")
 
-    def test_search_order_cwd_build_parent_parentbuild(self):
+    def _repo(self, tmp):
+        """A fake repo root: .git bounds the walk so tests never escape
+        the tempdir and pick up a stray database further up."""
+        root = Path(tmp)
+        (root / ".git").mkdir()
+        return root
+
+    def test_nearer_hits_win(self):
         with tempfile.TemporaryDirectory() as tmp:
-            root = Path(tmp)
+            root = self._repo(tmp)
             cwd = root / "sub"
             cwd.mkdir()
             for where, expect in [(root / "build", root / "build"),
@@ -497,14 +575,127 @@ class TestFindCompileCommands(unittest.TestCase):
                     self.assertEqual(asmdiff.find_compile_commands(),
                                      str(expect / "compile_commands.json"))
 
+    def test_walks_up_from_nested_component_dir(self):
+        # components/amy/src is three levels below the project root where
+        # idf.py leaves build/compile_commands.json.
+        with tempfile.TemporaryDirectory() as tmp:
+            root = self._repo(tmp)
+            self._touch_db(root / "build")
+            cwd = root / "components" / "amy" / "src"
+            cwd.mkdir(parents=True)
+            with _inside(cwd):
+                self.assertEqual(asmdiff.find_compile_commands(),
+                                 str(root / "build" / "compile_commands.json"))
+
+    def test_stops_at_repository_root(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            self._touch_db(Path(tmp))          # db ABOVE the repo root
+            repo = Path(tmp) / "repo"
+            repo.mkdir()
+            (repo / ".git").write_text("gitdir: elsewhere")  # worktree form
+            cwd = repo / "src"
+            cwd.mkdir()
+            with _inside(cwd):
+                self.assertIsNone(asmdiff.find_compile_commands())
+
     def test_nothing_found_returns_none(self):
         with tempfile.TemporaryDirectory() as tmp:
-            cwd = Path(tmp) / "a" / "b"
+            root = self._repo(tmp)
+            cwd = root / "a" / "b"
             cwd.mkdir(parents=True)
             with _inside(cwd):
                 self.assertIsNone(asmdiff.find_compile_commands())
 
 
+class TestObjectLabels(unittest.TestCase):
+    """Data labels must not be reported as functions."""
+
+    ASM = """\
+\t.type\tscale, @function
+scale:
+\tentry\tsp, 32
+\tretw.n
+\t.size\tscale, .-scale
+\t.type\t__func__$1, @object
+\t.size\t__func__$1, 9
+__func__$1:
+\t.string\t"app_main"
+\t.local\ts_queue
+\t.comm\ts_queue,4,4
+\t.lcomm\ts_tmp,8
+"""
+
+    def test_object_labels_skipped(self):
+        funcs = asmdiff.extract_functions(self.ASM)
+        self.assertEqual(list(funcs), ["scale"])
+
+    def test_arm_percent_function_type_still_reported(self):
+        asm = "\t.type\tf, %function\nf:\n\tbx\tlr\n\t.size\tf, .-f\n"
+        self.assertEqual(list(asmdiff.extract_functions(asm)), ["f"])
+
+    def test_untyped_label_still_treated_as_function(self):
+        # Hand-written asm often has no .type at all.
+        asm = "myfunc:\n\tret\n"
+        self.assertEqual(list(asmdiff.extract_functions(asm)), ["myfunc"])
+
+    def test_local_comm_literal_lines_not_counted(self):
+        asm = ("f:\n\tmov.n\ta2, a3\n\t.literal_position\n"
+               "\t.literal .LC1, 4096\n\t.local\tx\n\t.comm\tx,4,4\n"
+               "\tretw.n\n")
+        funcs = asmdiff.extract_functions(asm)
+        insns, _ = asmdiff.analyze(funcs["f"])
+        self.assertEqual(insns, 2)
+
+
+class TestCompileFailureOutput(unittest.TestCase):
+    CMD = ["xtensa-gcc", "-O2"] + [f"-I/inc{i}" for i in range(50)] + ["a.c"]
+    STDERR = "\n".join(f"err line {i}" for i in range(60))
+
+    def test_default_trims_flags_and_stderr(self):
+        asmdiff.VERBOSE = False
+        with self.assertRaises(SystemExit) as ctx:
+            asmdiff._compile_failure(self.CMD, self.STDERR)
+        msg = str(ctx.exception)
+        self.assertIn("xtensa-gcc failed on a.c", msg)
+        self.assertNotIn("-I/inc0", msg)                 # no flag dump
+        self.assertIn("err line 0", msg)
+        self.assertNotIn("err line 30", msg)             # stderr trimmed
+        self.assertIn("40 more stderr lines", msg)
+        self.assertIn("--verbose", msg)
+
+    def test_verbose_shows_everything(self):
+        asmdiff.VERBOSE = True
+        try:
+            with self.assertRaises(SystemExit) as ctx:
+                asmdiff._compile_failure(self.CMD, self.STDERR)
+        finally:
+            asmdiff.VERBOSE = False
+        msg = str(ctx.exception)
+        self.assertIn("-I/inc0", msg)
+        self.assertIn("err line 59", msg)
+
+    def test_short_stderr_not_annotated_with_more(self):
+        asmdiff.VERBOSE = False
+        with self.assertRaises(SystemExit) as ctx:
+            asmdiff._compile_failure(["gcc", "x.c"], "one error\n")
+        self.assertNotIn("more stderr", str(ctx.exception))
+
+
+class TestFormatCalls(unittest.TestCase):
+    def test_short_list_unchanged(self):
+        self.assertEqual(asmdiff.format_calls(["a", "b"]), "a, b")
+
+    def test_empty_is_dash(self):
+        self.assertEqual(asmdiff.format_calls([]), "-")
+
+    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.assertIn("fn7", out)
+        self.assertNotIn("fn8,", out)
+
+
 class TestDiscoveredCompileCommands(unittest.TestCase):
     """compile_commands = true in a target / bare --compile-commands."""