llvm dev - Nov 2014 - [LLVMdev] How to lower the intrinsic function 'llvm.objectsize'?

Thanks for your reply.
I'm attempting to expand KLEE to support this intrinsic function.
That's why I need to handle this myself.
According to the reply, the correct implementation should first find the
definition of the object and then determine the
size of the object.
BTW, can I just refer to the implementation in InstCombineCalls.cpp.


On Wed, Nov 5, 2014 at 2:24 PM, Matt Arsenault <Matthew.Arsenault at
amd.com>
wrote:
>  On 11/05/2014 02:04 PM, Dingbao Xie wrote:
>
>  The documentation of LLVM says that "The llvm.objectsize intrinsic is
> lowered to a constant representing the size of the object concerned".
I'm
> attempting to lower this intrinsic function to a constant in a pass. Below
> is the code snippet that I wrote:
>
> Why do you need to handle this yourself? This should already be handled
> for you (see InstCombineCalls.cpp). However, you have a few problems with
> this.
>
>   for (BasicBlock::iterator i = b.begin(), ie = b.end();
>    (i != ie) && (block_split == false);) {
>  IntrinsicInst *ii = dyn_cast<IntrinsicInst>(&*i);
>  ++i;
>  if(ii) {
>  switch (ii->getIntrinsicID()) {
>   case Intrinsic::objectsize: {
>    IRBuilder<> builder(ii->getParent(), ii);
>    Value *op1 = ii->getArgOperand(0); //i8*
>    uint64_t bit_size =
op1->getType()->getPointerElementType()->getPrimitiveSizeInBits();
>
>   First, you can't always determine the size. Just looking at the
pointer
> element type isn't enough. This requires finding the object definition,
> which can fail, and the existing handling uses llvm::getObjectSize to for.
> In general when looking at type sizes you don't want to use
> getPrimitiveSizeInBits, and should use the DataLayout for various reasons.
>
>
>    Value *result = ConstantInt::get(ii->getType(), bit_size);
>    ii->replaceAllUsesWith(result);
>    ii->removeFromParent();
>    delete ii;
>
>   You shouldn't use delete here. You probably want
ii->eraseFromParent().
>
>
>    break;
>   }
>  }
> }
>
> I'm new to LLVM and not sure whether the implementation is correct. Can
> anybody tell me whether the implementation is correct?
>
> Thanks in advance.
>
>
> --
>  Dingbao Xie
>
>
> _______________________________________________
> LLVM Developers mailing listLLVMdev at cs.uiuc.edu        
http://llvm.cs.uiuc.eduhttp://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
>
>

-- 
Dingbao Xie
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20141105/3da1fceb/attachment.html>

You may also want to take a look at this:
http://llvm.org/docs/doxygen/html/classllvm_1_1ObjectSizeOffsetEvaluator.html

In summary, this can lower objectsize computation to either a constant (if 
possible) or introduce additional instructions in the IR to compute the 
value at run time.  Sounds pretty much what you would want for KLEE.
This lowering is intra-procedural only. Anything else is too complicated.

Nuno

-----Original Message----- 
From: Dingbao Xie
Sent: Wednesday, November 05, 2014 10:37 PM
To: Matt Arsenault
Cc: llvmdev at cs.uiuc.edu
Subject: Re: [LLVMdev] How to lower the intrinsic function 
'llvm.objectsize'?


Thanks for your reply.
I'm attempting to expand KLEE to support this intrinsic function.
That's why I need to handle this myself.
According to the reply, the correct implementation should first find the 
definition of the object and then determine the
size of the object.
BTW, can I just refer to the implementation in InstCombineCalls.cpp.



On Wed, Nov 5, 2014 at 2:24 PM, Matt Arsenault <Matthew.Arsenault at
amd.com>
wrote:


On 11/05/2014 02:04 PM, Dingbao Xie wrote:


The documentation of LLVM says that "The llvm.objectsize intrinsic is 
lowered to a constant representing the size of the object concerned".
I'm
attempting to lower this intrinsic function to a constant in a pass. Below 
is the code snippet that I wrote:

Why do you need to handle this yourself? This should already be handled for 
you (see InstCombineCalls.cpp). However, you have a few problems with this.


for (BasicBlock::iterator i = b.begin(), ie = b.end(); (i != ie) && 
(block_split == false);) { IntrinsicInst *ii =
dyn_cast<IntrinsicInst>(&*i);
++i; if(ii) { switch (ii->getIntrinsicID()) { case Intrinsic::objectsize: 
{ IRBuilder<> builder(ii->getParent(), ii); Value *op1 = 
ii->getArgOperand(0); //i8* uint64_t bit_size = 
op1->getType()->getPointerElementType()->getPrimitiveSizeInBits();
First, you can't always determine the size. Just looking at the pointer 
element type isn't enough. This requires finding the object definition, 
which can fail, and the existing handling uses llvm::getObjectSize to for. 
In general when looking at type sizes you don't want to use 
getPrimitiveSizeInBits, and should use the DataLayout for various reasons.


Value *result = ConstantInt::get(ii->getType(), bit_size); 
ii->replaceAllUsesWith(result); ii->removeFromParent(); delete ii;
You shouldn't use delete here. You probably want ii->eraseFromParent().

break; } } }

I'm new to LLVM and not sure whether the implementation is correct. Can 
anybody tell me whether the implementation is correct?

Thanks in advance.


-- 

Dingbao Xie

Hi Dingbao,

On 5 November 2014 22:37, Dingbao Xie <xiedingbao at gmail.com>
wrote:
> Thanks for your reply.
> I'm attempting to expand KLEE to support this intrinsic function.
> That's why I need to handle this myself.
> According to the reply, the correct implementation should first find the
> definition of the object and then determine the
> size of the object.
> BTW, can I just refer to the implementation in InstCombineCalls.cpp.
Please see this [1] issue on KLEE's issue tracker.

After talking to Daniel (CC'ed) I was under the impression that the
easiest thing to do would be to treat these as no-ops rather than
trying to lower them.

Reading the docs on llvm.objectsize couldn't we just be really lazy
and return 0 or -1 (indicating unknown) depending on the value of the
"min" argument? If there are programs where control flow depends on
the return value of llvm.objectsize() this would probably break things
but I don't know if clang ever generates IR in that form.

What Nuno just suggested sounds quite promising way to do this that
isn't as lazy as what I suggested.

[1] https://github.com/klee/klee/issues/33
[2] http://llvm.org/docs/LangRef.html#llvm-objectsize-intrinsic

Thanks,
Dan.

Hi,

It depends on what you're trying to accomplish.
I guess for KLEE it would be sufficient to ignore the intrinsic (as you say, 
replace it with 0/-1). InstCombine will try to lower it properly. If it 
fails, it means that later CodeGen will ignore the intrinsic as well (i.e., 
replace it with 0/-1 and fold comparisons/branches depending on it).  So, in 
this way you would mimic LLVM's behavior.
If you want to do full-blown verification, then you'd need to consider the 
cases where the compiler might be able to lower the intrinsic and the cases 
it won't. For these, lowering the intrinsic with the API I mentioned would 
be better, but then you would need to fork and execute both branches: when 
the compiler can and cannot lower the intrinsic.  Probably not worth it.

Nuno

-----Original Message----- 
From: Dan Liew
Sent: Friday, November 07, 2014 11:13 AM
To: Dingbao Xie
Cc: Matt Arsenault ; LLVM Developers Mailing List ; Daniel Dunbar ; 
nunoplopes at sapo.pt
Subject: Re: [LLVMdev] How to lower the intrinsic function 
'llvm.objectsize'?

Hi Dingbao,

On 5 November 2014 22:37, Dingbao Xie <xiedingbao at gmail.com>
wrote:
> Thanks for your reply.
> I'm attempting to expand KLEE to support this intrinsic function.
> That's why I need to handle this myself.
> According to the reply, the correct implementation should first find the
> definition of the object and then determine the
> size of the object.
> BTW, can I just refer to the implementation in InstCombineCalls.cpp.
Please see this [1] issue on KLEE's issue tracker.

After talking to Daniel (CC'ed) I was under the impression that the
easiest thing to do would be to treat these as no-ops rather than
trying to lower them.

Reading the docs on llvm.objectsize couldn't we just be really lazy
and return 0 or -1 (indicating unknown) depending on the value of the
"min" argument? If there are programs where control flow depends on
the return value of llvm.objectsize() this would probably break things
but I don't know if clang ever generates IR in that form.

What Nuno just suggested sounds quite promising way to do this that
isn't as lazy as what I suggested.

[1] https://github.com/klee/klee/issues/33
[2] http://llvm.org/docs/LangRef.html#llvm-objectsize-intrinsic

Thanks,
Dan.