Beispiel #1
0
 def __init__(self, alloc, path_mgr=None):
     self.alloc = alloc
     self.path_mgr = path_mgr
     self.mem = alloc.get_mem()
     self.binfmt = BinFmt()
     # map seglist baddr to bin_img
     self.infos = {}
Beispiel #2
0
 def __init__(self, mem, alloc, label_mgr, path_mgr):
   self.mem = mem
   self.alloc = alloc
   self.label_mgr = label_mgr
   self.path_mgr = path_mgr
   self.error = None
   self.loaded_seg_lists = {}
   self.binfmt = BinFmt()
Beispiel #3
0
 def __init__(self, alloc, path_mgr=None):
   self.alloc = alloc
   self.path_mgr = path_mgr
   self.mem = alloc.get_mem()
   self.binfmt = BinFmt()
   # map seglist baddr to bin_img
   self.infos = {}
Beispiel #4
0
class SegmentLoader(object):
    def __init__(self, alloc, path_mgr=None):
        self.alloc = alloc
        self.path_mgr = path_mgr
        self.mem = alloc.get_mem()
        self.binfmt = BinFmt()
        # map seglist baddr to bin_img
        self.infos = {}

    def load_sys_seglist(self, sys_bin_file):
        """load seglist, register it, and return seglist baddr or 0"""
        info = self.int_load_sys_seglist(sys_bin_file)
        if info:
            baddr = info.seglist.get_baddr()
            self.infos[baddr] = info
            log_segload.info("loaded sys seglist: %s", info)
            return baddr
        else:
            log_segload.info("can't load sys seglist: %s", sys_bin_file)
            return 0

    def load_ami_seglist(self, ami_bin_file, lock=None):
        """load seglist, register it, and return seglist baddr or 0"""
        info = self.int_load_ami_seglist(ami_bin_file, lock)
        if info:
            baddr = info.seglist.get_baddr()
            self.infos[baddr] = info
            log_segload.info("loaded ami seglist: %s", info)
            return baddr
        else:
            log_segload.info("can't load ami seglist: %s", ami_bin_file)
            return 0

    def unload_seglist(self, seglist_baddr):
        """unregister given seglist baddr and free seglist.
       return True if seglist was unloaded"""
        if seglist_baddr not in self.infos:
            log_segload.error("unknown seglist at @%06x", seglist_baddr)
            return False
        info = self.infos[seglist_baddr]
        log_segload.info("unload seglist: %s", info)
        del self.infos[seglist_baddr]
        info.seglist.free()
        return True

    def get_info(self, seglist_baddr):
        """return associated bin_img for given registered seglist baddr or None"""
        if seglist_baddr in self.infos:
            return self.infos[seglist_baddr]

    def register_seglist(self, baddr):
        """register custom seglist"""
        info = SegLoadInfo(SegList(self.alloc, baddr))
        log_segload.info("register seglist: %s", info)
        self.infos[baddr] = info

    def unregister_seglist(self, baddr):
        """remove custom seglist"""
        info = self.infos[baddr]
        log_segload.info("unregister seglist: %s", info)
        del self.infos[baddr]

    def shutdown(self):
        """check orphan seglists on shutdown and return number of orphans"""
        log_segload.info("shutdown")
        for baddr in self.infos:
            info = self.infos[baddr]
            log_segload.warning("orphaned seglist: %s", info)
            # try to free list
            info.seglist.free()
        return len(self.infos)

    def int_load_ami_seglist(self, ami_bin_file, lock=None):
        """load seglist given by ami binary path and return SegLoadInfo"""
        if self.path_mgr is None:
            return None
        # try to map path
        sys_path = self.path_mgr.ami_to_sys_path(lock,
                                                 ami_bin_file,
                                                 mustExist=True)
        if sys_path:
            info = self.int_load_sys_seglist(sys_path)
            info.ami_file = ami_bin_file
            return info

    def int_load_sys_seglist(self, sys_bin_file):
        """load seglist given by sys binary path and return SegLoadInfo"""
        base_name = os.path.basename(sys_bin_file)

        # does file exist?
        if not os.path.isfile(sys_bin_file):
            log_segload.debug("no file: %s", sys_bin_file)
            return None

        # try to load bin image in supported format (e.g. HUNK or ELF)
        bin_img = self.binfmt.load_image(sys_bin_file)
        if bin_img is None:
            log_segload.debug("load_image failed: %s", sys_bin_file)
            return None

        # create relocator
        relocator = Relocate(bin_img)

        # get info about segments to allocate
        sizes = relocator.get_sizes()
        names = bin_img.get_segment_names()
        bin_img_segs = bin_img.get_segments()

        # build label names
        if self.alloc.label_mgr:
            labels = []
            for i in range(len(sizes)):
                name = "%s_%d:%s" % (base_name, i, names[i].lower())
                labels.append(name)
        else:
            labels = None

        # allocate seg list
        seg_list = SegList.alloc(self.alloc, sizes, labels, bin_img_segs)

        # retrieve addr
        addrs = seg_list.get_all_addrs()

        # relocate to addresses and return data
        datas = relocator.relocate(addrs)

        # write contents to allocated memory
        for i in range(len(sizes)):
            # write data to segments
            self.mem.w_block(addrs[i], datas[i])

        return SegLoadInfo(seg_list, bin_img, sys_bin_file)
