thr3ads.net - llvm dev - [LLVMdev] Problems in instrumentation [May 2014]

If this information is useful, please help other people find it:
Share via:

Qiuping Yi

2014-May-13 08:56 UTC

[LLVMdev] Problems in instrumentation

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:

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*'.
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.

Any Suggestions are welcome. Thank you all in advance.

Best Regards!

--------------------------------------------
Qiuping Yi
Institute Of Software
Chinese Academy of Sciences
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20140513/77fcf8ac/attachment.html>

John Criswell

2014-May-13 13:40 UTC

head link

[LLVMdev] Problems in instrumentation

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/20140513/d0c86e89/attachment.html>

Hongxu Chen

2014-May-13 17:01 UTC

head link

[LLVMdev] Problems in instrumentation

Hi Qiuping,

      IIRC, there's a wrapper API for easy use of all type definitions;
however I cannot remember exactly now.
      For a void* type, is the size i8? I don't think you can get the size
of *p though since this formal parameter of a function in C is no more than
an address.
      Another tip: you can try some C++11 features(such as range-based for
loops) in order to avoid "ugly code", or customize some macros
yourself.


Thanks and Regards,
Hongxu


On Tue, May 13, 2014 at 5:01 PM, Qiuping Yi-2 [via LLVM] <
ml-node+s1065342n68544h55 at n5.nabble.com> 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:
>
> 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*'.
> 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.
>
> Any Suggestions are welcome. Thank you all in advance.
>
> Best Regards!
>
> --------------------------------------------
> Qiuping Yi
> Institute Of Software
> Chinese Academy of Sciences
>
> _______________________________________________
> LLVM Developers mailing list
> [hidden email]
<http://user/SendEmail.jtp?type=node&node=68544&i=0>
>   http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
>
> ------------------------------
>  If you reply to this email, your message will be added to the discussion
> below:
> http://llvm.1065342.n5.nabble.com/Problems-in-instrumentation-tp68544.html
>  To start a new topic under LLVM - Dev, email
> ml-node+s1065342n3h84 at n5.nabble.com
> To unsubscribe from LLVM, click
here<http://llvm.1065342.n5.nabble.com/template/NamlServlet.jtp?macro=unsubscribe_by_code&node=2&code=bGVmdGNvcHkuY2h4QGdtYWlsLmNvbXwyfC0xMjc2Njc5OTI2>
> .
>
NAML<http://llvm.1065342.n5.nabble.com/template/NamlServlet.jtp?macro=macro_viewer&id=instant_html%21nabble%3Aemail.naml&base=nabble.naml.namespaces.BasicNamespace-nabble.view.web.template.NabbleNamespace-nabble.view.web.template.NodeNamespace&breadcrumbs=notify_subscribers%21nabble%3Aemail.naml-instant_emails%21nabble%3Aemail.naml-send_instant_email%21nabble%3Aemail.naml>
>



--
View this message in context:
http://llvm.1065342.n5.nabble.com/Problems-in-instrumentation-tp68544p68554.html
Sent from the LLVM - Dev mailing list archive at Nabble.com.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20140513/a2f6b785/attachment.html>

Qiuping Yi

2014-May-14 14:47 UTC

head link

[LLVMdev] Problems in instrumentation

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>

lucefe

2014-May-14 14:56 UTC

head link

[LLVMdev] Problems in instrumentation

Hi, Hongxu

Thank you for your advice. Now I resolve to the DataLayout (TargetData in
lower llvm version) analysis pass to get the size of each type.

Best Regards!
Qiuping


2014-05-14 1:01 GMT+08:00 Hongxu Chen <leftcopy.chx at gmail.com>:
> Hi Qiuping,
>
>       IIRC, there's a wrapper API for easy use of all type definitions;
> however I cannot remember exactly now.
>       For a void* type, is the size i8? I don't think you can get the
size
> of *p though since this formal parameter of a function in C is no more than
> an address.
>       Another tip: you can try some C++11 features(such as range-based for
> loops) in order to avoid "ugly code", or customize some macros
yourself.
>
>
> Thanks and Regards,
> Hongxu
>
>
> On Tue, May 13, 2014 at 5:01 PM, Qiuping Yi-2 [via LLVM] <[hidden
email]<http://user/SendEmail.jtp?type=node&node=68554&i=0>
> > 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:
>>
>> 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*'.
>> 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.
>>
>> Any Suggestions are welcome. Thank you all in advance.
>>
>> Best Regards!
>>
>> --------------------------------------------
>> Qiuping Yi
>> Institute Of Software
>> Chinese Academy of Sciences
>>
>> _______________________________________________
>> LLVM Developers mailing list
>> [hidden email]
<http://user/SendEmail.jtp?type=node&node=68544&i=0>
>>     http://llvm.cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>>
>>
>> ------------------------------
>>  If you reply to this email, your message will be added to the
>> discussion below:
>>
http://llvm.1065342.n5.nabble.com/Problems-in-instrumentation-tp68544.html
>>  To start a new topic under LLVM - Dev, email [hidden
email]<http://user/SendEmail.jtp?type=node&node=68554&i=1>
>> To unsubscribe from LLVM, click here.
>>
NAML<http://llvm.1065342.n5.nabble.com/template/NamlServlet.jtp?macro=macro_viewer&id=instant_html%21nabble%3Aemail.naml&base=nabble.naml.namespaces.BasicNamespace-nabble.view.web.template.NabbleNamespace-nabble.view.web.template.NodeNamespace&breadcrumbs=notify_subscribers%21nabble%3Aemail.naml-instant_emails%21nabble%3Aemail.naml-send_instant_email%21nabble%3Aemail.naml>
>>
>
>
> ------------------------------
> View this message in context: Re: Problems in
instrumentation<http://llvm.1065342.n5.nabble.com/Problems-in-instrumentation-tp68544p68554.html>
> Sent from the LLVM - Dev mailing list
archive<http://llvm.1065342.n5.nabble.com/LLVM-Dev-f3.html>at Nabble.com.
>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
>-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20140514/2641fa2f/attachment.html>

Reasonably Related Threads

Search for more maybe matching threads

llvm dev - May 2014 - [LLVMdev] Problems in instrumentation

[LLVMdev] Problems in instrumentation

[LLVMdev] Problems in instrumentation

[LLVMdev] Problems in instrumentation

[LLVMdev] Problems in instrumentation

[LLVMdev] Problems in instrumentation

Reasonably Related Threads