Diff 98959

polly/trunk/include/polly/ScopBuilder.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Lines	class ScopBuilder {
SmallSetVector<Value *, 16> ArrayBasePointers;		SmallSetVector<Value *, 16> ArrayBasePointers;

// The Scop		// The Scop
std::unique_ptr<Scop> scop;		std::unique_ptr<Scop> scop;

// Methods for pattern matching against Fortran code generated by dragonegg.		// Methods for pattern matching against Fortran code generated by dragonegg.
// @{		// @{

/// Try to pattern match and find the array descriptor structure in case of a		/// Try to match for the descriptor of a Fortran Array that has been declared
/// fortran array accesss. succeeds on load/store into a fortran array that		/// global, and is allocated in this module.
/// has been allocated.
///		///
/// @see polly::FortranArrayDescriptor		/// "@globaldescriptor" is the descriptor of the Fortran Array.
///		///
/// @param Inst The load/store instruction that access the memory.		/// Pattern match for "@globaldescriptor":
		/// 1. %mem = load double, double* bitcast (%"struct.array1_real(kind=8)"*
		/// @globaldescriptor to double**), align 32
		///
		/// 2. [%slot = getelementptr inbounds i8, i8* %mem, i64 <index>]
		/// 2 is optional because if you are writing to the 0th index, you don't
		/// need a GEP.
		///
		/// 3.1 store/load <memtype> <val>, <memtype>* %slot, align 8
		/// 3.2 store/load <memtype> <val>, <memtype>* %mem, align 8
		///
		/// @see polly::MemoryAccess, polly::ScopArrayInfo
		///
		/// @note assumes -polly-canonicalize has been run.
		///
		/// @param Inst The LoadInst/StoreInst that accesses the memory.
		///
		/// @returns Reference to @globaldescriptor on success, nullptr on failure.
		Value *findFADGlobalAlloc(MemAccInst Inst);

		/// Try to match for the descriptor of a Fortran Array that has been declared
		/// global, and is being accessed across modules.
		///
		/// Pattern match for "@globaldescriptor":
		/// 1. %mem = load double, double* bitcast (%"struct.array1_real(kind=8)"*
		/// @globaldescriptor to double**), align 32
		///
		/// 2. [%slot = getelementptr inbounds i8, i8* %mem, i64 <index>]
		/// 2 is optional because if you are writing to the 0th index, you don't
		/// need a GEP.
		///
		/// 3.1 store/load <memtype> <val>, <memtype>* %slot, align 8
		/// 3.2 store/load <memtype> <val>, <memtype>* %mem, align 8
		///
		/// @see polly::MemoryAccess, polly::ScopArrayInfo
///		///
/// @note assumes -polly-canonicalize has been run.		/// @note assumes -polly-canonicalize has been run.
GlobalValue *findFortranArrayDescriptorForAllocArrayAccess(MemAccInst Inst);		///
		/// @param Inst The LoadInst/StoreInst that accesses the memory.
		///
		/// @returns Reference to @globaldescriptor on success, nullptr on failure.
		Value *findFADGlobalNonAlloc(MemAccInst Inst);

/// Try to pattern match and find the array descriptor structure in case of a		/// Try to match for the descriptor of a Fortran array that is a parameter
/// fortran array accesss. succeeds on load/store into a fortran array that		/// to a function, and has not been allocated.
/// has been allocated.
///		///
/// @see polly::FortranArrayDescriptor		/// Pattern match for "%param":
		/// 1. %mem = bitcast %"struct.array1_integer(kind=4)"* %param to i32**
///		///
/// @param Inst The load/store instruction that access the memory.		/// 2. [%slot = getelementptr inbounds i8, i8* %mem, i64 <index>]
		/// 2 is optional because if you are writing to the 0th index, you don't
		/// need a GEP.
		///
		/// 3.1 store/load <memtype> <val>, <memtype>* %slot, align 8
		/// 3.2 store/load <memtype> <val>, <memtype>* %mem, align 8
		///
		/// @see polly::MemoryAccess, polly::ScopArrayInfo
///		///
/// @note assumes -polly-canonicalize has been run.		/// @note assumes -polly-canonicalize has been run.
GlobalValue *		///
findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst Inst);		/// @param Inst The LoadInst/StoreInst that accesses the memory.
		///
		/// @returns Reference to "%param" on success, nullptr on failure.
		Value *findFADLocalNonAlloc(MemAccInst Inst);
