[LLVMdev] identifing mallocs with constant sizes

[Ryan M. Lefever]

John,

Thanks for the reply!  You said you'd written code to evaluate a 
constant expression, would it be possible for you to post that code?

Ryan

John Criswell wrote:
> Ryan M. Lefever wrote:
> 
>>I am writing some code to identify malloc instructions with constant 
>>request sizes and to determine the request size if it is constant.  I 
>>have two questions.
>>
>>1) If a malloc is for an array allocation and the array size is a 
>>ConstantExpr, how can I obtain the value of the ConstantExpr?
>>  
> 
> The only way I know of is to determine what type of constant expression
> it is and then evaluate it yourself.  So, you'd have something like this:
> 
> if (is a negation constantexpr)
>     figure out the negated value of the operand
> if (is a cast constantexpr)
>     figure out the result of the operand casted to the new type
> ...
> etc, etc.
> 
> If anyone knows of a more efficient way, I'd be curious, too.  I've had
> to write code that determines the value of a constant expression, too.
> 
>>2) I am using the following logic to determine if the malloc is for a 
>>constant request size and to determine what is that size.  Does the 
>>logic make sense?
>>
>>============================================================
>>if (malloc is for non-array allocation){
>>   -- the request size is constant and is equal to the size of
>>      allocated type
>>}
>>else{
>>   // this is an array allocation
>>
>>   if(array size is a Constant){
>>     -- the request size is constant and equal to the size of the
>>        allocated type times the constant array size
>>
>>     if(the array size is a ConstantInt){
>>       -- the array size can be obtained using getLimitedValue()
>>     }
>>     else if(the array size is a ConstantExpr){
>>       -- there should be some way to evaluate the constant
>>          expression???
>>     }
>>     else if(the array size is a ConstantAggregateZero){
>>       -- the malloc is for size 0
>>     }
>>     else if(the array size is a ConstantFP){
>>       -- I don't believe this case should happen but if it did,
>>          the array size could be obtained by calling getValue()
>>     }
>>     else if(the array size is a ConstantArray or ConstantPointerNull
>>             or ConstantStruct or ConstantVector or GlobalValue
>>             or UndefValue){
>>       -- this should not happen!
>>     }
>>   }
>>}
>>  
>>in all other cases, the malloc is for a non-constant request size
>>  
> 
> At a glance, this looks good, except that a ConstantInt is also a
> Constant, so I don't see the difference between the two cases.
> 
> -- John T.
> 
> 
>>=============================================================
>>
>>Regards,
>>Ryan
>>_______________________________________________
>>LLVM Developers mailing list
>>LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
>>http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>>  
> 
> 
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

-- 
Ryan M. Lefever  [http://www.ews.uiuc.edu/~lefever]