angr 9.2.102__py3-none-win_amd64.whl → 9.2.103__py3-none-win_amd64.whl

angr/analyses/variable_recovery/variable_recovery_fast.py

@@ -1,5 +1,5 @@
 # pylint:disable=wrong-import-position,wrong-import-order
-from typing import Optional, List, Tuple, Union, DefaultDict, Set, Dict, TYPE_CHECKING
+from typing import DefaultDict, TYPE_CHECKING
 import logging
 from collections import defaultdict
 
@@ -103,8 +103,8 @@ class VariableRecoveryFastState(VariableRecoveryStateBase):
         return state
 
     def merge(
-        self, others: Tuple["VariableRecoveryFastState"], successor=None
-    ) -> Tuple["VariableRecoveryFastState", bool]:
+        self, others: tuple["VariableRecoveryFastState"], successor=None
+    ) -> tuple["VariableRecoveryFastState", bool]:
         """
         Merge two abstract states.
 
@@ -233,12 +233,12 @@ class VariableRecoveryFast(ForwardAnalysis, VariableRecoveryBase):  # pylint:dis
 
     def __init__(
         self,
-        func: Union[Function, str, int],
-        func_graph: Optional[networkx.DiGraph] = None,
+        func: Function | str | int,
+        func_graph: networkx.DiGraph | None = None,
         max_iterations: int = 2,
         low_priority=False,
         track_sp=True,
-        func_args: Optional[List[SimVariable]] = None,
+        func_args: list[SimVariable] | None = None,
         store_live_variables=False,
         unify_variables=True,
     ):
@@ -276,9 +276,9 @@ class VariableRecoveryFast(ForwardAnalysis, VariableRecoveryBase):  # pylint:dis
         self._node_iterations = defaultdict(int)
 
         self._node_to_cc = {}
-        self.var_to_typevars: DefaultDict[SimVariable, Set[TypeVariable]] = defaultdict(set)
+        self.var_to_typevars: DefaultDict[SimVariable, set[TypeVariable]] = defaultdict(set)
         self.typevars = None
-        self.type_constraints: Optional[Dict["TypeVariable", Set["TypeConstraint"]]] = None
+        self.type_constraints: dict["TypeVariable", set["TypeConstraint"]] | None = None
         self.func_typevar = TypeVariable(name=func.name)
         self.delayed_type_constraints = None
         self.ret_val_size = None

angr/analyses/veritesting.py

@@ -1,7 +1,6 @@
 import logging
 from collections import defaultdict
 from functools import cmp_to_key
-from typing import Tuple
 
 import networkx
 
@@ -235,7 +234,7 @@ class Veritesting(Analysis):
 
         self.result, self.final_manager = self._veritesting()
 
-    def _veritesting(self) -> Tuple[bool, SimulationManager]:
+    def _veritesting(self) -> tuple[bool, SimulationManager]:
         """
         Perform static symbolic execution starting from the given point.
         :returns: tuple of the success/failure of veritesting and the subsequent SimulationManager after execution

angr/analyses/vfg.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Any, Callable, DefaultDict, Dict, List, Generator, Optional, Set, Tuple, Union
+from typing import TYPE_CHECKING, Any, DefaultDict, Optional
+from collections.abc import Callable, Generator
 import logging
 from collections import defaultdict
 
@@ -45,24 +46,24 @@ class VFGJob(CFGJobBase):
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
 
-        self.call_stack_suffix: List = []
-        self.vfg_node: Optional[VFGNode] = None
+        self.call_stack_suffix: list = []
+        self.vfg_node: VFGNode | None = None
         self.is_call_jump = None
         self.call_target = None
         self.dbg_exit_status = {}
         self.is_return_jump = None
 
-        self.sim_successors: Optional[SimSuccessors] = None
+        self.sim_successors: SimSuccessors | None = None
 
         # if this job has a call successor, do we plan to skip the call successor or not
         self.call_skipped = False
         # if the call is skipped, calling stack of the skipped function is saved in `call_context_key`
