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
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 addressesstrictly 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! >
于 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
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