The decompilation skips some important data

[bog-dan-ro]

As you can see in the next image
before *addr = 0x5a5a5a5a; should be a nofault =nomem; statement which is missing.

Is it a bug or do I need to configure something?

The textual representation of asm & C code:

                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             uint32_t __cdecl mem_present(int * addr)
             uint32_t          EAX:4          <RETURN>
             int *             Stack[0x4]:4   addr                                    XREF[2]:     0002991c(R), 
                                                                                                   00029936(R)  
                             mem_present                                     XREF[1]:     scanmem:000084a9(c)  
        00029919 55              PUSH               EBP
        0002991a 8b ec           MOV                EBP,ESP
        0002991c 8b 45 08        MOV                EAX,dword ptr [EBP + addr]
        0002991f c7 05 38        MOV                dword ptr [nofault],nomem                                                   = 00000000
                 6c 00 c0 
                 4a 99 02 00
        00029929 c7 00 5a        MOV                dword ptr [EAX],0x5a5a5a5a
                 5a 5a 5a
        0002992f b9 00 01        MOV                ECX,0x100
                 00 00
                             LAB_00029934                                    XREF[1]:     00029934(j)  
        00029934 e2 fe           LOOP               LAB_00029934
        00029936 3b 45 08        CMP                EAX,dword ptr [EBP + addr]
        00029939 75 0f           JNZ                nomem
        0002993b 81 38 5a        CMP                dword ptr [EAX],0x5a5a5a5a
                 5a 5a 5a
        00029941 75 07           JNZ                nomem
        00029943 b8 01 00        MOV                EAX,0x1
                 00 00
        00029948 eb 02           JMP                LAB_0002994c
                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             undefined4 __cdecl nomem(void)
             undefined4        EAX:4          <RETURN>
                             nomem                                           XREF[5]:     k_trap:0000bd33(*), k_trap:0000bd49(*), 
                                                                                          mem_present:0002991f(*), mem_present:00029939(j), 
                                                                                          mem_present:00029941(j)  
        0002994a 33 c0           XOR                EAX,EAX
                             LAB_0002994c                                    XREF[1]:     mem_present:00029948(j)  
        0002994c c7 05 38        MOV                dword ptr [nofault],0x0                                                     = 00000000
                 6c 00 c0 
                 00 00 00 00
        00029956 5d              POP                EBP
        00029957 c3              RET

uint32_t mem_present(int *addr)

{
  int iVar1;
  
  *addr = 0x5a5a5a5a;
  iVar1 = 0x100;
  do {
    iVar1 = iVar1 + -1;
  } while (iVar1 != 0);
  nofault = (undefined *)0x0;
  return (uint)(*addr == 0x5a5a5a5a);
}

P.S. If needed I can share the entire ghidra project.

[astrelsky]

Go to the address of nofault, right click on the defined data at nofault, go to data->settings->mutability and choose volatile

[bog-dan-ro]

It worked, thanks!!!

One more thing on this matter, on old systems they used dummy assignments for delaying a bit the CPU something like:

#define delay {byte x=*PTR[addr];}

Ghidra sees that code as dead code and again it doesn't show it in the decompile window. Is there any setting wich tells ghidra to keep dead code too?

[igbecerra]

Give a try to disabling the checkbox at:

Edit->Tool Options->Options->Decompiler->Analysis->Eliminate unreachable code

By name and description, it shouldn't work, but it's worth a try...

[bog-dan-ro]

It didn't work...

IMHO the decompiler is doing the compiler work by stripping "unused" data which it shouldn't.
For my use case is not critical as I found where it does the delay trick, but might be useful for other people.

In case someone wants to test it here is the ASM code:

                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             int __cdecl splx(int spl)
                               assume addrsize = 0x1
                               assume DF = 0x0
                               assume opsize = 0x1
             int               EAX:4          <RETURN>
             int               Stack[0x4]:4   spl                                     XREF[1]:     00029222(R)  
             undefined4        EAX:4          old_ipl
                             
        00029222 8b 4c 24 04     MOV        ECX,dword ptr [ESP + spl]
                             LAB_00029226                                    XREF[1]:     00029220(j)  
        00029226 53              PUSH       EBX
        00029227 a1 09 82        MOV        EAX,[ppl]                                        = 7h
                 00 c0
        0002922c 89 0d 09        MOV        dword ptr [ppl],ECX                              = 7h
                 82 00 c0
        00029232 9c              PUSHFD
        00029233 0f b6 15        MOVZX      EDX,byte ptr [mycpu_id]
                 22 50 00 c0
        0002923a 8a 89 64        MOV        CL,byte ptr [ECX + mask]
                 81 00 c0
        00029240 0a 8a b0        OR         CL,byte ptr [EDX + intrmask]
                 10 02 c0
        00029246 0a 0d 64        OR         CL,byte ptr [maxmask]
                 64 02 c0
        0002924c fa              CLI
        0002924d 8b 15 d8        MOV        EDX,dword ptr [picimr]                           = 202h
                 80 00 c0
        00029253 88 8a 00        MOV        byte ptr [EDX + dma_area],CL                     = ??
                 00 00 c4
        00029259 8a 0d 64        MOV        CL,byte ptr [mask]
                 81 00 c0
        0002925f ba 00 0a        MOV        EDX,0xa00
                 00 00
        00029264 8a 9a 00        MOV        BL,byte ptr [EDX + 0xc4000000]=>dma_BYTE_ARRAY
                 00 00 c4
        0002926a 8a 9a 00        MOV        BL,byte ptr [EDX + 0xc4000000]=>dma_BYTE_ARRAY
                 00 00 c4
        00029270 0a db           OR         BL,BL
        00029272 9d              POPFD
        00029273 5b              POP        EBX
        00029274 c3              RET

and this is the decompiled C code:

int splx(int spl)

{
  dword old_ipl;
  
  old_ipl = ppl;
  ppl = spl;
  dma_area[picimr] = mask[spl] | intrmask[mycpu_id] | maxmask;
  return old_ipl;
}

As you can see before return old_ipl; it strips the dummy assignment which is used as a delay.
Of course a { byte x = dma_aread[0xa00]; x = dma_aread[0xa00]; x|=x;} code will be striped by all modern compilers, so, in this case the decompiler should use asm volatile ("....") instead, this way the compiles will not strip that code.