-        self.call_function_key: Optional[FunctionKey] = None
+        self.call_function_key: FunctionKey | None = None
 
-        self.call_task: Optional[CallAnalysis] = None
+        self.call_task: CallAnalysis | None = None
 
     @property
-    def block_id(self) -> Optional[BlockID]:
+    def block_id(self) -> BlockID | None:
         return self._block_id
 
     def callstack_repr(self, kb: "KnowledgeBase"):
@@ -134,13 +135,13 @@ class FunctionAnalysis(AnalysisTask):
     Analyze a function, generate fix-point states from all endpoints of that function, and then merge them to one state.
     """
 
-    def __init__(self, function_address: int, return_address: Optional[int]) -> None:
+    def __init__(self, function_address: int, return_address: int | None) -> None:
         super().__init__()
 
         self.function_address = function_address
         self.return_address = return_address
 
-        self.call_analysis: Optional[AnalysisTask] = None
+        self.call_analysis: AnalysisTask | None = None
 
         # tracks all jobs that are live currently
         self.jobs = []
@@ -168,8 +169,8 @@ class CallAnalysis(AnalysisTask):
         self,
         address: int,
         return_address: None,
-        function_analysis_tasks: Optional[List[Any]] = None,
-        mergeable_plugins: Optional[Tuple[str, str]] = None,
+        function_analysis_tasks: list[Any] | None = None,
+        mergeable_plugins: tuple[str, str] | None = None,
     ) -> None:
         super().__init__()
 
@@ -235,14 +236,14 @@ class VFGNode:
         """
         self.key = key
         self.addr = addr
-        self.state: Optional[SimState] = None
-        self.widened_state: Optional[SimState] = None
+        self.state: SimState | None = None
+        self.widened_state: SimState | None = None
         self.narrowing_times: int = 0
-        self.all_states: List[SimState] = []
-        self.events: List = []
-        self.input_variables: List = []
-        self.actions: List = []
-        self.final_states: List[SimState] = []
+        self.all_states: list[SimState] = []
+        self.events: list = []
+        self.input_variables: list = []
+        self.actions: list = []
+        self.final_states: list[SimState] = []
 
         if state:
             self.all_states.append(state)
