[Polly] [Fortran Support] Add pattern matching to find Fortran array descriptor

[bollu]

Summary

Dragonegg genereates Fortran arrays that have been created using Allocate(..),
as well as globals in a specific way. This allows us to acces their internal
structure and query for properties such as dimension.

This patch adds preliminary support for detection and storage of the Fortran
array descriptor structures. For now, the tests simply check that Fortran
arrays are being detected.

We can build up on this to emit run-time checks for array dimensions. That will
be a separate patch

[Meinersbur]

Can you explain why you need to call ConstantExpr::getAsInstruction(). The patch could be significantly simpler we do not "convert" a ConstantExpr to Instruction. Am I missing something?

DraggonEgg is a de-facto abandoned project (The test cases were generated by LLVM 3.3.1). To use DraggonEgg with Polly today, one has to emit the code with an old release of LLVM with DraggenEgg to a bitcode file, then import it into a newer LLVM with Polly. To compile Fortran, there is flang. Is there still a need to support DraggonEgg?

include/polly/ScopBuilder.h

63

Please use proper capitalization: @see polly::FortranArrayDescriptor

65

Please use the same capitalization as the argument name: @param Inst ...

include/polly/ScopInfo.h

413

"dumb struct" is also called a Plain Old Data (POD). See http://www.cplusplus.com/reference/type_traits/is_pod/.

It is not, btw. std::unique_ptr and AssertingVH have destructors.

I think you should just remove that line, as it is misleading.

432

Do you have other means of explaining the delete-issue than pointing to an unofficial mirror url?

452

This line is only used for asserts. You could put that part with this asserts into a #ifndef NDEBUG block.

468

Did you consider making this method const?

This seems to be the only public accessor of this class. DescriptorOwningInstruction is used to not prematurely free the instruction. To do need to store a reference to Descriptor or would its name be enough?

741

I don't know if Doxygen processes @see if not on its own line.

742

Did you consider moving this fields where the other fields of this class are defined?

lib/Analysis/ScopBuilder.cpp

1

Mistake?

116–129

Please don't just copy the IR from somewhere, only include things that are relevant. For instance !tbaa !5 doesn't mean anything without the MDNode.

Please also explain what the code you are matching is supposed to do.

180–181

I don't undersant why we need to call ConstantExpr::getAsInstruction? Can't we just also patch the ConstantExpr?

200

Can we avoid matching by name? The name should have no influence on the semantics.

251–252

Again, why the need for ConstantExpr::getAsInstruction()?

lib/Analysis/ScopInfo.cpp

1022

Did you consider having FAD as an argument of `MemoryAccesses ctor. It seems to be required only for initialization.

[bollu]

I'm not super familiar with the LLVM API to manipulate IR, so apologies for any API abuse!

Can you explain why you need to call ConstantExpr::getAsInstruction(). The patch could be significantly simpler we do not "convert" a ConstantExpr to Instruction. Am I missing something?

From what I understand, the docs seem to imply that ConstantExpr is a black-box. I wish to pattern match on the GetElementPtr constant expression.

• [lvm::GetElementPtrConstantExpr](http://llvm.org/docs/doxygen/html/classllvm_1_1GetElementPtrConstantExpr.html) mentions that "...GetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the s.cenes to implement getelementpr constant exprs".
• Similarly, I wish to destructure a ConstantExpr into a Bitcast, since I wanted to access the array that is being bitcasted.

The only API that seemed to expose the internals of which ContantExpr is being exposed is getAsInstruction(). If this is a misuse of the API, I'd like to know what the correct pattern is. Yes, if there's a clean way to get this information, the ugliness goes away.

[bollu]

include/polly/ScopBuilder.h

65

Thanks for the catch, will fix.

include/polly/ScopInfo.h

413

right. I meant "dumb" in the sense of "contains no dynamic behaviour" / "is used as a data aggregate", not "has no complex behaviour on destruction".

Do you have a better name for that sort of thing? I agree, "dumb" is misleading.

432

Everywhere else the method getAsInstruction is used, they attach to a basic-block that LLVM frees.

I can point to the official LLVM sources instead of the mirror, but the point is the same, is it not? It is used in a test within LLVM to free the chunk of memory.

468

yes, this should be const. Thanks for the catch.

I think I will need the Descriptor later on, to generate things such as run-time checks. I will need access to the LLVM IR Value to generate Load/Store instructions from the Descriptor.

lib/Analysis/ScopBuilder.cpp

200

do you want me to match based on the internal structure of the struct? I could do that, but again, there could be another struct with the same layout.

Would be OK with the solution where I pattern match on both the name and the structure?

lib/Analysis/ScopInfo.cpp

1022

I considered it. However, in that case, construction of the MemoryAccess becomes more complex (and tied in with the Fortran stuff). I wanted to keep the changes to MemoryAccess as isolated as possible.

Currently, computing the array descriptor is somewhat orthogonal from the computation of the memory access. I didn't want to tightly couple them for the reasons mentioned above.

[philip.pfaffe]

If this is a misuse of the API, I'd like to know what the correct pattern is. Yes, if there's a clean way to get this information, the ugliness goes away.

I wouldn't call it a misuse, but it isn't beautiful either. On the other hand, there might not be a beautiful way.

What you can do is check the Opcode of the ConstantExpr CE->getOpcode() == Instruction::GetElementPtr, and manually inspect the Operands, e.g. check if they're all ConstantInts.

[Meinersbur]

In D32639#740731, @bollu wrote:

I'm not super familiar with the LLVM API to manipulate IR, so apologies for any API abuse!

Can you explain why you need to call ConstantExpr::getAsInstruction(). The patch could be significantly simpler we do not "convert" a ConstantExpr to Instruction. Am I missing something?

From what I understand, the docs seem to imply that ConstantExpr is a black-box. I wish to pattern match on the GetElementPtr constant expression.

• [lvm::GetElementPtrConstantExpr](http://llvm.org/docs/doxygen/html/classllvm_1_1GetElementPtrConstantExpr.html) mentions that "...GetElementPtrConstantExpr - This class is private to Constants.cpp, and is used behind the s.cenes to implement getelementpr constant exprs".
• Similarly, I wish to destructure a ConstantExpr into a Bitcast, since I wanted to access the array that is being bitcasted.

The only API that seemed to expose the internals of which ContantExpr is being exposed is getAsInstruction(). If this is a misuse of the API, I'd like to know what the correct pattern is. Yes, if there's a clean way to get this information, the ugliness goes away.

Have you tried llvm::GEPOperator?

[bollu]

• [NFC wrt patch] fix capitalization, comment order and style, comment phrasing.

• Fix mistake comment
• Change order of comments to separate out Fortran parts
• Wrap Fortran pattern matching in ScopBuilder.h in a ..@
• Document pattern matching functions properly, remove extra un-necessary IR cruft.
• remove "dumb struct" comment. Still looking for a way to describe that this struct should not have behaviour. Rather, it is used as an aggregate.

[bollu]

[NFC wrt patch] Don't return StringRef for name, clone & return a std::string

[Meinersbur]

Fails for msvc with:

C:\Users\Meinersbur\src\llvm\tools\polly\lib\Analysis\ScopBuilder.cpp(218): error C2668: 'llvm::make_unique': ambiguous call to overloaded function
C:\Users\Meinersbur\src\llvm\include\llvm/ADT/STLExtras.h(927): note: could be 'std::unique_ptr<polly::FortranArrayDescriptor,std::default_delete<_Ty>> llvm::make_unique<polly::FortranArrayDescriptor,llvm::GlobalValue*&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>>>(llvm::GlobalValue *&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>> &&)'
        with
        [
            _Ty=polly::FortranArrayDescriptor
        ]
C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\memory(1628): note: or       'std::unique_ptr<polly::FortranArrayDescriptor,std::default_delete<_Ty>> std::make_unique<polly::FortranArrayDescriptor,llvm::GlobalValue*&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>>>(llvm::GlobalValue *&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>> &&)' [found using argument-dependent lookup]
        with
        [
            _Ty=polly::FortranArrayDescriptor
        ]
C:\Users\Meinersbur\src\llvm\tools\polly\lib\Analysis\ScopBuilder.cpp(218): note: while trying to match the argument list '(llvm::GlobalValue *, std::unique_ptr<llvm::Instruction,std::default_delete<_Ty>>)'
        with
        [
            _Ty=llvm::Instruction
        ]
C:\Users\Meinersbur\src\llvm\tools\polly\lib\Analysis\ScopBuilder.cpp(276): error C2668: 'llvm::make_unique': ambiguous call to overloaded function
C:\Users\Meinersbur\src\llvm\include\llvm/ADT/STLExtras.h(927): note: could be 'std::unique_ptr<polly::FortranArrayDescriptor,std::default_delete<_Ty>> llvm::make_unique<polly::FortranArrayDescriptor,llvm::GlobalValue*&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>>>(llvm::GlobalValue *&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>> &&)'
        with
        [
            _Ty=polly::FortranArrayDescriptor
        ]
C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\INCLUDE\memory(1628): note: or       'std::unique_ptr<polly::FortranArrayDescriptor,std::default_delete<_Ty>> std::make_unique<polly::FortranArrayDescriptor,llvm::GlobalValue*&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>>>(llvm::GlobalValue *&,std::unique_ptr<llvm::Instruction,std::default_delete<llvm::Instruction>> &&)' [found using argument-dependent lookup]
        with
        [
            _Ty=polly::FortranArrayDescriptor
        ]
C:\Users\Meinersbur\src\llvm\tools\polly\lib\Analysis\ScopBuilder.cpp(276): note: while trying to match the argument list '(llvm::GlobalValue *, std::unique_ptr<llvm::Instruction,std::default_delete<_Ty>>)'
        with
        [
            _Ty=llvm::Instruction
        ]

lib/Analysis/ScopBuilder.cpp

180–181

With this your test cases still work:

diff --git a/lib/Analysis/ScopBuilder.cpp b/lib/Analysis/ScopBuilder.cpp
index c399e0d2..9d9b381d 100644
--- a/lib/Analysis/ScopBuilder.cpp
+++ b/lib/Analysis/ScopBuilder.cpp
@@ -183,16 +183,7 @@ ScopBuilder::findFortranArrayDescriptorForAllocArrayAccess(MemAccInst Inst) {
     if (!DescriptorGEP)
       continue;

-    // this needs to be deleted, on the basis of:
-    // https://github.com/llvm-mirror/llvm/blob/93e6e5414ded14bcbb233baaaa5567132fee9a0c/unittests/IR/ConstantsTest.cpp#L186
-    std::unique_ptr<Instruction> DescriptorGEPRawInst(
-        DescriptorGEP->getAsInstruction());
-
-    // We want an instruction and not a ConstantExpr since this should
-    // give us more flexibility to inspect the GEP.
-    auto *DescriptorGEPInst =
-        dyn_cast<GetElementPtrInst>(DescriptorGEPRawInst.get());
-
+    auto *DescriptorGEPInst = dyn_cast<GEPOperator>(DescriptorGEP);
     if (!(DescriptorGEPInst && DescriptorGEPInst->hasAllConstantIndices())) {
       continue;
     }
@@ -214,8 +205,7 @@ ScopBuilder::findFortranArrayDescriptorForAllocArrayAccess(MemAccInst Inst) {
     if (!Descriptor) {
       continue;
     }
-    return make_unique<FortranArrayDescriptor>(Descriptor,
-                                               std::move(DescriptorGEPRawInst));
+    return make_unique<FortranArrayDescriptor>(Descriptor, nullptr);
   }

   return nullptr;

277

The ; is unnecessary

[etherzhhb]

lib/Analysis/ScopBuilder.cpp

139

Maybe functions from llvm/IR/PatternMatch.h can help you to simplify this function

691–697

Actually findFortranArrayDescriptorForAllocArrayAccess and findFortranArrayDescriptorForNonAllocArrayAccess do not need to return a std::unique_ptr.

If setFortranArrayDescriptor is written as:

void MemoryAccess::setFortranArrayDescriptor(FortranArrayDescriptor *FAD) {
  this->FAD.reset(FAD);

  // TODO: write checks to make sure it looks _exactly_ like a Fortran array
  // descriptor
};

[bollu]

@Meinersbur: Are there windows buildbots for Polly whose outputs I can look at? I think the ambiguity is between llvm::make_unique and std::make_unique.

[bollu]

• [NFC wrt patch] clarified which make_unique to pick. Pick llvm::make_unique

[Meinersbur]

If you are not going to use dyn_cast<GEPOperator>, could you please state the reason why?

[bollu]

• replace getAsInstruction with dyn_cast<[GEP|BitCast]Operator>. Thanks @Meinersbur!

[bollu]

@Meinersbur:

Fixed, I'm using dyn_cast<GEPOperator>. I wanted to explore the other error, not that I was against using GEPOperator. Thanks for pointing me to it!

Could you point me to how I could have discovered that GEPOperator works in this case on my own? I later read that *Operator acts as a unifying API to manipulate *Instruction and *ConstantExpr, but is there someplace in the documentation that this relationship is expressed? It's described in llvm::Operator, but not in llvm::Instruction or llvm::ConstantExpr from what I've seen.

@etherzhhb:

Maybe functions from llvm/IR/PatternMatch.h can help you to simplify this function

I looked at PatternMatch.h, and I did not find a way to pattern match against GEP instructions. Am I missing it or does the functionality not exist?

Actually findFortranArrayDescriptorForAllocArrayAccess and findFortranArrayDescriptorForNonAllocArrayAccess do not need to return a std::unique_ptr.

I would prefer to return a unique_ptr with make_unique at the site of the allocation itself since it prevents a whole class of bugs. Could you tell me the rationale for not wishing to
take a unique_ptr as a parameter to MemoryAccess::setFortranArrayDescriptor?

[Meinersbur]

I hoped to get rid of FortranaArrayDescriptor entirely. All the it is used for is getName(). ScopArrayInfo already has a BaseName property that you could use for this purpose.

In D32639#743129, @bollu wrote:

Could you point me to how I could have discovered that GEPOperator works in this case on my own? I later read that *Operator acts as a unifying API to manipulate *Instruction and *ConstantExpr, but is there someplace in the documentation that this relationship is expressed? It's described in llvm::Operator, but not in llvm::Instruction or llvm::ConstantExpr from what I've seen.

I look how other code in LLVM does things.

In this case I was looking for uses of GetElementPtrConstantExpr as I did not believe that no other code in LLVM was expecting the structure of constants. I found non-Constants.cpp uses in GEPOperator, which is used in all of LLVM.

I could not find a non-Doxygen documentation for this.

@etherzhhb:

Maybe functions from llvm/IR/PatternMatch.h can help you to simplify this function

I looked at PatternMatch.h, and I did not find a way to pattern match against GEP instructions. Am I missing it or does the functionality not exist?

I cannot find a matcher for GEP either.

Actually findFortranArrayDescriptorForAllocArrayAccess and findFortranArrayDescriptorForNonAllocArrayAccess do not need to return a std::unique_ptr.

I would prefer to return a unique_ptr with make_unique at the site of the allocation itself since it prevents a whole class of bugs. Could you tell me the rationale for not wishing to
take a unique_ptr as a parameter to MemoryAccess::setFortranArrayDescriptor?

If FortranArrayDescriptor is a type that has to be allocated on the heap (because it is identified by memory location; compared by its address) then I find unique_ptr appropriate. If it is used as a container only ("dumb struct"), then you can also pass-by-value, especially if it has just one member. The bug classes "use-after-free" don't "memory leak" don't even exist for pass-by-value.

With one member only, I don't even see a need to introduce that struct. You can just pass the GlobalValue.

include/polly/ScopInfo.h

437–438

This is not necessary anymore because with NDEBUG not set, the asserts will use the variable.

lib/Analysis/ScopBuilder.cpp

1

There is still a change in the diff.

200

Mmmh, not sure.

Ideally, DraggonEgg would add an annotation saying this is an array (access) so we don't have to rely on name and/or structure and on other compilers not generating the same name/structure for some other purpose. Would that be possible?

If not, let's keep the detection by name.

225–227

The order is confusing to me. Could you consider

///  2. [%slot = getelementptr inbounds i8, i8* %mem, i64 <index>]
///      %slot is optional because if you are writing to the 0th index, we don't need a GEP.

229–230

The implementation does not check for alignment.

252–257

Shorten to

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

?

[bollu]

I hoped to get rid of FortranArrayDescriptor entirely. All the it is used for is getName(). ScopArrayInfo already has a BaseName property that you could use for this purpose.

Ah yes, that's fair. I was considering keeping FortranArrayDescriptor around in case I wish to describe more properties, but for now I suppose I could kill the struct.

I'm writing a patch currently which will use the GlobalValue in the FortranArrayDescriptor. I suppose I could make this a memory of the ScopArrayInfo, and pull it out later on if need be. Does that sound OK?

[Meinersbur]

In D32639#744277, @bollu wrote:

I suppose I could make this a memory of the ScopArrayInfo, and pull it out later on if need be. Does that sound OK?

Yes, sounds great!

[bollu]

• [NFC wrt patch] nuke all references to FortranArayDescriptor struct
• [NFC wrt patch] Make changes suggested by @Meinersbur
• [NFW wrt patch] removed braces for one-line if/else

[bollu]

• Check for alignment of store/load

[grosser]

For some reason your diff contains parts of Philip's changes :(

lib/Analysis/ScopBuilder.cpp

1

Unrelated change.

[bollu]

• [NFC wrt patch] fixing diff of patch to diff against upstream/master

[bollu]

• [NFC wrt patch] reorder comment to make it easier to read
• [NFC wrt patch] add period at comment end

[bollu]

@Meinersbur: I restructured the code as you requested. Could you please take another look?

[Meinersbur]

Accepting, because I don't see more significant code improvements.

However, I have some concerns remaining:

• The detection code is too general. findFortranArrayDescriptorForNonAllocArrayAccess is a load from a global pointer, GEP and an access to it. That is very common code and we will get false positives. The prefix "struct.array" also does not seem to be unique to draggonegg's Fortran-style arrays. At the moment there is no effect of array descriptors, but let me suggest to add a command-line switch that enables detection of these arrays and can be enabled manually when compiling Fortran code (i.e. off by default)
• I still don't know that the Fortran Array Descriptor will be used for, hence I cannot evaluate whether the code is useful at all.

[bollu]

• Add better pattern matching checks for type of fortran array descriptor

[bollu]

lib/Analysis/ScopBuilder.cpp

135

@Meinersbur: I added more rigorous checks to make sure that a Global that we believe to be a fortran array is almost surely one. I would appreciate it if you take a look at it.

I am somewhat against adding a flag, for two reasons:

1. Not being behind a flag allows us to catch false positives for this sort of code, which is valuable

2. Polly already has a lot of options, and I don't want to add to the combinatorial explosion :)

If you think that even these pattern matches are too less, I could actually regex match against the name.

However, I am of the opinion that since this is a structural and a name based match, plus incredibly specific nature of "struct.descriptor_dimension" should make this foolproof.

[Meinersbur]

lib/Analysis/ScopBuilder.cpp

135

There is still nothing unique that only DragonEgg would generate. The name "struct.descriptor_dimension" make false positives less likely, but not I can even craft one using clang:

struct descriptor_dimension {int x,y,z};

clang -emit-llvm -S -o -

%struct.descriptor_dimension = type { i32, i32, i32 }

I wouldn't bet on that no code ever written or will be written in the future does not contain a struct of 3 ints called "descriptor_dimension" or "array1_real".

1. Not being behind a flag allows us to catch false positives for this sort of code, which is valuable

If you want to test for false positves, just use the flag. Being off by default doesn't make it impossible to test your code. I'd rather not use our users as guinea pigs. I'd also prefer not having to tell someone in a bug report that they were using the wrong variable/type name.

Once we compile something different depending on whether a Fortran array is detected, we don't even know whether a miscompilation is caused by a false positve since the only difference you can observe is the miscompilation (no error message or the like). Since there isn't even a flag to switch it off to see whether it works then, I cannot even check whether a false positive was the cause of a miscompilation.

Sorry, I have a rather strong opinion about this.

2. Polly already has a lot of options, and I don't want to add to the combinatorial explosion.

Tobias seems to have no hesitation to add more flags (we already have so many). Most are hidden, i.e. not meant for end users.

Telling the compiler what kind of input we are handling is a perfect reason for a new command line switch.

I can offer the alternative to modify your LLVM+DragonEgg such that it generates a unique flag/attribute/metadata that identifies a Fortran array. DragonEgg is not developed anymore, and you are probably the only one using it with Polly. Since DraggonEgg is in the LLVM repository, you can even upstream it.

[bollu]

I'd rather not use our users as guinea pigs. I'd also prefer not having to tell someone in a bug report that they were using the wrong variable/type name.

I understand. I didn't consider the ramifications of this generating false positives, I'm sorry.

Very well, I'll put this behind a flag for now. If I choose to modify dragonegg such that we will generate no false positives, then we can perhaps remove the flag. I hope that sounds okay?

[Meinersbur]

In D32639#749650, @bollu wrote:

Very well, I'll put this behind a flag for now. If I choose to modify dragonegg such that we will generate no false positives, then we can perhaps remove the flag. I hope that sounds okay?

Yes, this is what I had in mind. Thank you.

[bollu]

• hide fortran array detection behind option that is disabled by default

[bollu]

@Meinersbur: Done, I added an option to hide this behind.

[bollu]

@Meinersbur I would like it if you re-check this in its current state, after which I'll be comfortable upstreaming this. Thanks!

[Meinersbur]

Yes, looks great.

lib/Analysis/ScopBuilder.cpp

39

Capitalization of first latter.

693

If there are only two functions to call, the answer is: no.

include/polly/ScopBuilder.h

class ScopBuilder {
   SmallSetVector<Value *, 16> ArrayBasePointers;
 
   // The Scop
   std::unique_ptr<Scop> scop;
 
   // Build the SCoP for Region @p R.
   void buildScop(Region &R, AssumptionCache &AC);
 
+  /// Try to pattern match and find the array descriptor structure in case of a
+  /// fortran array accesss. succeeds on load/store into a fortran array that
+  /// has been allocated.
+  /// @see fortranarraydescriptor
+  ///
+  /// @param inst the load/store instruction that access the memory
+  ///
+  /// note: assumes -polly-canonicalize has been run
+  std::unique_ptr<FortranArrayDescriptor>
+  findFortranArrayDescriptorForAllocArrayAccess(MemAccInst Inst);
+
+  /// Try to pattern match and find the array descriptor structure in case of a
+  /// fortran array accesss. succeeds on load/store into a fortran array that
+  /// has been allocated.
+  /// @see fortranarraydescriptor
+  ///
+  /// @param inst the load/store instruction that access the memory
+  ///
+  /// note: assumes -polly-canonicalize has been run
+  std::unique_ptr<FortranArrayDescriptor>
+  findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst Inst);
+
   /// Try to build a multi-dimensional fixed sized MemoryAccess from the
   /// Load/Store instruction.
   ///
   /// @param Inst       The Load/Store instruction that access the memory
   /// @param Stmt       The parent statement of the instruction
   ///
   /// @returns True if the access could be built, False otherwise.
   bool buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt);

include/polly/ScopInfo.h

private:
 
   /// The data layout of the module.
   const DataLayout &DL;
 
   /// The scop this SAI object belongs to.
   Scop &S;
 };
 
+/// Hold Fortran Array related information.
+/// Meant to be a dumb struct.
+class FortranArrayDescriptor {
+private:
+  /// Fortran arrays that are created using "Allocate" are stored in terms
+  /// of a descriptor struct. This maintains a raw pointer to the memory,
+  /// along with auxiliary fields with information such as dimensions.
+  /// We hold a reference to the descriptor corresponding to a MemoryAccess
+  /// into a Fortran array
+  AssertingVH<GlobalValue> Descriptor;
+
+  /// The creation of the Descriptor requires a copy to be made from a
+  /// ConstantExpr by using ConstantExpr::getAsInstruction(). This is
+  /// not freed by LLVM, since it is detached from any BB.
+  /// So, maintain a reference to the Instruction that owns the Descriptor.
+  /// We free the Instruction when the FortranArrayDescriptor
+  /// finally goes out of scope.
+  /// @see ScopBuilder::findFortranArrayDescriptor*
+  /// @see ConstantExpr::getAsInstruction
+  /// @see
+  /// https://github.com/llvm-mirror/llvm/blob/93e6e5414ded14bcbb233baaaa5567132fee9a0c/unittests/IR/ConstantsTest.cpp#L186
+  std::unique_ptr<Instruction> DescriptorOwningInstruction;
+
+  FortranArrayDescriptor(const FortranArrayDescriptor &) = delete;
+  const FortranArrayDescriptor &
+  operator=(const FortranArrayDescriptor &) = delete;
+
+public:
+  /// Create a new FortranArrayDescriptor
+  ///
+  /// @param Descriptor Reference to the descriptor value in the IR
+  /// @param DescriptorOwningInstruction The Instruction from which the
+  ///                                    descriptor was taken.
+  FortranArrayDescriptor(
+      GlobalValue *Descriptor,
+      std::unique_ptr<Instruction> &&DescriptorOwningInstruction)
+      : Descriptor(Descriptor),
+        DescriptorOwningInstruction(std::move(DescriptorOwningInstruction)) {
+    assert(Descriptor != nullptr && "given nullptr for Descriptor");
+
+    StructType *ty = dyn_cast<StructType>(Descriptor->getValueType());
+    // Remove warning of unused variable
+    (void)ty;
+
+    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");
+    // TODO: add more checks that this obeys the exact format that dragonegg
+    // generates so that we can be sure that we don't have false positives.
+  };
+
+  /// Return the name of the descriptor value
+  StringRef getName() { return Descriptor->getName(); }
+};
+
 /// Represent memory accesses in statements.
 class MemoryAccess {
   friend class Scop;
   friend class ScopStmt;
 
 public:
   /// The access type of a memory access
   ///
private:
   /// pointer and would algebraically sum up all lower dimensions' indices of
   /// constant size.
   ///
   /// Example:
   ///   float (*A)[4];
   ///   A[1][6] -> A[2][2]
   void wrapConstantDimensions();
 
+  /// If this is a Fortran array, this will contain a descriptor of the
+  /// array. @see FortranArrayDescriptor
+  std::unique_ptr<FortranArrayDescriptor> FAD;
+
 public:
   /// Create a new MemoryAccess.
   ///
   /// @param Stmt       The parent statement.
   /// @param AccessInst The instruction doing the access.
   /// @param BaseAddr   The accessed array's address.
   /// @param ElemType   The type of the accessed array elements.
   /// @param AccType    Whether read or write access.
public:
   /// the name of the accessed array that is derived from the object accessible
   /// via @p AccRel.
   ///
   /// @param Stmt       The parent statement.
   /// @param AccType    Whether read or write access.
   /// @param AccRel     The access relation that describes the memory access.
   MemoryAccess(ScopStmt *Stmt, AccessType AccType, __isl_take isl_map *AccRel);
 
+  /// Set the array descriptor corresponding to the Array on which the
+  /// memory access is performed.
+  ///
+  /// @param FAD Reference to array descriptor
+  void setFortranArrayDescriptor(std::unique_ptr<FortranArrayDescriptor> &&FAD);
+
   ~MemoryAccess();
 
   /// Add a new incoming block/value pairs for this PHI/ExitPHI access.
   ///
   /// @param IncomingBlock The PHI's incoming block.
   /// @param IncomingValue The value when reacing the PHI from the @p
   ///                      IncomingBlock.
   void addIncoming(BasicBlock *IncomingBlock, Value *IncomingValue) {

lib/Analysis/ScopBuilder.cpp

-//===- ScopBuilder.cpp ---------------------------------------------------===//
+//===- ScopBuilder.cpp//---------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

 STATISTIC(InfeasibleScops,
           "Number of SCoPs with statically infeasible context.");
 
 static cl::opt<bool> ModelReadOnlyScalars(
     "polly-analyze-read-only-scalars",
     cl::desc("Model read-only scalar values in the scop description"),
     cl::Hidden, cl::ZeroOrMore, cl::init(true), cl::cat(PollyCategory));
 
 void ScopBuilder::buildPHIAccesses(PHINode *PHI, Region *NonAffineSubRegion,
                                    bool IsExitBlock) {
 
   // PHI nodes that are in the exit block of the region, hence if IsExitBlock is
   // true, are not modeled as ordinary PHI nodes as they are not part of the
   // region. However, we model the operands in the predecessor blocks that are
   // part of the region as regular scalar accesses.
 
   // If we can synthesize a PHI we can skip it, however only if it is in
if (!scop->contains(UseParent) ||
          scop->hasSingleExitEdge())) {
       // At least one escaping use found.
       ensureValueWrite(Inst);
       break;
     }
   }
 }
 
+/// Pattern Match:
+/// 1. %mallocmem = tail call noalias i8* @malloc(i64 40) #1
+///
+/// 5. store i8* %mallocmem, i8** getelementptr inbounds
+/// (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"*
+/// @globalname, i64 0, i32 0), align 32, !tbaa !3
+///
+/// 2. %typedmem = bitcast i8* %mallocmem to <memtype>*
+///
+/// 3 is optional because if you are writing to the 0th index, you don't
+//    need a GEP.
+/// 3. [%slot = getelementptr inbounds i8, i8* %typedmem, i64 <index>]
+///
+/// 4.1 store/load <memtype> <val>, <memtype>* %typedmem, align 8, !tbaa !5
+/// 4.2 store/load <memtype> <val>, <memtype>* %slot, align 8, !tbaa !5
+std::unique_ptr<FortranArrayDescriptor>
+ScopBuilder::findFortranArrayDescriptorForAllocArrayAccess(MemAccInst Inst) {
+  // match: 4.1 & 4.2 store/load
+  if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))
+    return nullptr;
+
+  Value *Address = Inst.getPointerOperand();
+
+  const BitCastInst *Bitcast = nullptr;
+  // [match: 3]
+  if (auto *Slot = dyn_cast<GetElementPtrInst>(Address)) {
+    Value *TypedMem = Slot->getPointerOperand();
+    // match: 2
+    Bitcast = dyn_cast<BitCastInst>(TypedMem);
+  } else {
+    // match: 2
+    Bitcast = dyn_cast<BitCastInst>(Address);
+  }
+
+  if (!Bitcast)
+    return nullptr;
+
+  auto *MallocMem = Bitcast->getOperand(0);
+
+  // match: 1
+  auto *MallocCall = dyn_cast<CallInst>(MallocMem);
+  if (!MallocCall)
+    return nullptr;
+
+  Function *MallocFn = MallocCall->getCalledFunction();
+  if (!(MallocFn && MallocFn->hasName() && MallocFn->getName() == "malloc"))
+    return nullptr;
+
+  // Find all uses the malloc'd memory.
+  // We are looking for a "store" into a struct with the type being the Fortran
+  // descriptor type
+  for (auto user : MallocMem->users()) {
+
+    /// match: 5
+    auto *MallocStore = dyn_cast<StoreInst>(user);
+    if (!MallocStore)
+      continue;
+
+    auto *DescriptorGEP =
+        dyn_cast<ConstantExpr>(MallocStore->getPointerOperand());
+    if (!DescriptorGEP)
+      continue;
+
+    // this needs to be deleted, on the basis of:
+    // https://github.com/llvm-mirror/llvm/blob/93e6e5414ded14bcbb233baaaa5567132fee9a0c/unittests/IR/ConstantsTest.cpp#L186
+    std::unique_ptr<Instruction> DescriptorGEPRawInst(
+        DescriptorGEP->getAsInstruction());
+
+    // We want an instruction and not a ConstantExpr since this should
+    // give us more flexibility to inspect the GEP.
+    auto *DescriptorGEPInst =
+        dyn_cast<GetElementPtrInst>(DescriptorGEPRawInst.get());
+
+    if (!(DescriptorGEPInst && DescriptorGEPInst->hasAllConstantIndices())) {
+      continue;
+    }
+
+    // match: 5
+    auto DescriptorType =
+        dyn_cast<StructType>(DescriptorGEPInst->getSourceElementType());
+    if (!(DescriptorType && DescriptorType->hasName())) {
+      continue;
+    }
+
+    // name does not match expected name
+    if (!DescriptorType->getName().startswith("struct.array")) {
+      continue;
+    }
+    GlobalValue *Descriptor =
+        dyn_cast<GlobalValue>(DescriptorGEPInst->getPointerOperand());
+
+    if (!Descriptor) {
+      continue;
+    }
+    return make_unique<FortranArrayDescriptor>(Descriptor,
+                                               std::move(DescriptorGEPRawInst));
+  }
+
+  return nullptr;
+}
+
+/// Pattern Match:
+///  1. %3 = load double*, double** bitcast (%"struct.array1_real(kind=8)"*
+///    @__src_soil_MOD_xdzs to double**), align 32, !tbaa !5
+///
+///  2 is optional because if you are writing to the 0th index, you don't
+///     need a GEP.
+///  2. [%slot = getelementptr inbounds i8, i8* %mem, i64 <index>]
+///
+///  3.1 store/load <memtype> <val>, <memtype>* %slot, align 8, !tbaa !5
+///  3.2 store/load <memtype> <val>, <memtype>* %mem, align 8, !tbaa !5
+std::unique_ptr<FortranArrayDescriptor>
+ScopBuilder::findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst Inst) {
+  // match: 3
+  if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst)) {
+    return nullptr;
+  }
+  Value *Slot = Inst.getPointerOperand();
+
+  LoadInst *MemLoad = nullptr;
+  // [match: 2]
+  if (auto *SlotGEP = dyn_cast<GetElementPtrInst>(Slot)) {
+    // match: 1
+    MemLoad = dyn_cast<LoadInst>(SlotGEP->getPointerOperand());
+  } else {
+    // match: 1
+    MemLoad = dyn_cast<LoadInst>(Slot);
+  }
+
+  if (!MemLoad)
+    return nullptr;
+
+  auto *BitcastConstantExpr =
+      dyn_cast<ConstantExpr>(MemLoad->getPointerOperand());
+  if (!BitcastConstantExpr)
+    return nullptr;
+  std::unique_ptr<Instruction> BitcastInstruction(
+      BitcastConstantExpr->getAsInstruction());
+
+  GlobalValue *ArrayDescriptor =
+      dyn_cast<GlobalValue>(BitcastInstruction->getOperand(0));
+  if (!ArrayDescriptor)
+    return nullptr;
+
+  return make_unique<FortranArrayDescriptor>(ArrayDescriptor,
+                                             std::move(BitcastInstruction));
+};
+
 bool ScopBuilder::buildAccessMultiDimFixed(MemAccInst Inst, ScopStmt *Stmt) {
   Value *Val = Inst.getValueOperand();
   Type *ElementType = Val->getType();
   Value *Address = Inst.getPointerOperand();
   const SCEV *AccessFunction =
       SE.getSCEVAtScope(Address, LI.getLoopFor(Inst->getParent()));
   const SCEVUnknown *BasePointer =
       dyn_cast<SCEVUnknown>(SE.getPointerBase(AccessFunction));
   enum MemoryAccess::AccessType AccType =
       isa<LoadInst>(Inst) ? MemoryAccess::READ : MemoryAccess::MUST_WRITE;
 
   if (auto *BitCast = dyn_cast<BitCastInst>(Address)) {
     auto *Src = BitCast->getOperand(0);
     auto *SrcTy = Src->getType();
     auto *DstTy = BitCast->getType();
     // Do not try to delinearize non-sized (opaque) pointers.
     if ((SrcTy->isPointerTy() && !SrcTy->getPointerElementType()->isSized()) ||
         (DstTy->isPointerTy() && !DstTy->getPointerElementType()->isSized())) {
       return false;
     }
     if (SrcTy->isPointerTy() && DstTy->isPointerTy() &&
         DL.getTypeAllocSize(SrcTy->getPointerElementType()) ==
             DL.getTypeAllocSize(DstTy->getPointerElementType()))
MemoryAccess *ScopBuilder::addMemoryAccess(
   return Access;
 }
 
 void ScopBuilder::addArrayAccess(
     MemAccInst MemAccInst, MemoryAccess::AccessType AccType, Value *BaseAddress,
     Type *ElementType, bool IsAffine, ArrayRef<const SCEV *> Subscripts,
     ArrayRef<const SCEV *> Sizes, Value *AccessValue) {
   ArrayBasePointers.insert(BaseAddress);
-  addMemoryAccess(MemAccInst->getParent(), MemAccInst, AccType, BaseAddress,
-                  ElementType, IsAffine, AccessValue, Subscripts, Sizes,
-                  MemoryKind::Array);
+  auto *MemAccess = addMemoryAccess(
+      MemAccInst->getParent(), MemAccInst, AccType, BaseAddress, ElementType,
+      IsAffine, AccessValue, Subscripts, Sizes, MemoryKind::Array);
+
+  // TODO: change to loop of function pointers?
+  if (std::unique_ptr<FortranArrayDescriptor> FAD =
+          findFortranArrayDescriptorForAllocArrayAccess(MemAccInst)) {
+    MemAccess->setFortranArrayDescriptor(std::move(FAD));
+  } else if (std::unique_ptr<FortranArrayDescriptor> FAD =
+                 findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst)) {
+    MemAccess->setFortranArrayDescriptor(std::move(FAD));
+  }
 }
 
 void ScopBuilder::ensureValueWrite(Instruction *Inst) {
   ScopStmt *Stmt = scop->getStmtFor(Inst);
 
   // Inst not defined within this SCoP.
   if (!Stmt)
     return;

lib/Analysis/ScopInfo.cpp

MemoryAccess::MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst,
                            ArrayRef<const SCEV *> Subscripts,
                            ArrayRef<const SCEV *> Sizes, Value *AccessValue,
                            MemoryKind Kind, StringRef BaseName)
     : Kind(Kind), AccType(AccType), RedType(RT_NONE), Statement(Stmt),
       InvalidDomain(nullptr), BaseAddr(BaseAddress), BaseName(BaseName),
       ElementType(ElementType), Sizes(Sizes.begin(), Sizes.end()),
       AccessInstruction(AccessInst), AccessValue(AccessValue), IsAffine(Affine),
       Subscripts(Subscripts.begin(), Subscripts.end()), AccessRelation(nullptr),
-      NewAccessRelation(nullptr) {
+      NewAccessRelation(nullptr), FAD(nullptr) {
   static const std::string TypeStrings[] = {"", "_Read", "_Write", "_MayWrite"};
   const std::string Access = TypeStrings[AccType] + utostr(Stmt->size()) + "_";
 
   std::string IdName =
       getIslCompatibleName(Stmt->getBaseName(), Access, BaseName);
   Id = isl_id_alloc(Stmt->getParent()->getIslCtx(), IdName.c_str(), this);
 }
 
 MemoryAccess::MemoryAccess(ScopStmt *Stmt, AccessType AccType,
                            __isl_take isl_map *AccRel)
     : Kind(MemoryKind::Array), AccType(AccType), RedType(RT_NONE),
       Statement(Stmt), InvalidDomain(nullptr), AccessInstruction(nullptr),
-      IsAffine(true), AccessRelation(nullptr), NewAccessRelation(AccRel) {
+      IsAffine(true), AccessRelation(nullptr), NewAccessRelation(AccRel),
+      FAD(nullptr) {
   auto *ArrayInfoId = isl_map_get_tuple_id(NewAccessRelation, isl_dim_out);
   auto *SAI = ScopArrayInfo::getFromId(ArrayInfoId);
   Sizes.push_back(nullptr);
   for (unsigned i = 1; i < SAI->getNumberOfDimensions(); i++)
     Sizes.push_back(SAI->getDimensionSize(i));
   ElementType = SAI->getElementType();
   BaseAddr = SAI->getBasePtr();
   BaseName = SAI->getName();
raw_ostream &polly::operator<<(raw_ostream &OS,
                                MemoryAccess::ReductionType RT) {
   if (RT == MemoryAccess::RT_NONE)
     OS << "NONE";
   else
     OS << MemoryAccess::getReductionOperatorStr(RT);
   return OS;
 }
 
+void MemoryAccess::setFortranArrayDescriptor(
+    std::unique_ptr<FortranArrayDescriptor> &&FAD) {
+  this->FAD = std::move(FAD);
+
+  // TODO: write checks to make sure it looks _exactly_ like a Fortran array
+  // descriptor
+};
+
 void MemoryAccess::print(raw_ostream &OS) const {
   switch (AccType) {
   case READ:
     OS.indent(12) << "ReadAccess :=\t";
     break;
   case MUST_WRITE:
     OS.indent(12) << "MustWriteAccess :=\t";
     break;
   case MAY_WRITE:
     OS.indent(12) << "MayWriteAccess :=\t";
     break;
   }
+
   OS << "[Reduction Type: " << getReductionType() << "] ";
+
+  if (FAD) {
+    OS << "[Fortran array descriptor: " << FAD->getName();
+    OS << "] ";
+  };
+
   OS << "[Scalar: " << isScalarKind() << "]\n";
   OS.indent(16) << getOriginalAccessRelationStr() << ";\n";
   if (hasNewAccessRelation())
     OS.indent(11) << "new: " << getNewAccessRelationStr() << ";\n";
 }
 
 void MemoryAccess::dump() const { print(errs()); }
 

test/FortranDetection/global-malloc-nonvectored.ll

+; RUN: opt -S  -analyze -polly-process-unprofitable  -polly-remarks-minimal \
+; RUN: -polly-canonicalize -polly-scops -polly-dependences \
+; RUN: -debug-only=polly-dependence -polly-canonicalize -polly-allow-nonaffine \
+; RUN: -polly-ignore-aliasing   -polly-invariant-load-hoisting \
+; RUN: < %s| FileCheck %s
+;
+; MODULE src_soil
+; USE data_parameters, ONLY :   &
+;     wp,        & ! KIND-type parameter for real variables
+;     iintegers    ! KIND-type parameter for standard integer variables
+; IMPLICIT NONE
+; REAL (KIND = wp),     ALLOCATABLE, PRIVATE  :: &
+;   xdzs     (:)
+; CONTAINS
+; SUBROUTINE terra1(n)
+;   INTEGER, intent(in) :: n
+;   INTEGER (KIND=iintegers) ::  &
+;     j
+;   Allocate(xdzs(n));
+;    DO j = 2, n
+;         xdzs(j) = xdzs(j) * xdzs(j) + xdzs(j - 1)
+;   END DO
+; END SUBROUTINE terra1
+; END MODULE src_soil
+
+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_real(kind=8)" = type { i8*, i64, i64, [1 x %struct.descriptor_dimension] }
+%struct.descriptor_dimension = type { i64, i64, i64 }
+
+@__src_soil_MOD_xdzs = unnamed_addr global %"struct.array1_real(kind=8)" zeroinitializer, align 32
+@.cst = private unnamed_addr constant [67 x i8] c"Integer overflow when calculating the amount of memory to allocate\00", align 64
+@.cst1 = private unnamed_addr constant [37 x i8] c"Allocation would exceed memory limit\00", align 64
+@.cst2 = private unnamed_addr constant [93 x i8] c"At line 23 of file /home/siddhart/cosmo-self-installation/cosmo-pompa/cosmo/src/src_soil.f90\00", align 64
+@.cst3 = private unnamed_addr constant [55 x i8] c"Attempting to allocate already allocated variable '%s'\00", align 64
+@.cst4 = private unnamed_addr constant [5 x i8] c"xdzs\00", align 8
+
+; Function Attrs: nounwind uwtable
+define void @__src_soil_MOD_terra1(i32* noalias nocapture %n) unnamed_addr #0 {
+entry:
+  store i64 537, i64* getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 2), align 16, !tbaa !0
+  store i64 1, i64* getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 3, i64 0, i32 1), align 8, !tbaa !0
+  %0 = load i32, i32* %n, align 4, !tbaa !3
+  %1 = sext i32 %0 to i64
+  store i64 %1, i64* getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 3, i64 0, i32 2), align 8, !tbaa !0
+  store i64 1, i64* getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 3, i64 0, i32 0), align 8, !tbaa !0
+  %2 = icmp slt i32 %0, 0
+  %3 = select i1 %2, i64 0, i64 %1
+  %4 = icmp eq i64 %3, 0
+  br i1 %4, label %"16", label %"8"
+
+"8":                                              ; preds = %entry
+  %5 = sdiv i64 9223372036854775807, %1
+  %6 = icmp slt i64 %5, 1
+  %7 = icmp slt i32 %0, 1
+  %8 = shl nsw i64 %3, 3
+  %.2 = select i1 %7, i64 0, i64 %8
+  br i1 %6, label %"15", label %"16"
+
+"15":                                             ; preds = %"8"
+
+  unreachable
+
+"16":                                             ; preds = %"8", %entry
+  %.24 = phi i64 [ %.2, %"8" ], [ 0, %entry ]
+  %9 = load i8*, i8** getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 0), align 32, !tbaa !5
+  %10 = icmp eq i8* %9, null
+  br i1 %10, label %"17", label %"20"
+
+"17":                                             ; preds = %"16"
+  %11 = icmp ne i64 %.24, 0
+  %12 = select i1 %11, i64 %.24, i64 1
+  %13 = tail call noalias i8* @malloc(i64 %12) #2 ;<= 1. malloc
+  %14 = icmp eq i8* %13, null
+  br i1 %14, label %"18", label %"19"
+
+"18":                                             ; preds = %"17"
+  unreachable
+
+"19":                                             ; preds = %"17"
+  store i8* %13, i8** getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 0), align 32, !tbaa !5
+  store i64 -1, i64* getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 1), align 8, !tbaa !0
+  %15 = icmp sgt i32 %0, 1
+  br i1 %15, label %"21.preheader", label %return
+
+"21.preheader":                                   ; preds = %"19"
+  %16 = bitcast i8* %13 to double* ;<= 2. bitcast to double*
+  %17 = add i32 %0, 1
+  br label %"21"
+
+"20":                                             ; preds = %"16"
+  unreachable
+
+"21":                                             ; preds = %"21", %"21.preheader"
+  %18 = phi double [ undef, %"21.preheader" ], [ %23, %"21" ]
+  %indvars.iv = phi i64 [ 2, %"21.preheader" ], [ %indvars.iv.next, %"21" ]
+  %19 = add nsw i64 %indvars.iv, -1
+  %20 = getelementptr inbounds double, double* %16, i64 %19 ;<= 3. GEP
+  %21 = load double, double* %20, align 8, !tbaa !7
+  %22 = fmul double %21, %21
+  %23 = fadd double %22, %18
+  store double %23, double* %20, align 8, !tbaa !7 ;<= 4. store
+  %indvars.iv.next = add i64 %indvars.iv, 1
+  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
+  %exitcond = icmp eq i32 %lftr.wideiv, %17
+  br i1 %exitcond, label %return, label %"21"
+
+return:                                           ; preds = %"21", %"19"
+  ret void
+}
+
+; Function Attrs: noreturn
+declare void @_gfortran_runtime_error(i8*, ...) #1
+
+; Function Attrs: nounwind
+declare noalias i8* @malloc(i64) #2
+
+; Function Attrs: noreturn
+declare void @_gfortran_os_error(i8*) #1
+
+; Function Attrs: noreturn
+declare void @_gfortran_runtime_error_at(i8*, i8*, ...) #1
+
+attributes #0 = { nounwind uwtable }
+attributes #1 = { noreturn }
+attributes #2 = { nounwind }
+attributes #3 = { noreturn nounwind }
+
+!0 = !{!1, !1, i64 0}
+!1 = !{!"alias set 4: integer(kind=8)", !2}
+!2 = distinct !{!2}
+!3 = !{!4, !4, i64 0}
+!4 = !{!"alias set 11: integer(kind=4)", !2}
+!5 = !{!6, !6, i64 0}
+!6 = !{!"alias set 3: void*", !2}
+!7 = !{!8, !8, i64 0}
+!8 = !{!"alias set 18: real(kind=8)", !2}
+
+; CHECK: ReadAccess :=  [Reduction Type: NONE] [Fortran array descriptor: __src_soil_MOD_xdzs] [Scalar: 0]
+; CHECK: MustWriteAccess := [Reduction Type: NONE] [Fortran array descriptor: __src_soil_MOD_xdzs] [Scalar: 0]

test/FortranDetection/global-nonmalloc-nonvectored.ll

+; RUN: opt -S  -analyze -polly-process-unprofitable  -polly-remarks-minimal \
+; RUN: -polly-canonicalize -polly-scops -polly-dependences \
+; RUN: -debug-only=polly-dependence -polly-canonicalize -polly-allow-nonaffine \
+; RUN: -polly-ignore-aliasing   -polly-invariant-load-hoisting \
+; RUN: < %s| FileCheck %s
+;
+; MODULE src_soil
+; USE data_parameters, ONLY :   &
+;     wp,        & ! KIND-type parameter for real variables
+;     iintegers    ! KIND-type parameter for standard integer variables
+; IMPLICIT NONE
+; REAL (KIND = wp),     ALLOCATABLE, PRIVATE  :: &
+;   xdzs     (:)
+; CONTAINS
+;
+; SUBROUTINE terra1(n)
+;   INTEGER, intent(in) :: n
+;
+;   INTEGER (KIND=iintegers) ::  &
+;     j
+;
+;    DO j = 22, n
+;         xdzs(j) = xdzs(j) * xdzs(j) + xdzs(j - 1)
+;   END DO
+; END SUBROUTINE terra1
+; END MODULE src_soil
+
+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_real(kind=8)" = type { i8*, i64, i64, [1 x %struct.descriptor_dimension] }
+%struct.descriptor_dimension = type { i64, i64, i64 }
+
+@__src_soil_MOD_xdzs = unnamed_addr global %"struct.array1_real(kind=8)" zeroinitializer, align 32
+
+; Function Attrs: nounwind uwtable
+define void @__src_soil_MOD_terra1(i32* noalias nocapture %n) unnamed_addr #0 {
+entry:
+  %0 = load i32, i32* %n, align 4, !tbaa !0
+  %1 = icmp sgt i32 %0, 21
+  br i1 %1, label %"3.preheader", label %return
+
+"3.preheader":                                    ; preds = %entry
+  %2 = load i64, i64* getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 1), align 8, !tbaa !3
+  %3 = load i8*, i8** getelementptr inbounds (%"struct.array1_real(kind=8)", %"struct.array1_real(kind=8)"* @__src_soil_MOD_xdzs, i64 0, i32 0), align 32, !tbaa !5
+  %4 = bitcast i8* %3 to double*
+  %5 = add i32 %0, 1
+  br label %"3"
+
+"3":                                              ; preds = %"3", %"3.preheader"
+  %indvars.iv = phi i64 [ 22, %"3.preheader" ], [ %indvars.iv.next, %"3" ]
+  %6 = add nsw i64 %indvars.iv, %2
+  %7 = getelementptr inbounds double, double* %4, i64 %6
+  %8 = load double, double* %7, align 8, !tbaa !7
+  %9 = fmul double %8, %8
+  %10 = add nsw i64 %indvars.iv, -1
+  %11 = add nsw i64 %10, %2
+  %12 = getelementptr inbounds double, double* %4, i64 %11
+  %13 = load double, double* %12, align 8, !tbaa !7
+  %14 = fadd double %9, %13
+  store double %14, double* %7, align 8, !tbaa !7
+  %indvars.iv.next = add i64 %indvars.iv, 1
+  %lftr.wideiv = trunc i64 %indvars.iv.next to i32
+  %exitcond = icmp eq i32 %lftr.wideiv, %5
+  br i1 %exitcond, label %return, label %"3"
+
+return:                                           ; preds = %"3", %entry
+  ret void
+}
+
+attributes #0 = { nounwind uwtable }
+
+!0 = !{!1, !1, i64 0}
+!1 = !{!"alias set 11: integer(kind=4)", !2}
+!2 = distinct !{!2}
+!3 = !{!4, !4, i64 0}
+!4 = !{!"alias set 4: integer(kind=8)", !2}
+!5 = !{!6, !6, i64 0}
+!6 = !{!"alias set 3: void*", !2}
+!7 = !{!8, !8, i64 0}
+!8 = !{!"alias set 18: real(kind=8)", !2}
+
+; CHECK: ReadAccess :=  [Reduction Type: NONE] [Fortran array descriptor: __src_soil_MOD_xdzs] [Scalar: 0]
+; CHECK: ReadAccess :=  [Reduction Type: NONE] [Fortran array descriptor: __src_soil_MOD_xdzs] [Scalar: 0]
+; CHECK: MustWriteAccess := [Reduction Type: NONE] [Fortran array descriptor: __src_soil_MOD_xdzs] [Scalar: 0]