// @}		// @}

// Build the SCoP for Region @p R.		// Build the SCoP for Region @p R.
void buildScop(Region &R, AssumptionCache &AC);		void buildScop(Region &R, AssumptionCache &AC);

/// Try to build a multi-dimensional fixed sized MemoryAccess from the		/// Try to build a multi-dimensional fixed sized MemoryAccess from the
/// Load/Store instruction.		/// Load/Store instruction.
///		///
▲ Show 20 Lines • Show All 203 Lines • Show Last 20 Lines

polly/trunk/include/polly/ScopInfo.h

Show First 20 Lines • Show All 610 Lines • ▼ Show 20 Lines	private:
/// S: A[i] = ((double)&A[4 * i]);		/// S: A[i] = ((double)&A[4 * i]);
///		///
/// => { S[i] -> A[i]; S[i] -> A[o] : 4i <= o <= 4i + 3 }		/// => { S[i] -> A[i]; S[i] -> A[o] : 4i <= o <= 4i + 3 }
isl_map *AccessRelation;		isl_map *AccessRelation;

/// Updated access relation read from JSCOP file.		/// Updated access relation read from JSCOP file.
isl_map *NewAccessRelation;		isl_map *NewAccessRelation;

/// Fortran arrays that are created using "Allocate" are stored in terms		/// Fortran arrays whose sizes are not statically known are stored in terms
/// of a descriptor struct. This maintains a raw pointer to the memory,		/// of a descriptor struct. This maintains a raw pointer to the memory,
/// along with auxiliary fields with information such as dimensions.		/// along with auxiliary fields with information such as dimensions.
/// We hold a reference to the descriptor corresponding to a MemoryAccess		/// We hold a reference to the descriptor corresponding to a MemoryAccess
/// into a Fortran array. FAD for "Fortran Array Descriptor"		/// into a Fortran array. FAD for "Fortran Array Descriptor"
AssertingVH<GlobalValue> FAD;		AssertingVH<Value> FAD;
// @}		// @}

__isl_give isl_basic_map createBasicAccessMap(ScopStmt Statement);		__isl_give isl_basic_map createBasicAccessMap(ScopStmt Statement);

void assumeNoOutOfBound();		void assumeNoOutOfBound();

/// Compute bounds on an over approximated access relation.		/// Compute bounds on an over approximated access relation.
///		///
▲ Show 20 Lines • Show All 382 Lines • ▼ Show 20 Lines	public:
/// Get the statement that contains this memory access.		/// Get the statement that contains this memory access.
ScopStmt *getStatement() const { return Statement; }		ScopStmt *getStatement() const { return Statement; }

/// Get the reduction type of this access		/// Get the reduction type of this access
ReductionType getReductionType() const { return RedType; }		ReductionType getReductionType() const { return RedType; }

/// Set the array descriptor corresponding to the Array on which the		/// Set the array descriptor corresponding to the Array on which the
/// memory access is performed.		/// memory access is performed.
void setFortranArrayDescriptor(GlobalValue *FAD);		void setFortranArrayDescriptor(Value *FAD);

/// Update the original access relation.		/// Update the original access relation.
///		///
/// We need to update the original access relation during scop construction,		/// We need to update the original access relation during scop construction,
/// when unifying the memory accesses that access the same scop array info		/// when unifying the memory accesses that access the same scop array info
/// object. After the scop has been constructed, the original access relation		/// object. After the scop has been constructed, the original access relation
/// should not be changed any more. Instead setNewAccessRelation should		/// should not be changed any more. Instead setNewAccessRelation should
/// be called.		/// be called.
▲ Show 20 Lines • Show All 1,796 Lines • Show Last 20 Lines

polly/trunk/lib/Analysis/ScopBuilder.cpp

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines	if (!scop->contains(UseParent) \|\|
scop->hasSingleExitEdge())) {		scop->hasSingleExitEdge())) {
// At least one escaping use found.		// At least one escaping use found.
ensureValueWrite(Inst);		ensureValueWrite(Inst);
break;		break;
}		}
}		}
}		}

/// Check that a global variable has a type resembling:		/// Check that a value is a Fortran Array descriptor.
		///
		/// We check if V has the following structure:
