mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 19:10:23 -10:00
64 lines
3.2 KiB
Plaintext
64 lines
3.2 KiB
Plaintext
* How to port Mono to your preferred architecture
|
|
|
|
** Endian, 64 bits and unaligned access issues
|
|
|
|
The first thing to do is to check that the metadata handling
|
|
library works on your target processor. You may use the disassembler
|
|
on simple programs and check that you get sensible results
|
|
(assuming it compiles at all on your system:-).
|
|
|
|
The main issue is to write macros that read unaligned
|
|
little endian shorts/ints/longs/float/doubles: look into
|
|
mono/metadata/endian.h. There may be other spots in the code that are
|
|
unsafe at reading/writing to some datatypes that require special
|
|
alignment, but there should be few such issues and they need to be fixed.
|
|
|
|
Once this stuff is sorted out, you should be able to run the interpreter
|
|
on simple programs that don't require delegates, P/Invoke functions etc..
|
|
|
|
** Generating assembly bytecodes for the target processor
|
|
|
|
Next, you need to provide the support code for generating assembly bytecode
|
|
for your target platform (in mono/arch/{ppc,sparc,alpha,*}).
|
|
The code should be more or less like the code in x86-codegen.h:
|
|
macros that produce fast in-line code. You don't need to provide
|
|
code to create every possible code, at first, just the code to
|
|
create trampolines and execute them is fine (you'll need to research
|
|
how the call convention works on your platform): that would be, for
|
|
example, the prolog and epilog code in a function, code to pass function
|
|
parameters and deal with the return value and so on.
|
|
|
|
libffi in gcc or the xptcall sources in mozilla may be helpful to
|
|
understand how the calling convention works, if you can't find a specification.
|
|
You'd need a processor manual to know how to create the assembly binary data.
|
|
This requires a lot of reading if you're not familiar with the assembly for your
|
|
target platform. Manuals for many processors are available as PDF files on the
|
|
web site of the respective vendors. Note that some processors require you to
|
|
flush the I-cache before executing the code: have a look at how the same thing is
|
|
done in GNU lightning.
|
|
|
|
** Getting the interpreter to work
|
|
|
|
Once you can generate binary code, you can start working on a
|
|
mono_create_trampoline() function for your platform: this function will receive
|
|
a MonoMethod that describes the arguments and the return type of a C function
|
|
and will create the code to call such function. When this function is complete
|
|
you'll be able to run more sample programs, that use System.IO, P/Invoke
|
|
functions etc.
|
|
|
|
To support delegates you'll need to write a mono_create_method_pointer()
|
|
function that creates a native function: this can be used to call the
|
|
method using the runtime's calling convention (it's basically the reverse
|
|
of mono_create_trampoline()).
|
|
|
|
** The final step: porting the JIT
|
|
|
|
At this point you'd need to have a more complete code generation header file
|
|
and you can start writing the machine description file for the monoburg
|
|
system. This code (jit/tesjit.c) will require some machine specific tweaks,
|
|
but hopefully all you have to do is create the grammar that emit assembly
|
|
code from the IR tree. Work is at the early stages also for x86 on this stuff
|
|
as we are still testing various solutions: you'd want to read about burg-like
|
|
code-generator generators (the LCC book is a good starting point).
|
|
|