[lldb-dev] Identifying instructions that definitely access memory

Tatyana Krasnukha via lldb-dev lldb-dev at lists.llvm.org
Thu Nov 7 03:49:08 PST 2019

Hi Vangelis,

Not sure this will help you, but you can try to compare llvm::MachineInstr::getOpcode() with TargetOpcode::G_LOAD and TargetOpcode::G_STORE if you can obtain a MachineInstr instance.
It also may have sense to ask llvm-dev for a proper solution.

From: lldb-dev <lldb-dev-bounces at lists.llvm.org> On Behalf Of Vangelis Tsiatsianas via lldb-dev
Sent: Tuesday, November 5, 2019 3:43 PM
To: via lldb-dev <lldb-dev at lists.llvm.org>
Cc: Vangelis Tsiatsianas <vangelists at icloud.com>
Subject: Re: [lldb-dev] Identifying instructions that definitely access memory


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 <vangelists at icloud.com<mailto:vangelists at icloud.com>> wrote:


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/lldb-dev/attachments/20191107/9930c434/attachment-0001.html>

More information about the lldb-dev mailing list