[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 ↗

(On Diff #97066)

Please use proper capitalization: @see polly::FortranArrayDescriptor

65 ↗

(On Diff #97066)

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

include/polly/ScopInfo.h

413 ↗

(On Diff #97066)

"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 ↗

(On Diff #97066)

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

452 ↗

(On Diff #97066)

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

468 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

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

742 ↗

(On Diff #97066)

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

lib/Analysis/ScopBuilder.cpp

1 ↗

(On Diff #97066)

Mistake?

116–129 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

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

200 ↗

(On Diff #97066)

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

251–252 ↗

(On Diff #97066)

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

lib/Analysis/ScopInfo.cpp

1022 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

Thanks for the catch, will fix.

include/polly/ScopInfo.h

413 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

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 ↗

(On Diff #97066)

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

277 ↗

(On Diff #97106)

The ; is unnecessary

180–181 ↗

(On Diff #97066)

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;

[etherzhhb]

lib/Analysis/ScopBuilder.cpp

139 ↗

(On Diff #97106)

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

707–713 ↗

(On Diff #97106)

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 ↗

(On Diff #97405)

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

lib/Analysis/ScopBuilder.cpp

225–227 ↗

(On Diff #97405)

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 ↗

(On Diff #97405)

The implementation does not check for alignment.

252–257 ↗

(On Diff #97405)

Shorten to

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

?

1 ↗

(On Diff #97066)

There is still a change in the diff.

200 ↗

(On Diff #97066)

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.

[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 ↗

(On Diff #97066)

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

141 ↗

(On Diff #98164)

@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

141 ↗

(On Diff #98164)

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

45 ↗

(On Diff #98289)

Capitalization of first latter.

777 ↗

(On Diff #98289)

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

polly/trunk/include/polly/ScopBuilder.h

class ScopBuilder {
   SmallVector<Instruction *, 16> GlobalReads;
 
   /// Set of all accessed array base pointers.
   SmallSetVector<Value *, 16> ArrayBasePointers;
 
   // The Scop
   std::unique_ptr<Scop> scop;
 
+  // Methods for pattern matching against Fortran code generated by dragonegg.
+  // @{
+
+  /// 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 polly::FortranArrayDescriptor
+  ///
+  /// @param Inst The load/store instruction that access the memory.
+  ///
+  /// @note assumes -polly-canonicalize has been run.
+  GlobalValue *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 polly::FortranArrayDescriptor
+  ///
+  /// @param Inst The load/store instruction that access the memory.
+  ///
+  /// @note assumes -polly-canonicalize has been run.
+  GlobalValue *
+  findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst Inst);
+  // @}
+
   // Build the SCoP for Region @p R.
   void buildScop(Region &R, AssumptionCache &AC);
 
   /// 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

polly/trunk/include/polly/ScopInfo.h

private:
   ///      for i
   ///    S:     A[i] = *((double*)&A[4 * i]);
   ///
   ///    => { S[i] -> A[i]; S[i] -> A[o] : 4i <= o <= 4i + 3 }
   isl_map *AccessRelation;
 
   /// Updated access relation read from JSCOP file.
   isl_map *NewAccessRelation;
+
+  /// 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. FAD for "Fortran Array Descriptor"
+  AssertingVH<GlobalValue> FAD;
   // @}
 
   __isl_give isl_basic_map *createBasicAccessMap(ScopStmt *Statement);
 
   void assumeNoOutOfBound();
 
   /// Compute bounds on an over approximated  access relation.
   ///
public:
   bool isAnyPHIKind() const { return isOriginalAnyPHIKind(); }
 
   /// Get the statement that contains this memory access.
   ScopStmt *getStatement() const { return Statement; }
 
   /// Get the reduction type of this access
   ReductionType getReductionType() const { return RedType; }
 
+  /// Set the array descriptor corresponding to the Array on which the
+  /// memory access is performed.
+  void setFortranArrayDescriptor(GlobalValue *FAD);
+
   /// Update the original access relation.
   ///
   /// We need to update the original access relation during scop construction,
   /// when unifying the memory accesses that access the same scop array info
   /// object. After the scop has been constructed, the original access relation
   /// should not be changed any more. Instead setNewAccessRelation should
   /// be called.
   void setAccessRelation(__isl_take isl_map *AccessRelation);

polly/trunk/lib/Analysis/ScopBuilder.cpp

static cl::opt<bool> ModelReadOnlyScalars(
     cl::desc("Model read-only scalar values in the scop description"),
     cl::Hidden, cl::ZeroOrMore, cl::init(true), cl::cat(PollyCategory));
 
 static cl::opt<bool> UnprofitableScalarAccs(
     "polly-unprofitable-scalar-accs",
     cl::desc("Count statements with scalar accesses as not optimizable"),
     cl::Hidden, cl::init(false), cl::cat(PollyCategory));
 
+static cl::opt<bool> DetectFortranArrays(
+    "polly-detect-fortran-arrays",
+    cl::desc("Detect Fortran arrays and use this for code generation"),
+    cl::Hidden, cl::init(false), 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 (!scop->contains(UseParent) ||
          scop->hasSingleExitEdge())) {
       // At least one escaping use found.
       ensureValueWrite(Inst);
       break;
     }
   }
 }
 
+/// Check that a global variable has a type resembling:
+/// %"struct.array1_real(kind=8)" = type { i8*, i<zz>, i<zz>,
+///                                   [<num> x %struct.descriptor_dimension] }
+///
+///
+/// %struct.descriptor_dimension = type { i<zz>, i<zz>, i<zz> }
+///
+/// @global = unnamed_addr global %"struct.array1_real(kind=8)"
+///
+/// This function checks that:
+/// 1. Global has a type name starting with "struct.array"
+/// 2. Global type has layout as shown
+/// 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
+/// generates for Fortran arrays.
+///
+/// @param Global the global variable believed to be a Fortran array
+bool isGlobalFortranArray(GlobalValue *Global) {
+  auto StructArrTy = dyn_cast<StructType>(Global->getValueType());
+
+  if (!(StructArrTy && StructArrTy->hasName()))
+    return false;
+
+  if (!StructArrTy->getName().startswith("struct.array"))
+    return false;
+
+  if (StructArrTy->getNumElements() != 4)
+    return false;
+
+  const ArrayRef<Type *> ArrMemberTys = StructArrTy->elements();
+
+  // i8* match
+  if (ArrMemberTys[0] != Type::getInt8PtrTy(Global->getContext()))
+    return false;
+
+  // Get a reference to the int type and check that all the members
+  // share the same int type
+  Type *IntTy = ArrMemberTys[1];
+  if (ArrMemberTys[2] != IntTy)
+    return false;
+
+  // type: [<num> x %struct.descriptor_dimension]
+  ArrayType *DescriptorDimArrayTy = dyn_cast<ArrayType>(ArrMemberTys[3]);
+  if (!DescriptorDimArrayTy)
+    return false;
+
+  // type: %struct.descriptor_dimension := type { ixx, ixx, ixx }
+  StructType *DescriptorDimTy =
+      dyn_cast<StructType>(DescriptorDimArrayTy->getElementType());
+
+  if (!(DescriptorDimTy && DescriptorDimTy->hasName()))
+    return false;
+
+  if (DescriptorDimTy->getName() != "struct.descriptor_dimension")
+    return false;
+
+  if (DescriptorDimTy->getNumElements() != 3)
+    return false;
+
+  for (auto MemberTy : DescriptorDimTy->elements()) {
+    if (MemberTy != IntTy)
+      return false;
+  }
+
+  return true;
+}
+
+/// This is matching against code generated by dragonegg after simplifier
+/// 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
+  if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))
+    return nullptr;
+
+  // match: 4
+  if (Inst.getAlignment() != 8)
+    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<GEPOperator>(MallocStore->getPointerOperand());
+    if (!DescriptorGEP)
+      continue;
+
+    // match: 5
+    auto DescriptorType =
+        dyn_cast<StructType>(DescriptorGEP->getSourceElementType());
+    if (!(DescriptorType && DescriptorType->hasName()))
+      continue;
+
+    GlobalValue *Descriptor =
+        dyn_cast<GlobalValue>(DescriptorGEP->getPointerOperand());
+
+    if (!Descriptor)
+      continue;
+
+    if (!isGlobalFortranArray(Descriptor))
+      continue;
+
+    return Descriptor;
+  }
+
+  return nullptr;
+}
+
+/// This is matching against code generated by dragonegg after simplifier
+/// 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
+  if (!isa<LoadInst>(Inst) && !isa<StoreInst>(Inst))
+    return nullptr;
+
+  // match: 3
+  if (Inst.getAlignment() != 8)
+    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 *BitcastOperator =
+      dyn_cast<BitCastOperator>(MemLoad->getPointerOperand());
+  if (!BitcastOperator)
+    return nullptr;
+
+  GlobalValue *Descriptor =
+      dyn_cast<GlobalValue>(BitcastOperator->getOperand(0));
+  if (!Descriptor)
+    return nullptr;
+
+  if (!isGlobalFortranArray(Descriptor))
+    return nullptr;
+
+  return Descriptor;
+}
+
 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));
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);
+
+  if (!DetectFortranArrays)
+    return;
+
+  if (GlobalValue *FAD =
+          findFortranArrayDescriptorForAllocArrayAccess(MemAccInst))
+    MemAccess->setFortranArrayDescriptor(FAD);
+  else if (GlobalValue *FAD =
+               findFortranArrayDescriptorForNonAllocArrayAccess(MemAccInst))
+    MemAccess->setFortranArrayDescriptor(FAD);
 }
 
 void ScopBuilder::ensureValueWrite(Instruction *Inst) {
   ScopStmt *Stmt = scop->getStmtFor(Inst);
 
   // Inst not defined within this SCoP.
   if (!Stmt)
     return;

polly/trunk/lib/Analysis/ScopInfo.cpp

MemoryAccess::MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst,
                            ArrayRef<const SCEV *> Subscripts,
                            ArrayRef<const SCEV *> Sizes, Value *AccessValue,
                            MemoryKind Kind)
     : Kind(Kind), AccType(AccType), RedType(RT_NONE), Statement(Stmt),
       InvalidDomain(nullptr), BaseAddr(BaseAddress), 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 = Stmt->getBaseName() + Access;
   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();
   static const std::string TypeStrings[] = {"", "_Read", "_Write", "_MayWrite"};
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(GlobalValue *FAD) {
+  this->FAD = FAD;
+
+// TODO: write checks to make sure it looks _exactly_ like a Fortran array
+// descriptor
+#ifdef NDEBUG
+  StructType *ty = dyn_cast<StructType>(Descriptor->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 {
   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()); }
 

polly/trunk/test/FortranDetection/global-malloc-nonvectored.ll

+; RUN: opt -S -polly-detect-fortran-arrays -analyze -polly-process-unprofitable \
+; RUN: -polly-remarks-minimal -polly-canonicalize -polly-scops \
+; RUN: -polly-dependences -debug-only=polly-dependence -polly-canonicalize \
+; RUN: -polly-allow-nonaffine -polly-ignore-aliasing \
+; RUN: -polly-invariant-load-hoisting < %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]

polly/trunk/test/FortranDetection/global-nonmalloc-nonvectored.ll

+; RUN: opt -S -polly-detect-fortran-arrays -analyze -polly-process-unprofitable \
+; RUN: -polly-remarks-minimal -polly-canonicalize -polly-scops \
+; RUN: -polly-dependences -debug-only=polly-dependence -polly-canonicalize \
+; RUN: -polly-allow-nonaffine -polly-ignore-aliasing \
+; RUN: -polly-invariant-load-hoisting < %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]