2018-05-06 21:58:06 +00:00
|
|
|
# SPDX-License-Identifier: GPL-2.0+
|
2017-11-14 01:54:54 +00:00
|
|
|
# Copyright (c) 2016 Google, Inc
|
|
|
|
# Written by Simon Glass <sjg@chromium.org>
|
|
|
|
#
|
|
|
|
# Handle various things related to ELF images
|
|
|
|
#
|
|
|
|
|
|
|
|
from collections import namedtuple, OrderedDict
|
2019-07-08 19:18:35 +00:00
|
|
|
import io
|
2017-11-14 01:54:54 +00:00
|
|
|
import os
|
|
|
|
import re
|
2019-07-08 19:18:34 +00:00
|
|
|
import shutil
|
2017-11-14 01:54:54 +00:00
|
|
|
import struct
|
2019-07-08 19:18:34 +00:00
|
|
|
import tempfile
|
2017-11-14 01:54:54 +00:00
|
|
|
|
2020-04-18 00:09:04 +00:00
|
|
|
from patman import command
|
|
|
|
from patman import tools
|
|
|
|
from patman import tout
|
2017-11-14 01:54:54 +00:00
|
|
|
|
2019-07-08 19:18:35 +00:00
|
|
|
ELF_TOOLS = True
|
|
|
|
try:
|
|
|
|
from elftools.elf.elffile import ELFFile
|
|
|
|
from elftools.elf.sections import SymbolTableSection
|
|
|
|
except: # pragma: no cover
|
|
|
|
ELF_TOOLS = False
|
|
|
|
|
2017-11-14 01:54:54 +00:00
|
|
|
Symbol = namedtuple('Symbol', ['section', 'address', 'size', 'weak'])
|
|
|
|
|
2019-07-08 19:18:35 +00:00
|
|
|
# Information about an ELF file:
|
|
|
|
# data: Extracted program contents of ELF file (this would be loaded by an
|
|
|
|
# ELF loader when reading this file
|
|
|
|
# load: Load address of code
|
|
|
|
# entry: Entry address of code
|
|
|
|
# memsize: Number of bytes in memory occupied by loading this ELF file
|
|
|
|
ElfInfo = namedtuple('ElfInfo', ['data', 'load', 'entry', 'memsize'])
|
|
|
|
|
2017-11-14 01:54:54 +00:00
|
|
|
|
|
|
|
def GetSymbols(fname, patterns):
|
|
|
|
"""Get the symbols from an ELF file
|
|
|
|
|
|
|
|
Args:
|
|
|
|
fname: Filename of the ELF file to read
|
|
|
|
patterns: List of regex patterns to search for, each a string
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
None, if the file does not exist, or Dict:
|
|
|
|
key: Name of symbol
|
|
|
|
value: Hex value of symbol
|
|
|
|
"""
|
2019-08-24 13:22:52 +00:00
|
|
|
stdout = tools.Run('objdump', '-t', fname)
|
2017-11-14 01:54:54 +00:00
|
|
|
lines = stdout.splitlines()
|
|
|
|
if patterns:
|
|
|
|
re_syms = re.compile('|'.join(patterns))
|
|
|
|
else:
|
|
|
|
re_syms = None
|
|
|
|
syms = {}
|
|
|
|
syms_started = False
|
|
|
|
for line in lines:
|
|
|
|
if not line or not syms_started:
|
|
|
|
if 'SYMBOL TABLE' in line:
|
|
|
|
syms_started = True
|
|
|
|
line = None # Otherwise code coverage complains about 'continue'
|
|
|
|
continue
|
|
|
|
if re_syms and not re_syms.search(line):
|
|
|
|
continue
|
|
|
|
|
|
|
|
space_pos = line.find(' ')
|
|
|
|
value, rest = line[:space_pos], line[space_pos + 1:]
|
|
|
|
flags = rest[:7]
|
|
|
|
parts = rest[7:].split()
|
|
|
|
section, size = parts[:2]
|
|
|
|
if len(parts) > 2:
|
2019-08-24 13:22:46 +00:00
|
|
|
name = parts[2] if parts[2] != '.hidden' else parts[3]
|
2017-11-14 01:54:54 +00:00
|
|
|
syms[name] = Symbol(section, int(value, 16), int(size,16),
|
|
|
|
flags[1] == 'w')
|
2018-07-17 19:25:24 +00:00
|
|
|
|
|
|
|
# Sort dict by address
|
2019-05-14 21:53:41 +00:00
|
|
|
return OrderedDict(sorted(syms.items(), key=lambda x: x[1].address))
|
2017-11-14 01:54:54 +00:00
|
|
|
|
|
|
|
def GetSymbolAddress(fname, sym_name):
|
|
|
|
"""Get a value of a symbol from an ELF file
|
|
|
|
|
|
|
|
Args:
|
|
|
|
fname: Filename of the ELF file to read
|
|
|
|
patterns: List of regex patterns to search for, each a string
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
Symbol value (as an integer) or None if not found
|
|
|
|
"""
|
|
|
|
syms = GetSymbols(fname, [sym_name])
|
|
|
|
sym = syms.get(sym_name)
|
|
|
|
if not sym:
|
|
|
|
return None
|
|
|
|
return sym.address
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
|
2018-06-01 15:38:13 +00:00
|
|
|
def LookupAndWriteSymbols(elf_fname, entry, section):
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
"""Replace all symbols in an entry with their correct values
|
|
|
|
|
|
|
|
The entry contents is updated so that values for referenced symbols will be
|
2018-08-01 21:22:37 +00:00
|
|
|
visible at run time. This is done by finding out the symbols offsets in the
|
|
|
|
entry (using the ELF file) and replacing them with values from binman's data
|
|
|
|
structures.
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
|
|
|
|
Args:
|
|
|
|
elf_fname: Filename of ELF image containing the symbol information for
|
|
|
|
entry
|
|
|
|
entry: Entry to process
|
2018-06-01 15:38:13 +00:00
|
|
|
section: Section which can be used to lookup symbol values
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
"""
|
|
|
|
fname = tools.GetInputFilename(elf_fname)
|
|
|
|
syms = GetSymbols(fname, ['image', 'binman'])
|
|
|
|
if not syms:
|
|
|
|
return
|
|
|
|
base = syms.get('__image_copy_start')
|
|
|
|
if not base:
|
|
|
|
return
|
2019-05-14 21:53:41 +00:00
|
|
|
for name, sym in syms.items():
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
if name.startswith('_binman'):
|
2018-06-01 15:38:13 +00:00
|
|
|
msg = ("Section '%s': Symbol '%s'\n in entry '%s'" %
|
|
|
|
(section.GetPath(), name, entry.GetPath()))
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
offset = sym.address - base.address
|
|
|
|
if offset < 0 or offset + sym.size > entry.contents_size:
|
|
|
|
raise ValueError('%s has offset %x (size %x) but the contents '
|
|
|
|
'size is %x' % (entry.GetPath(), offset,
|
|
|
|
sym.size, entry.contents_size))
|
|
|
|
if sym.size == 4:
|
|
|
|
pack_string = '<I'
|
|
|
|
elif sym.size == 8:
|
|
|
|
pack_string = '<Q'
|
|
|
|
else:
|
|
|
|
raise ValueError('%s has size %d: only 4 and 8 are supported' %
|
|
|
|
(msg, sym.size))
|
|
|
|
|
|
|
|
# Look up the symbol in our entry tables.
|
2021-01-07 04:35:15 +00:00
|
|
|
value = section.GetImage().LookupImageSymbol(name, sym.weak, msg,
|
|
|
|
base.address)
|
2019-10-21 03:31:34 +00:00
|
|
|
if value is None:
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
value = -1
|
|
|
|
pack_string = pack_string.lower()
|
|
|
|
value_bytes = struct.pack(pack_string, value)
|
2019-07-20 18:23:36 +00:00
|
|
|
tout.Debug('%s:\n insert %s, offset %x, value %x, length %d' %
|
|
|
|
(msg, name, offset, value, len(value_bytes)))
|
binman: Support accessing binman tables at run time
Binman construct images consisting of multiple binary files. These files
sometimes need to know (at run timme) where their peers are located. For
example, SPL may want to know where U-Boot is located in the image, so
that it can jump to U-Boot correctly on boot.
In general the positions where the binaries end up after binman has
finished packing them cannot be known at compile time. One reason for
this is that binman does not know the size of the binaries until
everything is compiled, linked and converted to binaries with objcopy.
To make this work, we add a feature to binman which checks each binary
for symbol names starting with '_binman'. These are then decoded to figure
out which entry and property they refer to. Then binman writes the value
of this symbol into the appropriate binary. With this, the symbol will
have the correct value at run time.
Macros are used to make this easier to use. As an example, this declares
a symbol that will access the 'u-boot-spl' entry to find the 'pos' value
(i.e. the position of SPL in the image):
binman_sym_declare(unsigned long, u_boot_spl, pos);
This converts to a symbol called '_binman_u_boot_spl_prop_pos' in any
binary that includes it. Binman then updates the value in that binary,
ensuring that it can be accessed at runtime with:
ulong u_boot_pos = binman_sym(ulong, u_boot_spl, pos);
This assigns the variable u_boot_pos to the position of SPL in the image.
Signed-off-by: Simon Glass <sjg@chromium.org>
2017-11-14 01:55:01 +00:00
|
|
|
entry.data = (entry.data[:offset] + value_bytes +
|
|
|
|
entry.data[offset + sym.size:])
|
2019-07-08 19:18:34 +00:00
|
|
|
|
|
|
|
def MakeElf(elf_fname, text, data):
|
|
|
|
"""Make an elf file with the given data in a single section
|
|
|
|
|
|
|
|
The output file has a several section including '.text' and '.data',
|
|
|
|
containing the info provided in arguments.
|
|
|
|
|
|
|
|
Args:
|
|
|
|
elf_fname: Output filename
|
|
|
|
text: Text (code) to put in the file's .text section
|
|
|
|
data: Data to put in the file's .data section
|
|
|
|
"""
|
|
|
|
outdir = tempfile.mkdtemp(prefix='binman.elf.')
|
|
|
|
s_file = os.path.join(outdir, 'elf.S')
|
|
|
|
|
|
|
|
# Spilt the text into two parts so that we can make the entry point two
|
|
|
|
# bytes after the start of the text section
|
2020-11-09 03:36:19 +00:00
|
|
|
text_bytes1 = ['\t.byte\t%#x' % byte for byte in text[:2]]
|
|
|
|
text_bytes2 = ['\t.byte\t%#x' % byte for byte in text[2:]]
|
|
|
|
data_bytes = ['\t.byte\t%#x' % byte for byte in data]
|
2019-07-08 19:18:34 +00:00
|
|
|
with open(s_file, 'w') as fd:
|
|
|
|
print('''/* Auto-generated C program to produce an ELF file for testing */
|
|
|
|
|
|
|
|
.section .text
|
|
|
|
.code32
|
|
|
|
.globl _start
|
|
|
|
.type _start, @function
|
|
|
|
%s
|
|
|
|
_start:
|
|
|
|
%s
|
|
|
|
.ident "comment"
|
|
|
|
|
|
|
|
.comm fred,8,4
|
|
|
|
|
|
|
|
.section .empty
|
|
|
|
.globl _empty
|
|
|
|
_empty:
|
|
|
|
.byte 1
|
|
|
|
|
|
|
|
.globl ernie
|
|
|
|
.data
|
|
|
|
.type ernie, @object
|
|
|
|
.size ernie, 4
|
|
|
|
ernie:
|
|
|
|
%s
|
|
|
|
''' % ('\n'.join(text_bytes1), '\n'.join(text_bytes2), '\n'.join(data_bytes)),
|
|
|
|
file=fd)
|
|
|
|
lds_file = os.path.join(outdir, 'elf.lds')
|
|
|
|
|
|
|
|
# Use a linker script to set the alignment and text address.
|
|
|
|
with open(lds_file, 'w') as fd:
|
|
|
|
print('''/* Auto-generated linker script to produce an ELF file for testing */
|
|
|
|
|
|
|
|
PHDRS
|
|
|
|
{
|
|
|
|
text PT_LOAD ;
|
|
|
|
data PT_LOAD ;
|
|
|
|
empty PT_LOAD FLAGS ( 6 ) ;
|
|
|
|
note PT_NOTE ;
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTIONS
|
|
|
|
{
|
|
|
|
. = 0xfef20000;
|
|
|
|
ENTRY(_start)
|
|
|
|
.text . : SUBALIGN(0)
|
|
|
|
{
|
|
|
|
*(.text)
|
|
|
|
} :text
|
|
|
|
.data : {
|
|
|
|
*(.data)
|
|
|
|
} :data
|
|
|
|
_bss_start = .;
|
|
|
|
.empty : {
|
|
|
|
*(.empty)
|
|
|
|
} :empty
|
2019-08-24 13:22:45 +00:00
|
|
|
/DISCARD/ : {
|
|
|
|
*(.note.gnu.property)
|
|
|
|
}
|
2019-07-08 19:18:34 +00:00
|
|
|
.note : {
|
|
|
|
*(.comment)
|
|
|
|
} :note
|
|
|
|
.bss _bss_start (OVERLAY) : {
|
|
|
|
*(.bss)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
''', file=fd)
|
|
|
|
# -static: Avoid requiring any shared libraries
|
|
|
|
# -nostdlib: Don't link with C library
|
|
|
|
# -Wl,--build-id=none: Don't generate a build ID, so that we just get the
|
|
|
|
# text section at the start
|
|
|
|
# -m32: Build for 32-bit x86
|
|
|
|
# -T...: Specifies the link script, which sets the start address
|
binman: Use target-specific tools when cross-compiling
Currently, binman always runs the compile tools like cc, objcopy, strip,
etc. using their literal name. Instead, this patch makes it use the
target-specific versions by default, derived from the tool-specific
environment variables (CC, OBJCOPY, STRIP, etc.) or from the
CROSS_COMPILE environment variable.
For example, the u-boot-elf etype directly uses 'strip'. Trying to run
the tests with 'CROSS_COMPILE=i686-linux-gnu- binman test' on an arm64
host results in the '097_elf_strip.dts' test to fail as the arm64
version of 'strip' can't understand the format of the x86 ELF file.
This also adjusts some command.Output() calls that caused test errors or
failures to use the target versions of the tools they call. After this,
patch, an arm64 host can run all tests with no errors or failures using
a correct CROSS_COMPILE value.
Signed-off-by: Alper Nebi Yasak <alpernebiyasak@gmail.com>
Reviewed-by: Simon Glass <sjg@chromium.org>
2020-09-06 11:46:05 +00:00
|
|
|
cc, args = tools.GetTargetCompileTool('cc')
|
|
|
|
args += ['-static', '-nostdlib', '-Wl,--build-id=none', '-m32', '-T',
|
|
|
|
lds_file, '-o', elf_fname, s_file]
|
|
|
|
stdout = command.Output(cc, *args)
|
2019-07-08 19:18:34 +00:00
|
|
|
shutil.rmtree(outdir)
|
2019-07-08 19:18:35 +00:00
|
|
|
|
|
|
|
def DecodeElf(data, location):
|
|
|
|
"""Decode an ELF file and return information about it
|
|
|
|
|
|
|
|
Args:
|
|
|
|
data: Data from ELF file
|
|
|
|
location: Start address of data to return
|
|
|
|
|
|
|
|
Returns:
|
|
|
|
ElfInfo object containing information about the decoded ELF file
|
|
|
|
"""
|
|
|
|
file_size = len(data)
|
|
|
|
with io.BytesIO(data) as fd:
|
|
|
|
elf = ELFFile(fd)
|
|
|
|
data_start = 0xffffffff;
|
|
|
|
data_end = 0;
|
|
|
|
mem_end = 0;
|
|
|
|
virt_to_phys = 0;
|
|
|
|
|
|
|
|
for i in range(elf.num_segments()):
|
|
|
|
segment = elf.get_segment(i)
|
|
|
|
if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
|
|
|
|
skipped = 1 # To make code-coverage see this line
|
|
|
|
continue
|
|
|
|
start = segment['p_paddr']
|
|
|
|
mend = start + segment['p_memsz']
|
|
|
|
rend = start + segment['p_filesz']
|
|
|
|
data_start = min(data_start, start)
|
|
|
|
data_end = max(data_end, rend)
|
|
|
|
mem_end = max(mem_end, mend)
|
|
|
|
if not virt_to_phys:
|
|
|
|
virt_to_phys = segment['p_paddr'] - segment['p_vaddr']
|
|
|
|
|
|
|
|
output = bytearray(data_end - data_start)
|
|
|
|
for i in range(elf.num_segments()):
|
|
|
|
segment = elf.get_segment(i)
|
|
|
|
if segment['p_type'] != 'PT_LOAD' or not segment['p_memsz']:
|
|
|
|
skipped = 1 # To make code-coverage see this line
|
|
|
|
continue
|
|
|
|
start = segment['p_paddr']
|
|
|
|
offset = 0
|
|
|
|
if start < location:
|
|
|
|
offset = location - start
|
|
|
|
start = location
|
|
|
|
# A legal ELF file can have a program header with non-zero length
|
|
|
|
# but zero-length file size and a non-zero offset which, added
|
|
|
|
# together, are greater than input->size (i.e. the total file size).
|
|
|
|
# So we need to not even test in the case that p_filesz is zero.
|
|
|
|
# Note: All of this code is commented out since we don't have a test
|
|
|
|
# case for it.
|
|
|
|
size = segment['p_filesz']
|
|
|
|
#if not size:
|
|
|
|
#continue
|
|
|
|
#end = segment['p_offset'] + segment['p_filesz']
|
|
|
|
#if end > file_size:
|
|
|
|
#raise ValueError('Underflow copying out the segment. File has %#x bytes left, segment end is %#x\n',
|
|
|
|
#file_size, end)
|
|
|
|
output[start - data_start:start - data_start + size] = (
|
|
|
|
segment.data()[offset:])
|
|
|
|
return ElfInfo(output, data_start, elf.header['e_entry'] + virt_to_phys,
|
|
|
|
mem_end - data_start)
|