Bold/elf.py

   1 # -*- coding: utf-8 -*-
   2 # kate: space-indent on; indent-width 2; mixedindent off; indent-mode python;
   3
   4 # Copyright (C) 2009 Amand 'alrj' Tihon <amand.tihon@alrj.org>
   5 #
   6 # This file is part of bold, the Byte Optimized Linker.
   7 #
   8 # You can redistribute this file and/or modify it under the terms of the
   9 # GNU General Public License as published by the Free Software Foundation,
  10 # either version 3 of the License or (at your option) any later version.
  11
  12
  13 from BinArray import BinArray
  14 from constants import *
  15 from errors import *
  16 import struct
  17
  18 # Helpful decorator
  19 def nested_property(c):
  20   return property(**c())
  21
  22
  23 #--------------------------------------------------------------------------
  24 #  Elf
  25 #--------------------------------------------------------------------------
  26
  27 class Elf64(object):
  28   """Handles an Elf64 object."""
  29   interpreter = "/lib64/ld-linux-x86-64.so.2"
  30
  31   def __init__(self, path=None):
  32     object.__init__(self)
  33     self.header = Elf64_Ehdr()
  34     self.header.owner = self
  35     self.shdrs = []
  36     self.phdrs = []
  37     self.shlibs = []
  38     self.sections = {}
  39     self.segments = []
  40     self.local_symbols = {}
  41     self.global_symbols = {}
  42     self.undefined_symbols = []
  43     self.common_symbols = []
  44
  45     if path:
  46       self.filename = path
  47       self.fromfile(path)
  48
  49   # Functions for relocatables files used as input
  50
  51   def fromfile(self, path):
  52     f = file(path, "rb")
  53
  54     # Load Elf header
  55     data = BinArray()
  56     data.fromfile(f, Elf64_Ehdr.size)
  57     self.header.fromBinArray(data)
  58
  59     # This linker only supports relocatable objects
  60     if self.header.e_type != ET_REL:
  61       raise NotRelocatableObject(path)
  62
  63     if self.header.e_ident.ei_class != ELFCLASS64:
  64       raise UnsupportedObject(path, "Not %s" % ELFCLASS64)
  65
  66     if self.header.e_machine != EM_X86_64:
  67       raise UnsupportedObject(path, "Not %s" % EM_X86_64)
  68
  69     # Load sections headers
  70     f.seek(self.header.e_shoff)
  71     for i in range(self.header.e_shnum):
  72       data = BinArray()
  73       data.fromfile(f, self.header.e_shentsize)
  74       h = Elf64_Shdr(i, data)
  75       h.owner = self
  76       self.shdrs.append(h)
  77
  78     # Read sections content
  79     for sh in self.shdrs:
  80       data = BinArray()
  81       if sh.sh_type != SHT_NOBITS:
  82         f.seek(sh.sh_offset)
  83         data.fromfile(f, sh.sh_size)
  84       sh.content = data
  85
  86     f.close()
  87
  88   def resolve_names(self):
  89     # The .shstrtab index is in Elf Header. find the sections names
  90     strtab = self.shdrs[self.header.e_shstrndx].content
  91
  92     for sh in self.shdrs:
  93       sh.name = strtab[int(sh.sh_name)]
  94       self.sections[sh.name] = sh
  95
  96       # And resolve names in the section itself
  97       sh.resolve_names()
  98
  99
 100   def find_symbols(self):
 101     for sh in self.shdrs:
 102       if sh.sh_type == SHT_SYMTAB:
 103         symtab = sh.content.symtab
 104
 105         for symbol in symtab:
 106           if symbol.st_type == STT_FILE:
 107             continue
 108           if symbol.st_shndx == SHN_ABS:
 109             continue
 110           if symbol.st_shndx == SHN_COMMON:
 111             if symbol.name:
 112               sym = (symbol.name, symbol.st_size, symbol.st_value)
 113               self.common_symbols.append(sym)
 114               continue
 115           if symbol.st_shndx == SHN_UNDEF:
 116             if symbol.name:
 117               self.undefined_symbols.append(symbol.name)
 118             continue
 119
 120           target_section = self.shdrs[symbol.st_shndx]
 121
 122           symbol_name = symbol.name
 123           value = symbol.st_value
 124           bind = symbol.st_binding
 125
 126           # We got a name, a target section, and an offset in the section
 127           if symbol.st_binding == STB_LOCAL:
 128             if symbol.st_type == STT_SECTION:
 129               symbol_name = target_section.name
 130             self.local_symbols[symbol_name] = (target_section, value)
 131           else:
 132             self.global_symbols[symbol_name] = (target_section, value)
 133
 134   def apply_relocation(self, all_global_symbols):
 135     # find relocation tables
 136     relocations = [sh for sh in self.shdrs if sh.sh_type in [SHT_REL, SHT_RELA]]
 137     for sh in relocations:
 138       target = sh.target.content
 139
 140       for reloc in sh.content.relatab:
 141         if reloc.symbol.st_shndx in [SHN_UNDEF, SHN_COMMON]:
 142           # This is an extern or common symbol, find it in all_global_symbols
 143           sym_address = all_global_symbols[reloc.symbol.name]
 144         else:
 145           # source == in which section it is defined
 146           source = self.shdrs[reloc.symbol.st_shndx].content
 147           sym_address = source.virt_addr + reloc.symbol.st_value
 148
 149         target_ba = target.data # The actual BinArray that we'll modify
 150         pc_address = target.virt_addr + reloc.r_offset
 151
 152         if reloc.r_type == R_X86_64_64:
 153           format = "<Q" # Direct 64 bit address
 154           target_value = sym_address + reloc.r_addend
 155         elif reloc.r_type == R_X86_64_PC32:
 156           format = "<i" # PC relative 32 bit signed
 157           target_value = sym_address + reloc.r_addend - pc_address
 158         elif reloc.r_type == R_X86_64_32:
 159           format = "<I" # Direct 32 bit zero extended
 160           target_value = sym_address + reloc.r_addend
 161         elif reloc.r_type == R_X86_64_32S:
 162           format = "<i" # Direct 32 bit sign extended
 163           target_value = sym_address + reloc.r_addend
 164         elif reloc.r_type == R_X86_64_PC16:
 165           format = "<h" # 16 bit sign extended pc relative
 166           target_value = sym_address + reloc.r_addend - pc_address
 167         elif reloc.r_type == R_X86_64_16:
 168           format = "<H" # Direct 16 bit zero extended
 169           target_value = sym_address + reloc.r_addend
 170         elif reloc.r_type == R_X86_64_PC8:
 171           format = "b" # 8 bit sign extended pc relative
 172           target_value = sym_address + reloc.r_addend - pc_address
 173         elif reloc.r_type == R_X86_64_8:
 174           format = "b" # Direct 8 bit sign extended
 175           target_value = sym_address + reloc.r_addend
 176         else:
 177           print "Unsupported relocation type: %s" % reloc.r_type
 178           exit(1)
 179
 180         d = BinArray(struct.pack(format, target_value))
 181         start = reloc.r_offset
 182         end = start + len(d)
 183         target_ba[start:end] = d
 184
 185
 186   # Functions for executables files, as output
 187
 188   def add_phdr(self, phdr):
 189     self.phdrs.append(phdr)
 190     self.header.e_phnum = len(self.phdrs)
 191     phdr.owner = self
 192
 193   def add_segment(self, segment):
 194     self.segments.append(segment)
 195
 196   def layout(self, base_vaddr):
 197     """Do the actual layout for final executable."""
 198
 199     virt_addr = base_vaddr
 200     file_offset = 0
 201     self.virt_addr = base_vaddr
 202     self.file_offset = file_offset
 203     for s in self.segments:
 204         virt_addr += s.align
 205         s.virt_addr = virt_addr
 206         s.file_offset = file_offset
 207         s.layout()
 208         virt_addr += s.logical_size
 209         file_offset += s.physical_size
 210
 211   def toBinArray(self):
 212     ba = BinArray()
 213     for s in self.segments:
 214       ba.extend(s.toBinArray())
 215     return ba
 216
 217
 218 #--------------------------------------------------------------------------
 219 #  Elf file header
 220 #--------------------------------------------------------------------------
 221
 222 class Elf64_eident(object):
 223   """Detailed representation for the Elf identifier."""
 224   format = "16B"
 225   size = struct.calcsize(format)
 226   physical_size = size
 227   logical_size = size
 228
 229   def __init__(self, rawdata=None):
 230     object.__init__(self)
 231     if rawdata is not None:
 232       self.fromBinArray(rawdata)
 233
 234   def fromBinArray(self, rawdata):
 235     t = struct.unpack(self.format, rawdata)
 236     self.ei_magic = rawdata[:4]
 237     self.ei_class = ElfClass(rawdata[4])
 238     self.ei_data = ElfData(rawdata[5])
 239     self.ei_version = ElfVersion(rawdata[6])
 240     self.ei_osabi = ElfOsAbi(rawdata[7])
 241     self.ei_abiversion = 0
 242     self.ei_pad = [0, 0, 0, 0, 0, 0, 0]
 243
 244   def make_default_amd64(self):
 245     self.ei_magic = BinArray([0x7f, 0x45, 0x4c, 0x46])
 246     self.ei_class = ELFCLASS64
 247     self.ei_data = ELFDATA2LSB
 248     self.ei_version = EV_CURRENT
 249     self.ei_osabi = ELFOSABI_SYSV
 250     self.ei_abiversion = 0
 251     self.ei_pad = [0, 0, 0, 0, 0, 0, 0]
 252
 253   def toBinArray(self):
 254     ba = BinArray(self.ei_magic)
 255     ba.append(self.ei_class)
 256     ba.append(self.ei_data)
 257     ba.append(self.ei_version)
 258     ba.append(self.ei_osabi)
 259     ba.append(self.ei_abiversion)
 260     ba.extend(self.ei_pad)
 261     return ba
 262
 263
 264 class Elf64_Ehdr(object):
 265   """Elf file header"""
 266   format = "<16B 2H I 3Q I 6H"
 267   size = struct.calcsize(format)
 268   physical_size = size
 269   logical_size = size
 270
 271   def __init__(self, rawdata=None):
 272     object.__init__(self)
 273     self.e_ident = Elf64_eident()
 274     self.e_type = ET_NONE
 275     self.e_machine = EM_X86_64
 276     self.e_version = EV_CURRENT
 277     self.e_entry = 0
 278     self.e_phoff = 0
 279     self.e_shoff = 0
 280     self.e_flags = 0
 281     self.e_ehsize = self.size
 282     self.e_phentsize = Elf64_Phdr.size
 283     self.e_phnum = 0
 284     self.e_shentsize = Elf64_Shdr.size
 285     self.e_shnum = 0
 286     self.e_shstrndx = 0
 287     if rawdata is not None:
 288       self.fromBinArray(rawdata)
 289
 290   def fromBinArray(self, rawdata):
 291     t = struct.unpack(self.format, rawdata)
 292     self.e_ident = Elf64_eident(BinArray(rawdata[:16]))
 293     self.e_type = ElfType(t[16])
 294     self.e_machine = ElfMachine(t[17])
 295     self.e_version = ElfVersion(t[18])
 296     self.e_entry = t[19]
 297     self.e_phoff = t[20]
 298     self.e_shoff = t[21]
 299     self.e_flags = t[22]
 300     self.e_ehsize = t[23]
 301     self.e_phentsize = t[24]
 302     self.e_phnum = t[25]
 303     self.e_shentsize = t[26]
 304     self.e_shnum = t[27]
 305     self.e_shstrndx = t[28]
 306
 307   def toBinArray(self):
 308     # Build a list from e_ident and all other fields, to feed struct.pack.
 309     values = self.e_ident.toBinArray().tolist()
 310     values.extend([self.e_type, self.e_machine, self.e_version, self.e_entry,
 311       self.e_phoff, self.e_shoff, self.e_flags, self.e_ehsize, self.e_phentsize,
 312       self.e_phnum, self.e_shentsize, self.e_shnum, self.e_shstrndx])
 313     res = struct.pack(self.format, *values)
 314     return BinArray(res)
 315
 316   def layout(self):
 317     pass
 318
 319
 320 #--------------------------------------------------------------------------
 321 #  Elf Sections
 322 #--------------------------------------------------------------------------
 323
 324 class Elf64_Shdr(object):
 325   """Elf64 section header."""
 326   format = "<2I 4Q 2I 2Q"
 327   size = struct.calcsize(format)
 328   physical_size = size
 329   logical_size = size
 330
 331   def __init__(self, index=None, rawdata=None):
 332     object.__init__(self)
 333     self.index = index
 334     if rawdata is not None:
 335       self.fromBinArray(rawdata)
 336
 337   def fromBinArray(self, rawdata):
 338     t = struct.unpack(self.format, rawdata)
 339     self.sh_name = t[0]
 340     self.sh_type = ElfShType(t[1])
 341     self.sh_flags = t[2]
 342     self.sh_addr = t[3]
 343     self.sh_offset = t[4]
 344     self.sh_size = t[5]
 345     self.sh_link = t[6]
 346     self.sh_info = t[7]
 347     self.sh_addralign = t[8]
 348     self.sh_entsize = t[9]
 349
 350   def resolve_names(self):
 351     self.content.resolve_names(self.owner)
 352
 353   @nested_property
 354   def content():
 355     def fget(self):
 356       return self._content
 357     def fset(self, data):
 358       """Use the Section factory to get the subclass corresponding to the
 359          session type specified in this header)."""
 360       self._content = Section(self, data)
 361     return locals()
 362
 363 # For sections that contain elements of specific types :
 364
 365 class Elf64_Sym(object):
 366   """Symbol Table entry"""
 367   format = "<I 2B H 2Q "
 368   entsize = struct.calcsize(format)
 369   def __init__(self, rawdata=None):
 370     object.__init__(self)
 371     if rawdata is not None:
 372       self.fromBinArray(rawdata)
 373
 374   @nested_property
 375   def st_binding():
 376     def fget(self):
 377       return ElfSymbolBinding((self.st_info >> 4) & 0x0f)
 378     def fset(self, value):
 379       self.st_info = (((value & 0x0f) << 4) | (self.st_info & 0x0f))
 380     return locals()
 381
 382   @nested_property
 383   def st_type():
 384     def fget(self):
 385        return ElfSymbolType(self.st_info & 0x0f)
 386     def fset(self, value):
 387       self.st_info = ((self.st_info & 0xf0) | (value & 0x0f))
 388     return locals()
 389
 390   @nested_property
 391   def st_visibility():
 392     def fget(self):
 393       return ElfSymbolVisibility(self.st_other & 0x03)
 394     def fset(self, value):
 395       self.st_other = ((self.st_other & 0xfc) | (value & 0x03))
 396     return locals()
 397
 398   def fromBinArray(self, rawdata):
 399     t = struct.unpack(self.format, rawdata)
 400     self.st_name = t[0] # index in the strtab pointed by sh_link
 401     self.st_info = t[1]
 402     self.st_other = t[2]
 403     self.st_shndx = ElfSectionIndex(t[3])
 404     self.st_value = t[4]
 405     self.st_size = t[5]
 406
 407
 408 class Elf64_Rel(object):
 409   format = "<2Q"
 410   def __init__(self, rawdata=None):
 411     object.__init__(self)
 412     self.r_addend = 0 # No addend in a Rel.
 413     if rawdata is not None:
 414       self.fromBinArray(rawdata)
 415
 416   def fromBinArray(sef, rawdata):
 417     t = struct.unpack(self.format, rawdata)
 418     self.r_offset = t[0]
 419     self.r_info = t[1]
 420
 421   @nested_property
 422   def r_sym():
 423     def fget(self):
 424       return (self.r_info >> 32) & 0xffffffff
 425     def fset(self, value):
 426       self.r_info = ((value & 0xffffffff) << 32) | (self.r_info & 0xffffffff)
 427     return locals()
 428
 429   @nested_property
 430   def r_type():
 431     def fget(self):
 432       return Amd64Relocation(self.r_info & 0xffffffff)
 433     def fset(self, value):
 434       self.r_info = (self.r_info & 0xffffffff00000000) | (value & 0xffffffff)
 435     return locals()
 436
 437
 438 class Elf64_Rela(Elf64_Rel):
 439   format = "<2Q q"
 440   def __init__(self, rawdata=None):
 441     Elf64_Rel.__init__(self, rawdata)
 442
 443   def fromBinArray(self, rawdata):
 444     t = struct.unpack(self.format, rawdata)
 445     self.r_offset = t[0]
 446     self.r_info = t[1]
 447     self.r_addend = t[2]
 448
 449
 450 class Elf64_Dyn(object):
 451   format = "<2Q"
 452   size = struct.calcsize(format)
 453   def __init__(self, tag, value):
 454     object.__init__(self)
 455     self.d_tag = tag
 456     self.d_val = value
 457
 458   @nested_property
 459   def d_ptr():
 460     def fget(self):
 461       return self.d_val
 462     def fset(self, value):
 463       self.d_val = value
 464     return locals()
 465
 466   def toBinArray(self):
 467     ba = BinArray()
 468     ba.fromstring(struct.pack(self.format, self.d_tag, self.d_val))
 469     return ba
 470
 471 # Sections types :
 472
 473 def Section(shdr, data=None):
 474   """A section factory"""
 475   dataclass = {
 476     SHT_NULL:           SNull,
 477     SHT_PROGBITS:       SProgBits,
 478     SHT_SYMTAB:         SSymtab,
 479     SHT_STRTAB:         SStrtab,
 480     SHT_RELA:           SRela,
 481     SHT_HASH:           SHash,
 482     SHT_DYNAMIC:        SDynamic,
 483     SHT_NOTE:           SNote,
 484     SHT_NOBITS:         SNobits,
 485     SHT_REL:            SRel,
 486     SHT_SHLIB:          SShlib,
 487     SHT_DYNSYM:         SDynsym
 488   }
 489   if shdr.sh_type in dataclass:
 490     return dataclass[shdr.sh_type](shdr, data)
 491   else:
 492     return BaseSection(shdr, data)
 493
 494
 495 class BaseSection(object):
 496   def __init__(self, shdr, rawdata=None):
 497     object.__init__(self)
 498     self.data = None
 499     self.header = shdr
 500     if rawdata is not None:
 501       self.fromBinArray(rawdata)
 502
 503   def fromBinArray(self, rawdata):
 504     self.data = rawdata
 505
 506   def toBinArray(self):
 507     if self.data:
 508       return self.data
 509     else:
 510       return BinArray()
 511
 512   def resolve_names(self, elf):
 513     """Nothing to resolve."""
 514     pass
 515
 516   @nested_property
 517   def size():
 518     def fget(self):
 519       return len(self.data)
 520     return locals()
 521   physical_size = size
 522   logical_size = size
 523
 524   def layout(self):
 525     pass
 526
 527
 528 class SNull(BaseSection):
 529   def __init__(self, shdr, data=None):
 530     BaseSection.__init__(self, shdr, None)
 531
 532
 533 class SProgBits(BaseSection):
 534   def __init__(self, shdr, data=None):
 535     BaseSection.__init__(self, shdr, data)
 536
 537
 538 class SSymtab(BaseSection):
 539   entsize = struct.calcsize(Elf64_Sym.format)
 540   def __init__(self, shdr, data=None):
 541     self.symtab = []
 542     BaseSection.__init__(self, shdr, data)
 543
 544   def fromBinArray(self, data):
 545     BaseSection.fromBinArray(self, data)
 546     nument = len(data) / self.entsize
 547     for i in range(nument):
 548       start = i * self.entsize
 549       end = i * self.entsize + self.entsize
 550       self.symtab.append(Elf64_Sym(data[start:end]))
 551
 552   def resolve_names(self, elf):
 553     # For a symtab, the strtab is indicated by sh_link
 554     strtab = elf.shdrs[self.header.sh_link].content
 555     # Resolve for all symbols in the table
 556     for sym in self.symtab:
 557       sym.name = strtab[sym.st_name]
 558
 559   def __getitem__(self, key):
 560     return self.symtab[key]
 561
 562
 563 class SStrtab(BaseSection):
 564   """This one behaves in two completely different ways.
 565   If it's given a section header and data, it will act as read-only, only to
 566   be used for name resolution.
 567   If it's not given any argument, it can be used to create a new Strtab."""
 568   def __init__(self, shdr=None, data=None):
 569     self.readonly = (shdr is not None)
 570     self.by_index = {}
 571     self.by_name = {}
 572     self.table = []
 573     BaseSection.__init__(self, shdr, data)
 574     self.virt_addr = None
 575
 576   def toBinArray(self):
 577     if self.readonly:
 578       return BaseSection.toBinArray()
 579
 580     ba = BinArray()
 581     keys = self.by_index.keys()
 582     keys.sort()
 583     for k in keys:
 584       ba.fromstring(self.by_index[k] + "\0")
 585     return ba
 586
 587   @nested_property
 588   def size():
 589     def fget(self):
 590       if len(self.by_index) == 0:
 591         return 0
 592       return len(self.data)
 593     return locals()
 594   physical_size = size
 595   logical_size = size
 596
 597   def iteritems(self):
 598     return self.by_index.iteritems()
 599
 600   # Resolution functions
 601
 602   def fromBinArray(self, data):
 603     BaseSection.fromBinArray(self, data)
 604     itab = data.tostring().split('\0')
 605     i = 0
 606     for sname in itab:
 607       self.by_index[i] = sname
 608       self.by_name[sname] = i
 609       i += len(sname) + 1
 610
 611   def __getitem__(self, key):
 612     if isinstance(key, int):
 613       # Find string by index
 614       if key in self.by_index:
 615         # Already computed, return it
 616         return self.by_index[key]
 617       else:
 618         # It references a substring
 619         v = self.data[key:].tostring().split('\0')[0]
 620         self.by_index[key] = v
 621         self.by_name[v] = key
 622         return v
 623     else:
 624       # find index by name
 625       if key in self.by_name:
 626         return self.by_name[key]
 627       else:
 628         raise KeyError(key)
 629
 630   # Executable creation functions
 631
 632   def append(self, identifier):
 633     if len(self.by_name) == 0:
 634       offset = 0
 635     else:
 636       last = max(self.by_index.keys())
 637       offset = last + len(self.by_index[last]) + 1 # for the \0
 638     self.by_index[offset] = identifier
 639     self.by_name[identifier] = offset
 640     self.data = self.toBinArray()
 641     return offset
 642
 643   def layout(self):
 644     pass
 645
 646
 647 class SRela(BaseSection):
 648   entsize = struct.calcsize(Elf64_Rela.format)
 649   def __init__(self, shdr, data=None):
 650     self.relatab = []
 651     BaseSection.__init__(self, shdr, data)
 652
 653   def fromBinArray(self, data):
 654     BaseSection.fromBinArray(self, data)
 655     nument = len(data) / self.entsize
 656     for i in range(nument):
 657       start = i * self.entsize
 658       end = i * self.entsize + self.entsize
 659       self.relatab.append(Elf64_Rela(data[start:end]))
 660
 661   def resolve_names(self, elf):
 662     """Badly named, this wil resolve to a symtab entry..."""
 663     # sh_link leads to the symtab
 664     self.symtab = elf.shdrs[self.header.sh_link].content
 665     # sh_info links to the section on which the relocation applies
 666     self.header.target = elf.shdrs[self.header.sh_info]
 667     for r in self.relatab:
 668       r.symbol = self.symtab[r.r_sym]
 669
 670
 671
 672 class SHash(BaseSection):
 673   pass
 674
 675
 676 class SDynamic(BaseSection):
 677   pass
 678
 679
 680 class SNote(BaseSection):
 681   pass
 682
 683
 684 class SNobits(BaseSection):
 685   size = 0
 686   physical_size = 0
 687
 688   @nested_property
 689   def logical_size():
 690     def fget(self):
 691       return self.header.sh_size
 692     return locals()
 693
 694   def toBinArray(self):
 695     return BinArray()
 696
 697
 698 class SRel(BaseSection):
 699   pass
 700
 701
 702 class SShlib(BaseSection):
 703   pass
 704
 705
 706 class SDynsym(SSymtab):
 707   pass
 708
 709
 710 class Elf64_Phdr(object):
 711   format = "<2I 6Q"
 712   size = struct.calcsize(format)
 713   physical_size = size
 714   logical_size = size
 715
 716   def __init__(self):
 717     object.__init__(self)
 718     self.p_type = PT_NULL
 719     self.p_flags = PF_X + PF_W + PF_R
 720     self.p_offset = 0
 721     self.p_vaddr = 0
 722     self.p_paddr = 0
 723     self.p_filesz = 0
 724     self.p_memsz = 0
 725     self.p_align = 1
 726
 727   def toBinArray(self):
 728     res = struct.pack(self.format, self.p_type, self.p_flags, self.p_offset,
 729       self.p_vaddr, self.p_paddr, self.p_filesz, self.p_memsz, self.p_align)
 730     return BinArray(res)
 731
 732   def layout(self):
 733     pass
 734
 735   def update_from_content(self, content):
 736     """ Update ofset, address and sizes.
 737     After having applied layout(),the content knows all these values."""
 738     self.p_offset = content.file_offset
 739     self.p_vaddr = content.virt_addr
 740     self.p_filesz = content.physical_size
 741     self.p_memsz = content.logical_size
 742
 743
 744 class BaseSegment(object):
 745   def __init__(self, align=0):
 746     object.__init__(self)
 747     self.align = align
 748     self.content = []
 749
 750   def add_content(self, content):
 751     self.content.append(content)
 752
 753   def toBinArray(self):
 754     ba = BinArray()
 755     for c in self.content:
 756       ba.extend(c.toBinArray())
 757     return ba
 758
 759   @nested_property
 760   def size():
 761     def fget(self):
 762       return sum(c.size for c in self.content)
 763     return locals()
 764   physical_size = size
 765   logical_size = size
 766
 767
 768 class TextSegment(BaseSegment):
 769   def __init__(self, align=0):
 770     BaseSegment.__init__(self, align)
 771
 772   def layout(self):
 773     virt_addr = self.virt_addr
 774     file_offset = self.file_offset
 775     for i in self.content:
 776       i.virt_addr = virt_addr
 777       i.file_offset = file_offset
 778       i.layout()
 779       virt_addr += i.logical_size
 780       file_offset += i.physical_size
 781
 782
 783 class DataSegment(BaseSegment):
 784   def __init__(self, align=0):
 785     BaseSegment.__init__(self, align)
 786     self.nobits = []
 787
 788   def add_nobits(self, content):
 789     self.nobits.append(content)
 790
 791   def layout(self):
 792     virt_addr = self.virt_addr
 793     file_offset = self.file_offset
 794     for i in self.content:
 795       i.virt_addr = virt_addr
 796       i.file_offset = file_offset
 797       i.layout()
 798       virt_addr += i.logical_size
 799       file_offset += i.physical_size
 800     for i in self.nobits:
 801       i.virt_addr = virt_addr
 802       i.file_offset = 0
 803       i.layout()
 804       virt_addr += i.logical_size
 805
 806   @nested_property
 807   def logical_size():
 808     def fget(self):
 809       return self.physical_size + sum(c.logical_size for c in self.nobits)
 810     return locals()
 811
 812
 813 class Dynamic(object):
 814   def __init__(self):
 815     object.__init__(self)
 816     self.dyntab = []
 817     self.strtab = SStrtab()
 818
 819   @nested_property
 820   def size():
 821     def fget(self):
 822       # End the table with a DT_NULL without associated value.
 823       return (Elf64_Dyn.size * len(self.dyntab) + struct.calcsize("Q"))
 824     return locals()
 825   physical_size = size
 826   logical_size = size
 827
 828   def add_shlib(self, shlib):
 829     offset = self.strtab.append(shlib)
 830     self.dyntab.append(Elf64_Dyn(DT_NEEDED, offset))
 831
 832   def add_symtab(self, vaddr):
 833     self.dyntab.append(Elf64_Dyn(DT_SYMTAB, vaddr))
 834
 835   def add_debug(self):
 836     self.dyntab.append(Elf64_Dyn(DT_DEBUG, 0))
 837
 838   def layout(self):
 839     # Adjust the address of the strtab, if
 840     if self.strtab.virt_addr is None:
 841       print "Ooops, strtab's address is not known yet. Aborting."
 842       exit(1)
 843     else:
 844       self.dyntab.append(Elf64_Dyn(DT_STRTAB, self.strtab.virt_addr))
 845
 846   @nested_property
 847   def dt_debug_address():
 848     def fget(self):
 849       for i, d in enumerate(self.dyntab):
 850         if d.d_tag == DT_DEBUG:
 851           return self.virt_addr + (i*d.size + (d.size/2))
 852     return locals()
 853
 854
 855   def toBinArray(self):
 856     ba = BinArray()
 857     for d in self.dyntab:
 858       ba.extend(d.toBinArray())
 859     null = struct.pack("<Q", DT_NULL)
 860     ba.fromstring(null)
 861     return ba
 862
 863
 864 class Interpreter(object):
 865   """
 866   Pseudo-section containing the null terminated string referencing the
 867   interpreter to use.
 868
 869   @ivar size: Read-only attribute, size of the null terminated string.
 870   @ivar logical_size: alias to size
 871   @ivar physical_size: alias to size
 872   """
 873   default_interpreter = "/lib64/ld-linux-x86-64.so.2"
 874
 875   def __init__(self, interpreter=None):
 876     """
 877     @param interpreter: The interpreter ot use. Defaults to
 878       "/lib64/ld-linux-x86-64.so.2", as per the specs.
 879     @type interpreter: string
 880     """
 881     object.__init__(self)
 882     if interpreter:
 883       self.interpreter = interpreter
 884     else:
 885       self.interpreter = self.default_interpreter
 886
 887   @nested_property
 888   def size():
 889     def fget(self):
 890       # Null terminated
 891       return len(self.interpreter) + 1
 892     return locals()
 893   physical_size = size
 894   logical_size = size
 895
 896   def toBinArray(self):
 897     """
 898     @return: a L{BinArray} with the content of the pseudo-section.
 899     """
 900     ba = BinArray(self.interpreter)
 901     ba.append(0)
 902     return ba
 903
 904   def layout(self):
 905     """
 906     Unused.
 907     """
 908     pass
 909