Beispiel #5
0
def do_build_cmd(args):
  # get options
  rom_size = args.rom_size
  kick_addr = int(args.kick_addr, 16)
  ext_addr = int(args.ext_addr, 16)
  kickety_split = args.kickety_split
  rom_type = args.rom_type
  fill_byte = int(args.fill_byte, 16)
  rom_rev = args.rom_rev
  if rom_rev is not None:
    rom_rev = map(int, rom_rev.split("."))
  add_footer = args.add_footer
  # select rom builder
  if rom_type == 'kick':
    logging.info("building %d KiB Kick ROM @%08x", rom_size, kick_addr)
    rb = KickRomBuilder(rom_size,
                        base_addr=kick_addr, fill_byte=fill_byte,
                        kickety_split=kickety_split, rom_ver=rom_rev)
  elif rom_type == 'ext':
    logging.info("building %d KiB Ext ROM @%08x Rev %r for Kick @%08x",
                 rom_size, ext_addr, rom_rev, kick_addr)
    rb = ExtRomBuilder(rom_size,
                       base_addr=ext_addr, fill_byte=fill_byte,
                       add_footer=add_footer, rom_ver=rom_rev,
                       kick_addr=kick_addr)
  else:
    logging.error("Unknown rom_type=%s", rom_type)
    return 1
  # build file list
  if args.modules is None:
    logging.error("No modules given!")
    return 1
  file_list = rb.build_file_list(args.modules)
  # load modules
  bf = BinFmt()
  for f in file_list:
    name = os.path.basename(f)
    # load image
    if bf.is_image(f):
      bin_img = bf.load_image(f)
      size = bin_img.get_size()
      data = None
    else:
      # load raw data
      bin_img = None
      with open(f, "rb") as fh:
        data = fh.read()
      size = len(data)

    # handle kickety split
    if kickety_split and rb.cross_kickety_split(size):
      off = rb.get_rom_offset()
      logging.info("@%08x: adding kickety split", off)
      rb.add_kickety_split()

    off = rb.get_rom_offset()
    # add image
    if bin_img is not None:
      logging.info("@%08x: adding module '%s'", off, f)
      e = rb.add_bin_img(name, bin_img)
      if e is None:
        logging.error("@%08x: can't add module '%s': %s", off, f, rb.get_error())
        return 3
    # add data
    else:
      logging.info("@%08x: adding raw data '%s'", off, f)
      e = rb.add_module(name, data)
      if e is None:
        logging.error("@%08x: can't add raw data '%s': %s", off, f, rb.get_error())
        return 3

  # build rom
  off = rb.get_rom_offset()
  logging.info("@%08x: padding %d bytes with %02x", off, rb.get_bytes_left(), fill_byte)
  rom_data = rb.build_rom()
  if rom_data is None:
    logging.error("building ROM failed: %s", rb.get_error())
    return 4

  # save rom
  output = args.output
  if output is not None:
    logging.info("saving ROM to '%s'", output)
    with open(output, "wb") as fh:
      fh.write(rom_data)
  return 0
Beispiel #6
0
def do_build_cmd(args):
    # get options
    rom_size = args.rom_size
    kick_addr = int(args.kick_addr, 16)
    ext_addr = int(args.ext_addr, 16)
    kickety_split = args.kickety_split
    rom_type = args.rom_type
    fill_byte = int(args.fill_byte, 16)
    rom_rev = args.rom_rev
    if rom_rev is not None:
        rom_rev = map(int, rom_rev.split("."))
    add_footer = args.add_footer
    # select rom builder
    if rom_type == 'kick':
        logging.info("building %d KiB Kick ROM @%08x", rom_size, kick_addr)
        rb = KickRomBuilder(rom_size,
                            base_addr=kick_addr,
                            fill_byte=fill_byte,
                            kickety_split=kickety_split,
                            rom_ver=rom_rev)
    elif rom_type == 'ext':
        logging.info("building %d KiB Ext ROM @%08x Rev %r for Kick @%08x",
                     rom_size, ext_addr, rom_rev, kick_addr)
        rb = ExtRomBuilder(rom_size,
                           base_addr=ext_addr,
                           fill_byte=fill_byte,
                           add_footer=add_footer,
                           rom_ver=rom_rev,
                           kick_addr=kick_addr)
    else:
        logging.error("Unknown rom_type=%s", rom_type)
        return 1
    # build file list
    if args.modules is None:
        logging.error("No modules given!")
        return 1
    file_list = rb.build_file_list(args.modules)
    # load modules
    bf = BinFmt()
    for f in file_list:
        name = os.path.basename(f)
        # load image
        if bf.is_image(f):
            bin_img = bf.load_image(f)
            size = bin_img.get_size()
            data = None
        else:
            # load raw data
            bin_img = None
            with open(f, "rb") as fh:
                data = fh.read()
            size = len(data)

        # handle kickety split
        if kickety_split and rb.cross_kickety_split(size):
            off = rb.get_rom_offset()
            logging.info("@%08x: adding kickety split", off)
            rb.add_kickety_split()

        off = rb.get_rom_offset()
        # add image
        if bin_img is not None:
            logging.info("@%08x: adding module '%s'", off, f)
            e = rb.add_bin_img(name, bin_img)
            if e is None:
                logging.error("@%08x: can't add module '%s': %s", off, f,
                              rb.get_error())
                return 3
        # add data
        else:
            logging.info("@%08x: adding raw data '%s'", off, f)
            e = rb.add_module(name, data)
            if e is None:
                logging.error("@%08x: can't add raw data '%s': %s", off, f,
                              rb.get_error())
                return 3

    # build rom
    off = rb.get_rom_offset()
    logging.info("@%08x: padding %d bytes with %02x", off, rb.get_bytes_left(),
                 fill_byte)
    rom_data = rb.build_rom()
    if rom_data is None:
        logging.error("building ROM failed: %s", rb.get_error())
        return 4

    # save rom
    output = args.output
    if output is not None:
        logging.info("saving ROM to '%s'", output)
        with open(output, "wb") as fh:
            fh.write(rom_data)
    return 0
Beispiel #7
0
            offs += (34, 38, 42)
        # get relocs to myself (seg 0)
        relocs = seg.get_reloc(seg)
        if relocs is not None:
            raise ValueError("no relocations expected in BlizKick module")
        relocs = BinImage.Relocations(seg)
        seg.add_reloc(seg, relocs)
        # add relocs
        for o in offs:
            relocs.add_reloc(BinImage.Reloc(o))
        # check if we can remove last data segment (contains only version info)
        if len(segs) == 2 and segs[1].get_type() == BinImage.SEGMENT_TYPE_DATA:
            data = segs[1].get_data()
            if data[:5] == "$VER:":
                self.bin_img.segments = [seg]