/// %"struct.array1_real(kind=8)" = type { i8*, i<zz>, i<zz>,		/// %"struct.array1_real(kind=8)" = type { i8*, i<zz>, i<zz>,
/// [<num> x %struct.descriptor_dimension] }		/// [<num> x %struct.descriptor_dimension] }
///		///
///		///
/// %struct.descriptor_dimension = type { i<zz>, i<zz>, i<zz> }		/// %struct.descriptor_dimension = type { i<zz>, i<zz>, i<zz> }
///		///
/// @global = unnamed_addr global %"struct.array1_real(kind=8)"		/// 1. V's type name starts with "struct.array"
///		/// 2. V's type has layout as shown.
/// This function checks that:		/// 3. Final member of V's type has name "struct.descriptor_dimension",
/// 1. Global has a type name starting with "struct.array"		/// 4. "struct.descriptor_dimension" has layout as shown.
/// 2. Global type has layout as shown		/// 5. Consistent use of i<zz> where <zz> is some fixed integer number.
/// 3. Final member of Global type has name "struct.descriptor_dimension"
/// 4. "struct.descriptor_dimension" has layout as shown
/// 5. Consistent use of i<zz> where <zz> is some fixed integer number
///		///
/// We are interested in such types since this is the code that dragonegg		/// We are interested in such types since this is the code that dragonegg
/// generates for Fortran arrays.		/// generates for Fortran array descriptors.
		///
		/// @param V the Value to be checked.
///		///
/// @param Global the global variable believed to be a Fortran array		/// @returns True if V is a Fortran array descriptor, False otherwise.
bool isGlobalFortranArray(GlobalValue *Global) {		bool isFortranArrayDescriptor(Value *V) {
auto StructArrTy = dyn_cast<StructType>(Global->getValueType());		PointerType *PTy = dyn_cast<PointerType>(V->getType());

		if (!PTy)
		return false;

		Type *Ty = PTy->getElementType();
		assert(Ty && "Ty expected to be initialized");
		auto *StructArrTy = dyn_cast<StructType>(Ty);

if (!(StructArrTy && StructArrTy->hasName()))		if (!(StructArrTy && StructArrTy->hasName()))
return false;		return false;

if (!StructArrTy->getName().startswith("struct.array"))		if (!StructArrTy->getName().startswith("struct.array"))
return false;		return false;

if (StructArrTy->getNumElements() != 4)		if (StructArrTy->getNumElements() != 4)
return false;		return false;

const ArrayRef<Type *> ArrMemberTys = StructArrTy->elements();		const ArrayRef<Type *> ArrMemberTys = StructArrTy->elements();

// i8* match		// i8* match
if (ArrMemberTys[0] != Type::getInt8PtrTy(Global->getContext()))		if (ArrMemberTys[0] != Type::getInt8PtrTy(V->getContext()))
return false;		return false;

// Get a reference to the int type and check that all the members		// Get a reference to the int type and check that all the members
// share the same int type		// share the same int type
Type *IntTy = ArrMemberTys[1];		Type *IntTy = ArrMemberTys[1];
if (ArrMemberTys[2] != IntTy)		if (ArrMemberTys[2] != IntTy)
return false;		return false;

Show All 18 Lines	bool isFortranArrayDescriptor(Value *V) {
for (auto MemberTy : DescriptorDimTy->elements()) {		for (auto MemberTy : DescriptorDimTy->elements()) {
if (MemberTy != IntTy)		if (MemberTy != IntTy)
return false;		return false;
}		}

return true;		return true;
}		}

/// This is matching against code generated by dragonegg after simplifier		Value *ScopBuilder::findFADGlobalNonAlloc(MemAccInst Inst) {
/// passes have been run.
///
/// This is trying to match against "@globaldescriptor", the descriptor
/// of the Fortran array that is being accessed at load/store. This style
/// of code is generated for arrays that have been allocated using "Allocate"
/// in the same module.
///
/// Pattern Match:
/// 1. %mallocmem = i8* @malloc(i64 40)
///
/// 5. store i8* %mallocmem, i8** getelementptr inbounds
/// (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"*
/// @globaldescriptor, i64 0, i32 0), align 32
///
/// 2. %typedmem = bitcast i8* %mallocmem to <memtype>*
///
/// 3. [%slot = getelementptr inbounds i8, i8* %typedmem, i64 <index>]
/// 3 is optional because if you are writing to the 0th index, you don't
/// need a GEP.
///
/// 4.1 store/load <memtype> <val>, <memtype>* %typedmem, align 8
/// 4.2 store/load <memtype> <val>, <memtype>* %slot, align 8
GlobalValue *
ScopBuilder::findFortranArrayDescriptorForAllocArrayAccess(MemAccInst Inst) {
// match: 4.1 & 4.2 store/load		// match: 4.1 & 4.2 store/load
if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))		if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))
return nullptr;		return nullptr;

