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?
===========================================================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
============================================================
Regards,
Ryan
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 >
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]