# test
if __name__ == "__main__":
    import sys
    from amitools.binfmt.BinFmt import BinFmt

    bfmt = BinFmt()
    for f in sys.argv[1:]:
        if bfmt.is_image(f):
            my_bin_img = bfmt.load_image(f)
            print(my_bin_img)
            bkm = BlizKickModule(my_bin_img)
            print((bkm.bk_type))
            bkm.fix_module()
Beispiel #8
0
      offs += ( 34, 38, 42 )
    # get relocs to myself (seg 0)
    relocs = seg.get_reloc(seg)
    if relocs is not None:
      raise ValueError("no relocations expected in BlizKick module")
    relocs = BinImage.Relocations(seg)
    seg.add_reloc(seg, relocs)
    # add relocs
    for o in offs:
      relocs.add_reloc(BinImage.Reloc(o))
    # check if we can remove last data segment (contains only version info)
    if len(segs) == 2 and segs[1].get_type() == BinImage.SEGMENT_TYPE_DATA:
      data = segs[1].get_data()
      if data[:5] == '$VER:':
        self.bin_img.segments = [seg]


# test
if __name__ == '__main__':
  import sys
  from amitools.binfmt.BinFmt import BinFmt
  bf = BinFmt()
  for f in sys.argv[1:]:
    if bf.is_image(f):
      bin_img = bf.load_image(f)
      print(bin_img)
      bkm = BlizKickModule(bin_img)
      print(bkm.bk_type)
      bkm.fix_module()

