417 lines
16 KiB
Python
417 lines
16 KiB
Python
# pyinstaller --onefile --distpath ./parse_xml --workpath ./parse_xml/build --specpath ./build parse_xml/Src/parse_xml.py
|
||
# python -m nuitka --standalone --onefile --output-dir=./parse_xml parse_xml/Src/parse_xml.py
|
||
import xml.etree.ElementTree as ET
|
||
import xml.dom.minidom
|
||
import sys
|
||
import os
|
||
|
||
|
||
|
||
if len(sys.argv) < 3:
|
||
print("Usage: python parse_xml.exe <input.xml> <info.txt> [output.xml]")
|
||
sys.exit(1)
|
||
|
||
input_path = sys.argv[1]
|
||
info_path = sys.argv[2]
|
||
|
||
base_type_sizes = {
|
||
"char": 2,
|
||
"short": 2,
|
||
"int": 2,
|
||
"long": 4,
|
||
"long long": 8,
|
||
"float": 4,
|
||
"double": 8,
|
||
}
|
||
|
||
if len(sys.argv) >= 4:
|
||
output_path = sys.argv[3]
|
||
else:
|
||
input_dir = os.path.dirname(os.path.abspath(input_path))
|
||
output_path = os.path.join(input_dir, "simplified.xml")
|
||
|
||
tree = ET.parse(input_path)
|
||
root = tree.getroot()
|
||
|
||
def extract_timestamp(info_path):
|
||
with open(info_path, "r", encoding="utf-8") as f:
|
||
for line in f:
|
||
if "Time Stamp:" in line:
|
||
parts = line.split("Time Stamp:")
|
||
if len(parts) > 1:
|
||
timestamp = parts[1].strip()
|
||
return timestamp
|
||
|
||
|
||
|
||
die_by_id = {die.attrib.get("id"): die for die in root.iter("die") if "id" in die.attrib}
|
||
|
||
def get_attr(die, attr_type):
|
||
for attr in die.findall("attribute"):
|
||
type_elem = attr.find("type")
|
||
if type_elem is not None and type_elem.text == attr_type:
|
||
return attr.find("value")
|
||
return None
|
||
|
||
def get_die_size(die):
|
||
"""Вернуть размер DIE в байтах из атрибута DW_AT_byte_size или по ключевым словам имени типа."""
|
||
|
||
# Сначала пытаемся получить размер из DW_AT_byte_size
|
||
for attr in die.findall("attribute"):
|
||
type_elem = attr.find("type")
|
||
if type_elem is not None and type_elem.text == "DW_AT_byte_size":
|
||
const_elem = attr.find("value/const")
|
||
if const_elem is not None:
|
||
return int(const_elem.text, 0)
|
||
|
||
# Если не нашли, пробуем определить размер по ключевым словам в имени типа
|
||
name_elem = die.find("attribute[@name='DW_AT_name']/value/const")
|
||
if name_elem is not None:
|
||
type_name = name_elem.text.lower()
|
||
|
||
for key, size in base_type_sizes.items():
|
||
if key in type_name:
|
||
return size
|
||
|
||
return None
|
||
|
||
def resolve_type_die(type_id):
|
||
"""Получить DIE типа, разрешая typedef, const и volatile."""
|
||
visited = set()
|
||
while type_id and type_id not in visited:
|
||
visited.add(type_id)
|
||
die = die_by_id.get(type_id)
|
||
if die is None:
|
||
return None
|
||
tag = die.findtext("tag")
|
||
if tag in ("DW_TAG_volatile_type", "DW_TAG_const_type", "DW_TAG_typedef", "DW_TAG_TI_far_type"):
|
||
ref = get_attr(die, "DW_AT_type")
|
||
if ref is not None and ref.find("ref") is not None:
|
||
type_id = ref.find("ref").attrib.get("idref")
|
||
else:
|
||
return None
|
||
else:
|
||
return die
|
||
return None
|
||
|
||
# Словарь для простых базовых типов по тегам (пример)
|
||
base_types_map = {
|
||
"DW_TAG_base_type": lambda die: die.find("attribute[@type='DW_AT_name']/value/string").text if die.find("attribute[@type='DW_AT_name']/value/string") is not None else "unknown",
|
||
"DW_TAG_structure_type": lambda die: "struct",
|
||
"DW_TAG_union_type": lambda die: "union",
|
||
"DW_TAG_pointer_type": lambda die: "pointer",
|
||
"DW_TAG_array_type": lambda die: "array",
|
||
}
|
||
|
||
def get_type_name(type_id):
|
||
die = resolve_type_die(type_id)
|
||
if die is None:
|
||
return "unknown"
|
||
|
||
tag = die.findtext("tag")
|
||
|
||
if tag == "DW_TAG_pointer_type":
|
||
ref = get_attr(die, "DW_AT_type")
|
||
if ref is not None and ref.find("ref") is not None:
|
||
pointee_id = ref.find("ref").attrib.get("idref")
|
||
name = get_type_name(pointee_id)
|
||
return name + "*" if name != "unknown" else name
|
||
else:
|
||
return "void*"
|
||
|
||
elif tag == "DW_TAG_base_type":
|
||
name_attr = get_attr(die, "DW_AT_name")
|
||
if name_attr is not None:
|
||
return name_attr.findtext("string")
|
||
else:
|
||
return "base_type_unknown"
|
||
|
||
elif tag == "DW_TAG_structure_type":
|
||
name_attr = get_attr(die, "DW_AT_name")
|
||
name = name_attr.findtext("string") if name_attr is not None else "anonymous_struct"
|
||
return f"struct {name}"
|
||
|
||
elif tag == "DW_TAG_union_type":
|
||
name_attr = get_attr(die, "DW_AT_name")
|
||
name = name_attr.findtext("string") if name_attr is not None else "anonymous_union"
|
||
return f"union {name}"
|
||
|
||
elif tag == "DW_TAG_array_type":
|
||
ref = get_attr(die, "DW_AT_type")
|
||
if ref is not None and ref.find("ref") is not None:
|
||
element_type_id = ref.find("ref").attrib.get("idref")
|
||
element_type_name = get_type_name(element_type_id)
|
||
return f"{element_type_name}[]"
|
||
else:
|
||
return "array[]"
|
||
|
||
# Добавляем поддержку enum
|
||
elif tag == "DW_TAG_enumeration_type":
|
||
name_attr = get_attr(die, "DW_AT_name")
|
||
name = name_attr.findtext("string") if name_attr is not None else "anonymous_enum"
|
||
return f"enum {name}"
|
||
|
||
else:
|
||
return "unknown"
|
||
|
||
def parse_offset(offset_text):
|
||
if offset_text and offset_text.startswith("DW_OP_plus_uconst "):
|
||
return int(offset_text.split()[-1], 0)
|
||
return 0
|
||
|
||
|
||
|
||
def get_base_type_die(array_die):
|
||
"""Спускаемся по цепочке DW_AT_type, пока не дойдем до не-массива (базового типа)."""
|
||
current_die = array_die
|
||
while True:
|
||
ref = get_attr(current_die, "DW_AT_type")
|
||
if ref is None or ref.find("ref") is None:
|
||
break
|
||
next_die = resolve_type_die(ref.find("ref").attrib.get("idref"))
|
||
if next_die is None:
|
||
break
|
||
if next_die.findtext("tag") == "DW_TAG_array_type":
|
||
current_die = next_die
|
||
else:
|
||
return next_die
|
||
return current_die
|
||
|
||
def get_array_dimensions(array_die):
|
||
dims = []
|
||
# Итерируем по всем DIE с тегом DW_TAG_subrange_type, потомки текущего массива
|
||
for child in array_die.findall("die"):
|
||
if child.findtext("tag") != "DW_TAG_subrange_type":
|
||
continue
|
||
|
||
dim_size = None
|
||
ub_attr = get_attr(child, "DW_AT_upper_bound")
|
||
if ub_attr is not None:
|
||
# Попробуем разные варианты получить значение upper_bound
|
||
# 1) value/const
|
||
val_const = ub_attr.find("const")
|
||
if val_const is not None:
|
||
try:
|
||
dim_size = int(val_const.text, 0) + 1
|
||
#print(f"[DEBUG] Found DW_AT_upper_bound const: {val_const.text}, size={dim_size}")
|
||
except Exception as e:
|
||
a=1#print(f"[WARN] Error parsing upper_bound const: {e}")
|
||
else:
|
||
# 2) value/block (DW_OP_constu / DW_OP_plus_uconst, etc.)
|
||
val_block = ub_attr.find("block")
|
||
if val_block is not None:
|
||
block_text = val_block.text
|
||
# Можно попытаться парсить DWARF expr (например DW_OP_plus_uconst 7)
|
||
if block_text and "DW_OP_plus_uconst" in block_text:
|
||
try:
|
||
parts = block_text.split()
|
||
val = int(parts[-1], 0)
|
||
dim_size = val + 1
|
||
#print(f"[DEBUG] Parsed upper_bound block: {val} + 1 = {dim_size}")
|
||
except Exception as e:
|
||
a=1#print(f"[WARN] Error parsing upper_bound block: {e}")
|
||
else:
|
||
a=1#print(f"[WARN] Unexpected DW_AT_upper_bound block content: {block_text}")
|
||
else:
|
||
a=1#print(f"[WARN] DW_AT_upper_bound has no const or block value")
|
||
|
||
if dim_size is None:
|
||
# fallback по DW_AT_count — редко встречается
|
||
ct_attr = get_attr(child, "DW_AT_count")
|
||
if ct_attr is not None:
|
||
val_const = ct_attr.find("value/const")
|
||
if val_const is not None:
|
||
try:
|
||
dim_size = int(val_const.text, 0)
|
||
#print(f"[DEBUG] Found DW_AT_count: {dim_size}")
|
||
except Exception as e:
|
||
a=1#print(f"[WARN] Error parsing DW_AT_count const: {e}")
|
||
|
||
if dim_size is None:
|
||
print("[DEBUG] No dimension size found for this subrange, defaulting to 0")
|
||
dim_size = 0
|
||
|
||
dims.append(dim_size)
|
||
|
||
# Если не нашли измерений — пытаемся вычислить размер массива по общему размеру
|
||
if not dims:
|
||
arr_size = get_die_size(array_die)
|
||
elem_size = None
|
||
element_type_ref = get_attr(array_die, "DW_AT_type")
|
||
if element_type_ref is not None and element_type_ref.find("ref") is not None:
|
||
element_type_id = element_type_ref.find("ref").attrib.get("idref")
|
||
elem_die = resolve_type_die(element_type_id)
|
||
if elem_die is not None:
|
||
elem_size = get_die_size(elem_die)
|
||
#print(f"[DEBUG] Fallback: arr_size={arr_size}, elem_size={elem_size}")
|
||
|
||
if arr_size is not None and elem_size:
|
||
dim_calc = arr_size // elem_size
|
||
dims.append(dim_calc)
|
||
#print(f"[DEBUG] Calculated dimension size from total size: {dim_calc}")
|
||
else:
|
||
dims.append(0)
|
||
print("[DEBUG] Could not calculate dimension size, set 0")
|
||
|
||
# Рекурсивно обрабатываем вложенные массивы
|
||
element_type_ref = get_attr(array_die, "DW_AT_type")
|
||
if element_type_ref is not None and element_type_ref.find("ref") is not None:
|
||
element_type_id = element_type_ref.find("ref").attrib.get("idref")
|
||
element_type_die = resolve_type_die(element_type_id)
|
||
if element_type_die is not None and element_type_die.findtext("tag") == "DW_TAG_array_type":
|
||
dims.extend(get_array_dimensions(element_type_die))
|
||
|
||
#print(f"[DEBUG] Array dimensions: {dims}")
|
||
return dims
|
||
|
||
|
||
|
||
def handle_array_type(member_elem, resolved_type, offset=0):
|
||
dims = get_array_dimensions(resolved_type)
|
||
|
||
base_die = get_base_type_die(resolved_type)
|
||
base_name = "unknown"
|
||
base_size = None
|
||
if base_die is not None:
|
||
base_id = base_die.attrib.get("id")
|
||
if base_id:
|
||
base_name = get_type_name(base_id)
|
||
base_size = get_die_size(base_die)
|
||
else:
|
||
base_name = get_type_name(base_die.attrib.get("id", ""))
|
||
#print(f"[DEBUG] Base type name: {base_name}, base size: {base_size}")
|
||
|
||
member_elem.set("type", base_name + "[]" * len(dims))
|
||
|
||
if base_size is None:
|
||
base_size = 0
|
||
|
||
total_elements = 1
|
||
for d in dims:
|
||
if d == 0:
|
||
total_elements = 0
|
||
print(f"[WARN] Dimension size is zero, setting total elements to 0")
|
||
break
|
||
total_elements *= d
|
||
|
||
total_size = total_elements * base_size if base_size is not None else 0
|
||
if total_size:
|
||
member_elem.set("size", str(base_size if base_size is not None else 1))
|
||
else:
|
||
arr_size = get_die_size(resolved_type)
|
||
if arr_size:
|
||
member_elem.set("size", str(arr_size))
|
||
#print(f"[DEBUG] Used fallback size from resolved_type: {arr_size}")
|
||
else:
|
||
print(f"[WARN] Could not determine total size for array")
|
||
|
||
for i, dim in enumerate(dims, 1):
|
||
member_elem.set(f"size{i}", str(dim))
|
||
#print(f"[DEBUG] Setting size{i} = {dim}")
|
||
|
||
member_elem.set("kind", "array")
|
||
|
||
if base_die is not None and base_die.findtext("tag") == "DW_TAG_structure_type":
|
||
add_members_recursive(member_elem, base_die, offset)
|
||
|
||
|
||
|
||
|
||
|
||
def add_members_recursive(parent_elem, struct_die, base_offset=0):
|
||
is_union = struct_die.findtext("tag") == "DW_TAG_union_type"
|
||
size = get_die_size(struct_die)
|
||
if size is not None:
|
||
parent_elem.set("size", hex(size))
|
||
|
||
for member in struct_die.findall("die"):
|
||
if member.findtext("tag") != "DW_TAG_member":
|
||
continue
|
||
|
||
name_attr = get_attr(member, "DW_AT_name")
|
||
offset_attr = get_attr(member, "DW_AT_data_member_location")
|
||
type_attr = get_attr(member, "DW_AT_type")
|
||
if name_attr is None or offset_attr is None or type_attr is None:
|
||
continue
|
||
|
||
name = name_attr.findtext("string")
|
||
offset = parse_offset(offset_attr.findtext("block")) + base_offset
|
||
type_id = type_attr.find("ref").attrib.get("idref")
|
||
resolved_type = resolve_type_die(type_id)
|
||
type_name = get_type_name(type_id)
|
||
if type_name == "unknown":
|
||
continue
|
||
|
||
member_elem = ET.SubElement(parent_elem, "member", name=name, offset=hex(offset), type=type_name)
|
||
if is_union:
|
||
member_elem.set("kind", "union")
|
||
|
||
if resolved_type is not None:
|
||
tag = resolved_type.findtext("tag")
|
||
if tag == "DW_TAG_array_type":
|
||
handle_array_type(member_elem, resolved_type, offset)
|
||
elif tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
|
||
member_elem.set("type", type_name)
|
||
add_members_recursive(member_elem, resolved_type, offset)
|
||
elif tag == "DW_TAG_pointer_type":
|
||
# Проверяем тип, на который указывает указатель
|
||
pointee_ref = get_attr(resolved_type, "DW_AT_type")
|
||
if pointee_ref is not None and pointee_ref.find("ref") is not None:
|
||
pointee_id = pointee_ref.find("ref").attrib.get("idref")
|
||
pointee_die = resolve_type_die(pointee_id)
|
||
if pointee_die is not None:
|
||
pointee_tag = pointee_die.findtext("tag")
|
||
if pointee_tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
|
||
# Добавляем подэлементы для структуры, на которую указывает указатель
|
||
pointer_elem = ET.SubElement(member_elem, "pointee", type=get_type_name(pointee_id))
|
||
add_members_recursive(pointer_elem, pointee_die, 0)
|
||
|
||
|
||
|
||
output_root = ET.Element("variables")
|
||
for die in root.iter("die"):
|
||
if die.findtext("tag") != "DW_TAG_variable":
|
||
continue
|
||
|
||
name_attr = get_attr(die, "DW_AT_name")
|
||
addr_attr = get_attr(die, "DW_AT_location")
|
||
type_attr = get_attr(die, "DW_AT_type")
|
||
if name_attr is None or addr_attr is None or type_attr is None:
|
||
continue
|
||
|
||
name = name_attr.findtext("string")
|
||
if "$" in name:
|
||
continue
|
||
|
||
addr_text = addr_attr.findtext("block")
|
||
if not addr_text or not addr_text.startswith("DW_OP_addr "):
|
||
continue
|
||
|
||
addr = int(addr_text.split()[-1], 0)
|
||
type_id = type_attr.find("ref").attrib.get("idref")
|
||
resolved_type = resolve_type_die(type_id)
|
||
type_name = get_type_name(type_id)
|
||
if 0x800 <= addr < 0x8000 or type_name == "unknown":
|
||
continue
|
||
|
||
var_elem = ET.SubElement(output_root, "variable", name=name, address=hex(addr), type=type_name)
|
||
if resolved_type is not None:
|
||
tag = resolved_type.findtext("tag")
|
||
if tag == "DW_TAG_array_type":
|
||
handle_array_type(var_elem, resolved_type)
|
||
elif tag in ("DW_TAG_structure_type", "DW_TAG_union_type"):
|
||
add_members_recursive(var_elem, resolved_type)
|
||
|
||
timestamp = extract_timestamp(info_path)
|
||
timestamp_elem = ET.Element("timestamp")
|
||
timestamp_elem.text = timestamp
|
||
output_root.insert(0, timestamp_elem)
|
||
|
||
rough_string = ET.tostring(output_root, encoding="utf-8")
|
||
pretty_xml = xml.dom.minidom.parseString(rough_string).toprettyxml(indent=" ")
|
||
with open(output_path, "w", encoding="utf-8") as f:
|
||
f.write(pretty_xml)
|
||
|
||
os.remove(input_path)
|
||
os.remove(info_path)
|
||
print(f"Simplified and formatted XML saved to: {output_path}") |