@@ -307,20 +308,20 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
 
     def __init__(
         self,
-        cfg: Optional[CFGEmulated] = None,
+        cfg: CFGEmulated | None = None,
         context_sensitivity_level: int = 2,
-        start: Optional[int] = None,
-        function_start: Optional[int] = None,
+        start: int | None = None,
+        function_start: int | None = None,
         interfunction_level: int = 0,
         initial_state: Optional["SimState"] = None,
-        avoid_runs: Optional[List[int]] = None,
-        remove_options: Optional[Set[str]] = None,
-        timeout: Optional[int] = None,
+        avoid_runs: list[int] | None = None,
+        remove_options: set[str] | None = None,
+        timeout: int | None = None,
         max_iterations_before_widening: int = 8,
         max_iterations: int = 40,
         widening_interval: int = 3,
-        final_state_callback: Optional[Callable[["SimState", CallStack], Any]] = None,
-        status_callback: Optional[Callable[["VFG"], Any]] = None,
+        final_state_callback: Callable[["SimState", CallStack], Any] | None = None,
+        status_callback: Callable[["VFG"], Any] | None = None,
         record_function_final_states: bool = False,
     ) -> None:
         """
@@ -352,7 +353,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
         self._function_start: int = function_start if function_start is not None else self._start
 
         # Other parameters
-        self._avoid_runs: List[int] = [] if avoid_runs is None else avoid_runs
+        self._avoid_runs: list[int] = [] if avoid_runs is None else avoid_runs
         self._context_sensitivity_level = context_sensitivity_level
         self._interfunction_level = interfunction_level
         self._state_options_to_remove = set() if remove_options is None else remove_options
@@ -369,46 +370,46 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
 
         self._record_function_final_states = record_function_final_states
 
-        self._nodes: Dict[BlockID, VFGNode] = {}  # all the vfg nodes, keyed on block IDs
-        self._normal_states: Dict[BlockID, SimState] = (
+        self._nodes: dict[BlockID, VFGNode] = {}  # all the vfg nodes, keyed on block IDs
+        self._normal_states: dict[BlockID, SimState] = (
             {}
         )  # Last available state for each program point without widening
-        self._widened_states: Dict[BlockID, SimState] = {}  # States on which widening has occurred
+        self._widened_states: dict[BlockID, SimState] = {}  # States on which widening has occurred
 
         # Initial states of each function, which is context sensitive
         # It maps function key to its states
-        self._function_initial_states: DefaultDict[int, Dict[int, SimState]] = defaultdict(dict)
+        self._function_initial_states: DefaultDict[int, dict[int, SimState]] = defaultdict(dict)
         # Final states of each function, right after `ret` is called. Also context sensitive.
         # even if a function may have multiple return sites, as long as they all return to the same place, there is
         # only one final state of that function.
-        self._function_final_states: DefaultDict[int, Dict[int, SimState]] = defaultdict(dict)
+        self._function_final_states: DefaultDict[int, dict[int, SimState]] = defaultdict(dict)
 
         # All final states are put in this list
-        self.final_states: List[SimState] = []
+        self.final_states: list[SimState] = []
 
-        self._state_initialization_map: DefaultDict[int, List[Tuple[int, int]]] = defaultdict(list)
+        self._state_initialization_map: DefaultDict[int, list[tuple[int, int]]] = defaultdict(list)
 
-        self._exit_targets: DefaultDict[Tuple[Union[int, None], ...], List[Tuple[BlockID, str]]] = defaultdict(
+        self._exit_targets: DefaultDict[tuple[int | None, ...], list[tuple[BlockID, str]]] = defaultdict(
             list
         )  # A dict to log edges and the jumpkind between each basic block
         # A dict to record all blocks that returns to a specific address
-        self._return_target_sources: DefaultDict[int, List[int]] = defaultdict(list)
+        self._return_target_sources: DefaultDict[int, list[int]] = defaultdict(list)
 
-        self._pending_returns: Dict[BlockID, PendingJob] = {}
+        self._pending_returns: dict[BlockID, PendingJob] = {}
 
-        self._thumb_addrs: Set[int] = set()  # set of all addresses that are code in thumb mode
+        self._thumb_addrs: set[int] = set()  # set of all addresses that are code in thumb mode
 
-        self._final_address: Optional[int] = (
+        self._final_address: int | None = (
             None  # Address of the very last instruction. The analysis is terminated there.
         )
 
-        self._function_merge_points: Dict[int, List[int]] = {}
-        self._function_widening_points: Dict[int, List[int]] = {}
-        self._function_node_addrs: Dict[int, List[int]] = {}  # sorted in reverse post-order
+        self._function_merge_points: dict[int, list[int]] = {}
+        self._function_widening_points: dict[int, list[int]] = {}
+        self._function_node_addrs: dict[int, list[int]] = {}  # sorted in reverse post-order
 
         self._mergeable_plugins = ("memory", "registers")
 
-        self._task_stack: List[FunctionAnalysis] = []
+        self._task_stack: list[FunctionAnalysis] = []
 
         self._tracing_times: DefaultDict[BlockID, int] = defaultdict(int)
 
@@ -427,7 +428,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
         return self._task_stack[-1].function_address
 
     @property
-    def _top_task(self) -> Optional[FunctionAnalysis]:
+    def _top_task(self) -> FunctionAnalysis | None:
         """
         Get the first task in the stack.
 
@@ -462,7 +463,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
     # Public methods
     #
 