// match: 4		// match: 4
if (Inst.getAlignment() != 8)		if (Inst.getAlignment() != 8)
return nullptr;		return nullptr;

Show All 40 Lines	if (!DescriptorGEP)
continue;		continue;

// match: 5		// match: 5
auto DescriptorType =		auto DescriptorType =
dyn_cast<StructType>(DescriptorGEP->getSourceElementType());		dyn_cast<StructType>(DescriptorGEP->getSourceElementType());
if (!(DescriptorType && DescriptorType->hasName()))		if (!(DescriptorType && DescriptorType->hasName()))
continue;		continue;

GlobalValue *Descriptor =		Value *Descriptor = dyn_cast<Value>(DescriptorGEP->getPointerOperand());
dyn_cast<GlobalValue>(DescriptorGEP->getPointerOperand());

if (!Descriptor)		if (!Descriptor)
continue;		continue;

if (!isGlobalFortranArray(Descriptor))		if (!isFortranArrayDescriptor(Descriptor))
continue;		continue;

return Descriptor;		return Descriptor;
}		}

return nullptr;		return nullptr;
}		}

/// This is matching against code generated by dragonegg after simplifier		Value *ScopBuilder::findFADGlobalAlloc(MemAccInst Inst) {
/// passes have been run.
///
/// This is trying to match against "@globaldescriptor", the descriptor
/// of the Fortran array that is being accessed at load/store. This style
/// of code is generated for arrays that have been declared global, and
/// are being accessed across modules.
///
/// Pattern Match:
/// 1. %mem = load double, double* bitcast (%"struct.array1_real(kind=8)"*
/// @globaldescriptor to double**), align 32
///
/// 2. [%slot = getelementptr inbounds i8, i8* %mem, i64 <index>]
/// 2 is optional because if you are writing to the 0th index, you don't
/// need a GEP.
///
/// 3.1 store/load <memtype> <val>, <memtype>* %slot, align 8
/// 3.2 store/load <memtype> <val>, <memtype>* %mem, align 8
GlobalValue *
ScopBuilder::findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst Inst) {
// match: 3		// match: 3
if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))		if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))
return nullptr;		return nullptr;

// match: 3		// match: 3
if (Inst.getAlignment() != 8)		if (Inst.getAlignment() != 8)
return nullptr;		return nullptr;

Show All 12 Lines	Value *ScopBuilder::findFADGlobalAlloc(MemAccInst Inst) {
if (!MemLoad)		if (!MemLoad)
return nullptr;		return nullptr;

auto *BitcastOperator =		auto *BitcastOperator =
dyn_cast<BitCastOperator>(MemLoad->getPointerOperand());		dyn_cast<BitCastOperator>(MemLoad->getPointerOperand());
if (!BitcastOperator)		if (!BitcastOperator)
return nullptr;		return nullptr;

GlobalValue *Descriptor =		Value *Descriptor = dyn_cast<Value>(BitcastOperator->getOperand(0));
dyn_cast<GlobalValue>(BitcastOperator->getOperand(0));		if (!Descriptor)
		return nullptr;

		if (!isFortranArrayDescriptor(Descriptor))
		return nullptr;

		return Descriptor;
		}

		Value *ScopBuilder::findFADLocalNonAlloc(MemAccInst Inst) {
		// match: 3
		if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))
		return nullptr;

		// match: 3
		if (Inst.getAlignment() != 8)
		return nullptr;

		Value *Slot = Inst.getPointerOperand();

		BitCastOperator *MemBitcast = nullptr;
		// [match: 2]
		if (auto *SlotGEP = dyn_cast<GetElementPtrInst>(Slot)) {
		// match: 1
		MemBitcast = dyn_cast<BitCastOperator>(SlotGEP->getPointerOperand());
		} else {
		// match: 1
		MemBitcast = dyn_cast<BitCastOperator>(Slot);
		}

		if (!MemBitcast)
		return nullptr;

		Value *Descriptor = dyn_cast<Value>(MemBitcast->getOperand(0));
