identifing mallocs with constant sizes

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?

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?

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.

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: