[llvm-dev] [MCDisassembler] Identifying instructions that definitely access memory

[Vangelis Tsiatsianas via llvm-dev]

[ This question has already been asked in lldb-dev (see attached emails), however it was suggested that I should forward the question to llvm-dev, since it is more relevant to MC Disassembler than LLDB. ]


Hello,

I am looking for a way to track memory stores and save both the old and the new value of the memory location being modified using LLDB, as described below:

1. Recognize the instructions that definitely access memory before they execute, based on their opcode.
2. Tell whether each operand is a register or a memory location.
3. If it’s a memory location, check whether it is a load or store destination.
4. In case it is a store destination, fetch and save current value from memory.
5. Execute instruction.
6. Fetch and save new value from memory.

However, I was not able to find a cross-architecture API that covers all of the conditions above and more specifically Instruction::DoesStore() and Operand::IsStoreDestination().

Last but not least, I should notice that the target is executed in single-step mode, so I do have control right before and after the execution of every instruction.

Thank you very much, in advance! 🙂


― Vangelis


> Begin forwarded message:
> 
> From: Vangelis Tsiatsianas
> Subject: Re: Identifying instructions that definitely access memory
> Date: 5 November 2019 - 14:43:29 EET
> To: via lldb-dev <lldb-dev at lists.llvm.org <mailto:lldb-dev at lists.llvm.org>>
> 
> Hello,
> 
> I decided to try once more with a follow-up email, since my previous one got no responses (I hope it’s not considered rude to send more than one message in a row for a particular question).
> 
> To sum up and clarify my previous question, what I need is a way to track memory stores and save both the old and the new value of the memory location being modified.
> 
> My thinking so far:
> 1. Recognize the instructions that definitely access memory before they execute, based on their opcode.
> 2. Tell whether each operand is a register or a memory location.
> 3. If it’s a memory location, check whether it is a load or store destination.
> 4. In case it is a store destination, fetch and save current value from memory.
> 5. Execute instruction.
> 6. Fetch and save new value from memory.
> 
> However, I was not able to find a cross-architecture API that covers all of the conditions above and more specifically Instruction::DoesStore() and Operand::IsStoreDestination().
> 
> Last but not least, I should notice that the target is executed in single-step mode, so I do have control right before and after the execution of every instruction.
> 
> Thanks, again, in advance! 🙂
> 
> 
> ― Vangelis
> 
> 
>> On 21 Oct 2019, at 08:54, Vangelis Tsiatsianas wrote:
>> 
>> Hello,
>> 
>> I am looking for a way to identify loads, stores and any other kind of instruction that definitely perform memory access and extract the address operand(s), however I was not able to find a cross-architecture API. The closest I stumbled upon are "MCInstrDesc::mayLoad()" and "MCInstrDesc::mayStore()", but I understand that their results are just a hint, so I would then need to examine the instruction name or opcode in order to find out whether it’s actually a load or store and which operand(s) is (are) memory address(es) and also do so for each architecture separately, which I would really like to avoid.
>> 
>> Is there a way to identify such instructions either by examining them through the disassembler (e.g. "DoesLoad()" | "DoesStore()") before they execute or right after they perform any kind of memory access?
>> 
>> Thank you very much, in advance! 🙂
>> 
>> 
>> ― Vangelis
>> 
> 

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20191115/857e71c2/attachment.html>