How to read the BEAM bytecode compiled into memory and that is not on the disk?

I’m the author of the Domo library that validates struct’s data against its @type spec and would like to upgrade it to support in-memory modules.

In the library, I read struct’s types by Code.Typespec.fetch_types(module_atom) that works for the module that has the compiled BEAM file on the disk. At the same time, for an in-memory module that you can make in iex, it returns :error like the following:

iex(1)> defmodule Ms do
...(1)>   defstruct [:id]
...(1)>   @type t :: %__MODULE__{id: atom}
...(1)> end
{:module, Ms, ...}

iex(2)> Code.Typespec.fetch_types(Ms)

The Code.Typespec.fetch_types/1 delegates to Erlang’s :code.get_object_code/1 that, from my understanding searches bytecode on the disk. That fails for modules that exist only in memory.

How can I get the bytecode for the module that is in memory only by its name in iex/Livebook?

You cannot. I have asked for such thing on the Erlang Issue Tracker and IRC and there is no way to achieve what you want. The only solution is to manually store 3rd element of the tuple returned by defmodule and use that as a BEAM data.


Good to know. It seems OTP has no public interface to get in-memory modules yet.

1 Like

It is not possible to do because during loading the original module is destroyed and it is not possible to reverse-load the module from what is loaded. So to implement such functionality we would be to keep the original module which would double the memory usage of the code for each loaded module.


So I’ve solved my problem by simply collecting types from the bytecode with @after_compile {module, fun} hook because the library should be used explicitly in the modules anyway.

The other way to get bytecodes is a {:on_module, bytecode, :none} compilation tracer introduced in Elixir v1.13.0. The tracer can be added to the elixir compiler configuration dynamically from a custom mix compile task that should go first in compilers list in project’s mix.exs file.

Hi @IvanR! Thanks for asking this — I’m also wondering about the same. Do you have any code examples you could share with details on how specifically you can get the types with an @after_compile hook? I understand the general idea but I’m not clear how to specifically do it in code.

Types can be read from the module’s bytecode like the following at compile-time:

defmodule MyModule do
  @type one_type :: atom()
  @opaque another_type :: integer()

  @after_compile {MyModule, :_collect_types}

  def _collect_types(_env, bytecode) do
    {:ok, types} = Code.Typespec.fetch_types(bytecode), fn {kind, type} ->
      type_ast = Code.Typespec.type_to_quoted(type)

      |> Macro.to_string()
      |> IO.inspect(label: kind)

it prints:

opaque: "another_type() :: integer()"
type: "one_type() :: atom()"

Ah perfect — I didn’t realize you could pass the bytecode directly to Code.Typespec.fetch_types (and Code.Typespec.fetch_specs). This works great!