TheRock/compiler/amd-llvm/llvm/utils/llvm-original-di-preservation.py

#!/usr/bin/env python
#
# Debugify summary for the original debug info testing.
#

from __future__ import print_function
import argparse
import os
import re
import sys
from json import loads
from collections import defaultdict
from collections import OrderedDict

class DILocBug:
    def __init__(self, origin, action, bb_name, fn_name, instr):
        self.origin = origin
        self.action = action
        self.bb_name = bb_name
        self.fn_name = fn_name
        self.instr = instr

    def key(self):
        return self.action + self.bb_name + self.fn_name + self.instr

    def reduced_key(self, bug_pass):
        if self.origin is not None:
            # If we have the origin stacktrace available, we can use it to efficiently deduplicate identical errors. We
            # just need to remove the pointer values from the string first, so that we can deduplicate across files.
            origin_no_addr = re.sub(r"0x[0-9a-fA-F]+", "", self.origin)
            return origin_no_addr
        return bug_pass + self.instr

    def to_dict(self):
        result = {
            "instr": self.instr,
            "fn_name": self.fn_name,
            "bb_name": self.bb_name,
            "action": self.action,
        }
        if self.origin:
            result["origin"] = self.origin
        return result


class DISPBug:
    def __init__(self, action, fn_name):
        self.action = action
        self.fn_name = fn_name

    def key(self):
        return self.action + self.fn_name

    def reduced_key(self, bug_pass):
        return bug_pass + self.fn_name

    def to_dict(self):
        return {
            "fn_name": self.fn_name,
            "action": self.action,
        }


class DIVarBug:
    def __init__(self, action, name, fn_name):
        self.action = action
        self.name = name
        self.fn_name = fn_name

    def key(self):
        return self.action + self.name + self.fn_name

    def reduced_key(self, bug_pass):
        return bug_pass + self.name

    def to_dict(self):
        return {
            "fn_name": self.fn_name,
            "name": self.name,
            "action": self.action,
        }


def print_bugs_yaml(name, bugs_dict, indent=2):
    def get_bug_line(indent_level: int, text: str, margin_mark: bool = False):
        if margin_mark:
            return "- ".rjust(indent_level * indent) + text
        return " " * indent * indent_level + text

    print(f"{name}:")
    for bugs_file, bugs_pass_dict in sorted(iter(bugs_dict.items())):
        print(get_bug_line(1, f"{bugs_file}:"))
        for bugs_pass, bugs_list in sorted(iter(bugs_pass_dict.items())):
            print(get_bug_line(2, f"{bugs_pass}:"))
            for bug in bugs_list:
                bug_dict = bug.to_dict()
                first_line = True
                # First item needs a '-' in the margin.
                for key, val in sorted(iter(bug_dict.items())):
                    if "\n" in val:
                        # Output block text for any multiline string.
                        print(get_bug_line(3, f"{key}: |", first_line))
                        for line in val.splitlines():
                            print(get_bug_line(4, line))
                    else:
                        print(get_bug_line(3, f"{key}: {val}", first_line))
                    first_line = False

# Report the bugs in form of html.
def generate_html_report(
    di_location_bugs,
    di_subprogram_bugs,
    di_var_bugs,
    di_location_bugs_summary,
    di_sp_bugs_summary,
    di_var_bugs_summary,
    html_file,
):
    fileout = open(html_file, "w")

    html_header = """ <html>
  <head>
  <style>
  table, th, td {
    border: 1px solid black;
  }
  table.center {
    margin-left: auto;
    margin-right: auto;
  }
  </style>
  </head>
  <body>
  """

    # Create the table for Location bugs.
    table_title_di_loc = "Location Bugs found by the Debugify"

    table_di_loc = """<table>
  <caption><b>{}</b></caption>
  <tr>
  """.format(
        table_title_di_loc
    )

    # If any DILocation bug has an origin stack trace, we emit an extra column in the table, which we must therefore
    # determine up-front.
    has_origin_col = any(
        x.origin is not None
        for per_file_bugs in di_location_bugs.values()
        for per_pass_bugs in per_file_bugs.values()
        for x in per_pass_bugs
    )

    header_di_loc = [
        "File",
        "LLVM Pass Name",
        "LLVM IR Instruction",
        "Function Name",
        "Basic Block Name",
        "Action",
    ]
    if has_origin_col:
        header_di_loc.append("Origin")

    for column in header_di_loc:
        table_di_loc += "    <th>{0}</th>\n".format(column.strip())
    table_di_loc += "  </tr>\n"

    at_least_one_bug_found = False

    # Handle loction bugs.
    for file, per_file_bugs in di_location_bugs.items():
        for llvm_pass, per_pass_bugs in per_file_bugs.items():
            # No location bugs for the pass.
            if len(per_pass_bugs) == 0:
                continue
            at_least_one_bug_found = True
            row = []
            table_di_loc += "  </tr>\n"
            # Get the bugs info.
            for x in per_pass_bugs:
                row.append("    <tr>\n")
                row.append(file)
                row.append(llvm_pass)
                row.append(x.instr)
                row.append(x.fn_name)
                row.append(x.bb_name)
                row.append(x.action)
                if has_origin_col:
                    if x.origin is not None:
                        row.append(
                            f"<details><summary>View Origin StackTrace</summary><pre>{x.origin}</pre></details>"
                        )
                    else:
                        row.append("")
                row.append("    </tr>\n")
            # Dump the bugs info into the table.
            for column in row:
                # The same file-pass pair can have multiple bugs.
                if column == "    <tr>\n" or column == "    </tr>\n":
                    table_di_loc += column
                    continue
                table_di_loc += "    <td>{0}</td>\n".format(column.strip())
            table_di_loc += "  <tr>\n"

    if not at_least_one_bug_found:
        table_di_loc += """  <tr>
        <td colspan='7'> No bugs found </td>
      </tr>
    """
    table_di_loc += "</table>\n"

    # Create the summary table for the loc bugs.
    table_title_di_loc_sum = "Summary of Location Bugs"
    table_di_loc_sum = """<table>
  <caption><b>{}</b></caption>
  <tr>
  """.format(
        table_title_di_loc_sum
    )

    header_di_loc_sum = ["LLVM Pass Name", "Number of bugs"]

    for column in header_di_loc_sum:
        table_di_loc_sum += "    <th>{0}</th>\n".format(column.strip())
    table_di_loc_sum += "  </tr>\n"

    # Print the summary.
    row = []
    for llvm_pass, num in sorted(di_location_bugs_summary.items()):
        row.append("    <tr>\n")
        row.append(llvm_pass)
        row.append(str(num))
        row.append("    </tr>\n")
    for column in row:
        if column == "    <tr>\n" or column == "    </tr>\n":
            table_di_loc_sum += column
            continue
        table_di_loc_sum += "    <td>{0}</td>\n".format(column.strip())
    table_di_loc_sum += "  <tr>\n"

    if not at_least_one_bug_found:
        table_di_loc_sum += """<tr>
        <td colspan='2'> No bugs found </td>
      </tr>
    """
    table_di_loc_sum += "</table>\n"

    # Create the table for SP bugs.
    table_title_di_sp = "SP Bugs found by the Debugify"
    table_di_sp = """<table>
  <caption><b>{}</b></caption>
  <tr>
  """.format(
        table_title_di_sp
    )

    header_di_sp = ["File", "LLVM Pass Name", "Function Name", "Action"]

    for column in header_di_sp:
        table_di_sp += "    <th>{0}</th>\n".format(column.strip())
    table_di_sp += "  </tr>\n"

    at_least_one_bug_found = False

    # Handle fn bugs.
    for file, per_file_bugs in di_subprogram_bugs.items():
        for llvm_pass, per_pass_bugs in per_file_bugs.items():
            # No SP bugs for the pass.
            if len(per_pass_bugs) == 0:
                continue
            at_least_one_bug_found = True
            row = []
            table_di_sp += "  </tr>\n"
            # Get the bugs info.
            for x in per_pass_bugs:
                row.append("    <tr>\n")
                row.append(file)
                row.append(llvm_pass)
                row.append(x.fn_name)
                row.append(x.action)
                row.append("    </tr>\n")
            # Dump the bugs info into the table.
            for column in row:
                # The same file-pass pair can have multiple bugs.
                if column == "    <tr>\n" or column == "    </tr>\n":
                    table_di_sp += column
                    continue
                table_di_sp += "    <td>{0}</td>\n".format(column.strip())
            table_di_sp += "  <tr>\n"

    if not at_least_one_bug_found:
        table_di_sp += """<tr>
        <td colspan='4'> No bugs found </td>
      </tr>
    """
    table_di_sp += "</table>\n"

    # Create the summary table for the sp bugs.
    table_title_di_sp_sum = "Summary of SP Bugs"
    table_di_sp_sum = """<table>
  <caption><b>{}</b></caption>
  <tr>
  """.format(
        table_title_di_sp_sum
    )

    header_di_sp_sum = ["LLVM Pass Name", "Number of bugs"]

    for column in header_di_sp_sum:
        table_di_sp_sum += "    <th>{0}</th>\n".format(column.strip())
    table_di_sp_sum += "  </tr>\n"

    # Print the summary.
    row = []
    for llvm_pass, num in sorted(di_sp_bugs_summary.items()):
        row.append("    <tr>\n")
        row.append(llvm_pass)
        row.append(str(num))
        row.append("    </tr>\n")
    for column in row:
        if column == "    <tr>\n" or column == "    </tr>\n":
            table_di_sp_sum += column
            continue
        table_di_sp_sum += "    <td>{0}</td>\n".format(column.strip())
    table_di_sp_sum += "  <tr>\n"

    if not at_least_one_bug_found:
        table_di_sp_sum += """<tr>
        <td colspan='2'> No bugs found </td>
      </tr>
    """
    table_di_sp_sum += "</table>\n"

    # Create the table for Variable bugs.
    table_title_di_var = "Variable Location Bugs found by the Debugify"
    table_di_var = """<table>
  <caption><b>{}</b></caption>
  <tr>
  """.format(
        table_title_di_var
    )

    header_di_var = ["File", "LLVM Pass Name", "Variable", "Function", "Action"]

    for column in header_di_var:
        table_di_var += "    <th>{0}</th>\n".format(column.strip())
    table_di_var += "  </tr>\n"

    at_least_one_bug_found = False

    # Handle var bugs.
    for file, per_file_bugs in di_var_bugs.items():
        for llvm_pass, per_pass_bugs in per_file_bugs.items():
            # No SP bugs for the pass.
            if len(per_pass_bugs) == 0:
                continue
            at_least_one_bug_found = True
            row = []
            table_di_var += "  </tr>\n"
            # Get the bugs info.
            for x in per_pass_bugs:
                row.append("    <tr>\n")
                row.append(file)
                row.append(llvm_pass)
                row.append(x.name)
                row.append(x.fn_name)
                row.append(x.action)
                row.append("    </tr>\n")
            # Dump the bugs info into the table.
            for column in row:
                # The same file-pass pair can have multiple bugs.
                if column == "    <tr>\n" or column == "    </tr>\n":
                    table_di_var += column
                    continue
                table_di_var += "    <td>{0}</td>\n".format(column.strip())
            table_di_var += "  <tr>\n"

    if not at_least_one_bug_found:
        table_di_var += """<tr>
        <td colspan='4'> No bugs found </td>
      </tr>
    """
    table_di_var += "</table>\n"

    # Create the summary table for the sp bugs.
    table_title_di_var_sum = "Summary of Variable Location Bugs"
    table_di_var_sum = """<table>
  <caption><b>{}</b></caption>
  <tr>
  """.format(
        table_title_di_var_sum
    )

    header_di_var_sum = ["LLVM Pass Name", "Number of bugs"]

    for column in header_di_var_sum:
        table_di_var_sum += "    <th>{0}</th>\n".format(column.strip())
    table_di_var_sum += "  </tr>\n"

    # Print the summary.
    row = []
    for llvm_pass, num in sorted(di_var_bugs_summary.items()):
        row.append("    <tr>\n")
        row.append(llvm_pass)
        row.append(str(num))
        row.append("    </tr>\n")
    for column in row:
        if column == "    <tr>\n" or column == "    </tr>\n":
            table_di_var_sum += column
            continue
        table_di_var_sum += "    <td>{0}</td>\n".format(column.strip())
    table_di_var_sum += "  <tr>\n"

    if not at_least_one_bug_found:
        table_di_var_sum += """<tr>
        <td colspan='2'> No bugs found </td>
      </tr>
    """
    table_di_var_sum += "</table>\n"

    # Finish the html page.
    html_footer = """</body>
  </html>"""

    new_line = "<br>\n"

    fileout.writelines(html_header)
    fileout.writelines(table_di_loc)
    fileout.writelines(new_line)
    fileout.writelines(table_di_loc_sum)
    fileout.writelines(new_line)
    fileout.writelines(new_line)
    fileout.writelines(table_di_sp)
    fileout.writelines(new_line)
    fileout.writelines(table_di_sp_sum)
    fileout.writelines(new_line)
    fileout.writelines(new_line)
    fileout.writelines(table_di_var)
    fileout.writelines(new_line)
    fileout.writelines(table_di_var_sum)
    fileout.writelines(html_footer)
    fileout.close()

    print("The " + html_file + " generated.")


