docs: def state_call(self, addr, *args, **kwargs):
          """
          Create a native or a Java call state.
  
          :param addr:    Soot or native addr of the invoke target.
          :param args:   List of SootArgument values.
          """
          state = kwargs.pop('base_state', None)
          # check if we need to setup a native or a java callsite
          if isinstance(addr, SootAddressDescriptor):
              # JAVA CALLSITE
              # ret addr precedence: ret_addr kwarg > base_state.addr > terminator
              ret_addr = kwargs.pop('ret_addr', state.addr if state else SootAddressTerminator())
              cc = kwargs.pop('cc', SimCCSoot(self.arch))
              if state is None:
                  state = self.state_blank(addr=addr, **kwargs)
              else:
                  state = state.copy()
                  state.regs.ip = addr
              cc.setup_callsite(state, ret_addr, args)
              return state
  
          else:
              # NATIVE CALLSITE
              # setup native argument values
              native_arg_values = []
              for arg in args:
                  if arg.type in ArchSoot.primitive_types or \
                     arg.type == "JNIEnv":
                      # the value of primitive types and the JNIEnv pointer
                      # are just getting copied into the native memory
                      native_arg_value = arg.value
                      if self.arch.bits == 32 and arg.type == "long":
                          # On 32 bit architecture, long values (w/ 64 bit) are copied
                          # as two 32 bit integer
                          # TODO is this correct?
                          upper = native_arg_value.get_bytes(0, 4)
                          lower = native_arg_value.get_bytes(4, 4)
                          idx = args.index(arg)
                          args = args[:idx] \
                                 + (SootArgument(upper, 'int'), SootArgument(lower, 'int')) \
                                 + args[idx+1:]
                          native_arg_values += [upper, lower]
                          continue
                  else:
                      # argument has a relative type
                      # => map Java reference to an opaque reference, which the native code
                      #    can use to access the Java object through the JNI interface
                      native_arg_value = state.jni_references.create_new_reference(obj=arg.value)
                  native_arg_values += [native_arg_value]
  
              # setup native return type
              ret_type = kwargs.pop('ret_type')
              native_ret_type = self.get_native_type(ret_type)
  
              # setup function prototype, so the SimCC know how to init the callsite
              arg_types = [self.get_native_type(arg.type) for arg in args]
              prototype = SimTypeFunction(args=arg_types, returnty=native_ret_type)
              native_cc = self.get_native_cc(func_ty=prototype)
  
              # setup native invoke state
              return self.native_simos.state_call(addr, *native_arg_values,
                                                  base_state=state,
                                                  ret_addr=self.native_return_hook_addr,
                                                  cc=native_cc, **kwargs)