Function typeToString

KittyMemoryEx/KittyAsm.cpp:185–212

    /// general shapes they are special cases of, or they decode as those instead.
    EKittyInsnTypeArm32 decodeInsnType(uint32_t instr)
    {
        // cond == 0b1111 is not a condition at all: it marks the unconditional
        // instruction space (BLX immediate, PLD, RFE, and the whole of Advanced
        // SIMD). Those encodings are unrelated to the ones decoded below, so
        // decoding them with the same masks produced pure fiction - `vqsub.u8`
        // read as MOVT, `rfeia` as POP_PC, and BLX's halfword-offset form read as
        // BL with a target two bytes off.
        if (bits(instr, 31, 28) == 0xF)
            return EKittyInsnTypeArm32::UNKNOWN;

        // Bit 25 means opposite things either side of bits 27-26: in
        // data-processing it selects an *immediate* operand, in load/store it
        // selects a *register* offset. Named for the bit rather than for either
        // meaning, so neither reading can be misapplied to the other space.
        const bool bBit25 = bit(instr, 25);

        // Bits 27-26 == 00 is shared between data-processing, the multiplies and
        // the "extra load/store" (halfword / doubleword / signed) encodings. Bit
        // 4 and bit 7 are what separate them: with a register operand and both
        // set, this is not data-processing at all. Without that test
        // `STRH R0,[R0],-R6` and `UMULL` both decoded as ADD, and the
        // destination register then received a fabricated address.
        const bool bExtraSpace = !bBit25 && bit(instr, 4) && bit(instr, 7);

        if ((instr & 0x0C000000) == 0x00000000 && !bExtraSpace)
        {
            // Against PC these are ADR, and the register form is its own type:
            // its target needs Rm, so nothing here can resolve it.
            const bool bAgainstPc = bits(instr, 19, 16) == 15;
            const bool bAdrReg    = bAgainstPc && !bBit25;