thr3ads.net - llvm dev - [LLVMdev] access array problem [May 2011]

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

Tan Guangming

2011-May-18 01:39 UTC

[LLVMdev] access array problem

Hi,
I want to access an array in my instrumentation code. For example:

GlobalVariable:
int *counter; //counter the number of load/store operations in run-time
int *counterArray; //record the load/store addresses

//increase the counter if a load/store is performed
std::vector<Constant *>index(2);
index[0] = Constant::getNullvalue(Type:getInt32Ty(Context));
index[1] = Constant::get(Type::getInt32Ty(Context), 0);
Constant *ElementPtr = ConstantExpr::getGetElementPtr(counter,
&index[0], index.size());
Value *oldcounter = new LoadInst(ElementPtr, "oldcounter", InsertPos);
Value *newcounter = BinaryOperator::Create(Instruction::Add,
oldcounter, ConstantInt::get(Type::getInt64Ty(Context), 1),
"newcounter", InsertPos);
new StoreInst(newcounter, ElmentPtr, InserPos);

//store the memory address to counterArray[oldcounter]
std::vector<Constant*> indexC(2);
indexC[0] =  Constant::getNullvalue(Type:getInt32Ty(Context));
indexC[1] = dync_cast(llvm::ConstantInt>(oldcounter);
Constant *ElmentPtr = ConstantExpr::getGetElementPtr(counterArray,
&indexC[0], indexC.size());
......// other codes

Unfortunately, the oldcounter of Value type can not be cast to
ConstantInt, dync_cast returns NULL.
Is there any way to retrieve the integer value from oldcounter?

Thanks!

-- 
Guangming Tan

Duncan Sands

2011-May-18 06:29 UTC

head link

[LLVMdev] access array problem

Hi Tan Guangming,
> I want to access an array in my instrumentation code. For example:
>
> GlobalVariable:
> int *counter; //counter the number of load/store operations in run-time
> int *counterArray; //record the load/store addresses
strictly speaking these are not arrays, they are pointers.  Also, you have
written them in some kind of C-style idiom.  What are the declarations in
LLVM IR?
> //increase the counter if a load/store is performed
> std::vector<Constant *>index(2);
> index[0] = Constant::getNullvalue(Type:getInt32Ty(Context));
> index[1] = Constant::get(Type::getInt32Ty(Context), 0);
The above two lines both compute the same thing (an i32 constant equal to
zero) in two different ways.
> Constant *ElementPtr = ConstantExpr::getGetElementPtr(counter,
> &index[0], index.size());
> Value *oldcounter = new LoadInst(ElementPtr, "oldcounter",
InsertPos);
> Value *newcounter = BinaryOperator::Create(Instruction::Add,
> oldcounter, ConstantInt::get(Type::getInt64Ty(Context), 1),
> "newcounter", InsertPos);
> new StoreInst(newcounter, ElmentPtr, InserPos);
>
> //store the memory address to counterArray[oldcounter]
> std::vector<Constant*>  indexC(2);
> indexC[0] =  Constant::getNullvalue(Type:getInt32Ty(Context));
> indexC[1] = dync_cast(llvm::ConstantInt>(oldcounter);
Since oldcounter is not a constant (its value is not known at compile time...)
this is never going to work.  Declare the vector to be of Value* not Constant*.
Then you don't need the dynamic cast.
> Constant *ElmentPtr = ConstantExpr::getGetElementPtr(counterArray,
> &indexC[0], indexC.size());
This line can then not be a ConstantExpr, it has to be an instruction.  Again,
it cannot be a constant since the address computed isn't constant (it is not
known at compile time...).

Ciao, Duncan.
> ......// other codes
>
> Unfortunately, the oldcounter of Value type can not be cast to
> ConstantInt, dync_cast returns NULL.
> Is there any way to retrieve the integer value from oldcounter?
>
> Thanks!
>

Guangming Tan

2011-May-18 07:27 UTC

head link

[LLVMdev] access array problem

于 2011/5/18 14:29, Duncan Sands 写道:> Hi Tan Guangming,
>
>> I want to access an array in my instrumentation code. For example:
>>
>> GlobalVariable:
>> int *counter; //counter the number of load/store operations in run-time
>> int *counterArray; //record the load/store addresses
> strictly speaking these are not arrays, they are pointers.  Also, you have
> written them in some kind of C-style idiom.  What are the declarations in
> LLVM IR?const Type *IntTy = Type::getInt32Ty(M.getContext());
const Type *ATyC = ArrayType::get(Type::getInt64Ty(M.getContext()), 1);

GlobalVariable *CounterSize = new GlobalVariable(M, ATyC, false, 
GlobalValue::InternalLinkage,
Constant::getNullValue(ATyC), "MemTraceCounterSize");

const Type *ATy = ArrayType::get(Type::getInt32Ty(M.getContext()), 3000);
GlobalVariable *Counters = new GlobalVariable(M, ATy, false, 
GlobalValue::InternalLinkage,
Constant::getNullValue(ATy),
"MemTraceCounters");>> //increase the counter if a load/store is performed
>> std::vector<Constant *>index(2);
>> index[0] = Constant::getNullvalue(Type:getInt32Ty(Context));
>> index[1] = Constant::get(Type::getInt32Ty(Context), 0);
> The above two lines both compute the same thing (an i32 constant equal to
> zero) in two different ways.
>
>> Constant *ElementPtr = ConstantExpr::getGetElementPtr(counter,
>> &index[0], index.size());
>> Value *oldcounter = new LoadInst(ElementPtr, "oldcounter",
InsertPos);
>> Value *newcounter = BinaryOperator::Create(Instruction::Add,
>> oldcounter, ConstantInt::get(Type::getInt64Ty(Context), 1),
>> "newcounter", InsertPos);
>> new StoreInst(newcounter, ElmentPtr, InserPos);
>>
>> //store the memory address to counterArray[oldcounter]
>> std::vector<Constant*>   indexC(2);
>> indexC[0] =  Constant::getNullvalue(Type:getInt32Ty(Context));
>> indexC[1] = dync_cast(llvm::ConstantInt>(oldcounter);
> Since oldcounter is not a constant (its value is not known at compile
time...)
> this is never going to work.  Declare the vector to be of Value* not
Constant*.
> Then you don't need the dynamic cast.So, do you mean that we have no way to use the "oldcounter" as an
index
to access an array?>> Constant *ElmentPtr = ConstantExpr::getGetElementPtr(counterArray,
>> &indexC[0], indexC.size());
> This line can then not be a ConstantExpr, it has to be an instruction. 
Again,
> it cannot be a constant since the address computed isn't constant (it
is not
> known at compile time...).
>
> Ciao, Duncan.
>
>> ......// other codes
>>
>> Unfortunately, the oldcounter of Value type can not be cast to
>> ConstantInt, dync_cast returns NULL.
>> Is there any way to retrieve the integer value from oldcounter?
>>
>> Thanks!
>>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

Guangming Tan

2011-May-18 07:34 UTC

head link

[LLVMdev] access array problem

In fact, the prolbem is:
I instrument two global variables: "counter",
"counterArray", which are
allocated in main function.
During runtime, I want to access the "counterArray" using the
"counter"
as a index, which is also changed at runtime.

于 2011/5/18 14:29, Duncan Sands 写道:> Hi Tan Guangming,
>
>> I want to access an array in my instrumentation code. For example:
>>
>> GlobalVariable:
>> int *counter; //counter the number of load/store operations in run-time
>> int *counterArray; //record the load/store addresses
> strictly speaking these are not arrays, they are pointers.  Also, you have
> written them in some kind of C-style idiom.  What are the declarations in
> LLVM IR?
>
>> //increase the counter if a load/store is performed
>> std::vector<Constant *>index(2);
>> index[0] = Constant::getNullvalue(Type:getInt32Ty(Context));
>> index[1] = Constant::get(Type::getInt32Ty(Context), 0);
> The above two lines both compute the same thing (an i32 constant equal to
> zero) in two different ways.
>
>> Constant *ElementPtr = ConstantExpr::getGetElementPtr(counter,
>> &index[0], index.size());
>> Value *oldcounter = new LoadInst(ElementPtr, "oldcounter",
InsertPos);
>> Value *newcounter = BinaryOperator::Create(Instruction::Add,
>> oldcounter, ConstantInt::get(Type::getInt64Ty(Context), 1),
>> "newcounter", InsertPos);
>> new StoreInst(newcounter, ElmentPtr, InserPos);
>>
>> //store the memory address to counterArray[oldcounter]
>> std::vector<Constant*>   indexC(2);
>> indexC[0] =  Constant::getNullvalue(Type:getInt32Ty(Context));
>> indexC[1] = dync_cast(llvm::ConstantInt>(oldcounter);
> Since oldcounter is not a constant (its value is not known at compile
time...)
> this is never going to work.  Declare the vector to be of Value* not
Constant*.
> Then you don't need the dynamic cast.
>
>> Constant *ElmentPtr = ConstantExpr::getGetElementPtr(counterArray,
>> &indexC[0], indexC.size());
> This line can then not be a ConstantExpr, it has to be an instruction. 
Again,
> it cannot be a constant since the address computed isn't constant (it
is not
> known at compile time...).
>
> Ciao, Duncan.
>
>> ......// other codes
>>
>> Unfortunately, the oldcounter of Value type can not be cast to
>> ConstantInt, dync_cast returns NULL.
>> Is there any way to retrieve the integer value from oldcounter?
>>
>> Thanks!
>>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev

Reasonably Related Threads

Search for more reasonably related threads

llvm dev - May 2011 - [LLVMdev] access array problem

[LLVMdev] access array problem

[LLVMdev] access array problem

[LLVMdev] access array problem

[LLVMdev] access array problem

Reasonably Related Threads