Beispiel #9
0
class SegmentLoader:

  def __init__(self, mem, alloc, label_mgr, path_mgr):
    self.mem = mem
    self.alloc = alloc
    self.label_mgr = label_mgr
    self.path_mgr = path_mgr
    self.error = None
    self.loaded_seg_lists = {}
    self.binfmt = BinFmt()

  def can_load_seg(self, lock, ami_bin_file):
    return self.path_mgr.ami_command_to_sys_path(lock, ami_bin_file) != None

  # load ami_bin_file
  def load_seg(self, lock, ami_bin_file, allow_reuse = True):
    # map file name
    sys_bin_file = self.path_mgr.ami_command_to_sys_path(lock, ami_bin_file)
    if sys_bin_file == None:
      self.error = "failed mapping binary path: '%s'" % ami_bin_file
      return None

    # check if seg list already loaded in a parent process
    # Bummer! This cannot work unless commands are resident!
    if allow_reuse and self.loaded_seg_lists.has_key(sys_bin_file):
      seg_list = self.loaded_seg_lists[sys_bin_file]
      seg_list.usage += 1
      return seg_list

    # really load new seg list
    seg_list = self._load_seg(ami_bin_file,sys_bin_file)
    if seg_list == None:
      return None

    # store in cache if allowed by caller
    if allow_reuse:
      self.loaded_seg_lists[sys_bin_file] = seg_list
    return seg_list

  # unload seg list
  def unload_seg(self, seg_list, allow_reuse = True):
    sys_bin_file = seg_list.sys_bin_file
    # check that file is in cache
    if not allow_reuse or sys_bin_file in self.loaded_seg_lists:
      seg_list.usage -= 1
      # no more used
      if seg_list.usage == 0:
        if sys_bin_file in self.loaded_seg_lists:
          del self.loaded_seg_lists[sys_bin_file]
        self._unload_seg(seg_list)
      return True
    else:
      self.error = "seglist not found in loaded seglists!"
      return False

  # load sys_bin_file
  def _load_seg(self, ami_bin_file, sys_bin_file):
    base_name = os.path.basename(sys_bin_file)

    # does file exist?
    if not os.path.isfile(sys_bin_file):
      self.error = "Can't find '%s'" % sys_bin_file
      return None

    # try to load bin image in supported format (e.g. HUNK or ELF)
    try:
      bin_img = self.binfmt.load_image(sys_bin_file)
      if bin_img is None:
        self.error = "Error loading '%s': unsupported format" % sys_bin_file
        return None
    except Exception as e:
      self.error = "Error loading '%s': %s" % (sys_bin_file, e)
      return None

    # create relocator
    relocator = Relocate(bin_img)

    # allocate segment memory
    sizes = relocator.get_sizes()
    names = bin_img.get_segment_names()
    bin_img_segs = bin_img.get_segments()
    seg_list = SegList(ami_bin_file, sys_bin_file, bin_img)
    addrs = []
    for i in xrange(len(sizes)):
      size = sizes[i]
      seg_size = size + 8 # add segment pointer and size of segment
      seg_addr = self.alloc.alloc_mem(seg_size)

      # create label
      label = None
      name = "%s_%d:%s" % (base_name,i,names[i].lower())
      bin_img_seg = bin_img_segs[i]
      if self.alloc.label_mgr != None:
        label = LabelSegment(name, seg_addr, seg_size, bin_img_seg)
        self.alloc.label_mgr.add_label(label)

      seg = Segment(name, seg_addr, seg_size, label, bin_img_seg)
      seg_list.add(seg)
      addrs.append(seg.addr + 8) # begin of segment data/code

    # relocate to addresses and return data
    datas = relocator.relocate(addrs)

    # write to allocated memory
    last_addr = None
    for i in xrange(len(sizes)):
      # write data to segments
      addr = addrs[i]
      self.mem.access.w_data(addr, datas[i])
      # link segment pointers
      if last_addr != None:
        b_addr = (addr-4) >> 2 # BCPL segment 'next' pointer
        self.mem.access.w32(last_addr - 4, b_addr)
      # write size before segment pointer
      total_size = (sizes[i] + 8)
      self.mem.access.w32(addr - 8, total_size)
      last_addr = addr

    # clear final 'next' pointer
    self.mem.access.w32(addr - 4, 0)

    return seg_list

  def _unload_seg(self, seg_list):
    for seg in seg_list.segments:
      # free memory of segment
      self.alloc.free_mem(seg.addr, seg.size)
      # remove label of segment
      if self.alloc.label_mgr != None:
        self.alloc.label_mgr.remove_label(seg.label)