-    def get_any_node(self, addr: int) -> Optional[VFGNode]:
+    def get_any_node(self, addr: int) -> VFGNode | None:
         """
         Get any VFG node corresponding to the basic block at @addr.
         Note that depending on the context sensitivity level, there might be
@@ -610,7 +611,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
 
         # return self._cfg.get_topological_order(self._cfg.get_node(job.block_id))
 
-    def _job_key(self, job: VFGJob) -> Optional[BlockID]:
+    def _job_key(self, job: VFGJob) -> BlockID | None:
         """
         Return the block ID of the job. Two or more jobs owning the same block ID will be merged together.
 
@@ -735,7 +736,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
 
         self._graph_add_edge(src_block_id, block_id, jumpkind=job.jumpkind, src_exit_stmt_idx=src_exit_stmt_idx)
 
-    def _get_successors(self, job: VFGJob) -> List[SimState]:
+    def _get_successors(self, job: VFGJob) -> list[SimState]:
         # Extract initial values
         state = job.state
         addr = job.addr
@@ -743,7 +744,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
         # Obtain successors
         if addr not in self._avoid_runs:
             assert job.sim_successors is not None
-            all_successors: List["SimState"] = (
+            all_successors: list["SimState"] = (
                 job.sim_successors.flat_successors + job.sim_successors.unconstrained_successors
             )
         else:
@@ -809,8 +810,8 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
         return all_successors
 
     def _handle_successor(
-        self, job: VFGJob, successor: SimState, all_successors: List[SimState]
-    ) -> List[Union[VFGJob, Any]]:  # pylint:disable=arguments-renamed
+        self, job: VFGJob, successor: SimState, all_successors: list[SimState]
+    ) -> list[VFGJob | Any]:  # pylint:disable=arguments-renamed
         """
         Process each successor generated by the job, and return a new list of succeeding jobs.
 
@@ -999,7 +1000,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
         return new_jobs
 
     def _post_job_handling(
-        self, job: VFGJob, new_jobs: List[Union[VFGJob, Any]], successors: List[SimState]
+        self, job: VFGJob, new_jobs: list[VFGJob | Any], successors: list[SimState]
     ) -> None:  # pylint:disable=unused-argument
         # Debugging output
         if l.level == logging.DEBUG:
@@ -1261,7 +1262,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
     # Helper methods
     #
 
-    def _prepare_initial_state(self, function_start: int, state: Optional[SimState]) -> SimState:
+    def _prepare_initial_state(self, function_start: int, state: SimState | None) -> SimState:
         """
         Get the state to start the analysis for function.
 
@@ -1404,7 +1405,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
 
         return self._nodes[block_id]
 
-    def _graph_add_edge(self, src_block_id: Optional[BlockID], dst_block_id: BlockID, **kwargs) -> None:
+    def _graph_add_edge(self, src_block_id: BlockID | None, dst_block_id: BlockID, **kwargs) -> None:
         """
         Add an edge onto the graph.
 
@@ -1429,7 +1430,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
     # Other methods
     #
 
-    def _get_simsuccessors(self, state: SimState, addr: int) -> Tuple[SimSuccessors, bool, bool]:
+    def _get_simsuccessors(self, state: SimState, addr: int) -> tuple[SimSuccessors, bool, bool]:
         error_occured = False
         restart_analysis = False
 
@@ -1474,7 +1475,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
 
     def _create_new_jobs(
         self, job: VFGJob, successor: "SimState", new_block_id: BlockID, new_call_stack: CallStack
-    ) -> List[Union[VFGJob, Any]]:
+    ) -> list[VFGJob | Any]:
         """
         Create a list of new VFG jobs for the successor state.
 
@@ -1740,7 +1741,7 @@ class VFG(ForwardAnalysis[SimState, VFGNode, VFGJob, BlockID], Analysis):  # pyl
         return reg_sp_si
 
     def _create_callstack(
-        self, job: VFGJob, successor_ip: int, jumpkind: str, fakeret_successor: Optional[SimState]
+        self, job: VFGJob, successor_ip: int, jumpkind: str, fakeret_successor: SimState | None
     ) -> CallStack:
         addr = job.addr
 

angr/analyses/xrefs.py

@@ -1,4 +1,3 @@
-from typing import Optional
 from collections import defaultdict
 
 import claripy
