Allow the choosing of emit bit length in runtime, not at compile time.

[HorseTrain]

Current Limitation with Xbyak Code Generation Mode
In Xbyak, emitting code for 64-bit mode requires defining XBYAK64 at compile time. While this approach works for single-target use cases, it limits flexibility in more complex scenarios. For instance, a JIT compiler running in a 64-bit environment may need to generate 32-bit code dynamically. Since the emit mode is fixed at compile time, supporting multiple target architectures within the same application becomes cumbersome.

A more adaptable design would allow the code generation mode (32-bit vs. 64-bit) to be specified at runtime—ideally through the CodeGenerator constructor—enabling more versatile use cases such as cross-mode JIT compilation and hybrid execution environments.

[herumi]

For instance, a JIT compiler running in a 64-bit environment may need to generate 32-bit code dynamically.

I can't think of any such cases, but could you be more specific about what scenario you have in mind?

It's quite complex to implement runtime switching between 32-bit and 64-bit architectures.

The compiled binary of code A in 64-bit mode is the same as the binary of code B in 32-bit mode.

// code A
add eax, ecx
mov eax, [rax+rcx*4+8]

// code B
add eax, ecx
mov eax, [eax+ecx*4+8]

Therefore, if the 32-bit code is minimal, it might be simpler to generate 32-bit code using the current XBYAK64 without modifications.

[HorseTrain]

So, when I say "Allow the choosing of emit bit length in runtime" I mean at the constructor level.

CodeGenerator c64 = CodeGenerator(..., 64);
CodeGenerator c32 = CodeGenerator(..., 32);

and this can be very useful if you are writing a static compiler. For example, I want to compile a 32 bit program on a 64 bit machine, and vise-versa. Allowing to choose the bit size in the constructor also removes the need to worry about having to predef code in and out depending on the size of the compilation. I was able to achieve this in my project by doing something like this

namespace Xbyak32
{
#include "xbyak.h"
}

namespace Xbyak64
{
#define XBYAK64

#include "xbyak.h"

#undef XBYAK64
}

[herumi]

I was able to achieve this in my project by doing something like this

Yes, I would also like it to be replaced with a method where we define XBYAK32 and XBYAK64 in code32.cpp and code64.cpp respectively, and then #include "xbyak/xbyak.h" to use them.