Function merge has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def merge(self, location_db):
        """Merge with another LocationDB @location_db

        WARNING: old reference to @location_db information (such as LocKeys)
        must be retrieved from the updated version of this instance. The

• Read up
  Read up

Function cb_op_plusminus has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def cb_op_plusminus(tokens):
    tokens = tokens[0]
    if len(tokens) == 3:
        # binary op
        assert isinstance(tokens[0], AstNode)

• Read up
  Read up

Function set has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def set(self, vm, addr, val):
        # MemSizedArray assignment
        if isinstance(val, MemSizedArray):
            if val.array_len != self.array_len or len(val) != self.size:
                raise ValueError("Size mismatch in MemSizedArray assignment")

• Read up
  Read up

Function to_type has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def to_type(obj):
    """If possible, return the Type associated with @obj, otherwise raises
    a ValueError.

    Works with a Type instance (returns obj) or a MemType subclass or instance

• Read up
  Read up

Function factor_fields has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

def factor_fields(tree):
    if not isinstance(tree, dict):
        return tree
    if len(tree) != 1:
        return tree

• Read up
  Read up

Function find_path has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def find_path(self, src, dst, cycles_count=0, done=None):
        """
        Searches for paths from @src to @dst
        @src: loc_key of basic block from which it should start
        @dst: loc_key of basic block where it should stop

• Read up
  Read up

Function dot has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def dot(self):
        """Render dot graph with HTML"""

        td_attr = {'align': 'left'}
        nodes_attr = {'shape': 'Mrecord',

• Read up
  Read up

Function msr has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def msr(ir, instr, arg1, arg2, arg3, arg4, arg5, arg6):

Function mrs has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def mrs(ir, insr, arg1, arg2, arg3, arg4, arg5, arg6):

Function mrc has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def mrc(ir, insr, arg1, arg2, arg3, arg4, arg5, arg6):

Function mcr has 8 arguments (exceeds 4 allowed). Consider refactoring.

Open

def mcr(ir, insr, arg1, arg2, arg3, arg4, arg5, arg6):

Consider simplifying this complex logical expression.

Open

        if expr.is_id() or expr.is_int() or expr.is_loc():
            o = color_expr_html(expr, loc_db)
        elif ((isinstance(expr, ExprOp) and expr.op == 'far' and
               isinstance(expr.args[0], ExprMem)) or
              isinstance(expr, ExprMem)):

Function __init__ has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def __init__(self, lifter_model_call, ircfg, mn):

        self.lifter_model_call = lifter_model_call
        self.ircfg = ircfg
        self.mn = mn

• Read up
  Read up

Function getby_offset has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def getby_offset(self, offset):
        """
        Return the set of loc_keys of irblocks containing @offset
        @offset: address
        """

• Read up
  Read up

Function write has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def write(self, offset, expr):
        """
        Write @expr at @offset
        @offset: integer (in bytes)
        @expr: Expr instance value

• Read up
  Read up

Function write has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def write(self, dst, src):
        """
        Update @dst with @src expression
        @dst: ExprId or ExprMem instance
        @src: Expression instance

• Read up
  Read up

Function from_ExprOp has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def from_ExprOp(self, expr):
        if expr.op in self.op_no_translate:
            args = list(map(self.from_expr, expr.args))
            if len(expr.args) == 1:
                return "((%s %s) & 0x%x)" % (

• Read up
  Read up

Function kernel32_ReadFile has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

def kernel32_ReadFile(jitter):
    ret_ad, args = jitter.func_args_stdcall(["hwnd", "lpbuffer",
                                             "nnumberofbytestoread",
                                             "lpnumberofbytesread",
                                             "lpoverlapped"])

• Read up
  Read up

Function prepare_loader_arml has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

def prepare_loader_arml(jitter, argv, envp, auxv, linux_env,
                        hlt_address=0x13371acc):
    """Fill the environment with enough information to run a linux loader

    @jitter: Jitter instance

• Read up
  Read up

Function get has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def get(self, addr, size, addr_size):
        """ Memory access at address @addr of size @size with
        address size @addr_size.
        @addr: an SMT2 expression, the address to read.
        @size: int, size of the read in bits.

• Read up
  Read up