Source Maps and Debug Information in Compilers

;; Without debug info
0x401000: mov [rbp-4], 5
0x401007: mov [rbp-8], 3
0x40100e: mov eax, [rbp-4]
0x401011: add eax, [rbp-8]
0x401014: mov [rbp-12], eax

;; With debug info
int main() {
    // 0x401000 line 5: int x = 5;
    // 0x401007 line 6: int y = 3;
    // 0x40100e line 7: int z = x + y;
}

{
  "version": 3,
  "file": "output.min.js",
  "sources": ["input.ts"],
  "names": ["add", "x", "y", "result"],
  "mappings": "AAAA,IAAIA,GAAG,CAACC,CAAD,EAAMC,CAAN;AAAA;AAAA,QAAYC,MAAM,GAAGF,CAAC,GAAGC,CAAzB;AAAA,SAAeC,MAAf;AAAA;AAAA,CAAX"
}

import base64

class SourceMapGenerator:
    def __init__(self, source_file, output_file):
        self.source_file = source_file
        self.output_file = output_file
        self.mappings = []
        self.names = []
        self.name_index = {}

    def add_mapping(self, gen_line, gen_col, source_line, source_col, name=None):
        entry = {
            "generated": (gen_line, gen_col),
            "source": (source_line, source_col)
        }
        if name:
            if name not in self.name_index:
                self.name_index[name] = len(self.names)
                self.names.append(name)
            entry["name"] = self.name_index[name]
        self.mappings.append(entry)

    def encode_vlq(self, value):
        # Simplified VLQ encoding
        vlq_map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
        if value < 0:
            value = ((-value) << 1) | 1
        else:
            value <<= 1
        result = []
        while value > 31:
            result.append(vlq_map[32 | (value & 31)])
            value >>= 5
        result.append(vlq_map[value & 31])
        return "".join(result)

    def generate(self):
        mapping_strings = []
        for m in self.mappings:
            parts = [
                self.encode_vlq(m["generated"][1]),
                self.encode_vlq(m["source"][0]),
                self.encode_vlq(m["source"][1]),
            ]
            if "name" in m:
                parts.append(self.encode_vlq(m["name"]))
            mapping_strings.append(",".join(parts))

        return {
            "version": 3,
            "file": self.output_file,
            "sources": [self.source_file],
            "names": self.names,
            "mappings": ";".join(mapping_strings),
            "sourceRoot": ""
        }

gen = SourceMapGenerator("input.ts", "output.js")
gen.add_mapping(0, 10, 0, 0, "add")
gen.add_mapping(0, 14, 0, 6, "x")
gen.add_mapping(0, 16, 0, 9, "y")
result = gen.generate()
print(f"Version: {result['version']}")
print(f"Sources: {result['sources']}")
print(f"Names: {result['names']}")

class DwarfDIE:
    def __init__(self, tag, attributes=None):
        self.tag = tag
        self.attributes = attributes or {}
        self.children = []

    def add_child(self, child):
        self.children.append(child)

    def print(self, indent=0):
        prefix = "  " * indent
        attrs = ", ".join(f"{k}: {v}" for k, v in self.attributes.items())
        print(f"{prefix}DIE {self.tag} ({attrs})")
        for child in self.children:
            child.print(indent + 1)

# Build a DWARF tree for a simple function
compile_unit = DwarfDIE("DW_TAG_compile_unit", {
    "DW_AT_name": "program.c",
    "DW_AT_language": "C99"
})

function = DwarfDIE("DW_TAG_subprogram", {
    "DW_AT_name": "main",
    "DW_AT_low_pc": "0x401000",
    "DW_AT_high_pc": "0x401050"
})

param_x = DwarfDIE("DW_TAG_formal_parameter", {
    "DW_AT_name": "x",
    "DW_AT_type": "int",
    "DW_AT_location": "reg:rdi"
})

function.add_child(param_x)
compile_unit.add_child(function)
compile_unit.print()

class DebugInfoEmitter:
    def __init__(self):
        self.line_number_program = []
        self.variable_table = []

    def emit_line(self, source_line, machine_addr):
        self.line_number_program.append({
            "source_line": source_line,
            "address": machine_addr
        })

    def emit_variable(self, name, type_name, scope, location):
        self.variable_table.append({
            "name": name,
            "type": type_name,
            "scope": scope,
            "location": location
        })

    def finalize(self):
        return {
            "line_table": self.line_number_program,
            "variables": self.variable_table
        }

debug = DebugInfoEmitter()
debug.emit_line(5, "0x401000")  # int x = 5
debug.emit_line(6, "0x401007")  # int y = 3
debug.emit_line(7, "0x40100e")  # int z = x + y
debug.emit_variable("x", "int", "main", "rbp-4")
debug.emit_variable("y", "int", "main", "rbp-8")
info = debug.finalize()
print("Line table:")
for entry in info["line_table"]:
    print(f"  Line {entry['source_line']} -> {entry['address']}")
print("Variables:")
for var in info["variables"]:
    print(f"  {var['name']}: {var['type']} at {var['location']}")