search for: dstptr

Here's the current code (abstracted a bit) const Instruction *Src, const Instruction *Dst, // make sure they are loads and stores, then const Value *SrcPtr = getPointerOperand(Src); // hides a little casting, then Src->getPointerOperand const Value *DstPtr = getPointerOperand(Dst); // ditto // see how underlying objects alias, then const GEPOperator *SrcGEP = dyn_cast<GEPOperator>(SrcPtr); const GEPOperator *DstGEP = dyn_cast<GEPOperator>(DstPtr); After that, most everything is done by disassembling the SrcGEP and DstGEP. The...

On 11/02/2012 11:02 AM, Hal Finkel wrote: > ----- Original Message ----- >> From: "Tobias Grosser" <tobias at grosser.es> >> To: "preston briggs" <preston.briggs at gmail.com> >> Cc: "Benjamin Kramer" <benny.kra at gmail.com>, "LLVM Developers Mailing List" <llvmdev at cs.uiuc.edu> >> Sent: Friday, November

...d: isa<X>(Val) && "cast<Ty>() argument of incompatible type!" This is what I'm attempting: SDValue LangTargetLowering::LowerSTORE(SDValue Op, SelectionDAG& DAG){ const StoreSDNode* storeOp = dyn_cast<StoreSDNode>(Op.Val); const SDValue& dstPtr = storeOp->getBasePtr(); const SrcValueSDNode* svdstVal = cast<SrcValueSDNode>(dstPtr.Val); const Value* dstVal = svdstVal->getValue(); int addressSpace = ADDRESS_NONE; const Type* dstType = dstVal->getType(); if (isa<PointerType>(dstType)) {...

The address qualifier is stored in the type of %result. From that operand, you can get the Value and then call getType. The type for result should be a PointerType which you cast to a PointerType and get the getAddressSpace e.g. cast<PointerType>(Ty)->getAddressSpace() -- Mon Ping On Sep 17, 2008, at 1:06 PM, Villmow, Micah wrote: > How do I access the address qualifier

How do I access the address qualifier from the store instruction. Given the following code: define void @test_unary_op_anegate(float %x, float addrspace(11)* %result) nounwind { entry: %neg = sub float -0.000000e+000, %x ; <float> [#uses=1] store float %neg, float addrspace(11)* %result ret void } When I attempt to generate this code, I'm

...s and add them as constraints // to the dependency checks. for (int i = 1; i < size; ++i) { if (!isKnownNonNegative(SrcSubscripts[i], SrcPtr)) return false; if (!isKnownLessThan(SrcSubscripts[i], Sizes[i - 1])) return false; if (!isKnownNonNegative(DstSubscripts[i], DstPtr)) return false; if (!isKnownLessThan(DstSubscripts[i], Sizes[i - 1])) return false; } ``` The problem is that in a lot of cases these conditions cannot be proven statically, even though the delinearized indexes are in fact correct. For example consider this simple loop: ```...

...better to record these sizes and add them as constraints // to the dependency checks. for (int i = 1; i < size; ++i) { if (!isKnownNonNegative(SrcSubscripts[i], SrcPtr)) return false; if (!isKnownLessThan(SrcSubscripts[i], Sizes[i - 1])) return false; if (!isKnownNonNegative(DstSubscripts[i], DstPtr)) return false; if (!isKnownLessThan(DstSubscripts[i], Sizes[i - 1])) return false; } ``` The problem is that in a lot of cases these conditions cannot be proven statically, even though the delinearized indexes are in fact correct. For example consider this simple loop: ``` void foo(int n, int m...

...constraints > // to the dependency checks. > for (int i = 1; i < size; ++i) { > if (!isKnownNonNegative(SrcSubscripts[i], SrcPtr)) > return false; > > if (!isKnownLessThan(SrcSubscripts[i], Sizes[i - 1])) > return false; > > if (!isKnownNonNegative(DstSubscripts[i], DstPtr)) > return false; > > if (!isKnownLessThan(DstSubscripts[i], Sizes[i - 1])) > return false; > } > ``` > > The problem is that in a lot of cases these conditions cannot be proven > statically, even though the delinearized indexes are in fact correct. For > example con...

...t; constraints > // to the dependency checks. > for (int i = 1; i < size; ++i) { > if (!isKnownNonNegative(SrcSubscripts[i], SrcPtr)) > return false; > > if (!isKnownLessThan(SrcSubscripts[i], Sizes[i - 1])) > return false; > > if (!isKnownNonNegative(DstSubscripts[i], DstPtr)) > return false; > > if (!isKnownLessThan(DstSubscripts[i], Sizes[i - 1])) > return false; > } > ``` > > The problem is that in a lot of cases these conditions cannot be proven > statically, even though the delinearized indexes are in fact correct. For > example consi...