script: footprint: Improve C++ static variable reporting

Enhance the `size_report` script to correctly categorize static C++
variables in the memory report.

Static C++ variables are currently listed under the "No paths"
category in the size report. This occurs because the script's
address-based mapping logic is designed for functions, which
occupy an address range, but fails to handle variables that
have only a single memory address.

This commit improves the `do_address_range_matching` function
to handle single-address mappings. The updated logic now correctly
identifies and assigns static C++ variables to their corresponding
source file paths in the report tree, providing a more accurate and
comprehensive memory footprint analysis for C++ applications.

This enhancement ensures that all symbols, regardless of their
linkage or type, are correctly placed in the report, providing a
more accurate overview of memory usage.

Signed-off-by: Nilesh Vyas <[email protected]>

Author: nileshvyas

scripts/footprint/size_report

@@ -464,7 +464,7 @@ def do_address_range_matching(dwarfinfo, symbol_dict, processed):
             offset_map[die.offset] = die
 
         for die in cu_list[cu]['dies']:
-            if not die.tag == 'DW_TAG_subprogram':
+            if not (die.tag == 'DW_TAG_subprogram' or die.tag == 'DW_TAG_variable'):
                 continue
 
             path = None
@@ -507,16 +507,32 @@ def do_address_range_matching(dwarfinfo, symbol_dict, processed):
                 if low is None:
                     continue
 
-                for ums in unmapped_symbols:
-                    for one_sym in symbol_dict[ums]:
-                        symbol = one_sym['symbol']
-                        symaddr = symbol['st_value']
-
-                        if symaddr not in mapped_addresses:
-                            if low <= symaddr < high:
-                                one_sym['mapped_files'].add(path)
-                                mapped_addresses.add(symaddr)
-                                newly_mapped_syms.add(ums)
+                # Case 1: Match for a function (using a range)
+                if die.tag == 'DW_TAG_subprogram':
+                    for ums in unmapped_symbols:
+                        for one_sym in symbol_dict[ums]:
+                            symbol = one_sym['symbol']
+                            symaddr = symbol['st_value']
+
+                            if symaddr not in mapped_addresses:
+                                if low <= symaddr < high:
+                                    one_sym['mapped_files'].add(path)
+                                    mapped_addresses.add(symaddr)
+                                    newly_mapped_syms.add(ums)
+
+                # Case 2: Match for a variable (using a single address)
+                elif die.tag == 'DW_TAG_variable':
+                    for ums in unmapped_symbols:
+                        for one_sym in symbol_dict[ums]:
+                            symbol = one_sym['symbol']
+                            symaddr = symbol['st_value']
+
+                            if symaddr not in mapped_addresses:
+                                # We expect the 'high' value to be 'low + 1' for a variable
+                                if low == symaddr:
+                                    one_sym['mapped_files'].add(path)
+                                    mapped_addresses.add(symaddr)
+                                    newly_mapped_syms.add(ums)
 
     mapped_symbols = mapped_symbols.union(newly_mapped_syms)
     unmapped_symbols = unmapped_symbols.difference(newly_mapped_syms)