llvm dev - Feb 2020 - Advice on memory copy instrumentation

Hi all,

Given a couple of lines of C++ code `int x = 42; int y = x`, we end up with
the following LLVM IR instructions:

%x = alloca i32, align 4
%y = alloca i32, align 4
store i32 42, i32* %x, align 4
%0 = load i32, i32* %x, align 4
store i32 %0, i32* %y, align 4

Is it possible to instrument the IR to perform a value trace?

What I'd like to do is stream a log of memory copies (reads then writes),
such that in this example, the final instruction will produce a log event
along the lines of:
"COPY: Value at <address of x> copied to <address of y>"?

Essentially what I'd like to do is annotate particular values, so that when
these same values are encountered again later in the program, I can
retrieve the annotation. I will also need the annotation to survive copies,
moves, etc. This could be considered a lightweight, parallel symbolic trace
performed at runtime on a very small subset of program values.

I am hoping to implement this tooling at the LLVM IR level, so that it can
be useful beyond C++, but if it's easier to instrument the CLang AST
instead then I guess I can start there. Looking forward to your responses :)
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20200220/406146e7/attachment.html>

I'm not sure if I understand exactly what you would like to do, but I would
imagine one could write a pass that looks for the pattern of "%x = load ...
store %x ..." and insert a function call that logs the copy. I don't
know
of any existing analysis or utility code that you could build on to make it
easy to do that, though.

It might be helpful if there is an example of the annotations you have in
mind.

On Wed, Feb 19, 2020 at 3:07 PM Matt Fysh via llvm-dev <
llvm-dev at lists.llvm.org> wrote:
> Hi all,
>
> Given a couple of lines of C++ code `int x = 42; int y = x`, we end up
> with the following LLVM IR instructions:
>
> %x = alloca i32, align 4
> %y = alloca i32, align 4
> store i32 42, i32* %x, align 4
> %0 = load i32, i32* %x, align 4
> store i32 %0, i32* %y, align 4
>
> Is it possible to instrument the IR to perform a value trace?
>
> What I'd like to do is stream a log of memory copies (reads then
writes),
> such that in this example, the final instruction will produce a log event
> along the lines of:
> "COPY: Value at <address of x> copied to <address of
y>"?
>
> Essentially what I'd like to do is annotate particular values, so that
> when these same values are encountered again later in the program, I can
> retrieve the annotation. I will also need the annotation to survive copies,
> moves, etc. This could be considered a lightweight, parallel symbolic trace
> performed at runtime on a very small subset of program values.
>
> I am hoping to implement this tooling at the LLVM IR level, so that it can
> be useful beyond C++, but if it's easier to instrument the CLang AST
> instead then I guess I can start there. Looking forward to your responses
:)
>
>
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20200221/452db3e1/attachment.html>

Thanks Hiroshi, this is exactly what I was looking for! I've been looking
into it for a few days, and I've just found the MemorySSA (virtual IR)
which is probably gonna help me out a bunch. Thanks again :)

On Sat, 22 Feb 2020 at 03:23, Hiroshi Yamauchi <yamauchi at google.com>
wrote:
> I'm not sure if I understand exactly what you would like to do, but I
> would imagine one could write a pass that looks for the pattern of "%x
> load ... store %x ..." and insert a function call that logs the copy.
I
> don't know of any existing analysis or utility code that you could
build on
> to make it easy to do that, though.
>
> It might be helpful if there is an example of the annotations you have in
> mind.
>
> On Wed, Feb 19, 2020 at 3:07 PM Matt Fysh via llvm-dev <
> llvm-dev at lists.llvm.org> wrote:
>
>> Hi all,
>>
>> Given a couple of lines of C++ code `int x = 42; int y = x`, we end up
>> with the following LLVM IR instructions:
>>
>> %x = alloca i32, align 4
>> %y = alloca i32, align 4
>> store i32 42, i32* %x, align 4
>> %0 = load i32, i32* %x, align 4
>> store i32 %0, i32* %y, align 4
>>
>> Is it possible to instrument the IR to perform a value trace?
>>
>> What I'd like to do is stream a log of memory copies (reads then
writes),
>> such that in this example, the final instruction will produce a log
event
>> along the lines of:
>> "COPY: Value at <address of x> copied to <address of
y>"?
>>
>> Essentially what I'd like to do is annotate particular values, so
that
>> when these same values are encountered again later in the program, I
can
>> retrieve the annotation. I will also need the annotation to survive
copies,
>> moves, etc. This could be considered a lightweight, parallel symbolic
trace
>> performed at runtime on a very small subset of program values.
>>
>> I am hoping to implement this tooling at the LLVM IR level, so that it
>> can be useful beyond C++, but if it's easier to instrument the
CLang AST
>> instead then I guess I can start there. Looking forward to your
responses :)
>>
>>
>> _______________________________________________
>> LLVM Developers mailing list
>> llvm-dev at lists.llvm.org
>> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20200222/a3706d52/attachment.html>