| |
| """Export source-owned concrete function identities using the pinned DWARF reader. |
| |
| This packages facts, not scores. dSYM use here does not add DecBench metric support. |
| """ |
|
|
| import argparse, collections, hashlib, json, sys, shlex |
| from pathlib import Path |
| from elftools.elf.elffile import ELFFile |
| import lief |
| from decbench.utils.binfmt import _build_dwarfinfo, die_attr_owner, die_str_attr |
| from decbench.utils.native_code import die_ranges |
| from decbench.metrics.type_match import _parse_function_die |
|
|
|
|
| def decode(value): |
| return value.decode("utf-8", "replace") if isinstance(value, bytes) else str(value) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("status", type=Path) |
| ap.add_argument("--stage", type=Path, required=True) |
| ap.add_argument("--sources", type=Path, required=True) |
| a = ap.parse_args() |
| s = json.loads(a.status.read_text()) |
| binary = a.stage / s["binary"] |
| source = (a.sources / s["project"]).resolve() |
| rows = [] |
| f = None |
| try: |
| if s["platform"] == "macos": |
| db = ( |
| binary.with_name(binary.name + ".dSYM") |
| / "Contents/Resources/DWARF" |
| / binary.name |
| ) |
| b = lief.parse(str(db)) |
| sections = { |
| "." + x.name[2:]: bytes(x.content) |
| for x in b.sections |
| if x.segment_name == "__DWARF" |
| } |
| if ".debug_str_offs" in sections: |
| sections[".debug_str_offsets"] = sections.pop(".debug_str_offs") |
| dw = _build_dwarfinfo(sections, True, 8, "AArch64") |
| else: |
| f = binary.open("rb") |
| elf = ELFFile(f) |
| dw = elf.get_dwarf_info() |
| image = lief.parse(str(binary)) |
| executable = [] |
| for section in image.sections: |
| if (s["platform"] == "macos" and section.name == "__text") or ( |
| s["platform"] == "linux" and int(section.flags) & 4 |
| ): |
| executable.append( |
| ( |
| section.virtual_address, |
| section.virtual_address + len(section.content), |
| ) |
| ) |
| assert executable, "No file-backed executable sections" |
| producer = set() |
| owned_cus = 0 |
| all_concrete = 0 |
| rejected_unmapped = 0 |
| compile_sources = {} |
| if s["platform"] == "macos": |
| for command in json.loads( |
| (a.status.parent / "compile_commands.json").read_text() |
| ): |
| original = Path(command["file"]).resolve() |
| args = command.get("arguments") or shlex.split(command["command"]) |
| output = ( |
| args[args.index("-o") + 1] |
| if "-o" in args |
| else command.get("output") |
| ) |
| aliases = [original] |
| if output: |
| object_file = Path(command["directory"]) / output |
| stem = object_file.with_suffix("") |
| aliases.extend([stem, Path(str(stem) + ".ii")]) |
| for alias in aliases: |
| alias = alias.resolve() |
| prior = compile_sources.get(alias) |
| assert ( |
| prior is None or prior == original |
| ), "Conflicting compile-command TU identity" |
| compile_sources[alias] = original |
| for cu in dw.iter_CUs(): |
| top = cu.get_top_DIE() |
| name = decode(top.attributes["DW_AT_name"].value) |
| comp = ( |
| decode(top.attributes.get("DW_AT_comp_dir").value) |
| if top.attributes.get("DW_AT_comp_dir") |
| else "" |
| ) |
| producer.add(decode(top.attributes["DW_AT_producer"].value)) |
| if s["platform"] == "macos": |
| tu = ( |
| (Path(comp) / name).resolve() |
| if not Path(name).is_absolute() |
| else Path(name).resolve() |
| ) |
| tu = compile_sources.get(tu, tu) |
| owned = ( |
| tu.is_relative_to(source) |
| and "third_party" not in tu.relative_to(source).parts |
| and "deps" not in tu.relative_to(source).parts |
| ) |
| else: |
| |
| |
| tu = Path(name) if Path(name).is_absolute() else Path(comp) / name |
| owned = ( |
| "/src/" in tu.as_posix() |
| and "third_party" not in tu.parts |
| and "deps" not in tu.parts |
| ) |
| if not owned: |
| continue |
| owned_cus += 1 |
| for die in cu.iter_DIEs(): |
| if die.tag != "DW_TAG_subprogram": |
| continue |
| ranges = die_ranges(die, dw) |
| if not ranges: |
| continue |
| if not all( |
| any(begin >= lo and end <= hi for lo, hi in executable) |
| for begin, end in ranges |
| ): |
| rejected_unmapped += 1 |
| continue |
| all_concrete += 1 |
| if s["platform"] == "macos": |
| attr, owner = die_attr_owner( |
| die, "DW_AT_decl_file", follow_abstract_origin=True |
| ) |
| if attr is None: |
| continue |
| lp = dw.line_program_for_CU(owner.cu) |
| version = lp.header["version"] |
| file_index = int(attr.value) - (0 if version >= 5 else 1) |
| files = lp["file_entry"] |
| if not 0 <= file_index < len(files): |
| continue |
| entry = files[file_index] |
| decl = Path(decode(entry.name)) |
| directory_index = int(entry.dir_index) - (0 if version >= 5 else 1) |
| if not decl.is_absolute() and 0 <= directory_index < len( |
| lp["include_directory"] |
| ): |
| decl = ( |
| Path(decode(lp["include_directory"][directory_index])) |
| / decl |
| ) |
| if not decl.is_absolute(): |
| decl = Path(comp) / decl |
| decl = decl.resolve() |
| if not decl.is_relative_to(source) or {"third_party", "deps"} & set( |
| decl.relative_to(source).parts |
| ): |
| continue |
| fname, variables = _parse_function_die(die, dw) |
| if not fname: |
| continue |
| low = min(begin for begin, end in ranges) |
| link = die_str_attr( |
| die, "DW_AT_linkage_name", follow_abstract_origin=True |
| ) or die_str_attr( |
| die, "DW_AT_MIPS_linkage_name", follow_abstract_origin=True |
| ) |
| rows.append( |
| { |
| "binary_sha256": s["binary_sha256"], |
| "address": low, |
| "ranges": ranges, |
| "name": fname, |
| "linkage_name": link if link else None, |
| "source_tu": str(tu), |
| "die_offset": die.offset, |
| "variables": variables, |
| } |
| ) |
| assert rows, "No source-owned named concrete function records" |
| counts = collections.Counter(x["name"] for x in rows) |
| for row in rows: |
| row["storage_key"] = ( |
| row["name"] |
| if counts[row["name"]] == 1 |
| else row["name"] + "@0x" + format(row["address"], "x") |
| ) |
| result = { |
| "schema": "decbench-cpp-dwarf-evidence-v2", |
| "platform": s["platform"], |
| "project": s["project"], |
| "source_owned_cus": owned_cus, |
| "concrete_records_before_name_resolution": all_concrete, |
| "named_records": len(rows), |
| "unique_entry_addresses": len({x["address"] for x in rows}), |
| "rejected_unmapped_range_records": rejected_unmapped, |
| "producer": sorted(producer), |
| "ownership_method": ( |
| "exact-native-source-root" |
| if s["platform"] == "macos" |
| else "raw-build-temp-src-layout; header-defined functions may include dependencies" |
| ), |
| "source_level_and_abi_type_policy": "raw DWARF variable spellings/storage retained; no higher-level correctness scoring policy", |
| "functions": rows, |
| } |
| (a.status.parent / "dwarf-functions.json").write_text( |
| json.dumps(result, indent=2) |
| ) |
| s.pop("dwarf_evidence_error", None) |
| s["source_owned_function_records"] = len(rows) |
| s["source_owned_cus"] = owned_cus |
| s["unique_source_entry_addresses"] = len({x["address"] for x in rows}) |
| s["rejected_unmapped_range_records"] = rejected_unmapped |
| s["debug_producers"] = sorted(producer) |
| s["remaining_gates"] = [ |
| x |
| for x in s["remaining_gates"] |
| if "function index" not in x and "function identity extraction" not in x |
| ] |
| except Exception as e: |
| s["dwarf_evidence_error"] = str(e) |
| finally: |
| if f: |
| f.close() |
| a.status.write_text(json.dumps(s, indent=2)) |
| print( |
| json.dumps( |
| { |
| "status": str(a.status), |
| "named_records": len(rows), |
| "error": s.get("dwarf_evidence_error"), |
| } |
| ), |
| flush=True, |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