if (!Descriptor)		if (!Descriptor)
return nullptr;		return nullptr;

if (!isGlobalFortranArray(Descriptor))		if (!isFortranArrayDescriptor(Descriptor))
return nullptr;		return nullptr;

return Descriptor;		return Descriptor;
}		}

bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {		bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
Value *Val = Inst.getValueOperand();		Value *Val = Inst.getValueOperand();
Type *ElementType = Val->getType();		Type *ElementType = Val->getType();
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 Lines	void ScopBuilder::addArrayAccess(
ArrayBasePointers.insert(BaseAddress);		ArrayBasePointers.insert(BaseAddress);
auto *MemAccess = addMemoryAccess(		auto *MemAccess = addMemoryAccess(
MemAccInst->getParent(), MemAccInst, AccType, BaseAddress, ElementType,		MemAccInst->getParent(), MemAccInst, AccType, BaseAddress, ElementType,
IsAffine, AccessValue, Subscripts, Sizes, MemoryKind::Array);		IsAffine, AccessValue, Subscripts, Sizes, MemoryKind::Array);

if (!DetectFortranArrays)		if (!DetectFortranArrays)
return;		return;

if (GlobalValue *FAD =		if (Value *FAD = findFADGlobalNonAlloc(MemAccInst))
findFortranArrayDescriptorForAllocArrayAccess(MemAccInst))		MemAccess->setFortranArrayDescriptor(FAD);
		else if (Value *FAD = findFADGlobalAlloc(MemAccInst))
MemAccess->setFortranArrayDescriptor(FAD);		MemAccess->setFortranArrayDescriptor(FAD);
else if (GlobalValue *FAD =		else if (Value *FAD = findFADLocalNonAlloc(MemAccInst))
findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst))
MemAccess->setFortranArrayDescriptor(FAD);		MemAccess->setFortranArrayDescriptor(FAD);
}		}

void ScopBuilder::ensureValueWrite(Instruction *Inst) {		void ScopBuilder::ensureValueWrite(Instruction *Inst) {
ScopStmt *Stmt = scop->getStmtFor(Inst);		ScopStmt *Stmt = scop->getStmtFor(Inst);

// Inst not defined within this SCoP.		// Inst not defined within this SCoP.
if (!Stmt)		if (!Stmt)
▲ Show 20 Lines • Show All 272 Lines • Show Last 20 Lines

polly/trunk/lib/Analysis/ScopInfo.cpp

Show First 20 Lines • Show All 1,028 Lines • ▼ Show 20 Lines	raw_ostream &polly::operator<<(raw_ostream &OS,
MemoryAccess::ReductionType RT) {		MemoryAccess::ReductionType RT) {
if (RT == MemoryAccess::RT_NONE)		if (RT == MemoryAccess::RT_NONE)
OS << "NONE";		OS << "NONE";
else		else
OS << MemoryAccess::getReductionOperatorStr(RT);		OS << MemoryAccess::getReductionOperatorStr(RT);
return OS;		return OS;
}		}

void MemoryAccess::setFortranArrayDescriptor(GlobalValue *FAD) {		void MemoryAccess::setFortranArrayDescriptor(Value *FAD) { this->FAD = FAD; }
this->FAD = FAD;

// TODO: write checks to make sure it looks _exactly_ like a Fortran array
// descriptor
#ifndef NDEBUG
StructType *ty = dyn_cast<StructType>(FAD->getValueType());
assert(ty && "expected value of type Fortran array descriptor");
assert(ty->hasName() && ty->getName().startswith("struct.array") &&
"expected global to follow Fortran array descriptor type naming "
"convention");
assert(ty->getNumElements() == 4 &&
"expected layout to be like Fortran array descriptor type");
#endif
}

void MemoryAccess::print(raw_ostream &OS) const {		void MemoryAccess::print(raw_ostream &OS) const {
switch (AccType) {		switch (AccType) {
case READ:		case READ:
OS.indent(12) << "ReadAccess :=\t";		OS.indent(12) << "ReadAccess :=\t";
break;		break;
case MUST_WRITE:		case MUST_WRITE:
OS.indent(12) << "MustWriteAccess :=\t";		OS.indent(12) << "MustWriteAccess :=\t";
▲ Show 20 Lines • Show All 3,837 Lines • Show Last 20 Lines

polly/trunk/test/ScopInfo/fortran_array_param_nonmalloc_nonvectored.ll

				; RUN: opt %loadPolly -analyze -polly-detect-fortran-arrays \
				; RUN: -polly-scops -polly-allow-nonaffine -polly-invariant-load-hoisting < %s \| FileCheck %s

				; This testcase is the corresponding LLVM for testfunc:
				; PROGRAM main
				; INTEGER, DIMENSION(1) :: xs
				;
				; CALL testfunc(xs, 10)
				; CONTAINS
				; SUBROUTINE func(xs, n)
				; IMPLICIT NONE
				; INTEGER, DIMENSION(:), INTENT(INOUT) :: xs
				; INTEGER, INTENT(IN) :: n
				; INTEGER :: i

				; DO i = 1, n
				; xs(i) = 1
				; END DO
				;
				; END SUBROUTINE func
				; END PROGRAM

				target datalayout = "e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
				target triple = "x86_64-unknown-linux-gnu"

				module asm "\09.ident\09\22GCC: (GNU) 4.6.4 LLVM: 3.3.1\22"

				%"struct.array1_integer(kind=4)" = type { i8*, i64, i64, [1 x %struct.descriptor_dimension] }
				%struct.descriptor_dimension = type { i64, i64, i64 }

				define internal void @testfunc(%"struct.array1_integer(kind=4)"* noalias %xs, i32* noalias %n) {
				entry:
				br label %entry.split

				entry.split: ; preds = %entry
				%tmp = getelementptr inbounds %"struct.array1_integer(kind=4)", %"struct.array1_integer(kind=4)"* %xs, i64 0, i32 3, i64 0, i32 0
				%tmp1 = load i64, i64* %tmp, align 8
				%tmp2 = icmp eq i64 %tmp1, 0
				%tmp3 = select i1 %tmp2, i64 1, i64 %tmp1
				%tmp4 = bitcast %"struct.array1_integer(kind=4)"* %xs to i32**
				%tmp5 = load i32, i32* %tmp4, align 8
				%tmp6 = load i32, i32* %n, align 4
				%tmp7 = icmp sgt i32 %tmp6, 0
				br i1 %tmp7, label %"6.preheader", label %return

				"6.preheader": ; preds = %entry.split
				br label %"6"

				"6": ; preds = %"6", %"6.preheader"
				%tmp8 = phi i32 [ %tmp14, %"6" ], [ 1, %"6.preheader" ]
				%tmp9 = sext i32 %tmp8 to i64
				%tmp10 = mul i64 %tmp3, %tmp9
				%tmp11 = sub i64 %tmp10, %tmp3
				%tmp12 = getelementptr i32, i32* %tmp5, i64 %tmp11
				store i32 1, i32* %tmp12, align 4
				%tmp13 = icmp eq i32 %tmp8, %tmp6
				%tmp14 = add i32 %tmp8, 1
				br i1 %tmp13, label %return.loopexit, label %"6"

				return.loopexit: ; preds = %"6"
				br label %return

				return: ; preds = %return.loopexit, %entry.split
				ret void
				}

				; CHECK: ReadAccess := [Reduction Type: NONE] [Fortran array descriptor: xs] [Scalar: 0]

This is an archive of the discontinued LLVM Phabricator instance.

[Fortran Support] Add pattern match style for local fortran arrays
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 98959

polly/trunk/include/polly/ScopBuilder.h

polly/trunk/include/polly/ScopInfo.h

polly/trunk/lib/Analysis/ScopBuilder.cpp

polly/trunk/lib/Analysis/ScopInfo.cpp

polly/trunk/test/ScopInfo/fortran_array_param_nonmalloc_nonvectored.ll

This is an archive of the discontinued LLVM Phabricator instance.

[Fortran Support] Add pattern match style for local fortran arraysClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 98959

polly/trunk/include/polly/ScopBuilder.h

polly/trunk/include/polly/ScopInfo.h

polly/trunk/lib/Analysis/ScopBuilder.cpp

polly/trunk/lib/Analysis/ScopInfo.cpp

polly/trunk/test/ScopInfo/fortran_array_param_nonmalloc_nonvectored.ll

[Fortran Support] Add pattern match style for local fortran arrays
ClosedPublic