tools/binman/elf.py

   1 # SPDX-License-Identifier: GPL-2.0+
   2 # Copyright (c) 2016 Google, Inc
   3 # Written by Simon Glass <sjg@chromium.org>
   4 #
   5 # Handle various things related to ELF images
   6 #
   7
   8 from __future__ import print_function
   9
  10 from collections import namedtuple, OrderedDict
  11 import command
  12 import io
  13 import os
  14 import re
  15 import shutil
  16 import struct
  17 import tempfile
  18
  19 import tools
  20 import tout
  21
  22 ELF_TOOLS = True
  23 try:
  24     from elftools.elf.elffile import ELFFile
  25     from elftools.elf.sections import SymbolTableSection
  26 except:  # pragma: no cover
  27     ELF_TOOLS = False
  28
  29 Symbol = namedtuple('Symbol', ['section', 'address', 'size', 'weak'])
  30
  31 # Information about an ELF file:
  32 #    data: Extracted program contents of ELF file (this would be loaded by an
  33 #           ELF loader when reading this file
  34 #    load: Load address of code
  35 #    entry: Entry address of code
  36 #    memsize: Number of bytes in memory occupied by loading this ELF file
  37 ElfInfo = namedtuple('ElfInfo', ['data', 'load', 'entry', 'memsize'])
  38
  39
  40 def GetSymbols(fname, patterns):
  41     """Get the symbols from an ELF file
  42
  43     Args:
  44         fname: Filename of the ELF file to read
  45         patterns: List of regex patterns to search for, each a string
  46
  47     Returns:
  48         None, if the file does not exist, or Dict:
  49           key: Name of symbol
  50           value: Hex value of symbol
  51     """
  52     stdout = command.Output('objdump', '-t', fname, raise_on_error=False)
  53     lines = stdout.splitlines()
  54     if patterns:
  55         re_syms = re.compile('|'.join(patterns))
  56     else:
  57         re_syms = None
  58     syms = {}
  59     syms_started = False
  60     for line in lines:
  61         if not line or not syms_started:
  62             if 'SYMBOL TABLE' in line:
  63                 syms_started = True
  64             line = None  # Otherwise code coverage complains about 'continue'
  65             continue
  66         if re_syms and not re_syms.search(line):
  67             continue
  68
  69         space_pos = line.find(' ')
  70         value, rest = line[:space_pos], line[space_pos + 1:]
  71         flags = rest[:7]
  72         parts = rest[7:].split()
  73         section, size =  parts[:2]
  74         if len(parts) > 2:
  75             name = parts[2]
  76             syms[name] = Symbol(section, int(value, 16), int(size,16),
  77                                 flags[1] == 'w')
  78
  79     # Sort dict by address
  80     return OrderedDict(sorted(syms.items(), key=lambda x: x[1].address))
  81
  82 def GetSymbolAddress(fname, sym_name):
  83     """Get a value of a symbol from an ELF file
  84
  85     Args:
  86         fname: Filename of the ELF file to read
  87         patterns: List of regex patterns to search for, each a string
  88
  89     Returns:
  90         Symbol value (as an integer) or None if not found
  91     """
  92     syms = GetSymbols(fname, [sym_name])
  93     sym = syms.get(sym_name)
  94     if not sym:
  95         return None
  96     return sym.address
  97
  98 def LookupAndWriteSymbols(elf_fname, entry, section):
  99     """Replace all symbols in an entry with their correct values
 100
 101     The entry contents is updated so that values for referenced symbols will be
 102     visible at run time. This is done by finding out the symbols offsets in the
 103     entry (using the ELF file) and replacing them with values from binman's data
 104     structures.
 105
 106     Args:
 107         elf_fname: Filename of ELF image containing the symbol information for
 108             entry
 109         entry: Entry to process
 110         section: Section which can be used to lookup symbol values
 111     """
 112     fname = tools.GetInputFilename(elf_fname)
 113     syms = GetSymbols(fname, ['image', 'binman'])
 114     if not syms:
 115         return
 116     base = syms.get('__image_copy_start')
 117     if not base:
 118         return
 119     for name, sym in syms.items():
 120         if name.startswith('_binman'):
 121             msg = ("Section '%s': Symbol '%s'\n   in entry '%s'" %
 122                    (section.GetPath(), name, entry.GetPath()))
 123             offset = sym.address - base.address
 124             if offset < 0 or offset + sym.size > entry.contents_size:
 125                 raise ValueError('%s has offset %x (size %x) but the contents '
 126                                  'size is %x' % (entry.GetPath(), offset,
 127                                                  sym.size, entry.contents_size))
 128             if sym.size == 4:
 129                 pack_string = '<I'
 130             elif sym.size == 8:
 131                 pack_string = '<Q'
 132             else:
 133                 raise ValueError('%s has size %d: only 4 and 8 are supported' %
 134                                  (msg, sym.size))
 135
 136             # Look up the symbol in our entry tables.
 137             value = section.LookupSymbol(name, sym.weak, msg)
 138             if value is not None:
 139                 value += base.address
 140             else:
 141                 value = -1
 142                 pack_string = pack_string.lower()
 143             value_bytes = struct.pack(pack_string, value)
 144             tout.Debug('%s:\n   insert %s, offset %x, value %x, length %d' %
 145                        (msg, name, offset, value, len(value_bytes)))
 146             entry.data = (entry.data[:offset] + value_bytes +
 147                         entry.data[offset + sym.size:])
 148
 149 def MakeElf(elf_fname, text, data):
 150     """Make an elf file with the given data in a single section
 151
 152     The output file has a several section including '.text' and '.data',
 153     containing the info provided in arguments.
 154
 155     Args:
 156         elf_fname: Output filename
 157         text: Text (code) to put in the file's .text section
 158         data: Data to put in the file's .data section
 159     """
 160     outdir = tempfile.mkdtemp(prefix='binman.elf.')
 161     s_file = os.path.join(outdir, 'elf.S')
 162
 163     # Spilt the text into two parts so that we can make the entry point two
 164     # bytes after the start of the text section
 165     text_bytes1 = ['\t.byte\t%#x' % tools.ToByte(byte) for byte in text[:2]]
 166     text_bytes2 = ['\t.byte\t%#x' % tools.ToByte(byte) for byte in text[2:]]
 167     data_bytes = ['\t.byte\t%#x' % tools.ToByte(byte) for byte in data]
 168     with open(s_file, 'w') as fd:
 169         print('''/* Auto-generated C program to produce an ELF file for testing */
 170
 171 .section .text
 172 .code32
 173 .globl _start
 174 .type _start, @function
 175 %s
 176 _start:
 177 %s
 178 .ident "comment"
 179
 180 .comm fred,8,4
 181
 182 .section .empty
 183 .globl _empty
 184 _empty:
 185 .byte 1
 186
 187 .globl ernie
 188 .data
 189 .type ernie, @object
 190 .size ernie, 4
 191 ernie:
 192 %s
 193 ''' % ('\n'.join(text_bytes1), '\n'.join(text_bytes2), '\n'.join(data_bytes)),
 194         file=fd)
 195     lds_file = os.path.join(outdir, 'elf.lds')
 196
 197     # Use a linker script to set the alignment and text address.
 198     with open(lds_file, 'w') as fd:
 199         print('''/* Auto-generated linker script to produce an ELF file for testing */
 200
 201 PHDRS
 202 {
 203     text PT_LOAD ;
 204     data PT_LOAD ;
 205     empty PT_LOAD FLAGS ( 6 ) ;
 206     note PT_NOTE ;
 207 }
 208
 209 SECTIONS
 210 {
 211     . = 0xfef20000;
 212     ENTRY(_start)
 213     .text . : SUBALIGN(0)
 214     {
 215         *(.text)
 216     } :text
 217     .data : {
 218         *(.data)
 219     } :data
 220     _bss_start = .;
 221     .empty : {
 222         *(.empty)
 223     } :empty
 224     .note : {
 225         *(.comment)
 226     } :note
 227     .bss _bss_start  (OVERLAY) : {
 228         *(.bss)
 229     }
 230 }
 231 ''', file=fd)
 232     # -static: Avoid requiring any shared libraries
 233     # -nostdlib: Don't link with C library
 234     # -Wl,--build-id=none: Don't generate a build ID, so that we just get the
 235     #   text section at the start
 236     # -m32: Build for 32-bit x86
 237     # -T...: Specifies the link script, which sets the start address
 238     stdout = command.Output('cc', '-static', '-nostdlib', '-Wl,--build-id=none',
 239                             '-m32','-T', lds_file, '-o', elf_fname, s_file)
 240     shutil.rmtree(outdir)
 241
 242 def DecodeElf(data, location):
 243     """Decode an ELF file and return information about it
 244
 245     Args:
 246         data: Data from ELF file
 247         location: Start address of data to return
 248
 249     Returns:
 250         ElfInfo object containing information about the decoded ELF file
 251     """
 252     file_size = len(data)
 253     with io.BytesIO(data) as fd:
 254         elf = ELFFile(fd)
 255         data_start = 0xffffffff;
 256         data_end = 0;
 257         mem_end = 0;
 258         virt_to_phys = 0;
 259
 260         for i in range(elf.num_segments()):
 261             segment = elf.get_segment(i)
 262             if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
 263                 skipped = 1  # To make code-coverage see this line
 264                 continue
 265             start = segment['p_paddr']
 266             mend = start + segment['p_memsz']
 267             rend = start + segment['p_filesz']
 268             data_start = min(data_start, start)
 269             data_end = max(data_end, rend)
 270             mem_end = max(mem_end, mend)
 271             if not virt_to_phys:
 272                 virt_to_phys = segment['p_paddr'] - segment['p_vaddr']
 273
 274         output = bytearray(data_end - data_start)
 275         for i in range(elf.num_segments()):
 276             segment = elf.get_segment(i)
 277             if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
 278                 skipped = 1  # To make code-coverage see this line
 279                 continue
 280             start = segment['p_paddr']
 281             offset = 0
 282             if start < location:
 283                 offset = location - start
 284                 start = location
 285             # A legal ELF file can have a program header with non-zero length
 286             # but zero-length file size and a non-zero offset which, added
 287             # together, are greater than input->size (i.e. the total file size).
 288             #  So we need to not even test in the case that p_filesz is zero.
 289             # Note: All of this code is commented out since we don't have a test
 290             # case for it.
 291             size = segment['p_filesz']
 292             #if not size:
 293                 #continue
 294             #end = segment['p_offset'] + segment['p_filesz']
 295             #if end > file_size:
 296                 #raise ValueError('Underflow copying out the segment. File has %#x bytes left, segment end is %#x\n',
 297                                  #file_size, end)
 298             output[start - data_start:start - data_start + size] = (
 299                 segment.data()[offset:])
 300     return ElfInfo(output, data_start, elf.header['e_entry'] + virt_to_phys,
 301                    mem_end - data_start)