Beispiel #10
0
def do_build_cmd(args):
    # get options
    rom_size = args.rom_size
    kick_addr = int(args.kick_addr, 16)
    ext_addr = int(args.ext_addr, 16)
    kickety_split = args.kickety_split
    rom_type = args.rom_type
    fill_byte = int(args.fill_byte, 16)
    rom_rev = args.rom_rev
    if rom_rev is not None:
        rom_rev = list(map(int, rom_rev.split(".")))
    add_footer = args.add_footer
    # select rom builder
    if rom_type == "kick":
        logging.info("building %d KiB Kick ROM @%08x", rom_size, kick_addr)
        rb = rom.KickRomBuilder(
            rom_size,
            base_addr=kick_addr,
            fill_byte=fill_byte,
            kickety_split=kickety_split,
            rom_ver=rom_rev,
        )
    elif rom_type == "ext":
        logging.info(
            "building %d KiB Ext ROM @%08x Rev %r for Kick @%08x",
            rom_size,
            ext_addr,
            rom_rev,
            kick_addr,
        )
        rb = rom.ExtRomBuilder(
            rom_size,
            base_addr=ext_addr,
            fill_byte=fill_byte,
            add_footer=add_footer,
            rom_ver=rom_rev,
            kick_addr=kick_addr,
        )
    else:
        logging.error("Unknown rom_type=%s", rom_type)
        return 1
    # build file list
    if args.modules is None:
        logging.error("No modules given!")
        return 1
    file_list = rb.build_file_list(args.modules)
    # load modules
    bf = BinFmt()
    for f in file_list:
        logging.info("adding file '%s'", f)
        name = os.path.basename(f)
        # load image
        if bf.is_image(f):
            bin_img = bf.load_image(f)
            # is it a blizkick module?
            bkm = rom.BlizKickModule(bin_img)
            if bkm.get_type() == "module":
                bkm.fix_module()
            elif bkm.get_type() == "patch":
                logging.error("BlizKick Patches are not supported, yet: %s",
                              name)
                return 5
            # get image params
            size = bin_img.get_size()
            data = None
        else:
            # load raw data
            bin_img = None
            with open(f, "rb") as fh:
                data = fh.read()
            size = len(data)

        # calc long word padding
        padding = 0
        if size & 3 != 0:
            padding = 4 - size & 3

        # handle kickety split
        if kickety_split and rb.cross_kickety_split(size + padding):
            off = rb.get_rom_offset()
            logging.info("@%08x: adding kickety split", off)
            rb.add_kickety_split()

        off = rb.get_rom_offset()
        # add image
        if bin_img is not None:
            logging.info("@%08x: adding module '%s'", off, f)
            e = rb.add_bin_img(name, bin_img)
            if e is None:
                logging.error("@%08x: can't add module '%s': %s", off, f,
                              rb.get_error())
                return 3
        # add data
        else:
            logging.info("@%08x: adding raw data '%s'", off, f)
            e = rb.add_module(name, data)
            if e is None:
                logging.error("@%08x: can't add raw data '%s': %s", off, f,
                              rb.get_error())
                return 3

        # add long word padding?
        if padding != 0:
            off = rb.get_rom_offset()
            logging.info("@%08x: adding padding: +%d" % (off, padding))
            e = rb.add_padding(padding)
            if e is None:
                logging.error("@%08x: can't add padding: %s", off,
                              rb.get_error())
                return 3

    # build rom
    off = rb.get_rom_offset()
    logging.info("@%08x: padding %d bytes with %02x", off, rb.get_bytes_left(),
                 fill_byte)
    rom_data = rb.build_rom()
    if rom_data is None:
        logging.error("building ROM failed: %s", rb.get_error())
        return 4

    # save rom
    output = args.output
    if output is not None:
        logging.info("saving ROM to '%s'", output)
        with open(output, "wb") as fh:
            fh.write(rom_data)
    return 0
