(self, state, block)
Scan through all statements and perform the following tasks:
        - Find stack pointers and the VEX temporary variable storing stack pointers
        - Selectively calculate VEX statements
        - Track memory loading and mark stack and global variables accordingly

        :param angr.Block block:
        :return:
Scan through all statements and perform the following tasks:
        - Find stack pointers and the VEX temporary variable storing stack pointers
        - Selectively calculate VEX statements
        - Track memory loading and mark stack and global variables accordingly
Scan through all statements and perform the following tasks : - Find stack pointers and the VEX temporary variable storing stack pointers - Selectively calculate VEX statements - Track memory loading and mark stack and global variables accordingly
def _process_block(self, state, block):  # pylint:disable=no-self-use
        """
        Scan through all statements and perform the following tasks:
        - Find stack pointers and the VEX temporary variable storing stack pointers
        - Selectively calculate VEX statements
        - Track memory loading and mark stack and global variables accordingly

        :param angr.Block block:
        :return:
        """

        l.debug('Processing block %#x.', block.addr)

        if isinstance(block, Block):
            try:
                _ = block.vex
            except SimEngineError:
                # the block does not exist or lifting failed
                return
            block = self._peephole_optimize(block)

        processor = self._ail_engine if isinstance(block, ailment.Block) else self._vex_engine
        processor.process(state, block=block, fail_fast=self._fail_fast)

        if self._track_sp and block.addr in self._node_to_cc:
            # readjusting sp at the end for blocks that end in a call
            sp: MultiValues = state.register_region.load(self.project.arch.sp_offset, size=self.project.arch.bytes)
            sp_v = sp.one_value()
            if sp_v is None:
                l.warning("Unexpected stack pointer value at the end of the function. Pick the first one.")
                sp_v = next(iter(next(iter(sp.values.values()))))

            adjusted = False

            if not adjusted:
                # make a guess
                # of course, this will fail miserably if the function called is not cdecl
                if self.project.arch.call_pushes_ret:
                    sp_v += self.project.arch.bytes
                    adjusted = True

            if adjusted:
                state.register_region.store(self.project.arch.sp_offset, sp_v)
def _process_block ( self , state , block ) : # pylint:disable=no-self-use l . debug ( 'Processing block %#x.' , block . addr ) if isinstance ( block , Block ) : try : _ = block . vex except SimEngineError : # the block does not exist or lifting failed return block = self . _peephole_optimize ( block ) processor = self . _ail_engine if isinstance ( block , ailment . Block ) else self . _vex_engine processor . process ( state , block = block , fail_fast = self . _fail_fast ) if self . _track_sp and block . addr in self . _node_to_cc : # readjusting sp at the end for blocks that end in a call sp : MultiValues = state . register_region . load ( self . project . arch . sp_offset , size = self . project . arch . bytes ) sp_v = sp . one_value ( ) if sp_v is None : l . warning ( "Unexpected stack pointer value at the end of the function. Pick the first one." ) sp_v = next ( iter ( next ( iter ( sp . values . values ( ) ) ) ) ) adjusted = False if not adjusted : # make a guess # of course, this will fail miserably if the function called is not cdecl if self . project . arch . call_pushes_ret : sp_v += self . project . arch . bytes adjusted = True if adjusted : state . register_region . store ( self . project . arch . sp_offset , sp_v )