[LLVMdev] access array problem

[Guangming Tan]

Thank you, Duncan.

  I rewrote the code, please help check why it still does not work:

//declare global variable
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");

//get the index
std::vector<Constant*>IndicesC(2);
IndicesC[0] = Constant::getNullValue(Type::getInt32Ty(Context));
IndicesC[1] = ConstantInt::get(Type::getInt32Ty(Context),0);
Constant *ElementPtrC =  
ConstantExpr::getGetElementPtr(CounterSize,&IndicesC[0],IndicesC.size());
                                                  Value *OldCounterSize 
=new LoadInst(ElementPtrC, "OldCounterSize", InsertPos);
Value *OldCounterSize =new LoadInst(ElementPtrC, "", InsertPos);

//create a getelementptr instruction: we want get &Counters[OldCounterSize]
  std::vector<Value*>new_idx;
new_idx.push_back(OldCounterSize); // ERROR?
Value *nextaddr = GetElementPtrInst::Create(Counters, new_idx.begin(), 
new_idx.end(), "", InsertPos);

Thanks!
? 2011/5/18 16:04, Duncan Sands ??:
> Hi Guangming Tan,
>
>>>> 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");
> so CounterSize is an array of length 1, containing a single 64 bit integer.
> Using an array seems rather pointless here.
>
>> const Type *ATy = ArrayType::get(Type::getInt32Ty(M.getContext()), 3000);
>> GlobalVariable *Counters = new GlobalVariable(M, ATy, false,
>> GlobalValue::InternalLinkage,
>> Constant::getNullValue(ATy), "MemTraceCounters");
> OK, so Counters is an array of 3000 32 bit integers.
>
>>>> Constant *ElementPtr = ConstantExpr::getGetElementPtr(counter,
>>>> &index[0], index.size());
> What is "counter", the same things as CounterSize?
>
>>>> //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?
> No, this is perfectly possible.  I think you are confusing constants and
> instructions.  Instructions are executed at runtime.  Constants are known
> at compile time.  You clearly need an instruction here but you are trying
> to create a constant.
>
>>>> Constant *ElmentPtr = ConstantExpr::getGetElementPtr(counterArray,
>>>> &indexC[0], indexC.size());
> Here you should be using GetElementPtrInst::Create to make a getelementptr
> instruction rather than using ConstantExpr::getGetElementPtr which creates a
> getelementptr constant (which represents a constant address - the address you
> are computing is clearly not constant since it changes every time counter is
> incremented).
>
> Ciao, Duncan.
>
>>> 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
>> _______________________________________________
>> 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

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20110518/01e5f13f/attachment.html>