[LLVMdev] Problems in instrumentation

[Qiuping Yi]

Hi, John Criswell

Thank you for your detail notes, which give me much invaluable information.


--------------------------------------------
Qiuping Yi
Institute Of Software
Chinese Academy of Sciences


On Tue, May 13, 2014 at 9:40 PM, John Criswell <criswell at illinois.edu>wrote:

>  On 5/13/14, 3:56 AM, Qiuping Yi wrote:
>
>  Hi everyone,
>
>  I have some trouble in instrumenting load instructions. I want to
> instrument load instructions as follow: Firstly, I judge whether the loaded
> pointer(*any type is possible*) is NULL. If so, I want to explicitly
> allocate the corresponding address space of its type to the pointer.
>
>  For example, in source code level I want to translate the next statement
>
>
>  *p = 1;
>
>  into the next statements
>
>  if (p == NULL)
>     *p = malloc(sizeof(*p));
> *p = 1;
>
>  For simplicity, I want to wrapper the first two statements into function
> init. And then I can implement as follow:
>
>  init((void*)p, sizeof(*p));
> *p = 1;
>
>  where
>
>  void init(void *p, int size) {
>      if (p == NULL)
>          p = malloc(size);
> }
>
> I am trying to use the next pass for instrumentation:
>
>
> Just three notes:
>
> 1) You may want to ensure that you're not invalidating the
> BasicBlock::iterator variable i by inserting the Call instruction.  If you
> are invalidating the iterator, then your code may skip over load
> instructions or instrument a single load twice.
>
> 2) It may be better make your class derive from the InstVisitor class.
>
> 3) You may want to instrument atomic operations as well as the Load
> Instruction.  This is because the atomic operations also perform a load (as
> well as a store).  The same applies to some of the intrinsics (e.g., the
> memcpy/memcmp intrinsics).
>
>
>
>  for (Module::iterator f=M.begin(), fe=M.end(); f!=fe; ++f) {
>    for (Function::iterator b=f->begin(), be=f->end(); b!=be; ++b) {
>       for (BasicBlock::iterator i=b->begin(), ie=b->end()l i!=ie; ++i)  {
>           if (i->getOpcode() == Instruction::Load) {
>
> *             CallInst::create(....); // add a call inst before inst i to
> invoke function init*
>
>
>            }
>       }
>    }
> }
>
>  So my question is How should I create the previous call inst to execute
> invocation: init((void*)p, sizeof(p)). Because any pointer type is
> possible, so I let the first parameter of function init as 'void*'.
>
>
> A "void *" in the LLVM IR is a pointer to an integer of size 1 (i.e., a
> char *).
>
>
>  Furthermore, how should I get the size of *p? I check Type.h, and found
> class Type only provide function getPrimitiveSizeInBits() to return the
> size of the primitive types. How can I know the size of other types, eg.
> the size of a structure type.
>
>
> You can use the DataLayout analysis pass to find the size of various
> types.  You can read the doxygen documentation on it at
> http://llvm.org/doxygen/classllvm_1_1DataLayout.html.
>
> Regards,
>
> John Criswell
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20140514/29386b17/attachment.html>