docs: def call_state(self, addr, *args, **kwargs):
          """
          Returns a state object initialized to the start of a given function, as if it were called with given parameters.
  
          :param addr:            The address the state should start at instead of the entry point.
          :param args:            Any additional positional arguments will be used as arguments to the function call.
  
          The following parametrs are optional.
  
          :param base_state:      Use this SimState as the base for the new state instead of a blank state.
          :param cc:              Optionally provide a SimCC object to use a specific calling convention.
          :param ret_addr:        Use this address as the function's return target.
          :param stack_base:      An optional pointer to use as the top of the stack, circa the function entry point
          :param alloc_base:      An optional pointer to use as the place to put excess argument data
          :param grow_like_stack: When allocating data at alloc_base, whether to allocate at decreasing addresses
          :param toc:             The address of the table of contents for ppc64
          :param initial_prefix:  If this is provided, all symbolic registers will hold symbolic values with names
                                  prefixed by this string.
          :param fs:              A dictionary of file names with associated preset SimFile objects.
          :param concrete_fs:     bool describing whether the host filesystem should be consulted when opening files.
          :param chroot:          A path to use as a fake root directory, Behaves similarly to a real chroot. Used only
                                  when concrete_fs is set to True.
          :param kwargs:          Any additional keyword args will be passed to the SimState constructor.
          :return:                The state at the beginning of the function.
          :rtype:                 SimState
  
          The idea here is that you can provide almost any kind of python type in `args` and it'll be translated to a
          binary format to be placed into simulated memory. Lists (representing arrays) must be entirely elements of the
          same type and size, while tuples (representing structs) can be elements of any type and size.
          If you'd like there to be a pointer to a given value, wrap the value in a `SimCC.PointerWrapper`. Any value
          that can't fit in a register will be automatically put in a
          PointerWrapper.
  
          If stack_base is not provided, the current stack pointer will be used, and it will be updated.
          If alloc_base is not provided, the current stack pointer will be used, and it will be updated.
          You might not like the results if you provide stack_base but not alloc_base.
  
          grow_like_stack controls the behavior of allocating data at alloc_base. When data from args needs to be wrapped
          in a pointer, the pointer needs to point somewhere, so that data is dumped into memory at alloc_base. If you
          set alloc_base to point to somewhere other than the stack, set grow_like_stack to False so that sequencial
          allocations happen at increasing addresses.
          """
          return self.project.simos.state_call(addr, *args, **kwargs)