disassembler.py 文件源码

def construct_basic_blocks(self):
        """
        Once we have obtained the leaders, i.e. the boundaries where a basic block may start or end,
        we need to build the basic blocks by parsing the leaders. A basic block spans from the starting leader
        upto the immediate next end leader as per their addresses.
        """
        logger.debug('Constructing basic blocks...')
        idx = 0
        dec = Decoder(self.insBytes)

        while idx < len(self.leaders):
            # Get a pair of leaders
            leader1, leader2 = self.leaders[idx], self.leaders[idx + 1]

            # Get the addresses of the respective leaders
            addr1, addr2 = leader1.address, leader2.address

            # Create a new basic block
            bb = BasicBlock()

            # Set the address of the basic block
            bb.address = addr1

            # The offset variable is used track the position of the individual instructions within the basic block
            offset = 0

            # Store the basic block at the entrypoint separately
            if addr1 == self.entrypoint:
                self.bb_graph.add_node(bb, isEntry=True)
            else:
                self.bb_graph.add_node(bb)

            # Add the basic block to the graph
            self.bb_graph.add_node(bb)

            # Leader1 is start leader, leader2 is end leader
            # All instructions inclusive of leader1 and leader2 are part of this basic block
            if leader1.type == 'S' and leader2.type == 'E':
                logger.debug(
                    'Creating basic block {} spanning from {} to {}, both inclusive'.format(hex(id(bb)),
                                                                                            leader1.address,
                                                                                            leader2.address))
                while addr1 + offset <= addr2:
                    ins = dec.decode_at(addr1 + offset)
                    bb.add_instruction(ins)
                    offset += ins.size
                idx += 2

            # Both Leader1 and leader2 are start leader
            # Instructions inclusive of leader1 but exclusive of leader2 are part of this basic block
            elif leader1.type == 'S' and leader2.type == 'S':
                logger.debug(
                    'Creating basic block {} spanning from {} to {}, end exclusive'.format(hex(id(bb)), leader1.address,
                                                                                           leader2.address))
                while addr1 + offset < addr2:
                    ins = dec.decode_at(addr1 + offset)
                    bb.add_instruction(ins)
                    offset += ins.size
                idx += 1

        logger.debug('{} basic blocks created'.format(self.bb_graph.number_of_nodes()))