# Read the JSON file in chunks.
def get_json_chunk(file, start, size):
    json_parsed = None
    di_checker_data = []
    skipped_lines = 0
    line = 0

    # The file contains json object per line.
    # An example of the line (formatted json):
    # {
    #  "file": "simple.c",
    #  "pass": "Deduce function attributes in RPO",
    #  "bugs": [
    #    [
    #      {
    #        "action": "drop",
    #        "metadata": "DISubprogram",
    #        "name": "fn2"
    #      },
    #      {
    #        "action": "drop",
    #        "metadata": "DISubprogram",
    #        "name": "fn1"
    #      }
    #    ]
    #  ]
    # }
    with open(file) as json_objects_file:
        for json_object_line in json_objects_file:
            line += 1
            if line < start:
                continue
            if line >= start + size:
                break
            try:
                json_object = loads(json_object_line)
            except:
                skipped_lines += 1
            else:
                di_checker_data.append(json_object)

    return (di_checker_data, skipped_lines, line)


# Parse the program arguments.
def parse_program_args(parser):
    parser.add_argument("file_name", type=str, help="json file to process")
    parser.add_argument(
        "--reduce",
        action="store_true",
        help="create reduced report by deduplicating bugs within and across files",
    )

    report_type_group = parser.add_mutually_exclusive_group(required=True)
    report_type_group.add_argument(
        "--report-html-file", type=str, help="output HTML file for the generated report"
    )
    report_type_group.add_argument(
        "--acceptance-test",
        action="store_true",
        help="if set, produce terminal-friendly output and return 0 iff the input file is empty or does not exist",
    )

    return parser.parse_args()