Beispiel #11
0
class SegmentLoader(object):

  def __init__(self, alloc, path_mgr=None):
    self.alloc = alloc
    self.path_mgr = path_mgr
    self.mem = alloc.get_mem()
    self.binfmt = BinFmt()
    # map seglist baddr to bin_img
    self.infos = {}

  def load_sys_seglist(self, sys_bin_file):
    """load seglist, register it, and return seglist baddr or 0"""
    info = self.int_load_sys_seglist(sys_bin_file)
    if info:
      baddr = info.seglist.get_baddr()
      self.infos[baddr] = info
      log_segload.info("loaded sys seglist: %s", info)
      return baddr
    else:
      log_segload.info("can't load sys seglist: %s", sys_bin_file)
      return 0

  def load_ami_seglist(self, ami_bin_file, lock=None):
    """load seglist, register it, and return seglist baddr or 0"""
    info = self.int_load_ami_seglist(ami_bin_file, lock)
    if info:
      baddr = info.seglist.get_baddr()
      self.infos[baddr] = info
      log_segload.info("loaded ami seglist: %s", info)
      return baddr
    else:
      log_segload.info("can't load ami seglist: %s", ami_bin_file)
      return 0

  def unload_seglist(self, seglist_baddr):
    """unregister given seglist baddr and free seglist.
       return True if seglist was unloaded"""
    if seglist_baddr not in self.infos:
      log_segload.error("unknown seglist at @%06x", seglist_baddr)
      return False
    info = self.infos[seglist_baddr]
    log_segload.info("unload seglist: %s", info)
    del self.infos[seglist_baddr]
    info.seglist.free()
    return True

  def get_info(self, seglist_baddr):
    """return associated bin_img for given registered seglist baddr or None"""
    if seglist_baddr in self.infos:
      return self.infos[seglist_baddr]

  def register_seglist(self, baddr):
    """register custom seglist"""
    info = SegLoadInfo(SegList(self.alloc, baddr))
    log_segload.info("register seglist: %s", info)
    self.infos[baddr] = info

  def unregister_seglist(self, baddr):
    """remove custom seglist"""
    info = self.infos[baddr]
    log_segload.info("unregister seglist: %s", info)
    del self.infos[baddr]

  def shutdown(self):
    """check orphan seglists on shutdown and return number of orphans"""
    log_segload.info("shutdown")
    for baddr in self.infos:
      info = self.infos[baddr]
      log_segload.warn("orphaned seglist: %s", info)
      # try to free list
      info.seglist.free()
    return len(self.infos)

  def int_load_ami_seglist(self, ami_bin_file, lock=None):
    """load seglist given by ami binary path and return SegLoadInfo"""
    if self.path_mgr is None:
      return None
    # try to map path
    sys_path = self.path_mgr.ami_to_sys_path(
        lock, ami_bin_file, mustExist=True)
    if sys_path:
      info = self.int_load_sys_seglist(sys_path)
      info.ami_file = ami_bin_file
      return info

  def int_load_sys_seglist(self, sys_bin_file):
    """load seglist given by sys binary path and return SegLoadInfo"""
    base_name = os.path.basename(sys_bin_file)

    # does file exist?
    if not os.path.isfile(sys_bin_file):
      return None

    # try to load bin image in supported format (e.g. HUNK or ELF)
    bin_img = self.binfmt.load_image(sys_bin_file)
    if bin_img is None:
      return None

    # create relocator
    relocator = Relocate(bin_img)

    # get info about segments to allocate
    sizes = relocator.get_sizes()
    names = bin_img.get_segment_names()
    bin_img_segs = bin_img.get_segments()

    # build label names
    if self.alloc.label_mgr:
      labels = []
      for i in xrange(len(sizes)):
        name = "%s_%d:%s" % (base_name, i, names[i].lower())
        labels.append(name)
    else:
      labels = None

    # allocate seg list
    seg_list = SegList.alloc(self.alloc, sizes, labels, bin_img_segs)

    # retrieve addr
    addrs = seg_list.get_all_addrs()

    # relocate to addresses and return data
    datas = relocator.relocate(addrs)

    # write contents to allocated memory
    for i in xrange(len(sizes)):
      # write data to segments
      self.mem.w_block(addrs[i], datas[i])

    return SegLoadInfo(seg_list, bin_img, sys_bin_file)
Beispiel #12
0
        if auto_init:
            offs += (34, 38, 42)
        # get relocs to myself (seg 0)
        relocs = seg.get_reloc(seg)
        if relocs is not None:
            raise ValueError("no relocations expected in BlizKick module")
        relocs = BinImage.Relocations(seg)
        seg.add_reloc(seg, relocs)
        # add relocs
        for o in offs:
            relocs.add_reloc(BinImage.Reloc(o))
        # check if we can remove last data segment (contains only version info)
        if len(segs) == 2 and segs[1].get_type() == BinImage.SEGMENT_TYPE_DATA:
            data = segs[1].get_data()
            if data[:5] == '$VER:':
                self.bin_img.segments = [seg]


# test
if __name__ == '__main__':
    import sys
    from amitools.binfmt.BinFmt import BinFmt
    bf = BinFmt()
    for f in sys.argv[1:]:
        if bf.is_image(f):
            bin_img = bf.load_image(f)
            print(bin_img)
            bkm = BlizKickModule(bin_img)
            print(bkm.bk_type)
            bkm.fix_module()
Beispiel #13
0
 def __init__(self, mem, alloc):
   self.mem = mem
   self.alloc = alloc
   self.error = None
   self.loaded_seg_lists = {}
   self.binfmt = BinFmt()