[LLVMdev] access array problem

[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