lunatic is an ARM (32-bit) dynamic recompiler for low-level emulators.

The library allows the program to send information to VTune about JITted code so that we can profile programs without it losing track of the call stack. See documentation here.

This makes CPU::Run() return the number of "cycles" (that is, instructions) executed so that user applications that count cycles externally can do their cycle counting. A return value of 0 means that the CPU is halted/waiting for an IRQ. This should not have any impact on existing code.

This adds the CancelIRQWait() function counterpart to WaitForIRQ() that clears the wait_for_irq flag which is necessary for save state support. Alternatively, we could expose the flag as a reference on WaitForIRQ() and let the user set the value accordingly, but that would break existing code.

Windows does not implement std::aligned_alloc because the requirements for std::free are incompatible with the way the Windows kernel does aligned memory allocations.

I've implemented memory::aligned_alloc that uses _aligned_malloc on Windows or std::aligned_alloc on other systems. The counterpart is memory::aligned_free, which uses _aligned_free or std::free.

Added a CMake option named LUNATIC_USE_EXTERNAL_FMT (OFF by default) to allow users of the library to provide their own {fmt} library.

These changes also include setting -fbracket-depth=4096 for Clang in the test project as the new default used in the compiler included in VS2019 16.11.0 is too low.

Also cleaned up a few compilation warnings and fixed the include paths for proper CMake installation.

If a basic block jumps to an address that is known at compile-time and that block is already compiled (or can be compiled upfront), then we can jump to that block directly and bypass the expensive block key construction and lookup step.

https://github.com/fleroviux/lunatic/blob/538a60f1d6c5bf835a92f7e690558e25f4045be0/src/backend/x86_64/backend.cpp#L481

Fairly sure this would break for the case of cmn against immediate zero. You could expect a cmn with immediate zero to produce an unset carry flag, unfortunately this code results in a set carry flag.

Later versions of {fmt} are more strict with parameters and require an implementation of the formatter for custom types including enum classes/structs. This is the only instance in lunatic where {fmt} complains about unformattable parameters.

• Follow branches to discover and compile blocks early
• Branch to already compiled blocks immediately if possible
• Allocate JIT memory from a single, large buffer
• Other minor cleanups

TODO

• [ ] New ARM instructions
  • [ ] implement Media instructions
    • [ ] Parallel add/sub, signed
    • [ ] Parallel add/sub, unsigned
    • [ ] Packing, unpacking, saturation and reversal
    • [ ] Signed multiply
    • [ ] USAD8
    • [ ] USADA8
  • [ ] implement exclusive monitor instructions (ldrex/strex/clrex)
  • [ ] implement Hint instructions (mainly nop and wfi)
  • [ ] implement UMAAL instruction
  • [ ] implement VFP instructions
• [ ] New Thumb instructions
  • TODO
• [ ] implement unaligned memory accesses
• [ ] rework armv5te flag in lunatic::frontend::Translator
• ...

We should distinguish between CPU model (ARM7TDMI-S or ARM946E-S e.g.) and architecture (ARMv4T or ARMv5TE). For example the unaligned LDRSH edge-case is documented as ARMv4T edge-case but it's actually unpredictable and specific to the ARM7TDMI-S.

In AND, EOR and ORR we use bt to restore the shifter carry flag, but this leaves the sign flag undefined.

https://www.felixcloutier.com/x86/bt

The CF flag contains the value of the selected bit. The ZF flag is unaffected. The OF, SF, AF, and PF flags are undefined.