#!/usr/bin/env python3
"""Map the hot instruction-fetch cache lines reported by drcachesim's histogram
tool onto functions of the traced binary.

The histogram tool reports instruction-fetch addresses at 64-byte cache-line
granularity, so this is a corroborating view of the traces themselves; the
exhaustive, instruction-exact attribution lives in
validation/steady_state/function_profile-segment-*.txt.

The binary is built -no-pie, so a runtime PC inside the main module equals its
link-time address and can be looked up directly in `nm` output; modules.log
(shipped in traces_simp/bin/) carries the base address of every module for the
general case.

Usage: trace_pc_funcs.py <histogram-output> <nm-file> [modules.log]
"""
import bisect
import re
import sys
from collections import defaultdict


def load_symbols(nm_path):
    syms = []
    for line in open(nm_path):
        parts = line.split(None, 2)
        if len(parts) < 3:
            continue
        addr, typ, name = parts[0], parts[1], parts[2].strip()
        if typ.lower() not in ("t", "w", "i"):
            continue
        try:
            syms.append((int(addr, 16), name))
        except ValueError:
            pass
    syms.sort()
    return [a for a, _ in syms], [n for _, n in syms]


def load_modules(path):
    """modules.log -> list of (base, end, name) for attribution of non-main PCs."""
    mods = []
    for line in open(path, errors="replace"):
        fields = [f.strip() for f in line.split(",")]
        if len(fields) < 6:
            continue
        try:
            base = int(fields[2], 16) if fields[2].startswith("0x") else int(fields[2])
            end = int(fields[3], 16) if fields[3].startswith("0x") else int(fields[3])
        except ValueError:
            continue
        mods.append((base, end, fields[-1]))
    return mods


def main():
    hist_path, nm_path = sys.argv[1], sys.argv[2]
    modules = load_modules(sys.argv[3]) if len(sys.argv) > 3 else []
    addrs, names = load_symbols(nm_path)
    lo, hi = addrs[0], addrs[-1] + 0x10000

    per_func = defaultdict(int)
    total = 0
    in_instr_section = False
    for line in open(hist_path):
        if re.match(r"\s*icache top", line, re.I):
            in_instr_section = True
            continue
        if re.match(r"\s*dcache top", line, re.I):
            in_instr_section = False
            continue
        if not in_instr_section:
            continue
        m = re.match(r"\s*(0x[0-9a-fA-F]+)\s*:\s*([0-9]+)", line)
        if not m:
            continue
        pc, cnt = int(m.group(1), 16), int(m.group(2))
        total += cnt
        if lo <= pc <= hi:
            i = bisect.bisect_right(addrs, pc) - 1
            per_func[names[i]] += cnt
        else:
            label = "[non-main module]"
            for base, end, name in modules:
                if base <= pc < end:
                    label = f"[{name}]"
                    break
            per_func[label] += cnt

    print(f"# hot instruction-fetch entries attributed: {total}")
    print(f"{'share%':>8}  {'count':>12}  function")
    for name, n in sorted(per_func.items(), key=lambda kv: -kv[1]):
        print(f"{100.0 * n / total:8.3f}  {n:12d}  {name}")


if __name__ == "__main__":
    main()