def Main():
    parser = argparse.ArgumentParser()
    opts = parse_program_args(parser)

    if opts.report_html_file is not None and not opts.report_html_file.endswith(
        ".html"
    ):
        print("error: The output file must be '.html'.")
        sys.exit(1)

    if opts.acceptance_test:
        if os.path.isdir(opts.file_name):
            print(f"error: Directory passed as input file: '{opts.file_name}'")
            sys.exit(1)
        if not os.path.exists(opts.file_name):
            # We treat an empty input file as a success, as debugify will generate an output file iff any errors are
            # found, meaning we expect 0 errors to mean that the expected file does not exist.
            print(f"No errors detected for: {opts.file_name}")
            sys.exit(0)

    # Use the defaultdict in order to make multidim dicts.
    di_location_bugs = defaultdict(lambda: defaultdict(list))
    di_subprogram_bugs = defaultdict(lambda: defaultdict(list))
    di_variable_bugs = defaultdict(lambda: defaultdict(list))

    # Use the ordered dict to make a summary.
    di_location_bugs_summary = OrderedDict()
    di_sp_bugs_summary = OrderedDict()
    di_var_bugs_summary = OrderedDict()

    # If we are using --reduce, use these sets to deduplicate similar bugs within and across files.
    di_loc_reduced_set = set()
    di_sp_reduced_set = set()
    di_var_reduced_set = set()

    start_line = 0
    chunk_size = 1000000
    end_line = chunk_size - 1
    skipped_lines = 0
    skipped_bugs = 0
    # Process each chunk of 1 million JSON lines.
    while True:
        if start_line > end_line:
            break
        (debug_info_bugs, skipped, end_line) = get_json_chunk(
            opts.file_name, start_line, chunk_size
        )
        start_line += chunk_size
        skipped_lines += skipped

        # Map the bugs into the file-pass pairs.
        for bugs_per_pass in debug_info_bugs:
            try:
                bugs_file = bugs_per_pass["file"]
                bugs_pass = bugs_per_pass["pass"]
                bugs = bugs_per_pass["bugs"][0]
            except:
                skipped_lines += 1
                continue

            di_loc_bugs = di_location_bugs.get("bugs_file", {}).get("bugs_pass", [])
            di_sp_bugs = di_subprogram_bugs.get("bugs_file", {}).get("bugs_pass", [])
            di_var_bugs = di_variable_bugs.get("bugs_file", {}).get("bugs_pass", [])

            # Omit duplicated bugs.
            di_loc_set = set()
            di_sp_set = set()
            di_var_set = set()
            for bug in bugs:
                try:
                    bugs_metadata = bug["metadata"]
                except:
                    skipped_bugs += 1
                    continue

                if bugs_metadata == "DILocation":
                    try:
                        origin = bug.get("origin")
                        action = bug["action"]
                        bb_name = bug["bb-name"]
                        fn_name = bug["fn-name"]
                        instr = bug["instr"]
                    except:
                        skipped_bugs += 1
                        continue
                    di_loc_bug = DILocBug(origin, action, bb_name, fn_name, instr)
                    if not di_loc_bug.key() in di_loc_set:
                        di_loc_set.add(di_loc_bug.key())
                        if opts.reduce:
                            reduced_key = di_loc_bug.reduced_key(bugs_pass)
                            if not reduced_key in di_loc_reduced_set:
                                di_loc_reduced_set.add(reduced_key)
                                di_loc_bugs.append(di_loc_bug)
                        else:
                            di_loc_bugs.append(di_loc_bug)

                    # Fill the summary dict.
                    if bugs_pass in di_location_bugs_summary:
                        di_location_bugs_summary[bugs_pass] += 1
                    else:
                        di_location_bugs_summary[bugs_pass] = 1
                elif bugs_metadata == "DISubprogram":
                    try:
                        action = bug["action"]
                        name = bug["name"]
                    except:
                        skipped_bugs += 1
                        continue
                    di_sp_bug = DISPBug(action, name)
                    if not di_sp_bug.key() in di_sp_set:
                        di_sp_set.add(di_sp_bug.key())
                        if opts.reduce:
                            reduced_key = di_sp_bug.reduced_key(bugs_pass)
                            if not reduced_key in di_sp_reduced_set:
                                di_sp_reduced_set.add(reduced_key)
                                di_sp_bugs.append(di_sp_bug)
                        else:
                            di_sp_bugs.append(di_sp_bug)

                    # Fill the summary dict.
                    if bugs_pass in di_sp_bugs_summary:
                        di_sp_bugs_summary[bugs_pass] += 1
                    else:
                        di_sp_bugs_summary[bugs_pass] = 1
                elif bugs_metadata == "dbg-var-intrinsic":
                    try:
                        action = bug["action"]
                        fn_name = bug["fn-name"]
                        name = bug["name"]
                    except:
                        skipped_bugs += 1
                        continue
                    di_var_bug = DIVarBug(action, name, fn_name)
                    if not di_var_bug.key() in di_var_set:
                        di_var_set.add(di_var_bug.key())
                        if opts.reduce:
                            reduced_key = di_var_bug.reduced_key(bugs_pass)
                            if not reduced_key in di_var_reduced_set:
                                di_var_reduced_set.add(reduced_key)
                                di_var_bugs.append(di_var_bug)
                        else:
                            di_var_bugs.append(di_var_bug)

                    # Fill the summary dict.
                    if bugs_pass in di_var_bugs_summary:
                        di_var_bugs_summary[bugs_pass] += 1
                    else:
                        di_var_bugs_summary[bugs_pass] = 1
                else:
                    # Unsupported metadata.
                    skipped_bugs += 1
                    continue

            if di_loc_bugs:
                di_location_bugs[bugs_file][bugs_pass] = di_loc_bugs
            if di_sp_bugs:
                di_subprogram_bugs[bugs_file][bugs_pass] = di_sp_bugs
            if di_var_bugs:
                di_variable_bugs[bugs_file][bugs_pass] = di_var_bugs

    if opts.report_html_file is not None:
        generate_html_report(
            di_location_bugs,
            di_subprogram_bugs,
            di_variable_bugs,
            di_location_bugs_summary,
            di_sp_bugs_summary,
            di_var_bugs_summary,
            opts.report_html_file,
        )
    else:
        # Pretty(ish) print the detected bugs, but check if any exist first so that we don't print an empty dict.
        if di_location_bugs:
            print_bugs_yaml("DILocation Bugs", di_location_bugs)
        if di_subprogram_bugs:
            print_bugs_yaml("DISubprogram Bugs", di_subprogram_bugs)
        if di_variable_bugs:
            print_bugs_yaml("DIVariable Bugs", di_variable_bugs)

    if opts.acceptance_test:
        if any((di_location_bugs, di_subprogram_bugs, di_variable_bugs)):
            # Add a newline gap after printing at least one error.
            print()
            print(f"Errors detected for: {opts.file_name}")
            sys.exit(1)
        else:
            print(f"No errors detected for: {opts.file_name}")

    if skipped_lines > 0:
        print("Skipped lines: " + str(skipped_lines))
    if skipped_bugs > 0:
        print("Skipped bugs: " + str(skipped_bugs))


if __name__ == "__main__":
    Main()
    sys.exit(0)