@@ -40,7 +39,7 @@ class SimEngineXRefsVEX(
         )
 
     @staticmethod
-    def extract_value_if_concrete(expr) -> Optional[int]:
+    def extract_value_if_concrete(expr) -> int | None:
         """
         Extract the concrete value from expr if it is a concrete claripy AST.
 

angr/angrdb/db.py

@@ -1,4 +1,4 @@
-from typing import List, Dict, Any, Optional, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 import time
 from contextlib import contextmanager
 
@@ -90,7 +90,7 @@ class AngrDB:
             return None
         return db_info.value
 
-    def update_dbinfo(self, session, extra_info: Optional[Dict[str, str]] = None):
+    def update_dbinfo(self, session, extra_info: dict[str, str] | None = None):
         """
         Update the information in database.
 
@@ -105,7 +105,7 @@ class AngrDB:
             for key, value in extra_info.items():
                 self.save_info(session, str(key), str(value))
 
-    def get_dbinfo(self, session, extra_info: Optional[Dict[str, str]] = None):
+    def get_dbinfo(self, session, extra_info: dict[str, str] | None = None):
         """
         Get database information.
 
@@ -145,7 +145,7 @@ class AngrDB:
 
         return version == self.VERSION
 
-    def dump(self, db_path, kbs: Optional[List["KnowledgeBase"]] = None, extra_info: Optional[Dict[str, Any]] = None):
+    def dump(self, db_path, kbs: list["KnowledgeBase"] | None = None, extra_info: dict[str, Any] | None = None):
         db_str = "sqlite:///%s" % db_path
 
         with self.open_db(db_str) as Session:
@@ -166,9 +166,9 @@ class AngrDB:
     def load(
         self,
         db_path: str,
-        kb_names: Optional[List[str]] = None,
-        other_kbs: Optional[Dict[str, "KnowledgeBase"]] = None,
-        extra_info: Optional[Dict[str, Any]] = None,
+        kb_names: list[str] | None = None,
+        other_kbs: dict[str, "KnowledgeBase"] | None = None,
+        extra_info: dict[str, Any] | None = None,
     ):
         db_str = "sqlite:///%s" % db_path
 

angr/angrdb/serializers/kb.py

@@ -90,18 +90,21 @@ class KnowledgeBaseSerializer:
         if structured_code is not None:
             kb.structured_code = structured_code
 
-        # fill in CFGNode.function_address
-        for func in funcs.values():
-            for block_addr in func.block_addrs_set:
-                node = cfg_model.get_any_node(block_addr)
-                if node is not None:
-                    node.function_address = func.addr
-
-        # re-initialize CFGModel.insn_addr_to_memory_data
-        # fill in insn_addr_to_memory_data
-        for xrefs in xrefs.xrefs_by_ins_addr.values():
-            for xref in xrefs:
-                if xref.ins_addr is not None and xref.memory_data is not None:
-                    cfg_model.insn_addr_to_memory_data[xref.ins_addr] = xref.memory_data
+        if cfg_model is not None:
+            # CFG may not exist for all knowledge bases
+
+            # fill in CFGNode.function_address
+            for func in funcs.values():
+                for block_addr in func.block_addrs_set:
+                    node = cfg_model.get_any_node(block_addr)
+                    if node is not None:
+                        node.function_address = func.addr
+
+            # re-initialize CFGModel.insn_addr_to_memory_data
+            # fill in insn_addr_to_memory_data
+            for xrefs in xrefs.xrefs_by_ins_addr.values():
+                for xref in xrefs:
+                    if xref.ins_addr is not None and xref.memory_data is not None:
+                        cfg_model.insn_addr_to_memory_data[xref.ins_addr] = xref.memory_data
 
         return kb

angr/angrdb/serializers/loader.py

@@ -1,5 +1,4 @@
 from io import BytesIO
-from typing import List
 
 import cle
 
@@ -58,7 +57,7 @@ class LoaderSerializer:
         all_objects = {}  # path to object
         main_object = None
 
-        db_objects: List[DbObject] = session.query(DbObject)
+        db_objects: list[DbObject] = session.query(DbObject)
 
         for db_o in db_objects:
             all_objects[db_o.path] = db_o

angr/angrdb/serializers/structured_code.py

@@ -1,4 +1,4 @@
-from typing import Dict, Any, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 import json
 import pickle
 
@@ -64,7 +64,7 @@ class StructuredCodeManagerSerializer:
             session.add(db_code)
 
     @staticmethod
-    def dict_strkey_to_intkey(d: Dict[str, Any]) -> Dict[int, Any]:
+    def dict_strkey_to_intkey(d: dict[str, Any]) -> dict[int, Any]:
         new_d = {}
 
         for key, value in d.items():

angr/annocfg.py

@@ -1,5 +1,4 @@
 from collections import defaultdict
-from typing import Dict, List, Union
 import logging
 
 import networkx
@@ -30,7 +29,7 @@ class AnnotatedCFG:
         self._cfg = None
         self._target = None
 
-        self._run_statement_whitelist: Dict[int, Union[List[int], bool]] = defaultdict(list)
+        self._run_statement_whitelist: dict[int, list[int] | bool] = defaultdict(list)
         self._exit_taken = defaultdict(list)
         self._addr_to_run = {}
         self._addr_to_last_stmt_id = {}

angr/block.py

@@ -1,6 +1,5 @@
 # pylint:disable=wrong-import-position,arguments-differ
 import logging
-from typing import List, Optional, Tuple
 
 import pyvex
 from pyvex import IRSB
@@ -151,6 +150,7 @@ class Block(Serializable):
         project=None,
         arch=None,
         size=None,
+        max_size=None,
         byte_string=None,
         vex=None,
         thumb=False,
@@ -164,6 +164,7 @@ class Block(Serializable):
         cross_insn_opt=True,
         load_from_ro_regions=False,
         initial_regs=None,
+        skip_stmts=False,
     ):
         # set up arch
         if project is not None:
@@ -189,7 +190,7 @@ class Block(Serializable):
         self.thumb = thumb
         self.addr = addr
         self._opt_level = opt_level
-        self._initial_regs: Optional[List[Tuple[int, int, int]]] = initial_regs if collect_data_refs else None
+        self._initial_regs: list[tuple[int, int, int]] | None = initial_regs if collect_data_refs else None
 
         if self._project is None and byte_string is None:
             raise ValueError('"byte_string" has to be specified if "project" is not provided.')
@@ -207,6 +208,7 @@ class Block(Serializable):
                     state=backup_state,
                     insn_bytes=byte_string,
                     addr=addr,
+                    size=max_size,
                     thumb=thumb,
                     extra_stop_points=extra_stop_points,
                     opt_level=opt_level,
@@ -216,13 +218,18 @@ class Block(Serializable):
                     collect_data_refs=collect_data_refs,
                     load_from_ro_regions=load_from_ro_regions,
                     cross_insn_opt=cross_insn_opt,
+                    skip_stmts=skip_stmts,
                 )
                 if self._initial_regs:
                     self.reset_initial_regs()
                 size = vex.size
 
-        self._vex = vex
-        self._vex_nostmt = None
+        if skip_stmts:
+            self._vex = None
+            self._vex_nostmt = vex
+        else:
+            self._vex = vex
+            self._vex_nostmt = None
         self._disassembly = None
         self._capstone = None
         self.size = size
@@ -232,9 +239,12 @@ class Block(Serializable):
         self._load_from_ro_regions = load_from_ro_regions
 
         self._instructions = num_inst
-        self._instruction_addrs: List[int] = []
+        self._instruction_addrs: list[int] = []
 
-        self._parse_vex_info(self._vex)
+        if skip_stmts:
+            self._parse_vex_info(self._vex_nostmt)
+        else:
+            self._parse_vex_info(self._vex)
 
         if byte_string is None:
             if backup_state is not None: