angr 9.2.116__py3-none-manylinux2014_aarch64.whl → 9.2.118__py3-none-manylinux2014_aarch64.whl

angr/analyses/decompiler/structured_codegen/c.py

@@ -1,5 +1,6 @@
 # pylint:disable=missing-class-docstring,too-many-boolean-expressions,unused-argument,no-self-use
-from typing import Optional, Any, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 from collections.abc import Callable
 from collections import defaultdict, Counter
 import logging
@@ -120,7 +121,7 @@ def qualifies_for_implicit_cast(ty1, ty2):
     return ty1.size <= ty2.size
 
 
-def extract_terms(expr: "CExpression") -> tuple[int, list[tuple[int, "CExpression"]]]:
+def extract_terms(expr: CExpression) -> tuple[int, list[tuple[int, CExpression]]]:
     # handle unnecessary type casts
     if isinstance(expr, CTypeCast):
         expr = MakeTypecastsImplicit.collapse(expr.dst_type, expr.expr)
@@ -137,37 +138,35 @@ def extract_terms(expr: "CExpression") -> tuple[int, list[tuple[int, "CExpressio
     if isinstance(expr, CConstant):
         return expr.value, []
     # elif isinstance(expr, CUnaryOp) and expr.op == 'Minus'
-    elif isinstance(expr, CBinaryOp) and expr.op == "Add":
+    if isinstance(expr, CBinaryOp) and expr.op == "Add":
         c1, t1 = extract_terms(expr.lhs)
         c2, t2 = extract_terms(expr.rhs)
         return c1 + c2, t1 + t2
-    elif isinstance(expr, CBinaryOp) and expr.op == "Sub":
+    if isinstance(expr, CBinaryOp) and expr.op == "Sub":
         c1, t1 = extract_terms(expr.lhs)
         c2, t2 = extract_terms(expr.rhs)
         return c1 - c2, t1 + [(-c, t) for c, t in t2]
-    elif isinstance(expr, CBinaryOp) and expr.op == "Mul":
+    if isinstance(expr, CBinaryOp) and expr.op == "Mul":
         if isinstance(expr.lhs, CConstant):
             c, t = extract_terms(expr.rhs)
             return c * expr.lhs.value, [(c1 * expr.lhs.value, t1) for c1, t1 in t]
-        elif isinstance(expr.rhs, CConstant):
+        if isinstance(expr.rhs, CConstant):
             c, t = extract_terms(expr.lhs)
             return c * expr.rhs.value, [(c1 * expr.rhs.value, t1) for c1, t1 in t]
-        else:
-            return 0, [(1, expr)]
-    elif isinstance(expr, CBinaryOp) and expr.op == "Shl":
+        return 0, [(1, expr)]
+    if isinstance(expr, CBinaryOp) and expr.op == "Shl":
         if isinstance(expr.rhs, CConstant):
             c, t = extract_terms(expr.lhs)
             return c << expr.rhs.value, [(c1 << expr.rhs.value, t1) for c1, t1 in t]
         return 0, [(1, expr)]
-    else:
-        return 0, [(1, expr)]
+    return 0, [(1, expr)]
 
 
-def is_machine_word_size_type(type_: SimType, arch: "archinfo.Arch") -> bool:
+def is_machine_word_size_type(type_: SimType, arch: archinfo.Arch) -> bool:
     return isinstance(type_, SimTypeReg) and type_.size == arch.bits
 
 
-def guess_value_type(value: int, project: "angr.Project") -> SimType | None:
+def guess_value_type(value: int, project: angr.Project) -> SimType | None:
     if project.kb.functions.contains_addr(value):
         # might be a function pointer
         return SimTypePointer(SimTypeBottom(label="void")).with_arch(project.arch)
@@ -260,7 +259,7 @@ class CConstruct:
     __slots__ = ("codegen",)
 
     def __init__(self, codegen):
-        self.codegen: "StructuredCodeGenerator" = codegen
+        self.codegen: StructuredCodeGenerator = codegen
 
     def c_repr(self, indent=0, pos_to_node=None, pos_to_addr=None, addr_to_pos=None):
         """
@@ -303,22 +302,24 @@ class CConstruct:
 
                     # add all variables, constants, and function calls to map_pos_to_node for highlighting
                     # add ops to pos_to_node but NOT ast_to_pos
-                    if isinstance(
-                        obj,
-                        (
-                            CVariable,
-                            CConstant,
-                            CStructField,
-                            CIndexedVariable,
-                            CVariableField,
-                            CBinaryOp,
-                            CUnaryOp,
-                            CAssignment,
-                            CFunctionCall,
-                        ),
+                    if (
+                        isinstance(
+                            obj,
+                            (
+                                CVariable,
+                                CConstant,
+                                CStructField,
+                                CIndexedVariable,
+                                CVariableField,
+                                CBinaryOp,
+                                CUnaryOp,
+                                CAssignment,
+                                CFunctionCall,
+                            ),
+                        )
+                        and pos_to_node is not None
                     ):
-                        if pos_to_node is not None:
-                            pos_to_node.add_mapping(pos, len(s), obj)
+                        pos_to_node.add_mapping(pos, len(s), obj)
 
                 # add (), {}, [], and [20] to mapping for highlighting as well as the full functions name
                 elif isinstance(obj, (CClosingObject, CFunction, CArrayTypeLength, CStructFieldNameDef)):
@@ -369,7 +370,7 @@ class CConstruct:
         return "".join(mapper(self.c_repr_chunks(indent)))
 
     def c_repr_chunks(self, indent=0, asexpr=False):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @staticmethod
     def indent_str(indent=0):
@@ -400,7 +401,7 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
         addr,
         name,
         functy: SimTypeFunction,
-        arg_list: list["CVariable"],
+        arg_list: list[CVariable],
         statements,
         variables_in_use,
         variable_manager,
@@ -417,13 +418,13 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
         self.arg_list = arg_list
         self.statements = statements
         self.variables_in_use = variables_in_use
-        self.variable_manager: "VariableManagerInternal" = variable_manager
+        self.variable_manager: VariableManagerInternal = variable_manager
         self.demangled_name = demangled_name
         self.unified_local_vars: dict[SimVariable, set[tuple[CVariable, SimType]]] = self.get_unified_local_vars()
         self.show_demangled_name = show_demangled_name
         self.omit_header = omit_header
 
-    def get_unified_local_vars(self) -> dict[SimVariable, set[tuple["CVariable", SimType]]]:
+    def get_unified_local_vars(self) -> dict[SimVariable, set[tuple[CVariable, SimType]]]:
         unified_to_var_and_types: dict[SimVariable, set[tuple[CVariable, SimType]]] = defaultdict(set)
 
         arg_set: set[SimVariable] = set()
@@ -559,10 +560,7 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
 
         if self.codegen.show_externs and self.codegen.cexterns:
             for v in sorted(self.codegen.cexterns, key=lambda v: v.variable.name):
-                if v.type is None:
-                    varname = v.c_repr()
-                else:
-                    varname = v.variable.name
+                varname = v.c_repr() if v.type is None else v.variable.name
                 yield "extern ", None
                 yield from type_to_c_repr_chunks(v.type, name=varname, name_type=v, full=False)
                 yield ";\n", None
@@ -659,7 +657,7 @@ class CExpression(CConstruct):
 
     @property
     def type(self):
-        raise NotImplementedError("Class %s does not implement type()." % type(self))
+        raise NotImplementedError(f"Class {type(self)} does not implement type().")
 
     def set_type(self, v):
         self._type = v
@@ -1229,7 +1227,7 @@ class CFunctionCall(CStatement, CExpression):
         super().__init__(**kwargs)
 
         self.callee_target = callee_target
-        self.callee_func: Optional["Function"] = callee_func
+        self.callee_func: Function | None = callee_func
         self.args = args if args is not None else []
         self.returning = returning
         self.ret_expr = ret_expr
@@ -1258,10 +1256,7 @@ class CFunctionCall(CStatement, CExpression):
     def type(self):
         if self.is_expr:
             return self.prototype.returnty or SimTypeInt(signed=False).with_arch(self.codegen.project.arch)
-        else:
-            raise AngrRuntimeError(
-                "CFunctionCall.type should not be accessed if the function call is used as a statement."
-            )
+        raise AngrRuntimeError("CFunctionCall.type should not be accessed if the function call is used as a statement.")
 
     def _is_target_ambiguous(self, func_name: str) -> bool:
         """
@@ -1409,7 +1404,6 @@ class CUnsupportedStatement(CStatement):
 
 
 class CDirtyStatement(CExpression):
-
     __slots__ = ("dirty",)
 
     def __init__(self, dirty, **kwargs):
@@ -1535,10 +1529,9 @@ class CVariable(CExpression):
 
         if v.name:
             return v.name
-        elif isinstance(v, SimTemporaryVariable):
+        if isinstance(v, SimTemporaryVariable):
             return "tmp_%d" % v.tmp_id
-        else:
-            return str(v)
+        return str(v)
 
     def c_repr_chunks(self, indent=0, asexpr=False):
         yield self.name, self
@@ -1559,11 +1552,8 @@ class CIndexedVariable(CExpression):
         if self._type is None and self.variable.type is not None:
             u = unpack_typeref(self.variable.type)
             if isinstance(u, SimTypePointer):
-                if isinstance(u.pts_to, (SimTypeArray, SimTypeFixedSizeArray)):
-                    # special case: (&array)[x]
-                    u = u.pts_to.elem_type
-                else:
-                    u = u.pts_to
+                # special case: (&array)[x]
+                u = u.pts_to.elem_type if isinstance(u.pts_to, (SimTypeArray, SimTypeFixedSizeArray)) else u.pts_to
                 u = unpack_typeref(u)
             elif isinstance(u, (SimTypeArray, SimTypeFixedSizeArray)):
                 u = u.elem_type
@@ -1650,9 +1640,8 @@ class CUnaryOp(CExpression):
 
     @property
     def type(self):
-        if self._type is None:
-            if self.operand is not None and hasattr(self.operand, "type"):
-                self._type = self.operand.type
+        if self._type is None and self.operand is not None and hasattr(self.operand, "type"):
+            self._type = self.operand.type
         return self._type
 
     def c_repr_chunks(self, indent=0, asexpr=False):
@@ -1673,7 +1662,7 @@ class CUnaryOp(CExpression):
         if handler is not None:
             yield from handler()
         else:
-            yield "UnaryOp %s" % (self.op), self
+            yield f"UnaryOp {self.op}", self
 
     #
     # Handlers
@@ -1773,8 +1762,7 @@ class CBinaryOp(CExpression):
         if lhs_signed == rhs_signed:
             if lhs_ty.size > rhs_ty.size:
                 return lhs_ty
-            else:
-                return rhs_ty
+            return rhs_ty
 
         if lhs_signed:
             signed_ty = lhs_ty
@@ -1870,13 +1858,12 @@ class CBinaryOp(CExpression):
 
     def _c_repr_chunks(self, op):
         skip_op_and_rhs = False
-        if self._cstyle_null_cmp:
-            if self._has_const_null_rhs():
-                if self.op == "CmpEQ":
-                    skip_op_and_rhs = True
-                    yield "!", None
-                elif self.op == "CmpNE":
-                    skip_op_and_rhs = True
+        if self._cstyle_null_cmp and self._has_const_null_rhs():
+            if self.op == "CmpEQ":
+                skip_op_and_rhs = True
+                yield "!", None
+            elif self.op == "CmpNE":
+                skip_op_and_rhs = True
         # lhs
         if isinstance(self.lhs, CBinaryOp) and self.op_precedence > self.lhs.op_precedence:
             paren = CClosingObject("(")
@@ -2059,8 +2046,7 @@ class CConstant(CExpression):
         ident = (self.tags or {}).get("ins_addr", None)
         if ident is not None:
             return ("inst", ident)
-        else:
-            return ("val", self.value)
+        return ("val", self.value)
 
     @property
     def fmt(self):
@@ -2094,13 +2080,13 @@ class CConstant(CExpression):
         if result is None:
             result = False
             if isinstance(self.value, int):
-                if self._type is not None:
-                    value_size = self._type.size
-                else:
-                    value_size = None
-                if value_size == 32 and 0xF000_0000 <= self.value <= 0xFFFF_FFFF:
-                    result = True
-                elif value_size == 64 and 0xF000_0000_0000_0000 <= self.value <= 0xFFFF_FFFF_FFFF_FFFF:
+                value_size = self._type.size if self._type is not None else None
+                if (
+                    value_size == 32
+                    and 0xF000_0000 <= self.value <= 0xFFFF_FFFF
+                    or value_size == 64
+                    and 0xF000_0000_0000_0000 <= self.value <= 0xFFFF_FFFF_FFFF_FFFF
+                ):
                     result = True
 
         return result
@@ -2141,10 +2127,9 @@ class CConstant(CExpression):
     def str_to_c_str(_str, prefix: str = ""):
         repr_str = repr(_str)
         base_str = repr_str[1:-1]
-        if repr_str[0] == "'":
-            # check if there's double quotes in the body
-            if '"' in base_str:
-                base_str = base_str.replace('"', '\\"')
+        # check if there's double quotes in the body
+        if repr_str[0] == "'" and '"' in base_str:
+            base_str = base_str.replace('"', '\\"')
         return f'{prefix}"{base_str}"'
 
     def c_repr_chunks(self, indent=0, asexpr=False):
@@ -2154,7 +2139,7 @@ class CConstant(CExpression):
 
         # default priority: string references -> variables -> other reference values
         if self.reference_values is not None:
-            for ty, v in self.reference_values.items():  # pylint:disable=unused-variable
+            for _ty, v in self.reference_values.items():  # pylint:disable=unused-variable
                 if isinstance(v, MemoryData) and v.sort == MemoryDataSort.String:
                     yield CConstant.str_to_c_str(v.content.decode("utf-8")), self
                     return
@@ -2179,11 +2164,7 @@ class CConstant(CExpression):
                 yield CConstant.str_to_c_str(v), self
             elif isinstance(self._type, SimTypePointer) and isinstance(self._type.pts_to, SimTypeWideChar):
                 refval = self.reference_values[self._type]
-                if isinstance(refval, MemoryData):
-                    v = refval.content.decode("utf_16_le")
-                else:
-                    # it's a string
-                    v = refval
+                v = refval.content.decode("utf_16_le") if isinstance(refval, MemoryData) else refval  # it's a string
                 yield CConstant.str_to_c_str(v, prefix="L"), self
             else:
                 if isinstance(self.reference_values[self._type], int):
@@ -2217,9 +2198,8 @@ class CConstant(CExpression):
         :return:        The formatted string.
         """
 
-        if self.fmt_float:
-            if 0 < value <= 0xFFFF_FFFF:
-                return str(struct.unpack("f", struct.pack("I", value))[0])
+        if self.fmt_float and 0 < value <= 0xFFFF_FFFF:
+            return str(struct.unpack("f", struct.pack("I", value))[0])
 
         if self.fmt_char:
             if value < 0:
@@ -2227,10 +2207,8 @@ class CConstant(CExpression):
             value &= 0xFF
             return repr(chr(value)) if value < 0x80 else f"'\\x{value:x}'"
 
-        if self.fmt_double:
-            if 0 < value <= 0xFFFF_FFFF_FFFF_FFFF:
-                str_value = str(struct.unpack("d", struct.pack("Q", value))[0])
-                return str_value
+        if self.fmt_double and 0 < value <= 0xFFFF_FFFF_FFFF_FFFF:
+            return str(struct.unpack("d", struct.pack("Q", value))[0])
 
         if self.fmt_neg:
             if value > 0:
@@ -2448,6 +2426,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             Expr.ITE: self._handle_Expr_ITE,
             Expr.Reinterpret: self._handle_Reinterpret,
             Expr.MultiStatementExpression: self._handle_MultiStatementExpression,
+            Expr.VirtualVariable: self._handle_VirtualVariable,
         }
 
         self._func = func
@@ -2523,10 +2502,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         # memo
         self.ailexpr2cnode = {}
 
-        if self._func_args:
-            arg_list = [self._variable(arg, None) for arg in self._func_args]
-        else:
-            arg_list = []
+        arg_list = [self._variable(arg, None) for arg in self._func_args] if self._func_args else []
 
         obj = self._handle(self._sequence)
 
@@ -2619,8 +2595,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
     def _get_variable_type(self, var, is_global=False):
         if is_global:
             return self._variable_kb.variables["global"].get_variable_type(var)
-        else:
-            return self._variable_kb.variables[self._func.addr].get_variable_type(var)
+        return self._variable_kb.variables[self._func.addr].get_variable_type(var)
 
     def _get_derefed_type(self, ty: SimType) -> SimType | None:
         if ty is None:
@@ -2758,10 +2733,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
                 codegen=self,
             )
 
-        if isinstance(expr, CUnaryOp) and expr.op == "Reference":
-            base_expr = expr.operand
-        else:
-            base_expr = None
+        base_expr = expr.operand if isinstance(expr, CUnaryOp) and expr.op == "Reference" else None
 
         if offset == 0:
             data_type = renegotiate_type(data_type, base_type)
@@ -2779,10 +2751,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
                     return _force_type_cast(base_type, data_type, expr)
                 return CUnaryOp("Dereference", expr, codegen=self)
 
-        if base_type.size is None:
-            stride = 1
-        else:
-            stride = base_type.size // self.project.arch.byte_width or 1
+        stride = 1 if base_type.size is None else base_type.size // self.project.arch.byte_width or 1
         index, remainder = divmod(offset, stride)
         if index != 0:
             index = CConstant(index, SimTypeInt(), codegen=self)
@@ -2915,10 +2884,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
                         ),
                         codegen=self,
                     )
-                if result is None:
-                    result = piece
-                else:
-                    result = CBinaryOp(op, result, piece, codegen=self)
+                result = piece if result is None else CBinaryOp(op, result, piece, codegen=self)
             if o_constant != 0:
                 result = CBinaryOp("Add", CConstant(o_constant, SimTypeInt(), codegen=self), result, codegen=self)
 
@@ -3048,14 +3014,11 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
 
         handler: Callable | None = self._handlers.get(node.__class__, None)
         if handler is not None:
-            if isinstance(node, Stmt.Call):
-                # special case for Call
-                converted = handler(node, is_expr=is_expr)
-            else:
-                converted = handler(node, lvalue=lvalue)
+            # special case for Call
+            converted = handler(node, is_expr=is_expr) if isinstance(node, Stmt.Call) else handler(node, lvalue=lvalue)
             self.ailexpr2cnode[(node, is_expr)] = converted
             return converted
-        raise UnsupportedNodeTypeError("Node type %s is not supported yet." % type(node))
+        raise UnsupportedNodeTypeError(f"Node type {type(node)} is not supported yet.")
 
     def _handle_Code(self, node, **kwargs):
         return self._handle(node.node, is_expr=False)
@@ -3081,14 +3044,14 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
                 tags=tags,
                 codegen=self,
             )
-        elif loop_node.sort == "do-while":
+        if loop_node.sort == "do-while":
             return CDoWhileLoop(
                 self._handle(loop_node.condition),
                 None if loop_node.sequence_node is None else self._handle(loop_node.sequence_node, is_expr=False),
                 tags=tags,
                 codegen=self,
             )
-        elif loop_node.sort == "for":
+        if loop_node.sort == "for":
             return CForLoop(
                 None if loop_node.initializer is None else self._handle(loop_node.initializer),
                 None if loop_node.condition is None else self._handle(loop_node.condition),
@@ -3098,8 +3061,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
                 codegen=self,
             )
 
-        else:
-            raise NotImplementedError()
+        raise NotImplementedError
 
     def _handle_Condition(self, condition_node: ConditionNode, **kwargs):
         tags = {"ins_addr": condition_node.addr}
@@ -3113,7 +3075,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
 
         else_node = self._handle(condition_node.false_node, is_expr=False) if condition_node.false_node else None
 
-        code = CIfElse(
+        return CIfElse(
             condition_and_nodes,
             else_node=else_node,
             simplify_else_scope=self.simplify_else_scope
@@ -3123,7 +3085,6 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             tags=tags,
             codegen=self,
         )
-        return code
 
     def _handle_CascadingCondition(self, cond_node: CascadingConditionNode, **kwargs):
         tags = {"ins_addr": cond_node.addr}
@@ -3133,14 +3094,13 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         ]
         else_node = self._handle(cond_node.else_node) if cond_node.else_node is not None else None
 
-        code = CIfElse(
+        return CIfElse(
             condition_and_nodes,
             else_node=else_node,
             tags=tags,
             cstyle_ifs=self.cstyle_ifs,
             codegen=self,
         )
-        return code
 
     def _handle_ConditionalBreak(self, node, **kwargs):
         tags = {"ins_addr": node.addr}
@@ -3172,8 +3132,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         cases = [(idx, self._handle(case, is_expr=False)) for idx, case in node.cases.items()]
         default = self._handle(node.default_node, is_expr=False) if node.default_node is not None else None
         tags = {"ins_addr": node.addr}
-        switch_case = CSwitchCase(switch_expr, cases, default=default, tags=tags, codegen=self)
-        return switch_case
+        return CSwitchCase(switch_expr, cases, default=default, tags=tags, codegen=self)
 
     def _handle_Continue(self, node, **kwargs):
         tags = {"ins_addr": node.addr}
@@ -3235,33 +3194,57 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         return CAssignment(cdst, cdata, tags=stmt.tags, codegen=self)
 
     def _handle_Stmt_Assignment(self, stmt, **kwargs):
-        cdst = self._handle(stmt.dst, lvalue=True)
         csrc = self._handle(stmt.src, lvalue=False)
+        cdst = None
+
+        if isinstance(stmt.dst, Expr.VirtualVariable) and stmt.dst.was_stack:
+
+            def negotiate(old_ty, proposed_ty):
+                # transfer casts from the dst to the src if possible
+                # if we see something like *(size_t*)&v4 = x; where v4 is a pointer, change to v4 = (void*)x;
+                nonlocal csrc
+                if old_ty != proposed_ty and qualifies_for_simple_cast(old_ty, proposed_ty):
+                    csrc = CTypeCast(csrc.type, proposed_ty, csrc, codegen=self)
+                    return proposed_ty
+                return old_ty
+
+            if stmt.dst.variable is not None:
+                if "struct_member_info" in stmt.dst.tags:
+                    offset, var, _ = stmt.dst.struct_member_info
+                    cvar = self._variable(var, stmt.dst.size)
+                else:
+                    cvar = self._variable(stmt.dst.variable, stmt.dst.size)
+                    offset = stmt.dst.variable_offset or 0
+                assert type(offset) is int  # I refuse to deal with the alternative
+
+                cdst = self._access_constant_offset(
+                    self._get_variable_reference(cvar), offset, csrc.type, True, negotiate
+                )
+
+        if cdst is None:
+            cdst = self._handle(stmt.dst, lvalue=True)
 
         return CAssignment(cdst, csrc, tags=stmt.tags, codegen=self)
 
     def _handle_Stmt_Call(self, stmt: Stmt.Call, is_expr: bool = False, **kwargs):
         try:
             # Try to handle it as a normal function call
-            if not isinstance(stmt.target, str):
-                target = self._handle(stmt.target)
-            else:
-                target = stmt.target
+            target = self._handle(stmt.target) if not isinstance(stmt.target, str) else stmt.target
         except UnsupportedNodeTypeError:
             target = stmt.target
 
-        if isinstance(target, CConstant):
-            target_func = self.kb.functions.function(addr=target.value)
-        else:
-            target_func = None
+        target_func = self.kb.functions.function(addr=target.value) if isinstance(target, CConstant) else None
 
         args = []
         if stmt.args is not None:
             for i, arg in enumerate(stmt.args):
                 type_ = None
-                if target_func is not None:
-                    if target_func.prototype is not None and i < len(target_func.prototype.args):
-                        type_ = target_func.prototype.args[i].with_arch(self.project.arch)
+                if (
+                    target_func is not None
+                    and target_func.prototype is not None
+                    and i < len(target_func.prototype.args)
+                ):
+                    type_ = target_func.prototype.args[i].with_arch(self.project.arch)
 
                 if isinstance(arg, Expr.Const):
                     if type_ is None or is_machine_word_size_type(type_, self.project.arch):
@@ -3308,26 +3291,24 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             if stmt.false_target is None
             else CGoto(self._handle(stmt.false_target), None, tags=stmt.tags, codegen=self)
         )
-        ifelse = CIfElse(
+        return CIfElse(
             [(self._handle(stmt.condition), CGoto(self._handle(stmt.true_target), None, tags=stmt.tags, codegen=self))],
             else_node=else_node,
             cstyle_ifs=self.cstyle_ifs,
             tags=stmt.tags,
             codegen=self,
         )
-        return ifelse
 
     def _handle_Stmt_Return(self, stmt: Stmt.Return, **kwargs):
         if not stmt.ret_exprs:
             return CReturn(None, tags=stmt.tags, codegen=self)
-        elif len(stmt.ret_exprs) == 1:
-            ret_expr = stmt.ret_exprs[0]
-            return CReturn(self._handle(ret_expr), tags=stmt.tags, codegen=self)
-        else:
-            # TODO: Multiple return expressions
-            l.warning("StructuredCodeGen does not support multiple return expressions yet. Only picking the first one.")
+        if len(stmt.ret_exprs) == 1:
             ret_expr = stmt.ret_exprs[0]
             return CReturn(self._handle(ret_expr), tags=stmt.tags, codegen=self)
+        # TODO: Multiple return expressions
+        l.warning("StructuredCodeGen does not support multiple return expressions yet. Only picking the first one.")
+        ret_expr = stmt.ret_exprs[0]
+        return CReturn(self._handle(ret_expr), tags=stmt.tags, codegen=self)
 
     def _handle_Stmt_Label(self, stmt: Stmt.Label, **kwargs):
         clabel = CLabel(stmt.name, stmt.ins_addr, stmt.block_idx, tags=stmt.tags, codegen=self)
@@ -3343,10 +3324,11 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
 
     def _handle_Expr_Register(self, expr: Expr.Register, lvalue: bool = False, **kwargs):
         def negotiate(old_ty: SimType, proposed_ty: SimType) -> SimType:
-            if old_ty.size == proposed_ty.size:
-                # we do not allow returning a struct for a primitive type
-                if not (isinstance(proposed_ty, SimStruct) and not isinstance(old_ty, SimStruct)):
-                    return proposed_ty
+            # we do not allow returning a struct for a primitive type
+            if old_ty.size == proposed_ty.size and (
+                not isinstance(proposed_ty, SimStruct) or isinstance(old_ty, SimStruct)
+            ):
+                return proposed_ty
             return old_ty
 
         if expr.variable:
@@ -3357,17 +3339,19 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             # FIXME: The type should be associated to the register expression itself
             type_ = self.default_simtype_from_size(expr.size, signed=False)
             return self._access_constant_offset(self._get_variable_reference(cvar), offset, type_, lvalue, negotiate)
-        else:
-            return CRegister(expr, tags=expr.tags, codegen=self)
+        return CRegister(expr, tags=expr.tags, codegen=self)
 
     def _handle_Expr_Load(self, expr: Expr.Load, **kwargs):
         ty = self.default_simtype_from_size(expr.size)
 
         def negotiate(old_ty: SimType, proposed_ty: SimType) -> SimType:
-            if old_ty.size == proposed_ty.size:
-                # we do not allow returning a struct for a primitive type
-                if not (isinstance(proposed_ty, SimStruct) and not isinstance(old_ty, SimStruct)):
-                    return proposed_ty
+            # we do not allow returning a struct for a primitive type
+            if (
+                old_ty.size == proposed_ty.size
+                and not isinstance(proposed_ty, SimStruct)
+                and not isinstance(old_ty, SimStruct)
+            ):
+                return proposed_ty
             return old_ty
 
         if expr.variable is not None:
@@ -3506,7 +3490,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         elif expr.to_bits == 1:
             dst_type = SimTypeChar()  # FIXME: Add a SimTypeBit?
         else:
-            raise UnsupportedNodeTypeError("Unsupported conversion bits %s." % expr.to_bits)
+            raise UnsupportedNodeTypeError(f"Unsupported conversion bits {expr.to_bits}.")
 
         # convert child
         child = self._handle(expr.operand)
@@ -3565,6 +3549,28 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         cexpr = self._handle(expr.expr)
         return CMultiStatementExpression(cstmts, cexpr, tags=expr.tags, codegen=self)
 
+    def _handle_VirtualVariable(self, expr: Expr.VirtualVariable, **kwargs):
+        if expr.variable:
+            cvar = self._variable(expr.variable, None)
+            if expr.variable.size != expr.size:
+                l.warning(
+                    "VirtualVariable size (%d) and variable size (%d) do not match. Force a type cast.",
+                    expr.size,
+                    expr.variable.size,
+                )
+                src_type = cvar.type
+                dst_type = {
+                    64: SimTypeLongLong(signed=False),
+                    32: SimTypeInt(signed=False),
+                    16: SimTypeShort(signed=False),
+                    8: SimTypeChar(signed=False),
+                }.get(expr.bits, None)
+                if dst_type is not None:
+                    dst_type = dst_type.with_arch(self.project.arch)
+                    return CTypeCast(src_type, dst_type, cvar, tags=expr.tags, codegen=self)
+            return cvar
+        return CDirtyExpression(expr, codegen=self)
+
     def _handle_Expr_StackBaseOffset(self, expr: StackBaseOffset, **kwargs):
         if expr.variable is not None:
             var_thing = self._variable(expr.variable, expr.size)
@@ -3575,8 +3581,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
 
         # FIXME
         stack_base = CFakeVariable("stack_base", SimTypePointer(SimTypeBottom()), codegen=self)
-        ptr = CBinaryOp("Add", stack_base, CConstant(expr.offset, SimTypeInt(), codegen=self), codegen=self)
-        return ptr
+        return CBinaryOp("Add", stack_base, CConstant(expr.offset, SimTypeInt(), codegen=self), codegen=self)
 
 
 class CStructuredCodeWalker: