LLVM Tutorial 1: A First Function

- - - - Owen Anderson - The LLVM Compiler Infrastructure - Last modified: $Date: 2009-07-21 11:05:13 -0700 (Tue, 21 Jul 2009) $ - · ;; Evaluate expression on line 2, assigning to X.

-  void %llvm.dbg.stoppoint( uint, uint, metadata)
-
%llvm.dbg.compile_unit
%lvm.dbg.stoppoint
-  void %llvm.dbg.func.start( metadata )
-
%llvm.dbg.subprogram
llvm.dbg.stoppoint
%llvm.dbg.region.end
%llvm.dbg.subprogram.type
-  void %llvm.dbg.region.start( metadata )
-
%llvm.dbg.region.end
%llvm.dbg.block
-  void %llvm.dbg.region.end( metadata )
-
%llvm.dbg.region.start
%llvm.dbg.func.start
%llvm.dbg.block
%llvm.dbg.subprogram.type
llvm.dbg.stoppoint
step
 1.  void foo() {
-2.    int X = ...;
-3.    int Y = ...;
+2.    int X = 21;
+3.    int Y = 22;
 4.    {
-5.      int Z = ...;
-6.      ...
+5.      int Z = 23;
+6.      Z = X;
 7.    }
-8.    ...
+8.    X = Y;
 9.  }
 
-void %foo() {
+nounwind ssp {
 entry:
-    %X = alloca int
-    %Y = alloca int
-    %Z = alloca int
-    
-    ...
-    
-    call void @llvm.dbg.func.start( metadata !0)
-    
-    call void @llvm.dbg.stoppoint( uint 2, uint 2, metadata !1)
-    
-    call void @llvm.dbg.declare({}* %X, ...)
-    call void @llvm.dbg.declare({}* %Y, ...)
-    
-    ;; Evaluate expression on line 2, assigning to X.
-    
-    call void @llvm.dbg.stoppoint( uint 3, uint 2, metadata !1)
-    
-    ;; Evaluate expression on line 3, assigning to Y.
-    
-    call void @llvm.region.start()
-    call void @llvm.dbg.stoppoint( uint 5, uint 4, metadata !1)
-    call void @llvm.dbg.declare({}* %X, ...)
-    
-    ;; Evaluate expression on line 5, assigning to Z.
-    
-    call void @llvm.dbg.stoppoint( uint 7, uint 2, metadata !1)
-    call void @llvm.region.end()
-    
-    call void @llvm.dbg.stoppoint( uint 9, uint 2, metadata !1)
-    
-    call void @llvm.region.end()
-    
-    ret void
-}
+  %X = alloca i32, align 4                        ;  [#uses=4]
+  %Y = alloca i32, align 4                        ;  [#uses=4]
+  %Z = alloca i32, align 4                        ;  [#uses=3]
+  %0 = bitcast i32* %X to { }*                    ; <{ }*> [#uses=1]
+  call void @llvm.dbg.declare({ }* %0, metadata !0), !dbg !7
+  store i32 21, i32* %X, !dbg !8
+  %1 = bitcast i32* %Y to { }*                    ; <{ }*> [#uses=1]
+  call void @llvm.dbg.declare({ }* %1, metadata !9), !dbg !10
+  store i32 22, i32* %Y, !dbg !11
+  %2 = bitcast i32* %Z to { }*                    ; <{ }*> [#uses=1]
+  call void @llvm.dbg.declare({ }* %2, metadata !12), !dbg !14
+  store i32 23, i32* %Z, !dbg !15
+  %tmp = load i32* %X, !dbg !16                   ;  [#uses=1]
+  %tmp1 = load i32* %Y, !dbg !16                  ;  [#uses=1]
+  %add = add nsw i32 %tmp, %tmp1, !dbg !16        ;  [#uses=1]
+  store i32 %add, i32* %Z, !dbg !16
+  %tmp2 = load i32* %Y, !dbg !17                  ;  [#uses=1]
+  store i32 %tmp2, i32* %X, !dbg !17
+  ret void, !dbg !18
+}
+
+declare void @llvm.dbg.declare({ }*, metadata) nounwind readnone
+
+!0 = metadata !{i32 459008, metadata !1, metadata !"X", 
+                metadata !3, i32 2, metadata !6}; [ DW_TAG_auto_variable ]
+!1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
+!2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", metadata !"foo", 
+               metadata !"foo", metadata !3, i32 1, metadata !4, 
+               i1 false, i1 true}; [DW_TAG_subprogram ]
+!3 = metadata !{i32 458769, i32 0, i32 12, metadata !"foo.c", 
+                metadata !"/private/tmp", metadata !"clang 1.1", i1 true, 
+                i1 false, metadata !"", i32 0}; [DW_TAG_compile_unit ]
+!4 = metadata !{i32 458773, metadata !3, metadata !"", null, i32 0, i64 0, i64 0, 
+                i64 0, i32 0, null, metadata !5, i32 0}; [DW_TAG_subroutine_type ]
+!5 = metadata !{null}
+!6 = metadata !{i32 458788, metadata !3, metadata !"int", metadata !3, i32 0, 
+                i64 32, i64 32, i64 0, i32 0, i32 5}; [DW_TAG_base_type ]
+!7 = metadata !{i32 2, i32 7, metadata !1, null}
+!8 = metadata !{i32 2, i32 3, metadata !1, null}
+!9 = metadata !{i32 459008, metadata !1, metadata !"Y", metadata !3, i32 3, 
+                metadata !6}; [ DW_TAG_auto_variable ]
+!10 = metadata !{i32 3, i32 7, metadata !1, null}
+!11 = metadata !{i32 3, i32 3, metadata !1, null}
+!12 = metadata !{i32 459008, metadata !13, metadata !"Z", metadata !3, i32 5, 
+                 metadata !6}; [ DW_TAG_auto_variable ]
+!13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
+!14 = metadata !{i32 5, i32 9, metadata !13, null}
+!15 = metadata !{i32 5, i32 5, metadata !13, null}
+!16 = metadata !{i32 6, i32 5, metadata !13, null}
+!17 = metadata !{i32 8, i32 3, metadata !1, null}
+!18 = metadata !{i32 9, i32 1, metadata !2, null}
 
%llvm.dbg.func.start
%llvm.region.end
llvm.region.start
%llvm.region.end
stopping point
llvm.dbg.declare
Z
Z
 
+     call void @llvm.dbg.declare({ }* %0, metadata !0), !dbg !7   
+   
%llvm.dbg.declare
X
!dbg !7
X
+     !7 = metadata !{i32 2, i32 7, metadata !1, null}
+     !1 = metadata !{i32 458763, metadata !2}; [DW_TAG_lexical_block ]
+     !2 = metadata !{i32 458798, i32 0, metadata !3, metadata !"foo", 
+                     metadata !"foo", metadata !"foo", metadata !3, i32 1, 
+                     metadata !4, i1 false, i1 true}; [DW_TAG_subprogram ]   
+   
!7
!1
!1
!2
!2
X
foo
 
+     call void @llvm.dbg.declare({ }* %2, metadata !12), !dbg !14
+   
%llvm.dbg.declare
Z
!dbg !14
Z
+     !13 = metadata !{i32 458763, metadata !1}; [DW_TAG_lexical_block ]
+     !14 = metadata !{i32 5, i32 9, metadata !13, null}
+   
!14
Z
!13
!1
 text).  I couldn't figure out how to get the pod to not be ugly.

-Chris


From clattner at apple.com  Wed Nov 25 18:18:10 2009
From: clattner at apple.com (Chris Lattner)
Date: Wed, 25 Nov 2009 16:18:10 -0800
Subject: [llvm-commits] [llvm] r89877 -
	/llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h
In-Reply-To: <200911251957.nAPJvEma011366@zion.cs.uiuc.edu>
References: <200911251957.nAPJvEma011366@zion.cs.uiuc.edu>
Message-ID: <6CB2B61C-657A-4260-9717-1267F605009E@apple.com>


On Nov 25, 2009, at 11:57 AM, Bob Wilson wrote:

> Author: bwilson
> Date: Wed Nov 25 13:57:14 2009
> New Revision: 89877
> 
> URL: http://llvm.org/viewvc/llvm-project?rev=89877&view=rev
> Log:
> Tail duplicate indirect branches for PowerPC, too.
> With the testcase for pr3120, the "threaded interpreter" runtime decreases
> from 1788 to 1413 with this change.

Very nice Bob!  Silly question: should isProfitableToDuplicateIndirectBranch default to true?  That would let targets opt out if it is not beneficial and would save a small bit of code size.

-Chris

> 
> Modified:
>    llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h
> 
> Modified: llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h?rev=89877&r1=89876&r2=89877&view=diff
> 
> ==============================================================================
> --- llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h (original)
> +++ llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h Wed Nov 25 13:57:14 2009
> @@ -151,6 +151,8 @@
>   /// instruction may be.  This returns the maximum number of bytes.
>   ///
>   virtual unsigned GetInstSizeInBytes(const MachineInstr *MI) const;
> +
> +  virtual bool isProfitableToDuplicateIndirectBranch() const { return true; }
> };
> 
> }
> 
> 
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits




From bob.wilson at apple.com  Wed Nov 25 18:32:22 2009
From: bob.wilson at apple.com (Bob Wilson)
Date: Thu, 26 Nov 2009 00:32:22 -0000
Subject: [llvm-commits] [llvm] r89904 - in /llvm/trunk:
 include/llvm/CodeGen/MachineBasicBlock.h include/llvm/CodeGen/Passes.h
 lib/CodeGen/BranchFolding.cpp lib/CodeGen/BranchFolding.h
 lib/CodeGen/CMakeLists.txt lib/CodeGen/LLVMTargetMachine.cpp
 lib/CodeGen/MachineBasicBlock.cpp lib/CodeGen/TailDuplication.cpp
Message-ID: <200911260032.nAQ0WMAl020719@zion.cs.uiuc.edu>

Author: bwilson
Date: Wed Nov 25 18:32:21 2009
New Revision: 89904

URL: http://llvm.org/viewvc/llvm-project?rev=89904&view=rev
Log:
Split tail duplication into a separate pass.  This is needed to avoid
running tail duplication when doing branch folding for if-conversion, and
we also want to be able to run tail duplication earlier to fix some
reg alloc problems.  Move the CanFallThrough function from BranchFolding
to MachineBasicBlock so that it can be shared by TailDuplication.

Added:
    llvm/trunk/lib/CodeGen/TailDuplication.cpp
Modified:
    llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h
    llvm/trunk/include/llvm/CodeGen/Passes.h
    llvm/trunk/lib/CodeGen/BranchFolding.cpp
    llvm/trunk/lib/CodeGen/BranchFolding.h
    llvm/trunk/lib/CodeGen/CMakeLists.txt
    llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
    llvm/trunk/lib/CodeGen/MachineBasicBlock.cpp

Modified: llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================

--- llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineBasicBlock.h Wed Nov 25 18:32:21 2009
@@ -271,6 +271,12 @@
   /// ends with an unconditional branch to some other block.
   bool isLayoutSuccessor(const MachineBasicBlock *MBB) const;
 
+  /// canFallThrough - Return true if the block can implicitly transfer
+  /// control to the block after it by falling off the end of it.  This should
+  /// return false if it can reach the block after it, but it uses an explicit
+  /// branch to do so (e.g., a table jump).  True is a conservative answer.
+  bool canFallThrough();
+
   /// getFirstTerminator - returns an iterator to the first terminator
   /// instruction of this basic block. If a terminator does not exist,
   /// it returns end()

Modified: llvm/trunk/include/llvm/CodeGen/Passes.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/Passes.h?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================
--- llvm/trunk/include/llvm/CodeGen/Passes.h (original)
+++ llvm/trunk/include/llvm/CodeGen/Passes.h Wed Nov 25 18:32:21 2009
@@ -129,6 +129,10 @@
   /// branches.
   FunctionPass *createBranchFoldingPass(bool DefaultEnableTailMerge);
 
+  /// TailDuplication Pass - Duplicate blocks with unconditional branches
+  /// into tails of their predecessors.
+  FunctionPass *createTailDuplicationPass();
+
   /// IfConverter Pass - This pass performs machine code if conversion.
   FunctionPass *createIfConverterPass();
 

Modified: llvm/trunk/lib/CodeGen/BranchFolding.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/BranchFolding.cpp?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/BranchFolding.cpp (original)
+++ llvm/trunk/lib/CodeGen/BranchFolding.cpp Wed Nov 25 18:32:21 2009
@@ -41,8 +41,6 @@
 STATISTIC(NumDeadBlocks, "Number of dead blocks removed");
 STATISTIC(NumBranchOpts, "Number of branches optimized");
 STATISTIC(NumTailMerge , "Number of block tails merged");
-STATISTIC(NumTailDups  , "Number of tail duplicated blocks");
-STATISTIC(NumInstrDups , "Additional instructions due to tail duplication");
 
 static cl::opt FlagEnableTailMerge("enable-tail-merge",
                               cl::init(cl::BOU_UNSET), cl::Hidden);
@@ -205,16 +203,6 @@
     MadeChange |= MadeChangeThisIteration;
   }
 
-  // Do tail duplication after tail merging is done.  Otherwise it is
-  // tough to avoid situations where tail duplication and tail merging undo
-  // each other's transformations ad infinitum.
-  MadeChangeThisIteration = true;
-  while (MadeChangeThisIteration) {
-    MadeChangeThisIteration = false;
-    MadeChangeThisIteration |= TailDuplicateBlocks(MF);
-    MadeChange |= MadeChangeThisIteration;
-  }
-
   // See if any jump tables have become mergable or dead as the code generator
   // did its thing.
   MachineJumpTableInfo *JTI = MF.getJumpTableInfo();
@@ -918,71 +906,6 @@
 }
 
 
-/// CanFallThrough - Return true if the specified block (with the specified
-/// branch condition) can implicitly transfer control to the block after it by
-/// falling off the end of it.  This should return false if it can reach the
-/// block after it, but it uses an explicit branch to do so (e.g. a table jump).
-///
-/// True is a conservative answer.
-///
-bool BranchFolder::CanFallThrough(MachineBasicBlock *CurBB,
-                                  bool BranchUnAnalyzable,
-                                  MachineBasicBlock *TBB,
-                                  MachineBasicBlock *FBB,
-                                  const SmallVectorImpl &Cond) {
-  MachineFunction::iterator Fallthrough = CurBB;
-  ++Fallthrough;
-  // If FallthroughBlock is off the end of the function, it can't fall through.
-  if (Fallthrough == CurBB->getParent()->end())
-    return false;
-
-  // If FallthroughBlock isn't a successor of CurBB, no fallthrough is possible.
-  if (!CurBB->isSuccessor(Fallthrough))
-    return false;
-
-  // If we couldn't analyze the branch, examine the last instruction.
-  // If the block doesn't end in a known control barrier, assume fallthrough
-  // is possible. The isPredicable check is needed because this code can be
-  // called during IfConversion, where an instruction which is normally a
-  // Barrier is predicated and thus no longer an actual control barrier. This
-  // is over-conservative though, because if an instruction isn't actually
-  // predicated we could still treat it like a barrier.
-  if (BranchUnAnalyzable)
-    return CurBB->empty() || !CurBB->back().getDesc().isBarrier() ||
-           CurBB->back().getDesc().isPredicable();
-
-  // If there is no branch, control always falls through.
-  if (TBB == 0) return true;
-
-  // If there is some explicit branch to the fallthrough block, it can obviously
-  // reach, even though the branch should get folded to fall through implicitly.
-  if (MachineFunction::iterator(TBB) == Fallthrough ||
-      MachineFunction::iterator(FBB) == Fallthrough)
-    return true;
-
-  // If it's an unconditional branch to some block not the fall through, it
-  // doesn't fall through.
-  if (Cond.empty()) return false;
-
-  // Otherwise, if it is conditional and has no explicit false block, it falls
-  // through.
-  return FBB == 0;
-}
-
-/// CanFallThrough - Return true if the specified can implicitly transfer
-/// control to the block after it by falling off the end of it.  This should
-/// return false if it can reach the block after it, but it uses an explicit
-/// branch to do so (e.g. a table jump).
-///
-/// True is a conservative answer.
-///
-bool BranchFolder::CanFallThrough(MachineBasicBlock *CurBB) {
-  MachineBasicBlock *TBB = 0, *FBB = 0;
-  SmallVector Cond;
-  bool CurUnAnalyzable = TII->AnalyzeBranch(*CurBB, TBB, FBB, Cond, true);
-  return CanFallThrough(CurBB, CurUnAnalyzable, TBB, FBB, Cond);
-}
-
 /// IsBetterFallthrough - Return true if it would be clearly better to
 /// fall-through to MBB1 than to fall through into MBB2.  This has to return
 /// a strict ordering, returning true for both (MBB1,MBB2) and (MBB2,MBB1) will
@@ -1005,152 +928,6 @@
   return MBB2I->getDesc().isCall() && !MBB1I->getDesc().isCall();
 }
 
-/// TailDuplicateBlocks - Look for small blocks that are unconditionally
-/// branched to and do not fall through. Tail-duplicate their instructions
-/// into their predecessors to eliminate (dynamic) branches.
-bool BranchFolder::TailDuplicateBlocks(MachineFunction &MF) {
-  bool MadeChange = false;
-
-  for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ) {
-    MachineBasicBlock *MBB = I++;
-
-    // Only duplicate blocks that end with unconditional branches.
-    if (CanFallThrough(MBB))
-      continue;
-
-    MadeChange |= TailDuplicate(MBB, MF);
-
-    // If it is dead, remove it.
-    if (MBB->pred_empty()) {
-      NumInstrDups -= MBB->size();
-      RemoveDeadBlock(MBB);
-      MadeChange = true;
-      ++NumDeadBlocks;
-    }
-  }
-  return MadeChange;
-}
-
-/// TailDuplicate - If it is profitable, duplicate TailBB's contents in each
-/// of its predecessors.
-bool BranchFolder::TailDuplicate(MachineBasicBlock *TailBB,
-                                 MachineFunction &MF) {
-  // Don't try to tail-duplicate single-block loops.
-  if (TailBB->isSuccessor(TailBB))
-    return false;
-
-  // Set the limit on the number of instructions to duplicate, with a default
-  // of one less than the tail-merge threshold. When optimizing for size,
-  // duplicate only one, because one branch instruction can be eliminated to
-  // compensate for the duplication.
-  unsigned MaxDuplicateCount;
-  if (MF.getFunction()->hasFnAttr(Attribute::OptimizeForSize))
-    MaxDuplicateCount = 1;
-  else if (TII->isProfitableToDuplicateIndirectBranch() &&
-           !TailBB->empty() && TailBB->back().getDesc().isIndirectBranch())
-    // If the target has hardware branch prediction that can handle indirect
-    // branches, duplicating them can often make them predictable when there
-    // are common paths through the code.  The limit needs to be high enough
-    // to allow undoing the effects of tail merging.
-    MaxDuplicateCount = 20;
-  else
-    MaxDuplicateCount = TailMergeSize - 1;
-
-  // Check the instructions in the block to determine whether tail-duplication
-  // is invalid or unlikely to be profitable.
-  unsigned i = 0;
-  bool HasCall = false;
-  for (MachineBasicBlock::iterator I = TailBB->begin();
-       I != TailBB->end(); ++I, ++i) {
-    // Non-duplicable things shouldn't be tail-duplicated.
-    if (I->getDesc().isNotDuplicable()) return false;
-    // Don't duplicate more than the threshold.
-    if (i == MaxDuplicateCount) return false;
-    // Remember if we saw a call.
-    if (I->getDesc().isCall()) HasCall = true;
-  }
-  // Heuristically, don't tail-duplicate calls if it would expand code size,
-  // as it's less likely to be worth the extra cost.
-  if (i > 1 && HasCall)
-    return false;
-
-  // Iterate through all the unique predecessors and tail-duplicate this
-  // block into them, if possible. Copying the list ahead of time also
-  // avoids trouble with the predecessor list reallocating.
-  bool Changed = false;
-  SmallSetVector Preds(TailBB->pred_begin(),
-                                               TailBB->pred_end());
-  for (SmallSetVector::iterator PI = Preds.begin(),
-       PE = Preds.end(); PI != PE; ++PI) {
-    MachineBasicBlock *PredBB = *PI;
-
-    assert(TailBB != PredBB &&
-           "Single-block loop should have been rejected earlier!");
-    if (PredBB->succ_size() > 1) continue;
-
-    MachineBasicBlock *PredTBB, *PredFBB;
-    SmallVector PredCond;
-    if (TII->AnalyzeBranch(*PredBB, PredTBB, PredFBB, PredCond, true))
-      continue;
-    if (!PredCond.empty())
-      continue;
-    // EH edges are ignored by AnalyzeBranch.
-    if (PredBB->succ_size() != 1)
-      continue;
-    // Don't duplicate into a fall-through predecessor (at least for now).
-    if (PredBB->isLayoutSuccessor(TailBB) && CanFallThrough(PredBB))
-      continue;
-
-    DEBUG(errs() << "\nTail-duplicating into PredBB: " << *PredBB
-                 << "From Succ: " << *TailBB);
-
-    // Remove PredBB's unconditional branch.
-    TII->RemoveBranch(*PredBB);
-    // Clone the contents of TailBB into PredBB.
-    for (MachineBasicBlock::iterator I = TailBB->begin(), E = TailBB->end();
-         I != E; ++I) {
-      MachineInstr *NewMI = MF.CloneMachineInstr(I);
-      PredBB->insert(PredBB->end(), NewMI);
-    }
-    NumInstrDups += TailBB->size() - 1; // subtract one for removed branch
-
-    // Update the CFG.
-    PredBB->removeSuccessor(PredBB->succ_begin());
-    assert(PredBB->succ_empty() &&
-           "TailDuplicate called on block with multiple successors!");
-    for (MachineBasicBlock::succ_iterator I = TailBB->succ_begin(),
-         E = TailBB->succ_end(); I != E; ++I)
-       PredBB->addSuccessor(*I);
-
-    Changed = true;
-    ++NumTailDups;
-  }
-
-  // If TailBB was duplicated into all its predecessors except for the prior
-  // block, which falls through unconditionally, move the contents of this
-  // block into the prior block.
-  MachineBasicBlock &PrevBB = *prior(MachineFunction::iterator(TailBB));
-  MachineBasicBlock *PriorTBB = 0, *PriorFBB = 0;
-  SmallVector PriorCond;
-  bool PriorUnAnalyzable =
-    TII->AnalyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, true);
-  // This has to check PrevBB->succ_size() because EH edges are ignored by
-  // AnalyzeBranch.
-  if (!PriorUnAnalyzable && PriorCond.empty() && !PriorTBB &&
-      TailBB->pred_size() == 1 && PrevBB.succ_size() == 1 &&
-      !TailBB->hasAddressTaken()) {
-    DEBUG(errs() << "\nMerging into block: " << PrevBB
-          << "From MBB: " << *TailBB);
-    PrevBB.splice(PrevBB.end(), TailBB, TailBB->begin(), TailBB->end());
-    PrevBB.removeSuccessor(PrevBB.succ_begin());;
-    assert(PrevBB.succ_empty());
-    PrevBB.transferSuccessors(TailBB);
-    Changed = true;
-  }
-
-  return Changed;
-}
-
 /// OptimizeBlock - Analyze and optimize control flow related to the specified
 /// block.  This is never called on the entry block.
 bool BranchFolder::OptimizeBlock(MachineBasicBlock *MBB) {
@@ -1275,7 +1052,7 @@
     // the assert condition out of the loop body.
     if (MBB->succ_empty() && !PriorCond.empty() && PriorFBB == 0 &&
         MachineFunction::iterator(PriorTBB) == FallThrough &&
-        !CanFallThrough(MBB)) {
+        !MBB->canFallThrough()) {
       bool DoTransform = true;
 
       // We have to be careful that the succs of PredBB aren't both no-successor
@@ -1299,7 +1076,7 @@
       // In this case, we could actually be moving the return block *into* a
       // loop!
       if (DoTransform && !MBB->succ_empty() &&
-          (!CanFallThrough(PriorTBB) || PriorTBB->empty()))
+          (!PriorTBB->canFallThrough() || PriorTBB->empty()))
         DoTransform = false;
 
 
@@ -1431,13 +1208,11 @@
   // If the prior block doesn't fall through into this block, and if this
   // block doesn't fall through into some other block, see if we can find a
   // place to move this block where a fall-through will happen.
-  if (!CanFallThrough(&PrevBB, PriorUnAnalyzable,
-                      PriorTBB, PriorFBB, PriorCond)) {
+  if (!PrevBB.canFallThrough()) {
 
     // Now we know that there was no fall-through into this block, check to
     // see if it has a fall-through into its successor.
-    bool CurFallsThru = CanFallThrough(MBB, CurUnAnalyzable, CurTBB, CurFBB,
-                                       CurCond);
+    bool CurFallsThru = MBB->canFallThrough();
 
     if (!MBB->isLandingPad()) {
       // Check all the predecessors of this block.  If one of them has no fall
@@ -1449,7 +1224,7 @@
         MachineFunction::iterator PredFallthrough = PredBB; ++PredFallthrough;
         MachineBasicBlock *PredTBB, *PredFBB;
         SmallVector PredCond;
-        if (PredBB != MBB && !CanFallThrough(PredBB) &&
+        if (PredBB != MBB && !PredBB->canFallThrough() &&
             !TII->AnalyzeBranch(*PredBB, PredTBB, PredFBB, PredCond, true)
             && (!CurFallsThru || !CurTBB || !CurFBB)
             && (!CurFallsThru || MBB->getNumber() >= PredBB->getNumber())) {
@@ -1488,7 +1263,7 @@
         // and if the successor isn't an EH destination, we can arrange for the
         // fallthrough to happen.
         if (SuccBB != MBB && &*SuccPrev != MBB &&
-            !CanFallThrough(SuccPrev) && !CurUnAnalyzable &&
+            !SuccPrev->canFallThrough() && !CurUnAnalyzable &&
             !SuccBB->isLandingPad()) {
           MBB->moveBefore(SuccBB);
           MadeChange = true;

Modified: llvm/trunk/lib/CodeGen/BranchFolding.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/BranchFolding.h?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/BranchFolding.h (original)
+++ llvm/trunk/lib/CodeGen/BranchFolding.h Wed Nov 25 18:32:21 2009
@@ -105,18 +105,10 @@
     unsigned CreateCommonTailOnlyBlock(MachineBasicBlock *&PredBB,
                                        unsigned maxCommonTailLength);
 
-    bool TailDuplicateBlocks(MachineFunction &MF);
-    bool TailDuplicate(MachineBasicBlock *TailBB, MachineFunction &MF);
-    
     bool OptimizeBranches(MachineFunction &MF);
     bool OptimizeBlock(MachineBasicBlock *MBB);
     void RemoveDeadBlock(MachineBasicBlock *MBB);
     bool OptimizeImpDefsBlock(MachineBasicBlock *MBB);
-    
-    bool CanFallThrough(MachineBasicBlock *CurBB);
-    bool CanFallThrough(MachineBasicBlock *CurBB, bool BranchUnAnalyzable,
-                        MachineBasicBlock *TBB, MachineBasicBlock *FBB,
-                        const SmallVectorImpl &Cond);
   };
 }
 

Modified: llvm/trunk/lib/CodeGen/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/CMakeLists.txt?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/CMakeLists.txt (original)
+++ llvm/trunk/lib/CodeGen/CMakeLists.txt Wed Nov 25 18:32:21 2009
@@ -63,6 +63,7 @@
   StackProtector.cpp
   StackSlotColoring.cpp
   StrongPHIElimination.cpp
+  TailDuplication.cpp
   TargetInstrInfoImpl.cpp
   TwoAddressInstructionPass.cpp
   UnreachableBlockElim.cpp

Modified: llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp (original)
+++ llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp Wed Nov 25 18:32:21 2009
@@ -35,6 +35,8 @@
     cl::desc("Disable Post Regalloc"));
 static cl::opt DisableBranchFold("disable-branch-fold", cl::Hidden,
     cl::desc("Disable branch folding"));
+static cl::opt DisableTailDuplicate("disable-tail-duplicate", cl::Hidden,
+    cl::desc("Disable tail duplication"));
 static cl::opt DisableCodePlace("disable-code-place", cl::Hidden,
     cl::desc("Disable code placement"));
 static cl::opt DisableSSC("disable-ssc", cl::Hidden,
@@ -344,6 +346,12 @@
     printAndVerify(PM, "After BranchFolding");
   }
 
+  // Tail duplication.
+  if (OptLevel != CodeGenOpt::None && !DisableTailDuplicate) {
+    PM.add(createTailDuplicationPass());
+    printAndVerify(PM, "After TailDuplication");
+  }
+
   PM.add(createGCMachineCodeAnalysisPass());
 
   if (PrintGCInfo)

Modified: llvm/trunk/lib/CodeGen/MachineBasicBlock.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachineBasicBlock.cpp?rev=89904&r1=89903&r2=89904&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/MachineBasicBlock.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachineBasicBlock.cpp Wed Nov 25 18:32:21 2009
@@ -362,6 +362,51 @@
   return next(I) == MachineFunction::const_iterator(MBB);
 }
 
+bool MachineBasicBlock::canFallThrough() {
+  MachineBasicBlock *TBB = 0, *FBB = 0;
+  SmallVector Cond;
+  const TargetInstrInfo *TII = getParent()->getTarget().getInstrInfo();
+  bool BranchUnAnalyzable = TII->AnalyzeBranch(*this, TBB, FBB, Cond, true);
+
+  MachineFunction::iterator Fallthrough = this;
+  ++Fallthrough;
+  // If FallthroughBlock is off the end of the function, it can't fall through.
+  if (Fallthrough == getParent()->end())
+    return false;
+
+  // If FallthroughBlock isn't a successor, no fallthrough is possible.
+  if (!isSuccessor(Fallthrough))
+    return false;
+
+  // If we couldn't analyze the branch, examine the last instruction.
+  // If the block doesn't end in a known control barrier, assume fallthrough
+  // is possible. The isPredicable check is needed because this code can be
+  // called during IfConversion, where an instruction which is normally a
+  // Barrier is predicated and thus no longer an actual control barrier. This
+  // is over-conservative though, because if an instruction isn't actually
+  // predicated we could still treat it like a barrier.
+  if (BranchUnAnalyzable)
+    return empty() || !back().getDesc().isBarrier() ||
+           back().getDesc().isPredicable();
+
+  // If there is no branch, control always falls through.
+  if (TBB == 0) return true;
+
+  // If there is some explicit branch to the fallthrough block, it can obviously
+  // reach, even though the branch should get folded to fall through implicitly.
+  if (MachineFunction::iterator(TBB) == Fallthrough ||
+      MachineFunction::iterator(FBB) == Fallthrough)
+    return true;
+
+  // If it's an unconditional branch to some block not the fall through, it
+  // doesn't fall through.
+  if (Cond.empty()) return false;
+
+  // Otherwise, if it is conditional and has no explicit false block, it falls
+  // through.
+  return FBB == 0;
+}
+
 /// removeFromParent - This method unlinks 'this' from the containing function,
 /// and returns it, but does not delete it.
 MachineBasicBlock *MachineBasicBlock::removeFromParent() {

Added: llvm/trunk/lib/CodeGen/TailDuplication.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/TailDuplication.cpp?rev=89904&view=auto

==============================================================================
--- llvm/trunk/lib/CodeGen/TailDuplication.cpp (added)
+++ llvm/trunk/lib/CodeGen/TailDuplication.cpp Wed Nov 25 18:32:21 2009
@@ -0,0 +1,250 @@
+//===-- TailDuplication.cpp - Duplicate blocks into predecessors' tails ---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass duplicates basic blocks ending in unconditional branches into
+// the tails of their predecessors.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "tailduplication"
+#include "llvm/Function.h"
+#include "llvm/CodeGen/Passes.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/CodeGen/MachineFunctionPass.h"
+#include "llvm/Target/TargetInstrInfo.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/Statistic.h"
+using namespace llvm;
+
+STATISTIC(NumTailDups  , "Number of tail duplicated blocks");
+STATISTIC(NumInstrDups , "Additional instructions due to tail duplication");
+STATISTIC(NumDeadBlocks, "Number of dead blocks removed");
+
+// Heuristic for tail duplication.
+static cl::opt
+TailDuplicateSize("tail-dup-size",
+                  cl::desc("Maximum instructions to consider tail duplicating"),
+                  cl::init(2), cl::Hidden);
+
+namespace {
+  /// TailDuplicationPass - Perform tail duplication.
+  class TailDuplicationPass : public MachineFunctionPass {
+    const TargetInstrInfo *TII;
+    MachineModuleInfo *MMI;
+
+  public:
+    static char ID;
+    explicit TailDuplicationPass() : MachineFunctionPass(&ID) {}
+
+    virtual bool runOnMachineFunction(MachineFunction &MF);
+    virtual const char *getPassName() const { return "Tail Duplication"; }
+
+  private:
+    bool TailDuplicateBlocks(MachineFunction &MF);
+    bool TailDuplicate(MachineBasicBlock *TailBB, MachineFunction &MF);
+    void RemoveDeadBlock(MachineBasicBlock *MBB);
+  };
+
+  char TailDuplicationPass::ID = 0;
+}
+
+FunctionPass *llvm::createTailDuplicationPass() {
+  return new TailDuplicationPass();
+}
+
+bool TailDuplicationPass::runOnMachineFunction(MachineFunction &MF) {
+  TII = MF.getTarget().getInstrInfo();
+  MMI = getAnalysisIfAvailable();
+
+  bool MadeChange = false;
+  bool MadeChangeThisIteration = true;
+  while (MadeChangeThisIteration) {
+    MadeChangeThisIteration = false;
+    MadeChangeThisIteration |= TailDuplicateBlocks(MF);
+    MadeChange |= MadeChangeThisIteration;
+  }
+
+  return MadeChange;
+}
+
+/// TailDuplicateBlocks - Look for small blocks that are unconditionally
+/// branched to and do not fall through. Tail-duplicate their instructions
+/// into their predecessors to eliminate (dynamic) branches.
+bool TailDuplicationPass::TailDuplicateBlocks(MachineFunction &MF) {
+  bool MadeChange = false;
+
+  for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ) {
+    MachineBasicBlock *MBB = I++;
+
+    // Only duplicate blocks that end with unconditional branches.
+    if (MBB->canFallThrough())
+      continue;
+
+    MadeChange |= TailDuplicate(MBB, MF);
+
+    // If it is dead, remove it.
+    if (MBB->pred_empty()) {
+      NumInstrDups -= MBB->size();
+      RemoveDeadBlock(MBB);
+      MadeChange = true;
+      ++NumDeadBlocks;
+    }
+  }
+  return MadeChange;
+}
+
+/// TailDuplicate - If it is profitable, duplicate TailBB's contents in each
+/// of its predecessors.
+bool TailDuplicationPass::TailDuplicate(MachineBasicBlock *TailBB,
+                                        MachineFunction &MF) {
+  // Don't try to tail-duplicate single-block loops.
+  if (TailBB->isSuccessor(TailBB))
+    return false;
+
+  // Set the limit on the number of instructions to duplicate, with a default
+  // of one less than the tail-merge threshold. When optimizing for size,
+  // duplicate only one, because one branch instruction can be eliminated to
+  // compensate for the duplication.
+  unsigned MaxDuplicateCount;
+  if (MF.getFunction()->hasFnAttr(Attribute::OptimizeForSize))
+    MaxDuplicateCount = 1;
+  else if (TII->isProfitableToDuplicateIndirectBranch() &&
+           !TailBB->empty() && TailBB->back().getDesc().isIndirectBranch())
+    // If the target has hardware branch prediction that can handle indirect
+    // branches, duplicating them can often make them predictable when there
+    // are common paths through the code.  The limit needs to be high enough
+    // to allow undoing the effects of tail merging.
+    MaxDuplicateCount = 20;
+  else
+    MaxDuplicateCount = TailDuplicateSize;
+
+  // Check the instructions in the block to determine whether tail-duplication
+  // is invalid or unlikely to be profitable.
+  unsigned i = 0;
+  bool HasCall = false;
+  for (MachineBasicBlock::iterator I = TailBB->begin();
+       I != TailBB->end(); ++I, ++i) {
+    // Non-duplicable things shouldn't be tail-duplicated.
+    if (I->getDesc().isNotDuplicable()) return false;
+    // Don't duplicate more than the threshold.
+    if (i == MaxDuplicateCount) return false;
+    // Remember if we saw a call.
+    if (I->getDesc().isCall()) HasCall = true;
+  }
+  // Heuristically, don't tail-duplicate calls if it would expand code size,
+  // as it's less likely to be worth the extra cost.
+  if (i > 1 && HasCall)
+    return false;
+
+  // Iterate through all the unique predecessors and tail-duplicate this
+  // block into them, if possible. Copying the list ahead of time also
+  // avoids trouble with the predecessor list reallocating.
+  bool Changed = false;
+  SmallSetVector Preds(TailBB->pred_begin(),
+                                               TailBB->pred_end());
+  for (SmallSetVector::iterator PI = Preds.begin(),
+       PE = Preds.end(); PI != PE; ++PI) {
+    MachineBasicBlock *PredBB = *PI;
+
+    assert(TailBB != PredBB &&
+           "Single-block loop should have been rejected earlier!");
+    if (PredBB->succ_size() > 1) continue;
+
+    MachineBasicBlock *PredTBB, *PredFBB;
+    SmallVector PredCond;
+    if (TII->AnalyzeBranch(*PredBB, PredTBB, PredFBB, PredCond, true))
+      continue;
+    if (!PredCond.empty())
+      continue;
+    // EH edges are ignored by AnalyzeBranch.
+    if (PredBB->succ_size() != 1)
+      continue;
+    // Don't duplicate into a fall-through predecessor (at least for now).
+    if (PredBB->isLayoutSuccessor(TailBB) && PredBB->canFallThrough())
+      continue;
+
+    DEBUG(errs() << "\nTail-duplicating into PredBB: " << *PredBB
+                 << "From Succ: " << *TailBB);
+
+    // Remove PredBB's unconditional branch.
+    TII->RemoveBranch(*PredBB);
+    // Clone the contents of TailBB into PredBB.
+    for (MachineBasicBlock::iterator I = TailBB->begin(), E = TailBB->end();
+         I != E; ++I) {
+      MachineInstr *NewMI = MF.CloneMachineInstr(I);
+      PredBB->insert(PredBB->end(), NewMI);
+    }
+    NumInstrDups += TailBB->size() - 1; // subtract one for removed branch
+
+    // Update the CFG.
+    PredBB->removeSuccessor(PredBB->succ_begin());
+    assert(PredBB->succ_empty() &&
+           "TailDuplicate called on block with multiple successors!");
+    for (MachineBasicBlock::succ_iterator I = TailBB->succ_begin(),
+         E = TailBB->succ_end(); I != E; ++I)
+       PredBB->addSuccessor(*I);
+
+    Changed = true;
+    ++NumTailDups;
+  }
+
+  // If TailBB was duplicated into all its predecessors except for the prior
+  // block, which falls through unconditionally, move the contents of this
+  // block into the prior block.
+  MachineBasicBlock &PrevBB = *prior(MachineFunction::iterator(TailBB));
+  MachineBasicBlock *PriorTBB = 0, *PriorFBB = 0;
+  SmallVector PriorCond;
+  bool PriorUnAnalyzable =
+    TII->AnalyzeBranch(PrevBB, PriorTBB, PriorFBB, PriorCond, true);
+  // This has to check PrevBB->succ_size() because EH edges are ignored by
+  // AnalyzeBranch.
+  if (!PriorUnAnalyzable && PriorCond.empty() && !PriorTBB &&
+      TailBB->pred_size() == 1 && PrevBB.succ_size() == 1 &&
+      !TailBB->hasAddressTaken()) {
+    DEBUG(errs() << "\nMerging into block: " << PrevBB
+          << "From MBB: " << *TailBB);
+    PrevBB.splice(PrevBB.end(), TailBB, TailBB->begin(), TailBB->end());
+    PrevBB.removeSuccessor(PrevBB.succ_begin());;
+    assert(PrevBB.succ_empty());
+    PrevBB.transferSuccessors(TailBB);
+    Changed = true;
+  }
+
+  return Changed;
+}
+
+/// RemoveDeadBlock - Remove the specified dead machine basic block from the
+/// function, updating the CFG.
+void TailDuplicationPass::RemoveDeadBlock(MachineBasicBlock *MBB) {
+  assert(MBB->pred_empty() && "MBB must be dead!");
+  DEBUG(errs() << "\nRemoving MBB: " << *MBB);
+
+  // Remove all successors.
+  while (!MBB->succ_empty())
+    MBB->removeSuccessor(MBB->succ_end()-1);
+
+  // If there are any labels in the basic block, unregister them from
+  // MachineModuleInfo.
+  if (MMI && !MBB->empty()) {
+    for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end();
+         I != E; ++I) {
+      if (I->isLabel())
+        // The label ID # is always operand #0, an immediate.
+        MMI->InvalidateLabel(I->getOperand(0).getImm());
+    }
+  }
+
+  // Remove the block.
+  MBB->eraseFromParent();
+}
+




From evan.cheng at apple.com  Wed Nov 25 18:32:36 2009
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 26 Nov 2009 00:32:36 -0000
Subject: [llvm-commits] [llvm] r89905 -
	/llvm/trunk/lib/CodeGen/ProcessImplicitDefs.cpp
Message-ID: <200911260032.nAQ0WaRx020738@zion.cs.uiuc.edu>

Author: evancheng
Date: Wed Nov 25 18:32:36 2009
New Revision: 89905

URL: http://llvm.org/viewvc/llvm-project?rev=89905&view=rev
Log:
When all defs of a vr are implicit_def, delete all of the defs.

Modified:
    llvm/trunk/lib/CodeGen/ProcessImplicitDefs.cpp

Modified: llvm/trunk/lib/CodeGen/ProcessImplicitDefs.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/ProcessImplicitDefs.cpp?rev=89905&r1=89904&r2=89905&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/ProcessImplicitDefs.cpp (original)
+++ llvm/trunk/lib/CodeGen/ProcessImplicitDefs.cpp Wed Nov 25 18:32:36 2009
@@ -183,19 +183,23 @@
       // is not an implicit_def, do not insert implicit_def's before the
       // uses.
       bool Skip = false;
+      SmallVector DeadImpDefs;
       for (MachineRegisterInfo::def_iterator DI = mri_->def_begin(Reg),
              DE = mri_->def_end(); DI != DE; ++DI) {
-        if (DI->getOpcode() != TargetInstrInfo::IMPLICIT_DEF) {
+        MachineInstr *DeadImpDef = &*DI;
+        if (DeadImpDef->getOpcode() != TargetInstrInfo::IMPLICIT_DEF) {
           Skip = true;
           break;
         }
+        DeadImpDefs.push_back(DeadImpDef);
       }
       if (Skip)
         continue;
 
       // The only implicit_def which we want to keep are those that are live
       // out of its block.
-      MI->eraseFromParent();
+      for (unsigned j = 0, ee = DeadImpDefs.size(); j != ee; ++j)
+        DeadImpDefs[j]->eraseFromParent();
       Changed = true;
 
       // Process each use instruction once.




From evan.cheng at apple.com  Wed Nov 25 18:35:01 2009
From: evan.cheng at apple.com (Evan Cheng)
Date: Thu, 26 Nov 2009 00:35:01 -0000
Subject: [llvm-commits] [llvm] r89906 -
	/llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll
Message-ID: <200911260035.nAQ0Z1mo020843@zion.cs.uiuc.edu>

Author: evancheng
Date: Wed Nov 25 18:35:01 2009
New Revision: 89906

URL: http://llvm.org/viewvc/llvm-project?rev=89906&view=rev
Log:
Test for 89905.

Added:
    llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll

Added: llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll?rev=89906&view=auto

==============================================================================
--- llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll (added)
+++ llvm/trunk/test/CodeGen/X86/2009-11-25-ImpDefBug.ll Wed Nov 25 18:35:01 2009
@@ -0,0 +1,116 @@
+; RUN: llc < %s -mtriple=x86_64-unknown-linux-gnu
+; pr5600
+
+%struct..0__pthread_mutex_s = type { i32, i32, i32, i32, i32, i32, %struct.__pthread_list_t }
+%struct.ASN1ObjHeader = type { i8, %"struct.__gmp_expr<__mpz_struct [1],__mpz_struct [1]>", i64, i32, i32, i32 }
+%struct.ASN1Object = type { i32 (...)**, i32, i32, i64 }
+%struct.ASN1Unit = type { [4 x i32 (%struct.ASN1ObjHeader*, %struct.ASN1Object**)*], %"struct.std::ASN1ObjList" }
+%"struct.__gmp_expr<__mpz_struct [1],__mpz_struct [1]>" = type { [1 x %struct.__mpz_struct] }
+%struct.__mpz_struct = type { i32, i32, i64* }
+%struct.__pthread_list_t = type { %struct.__pthread_list_t*, %struct.__pthread_list_t* }
+%struct.pthread_attr_t = type { i64, [48 x i8] }
+%struct.pthread_mutex_t = type { %struct..0__pthread_mutex_s }
+%struct.pthread_mutexattr_t = type { i32 }
+%"struct.std::ASN1ObjList" = type { %"struct.std::_Vector_base >" }
+%"struct.std::_Vector_base >" = type { %"struct.std::_Vector_base >::_Vector_impl" }
+%"struct.std::_Vector_base >::_Vector_impl" = type { %struct.ASN1Object**, %struct.ASN1Object**, %struct.ASN1Object** }
+%struct.xmstream = type { i8*, i64, i64, i64, i8 }
+
+declare void @_ZNSt6vectorIP10ASN1ObjectSaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_(%"struct.std::ASN1ObjList"* nocapture, i64, %struct.ASN1Object** nocapture)
+
+declare i32 @_Z17LoadObjectFromBERR8xmstreamPP10ASN1ObjectPPF10ASN1StatusP13ASN1ObjHeaderS3_E(%struct.xmstream*, %struct.ASN1Object**, i32 (%struct.ASN1ObjHeader*, %struct.ASN1Object**)**)
+
+define i32 @_ZN8ASN1Unit4loadER8xmstreamjm18ASN1LengthEncoding(%struct.ASN1Unit* %this, %struct.xmstream* nocapture %stream, i32 %numObjects, i64 %size, i32 %lEncoding) {
+entry:
+  br label %meshBB85
+
+bb5:                                              ; preds = %bb13.fragment.cl135, %bb13.fragment.cl, %bb.i.i.bbcl.disp, %bb13.fragment
+  %0 = invoke i32 @_Z17LoadObjectFromBERR8xmstreamPP10ASN1ObjectPPF10ASN1StatusP13ASN1ObjHeaderS3_E(%struct.xmstream* undef, %struct.ASN1Object** undef, i32 (%struct.ASN1ObjHeader*, %struct.ASN1Object**)** undef)
+          to label %meshBB81.bbcl.disp unwind label %lpad ;  [#uses=0]
+
+bb10.fragment:                                    ; preds = %bb13.fragment.bbcl.disp
+  br i1 undef, label %bb1.i.fragment.bbcl.disp, label %bb.i.i.bbcl.disp
+
+bb1.i.fragment:                                   ; preds = %bb1.i.fragment.bbcl.disp
+  invoke void @_ZNSt6vectorIP10ASN1ObjectSaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_(%"struct.std::ASN1ObjList"* undef, i64 undef, %struct.ASN1Object** undef)
+          to label %meshBB81.bbcl.disp unwind label %lpad
+
+bb13.fragment:                                    ; preds = %bb13.fragment.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb5
+
+bb.i4:                                            ; preds = %bb.i4.bbcl.disp, %bb1.i.fragment.bbcl.disp
+  ret i32 undef
+
+bb1.i5:                                           ; preds = %bb.i1
+  ret i32 undef
+
+lpad:                                             ; preds = %bb1.i.fragment.cl, %bb1.i.fragment, %bb5
+  %.SV10.phi807 = phi i8* [ undef, %bb1.i.fragment.cl ], [ undef, %bb1.i.fragment ], [ undef, %bb5 ] ;  [#uses=1]
+  %1 = load i8* %.SV10.phi807, align 8            ;  [#uses=0]
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb13.fragment.bbcl.disp
+
+bb.i1:                                            ; preds = %bb.i.i.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb1.i5
+
+meshBB81:                                         ; preds = %meshBB81.bbcl.disp, %bb.i.i.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb.i4.bbcl.disp
+
+meshBB85:                                         ; preds = %meshBB81.bbcl.disp, %bb.i4.bbcl.disp, %bb1.i.fragment.bbcl.disp, %bb.i.i.bbcl.disp, %entry
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb13.fragment.bbcl.disp
+
+bb.i.i.bbcl.disp:                                 ; preds = %bb10.fragment
+  switch i8 undef, label %meshBB85 [
+    i8 123, label %bb.i1
+    i8 97, label %bb5
+    i8 44, label %meshBB81
+    i8 1, label %meshBB81.cl
+    i8 51, label %meshBB81.cl141
+  ]
+
+bb1.i.fragment.cl:                                ; preds = %bb1.i.fragment.bbcl.disp
+  invoke void @_ZNSt6vectorIP10ASN1ObjectSaIS1_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS1_S3_EERKS1_(%"struct.std::ASN1ObjList"* undef, i64 undef, %struct.ASN1Object** undef)
+          to label %meshBB81.bbcl.disp unwind label %lpad
+
+bb1.i.fragment.bbcl.disp:                         ; preds = %bb10.fragment
+  switch i8 undef, label %bb.i4 [
+    i8 97, label %bb1.i.fragment
+    i8 7, label %bb1.i.fragment.cl
+    i8 35, label %bb.i4.cl
+    i8 77, label %meshBB85
+  ]
+
+bb13.fragment.cl:                                 ; preds = %bb13.fragment.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb5
+
+bb13.fragment.cl135:                              ; preds = %bb13.fragment.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb5
+
+bb13.fragment.bbcl.disp:                          ; preds = %meshBB85, %lpad
+  switch i8 undef, label %bb10.fragment [
+    i8 67, label %bb13.fragment.cl
+    i8 108, label %bb13.fragment
+    i8 58, label %bb13.fragment.cl135
+  ]
+
+bb.i4.cl:                                         ; preds = %bb.i4.bbcl.disp, %bb1.i.fragment.bbcl.disp
+  ret i32 undef
+
+bb.i4.bbcl.disp:                                  ; preds = %meshBB81.cl141, %meshBB81.cl, %meshBB81
+  switch i8 undef, label %bb.i4 [
+    i8 35, label %bb.i4.cl
+    i8 77, label %meshBB85
+  ]
+
+meshBB81.cl:                                      ; preds = %meshBB81.bbcl.disp, %bb.i.i.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb.i4.bbcl.disp
+
+meshBB81.cl141:                                   ; preds = %meshBB81.bbcl.disp, %bb.i.i.bbcl.disp
+  br i1 undef, label %meshBB81.bbcl.disp, label %bb.i4.bbcl.disp
+
+meshBB81.bbcl.disp:                               ; preds = %meshBB81.cl141, %meshBB81.cl, %bb13.fragment.cl135, %bb13.fragment.cl, %bb1.i.fragment.cl, %meshBB85, %meshBB81, %bb.i1, %lpad, %bb13.fragment, %bb1.i.fragment, %bb5
+  switch i8 undef, label %meshBB85 [
+    i8 44, label %meshBB81
+    i8 1, label %meshBB81.cl
+    i8 51, label %meshBB81.cl141
+  ]
+}




From bob.wilson at apple.com  Wed Nov 25 18:45:26 2009
From: bob.wilson at apple.com (Bob Wilson)
Date: Wed, 25 Nov 2009 16:45:26 -0800
Subject: [llvm-commits] [llvm] r89877 -
	/llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h
In-Reply-To: <6CB2B61C-657A-4260-9717-1267F605009E@apple.com>
References: <200911251957.nAPJvEma011366@zion.cs.uiuc.edu>
	<6CB2B61C-657A-4260-9717-1267F605009E@apple.com>
Message-ID: <20AB4AAE-93CF-46FB-8788-F53C1107E490@apple.com>


On Nov 25, 2009, at 4:18 PM, Chris Lattner wrote:

> 
> On Nov 25, 2009, at 11:57 AM, Bob Wilson wrote:
> 
>> Author: bwilson
>> Date: Wed Nov 25 13:57:14 2009
>> New Revision: 89877
>> 
>> URL: http://llvm.org/viewvc/llvm-project?rev=89877&view=rev
>> Log:
>> Tail duplicate indirect branches for PowerPC, too.
>> With the testcase for pr3120, the "threaded interpreter" runtime decreases
>> from 1788 to 1413 with this change.
> 
> Very nice Bob!  Silly question: should isProfitableToDuplicateIndirectBranch default to true?  That would let targets opt out if it is not beneficial and would save a small bit of code size.

Not silly at all.... I had the same thought.

Having spent more time looking at the effects of this transformation, I have a different proposal that I think you might like.  Let's just get rid of that target hook altogether.  ;-)

This special treatment of indirect branches for tail duplication just doesn't kick in very often.  I was being cautious about blowing up code size, but it doesn't happen often enough to matter.  I also wasn't sure if this would matter on anything besides ARM Cortex processors but now we know that it does.

On a related note, Evan suggested that we be more aggressive about this with -Os, and I think that's also a good idea.

Unless someone objects, I'll go ahead with those changes sometime soon.


From sabre at nondot.org  Wed Nov 25 19:50:12 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 01:50:12 -0000
Subject: [llvm-commits] [llvm] r89912 -
	/llvm/trunk/lib/Analysis/ValueTracking.cpp
Message-ID: <200911260150.nAQ1oCXa023320@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 19:50:12 2009
New Revision: 89912

URL: http://llvm.org/viewvc/llvm-project?rev=89912&view=rev
Log:
remove some redundant braces

Modified:
    llvm/trunk/lib/Analysis/ValueTracking.cpp

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=89912&r1=89911&r2=89912&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Wed Nov 25 19:50:12 2009
@@ -833,14 +833,12 @@
 
   switch (I->getOpcode()) {
   default: break;
-  case Instruction::SExt: {
+  case Instruction::SExt:
     if (!LookThroughSExt) return false;
     // otherwise fall through to ZExt
-  }
-  case Instruction::ZExt: {
+  case Instruction::ZExt:
     return ComputeMultiple(I->getOperand(0), Base, Multiple,
                            LookThroughSExt, Depth+1);
-  }
   case Instruction::Shl:
   case Instruction::Mul: {
     Value *Op0 = I->getOperand(0);




From sabre at nondot.org  Wed Nov 25 19:51:19 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 01:51:19 -0000
Subject: [llvm-commits] [llvm] r89913 - /llvm/trunk/lib/Target/README.txt
Message-ID: <200911260151.nAQ1pJP7023358@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 19:51:18 2009
New Revision: 89913

URL: http://llvm.org/viewvc/llvm-project?rev=89913&view=rev
Log:
update some notes slightly

Modified:
    llvm/trunk/lib/Target/README.txt

Modified: llvm/trunk/lib/Target/README.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/README.txt?rev=89913&r1=89912&r2=89913&view=diff

==============================================================================
--- llvm/trunk/lib/Target/README.txt (original)
+++ llvm/trunk/lib/Target/README.txt Wed Nov 25 19:51:18 2009
@@ -220,7 +220,7 @@
 ... which would only do one 32-bit XOR per loop iteration instead of two.
 
 It would also be nice to recognize the reg->size doesn't alias reg->node[i], but
-alas.
+this requires TBAA.
 
 //===---------------------------------------------------------------------===//
 
@@ -280,6 +280,9 @@
   return count;
 }
 
+This is a form of idiom recognition for loops, the same thing that could be
+useful for recognizing memset/memcpy.
+
 //===---------------------------------------------------------------------===//
 
 These should turn into single 16-bit (unaligned?) loads on little/big endian
@@ -343,7 +346,7 @@
 
 //===---------------------------------------------------------------------===//
 
-LSR should know what GPR types a target has.  This code:
+LSR should know what GPR types a target has from TargetData.  This code:
 
 volatile short X, Y; // globals
 
@@ -369,7 +372,6 @@
 
 LSR should reuse the "+" IV for the exit test.
 
-
 //===---------------------------------------------------------------------===//
 
 Tail call elim should be more aggressive, checking to see if the call is




From sabre at nondot.org  Wed Nov 25 20:11:09 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 02:11:09 -0000
Subject: [llvm-commits] [llvm] r89914 -
	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
Message-ID: <200911260211.nAQ2B9FU024092@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 20:11:08 2009
New Revision: 89914

URL: http://llvm.org/viewvc/llvm-project?rev=89914&view=rev
Log:
Use GEPOperator more pervasively to simplify code.


Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89914&r1=89913&r2=89914&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Wed Nov 25 20:11:08 2009
@@ -38,24 +38,24 @@
 // Useful predicates
 //===----------------------------------------------------------------------===//
 
-static const Value *GetGEPOperands(const Value *V, 
+static const Value *GetGEPOperands(const GEPOperator *V, 
                                    SmallVector &GEPOps) {
   assert(GEPOps.empty() && "Expect empty list to populate!");
-  GEPOps.insert(GEPOps.end(), cast(V)->op_begin()+1,
-                cast(V)->op_end());
+  GEPOps.insert(GEPOps.end(), V->op_begin()+1, V->op_end());
 
-  // Accumulate all of the chained indexes into the operand array
-  V = cast(V)->getOperand(0);
-
-  while (const GEPOperator *G = dyn_cast(V)) {
-    if (!isa(GEPOps[0]) || isa(GEPOps[0]) ||
-        !cast(GEPOps[0])->isNullValue())
-      break;  // Don't handle folding arbitrary pointer offsets yet...
+  // Accumulate all of the chained indexes into the operand array.
+  Value *BasePtr = V->getOperand(0);
+  while (1) {
+    V = dyn_cast(BasePtr);
+    if (V == 0) return BasePtr;
+    
+    // Don't handle folding arbitrary pointer offsets yet.
+    if (!isa(GEPOps[0]) || !cast(GEPOps[0])->isNullValue())
+      return BasePtr;
+    
     GEPOps.erase(GEPOps.begin());   // Drop the zero index
-    GEPOps.insert(GEPOps.begin(), G->op_begin()+1, G->op_end());
-    V = G->getOperand(0);
+    GEPOps.insert(GEPOps.begin(), V->op_begin()+1, V->op_end());
   }
-  return V;
 }
 
 /// isKnownNonNull - Return true if we know that the specified value is never
@@ -219,7 +219,7 @@
 
     // aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP
     // instruction against another.
-    AliasResult aliasGEP(const Value *V1, unsigned V1Size,
+    AliasResult aliasGEP(const GEPOperator *V1, unsigned V1Size,
                          const Value *V2, unsigned V2Size);
 
     // aliasPHI - Provide a bunch of ad-hoc rules to disambiguate a PHI
@@ -405,21 +405,19 @@
   return NoAA::getModRefInfo(CS1, CS2);
 }
 
-// aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP instruction
-// against another.
-//
+/// aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP instruction
+/// against another pointer.  We know that V1 is a GEP, but we don't know
+/// anything about V2.
+///
 AliasAnalysis::AliasResult
-BasicAliasAnalysis::aliasGEP(const Value *V1, unsigned V1Size,
+BasicAliasAnalysis::aliasGEP(const GEPOperator *GEP1, unsigned V1Size,
                              const Value *V2, unsigned V2Size) {
   // If we have two gep instructions with must-alias'ing base pointers, figure
   // out if the indexes to the GEP tell us anything about the derived pointer.
   // Note that we also handle chains of getelementptr instructions as well as
   // constant expression getelementptrs here.
   //
-  if (isa(V1) && isa(V2)) {
-    const User *GEP1 = cast(V1);
-    const User *GEP2 = cast(V2);
-    
+  if (const GEPOperator *GEP2 = dyn_cast(V2)) {
     // If V1 and V2 are identical GEPs, just recurse down on both of them.
     // This allows us to analyze things like:
     //   P = gep A, 0, i, 1
@@ -438,13 +436,13 @@
     while (isa(GEP1->getOperand(0)) &&
            GEP1->getOperand(1) ==
            Constant::getNullValue(GEP1->getOperand(1)->getType()))
-      GEP1 = cast(GEP1->getOperand(0));
+      GEP1 = cast(GEP1->getOperand(0));
     const Value *BasePtr1 = GEP1->getOperand(0);
 
     while (isa(GEP2->getOperand(0)) &&
            GEP2->getOperand(1) ==
            Constant::getNullValue(GEP2->getOperand(1)->getType()))
-      GEP2 = cast(GEP2->getOperand(0));
+      GEP2 = cast(GEP2->getOperand(0));
     const Value *BasePtr2 = GEP2->getOperand(0);
 
     // Do the base pointers alias?
@@ -457,8 +455,8 @@
 
       // Collect all of the chained GEP operands together into one simple place
       SmallVector GEP1Ops, GEP2Ops;
-      BasePtr1 = GetGEPOperands(V1, GEP1Ops);
-      BasePtr2 = GetGEPOperands(V2, GEP2Ops);
+      BasePtr1 = GetGEPOperands(GEP1, GEP1Ops);
+      BasePtr2 = GetGEPOperands(GEP2, GEP2Ops);
 
       // If GetGEPOperands were able to fold to the same must-aliased pointer,
       // do the comparison.
@@ -482,7 +480,7 @@
     return MayAlias;
 
   SmallVector GEPOperands;
-  const Value *BasePtr = GetGEPOperands(V1, GEPOperands);
+  const Value *BasePtr = GetGEPOperands(GEP1, GEPOperands);
 
   AliasResult R = aliasCheck(BasePtr, ~0U, V2, V2Size);
   if (R != MustAlias)
@@ -719,8 +717,8 @@
     std::swap(V1, V2);
     std::swap(V1Size, V2Size);
   }
-  if (isa(V1))
-    return aliasGEP(V1, V1Size, V2, V2Size);
+  if (const GEPOperator *GV1 = dyn_cast(V1))
+    return aliasGEP(GV1, V1Size, V2, V2Size);
 
   if (isa(V2) && !isa(V1)) {
     std::swap(V1, V2);




From sabre at nondot.org  Wed Nov 25 20:13:03 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 02:13:03 -0000
Subject: [llvm-commits] [llvm] r89915 -
	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
Message-ID: <200911260213.nAQ2D3Q0024164@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 20:13:03 2009
New Revision: 89915

URL: http://llvm.org/viewvc/llvm-project?rev=89915&view=rev
Log:
Implement a new DecomposeGEPExpression method, which decomposes a GEP into a list of scaled offsets.  Use this to eliminate some previous ad-hoc code which was subtly broken (it assumed all Constant*'s were non-zero, but strange constant express could be zero).

Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89915&r1=89914&r2=89915&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Wed Nov 25 20:13:03 2009
@@ -405,6 +405,97 @@
   return NoAA::getModRefInfo(CS1, CS2);
 }
 
+/// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it
+/// into a base pointer with a constant offset and a number of scaled symbolic
+/// offsets.
+static const Value *DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
+               SmallVectorImpl > &VarIndices,
+                                           const TargetData *TD) {
+  const Value *OrigPtr = V;
+  BaseOffs = 0;
+  while (1) {
+    // See if this is a bitcast or GEP.
+    const Operator *Op = dyn_cast(V);
+    if (Op == 0) return V;
+    
+    if (Op->getOpcode() == Instruction::BitCast) {
+      V = Op->getOperand(0);
+      continue;
+    }
+    
+    if (Op->getOpcode() != Instruction::GetElementPtr)
+      return V;
+    
+    // Don't attempt to analyze GEPs over unsized objects.
+    if (!cast(Op->getOperand(0)->getType())
+          ->getElementType()->isSized())
+      return V;
+    
+    // Walk the indices of the GEP, accumulating them into BaseOff/VarIndices.
+    gep_type_iterator GTI = gep_type_begin(Op);
+    for (User::const_op_iterator I = next(Op->op_begin()), E = Op->op_end();
+         I != E; ++I) {
+      Value *Index = *I;
+      // Compute the (potentially symbolic) offset in bytes for this index.
+      if (const StructType *STy = dyn_cast(*GTI++)) {
+        // For a struct, add the member offset.
+        unsigned FieldNo = cast(Index)->getZExtValue();
+        if (FieldNo == 0) continue;
+        if (TD == 0) goto FailNoTD;
+        
+        BaseOffs += TD->getStructLayout(STy)->getElementOffset(FieldNo);
+        continue;
+      }
+      
+      // For an array/pointer, add the element offset, explicitly scaled.
+      if (ConstantInt *CIdx = dyn_cast(Index)) {
+        if (CIdx->isZero()) continue;
+        if (TD == 0) goto FailNoTD;
+        
+        BaseOffs += TD->getTypeAllocSize(*GTI)*CIdx->getSExtValue();
+        continue;
+      }
+      
+      if (TD == 0) goto FailNoTD;
+      
+      // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
+      uint64_t Scale = TD->getTypeAllocSize(*GTI);
+      
+      // If we already had an occurrance of this index variable, merge this
+      // scale into it.  For example, we want to handle:
+      //   A[x][x] -> x*16 + x*4 -> x*20
+      for (unsigned i = 0, e = VarIndices.size(); i != e; ++i) {
+        if (VarIndices[i].first == Index) {
+          Scale += VarIndices[i].second;
+          VarIndices.erase(VarIndices.begin()+i);
+          break;
+        }
+      }
+      
+      // Make sure that we have a scale that makes sense for this target's
+      // pointer size.
+      if (unsigned ShiftBits = 64-TD->getPointerSizeInBits()) {
+        Scale <<= ShiftBits;
+        Scale >>= ShiftBits;
+      }
+      
+      if (Scale)
+        VarIndices.push_back(std::make_pair(Index, Scale));
+    }
+    
+    // Analyze the base pointer next.
+    V = Op->getOperand(0);
+  }
+  
+  // If we don't have TD around, we can't analyze this index, remove all
+  // information we've found.
+FailNoTD:
+  VarIndices.clear();
+  BaseOffs = 0;
+  return OrigPtr;
+}
+
+
 /// aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP instruction
 /// against another pointer.  We know that V1 is a GEP, but we don't know
 /// anything about V2.
@@ -479,10 +570,12 @@
   if (V1Size == ~0U || V2Size == ~0U)
     return MayAlias;
 
-  SmallVector GEPOperands;
-  const Value *BasePtr = GetGEPOperands(GEP1, GEPOperands);
-
-  AliasResult R = aliasCheck(BasePtr, ~0U, V2, V2Size);
+  int64_t GEP1BaseOffset;
+  SmallVector, 4> VariableIndices;
+  const Value *GEP1BasePtr =
+    DecomposeGEPExpression(GEP1, GEP1BaseOffset, VariableIndices, TD);
+    
+  AliasResult R = aliasCheck(GEP1BasePtr, ~0U, V2, V2Size);
   if (R != MustAlias)
     // If V2 may alias GEP base pointer, conservatively returns MayAlias.
     // If V2 is known not to alias GEP base pointer, then the two values
@@ -491,48 +584,34 @@
     // with the first operand of the getelementptr".
     return R;
 
-  // If there is at least one non-zero constant index, we know they cannot
-  // alias.
-  bool ConstantFound = false;
-  bool AllZerosFound = true;
-  for (unsigned i = 0, e = GEPOperands.size(); i != e; ++i)
-    if (const Constant *C = dyn_cast(GEPOperands[i])) {
-      if (!C->isNullValue()) {
-        ConstantFound = true;
-        AllZerosFound = false;
-        break;
-      }
-    } else {
-      AllZerosFound = false;
-    }
-
   // If we have getelementptr , 0, 0, 0, 0, ... and V2 must aliases
   // the ptr, the end result is a must alias also.
-  if (AllZerosFound)
+  if (GEP1BaseOffset == 0 && VariableIndices.empty())
     return MustAlias;
 
-  if (ConstantFound) {
-    if (V2Size <= 1 && V1Size <= 1)  // Just pointer check?
+  // If we have a known constant offset, see if this offset is larger than the
+  // access size being queried.  If so, and if no variable indices can remove
+  // pieces of this constant, then we know we have a no-alias.  For example,
+  //   &A[100] != &A.
+  
+  // In order to handle cases like &A[100][i] where i is an out of range
+  // subscript, we have to ignore all constant offset pieces that are a multiple
+  // of a scaled index.  Do this by removing constant offsets that are a
+  // multiple of any of our variable indices.  This allows us to transform
+  // things like &A[i][1] because i has a stride of (e.g.) 8 bytes but the 1
+  // provides an offset of 4 bytes (assuming a <= 4 byte access).
+  for (unsigned i = 0, e = VariableIndices.size(); i != e && GEP1BaseOffset;++i)
+    if (int64_t RemovedOffset = GEP1BaseOffset/VariableIndices[i].second)
+      GEP1BaseOffset -= RemovedOffset*VariableIndices[i].second;
+  
+  // If our known offset is bigger than the access size, we know we don't have
+  // an alias.
+  if (GEP1BaseOffset) {
+    if (GEP1BaseOffset >= (int64_t)V2Size ||
+        GEP1BaseOffset <= -(int64_t)V1Size)
       return NoAlias;
-
-    // Otherwise we have to check to see that the distance is more than
-    // the size of the argument... build an index vector that is equal to
-    // the arguments provided, except substitute 0's for any variable
-    // indexes we find...
-    if (TD &&
-        cast(BasePtr->getType())->getElementType()->isSized()) {
-      for (unsigned i = 0; i != GEPOperands.size(); ++i)
-        if (!isa(GEPOperands[i]))
-          GEPOperands[i] = Constant::getNullValue(GEPOperands[i]->getType());
-      int64_t Offset = TD->getIndexedOffset(BasePtr->getType(),
-                                            &GEPOperands[0],
-                                            GEPOperands.size());
-
-      if (Offset >= (int64_t)V2Size || Offset <= -(int64_t)V1Size)
-        return NoAlias;
-    }
   }
-
+  
   return MayAlias;
 }
 
@@ -713,6 +792,8 @@
       return NoAlias;
   }
 
+  // FIXME: This isn't aggressively handling alias(GEP, PHI) for example: if the
+  // GEP can't simplify, we don't even look at the PHI cases.
   if (!isa(V1) && isa(V2)) {
     std::swap(V1, V2);
     std::swap(V1Size, V2Size);




From sabre at nondot.org  Wed Nov 25 20:14:59 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 02:14:59 -0000
Subject: [llvm-commits] [llvm] r89920 -
	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
Message-ID: <200911260214.nAQ2Ex4w024292@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 20:14:59 2009
New Revision: 89920

URL: http://llvm.org/viewvc/llvm-project?rev=89920&view=rev
Log:
Generalize DecomposeGEPExpression to exactly handle what Value::getUnderlyingObject does (when TD is around).  This allows us to avoid calling DecomposeGEPExpression unless the ultimate alias check we care about passes, speedup up BasicAA a bit.


Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89920&r1=89919&r2=89920&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Wed Nov 25 20:14:59 2009
@@ -20,6 +20,7 @@
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
+#include "llvm/GlobalAlias.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/Instructions.h"
 #include "llvm/IntrinsicInst.h"
@@ -220,7 +221,8 @@
     // aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP
     // instruction against another.
     AliasResult aliasGEP(const GEPOperator *V1, unsigned V1Size,
-                         const Value *V2, unsigned V2Size);
+                         const Value *V2, unsigned V2Size,
+                         const Value *UnderlyingV1, const Value *UnderlyingV2);
 
     // aliasPHI - Provide a bunch of ad-hoc rules to disambiguate a PHI
     // instruction against another.
@@ -408,40 +410,66 @@
 /// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it
 /// into a base pointer with a constant offset and a number of scaled symbolic
 /// offsets.
+///
+/// When TargetData is around, this function is capable of analyzing everything
+/// that Value::getUnderlyingObject() can look through.  When not, it just looks
+/// through pointer casts.
+///
+/// FIXME: Move this out to ValueTracking.cpp
+///
 static const Value *DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
                SmallVectorImpl > &VarIndices,
                                            const TargetData *TD) {
-  const Value *OrigPtr = V;
+  // FIXME: Should limit depth like getUnderlyingObject?
   BaseOffs = 0;
   while (1) {
     // See if this is a bitcast or GEP.
     const Operator *Op = dyn_cast(V);
-    if (Op == 0) return V;
+    if (Op == 0) {
+      // The only non-operator case we can handle are GlobalAliases.
+      if (const GlobalAlias *GA = dyn_cast(V)) {
+        if (!GA->mayBeOverridden()) {
+          V = GA->getAliasee();
+          continue;
+        }
+      }
+      return V;
+    }
     
     if (Op->getOpcode() == Instruction::BitCast) {
       V = Op->getOperand(0);
       continue;
     }
     
-    if (Op->getOpcode() != Instruction::GetElementPtr)
+    const GEPOperator *GEPOp = dyn_cast(Op);
+    if (GEPOp == 0)
       return V;
     
     // Don't attempt to analyze GEPs over unsized objects.
-    if (!cast(Op->getOperand(0)->getType())
+    if (!cast(GEPOp->getOperand(0)->getType())
           ->getElementType()->isSized())
       return V;
+
+    // If we are lacking TargetData information, we can't compute the offets of
+    // elements computed by GEPs.  However, we can handle bitcast equivalent
+    // GEPs.
+    if (!TD) {
+      if (!GEPOp->hasAllZeroIndices())
+        return V;
+      V = GEPOp->getOperand(0);
+      continue;
+    }
     
     // Walk the indices of the GEP, accumulating them into BaseOff/VarIndices.
-    gep_type_iterator GTI = gep_type_begin(Op);
-    for (User::const_op_iterator I = next(Op->op_begin()), E = Op->op_end();
-         I != E; ++I) {
+    gep_type_iterator GTI = gep_type_begin(GEPOp);
+    for (User::const_op_iterator I = next(GEPOp->op_begin()),
+         E = GEPOp->op_end(); I != E; ++I) {
       Value *Index = *I;
       // Compute the (potentially symbolic) offset in bytes for this index.
       if (const StructType *STy = dyn_cast(*GTI++)) {
         // For a struct, add the member offset.
         unsigned FieldNo = cast(Index)->getZExtValue();
         if (FieldNo == 0) continue;
-        if (TD == 0) goto FailNoTD;
         
         BaseOffs += TD->getStructLayout(STy)->getElementOffset(FieldNo);
         continue;
@@ -450,14 +478,10 @@
       // For an array/pointer, add the element offset, explicitly scaled.
       if (ConstantInt *CIdx = dyn_cast(Index)) {
         if (CIdx->isZero()) continue;
-        if (TD == 0) goto FailNoTD;
-        
         BaseOffs += TD->getTypeAllocSize(*GTI)*CIdx->getSExtValue();
         continue;
       }
       
-      if (TD == 0) goto FailNoTD;
-      
       // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
       uint64_t Scale = TD->getTypeAllocSize(*GTI);
       
@@ -484,25 +508,21 @@
     }
     
     // Analyze the base pointer next.
-    V = Op->getOperand(0);
+    V = GEPOp->getOperand(0);
   }
-  
-  // If we don't have TD around, we can't analyze this index, remove all
-  // information we've found.
-FailNoTD:
-  VarIndices.clear();
-  BaseOffs = 0;
-  return OrigPtr;
 }
 
 
 /// aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP instruction
 /// against another pointer.  We know that V1 is a GEP, but we don't know
-/// anything about V2.
+/// anything about V2.  UnderlyingV1 is GEP1->getUnderlyingObject(),
+/// UnderlyingV2 is the same for V2.
 ///
 AliasAnalysis::AliasResult
 BasicAliasAnalysis::aliasGEP(const GEPOperator *GEP1, unsigned V1Size,
-                             const Value *V2, unsigned V2Size) {
+                             const Value *V2, unsigned V2Size,
+                             const Value *UnderlyingV1,
+                             const Value *UnderlyingV2) {
   // If we have two gep instructions with must-alias'ing base pointers, figure
   // out if the indexes to the GEP tell us anything about the derived pointer.
   // Note that we also handle chains of getelementptr instructions as well as
@@ -567,15 +587,12 @@
   // instruction.  If one pointer is a GEP with a non-zero index of the other
   // pointer, we know they cannot alias.
   //
+  // FIXME: The check below only looks at the size of one of the pointers, not
+  // both, this may cause us to miss things.
   if (V1Size == ~0U || V2Size == ~0U)
     return MayAlias;
 
-  int64_t GEP1BaseOffset;
-  SmallVector, 4> VariableIndices;
-  const Value *GEP1BasePtr =
-    DecomposeGEPExpression(GEP1, GEP1BaseOffset, VariableIndices, TD);
-    
-  AliasResult R = aliasCheck(GEP1BasePtr, ~0U, V2, V2Size);
+  AliasResult R = aliasCheck(UnderlyingV1, ~0U, V2, V2Size);
   if (R != MustAlias)
     // If V2 may alias GEP base pointer, conservatively returns MayAlias.
     // If V2 is known not to alias GEP base pointer, then the two values
@@ -584,6 +601,20 @@
     // with the first operand of the getelementptr".
     return R;
 
+  int64_t GEP1BaseOffset;
+  SmallVector, 4> VariableIndices;
+  const Value *GEP1BasePtr =
+    DecomposeGEPExpression(GEP1, GEP1BaseOffset, VariableIndices, TD);
+  
+  // If DecomposeGEPExpression isn't able to look all the way through the
+  // addressing operation, we must not have TD and this is too complex for us
+  // to handle without it.
+  if (GEP1BasePtr != UnderlyingV1) {
+    assert(TD == 0 &&
+           "DecomposeGEPExpression and getUnderlyingObject disagree!");
+    return MayAlias;
+  }
+  
   // If we have getelementptr , 0, 0, 0, 0, ... and V2 must aliases
   // the ptr, the end result is a must alias also.
   if (GEP1BaseOffset == 0 && VariableIndices.empty())
@@ -797,9 +828,10 @@
   if (!isa(V1) && isa(V2)) {
     std::swap(V1, V2);
     std::swap(V1Size, V2Size);
+    std::swap(O1, O2);
   }
   if (const GEPOperator *GV1 = dyn_cast(V1))
-    return aliasGEP(GV1, V1Size, V2, V2Size);
+    return aliasGEP(GV1, V1Size, V2, V2Size, O1, O2);
 
   if (isa(V2) && !isa(V1)) {
     std::swap(V1, V2);




From sabre at nondot.org  Wed Nov 25 20:16:28 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 02:16:28 -0000
Subject: [llvm-commits] [llvm] r89921 -
	/llvm/trunk/test/Analysis/BasicAA/modref.ll
Message-ID: <200911260216.nAQ2GSXi024344@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 20:16:28 2009
New Revision: 89921

URL: http://llvm.org/viewvc/llvm-project?rev=89921&view=rev
Log:
add a new random feature test

Modified:
    llvm/trunk/test/Analysis/BasicAA/modref.ll

Modified: llvm/trunk/test/Analysis/BasicAA/modref.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/modref.ll?rev=89921&r1=89920&r2=89921&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/modref.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/modref.ll Wed Nov 25 20:16:28 2009
@@ -4,6 +4,7 @@
 declare void @llvm.memset.i32(i8*, i8, i32, i32)
 declare void @llvm.memset.i8(i8*, i8, i8, i32)
 declare void @llvm.memcpy.i8(i8*, i8*, i8, i32)
+declare void @llvm.memcpy.i32(i8*, i8*, i32, i32)
 declare void @llvm.lifetime.end(i64, i8* nocapture)
 
 declare void @external(i32*) 
@@ -94,7 +95,7 @@
 @G1 = external global i32
 @G2 = external global [4000 x i32]
 
-define i32 @test4(i8* %P, i8 %X) {
+define i32 @test4(i8* %P) {
   %tmp = load i32* @G1
   call void @llvm.memset.i32(i8* bitcast ([4000 x i32]* @G2 to i8*), i8 0, i32 4000, i32 1)
   %tmp2 = load i32* @G1
@@ -107,3 +108,18 @@
 ; CHECK: sub i32 %tmp, %tmp
 }
 
+; Verify that basicaa is handling variable length memcpy, knowing it doesn't
+; write to G1.
+define i32 @test5(i8* %P, i32 %Len) {
+  %tmp = load i32* @G1
+  call void @llvm.memcpy.i32(i8* bitcast ([4000 x i32]* @G2 to i8*), i8* bitcast (i32* @G1 to i8*), i32 %Len, i32 1)
+  %tmp2 = load i32* @G1
+  %sub = sub i32 %tmp2, %tmp
+  ret i32 %sub
+; CHECK: @test5
+; CHECK: load i32* @G
+; CHECK: memcpy.i32
+; CHECK-NOT: load
+; CHECK: sub i32 %tmp, %tmp
+}
+




From sabre at nondot.org  Wed Nov 25 20:17:34 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 02:17:34 -0000
Subject: [llvm-commits] [llvm] r89922 - in /llvm/trunk:
 lib/Analysis/BasicAliasAnalysis.cpp
 test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll
Message-ID: <200911260217.nAQ2HYJo024394@zion.cs.uiuc.edu>

Author: lattner
Date: Wed Nov 25 20:17:34 2009
New Revision: 89922

URL: http://llvm.org/viewvc/llvm-project?rev=89922&view=rev
Log:
Change the other half of aliasGEP (which handles GEP differencing) to use DecomposeGEPExpression.  This dramatically simplifies and shrinks the code by eliminating the horrible CheckGEPInstructions method, fixes a miscompilation (@test3) and makes the code more aggressive.  In particular, we now handle the @test4 case, which is reduced from the SmallPtrSet constructor.  Missing this caused us to emit a variable length memset instead of a fixed size one.


Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
    llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89922&r1=89921&r2=89922&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Wed Nov 25 20:17:34 2009
@@ -39,26 +39,6 @@
 // Useful predicates
 //===----------------------------------------------------------------------===//
 
-static const Value *GetGEPOperands(const GEPOperator *V, 
-                                   SmallVector &GEPOps) {
-  assert(GEPOps.empty() && "Expect empty list to populate!");
-  GEPOps.insert(GEPOps.end(), V->op_begin()+1, V->op_end());
-
-  // Accumulate all of the chained indexes into the operand array.
-  Value *BasePtr = V->getOperand(0);
-  while (1) {
-    V = dyn_cast(BasePtr);
-    if (V == 0) return BasePtr;
-    
-    // Don't handle folding arbitrary pointer offsets yet.
-    if (!isa(GEPOps[0]) || !cast(GEPOps[0])->isNullValue())
-      return BasePtr;
-    
-    GEPOps.erase(GEPOps.begin());   // Drop the zero index
-    GEPOps.insert(GEPOps.begin(), V->op_begin()+1, V->op_end());
-  }
-}
-
 /// isKnownNonNull - Return true if we know that the specified value is never
 /// null.
 static bool isKnownNonNull(const Value *V) {
@@ -235,15 +215,6 @@
 
     AliasResult aliasCheck(const Value *V1, unsigned V1Size,
                            const Value *V2, unsigned V2Size);
-
-    // CheckGEPInstructions - Check two GEP instructions with known
-    // must-aliasing base pointers.  This checks to see if the index expressions
-    // preclude the pointers from aliasing.
-    AliasResult
-    CheckGEPInstructions(const Type* BasePtr1Ty,
-                         Value **GEP1Ops, unsigned NumGEP1Ops, unsigned G1Size,
-                         const Type *BasePtr2Ty,
-                         Value **GEP2Ops, unsigned NumGEP2Ops, unsigned G2Size);
   };
 }  // End of anonymous namespace
 
@@ -418,7 +389,7 @@
 /// FIXME: Move this out to ValueTracking.cpp
 ///
 static const Value *DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
-               SmallVectorImpl > &VarIndices,
+                 SmallVectorImpl > &VarIndices,
                                            const TargetData *TD) {
   // FIXME: Should limit depth like getUnderlyingObject?
   BaseOffs = 0;
@@ -488,6 +459,7 @@
       // If we already had an occurrance of this index variable, merge this
       // scale into it.  For example, we want to handle:
       //   A[x][x] -> x*16 + x*4 -> x*20
+      // This also ensures that 'x' only appears in the index list once.
       for (unsigned i = 0, e = VarIndices.size(); i != e; ++i) {
         if (VarIndices[i].first == Index) {
           Scale += VarIndices[i].second;
@@ -512,6 +484,39 @@
   }
 }
 
+/// GetIndiceDifference - Dest and Src are the variable indices from two
+/// decomposed GetElementPtr instructions GEP1 and GEP2 which have common base
+/// pointers.  Subtract the GEP2 indices from GEP1 to find the symbolic
+/// difference between the two pointers. 
+static void GetIndiceDifference(
+                      SmallVectorImpl > &Dest,
+                const SmallVectorImpl > &Src) {
+  if (Src.empty()) return;
+
+  for (unsigned i = 0, e = Src.size(); i != e; ++i) {
+    const Value *V = Src[i].first;
+    int64_t Scale = Src[i].second;
+    
+    // Find V in Dest.  This is N^2, but pointer indices almost never have more
+    // than a few variable indexes.
+    for (unsigned j = 0, e = Dest.size(); j != e; ++j) {
+      if (Dest[j].first != V) continue;
+      
+      // If we found it, subtract off Scale V's from the entry in Dest.  If it
+      // goes to zero, remove the entry.
+      if (Dest[j].second != Scale)
+        Dest[j].second -= Scale;
+      else
+        Dest.erase(Dest.begin()+j);
+      Scale = 0;
+      break;
+    }
+    
+    // If we didn't consume this entry, add it to the end of the Dest list.
+    if (Scale)
+      Dest.push_back(std::make_pair(V, -Scale));
+  }
+}
 
 /// aliasGEP - Provide a bunch of ad-hoc rules to disambiguate a GEP instruction
 /// against another pointer.  We know that V1 is a GEP, but we don't know
@@ -523,101 +528,83 @@
                              const Value *V2, unsigned V2Size,
                              const Value *UnderlyingV1,
                              const Value *UnderlyingV2) {
+  int64_t GEP1BaseOffset;
+  SmallVector, 4> GEP1VariableIndices;
+
   // If we have two gep instructions with must-alias'ing base pointers, figure
   // out if the indexes to the GEP tell us anything about the derived pointer.
-  // Note that we also handle chains of getelementptr instructions as well as
-  // constant expression getelementptrs here.
-  //
   if (const GEPOperator *GEP2 = dyn_cast(V2)) {
-    // If V1 and V2 are identical GEPs, just recurse down on both of them.
-    // This allows us to analyze things like:
-    //   P = gep A, 0, i, 1
-    //   Q = gep B, 0, i, 1
-    // by just analyzing A and B.  This is even safe for variable indices.
-    if (GEP1->getType() == GEP2->getType() &&
-        GEP1->getNumOperands() == GEP2->getNumOperands() &&
-        GEP1->getOperand(0)->getType() == GEP2->getOperand(0)->getType() &&
-        // All operands are the same, ignoring the base.
-        std::equal(GEP1->op_begin()+1, GEP1->op_end(), GEP2->op_begin()+1))
-      return aliasCheck(GEP1->getOperand(0), V1Size,
-                        GEP2->getOperand(0), V2Size);
-    
-    // Drill down into the first non-gep value, to test for must-aliasing of
-    // the base pointers.
-    while (isa(GEP1->getOperand(0)) &&
-           GEP1->getOperand(1) ==
-           Constant::getNullValue(GEP1->getOperand(1)->getType()))
-      GEP1 = cast(GEP1->getOperand(0));
-    const Value *BasePtr1 = GEP1->getOperand(0);
-
-    while (isa(GEP2->getOperand(0)) &&
-           GEP2->getOperand(1) ==
-           Constant::getNullValue(GEP2->getOperand(1)->getType()))
-      GEP2 = cast(GEP2->getOperand(0));
-    const Value *BasePtr2 = GEP2->getOperand(0);
-
     // Do the base pointers alias?
-    AliasResult BaseAlias = aliasCheck(BasePtr1, ~0U, BasePtr2, ~0U);
-    if (BaseAlias == NoAlias) return NoAlias;
-    if (BaseAlias == MustAlias) {
-      // If the base pointers alias each other exactly, check to see if we can
-      // figure out anything about the resultant pointers, to try to prove
-      // non-aliasing.
-
-      // Collect all of the chained GEP operands together into one simple place
-      SmallVector GEP1Ops, GEP2Ops;
-      BasePtr1 = GetGEPOperands(GEP1, GEP1Ops);
-      BasePtr2 = GetGEPOperands(GEP2, GEP2Ops);
-
-      // If GetGEPOperands were able to fold to the same must-aliased pointer,
-      // do the comparison.
-      if (BasePtr1 == BasePtr2) {
-        AliasResult GAlias =
-          CheckGEPInstructions(BasePtr1->getType(),
-                               &GEP1Ops[0], GEP1Ops.size(), V1Size,
-                               BasePtr2->getType(),
-                               &GEP2Ops[0], GEP2Ops.size(), V2Size);
-        if (GAlias != MayAlias)
-          return GAlias;
-      }
+    AliasResult BaseAlias = aliasCheck(UnderlyingV1, ~0U, UnderlyingV2, ~0U);
+    
+    // If we get a No or May, then return it immediately, no amount of analysis
+    // will improve this situation.
+    if (BaseAlias != MustAlias) return BaseAlias;
+    
+    // Otherwise, we have a MustAlias.  Since the base pointers alias each other
+    // exactly, see if the computed offset from the common pointer tells us
+    // about the relation of the resulting pointer.
+    const Value *GEP1BasePtr =
+      DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices, TD);
+    
+    int64_t GEP2BaseOffset;
+    SmallVector, 4> GEP2VariableIndices;
+    const Value *GEP2BasePtr =
+      DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices, TD);
+    
+    // If DecomposeGEPExpression isn't able to look all the way through the
+    // addressing operation, we must not have TD and this is too complex for us
+    // to handle without it.
+    if (GEP1BasePtr != UnderlyingV1 || GEP2BasePtr != UnderlyingV2) {
+      assert(TD == 0 &&
+             "DecomposeGEPExpression and getUnderlyingObject disagree!");
+      return MayAlias;
     }
-  }
-
-  // Check to see if these two pointers are related by a getelementptr
-  // instruction.  If one pointer is a GEP with a non-zero index of the other
-  // pointer, we know they cannot alias.
-  //
-  // FIXME: The check below only looks at the size of one of the pointers, not
-  // both, this may cause us to miss things.
-  if (V1Size == ~0U || V2Size == ~0U)
-    return MayAlias;
-
-  AliasResult R = aliasCheck(UnderlyingV1, ~0U, V2, V2Size);
-  if (R != MustAlias)
-    // If V2 may alias GEP base pointer, conservatively returns MayAlias.
-    // If V2 is known not to alias GEP base pointer, then the two values
-    // cannot alias per GEP semantics: "A pointer value formed from a
-    // getelementptr instruction is associated with the addresses associated
-    // with the first operand of the getelementptr".
-    return R;
+    
+    // Subtract the GEP2 pointer from the GEP1 pointer to find out their
+    // symbolic difference.
+    GEP1BaseOffset -= GEP2BaseOffset;
+    GetIndiceDifference(GEP1VariableIndices, GEP2VariableIndices);
+    
+  } else {
+    // Check to see if these two pointers are related by the getelementptr
+    // instruction.  If one pointer is a GEP with a non-zero index of the other
+    // pointer, we know they cannot alias.
+    //
+    // FIXME: The check below only looks at the size of one of the pointers, not
+    // both, this may cause us to miss things.
+    if (V1Size == ~0U || V2Size == ~0U)
+      return MayAlias;
 
-  int64_t GEP1BaseOffset;
-  SmallVector, 4> VariableIndices;
-  const Value *GEP1BasePtr =
-    DecomposeGEPExpression(GEP1, GEP1BaseOffset, VariableIndices, TD);
-  
-  // If DecomposeGEPExpression isn't able to look all the way through the
-  // addressing operation, we must not have TD and this is too complex for us
-  // to handle without it.
-  if (GEP1BasePtr != UnderlyingV1) {
-    assert(TD == 0 &&
-           "DecomposeGEPExpression and getUnderlyingObject disagree!");
-    return MayAlias;
+    AliasResult R = aliasCheck(UnderlyingV1, ~0U, V2, V2Size);
+    if (R != MustAlias)
+      // If V2 may alias GEP base pointer, conservatively returns MayAlias.
+      // If V2 is known not to alias GEP base pointer, then the two values
+      // cannot alias per GEP semantics: "A pointer value formed from a
+      // getelementptr instruction is associated with the addresses associated
+      // with the first operand of the getelementptr".
+      return R;
+
+    const Value *GEP1BasePtr =
+      DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices, TD);
+    
+    // If DecomposeGEPExpression isn't able to look all the way through the
+    // addressing operation, we must not have TD and this is too complex for us
+    // to handle without it.
+    if (GEP1BasePtr != UnderlyingV1) {
+      assert(TD == 0 &&
+             "DecomposeGEPExpression and getUnderlyingObject disagree!");
+      return MayAlias;
+    }
   }
   
-  // If we have getelementptr , 0, 0, 0, 0, ... and V2 must aliases
-  // the ptr, the end result is a must alias also.
-  if (GEP1BaseOffset == 0 && VariableIndices.empty())
+  // In the two GEP Case, if there is no difference in the offsets of the
+  // computed pointers, the resultant pointers are a must alias.  This
+  // hapens when we have two lexically identical GEP's (for example).
+  //
+  // In the other case, if we have getelementptr , 0, 0, 0, 0, ... and V2
+  // must aliases the GEP, the end result is a must alias also.
+  if (GEP1BaseOffset == 0 && GEP1VariableIndices.empty())
     return MustAlias;
 
   // If we have a known constant offset, see if this offset is larger than the
@@ -631,9 +618,10 @@
   // multiple of any of our variable indices.  This allows us to transform
   // things like &A[i][1] because i has a stride of (e.g.) 8 bytes but the 1
   // provides an offset of 4 bytes (assuming a <= 4 byte access).
-  for (unsigned i = 0, e = VariableIndices.size(); i != e && GEP1BaseOffset;++i)
-    if (int64_t RemovedOffset = GEP1BaseOffset/VariableIndices[i].second)
-      GEP1BaseOffset -= RemovedOffset*VariableIndices[i].second;
+  for (unsigned i = 0, e = GEP1VariableIndices.size();
+       i != e && GEP1BaseOffset;++i)
+    if (int64_t RemovedOffset = GEP1BaseOffset/GEP1VariableIndices[i].second)
+      GEP1BaseOffset -= RemovedOffset*GEP1VariableIndices[i].second;
   
   // If our known offset is bigger than the access size, we know we don't have
   // an alias.
@@ -850,351 +838,5 @@
   return MayAlias;
 }
 
-// This function is used to determine if the indices of two GEP instructions are
-// equal. V1 and V2 are the indices.
-static bool IndexOperandsEqual(Value *V1, Value *V2) {
-  if (V1->getType() == V2->getType())
-    return V1 == V2;
-  if (Constant *C1 = dyn_cast(V1))
-    if (Constant *C2 = dyn_cast(V2)) {
-      // Sign extend the constants to long types, if necessary
-      if (C1->getType() != Type::getInt64Ty(C1->getContext()))
-        C1 = ConstantExpr::getSExt(C1, Type::getInt64Ty(C1->getContext()));
-      if (C2->getType() != Type::getInt64Ty(C1->getContext())) 
-        C2 = ConstantExpr::getSExt(C2, Type::getInt64Ty(C1->getContext()));
-      return C1 == C2;
-    }
-  return false;
-}
-
-/// CheckGEPInstructions - Check two GEP instructions with known must-aliasing
-/// base pointers.  This checks to see if the index expressions preclude the
-/// pointers from aliasing.
-AliasAnalysis::AliasResult 
-BasicAliasAnalysis::CheckGEPInstructions(
-  const Type* BasePtr1Ty, Value **GEP1Ops, unsigned NumGEP1Ops, unsigned G1S,
-  const Type *BasePtr2Ty, Value **GEP2Ops, unsigned NumGEP2Ops, unsigned G2S) {
-  // We currently can't handle the case when the base pointers have different
-  // primitive types.  Since this is uncommon anyway, we are happy being
-  // extremely conservative.
-  if (BasePtr1Ty != BasePtr2Ty)
-    return MayAlias;
-
-  const PointerType *GEPPointerTy = cast(BasePtr1Ty);
-
-  // Find the (possibly empty) initial sequence of equal values... which are not
-  // necessarily constants.
-  unsigned NumGEP1Operands = NumGEP1Ops, NumGEP2Operands = NumGEP2Ops;
-  unsigned MinOperands = std::min(NumGEP1Operands, NumGEP2Operands);
-  unsigned MaxOperands = std::max(NumGEP1Operands, NumGEP2Operands);
-  unsigned UnequalOper = 0;
-  while (UnequalOper != MinOperands &&
-         IndexOperandsEqual(GEP1Ops[UnequalOper], GEP2Ops[UnequalOper])) {
-    // Advance through the type as we go...
-    ++UnequalOper;
-    if (const CompositeType *CT = dyn_cast(BasePtr1Ty))
-      BasePtr1Ty = CT->getTypeAtIndex(GEP1Ops[UnequalOper-1]);
-    else {
-      // If all operands equal each other, then the derived pointers must
-      // alias each other...
-      BasePtr1Ty = 0;
-      assert(UnequalOper == NumGEP1Operands && UnequalOper == NumGEP2Operands &&
-             "Ran out of type nesting, but not out of operands?");
-      return MustAlias;
-    }
-  }
-
-  // If we have seen all constant operands, and run out of indexes on one of the
-  // getelementptrs, check to see if the tail of the leftover one is all zeros.
-  // If so, return mustalias.
-  if (UnequalOper == MinOperands) {
-    if (NumGEP1Ops < NumGEP2Ops) {
-      std::swap(GEP1Ops, GEP2Ops);
-      std::swap(NumGEP1Ops, NumGEP2Ops);
-    }
-
-    bool AllAreZeros = true;
-    for (unsigned i = UnequalOper; i != MaxOperands; ++i)
-      if (!isa(GEP1Ops[i]) ||
-          !cast(GEP1Ops[i])->isNullValue()) {
-        AllAreZeros = false;
-        break;
-      }
-    if (AllAreZeros) return MustAlias;
-  }
-
-
-  // So now we know that the indexes derived from the base pointers,
-  // which are known to alias, are different.  We can still determine a
-  // no-alias result if there are differing constant pairs in the index
-  // chain.  For example:
-  //        A[i][0] != A[j][1] iff (&A[0][1]-&A[0][0] >= std::max(G1S, G2S))
-  //
-  // We have to be careful here about array accesses.  In particular, consider:
-  //        A[1][0] vs A[0][i]
-  // In this case, we don't *know* that the array will be accessed in bounds:
-  // the index could even be negative.  Because of this, we have to
-  // conservatively *give up* and return may alias.  We disregard differing
-  // array subscripts that are followed by a variable index without going
-  // through a struct.
-  //
-  unsigned SizeMax = std::max(G1S, G2S);
-  if (SizeMax == ~0U) return MayAlias; // Avoid frivolous work.
-
-  // Scan for the first operand that is constant and unequal in the
-  // two getelementptrs...
-  unsigned FirstConstantOper = UnequalOper;
-  for (; FirstConstantOper != MinOperands; ++FirstConstantOper) {
-    const Value *G1Oper = GEP1Ops[FirstConstantOper];
-    const Value *G2Oper = GEP2Ops[FirstConstantOper];
-
-    if (G1Oper != G2Oper)   // Found non-equal constant indexes...
-      if (Constant *G1OC = dyn_cast(const_cast(G1Oper)))
-        if (Constant *G2OC = dyn_cast(const_cast(G2Oper))){
-          if (G1OC->getType() != G2OC->getType()) {
-            // Sign extend both operands to long.
-            const Type *Int64Ty = Type::getInt64Ty(G1OC->getContext());
-            if (G1OC->getType() != Int64Ty)
-              G1OC = ConstantExpr::getSExt(G1OC, Int64Ty);
-            if (G2OC->getType() != Int64Ty) 
-              G2OC = ConstantExpr::getSExt(G2OC, Int64Ty);
-            GEP1Ops[FirstConstantOper] = G1OC;
-            GEP2Ops[FirstConstantOper] = G2OC;
-          }
-          
-          if (G1OC != G2OC) {
-            // Handle the "be careful" case above: if this is an array/vector
-            // subscript, scan for a subsequent variable array index.
-            if (const SequentialType *STy =
-                  dyn_cast(BasePtr1Ty)) {
-              const Type *NextTy = STy;
-              bool isBadCase = false;
-              
-              for (unsigned Idx = FirstConstantOper;
-                   Idx != MinOperands && isa(NextTy); ++Idx) {
-                const Value *V1 = GEP1Ops[Idx], *V2 = GEP2Ops[Idx];
-                if (!isa(V1) || !isa(V2)) {
-                  isBadCase = true;
-                  break;
-                }
-                // If the array is indexed beyond the bounds of the static type
-                // at this level, it will also fall into the "be careful" case.
-                // It would theoretically be possible to analyze these cases,
-                // but for now just be conservatively correct.
-                if (const ArrayType *ATy = dyn_cast(STy))
-                  if (cast(G1OC)->getZExtValue() >=
-                        ATy->getNumElements() ||
-                      cast(G2OC)->getZExtValue() >=
-                        ATy->getNumElements()) {
-                    isBadCase = true;
-                    break;
-                  }
-                if (const VectorType *VTy = dyn_cast(STy))
-                  if (cast(G1OC)->getZExtValue() >=
-                        VTy->getNumElements() ||
-                      cast(G2OC)->getZExtValue() >=
-                        VTy->getNumElements()) {
-                    isBadCase = true;
-                    break;
-                  }
-                STy = cast(NextTy);
-                NextTy = cast(NextTy)->getElementType();
-              }
-              
-              if (isBadCase) G1OC = 0;
-            }
-
-            // Make sure they are comparable (ie, not constant expressions), and
-            // make sure the GEP with the smaller leading constant is GEP1.
-            if (G1OC) {
-              Constant *Compare = ConstantExpr::getICmp(ICmpInst::ICMP_SGT, 
-                                                        G1OC, G2OC);
-              if (ConstantInt *CV = dyn_cast(Compare)) {
-                if (CV->getZExtValue()) {  // If they are comparable and G2 > G1
-                  std::swap(GEP1Ops, GEP2Ops);  // Make GEP1 < GEP2
-                  std::swap(NumGEP1Ops, NumGEP2Ops);
-                }
-                break;
-              }
-            }
-          }
-        }
-    BasePtr1Ty = cast(BasePtr1Ty)->getTypeAtIndex(G1Oper);
-  }
-
-  // No shared constant operands, and we ran out of common operands.  At this
-  // point, the GEP instructions have run through all of their operands, and we
-  // haven't found evidence that there are any deltas between the GEP's.
-  // However, one GEP may have more operands than the other.  If this is the
-  // case, there may still be hope.  Check this now.
-  if (FirstConstantOper == MinOperands) {
-    // Without TargetData, we won't know what the offsets are.
-    if (!TD)
-      return MayAlias;
-
-    // Make GEP1Ops be the longer one if there is a longer one.
-    if (NumGEP1Ops < NumGEP2Ops) {
-      std::swap(GEP1Ops, GEP2Ops);
-      std::swap(NumGEP1Ops, NumGEP2Ops);
-    }
-
-    // Is there anything to check?
-    if (NumGEP1Ops > MinOperands) {
-      for (unsigned i = FirstConstantOper; i != MaxOperands; ++i)
-        if (isa(GEP1Ops[i]) && 
-            !cast(GEP1Ops[i])->isZero()) {
-          // Yup, there's a constant in the tail.  Set all variables to
-          // constants in the GEP instruction to make it suitable for
-          // TargetData::getIndexedOffset.
-          for (i = 0; i != MaxOperands; ++i)
-            if (!isa(GEP1Ops[i]))
-              GEP1Ops[i] = Constant::getNullValue(GEP1Ops[i]->getType());
-          // Okay, now get the offset.  This is the relative offset for the full
-          // instruction.
-          int64_t Offset1 = TD->getIndexedOffset(GEPPointerTy, GEP1Ops,
-                                                 NumGEP1Ops);
-
-          // Now check without any constants at the end.
-          int64_t Offset2 = TD->getIndexedOffset(GEPPointerTy, GEP1Ops,
-                                                 MinOperands);
-
-          // Make sure we compare the absolute difference.
-          if (Offset1 > Offset2)
-            std::swap(Offset1, Offset2);
-
-          // If the tail provided a bit enough offset, return noalias!
-          if ((uint64_t)(Offset2-Offset1) >= SizeMax)
-            return NoAlias;
-          // Otherwise break - we don't look for another constant in the tail.
-          break;
-        }
-    }
-
-    // Couldn't find anything useful.
-    return MayAlias;
-  }
-
-  // If there are non-equal constants arguments, then we can figure
-  // out a minimum known delta between the two index expressions... at
-  // this point we know that the first constant index of GEP1 is less
-  // than the first constant index of GEP2.
-
-  // Advance BasePtr[12]Ty over this first differing constant operand.
-  BasePtr2Ty = cast(BasePtr1Ty)->
-      getTypeAtIndex(GEP2Ops[FirstConstantOper]);
-  BasePtr1Ty = cast(BasePtr1Ty)->
-      getTypeAtIndex(GEP1Ops[FirstConstantOper]);
-
-  // We are going to be using TargetData::getIndexedOffset to determine the
-  // offset that each of the GEP's is reaching.  To do this, we have to convert
-  // all variable references to constant references.  To do this, we convert the
-  // initial sequence of array subscripts into constant zeros to start with.
-  const Type *ZeroIdxTy = GEPPointerTy;
-  for (unsigned i = 0; i != FirstConstantOper; ++i) {
-    if (!isa(ZeroIdxTy))
-      GEP1Ops[i] = GEP2Ops[i] = 
-              Constant::getNullValue(Type::getInt32Ty(ZeroIdxTy->getContext()));
-
-    if (const CompositeType *CT = dyn_cast(ZeroIdxTy))
-      ZeroIdxTy = CT->getTypeAtIndex(GEP1Ops[i]);
-  }
-
-  // We know that GEP1Ops[FirstConstantOper] & GEP2Ops[FirstConstantOper] are ok
-
-  // Loop over the rest of the operands...
-  for (unsigned i = FirstConstantOper+1; i != MaxOperands; ++i) {
-    const Value *Op1 = i < NumGEP1Ops ? GEP1Ops[i] : 0;
-    const Value *Op2 = i < NumGEP2Ops ? GEP2Ops[i] : 0;
-    // If they are equal, use a zero index...
-    if (Op1 == Op2 && BasePtr1Ty == BasePtr2Ty) {
-      if (!isa(Op1))
-        GEP1Ops[i] = GEP2Ops[i] = Constant::getNullValue(Op1->getType());
-      // Otherwise, just keep the constants we have.
-    } else {
-      if (Op1) {
-        if (const ConstantInt *Op1C = dyn_cast(Op1)) {
-          // If this is an array index, make sure the array element is in range.
-          if (const ArrayType *AT = dyn_cast(BasePtr1Ty)) {
-            if (Op1C->getZExtValue() >= AT->getNumElements())
-              return MayAlias;  // Be conservative with out-of-range accesses
-          } else if (const VectorType *VT = dyn_cast(BasePtr1Ty)) {
-            if (Op1C->getZExtValue() >= VT->getNumElements())
-              return MayAlias;  // Be conservative with out-of-range accesses
-          }
-          
-        } else {
-          // GEP1 is known to produce a value less than GEP2.  To be
-          // conservatively correct, we must assume the largest possible
-          // constant is used in this position.  This cannot be the initial
-          // index to the GEP instructions (because we know we have at least one
-          // element before this one with the different constant arguments), so
-          // we know that the current index must be into either a struct or
-          // array.  Because we know it's not constant, this cannot be a
-          // structure index.  Because of this, we can calculate the maximum
-          // value possible.
-          //
-          if (const ArrayType *AT = dyn_cast(BasePtr1Ty))
-            GEP1Ops[i] =
-                  ConstantInt::get(Type::getInt64Ty(AT->getContext()), 
-                                   AT->getNumElements()-1);
-          else if (const VectorType *VT = dyn_cast(BasePtr1Ty))
-            GEP1Ops[i] = 
-                  ConstantInt::get(Type::getInt64Ty(VT->getContext()),
-                                   VT->getNumElements()-1);
-        }
-      }
-
-      if (Op2) {
-        if (const ConstantInt *Op2C = dyn_cast(Op2)) {
-          // If this is an array index, make sure the array element is in range.
-          if (const ArrayType *AT = dyn_cast(BasePtr2Ty)) {
-            if (Op2C->getZExtValue() >= AT->getNumElements())
-              return MayAlias;  // Be conservative with out-of-range accesses
-          } else if (const VectorType *VT = dyn_cast(BasePtr2Ty)) {
-            if (Op2C->getZExtValue() >= VT->getNumElements())
-              return MayAlias;  // Be conservative with out-of-range accesses
-          }
-        } else {  // Conservatively assume the minimum value for this index
-          GEP2Ops[i] = Constant::getNullValue(Op2->getType());
-        }
-      }
-    }
-
-    if (BasePtr1Ty && Op1) {
-      if (const CompositeType *CT = dyn_cast(BasePtr1Ty))
-        BasePtr1Ty = CT->getTypeAtIndex(GEP1Ops[i]);
-      else
-        BasePtr1Ty = 0;
-    }
-
-    if (BasePtr2Ty && Op2) {
-      if (const CompositeType *CT = dyn_cast(BasePtr2Ty))
-        BasePtr2Ty = CT->getTypeAtIndex(GEP2Ops[i]);
-      else
-        BasePtr2Ty = 0;
-    }
-  }
-
-  if (TD && GEPPointerTy->getElementType()->isSized()) {
-    int64_t Offset1 =
-      TD->getIndexedOffset(GEPPointerTy, GEP1Ops, NumGEP1Ops);
-    int64_t Offset2 = 
-      TD->getIndexedOffset(GEPPointerTy, GEP2Ops, NumGEP2Ops);
-    assert(Offset1 != Offset2 &&
-           "There is at least one different constant here!");
-    
-    // Make sure we compare the absolute difference.
-    if (Offset1 > Offset2)
-      std::swap(Offset1, Offset2);
-    
-    if ((uint64_t)(Offset2-Offset1) >= SizeMax) {
-      //cerr << "Determined that these two GEP's don't alias ["
-      //     << SizeMax << " bytes]: \n" << *GEP1 << *GEP2;
-      return NoAlias;
-    }
-  }
-  return MayAlias;
-}
-
 // Make sure that anything that uses AliasAnalysis pulls in this file.
 DEFINING_FILE_FOR(BasicAliasAnalysis)

Modified: llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll?rev=89922&r1=89921&r2=89922&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll Wed Nov 25 20:17:34 2009
@@ -1,7 +1,9 @@
-; RUN: opt < %s -aa-eval -print-all-alias-modref-info -disable-output |& grep {MustAlias:.*%R,.*%r}
+; RUN: opt < %s -gvn -instcombine -S |& FileCheck %s
 ; Make sure that basicaa thinks R and r are must aliases.
 
-define i32 @test(i8 * %P) {
+target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
+
+define i32 @test1(i8 * %P) {
 entry:
 	%Q = bitcast i8* %P to {i32, i32}*
 	%R = getelementptr {i32, i32}* %Q, i32 0, i32 1
@@ -13,4 +15,59 @@
 
 	%t = sub i32 %S, %s
 	ret i32 %t
+; CHECK: @test1
+; CHECK: ret i32 0
+}
+
+define i32 @test2(i8 * %P) {
+entry:
+	%Q = bitcast i8* %P to {i32, i32, i32}*
+	%R = getelementptr {i32, i32, i32}* %Q, i32 0, i32 1
+	%S = load i32* %R
+
+	%r = getelementptr {i32, i32, i32}* %Q, i32 0, i32 2
+  store i32 42, i32* %r
+
+	%s = load i32* %R
+
+	%t = sub i32 %S, %s
+	ret i32 %t
+; CHECK: @test2
+; CHECK: ret i32 0
+}
+
+
+; This was a miscompilation.
+define i32 @test3({float, {i32, i32, i32}}* %P) {
+entry:
+  %P2 = getelementptr {float, {i32, i32, i32}}* %P, i32 0, i32 1
+	%R = getelementptr {i32, i32, i32}* %P2, i32 0, i32 1
+	%S = load i32* %R
+
+	%r = getelementptr {i32, i32, i32}* %P2, i32 0, i32 2
+  store i32 42, i32* %r
+
+	%s = load i32* %R
+
+	%t = sub i32 %S, %s
+	ret i32 %t
+; CHECK: @test3
+; CHECK: ret i32 0
+}
+
+
+;; This is reduced from the SmallPtrSet constructor.
+%SmallPtrSetImpl = type { i8**, i32, i32, i32, [1 x i8*] }
+%SmallPtrSet64 = type { %SmallPtrSetImpl, [64 x i8*] }
+
+define i32 @test4(%SmallPtrSet64* %P) {
+entry:
+  %tmp2 = getelementptr inbounds %SmallPtrSet64* %P, i64 0, i32 0, i32 1
+  store i32 64, i32* %tmp2, align 8
+  %tmp3 = getelementptr inbounds %SmallPtrSet64* %P, i64 0, i32 0, i32 4, i64 64
+  store i8* null, i8** %tmp3, align 8
+  %tmp4 = load i32* %tmp2, align 8
+	ret i32 %tmp4
+; CHECK: @test4
+; CHECK: ret i32 64
 }




From clattner at apple.com  Wed Nov 25 20:21:04 2009
From: clattner at apple.com (Chris Lattner)
Date: Wed, 25 Nov 2009 18:21:04 -0800
Subject: [llvm-commits] [llvm] r89663
	-	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <4B0AF85E.4090709@free.fr>
References: <200911231644.nANGiiSl030197@zion.cs.uiuc.edu>
	<4B0AF85E.4090709@free.fr>
Message-ID: <0D454083-C03A-4B5D-9D2B-055F3EA610E0@apple.com>


On Nov 23, 2009, at 1:02 PM, Duncan Sands wrote:

> Hi Chris, I tried to understand what you are doing here but failed,
> feel like explaining some more?  I don't see how capture/nocapture
> is relevant here...

The basic idea is that this is trying to decide whether a call could mod/ref a non-escaping alloca.  If the alloca is passed as an argument to a call, then it will be escaping, unless the call argument is marked nocapture.  Because of this, we only need to check nocapture arguments.

-Chris




From clattner at apple.com  Wed Nov 25 20:33:27 2009
From: clattner at apple.com (Chris Lattner)
Date: Wed, 25 Nov 2009 18:33:27 -0800
Subject: [llvm-commits] [llvm] r89877 -
	/llvm/trunk/lib/Target/PowerPC/PPCInstrInfo.h
In-Reply-To: <20AB4AAE-93CF-46FB-8788-F53C1107E490@apple.com>
References: <200911251957.nAPJvEma011366@zion.cs.uiuc.edu>
	<6CB2B61C-657A-4260-9717-1267F605009E@apple.com>
	<20AB4AAE-93CF-46FB-8788-F53C1107E490@apple.com>
Message-ID: <06AC226D-4505-40A4-93EA-18A39047A994@apple.com>


On Nov 25, 2009, at 4:45 PM, Bob Wilson wrote:

> 
> On Nov 25, 2009, at 4:18 PM, Chris Lattner wrote:
> 
>> 
>> On Nov 25, 2009, at 11:57 AM, Bob Wilson wrote:
>> 
>>> Author: bwilson
>>> Date: Wed Nov 25 13:57:14 2009
>>> New Revision: 89877
>>> 
>>> URL: http://llvm.org/viewvc/llvm-project?rev=89877&view=rev
>>> Log:
>>> Tail duplicate indirect branches for PowerPC, too.
>>> With the testcase for pr3120, the "threaded interpreter" runtime decreases
>>> from 1788 to 1413 with this change.
>> 
>> Very nice Bob!  Silly question: should isProfitableToDuplicateIndirectBranch default to true?  That would let targets opt out if it is not beneficial and would save a small bit of code size.
> 
> Not silly at all.... I had the same thought.
> 
> Having spent more time looking at the effects of this transformation, I have a different proposal that I think you might like.  Let's just get rid of that target hook altogether.  ;-)

You are very persuasive, I'm convinced!!

> This special treatment of indirect branches for tail duplication just doesn't kick in very often.  I was being cautious about blowing up code size, but it doesn't happen often enough to matter.  I also wasn't sure if this would matter on anything besides ARM Cortex processors but now we know that it does.

Right.  Indirect gotos just aren't that common.

> On a related note, Evan suggested that we be more aggressive about this with -Os, and I think that's also a good idea.
> 
> Unless someone objects, I'll go ahead with those changes sometime soon.

Sounds great, thanks Bob!

-Chris
 


From espindola at google.com  Wed Nov 25 22:18:11 2009
From: espindola at google.com (Rafael Espindola)
Date: Wed, 25 Nov 2009 23:18:11 -0500
Subject: [llvm-commits] [llvm-gcc-4.2] r86892 -
	/llvm-gcc-4.2/trunk/gcc/llvm-abi.h
In-Reply-To: <35038F04-ED7A-4D60-ABD5-0CADD56536D2@apple.com>
References: <200911112305.nABN5jd1010544@zion.cs.uiuc.edu>
	<860AC9D2-EA76-476F-9B1D-DA0E7BB0A651@apple.com>
	<35038F04-ED7A-4D60-ABD5-0CADD56536D2@apple.com>
Message-ID: <38a0d8450911252018p3930f82cg43ebe9f6ded326c0@mail.gmail.com>

2009/11/12 Bob Wilson :
> It's breaking something on ARM, too. ?I'll revert it for now.
>
> I did run gcc's compat tests, but not on PPC. ?I guess I'll need to do
> that.

Can you try the patch I attached to the bug?

Is there an easy way to get just a pass/fail list from the test-suite?
I found the testcase in the bug report by doing

gmake TEST=nightly report report.html

in the SingleSource directory both with and without r86892 and
searching for FAIL in the output.

Cheers,
-- 
Rafael ?vila de Esp?ndola



From baldrick at free.fr  Thu Nov 26 03:03:48 2009
From: baldrick at free.fr (Duncan Sands)
Date: Thu, 26 Nov 2009 10:03:48 +0100
Subject: [llvm-commits] [llvm] r89663
	-	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <0D454083-C03A-4B5D-9D2B-055F3EA610E0@apple.com>
References: <200911231644.nANGiiSl030197@zion.cs.uiuc.edu>
	<4B0AF85E.4090709@free.fr>
	<0D454083-C03A-4B5D-9D2B-055F3EA610E0@apple.com>
Message-ID: <4B0E4474.5030209@free.fr>

Hi Chris,

> The basic idea is that this is trying to decide whether a call could mod/ref a non-escaping alloca.  If the alloca is passed as an argument to a call, then it will be escaping, unless the call argument is marked nocapture.  Because of this, we only need to check nocapture arguments.

I see, that makes sense.  I noticed that there is no logic about readonly calls
in this routine - is this handled elsewhere?

Ciao,

Duncan.


From clattner at apple.com  Thu Nov 26 09:06:29 2009
From: clattner at apple.com (Chris Lattner)
Date: Thu, 26 Nov 2009 07:06:29 -0800
Subject: [llvm-commits] [llvm] r89663 -
	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <4B0E4474.5030209@free.fr>
References: <200911231644.nANGiiSl030197@zion.cs.uiuc.edu>
	<4B0AF85E.4090709@free.fr>
	<0D454083-C03A-4B5D-9D2B-055F3EA610E0@apple.com>
	<4B0E4474.5030209@free.fr>
Message-ID: <63DB33A4-C113-40BB-8EFA-08BCC0D4439D@apple.com>


On Nov 26, 2009, at 1:03 AM, Duncan Sands wrote:

> Hi Chris,
> 
>> The basic idea is that this is trying to decide whether a call could mod/ref a non-escaping alloca.  If the alloca is passed as an argument to a call, then it will be escaping, unless the call argument is marked nocapture.  Because of this, we only need to check nocapture arguments.
> 
> I see, that makes sense.  I noticed that there is no logic about readonly calls
> in this routine - is this handled elsewhere?

Yep, the code falls back to AliasAnalysis::getModRefInfo if it can't do any better.  That code handles "accesses arguments", readonly, etc.

-Chris


From sabre at nondot.org  Thu Nov 26 10:08:42 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 16:08:42 -0000
Subject: [llvm-commits] [llvm] r89950 - in
 /llvm/trunk/test/Analysis/BasicAA: 2008-12-09-GEP-IndicesAlias.ll
 gep-alias.ll
Message-ID: <200911261608.nAQG8gXV002962@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 10:08:41 2009
New Revision: 89950

URL: http://llvm.org/viewvc/llvm-project?rev=89950&view=rev
Log:
rename test

Added:
    llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
      - copied unchanged from r89948, llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll
Removed:
    llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll

Removed: llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll?rev=89949&view=auto

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/2008-12-09-GEP-IndicesAlias.ll (removed)
@@ -1,73 +0,0 @@
-; RUN: opt < %s -gvn -instcombine -S |& FileCheck %s
-; Make sure that basicaa thinks R and r are must aliases.
-
-target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
-
-define i32 @test1(i8 * %P) {
-entry:
-	%Q = bitcast i8* %P to {i32, i32}*
-	%R = getelementptr {i32, i32}* %Q, i32 0, i32 1
-	%S = load i32* %R
-
-	%q = bitcast i8* %P to {i32, i32}*
-	%r = getelementptr {i32, i32}* %q, i32 0, i32 1
-	%s = load i32* %r
-
-	%t = sub i32 %S, %s
-	ret i32 %t
-; CHECK: @test1
-; CHECK: ret i32 0
-}
-
-define i32 @test2(i8 * %P) {
-entry:
-	%Q = bitcast i8* %P to {i32, i32, i32}*
-	%R = getelementptr {i32, i32, i32}* %Q, i32 0, i32 1
-	%S = load i32* %R
-
-	%r = getelementptr {i32, i32, i32}* %Q, i32 0, i32 2
-  store i32 42, i32* %r
-
-	%s = load i32* %R
-
-	%t = sub i32 %S, %s
-	ret i32 %t
-; CHECK: @test2
-; CHECK: ret i32 0
-}
-
-
-; This was a miscompilation.
-define i32 @test3({float, {i32, i32, i32}}* %P) {
-entry:
-  %P2 = getelementptr {float, {i32, i32, i32}}* %P, i32 0, i32 1
-	%R = getelementptr {i32, i32, i32}* %P2, i32 0, i32 1
-	%S = load i32* %R
-
-	%r = getelementptr {i32, i32, i32}* %P2, i32 0, i32 2
-  store i32 42, i32* %r
-
-	%s = load i32* %R
-
-	%t = sub i32 %S, %s
-	ret i32 %t
-; CHECK: @test3
-; CHECK: ret i32 0
-}
-
-
-;; This is reduced from the SmallPtrSet constructor.
-%SmallPtrSetImpl = type { i8**, i32, i32, i32, [1 x i8*] }
-%SmallPtrSet64 = type { %SmallPtrSetImpl, [64 x i8*] }
-
-define i32 @test4(%SmallPtrSet64* %P) {
-entry:
-  %tmp2 = getelementptr inbounds %SmallPtrSet64* %P, i64 0, i32 0, i32 1
-  store i32 64, i32* %tmp2, align 8
-  %tmp3 = getelementptr inbounds %SmallPtrSet64* %P, i64 0, i32 0, i32 4, i64 64
-  store i8* null, i8** %tmp3, align 8
-  %tmp4 = load i32* %tmp2, align 8
-	ret i32 %tmp4
-; CHECK: @test4
-; CHECK: ret i32 64
-}




From sabre at nondot.org  Thu Nov 26 10:18:10 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 16:18:10 -0000
Subject: [llvm-commits] [llvm] r89951 - in /llvm/trunk:
 lib/Analysis/BasicAliasAnalysis.cpp lib/Target/README.txt
 test/Analysis/BasicAA/gep-alias.ll
Message-ID: <200911261618.nAQGIBxe003273@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 10:18:10 2009
New Revision: 89951

URL: http://llvm.org/viewvc/llvm-project?rev=89951&view=rev
Log:
teach basicaa that A[i] != A[i+1].


Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
    llvm/trunk/lib/Target/README.txt
    llvm/trunk/test/Analysis/BasicAA/gep-alias.ll

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89951&r1=89950&r2=89951&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Thu Nov 26 10:18:10 2009
@@ -378,6 +378,30 @@
   return NoAA::getModRefInfo(CS1, CS2);
 }
 
+/// GetLinearExpression - Analyze the specified value as a linear expression:
+/// "A*V + B".  Return the scale and offset values as APInts and return V as a
+/// Value*.  The incoming Value is known to be a scalar integer.
+static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset) {
+  assert(isa(V->getType()) && "Not an integer value");
+  
+  if (BinaryOperator *BOp = dyn_cast(V)) {
+    if (ConstantInt *RHSC = dyn_cast(BOp->getOperand(1))) {
+      switch (BOp->getOpcode()) {
+      default: break;
+      case Instruction::Add:
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset);
+        Offset += RHSC->getValue();
+        return V;
+      // TODO: SHL, MUL, OR.
+      }
+    }
+  }
+
+  Scale = 1;
+  Offset = 0;
+  return V;
+}
+
 /// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it
 /// into a base pointer with a constant offset and a number of scaled symbolic
 /// offsets.
@@ -456,6 +480,14 @@
       // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
       uint64_t Scale = TD->getTypeAllocSize(*GTI);
       
+      unsigned Width = cast(Index->getType())->getBitWidth();
+      APInt IndexScale(Width, 0), IndexOffset(Width, 0);
+      Index = GetLinearExpression(Index, IndexScale, IndexOffset);
+      
+      Scale *= IndexScale.getZExtValue();
+      BaseOffs += IndexOffset.getZExtValue()*Scale;
+      
+      
       // If we already had an occurrance of this index variable, merge this
       // scale into it.  For example, we want to handle:
       //   A[x][x] -> x*16 + x*4 -> x*20

Modified: llvm/trunk/lib/Target/README.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/README.txt?rev=89951&r1=89950&r2=89951&view=diff

==============================================================================
--- llvm/trunk/lib/Target/README.txt (original)
+++ llvm/trunk/lib/Target/README.txt Thu Nov 26 10:18:10 2009
@@ -458,8 +458,6 @@
   }
 }
 
-BasicAA also doesn't do this for add.  It needs to know that &A[i+1] != &A[i].
-
 //===---------------------------------------------------------------------===//
 
 We should investigate an instruction sinking pass.  Consider this silly

Modified: llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/gep-alias.ll?rev=89951&r1=89950&r2=89951&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/gep-alias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/gep-alias.ll Thu Nov 26 10:18:10 2009
@@ -71,3 +71,19 @@
 ; CHECK: @test4
 ; CHECK: ret i32 64
 }
+
+; P[i] != p[i+1]
+define i32 @test5(i32* %p, i64 %i) {
+  %pi = getelementptr i32* %p, i64 %i
+  %i.next = add i64 %i, 1
+  %pi.next = getelementptr i32* %p, i64 %i.next
+  %x = load i32* %pi
+  store i32 42, i32* %pi.next
+  %y = load i32* %pi
+  %z = sub i32 %x, %y
+  ret i32 %z
+; CHECK: @test5
+; CHECK: ret i32 0
+}
+
+




From sabre at nondot.org  Thu Nov 26 10:26:43 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 16:26:43 -0000
Subject: [llvm-commits] [llvm] r89952 - in /llvm/trunk:
 lib/Analysis/BasicAliasAnalysis.cpp lib/Target/README.txt
 test/Analysis/BasicAA/gep-alias.ll
Message-ID: <200911261626.nAQGQiEV003805@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 10:26:43 2009
New Revision: 89952

URL: http://llvm.org/viewvc/llvm-project?rev=89952&view=rev
Log:
Teach basicaa that x|c == x+c when the c bits of x are clear.  This
allows us to compile the example in readme.txt into:

LBB1_1:                                                     ## %bb
	movl	4(%rdx,%rax), %ecx
	movl	%ecx, %esi
	imull	(%rdx,%rax), %esi
	imull	%esi, %ecx
	movl	%esi, 8(%rdx,%rax)
	imull	%ecx, %esi
	movl	%ecx, 12(%rdx,%rax)
	movl	%esi, 16(%rdx,%rax)
	imull	%ecx, %esi
	movl	%esi, 20(%rdx,%rax)
	addq	$16, %rax
	cmpq	$4000, %rax
	jne	LBB1_1

instead of:

LBB1_1: 
	movl	(%rdx,%rax), %ecx
	imull	4(%rdx,%rax), %ecx
	movl	%ecx, 8(%rdx,%rax)
	imull	4(%rdx,%rax), %ecx
	movl	%ecx, 12(%rdx,%rax)
	imull	8(%rdx,%rax), %ecx
	movl	%ecx, 16(%rdx,%rax)
	imull	12(%rdx,%rax), %ecx
	movl	%ecx, 20(%rdx,%rax)
	addq	$16, %rax
	cmpq	$4000, %rax
	jne	LBB1_1

GCC (4.2) doesn't seem to be able to eliminate the loads in this 
testcase either, it generates:

L2:
	movl	(%rdx), %eax
	imull	4(%rdx), %eax
	movl	%eax, 8(%rdx)
	imull	4(%rdx), %eax
	movl	%eax, 12(%rdx)
	imull	8(%rdx), %eax
	movl	%eax, 16(%rdx)
	imull	12(%rdx), %eax
	movl	%eax, 20(%rdx)
	addl	$4, %ecx
	addq	$16, %rdx
	cmpl	$1002, %ecx
	jne	L2



Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
    llvm/trunk/lib/Target/README.txt
    llvm/trunk/test/Analysis/BasicAA/gep-alias.ll

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89952&r1=89951&r2=89952&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Thu Nov 26 10:26:43 2009
@@ -14,8 +14,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/AliasAnalysis.h"
-#include "llvm/Analysis/CaptureTracking.h"
-#include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/Passes.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
@@ -26,6 +24,9 @@
 #include "llvm/IntrinsicInst.h"
 #include "llvm/Operator.h"
 #include "llvm/Pass.h"
+#include "llvm/Analysis/CaptureTracking.h"
+#include "llvm/Analysis/MemoryBuiltins.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Target/TargetData.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
@@ -381,15 +382,22 @@
 /// GetLinearExpression - Analyze the specified value as a linear expression:
 /// "A*V + B".  Return the scale and offset values as APInts and return V as a
 /// Value*.  The incoming Value is known to be a scalar integer.
-static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset) {
+static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
+                                  const TargetData *TD) {
   assert(isa(V->getType()) && "Not an integer value");
   
   if (BinaryOperator *BOp = dyn_cast(V)) {
     if (ConstantInt *RHSC = dyn_cast(BOp->getOperand(1))) {
       switch (BOp->getOpcode()) {
       default: break;
+      case Instruction::Or:
+        // X|C == X+C if all the bits in C are unset in X.  Otherwise we can't
+        // analyze it.
+        if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), TD))
+          break;
+        // FALL THROUGH.
       case Instruction::Add:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset);
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
         Offset += RHSC->getValue();
         return V;
       // TODO: SHL, MUL, OR.
@@ -482,7 +490,7 @@
       
       unsigned Width = cast(Index->getType())->getBitWidth();
       APInt IndexScale(Width, 0), IndexOffset(Width, 0);
-      Index = GetLinearExpression(Index, IndexScale, IndexOffset);
+      Index = GetLinearExpression(Index, IndexScale, IndexOffset, TD);
       
       Scale *= IndexScale.getZExtValue();
       BaseOffs += IndexOffset.getZExtValue()*Scale;

Modified: llvm/trunk/lib/Target/README.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/README.txt?rev=89952&r1=89951&r2=89952&view=diff

==============================================================================
--- llvm/trunk/lib/Target/README.txt (original)
+++ llvm/trunk/lib/Target/README.txt Thu Nov 26 10:26:43 2009
@@ -443,23 +443,6 @@
 
 //===---------------------------------------------------------------------===//
 
-"basicaa" should know how to look through "or" instructions that act like add
-instructions.  For example in this code, the x*4+1 is turned into x*4 | 1, and
-basicaa can't analyze the array subscript, leading to duplicated loads in the
-generated code:
-
-void test(int X, int Y, int a[]) {
-int i;
-  for (i=2; i<1000; i+=4) {
-  a[i+0] = a[i-1+0]*a[i-2+0];
-  a[i+1] = a[i-1+1]*a[i-2+1];
-  a[i+2] = a[i-1+2]*a[i-2+2];
-  a[i+3] = a[i-1+3]*a[i-2+3];
-  }
-}
-
-//===---------------------------------------------------------------------===//
-
 We should investigate an instruction sinking pass.  Consider this silly
 example in pic mode:
 

Modified: llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/gep-alias.ll?rev=89952&r1=89951&r2=89952&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/gep-alias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/gep-alias.ll Thu Nov 26 10:26:43 2009
@@ -86,4 +86,18 @@
 ; CHECK: ret i32 0
 }
 
+; P[i] != p[(i*4)|1]
+define i32 @test6(i32* %p, i64 %i1) {
+  %i = shl i64 %i1, 2
+  %pi = getelementptr i32* %p, i64 %i
+  %i.next = or i64 %i, 1
+  %pi.next = getelementptr i32* %p, i64 %i.next
+  %x = load i32* %pi
+  store i32 42, i32* %pi.next
+  %y = load i32* %pi
+  %z = sub i32 %x, %y
+  ret i32 %z
+; CHECK: @test6
+; CHECK: ret i32 0
+}
 




From sabre at nondot.org  Thu Nov 26 10:42:00 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 16:42:00 -0000
Subject: [llvm-commits] [llvm] r89953 -
	/llvm/trunk/test/Analysis/ScalarEvolution/scev-aa.ll
Message-ID: <200911261642.nAQGg04R004287@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 10:42:00 2009
New Revision: 89953

URL: http://llvm.org/viewvc/llvm-project?rev=89953&view=rev
Log:
update status of this.  basicaa is much improved now,
only missing the one form (in this testcase).  Dan, do you
consider this example to be important?


Modified:
    llvm/trunk/test/Analysis/ScalarEvolution/scev-aa.ll

Modified: llvm/trunk/test/Analysis/ScalarEvolution/scev-aa.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/ScalarEvolution/scev-aa.ll?rev=89953&r1=89952&r2=89953&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/ScalarEvolution/scev-aa.ll (original)
+++ llvm/trunk/test/Analysis/ScalarEvolution/scev-aa.ll Thu Nov 26 10:42:00 2009
@@ -1,8 +1,8 @@
 ; RUN: opt < %s -scev-aa -aa-eval -print-all-alias-modref-info \
 ; RUN:   |& FileCheck %s
 
-; At the time of this writing, all of these CHECK lines are cases that
-; plain -basicaa misses.
+; At the time of this writing, -basicaa only misses the example of the form
+; A[i+(j+1)] != A[i+j].  However, it does get A[(i+j)+1] != A[i+j].
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
 




From sabre at nondot.org  Thu Nov 26 10:52:32 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 16:52:32 -0000
Subject: [llvm-commits] [llvm] r89954 -
	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
Message-ID: <200911261652.nAQGqWwB004772@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 10:52:32 2009
New Revision: 89954

URL: http://llvm.org/viewvc/llvm-project?rev=89954&view=rev
Log:
resolve a fixme.  I haven't figured out how to write a testcase
to exercise this though.

Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89954&r1=89953&r2=89954&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Thu Nov 26 10:52:32 2009
@@ -400,7 +400,7 @@
         V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
         Offset += RHSC->getValue();
         return V;
-      // TODO: SHL, MUL, OR.
+      // TODO: SHL, MUL.
       }
     }
   }
@@ -610,10 +610,9 @@
     // Check to see if these two pointers are related by the getelementptr
     // instruction.  If one pointer is a GEP with a non-zero index of the other
     // pointer, we know they cannot alias.
-    //
-    // FIXME: The check below only looks at the size of one of the pointers, not
-    // both, this may cause us to miss things.
-    if (V1Size == ~0U || V2Size == ~0U)
+
+    // If both accesses are unknown size, we can't do anything useful here.
+    if (V1Size == ~0U && V2Size == ~0U)
       return MayAlias;
 
     AliasResult R = aliasCheck(UnderlyingV1, ~0U, V2, V2Size);




From sabre at nondot.org  Thu Nov 26 11:00:01 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 17:00:01 -0000
Subject: [llvm-commits] [llvm] r89955 - in /llvm/trunk:
 lib/Analysis/BasicAliasAnalysis.cpp test/Analysis/BasicAA/gep-alias.ll
Message-ID: <200911261700.nAQH01H0005061@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 11:00:01 2009
New Revision: 89955

URL: http://llvm.org/viewvc/llvm-project?rev=89955&view=rev
Log:
teach GetLinearExpression to be a bit more aggressive.

Modified:
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
    llvm/trunk/test/Analysis/BasicAA/gep-alias.ll

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89955&r1=89954&r2=89955&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Thu Nov 26 11:00:01 2009
@@ -400,7 +400,16 @@
         V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
         Offset += RHSC->getValue();
         return V;
-      // TODO: SHL, MUL.
+      case Instruction::Mul:
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        Offset *= RHSC->getValue();
+        Scale *= RHSC->getValue();
+        return V;
+      case Instruction::Shl:
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        Offset <<= RHSC->getValue().getLimitedValue();
+        Scale <<= RHSC->getValue().getLimitedValue();
+        return V;
       }
     }
   }

Modified: llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/gep-alias.ll?rev=89955&r1=89954&r2=89955&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/gep-alias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/gep-alias.ll Thu Nov 26 11:00:01 2009
@@ -101,3 +101,18 @@
 ; CHECK: ret i32 0
 }
 
+; P[1] != P[i*4]
+define i32 @test7(i32* %p, i64 %i) {
+  %pi = getelementptr i32* %p, i64 1
+  %i.next = shl i64 %i, 2
+  %pi.next = getelementptr i32* %p, i64 %i.next
+  %x = load i32* %pi
+  store i32 42, i32* %pi.next
+  %y = load i32* %pi
+  %z = sub i32 %x, %y
+  ret i32 %z
+; CHECK: @test7
+; CHECK: ret i32 0
+}
+
+




From sabre at nondot.org  Thu Nov 26 11:12:51 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 17:12:51 -0000
Subject: [llvm-commits] [llvm] r89956 - in /llvm/trunk:
 include/llvm/Analysis/ValueTracking.h lib/Analysis/BasicAliasAnalysis.cpp
 lib/Analysis/ValueTracking.cpp
Message-ID: <200911261712.nAQHCpkH005459@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 11:12:50 2009
New Revision: 89956

URL: http://llvm.org/viewvc/llvm-project?rev=89956&view=rev
Log:
move DecomposeGEPExpression out into ValueTracking.cpp

Modified:
    llvm/trunk/include/llvm/Analysis/ValueTracking.h
    llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
    llvm/trunk/lib/Analysis/ValueTracking.cpp

Modified: llvm/trunk/include/llvm/Analysis/ValueTracking.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ValueTracking.h?rev=89956&r1=89955&r2=89956&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Analysis/ValueTracking.h (original)
+++ llvm/trunk/include/llvm/Analysis/ValueTracking.h Thu Nov 26 11:12:50 2009
@@ -19,6 +19,7 @@
 #include 
 
 namespace llvm {
+  template  class SmallVectorImpl;
   class Value;
   class Instruction;
   class APInt;
@@ -77,6 +78,20 @@
   ///
   bool CannotBeNegativeZero(const Value *V, unsigned Depth = 0);
 
+  /// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose
+  /// it into a base pointer with a constant offset and a number of scaled
+  /// symbolic offsets.
+  ///
+  /// When TargetData is around, this function is capable of analyzing
+  /// everything that Value::getUnderlyingObject() can look through.  When not,
+  /// it just looks through pointer casts.
+  ///
+  const Value *DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
+                 SmallVectorImpl > &VarIndices,
+                                      const TargetData *TD);
+    
+  
+  
   /// FindScalarValue - Given an aggregrate and an sequence of indices, see if
   /// the scalar value indexed is already around as a register, for example if
   /// it were inserted directly into the aggregrate.

Modified: llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp?rev=89956&r1=89955&r2=89956&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp Thu Nov 26 11:12:50 2009
@@ -18,7 +18,6 @@
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
-#include "llvm/GlobalAlias.h"
 #include "llvm/GlobalVariable.h"
 #include "llvm/Instructions.h"
 #include "llvm/IntrinsicInst.h"
@@ -28,11 +27,9 @@
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Target/TargetData.h"
-#include "llvm/ADT/SmallSet.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/GetElementPtrTypeIterator.h"
 #include 
 using namespace llvm;
 
@@ -379,160 +376,6 @@
   return NoAA::getModRefInfo(CS1, CS2);
 }
 
-/// GetLinearExpression - Analyze the specified value as a linear expression:
-/// "A*V + B".  Return the scale and offset values as APInts and return V as a
-/// Value*.  The incoming Value is known to be a scalar integer.
-static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
-                                  const TargetData *TD) {
-  assert(isa(V->getType()) && "Not an integer value");
-  
-  if (BinaryOperator *BOp = dyn_cast(V)) {
-    if (ConstantInt *RHSC = dyn_cast(BOp->getOperand(1))) {
-      switch (BOp->getOpcode()) {
-      default: break;
-      case Instruction::Or:
-        // X|C == X+C if all the bits in C are unset in X.  Otherwise we can't
-        // analyze it.
-        if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), TD))
-          break;
-        // FALL THROUGH.
-      case Instruction::Add:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
-        Offset += RHSC->getValue();
-        return V;
-      case Instruction::Mul:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
-        Offset *= RHSC->getValue();
-        Scale *= RHSC->getValue();
-        return V;
-      case Instruction::Shl:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
-        Offset <<= RHSC->getValue().getLimitedValue();
-        Scale <<= RHSC->getValue().getLimitedValue();
-        return V;
-      }
-    }
-  }
-
-  Scale = 1;
-  Offset = 0;
-  return V;
-}
-
-/// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it
-/// into a base pointer with a constant offset and a number of scaled symbolic
-/// offsets.
-///
-/// When TargetData is around, this function is capable of analyzing everything
-/// that Value::getUnderlyingObject() can look through.  When not, it just looks
-/// through pointer casts.
-///
-/// FIXME: Move this out to ValueTracking.cpp
-///
-static const Value *DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
-                 SmallVectorImpl > &VarIndices,
-                                           const TargetData *TD) {
-  // FIXME: Should limit depth like getUnderlyingObject?
-  BaseOffs = 0;
-  while (1) {
-    // See if this is a bitcast or GEP.
-    const Operator *Op = dyn_cast(V);
-    if (Op == 0) {
-      // The only non-operator case we can handle are GlobalAliases.
-      if (const GlobalAlias *GA = dyn_cast(V)) {
-        if (!GA->mayBeOverridden()) {
-          V = GA->getAliasee();
-          continue;
-        }
-      }
-      return V;
-    }
-    
-    if (Op->getOpcode() == Instruction::BitCast) {
-      V = Op->getOperand(0);
-      continue;
-    }
-    
-    const GEPOperator *GEPOp = dyn_cast(Op);
-    if (GEPOp == 0)
-      return V;
-    
-    // Don't attempt to analyze GEPs over unsized objects.
-    if (!cast(GEPOp->getOperand(0)->getType())
-          ->getElementType()->isSized())
-      return V;
-
-    // If we are lacking TargetData information, we can't compute the offets of
-    // elements computed by GEPs.  However, we can handle bitcast equivalent
-    // GEPs.
-    if (!TD) {
-      if (!GEPOp->hasAllZeroIndices())
-        return V;
-      V = GEPOp->getOperand(0);
-      continue;
-    }
-    
-    // Walk the indices of the GEP, accumulating them into BaseOff/VarIndices.
-    gep_type_iterator GTI = gep_type_begin(GEPOp);
-    for (User::const_op_iterator I = next(GEPOp->op_begin()),
-         E = GEPOp->op_end(); I != E; ++I) {
-      Value *Index = *I;
-      // Compute the (potentially symbolic) offset in bytes for this index.
-      if (const StructType *STy = dyn_cast(*GTI++)) {
-        // For a struct, add the member offset.
-        unsigned FieldNo = cast(Index)->getZExtValue();
-        if (FieldNo == 0) continue;
-        
-        BaseOffs += TD->getStructLayout(STy)->getElementOffset(FieldNo);
-        continue;
-      }
-      
-      // For an array/pointer, add the element offset, explicitly scaled.
-      if (ConstantInt *CIdx = dyn_cast(Index)) {
-        if (CIdx->isZero()) continue;
-        BaseOffs += TD->getTypeAllocSize(*GTI)*CIdx->getSExtValue();
-        continue;
-      }
-      
-      // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
-      uint64_t Scale = TD->getTypeAllocSize(*GTI);
-      
-      unsigned Width = cast(Index->getType())->getBitWidth();
-      APInt IndexScale(Width, 0), IndexOffset(Width, 0);
-      Index = GetLinearExpression(Index, IndexScale, IndexOffset, TD);
-      
-      Scale *= IndexScale.getZExtValue();
-      BaseOffs += IndexOffset.getZExtValue()*Scale;
-      
-      
-      // If we already had an occurrance of this index variable, merge this
-      // scale into it.  For example, we want to handle:
-      //   A[x][x] -> x*16 + x*4 -> x*20
-      // This also ensures that 'x' only appears in the index list once.
-      for (unsigned i = 0, e = VarIndices.size(); i != e; ++i) {
-        if (VarIndices[i].first == Index) {
-          Scale += VarIndices[i].second;
-          VarIndices.erase(VarIndices.begin()+i);
-          break;
-        }
-      }
-      
-      // Make sure that we have a scale that makes sense for this target's
-      // pointer size.
-      if (unsigned ShiftBits = 64-TD->getPointerSizeInBits()) {
-        Scale <<= ShiftBits;
-        Scale >>= ShiftBits;
-      }
-      
-      if (Scale)
-        VarIndices.push_back(std::make_pair(Index, Scale));
-    }
-    
-    // Analyze the base pointer next.
-    V = GEPOp->getOperand(0);
-  }
-}
-
 /// GetIndiceDifference - Dest and Src are the variable indices from two
 /// decomposed GetElementPtr instructions GEP1 and GEP2 which have common base
 /// pointers.  Subtract the GEP2 indices from GEP1 to find the symbolic

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=89956&r1=89955&r2=89956&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Thu Nov 26 11:12:50 2009
@@ -948,6 +948,160 @@
   return false;
 }
 
+
+/// GetLinearExpression - Analyze the specified value as a linear expression:
+/// "A*V + B".  Return the scale and offset values as APInts and return V as a
+/// Value*.  The incoming Value is known to be a scalar integer.
+static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
+                                  const TargetData *TD) {
+  assert(isa(V->getType()) && "Not an integer value");
+  
+  if (BinaryOperator *BOp = dyn_cast(V)) {
+    if (ConstantInt *RHSC = dyn_cast(BOp->getOperand(1))) {
+      switch (BOp->getOpcode()) {
+      default: break;
+      case Instruction::Or:
+        // X|C == X+C if all the bits in C are unset in X.  Otherwise we can't
+        // analyze it.
+        if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), TD))
+          break;
+        // FALL THROUGH.
+      case Instruction::Add:
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        Offset += RHSC->getValue();
+        return V;
+      case Instruction::Mul:
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        Offset *= RHSC->getValue();
+        Scale *= RHSC->getValue();
+        return V;
+      case Instruction::Shl:
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        Offset <<= RHSC->getValue().getLimitedValue();
+        Scale <<= RHSC->getValue().getLimitedValue();
+        return V;
+      }
+    }
+  }
+  
+  Scale = 1;
+  Offset = 0;
+  return V;
+}
+
+/// DecomposeGEPExpression - If V is a symbolic pointer expression, decompose it
+/// into a base pointer with a constant offset and a number of scaled symbolic
+/// offsets.
+///
+/// When TargetData is around, this function is capable of analyzing everything
+/// that Value::getUnderlyingObject() can look through.  When not, it just looks
+/// through pointer casts.
+///
+const Value *llvm::DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
+                 SmallVectorImpl > &VarIndices,
+                                          const TargetData *TD) {
+  // FIXME: Should limit depth like getUnderlyingObject?
+  BaseOffs = 0;
+  while (1) {
+    // See if this is a bitcast or GEP.
+    const Operator *Op = dyn_cast(V);
+    if (Op == 0) {
+      // The only non-operator case we can handle are GlobalAliases.
+      if (const GlobalAlias *GA = dyn_cast(V)) {
+        if (!GA->mayBeOverridden()) {
+          V = GA->getAliasee();
+          continue;
+        }
+      }
+      return V;
+    }
+    
+    if (Op->getOpcode() == Instruction::BitCast) {
+      V = Op->getOperand(0);
+      continue;
+    }
+    
+    const GEPOperator *GEPOp = dyn_cast(Op);
+    if (GEPOp == 0)
+      return V;
+    
+    // Don't attempt to analyze GEPs over unsized objects.
+    if (!cast(GEPOp->getOperand(0)->getType())
+        ->getElementType()->isSized())
+      return V;
+    
+    // If we are lacking TargetData information, we can't compute the offets of
+    // elements computed by GEPs.  However, we can handle bitcast equivalent
+    // GEPs.
+    if (!TD) {
+      if (!GEPOp->hasAllZeroIndices())
+        return V;
+      V = GEPOp->getOperand(0);
+      continue;
+    }
+    
+    // Walk the indices of the GEP, accumulating them into BaseOff/VarIndices.
+    gep_type_iterator GTI = gep_type_begin(GEPOp);
+    for (User::const_op_iterator I = GEPOp->op_begin()+1,
+         E = GEPOp->op_end(); I != E; ++I) {
+      Value *Index = *I;
+      // Compute the (potentially symbolic) offset in bytes for this index.
+      if (const StructType *STy = dyn_cast(*GTI++)) {
+        // For a struct, add the member offset.
+        unsigned FieldNo = cast(Index)->getZExtValue();
+        if (FieldNo == 0) continue;
+        
+        BaseOffs += TD->getStructLayout(STy)->getElementOffset(FieldNo);
+        continue;
+      }
+      
+      // For an array/pointer, add the element offset, explicitly scaled.
+      if (ConstantInt *CIdx = dyn_cast(Index)) {
+        if (CIdx->isZero()) continue;
+        BaseOffs += TD->getTypeAllocSize(*GTI)*CIdx->getSExtValue();
+        continue;
+      }
+      
+      // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
+      uint64_t Scale = TD->getTypeAllocSize(*GTI);
+      
+      unsigned Width = cast(Index->getType())->getBitWidth();
+      APInt IndexScale(Width, 0), IndexOffset(Width, 0);
+      Index = GetLinearExpression(Index, IndexScale, IndexOffset, TD);
+      
+      Scale *= IndexScale.getZExtValue();
+      BaseOffs += IndexOffset.getZExtValue()*Scale;
+      
+      
+      // If we already had an occurrance of this index variable, merge this
+      // scale into it.  For example, we want to handle:
+      //   A[x][x] -> x*16 + x*4 -> x*20
+      // This also ensures that 'x' only appears in the index list once.
+      for (unsigned i = 0, e = VarIndices.size(); i != e; ++i) {
+        if (VarIndices[i].first == Index) {
+          Scale += VarIndices[i].second;
+          VarIndices.erase(VarIndices.begin()+i);
+          break;
+        }
+      }
+      
+      // Make sure that we have a scale that makes sense for this target's
+      // pointer size.
+      if (unsigned ShiftBits = 64-TD->getPointerSizeInBits()) {
+        Scale <<= ShiftBits;
+        Scale >>= ShiftBits;
+      }
+      
+      if (Scale)
+        VarIndices.push_back(std::make_pair(Index, Scale));
+    }
+    
+    // Analyze the base pointer next.
+    V = GEPOp->getOperand(0);
+  }
+}
+
+
 // This is the recursive version of BuildSubAggregate. It takes a few different
 // arguments. Idxs is the index within the nested struct From that we are
 // looking at now (which is of type IndexedType). IdxSkip is the number of




From sabre at nondot.org  Thu Nov 26 11:14:10 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 17:14:10 -0000
Subject: [llvm-commits] [llvm] r89957 -
	/llvm/trunk/lib/Analysis/ValueTracking.cpp
Message-ID: <200911261714.nAQHEANM005500@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 11:14:10 2009
New Revision: 89957

URL: http://llvm.org/viewvc/llvm-project?rev=89957&view=rev
Log:
this todo is resolved.

Modified:
    llvm/trunk/lib/Analysis/ValueTracking.cpp

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=89957&r1=89956&r2=89957&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Thu Nov 26 11:14:10 2009
@@ -1062,7 +1062,6 @@
         continue;
       }
       
-      // TODO: Could handle linear expressions here like A[X+1], also A[X*4|1].
       uint64_t Scale = TD->getTypeAllocSize(*GTI);
       
       unsigned Width = cast(Index->getType())->getBitWidth();




From baldrick at free.fr  Thu Nov 26 11:29:30 2009
From: baldrick at free.fr (Duncan Sands)
Date: Thu, 26 Nov 2009 18:29:30 +0100
Subject: [llvm-commits] [llvm] r89951 - in /llvm/trunk:
 lib/Analysis/BasicAliasAnalysis.cpp lib/Target/README.txt
 test/Analysis/BasicAA/gep-alias.ll
In-Reply-To: <200911261618.nAQGIBxe003273@zion.cs.uiuc.edu>
References: <200911261618.nAQGIBxe003273@zion.cs.uiuc.edu>
Message-ID: <4B0EBAFA.2000107@free.fr>

Hi Chris,

> +      Scale *= IndexScale.getZExtValue();
> +      BaseOffs += IndexOffset.getZExtValue()*Scale;

shouldn't these two lines be swapped?  I think in the BaseOffs line
you should be multiplying by the value of Scale before IndexScale was
factored into it, not afterwards...

Ciao,

Duncan.


From baldrick at free.fr  Thu Nov 26 11:46:28 2009
From: baldrick at free.fr (Duncan Sands)
Date: Thu, 26 Nov 2009 18:46:28 +0100
Subject: [llvm-commits] [llvm] r89915
	-	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <200911260213.nAQ2D3Q0024164@zion.cs.uiuc.edu>
References: <200911260213.nAQ2D3Q0024164@zion.cs.uiuc.edu>
Message-ID: <4B0EBEF4.4020507@free.fr>

Hi Chris,

> +  // If our known offset is bigger than the access size, we know we don't have
> +  // an alias.
> +  if (GEP1BaseOffset) {
> +    if (GEP1BaseOffset >= (int64_t)V2Size ||
> +        GEP1BaseOffset <= -(int64_t)V1Size)
>        return NoAlias;

what if this wraps around the entire address space and lands back on top of
the original pointer?

Ciao,

Duncan.


From sabre at nondot.org  Thu Nov 26 12:29:40 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 10:29:40 -0800
Subject: [llvm-commits] [llvm] r89915
	-	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <4B0EBEF4.4020507@free.fr>
References: <200911260213.nAQ2D3Q0024164@zion.cs.uiuc.edu>
	<4B0EBEF4.4020507@free.fr>
Message-ID: <294E5597-8435-4C69-AE83-272E57FFB474@nondot.org>


On Nov 26, 2009, at 9:46 AM, Duncan Sands wrote:

> Hi Chris,
> 
>> +  // If our known offset is bigger than the access size, we know we don't have
>> +  // an alias.
>> +  if (GEP1BaseOffset) {
>> +    if (GEP1BaseOffset >= (int64_t)V2Size ||
>> +        GEP1BaseOffset <= -(int64_t)V1Size)
>>       return NoAlias;
> 
> what if this wraps around the entire address space and lands back on top of
> the original pointer?

Then that's undefined behavior.

-Chris


From sabre at nondot.org  Thu Nov 26 12:31:46 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 10:31:46 -0800
Subject: [llvm-commits] [llvm] r89951 - in /llvm/trunk:
	lib/Analysis/BasicAliasAnalysis.cpp lib/Target/README.txt
	test/Analysis/BasicAA/gep-alias.ll
In-Reply-To: <4B0EBAFA.2000107@free.fr>
References: <200911261618.nAQGIBxe003273@zion.cs.uiuc.edu>
	<4B0EBAFA.2000107@free.fr>
Message-ID: <922C1681-40B0-4777-98E7-5D41468D633E@nondot.org>

On Nov 26, 2009, at 9:29 AM, Duncan Sands wrote:

> Hi Chris,
> 
>> +      Scale *= IndexScale.getZExtValue();
>> +      BaseOffs += IndexOffset.getZExtValue()*Scale;
> 
> shouldn't these two lines be swapped?  I think in the BaseOffs line
> you should be multiplying by the value of Scale before IndexScale was
> factored into it, not afterwards...

Nice catch, you're completely right, will fix!


From baldrick at free.fr  Thu Nov 26 12:33:02 2009
From: baldrick at free.fr (Duncan Sands)
Date: Thu, 26 Nov 2009 19:33:02 +0100
Subject: [llvm-commits] [llvm] r89915
	-	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <294E5597-8435-4C69-AE83-272E57FFB474@nondot.org>
References: <200911260213.nAQ2D3Q0024164@zion.cs.uiuc.edu>
	<4B0EBEF4.4020507@free.fr>
	<294E5597-8435-4C69-AE83-272E57FFB474@nondot.org>
Message-ID: <4B0EC9DE.9060404@free.fr>

>> what if this wraps around the entire address space and lands back on top of
>> the original pointer?
> 
> Then that's undefined behavior.

I thought it was only undefined for inbounds GEP?  I'm a bit worried about this
because I have a testcase in which the optimizers changed increments by -4 into
increments by 2^32 - 4, which would mean that they are creating undefined
behaviour where there was none before (PR5282).

Ciao,

Duncan.


From sabre at nondot.org  Thu Nov 26 12:35:46 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 18:35:46 -0000
Subject: [llvm-commits] [llvm] r89958 -
	/llvm/trunk/lib/Analysis/ValueTracking.cpp
Message-ID: <200911261835.nAQIZk5f008207@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 12:35:46 2009
New Revision: 89958

URL: http://llvm.org/viewvc/llvm-project?rev=89958&view=rev
Log:
fix two transposed lines duncan caught and add an explanatory comment.

Modified:
    llvm/trunk/lib/Analysis/ValueTracking.cpp

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=89958&r1=89957&r2=89958&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Thu Nov 26 12:35:46 2009
@@ -1064,12 +1064,15 @@
       
       uint64_t Scale = TD->getTypeAllocSize(*GTI);
       
+      // Use GetLinearExpression to decompose the index into a C1*V+C2 form.
       unsigned Width = cast(Index->getType())->getBitWidth();
       APInt IndexScale(Width, 0), IndexOffset(Width, 0);
       Index = GetLinearExpression(Index, IndexScale, IndexOffset, TD);
       
-      Scale *= IndexScale.getZExtValue();
+      // The GEP index scale ("Scale") scales C1*V+C2, yielding (C1*V+C2)*Scale.
+      // This gives us an aggregate computation of (C1*Scale)*V + C2*Scale.
       BaseOffs += IndexOffset.getZExtValue()*Scale;
+      Scale *= IndexScale.getZExtValue();
       
       
       // If we already had an occurrance of this index variable, merge this




From sabre at nondot.org  Thu Nov 26 12:53:34 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 18:53:34 -0000
Subject: [llvm-commits] [llvm] r89959 - in /llvm/trunk:
 include/llvm/Analysis/ValueTracking.h lib/Analysis/ValueTracking.cpp
 test/Analysis/BasicAA/gep-alias.ll
Message-ID: <200911261853.nAQIrYs3008772@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 12:53:33 2009
New Revision: 89959

URL: http://llvm.org/viewvc/llvm-project?rev=89959&view=rev
Log:
Implement PR1143 (at -m64) by making basicaa look through extensions.  We
previously already handled it at -m32 because there were no i32->i64 
extensions for addressing.

Modified:
    llvm/trunk/include/llvm/Analysis/ValueTracking.h
    llvm/trunk/lib/Analysis/ValueTracking.cpp
    llvm/trunk/test/Analysis/BasicAA/gep-alias.ll

Modified: llvm/trunk/include/llvm/Analysis/ValueTracking.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/ValueTracking.h?rev=89959&r1=89958&r2=89959&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Analysis/ValueTracking.h (original)
+++ llvm/trunk/include/llvm/Analysis/ValueTracking.h Thu Nov 26 12:53:33 2009
@@ -82,6 +82,12 @@
   /// it into a base pointer with a constant offset and a number of scaled
   /// symbolic offsets.
   ///
+  /// The scaled symbolic offsets (represented by pairs of a Value* and a scale
+  /// in the VarIndices vector) are Value*'s that are known to be scaled by the
+  /// specified amount, but which may have other unrepresented high bits. As
+  /// such, the gep cannot necessarily be reconstructed from its decomposed
+  /// form.
+  ///
   /// When TargetData is around, this function is capable of analyzing
   /// everything that Value::getUnderlyingObject() can look through.  When not,
   /// it just looks through pointer casts.

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=89959&r1=89958&r2=89959&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Thu Nov 26 12:53:33 2009
@@ -950,8 +950,10 @@
 
 
 /// GetLinearExpression - Analyze the specified value as a linear expression:
-/// "A*V + B".  Return the scale and offset values as APInts and return V as a
-/// Value*.  The incoming Value is known to be a scalar integer.
+/// "A*V + B", where A and B are constant integers.  Return the scale and offset
+/// values as APInts and return V as a Value*.  The incoming Value is known to
+/// have IntegerType.  Note that this looks through extends, so the high bits
+/// may not be represented in the result.
 static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
                                   const TargetData *TD) {
   assert(isa(V->getType()) && "Not an integer value");
@@ -984,6 +986,20 @@
     }
   }
   
+  // Since clients don't care about the high bits of the value, just scales and
+  // offsets, we can look through extensions.
+  if (isa(V) || isa(V)) {
+    Value *CastOp = cast(V)->getOperand(0);
+    unsigned OldWidth = Scale.getBitWidth();
+    unsigned SmallWidth = CastOp->getType()->getPrimitiveSizeInBits();
+    Scale.trunc(SmallWidth);
+    Offset.trunc(SmallWidth);
+    Value *Result = GetLinearExpression(CastOp, Scale, Offset, TD);
+    Scale.zext(OldWidth);
+    Offset.zext(OldWidth);
+    return Result;
+  }
+  
   Scale = 1;
   Offset = 0;
   return V;
@@ -993,6 +1009,11 @@
 /// into a base pointer with a constant offset and a number of scaled symbolic
 /// offsets.
 ///
+/// The scaled symbolic offsets (represented by pairs of a Value* and a scale in
+/// the VarIndices vector) are Value*'s that are known to be scaled by the
+/// specified amount, but which may have other unrepresented high bits. As such,
+/// the gep cannot necessarily be reconstructed from its decomposed form.
+///
 /// When TargetData is around, this function is capable of analyzing everything
 /// that Value::getUnderlyingObject() can look through.  When not, it just looks
 /// through pointer casts.

Modified: llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/gep-alias.ll?rev=89959&r1=89958&r2=89959&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/gep-alias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/gep-alias.ll Thu Nov 26 12:53:33 2009
@@ -115,4 +115,19 @@
 ; CHECK: ret i32 0
 }
 
-
+; P[zext(i)] != p[zext(i+1)]
+; PR1143
+define i32 @test8(i32* %p, i32 %i) {
+  %i1 = zext i32 %i to i64
+  %pi = getelementptr i32* %p, i64 %i1
+  %i.next = add i32 %i, 1
+  %i.next2 = zext i32 %i.next to i64
+  %pi.next = getelementptr i32* %p, i64 %i.next2
+  %x = load i32* %pi
+  store i32 42, i32* %pi.next
+  %y = load i32* %pi
+  %z = sub i32 %x, %y
+  ret i32 %z
+; CHECK: @test8
+; CHECK: ret i32 0
+}




From sabre at nondot.org  Thu Nov 26 13:25:46 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 19:25:46 -0000
Subject: [llvm-commits] [llvm] r89960 -
	/llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
Message-ID: <200911261925.nAQJPkU4009844@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 13:25:46 2009
New Revision: 89960

URL: http://llvm.org/viewvc/llvm-project?rev=89960&view=rev
Log:
@test9 is a testcase for r89958.  Before 89958, we misanalyzed the
first expression as P+4+4*i which we considered to possibly alias
P+4*j.  Now we correctly analyze the former one as P+1+4*i.

@test10 is a sanity test that verfies that we know that P+4+4*i != P+4*i.


Modified:
    llvm/trunk/test/Analysis/BasicAA/gep-alias.ll

Modified: llvm/trunk/test/Analysis/BasicAA/gep-alias.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/BasicAA/gep-alias.ll?rev=89960&r1=89959&r2=89960&view=diff

==============================================================================
--- llvm/trunk/test/Analysis/BasicAA/gep-alias.ll (original)
+++ llvm/trunk/test/Analysis/BasicAA/gep-alias.ll Thu Nov 26 13:25:46 2009
@@ -1,8 +1,8 @@
 ; RUN: opt < %s -gvn -instcombine -S |& FileCheck %s
-; Make sure that basicaa thinks R and r are must aliases.
 
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 
+; Make sure that basicaa thinks R and r are must aliases.
 define i32 @test1(i8 * %P) {
 entry:
 	%Q = bitcast i8* %P to {i32, i32}*
@@ -131,3 +131,41 @@
 ; CHECK: @test8
 ; CHECK: ret i32 0
 }
+
+define i8 @test9([4 x i8] *%P, i32 %i, i32 %j) {
+  %i2 = shl i32 %i, 2
+  %i3 = add i32 %i2, 1
+  ; P2 = P + 1 + 4*i
+  %P2 = getelementptr [4 x i8] *%P, i32 0, i32 %i3
+
+  %j2 = shl i32 %j, 2
+  
+  ; P4 = P + 4*j
+  %P4 = getelementptr [4 x i8]* %P, i32 0, i32 %j2
+
+  %x = load i8* %P2
+  store i8 42, i8* %P4
+  %y = load i8* %P2
+  %z = sub i8 %x, %y
+  ret i8 %z
+; CHECK: @test9
+; CHECK: ret i8 0
+}
+
+define i8 @test10([4 x i8] *%P, i32 %i) {
+  %i2 = shl i32 %i, 2
+  %i3 = add i32 %i2, 4
+  ; P2 = P + 4 + 4*i
+  %P2 = getelementptr [4 x i8] *%P, i32 0, i32 %i3
+  
+  ; P4 = P + 4*i
+  %P4 = getelementptr [4 x i8]* %P, i32 0, i32 %i2
+
+  %x = load i8* %P2
+  store i8 42, i8* %P4
+  %y = load i8* %P2
+  %z = sub i8 %x, %y
+  ret i8 %z
+; CHECK: @test10
+; CHECK: ret i8 0
+}




From baldrick at free.fr  Thu Nov 26 13:27:08 2009
From: baldrick at free.fr (Duncan Sands)
Date: Thu, 26 Nov 2009 20:27:08 +0100
Subject: [llvm-commits] [llvm] r89959 - in /llvm/trunk:
 include/llvm/Analysis/ValueTracking.h lib/Analysis/ValueTracking.cpp
 test/Analysis/BasicAA/gep-alias.ll
In-Reply-To: <200911261853.nAQIrYs3008772@zion.cs.uiuc.edu>
References: <200911261853.nAQIrYs3008772@zion.cs.uiuc.edu>
Message-ID: <4B0ED68C.4080409@free.fr>

Hi Chris,

> +  /// The scaled symbolic offsets (represented by pairs of a Value* and a scale
> +  /// in the VarIndices vector) are Value*'s that are known to be scaled by the
> +  /// specified amount, but which may have other unrepresented high bits. As
> +  /// such, the gep cannot necessarily be reconstructed from its decomposed
> +  /// form.

it looks like there is no control on how many bits are "unrepresented high
bits".  For example, if you had an extension from i1 somewhere, presumably
all bits except the first may contain some rubbish values.  If you now do
a test like "is this value bigger than 4", how can you answer?

Ciao,

Duncan.


From sabre at nondot.org  Thu Nov 26 14:11:31 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 12:11:31 -0800
Subject: [llvm-commits] [llvm] r89959 - in /llvm/trunk:
	include/llvm/Analysis/ValueTracking.h lib/Analysis/ValueTracking.cpp
	test/Analysis/BasicAA/gep-alias.ll
In-Reply-To: <4B0ED68C.4080409@free.fr>
References: <200911261853.nAQIrYs3008772@zion.cs.uiuc.edu>
	<4B0ED68C.4080409@free.fr>
Message-ID: 


On Nov 26, 2009, at 11:27 AM, Duncan Sands wrote:

> Hi Chris,
> 
>> +  /// The scaled symbolic offsets (represented by pairs of a Value* and a scale
>> +  /// in the VarIndices vector) are Value*'s that are known to be scaled by the
>> +  /// specified amount, but which may have other unrepresented high bits. As
>> +  /// such, the gep cannot necessarily be reconstructed from its decomposed
>> +  /// form.
> 
> it looks like there is no control on how many bits are "unrepresented high
> bits".  For example, if you had an extension from i1 somewhere, presumably
> all bits except the first may contain some rubbish values.  If you now do
> a test like "is this value bigger than 4", how can you answer?

This code only cares about scales and offsets.  Because of this, an i1 won't have a scale.  It doesn't matter of it is 0 or 1. :)

-Chris


From sabre at nondot.org  Thu Nov 26 14:18:46 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 12:18:46 -0800
Subject: [llvm-commits] [llvm] r89915
	-	/llvm/trunk/lib/Analysis/BasicAliasAnalysis.cpp
In-Reply-To: <4B0EC9DE.9060404@free.fr>
References: <200911260213.nAQ2D3Q0024164@zion.cs.uiuc.edu>
	<4B0EBEF4.4020507@free.fr>
	<294E5597-8435-4C69-AE83-272E57FFB474@nondot.org>
	<4B0EC9DE.9060404@free.fr>
Message-ID: <18BEBF85-FCC7-4246-9BF8-26F41C6D7D37@nondot.org>


On Nov 26, 2009, at 10:33 AM, Duncan Sands wrote:

>>> what if this wraps around the entire address space and lands back on top of
>>> the original pointer?
>> Then that's undefined behavior.
> 
> I thought it was only undefined for inbounds GEP?  I'm a bit worried about this
> because I have a testcase in which the optimizers changed increments by -4 into
> increments by 2^32 - 4, which would mean that they are creating undefined
> behaviour where there was none before (PR5282).

This isn't related, it is looking at the access size in this code, not the stride.  The scales are explicitly truncated to pointer size here:

      // Make sure that we have a scale that makes sense for this target's
      // pointer size.
      if (unsigned ShiftBits = 64-TD->getPointerSizeInBits()) {
        Scale <<= ShiftBits;
        Scale >>= ShiftBits;
      }

so it will be handled as -4, not "something crazy".

-Chris
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20091126/0bd1d71e/attachment.html 

From anton at korobeynikov.info  Thu Nov 26 14:25:43 2009
From: anton at korobeynikov.info (Anton Korobeynikov)
Date: Thu, 26 Nov 2009 23:25:43 +0300
Subject: [llvm-commits] Invalid instcombine transformation
Message-ID: <1259267143.21630.143.camel@aslstation>

Hello, Everyone

Currently instcombine turns small memcpy's (say, of 1/2/4/8 bytes)
into loads / stores. This seems to be invalid if target does not allow
unaligned access (and even if it allows, it's slower in general).
Consider ARM, there we have:
 
1. Byte loads / stores => no alignment requirement
2. 2-byte loads / stores => 16 bit alignment requirement
3. 4-byte loads / stores => 32 bit alignment requirement
 
In case of misaligned access in cases 2 and 3 it can be either "fixed"
(if the processor is configured so), or trap (it it doesn't configured
so).

memcpy allows arbitrary alignment. In such situation, turn of e.g.
memcpy(i8*, i8*, 2, 1) and memcpy(i8*, i8*, 4, 1) into loads / stores
is invalid and thus the transform should be disabled. Same applies to
memset.

Attached patch allows memcpy => load/store transformation only if memcpy
alignment is not lower than ABI alignment of the load/store type (when
TargetData is available).

This fixed several bugs in real code running on ARM.

Ok to commit?

-- 
With best regards, Anton Korobeynikov.

Faculty of Mathematics & Mechanics, Saint Petersburg State University.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: instcombine-unaligned.diff
Type: text/x-patch
Size: 4257 bytes
Desc: not available
Url : http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20091126/5d02154c/attachment.bin 

From nicholas at mxc.ca  Mon Nov 23 23:49:22 2009
From: nicholas at mxc.ca (Nick Lewycky)
Date: Mon, 23 Nov 2009 21:49:22 -0800
Subject: [llvm-commits] [llvm] r89639 - in /llvm/trunk:
 lib/Transforms/Scalar/InstructionCombining.cpp
 test/Transforms/InstCombine/compare-signs.ll
In-Reply-To: 
References: <200911230317.nAN3HYvG017794@zion.cs.uiuc.edu>
	<4B0A446C.10104@free.fr> <4B0A4558.8070803@mxc.ca>
	<4B0A48CB.4020201@free.fr>
	
Message-ID: <4B0B73E2.6010009@mxc.ca>

Chris Lattner wrote:
>
> On Nov 23, 2009, at 12:33 AM, Duncan Sands wrote:
>
>>>>> + if (KnownZeroLHS.countLeadingOnes() == BitWidth-1&&
>>>>> + KnownZeroRHS.countLeadingOnes() == BitWidth-1) {
>>>>
>>>> == ->  >= :)
>>>
>>> Nope, look again!
>>>
>>> +        APInt TypeMask(APInt::getHighBitsSet(BitWidth, BitWidth-1));
>>>
>>> Thus, it will never return a knownzero with all bits set. :)
>>
>> Ha ha, you got me there!
>
> Please add a comment.  Obviously it isn't clear what is going on here.

Sorry Chris, but I don't think a comment would do anything but confuse 
people further. A reader who wasn't thinking of the earlier version of 
the patch that behaved differently wouldn't be asking this question.

Also, the issue Duncan raised is one of possible missed optimization, 
not correctness. It addressed handling the case where the comparison is 
with a constant, but those should be getting optimized away elsewhere 
anyways.

Nick

PS. Of course, if you were to tell me to stop arguing and just add a 
damned comment, I will.


From baldrick at free.fr  Thu Nov 26 14:43:00 2009
From: baldrick at free.fr (Duncan Sands)
Date: Thu, 26 Nov 2009 21:43:00 +0100
Subject: [llvm-commits] [llvm] r89639 - in /llvm/trunk:
 lib/Transforms/Scalar/InstructionCombining.cpp
 test/Transforms/InstCombine/compare-signs.ll
In-Reply-To: <4B0B73E2.6010009@mxc.ca>
References: <200911230317.nAN3HYvG017794@zion.cs.uiuc.edu>
	<4B0A446C.10104@free.fr> <4B0A4558.8070803@mxc.ca>
	<4B0A48CB.4020201@free.fr>
	
	<4B0B73E2.6010009@mxc.ca>
Message-ID: <4B0EE854.80802@free.fr>

> Sorry Chris, but I don't think a comment would do anything but confuse 
> people further. A reader who wasn't thinking of the earlier version of 
> the patch that behaved differently wouldn't be asking this question.

Yeah, it was basically an "in joke" :)

Ciao,

Duncan.


From clattner at apple.com  Thu Nov 26 15:20:46 2009
From: clattner at apple.com (Chris Lattner)
Date: Thu, 26 Nov 2009 13:20:46 -0800
Subject: [llvm-commits] [llvm] r89639 - in /llvm/trunk:
	lib/Transforms/Scalar/InstructionCombining.cpp
	test/Transforms/InstCombine/compare-signs.ll
In-Reply-To: <4B0EE854.80802@free.fr>
References: <200911230317.nAN3HYvG017794@zion.cs.uiuc.edu>
	<4B0A446C.10104@free.fr> <4B0A4558.8070803@mxc.ca>
	<4B0A48CB.4020201@free.fr>
	
	<4B0B73E2.6010009@mxc.ca> <4B0EE854.80802@free.fr>
Message-ID: 

ok

On Nov 26, 2009, at 12:43 PM, Duncan Sands wrote:

>> Sorry Chris, but I don't think a comment would do anything but confuse people further. A reader who wasn't thinking of the earlier version of the patch that behaved differently wouldn't be asking this question.
> 
> Yeah, it was basically an "in joke" :)
> 
> Ciao,
> 
> Duncan.




From clattner at apple.com  Thu Nov 26 15:24:06 2009
From: clattner at apple.com (Chris Lattner)
Date: Thu, 26 Nov 2009 13:24:06 -0800
Subject: [llvm-commits] Invalid instcombine transformation
In-Reply-To: <1259267143.21630.143.camel@aslstation>
References: <1259267143.21630.143.camel@aslstation>
Message-ID: <6634FC61-E6AE-4FA4-BCF2-267F390C1735@apple.com>

On Nov 26, 2009, at 12:25 PM, Anton Korobeynikov wrote:
> Hello, Everyone
> 
> Currently instcombine turns small memcpy's (say, of 1/2/4/8 bytes)
> into loads / stores. 

Yes, this is very bad.  instcombine should not 'lower' into 2/4/8 byte stores (1 byte are ok though).  This is for a couple of reasons, not the least of which is that it introduces type-unsafe code that is harder to analyze than the original IR.

> This seems to be invalid if target does not allow
> unaligned access (and even if it allows, it's slower in general).

The target *has* to support unaligned accesses.  Worst case, the code generator should lower to byte accesses.  That said, this is still bad :)

> Attached patch allows memcpy => load/store transformation only if memcpy
> alignment is not lower than ABI alignment of the load/store type (when
> TargetData is available).
> 
> This fixed several bugs in real code running on ARM.

I'd prefer to completely remove this from instcombine.  To do this, please verify that we are already doing the equivalent lowering in codegen (e.g. on x86 a 2 and 4-byte memset should turn into an unaligned store).  Then verify that disabling the instcombine xform doesn't cause any significant changes in codegen on multisource (or something else signifcant).

-Chris


From anton at korobeynikov.info  Thu Nov 26 15:30:16 2009
From: anton at korobeynikov.info (Anton Korobeynikov)
Date: Fri, 27 Nov 2009 00:30:16 +0300
Subject: [llvm-commits] Invalid instcombine transformation
In-Reply-To: <6634FC61-E6AE-4FA4-BCF2-267F390C1735@apple.com>
References: <1259267143.21630.143.camel@aslstation>
	<6634FC61-E6AE-4FA4-BCF2-267F390C1735@apple.com>
Message-ID: 

Hi, Chris

> The target *has* to support unaligned accesses.
Sorry, this is definitely unreal :) Especially in embedded world. And
not only there (think about sparc/solaris).

> I'd prefer to completely remove this from instcombine. ?To do this, please verify that we are already doing the equivalent lowering in codegen (e.g. on x86 a 2 and 4-byte memset should turn into an unaligned store). ?Then verify that disabling the instcombine xform doesn't cause any significant changes in codegen on multisource (or something else signifcant).
Ok.

-- 
With best regards, Anton Korobeynikov
Faculty of Mathematics and Mechanics, Saint Petersburg State University



From bob.wilson at apple.com  Thu Nov 26 15:38:42 2009
From: bob.wilson at apple.com (Bob Wilson)
Date: Thu, 26 Nov 2009 21:38:42 -0000
Subject: [llvm-commits] [llvm] r89968 - in /llvm/trunk:
 include/llvm/CodeGen/Passes.h lib/CodeGen/LLVMTargetMachine.cpp
 lib/CodeGen/TailDuplication.cpp
Message-ID: <200911262138.nAQLcgII014775@zion.cs.uiuc.edu>

Author: bwilson
Date: Thu Nov 26 15:38:41 2009
New Revision: 89968

URL: http://llvm.org/viewvc/llvm-project?rev=89968&view=rev
Log:
Rename new TailDuplicationPass to avoid name conflict with the old one.

Modified:
    llvm/trunk/include/llvm/CodeGen/Passes.h
    llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
    llvm/trunk/lib/CodeGen/TailDuplication.cpp

Modified: llvm/trunk/include/llvm/CodeGen/Passes.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/Passes.h?rev=89968&r1=89967&r2=89968&view=diff

==============================================================================
--- llvm/trunk/include/llvm/CodeGen/Passes.h (original)
+++ llvm/trunk/include/llvm/CodeGen/Passes.h Thu Nov 26 15:38:41 2009
@@ -129,9 +129,9 @@
   /// branches.
   FunctionPass *createBranchFoldingPass(bool DefaultEnableTailMerge);
 
-  /// TailDuplication Pass - Duplicate blocks with unconditional branches
+  /// TailDuplicate Pass - Duplicate blocks with unconditional branches
   /// into tails of their predecessors.
-  FunctionPass *createTailDuplicationPass();
+  FunctionPass *createTailDuplicatePass();
 
   /// IfConverter Pass - This pass performs machine code if conversion.
   FunctionPass *createIfConverterPass();

Modified: llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp?rev=89968&r1=89967&r2=89968&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp (original)
+++ llvm/trunk/lib/CodeGen/LLVMTargetMachine.cpp Thu Nov 26 15:38:41 2009
@@ -348,8 +348,8 @@
 
   // Tail duplication.
   if (OptLevel != CodeGenOpt::None && !DisableTailDuplicate) {
-    PM.add(createTailDuplicationPass());
-    printAndVerify(PM, "After TailDuplication");
+    PM.add(createTailDuplicatePass());
+    printAndVerify(PM, "After TailDuplicate");
   }
 
   PM.add(createGCMachineCodeAnalysisPass());

Modified: llvm/trunk/lib/CodeGen/TailDuplication.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/TailDuplication.cpp?rev=89968&r1=89967&r2=89968&view=diff

==============================================================================
--- llvm/trunk/lib/CodeGen/TailDuplication.cpp (original)
+++ llvm/trunk/lib/CodeGen/TailDuplication.cpp Thu Nov 26 15:38:41 2009
@@ -37,14 +37,14 @@
                   cl::init(2), cl::Hidden);
 
 namespace {
-  /// TailDuplicationPass - Perform tail duplication.
-  class TailDuplicationPass : public MachineFunctionPass {
+  /// TailDuplicatePass - Perform tail duplication.
+  class TailDuplicatePass : public MachineFunctionPass {
     const TargetInstrInfo *TII;
     MachineModuleInfo *MMI;
 
   public:
     static char ID;
-    explicit TailDuplicationPass() : MachineFunctionPass(&ID) {}
+    explicit TailDuplicatePass() : MachineFunctionPass(&ID) {}
 
     virtual bool runOnMachineFunction(MachineFunction &MF);
     virtual const char *getPassName() const { return "Tail Duplication"; }
@@ -55,14 +55,14 @@
     void RemoveDeadBlock(MachineBasicBlock *MBB);
   };
 
-  char TailDuplicationPass::ID = 0;
+  char TailDuplicatePass::ID = 0;
 }
 
-FunctionPass *llvm::createTailDuplicationPass() {
-  return new TailDuplicationPass();
+FunctionPass *llvm::createTailDuplicatePass() {
+  return new TailDuplicatePass();
 }
 
-bool TailDuplicationPass::runOnMachineFunction(MachineFunction &MF) {
+bool TailDuplicatePass::runOnMachineFunction(MachineFunction &MF) {
   TII = MF.getTarget().getInstrInfo();
   MMI = getAnalysisIfAvailable();
 
@@ -80,7 +80,7 @@
 /// TailDuplicateBlocks - Look for small blocks that are unconditionally
 /// branched to and do not fall through. Tail-duplicate their instructions
 /// into their predecessors to eliminate (dynamic) branches.
-bool TailDuplicationPass::TailDuplicateBlocks(MachineFunction &MF) {
+bool TailDuplicatePass::TailDuplicateBlocks(MachineFunction &MF) {
   bool MadeChange = false;
 
   for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ) {
@@ -105,7 +105,7 @@
 
 /// TailDuplicate - If it is profitable, duplicate TailBB's contents in each
 /// of its predecessors.
-bool TailDuplicationPass::TailDuplicate(MachineBasicBlock *TailBB,
+bool TailDuplicatePass::TailDuplicate(MachineBasicBlock *TailBB,
                                         MachineFunction &MF) {
   // Don't try to tail-duplicate single-block loops.
   if (TailBB->isSuccessor(TailBB))
@@ -225,7 +225,7 @@
 
 /// RemoveDeadBlock - Remove the specified dead machine basic block from the
 /// function, updating the CFG.
-void TailDuplicationPass::RemoveDeadBlock(MachineBasicBlock *MBB) {
+void TailDuplicatePass::RemoveDeadBlock(MachineBasicBlock *MBB) {
   assert(MBB->pred_empty() && "MBB must be dead!");
   DEBUG(errs() << "\nRemoving MBB: " << *MBB);
 




From sabre at nondot.org  Thu Nov 26 15:42:48 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 21:42:48 -0000
Subject: [llvm-commits] [llvm] r89970 -
	/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
Message-ID: <200911262142.nAQLgmlS014915@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 15:42:47 2009
New Revision: 89970

URL: http://llvm.org/viewvc/llvm-project?rev=89970&view=rev
Log:
implement a bunch of xforms for overflow intrinsics, based on a patch
by Alastair Lynn.


Modified:
    llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp

Modified: llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp?rev=89970&r1=89969&r2=89970&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp Thu Nov 26 15:42:47 2009
@@ -9872,6 +9872,120 @@
       if (Operand->getIntrinsicID() == Intrinsic::bswap)
         return ReplaceInstUsesWith(CI, Operand->getOperand(1));
     break;
+  case Intrinsic::uadd_with_overflow: {
+    Value *LHS = II->getOperand(1), *RHS = II->getOperand(2);
+    const IntegerType *IT = cast(II->getOperand(1)->getType());
+    uint32_t BitWidth = IT->getBitWidth();
+    APInt Mask = APInt::getSignBit(BitWidth);
+    APInt LHSKnownZero, LHSKnownOne, RHSKnownZero, RHSKnownOne;
+    ComputeMaskedBits(LHS, Mask, LHSKnownZero, LHSKnownOne);
+    bool LHSKnownNegative = LHSKnownOne[BitWidth - 1];
+    bool LHSKnownPositive = LHSKnownZero[BitWidth - 1];
+
+    if (LHSKnownNegative || LHSKnownPositive) {
+      ComputeMaskedBits(RHS, Mask, RHSKnownZero, RHSKnownOne);
+      bool RHSKnownNegative = RHSKnownOne[BitWidth - 1];
+      bool RHSKnownPositive = RHSKnownZero[BitWidth - 1];
+      if (LHSKnownNegative && RHSKnownNegative) {
+        // The sign bit is set in both cases: this MUST overflow.
+        // Create a simple add instruction, and insert it into the struct.
+        Instruction *Add = BinaryOperator::CreateAdd(LHS, RHS, "", &CI);
+        Worklist.Add(Add);
+        Constant *V[2];
+        V[0] = UndefValue::get(LHS->getType());
+        V[1] = ConstantInt::getTrue(*Context);
+        Constant *Struct = ConstantStruct::get(*Context, V, 2, false);
+        return InsertValueInst::Create(Struct, Add, 0);
+      }
+      
+      if (LHSKnownPositive && RHSKnownPositive) {
+        // The sign bit is clear in both cases: this CANNOT overflow.
+        // Create a simple add instruction, and insert it into the struct.
+        Instruction *Add = BinaryOperator::CreateNUWAdd(LHS, RHS, "", &CI);
+        Worklist.Add(Add);
+        Constant *V[2];
+        V[0] = UndefValue::get(LHS->getType());
+        V[1] = ConstantInt::getFalse(*Context);
+        Constant *Struct = ConstantStruct::get(*Context, V, 2, false);
+        return InsertValueInst::Create(Struct, Add, 0);
+      }
+    }
+  }
+  // FALL THROUGH uadd into sadd
+  case Intrinsic::sadd_with_overflow:
+    // Canonicalize constants into the RHS.
+    if (isa(II->getOperand(1)) &&
+        !isa(II->getOperand(2))) {
+      Value *LHS = II->getOperand(1);
+      II->setOperand(1, II->getOperand(2));
+      II->setOperand(2, LHS);
+      return II;
+    }
+
+    // X + undef -> undef
+    if (isa(II->getOperand(2)))
+      return ReplaceInstUsesWith(CI, UndefValue::get(II->getType()));
+      
+    if (ConstantInt *RHS = dyn_cast(II->getOperand(2))) {
+      // X + 0 -> {X, false}
+      if (RHS->isZero()) {
+        Constant *V[] = {
+          UndefValue::get(II->getType()), ConstantInt::getFalse(*Context)
+        };
+        Constant *Struct = ConstantStruct::get(*Context, V, 2, false);
+        return InsertValueInst::Create(Struct, II->getOperand(1), 0);
+      }
+    }
+    break;
+  case Intrinsic::usub_with_overflow:
+  case Intrinsic::ssub_with_overflow:
+    // undef - X -> undef
+    // X - undef -> undef
+    if (isa(II->getOperand(1)) ||
+        isa(II->getOperand(2)))
+      return ReplaceInstUsesWith(CI, UndefValue::get(II->getType()));
+      
+    if (ConstantInt *RHS = dyn_cast(II->getOperand(2))) {
+      // X - 0 -> {X, false}
+      if (RHS->isZero()) {
+        Constant *V[] = {
+          UndefValue::get(II->getType()), ConstantInt::getFalse(*Context)
+        };
+        Constant *Struct = ConstantStruct::get(*Context, V, 2, false);
+        return InsertValueInst::Create(Struct, II->getOperand(1), 0);
+      }
+    }
+    break;
+  case Intrinsic::umul_with_overflow:
+  case Intrinsic::smul_with_overflow:
+    // Canonicalize constants into the RHS.
+    if (isa(II->getOperand(1)) &&
+        !isa(II->getOperand(2))) {
+      Value *LHS = II->getOperand(1);
+      II->setOperand(1, II->getOperand(2));
+      II->setOperand(2, LHS);
+      return II;
+    }
+
+    // X * undef -> undef
+    if (isa(II->getOperand(2)))
+      return ReplaceInstUsesWith(CI, UndefValue::get(II->getType()));
+      
+    if (ConstantInt *RHSI = dyn_cast(II->getOperand(2))) {
+      // X*0 -> {0, false}
+      if (RHSI->isZero())
+        return ReplaceInstUsesWith(CI, Constant::getNullValue(II->getType()));
+      
+      // X * 1 -> {X, false}
+      if (RHSI->equalsInt(1)) {
+        Constant *V[2];
+        V[0] = UndefValue::get(II->getType());
+        V[1] = ConstantInt::getFalse(*Context);
+        Constant *Struct = ConstantStruct::get(*Context, V, 2, false);
+        return InsertValueInst::Create(Struct, II->getOperand(1), 1);
+      }
+    }
+    break;
   case Intrinsic::ppc_altivec_lvx:
   case Intrinsic::ppc_altivec_lvxl:
   case Intrinsic::x86_sse_loadu_ps:




From clattner at apple.com  Thu Nov 26 15:43:25 2009
From: clattner at apple.com (Chris Lattner)
Date: Thu, 26 Nov 2009 13:43:25 -0800
Subject: [llvm-commits] Overflow intrinsics patch
In-Reply-To: <17C1443D-34E2-4FE9-BBF9-13BECDA37A51@gmail.com>
References: <17C1443D-34E2-4FE9-BBF9-13BECDA37A51@gmail.com>
Message-ID: 


On Nov 11, 2009, at 7:23 PM, Alastair Lynn wrote:

> Hello-
> 
> Third time lucky, here is the absolutely bug-free patch.

Thanks Alastair, sorry for the delay reviewing this.

I committed a simplified version of the patch as r89970.  Please send in a testcase that covers these xforms.

-Chris


From clattner at apple.com  Thu Nov 26 15:44:34 2009
From: clattner at apple.com (Chris Lattner)
Date: Thu, 26 Nov 2009 13:44:34 -0800
Subject: [llvm-commits] Invalid instcombine transformation
In-Reply-To: 
References: <1259267143.21630.143.camel@aslstation>
	<6634FC61-E6AE-4FA4-BCF2-267F390C1735@apple.com>
	
Message-ID: <71FB32CC-9F96-4FC0-BDBE-55741E5BBA5B@apple.com>


On Nov 26, 2009, at 1:30 PM, Anton Korobeynikov wrote:

> Hi, Chris
> 
>> The target *has* to support unaligned accesses.
> Sorry, this is definitely unreal :) Especially in embedded world. And
> not only there (think about sparc/solaris).

What do you mean?  Legalize can always 'fix' this for a target.  Unaligned load/store should always be legal for any target.

-Chris




From sabre at nondot.org  Thu Nov 26 16:04:42 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 22:04:42 -0000
Subject: [llvm-commits] [llvm] r89971 - in /llvm/trunk:
 lib/Transforms/Scalar/InstructionCombining.cpp
 test/Transforms/InstCombine/crash.ll test/Transforms/InstCombine/store.ll
Message-ID: <200911262204.nAQM4gWY015836@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 16:04:42 2009
New Revision: 89971

URL: http://llvm.org/viewvc/llvm-project?rev=89971&view=rev
Log:
Fix PR5471 by removing an instcombine xform.  Some pieces of the code
generates store to undef and some generates store to null as the idiom
for undefined behavior.  Since simplifycfg zaps both, don't remove the
undefined behavior in instcombine.

Modified:
    llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
    llvm/trunk/test/Transforms/InstCombine/crash.ll
    llvm/trunk/test/Transforms/InstCombine/store.ll

Modified: llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp?rev=89971&r1=89970&r2=89971&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp Thu Nov 26 16:04:42 2009
@@ -12096,12 +12096,6 @@
   Value *Val = SI.getOperand(0);
   Value *Ptr = SI.getOperand(1);
 
-  if (isa(Ptr)) {     // store X, undef -> noop (even if volatile)
-    EraseInstFromFunction(SI);
-    ++NumCombined;
-    return 0;
-  }
-  
   // If the RHS is an alloca with a single use, zapify the store, making the
   // alloca dead.
   // If the RHS is an alloca with a two uses, the other one being a 

Modified: llvm/trunk/test/Transforms/InstCombine/crash.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/crash.ll?rev=89971&r1=89970&r2=89971&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/InstCombine/crash.ll (original)
+++ llvm/trunk/test/Transforms/InstCombine/crash.ll Thu Nov 26 16:04:42 2009
@@ -125,3 +125,15 @@
   %v11 = select i1 %v5_, i64 0, i64 %v6
   ret i64 %v11
 }
+
+; PR5471
+define arm_apcscc i32 @test5a() {
+       ret i32 0
+}
+
+define arm_apcscc void @test5() {
+       store i1 true, i1* undef
+       %1 = invoke i32 @test5a() to label %exit unwind label %exit
+exit:
+       ret void
+}

Modified: llvm/trunk/test/Transforms/InstCombine/store.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/InstCombine/store.ll?rev=89971&r1=89970&r2=89971&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/InstCombine/store.ll (original)
+++ llvm/trunk/test/Transforms/InstCombine/store.ll Thu Nov 26 16:04:42 2009
@@ -6,6 +6,7 @@
         store i32 124, i32* null
         ret void
 ; CHECK: @test1(
+; CHECK-NEXT: store i32 123, i32* undef
 ; CHECK-NEXT: store i32 undef, i32* null
 ; CHECK-NEXT: ret void
 }




From sabre at nondot.org  Thu Nov 26 16:08:06 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 22:08:06 -0000
Subject: [llvm-commits] [llvm] r89972 -
	/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
Message-ID: <200911262208.nAQM8636015959@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 16:08:06 2009
New Revision: 89972

URL: http://llvm.org/viewvc/llvm-project?rev=89972&view=rev
Log:
fix crash on Transforms/InstCombine/intrinsics.ll introduced by r89970 

Modified:
    llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp

Modified: llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp?rev=89972&r1=89971&r2=89972&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp Thu Nov 26 16:08:06 2009
@@ -9877,12 +9877,15 @@
     const IntegerType *IT = cast(II->getOperand(1)->getType());
     uint32_t BitWidth = IT->getBitWidth();
     APInt Mask = APInt::getSignBit(BitWidth);
-    APInt LHSKnownZero, LHSKnownOne, RHSKnownZero, RHSKnownOne;
+    APInt LHSKnownZero(BitWidth, 0);
+    APInt LHSKnownOne(BitWidth, 0);
     ComputeMaskedBits(LHS, Mask, LHSKnownZero, LHSKnownOne);
     bool LHSKnownNegative = LHSKnownOne[BitWidth - 1];
     bool LHSKnownPositive = LHSKnownZero[BitWidth - 1];
 
     if (LHSKnownNegative || LHSKnownPositive) {
+      APInt RHSKnownZero(BitWidth, 0);
+      APInt RHSKnownOne(BitWidth, 0);
       ComputeMaskedBits(RHS, Mask, RHSKnownZero, RHSKnownOne);
       bool RHSKnownNegative = RHSKnownOne[BitWidth - 1];
       bool RHSKnownPositive = RHSKnownZero[BitWidth - 1];




From nicholas at mxc.ca  Thu Nov 26 16:15:58 2009
From: nicholas at mxc.ca (Nick Lewycky)
Date: Thu, 26 Nov 2009 14:15:58 -0800
Subject: [llvm-commits] [PATCH] LTO code generator options
In-Reply-To: <352a1fb20911250925q4d4b8b9fwae1ac454f4c0341c@mail.gmail.com>
References: <04F6B1512E264B27AEE607542FCDD113@andreic6e7fe55>	<41BA1AA405BC4D19BA9B4FAB6543D62F@andreic6e7fe55>	<38a0d8450911190723g644ad4c7ife769ab35da9efb9@mail.gmail.com>		<38a0d8450911200722i5efa690ci6ab671d71b5f40dc@mail.gmail.com>		<38a0d8450911231309t6f37e2a0ga7c9eaa50d495c60@mail.gmail.com>	<2E9E5BD4D91C4B32850CD83726EFE19B@andreic6e7fe55>	<352a1fb20911241558o4131950di5e3bac9db3a31e30@mail.gmail.com>	<3780A335BCB5498984B6E0408C2EDB0D@andreic6e7fe55>
	<352a1fb20911250925q4d4b8b9fwae1ac454f4c0341c@mail.gmail.com>
Message-ID: <4B0EFE1E.3000000@mxc.ca>

Devang Patel wrote:
> 3 - It is quite reasonable for some to put two copies of a function,
> one for SSE3 machines, one for non-SSE machines, in one bitcode file
> and let code generator generate appropriate code for each functions so
> that the user can select desired function at run time. At Apple, we
> supported similar requirements for Altivec vs. non-Altivec code. This
> can be achieved if subtarget features like SSE3 are encoded in bitcode
> files.

Now that's an interesting idea. There's one obvious major issue with it, 
which is that we would end up with two different function definitions 
with the same name. Assuming we can overcome that, we then run into 
issues with (for example) the inliner being unable to inline a function 
because it doesn't know what the subtarget is.

Otherwise, this 'fat llvm ir' sounds like it would work, if that's what 
you really wanted to do-- which I don't think it is. I have trouble 
creating an argument for why it's bad, but I note that this is contrary 
to the way LLVM has approached portability thus far.

Nick


From anton at korobeynikov.info  Thu Nov 26 16:20:51 2009
From: anton at korobeynikov.info (Anton Korobeynikov)
Date: Fri, 27 Nov 2009 01:20:51 +0300
Subject: [llvm-commits] Invalid instcombine transformation
In-Reply-To: <71FB32CC-9F96-4FC0-BDBE-55741E5BBA5B@apple.com>
References: <1259267143.21630.143.camel@aslstation>
	<6634FC61-E6AE-4FA4-BCF2-267F390C1735@apple.com>
	
	<71FB32CC-9F96-4FC0-BDBE-55741E5BBA5B@apple.com>
Message-ID: <1259274051.21630.147.camel@aslstation>

Hi, Chris

> What do you mean?  Legalize can always 'fix' this for a target.  Unaligned load/store should always be legal for any target.
Looks like it didn't in this case... Maybe we're just caught some
legalize bug as well. I will investigate

-- 
With best regards, Anton Korobeynikov.

Faculty of Mathematics & Mechanics, Saint Petersburg State University.



From clattner at apple.com  Thu Nov 26 16:36:37 2009
From: clattner at apple.com (Chris Lattner)
Date: Thu, 26 Nov 2009 14:36:37 -0800
Subject: [llvm-commits] Invalid instcombine transformation
In-Reply-To: <1259274051.21630.147.camel@aslstation>
References: <1259267143.21630.143.camel@aslstation>
	<6634FC61-E6AE-4FA4-BCF2-267F390C1735@apple.com>
	
	<71FB32CC-9F96-4FC0-BDBE-55741E5BBA5B@apple.com>
	<1259274051.21630.147.camel@aslstation>
Message-ID: 


On Nov 26, 2009, at 2:20 PM, Anton Korobeynikov wrote:

> Hi, Chris
> 
>> What do you mean?  Legalize can always 'fix' this for a target.  Unaligned load/store should always be legal for any target.
> Looks like it didn't in this case... Maybe we're just caught some
> legalize bug as well. I will investigate

Thanks Anton!

-Chris


From sabre at nondot.org  Thu Nov 26 16:48:24 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 22:48:24 -0000
Subject: [llvm-commits] [llvm] r89973 -
	/llvm/trunk/lib/AsmParser/LLParser.cpp
Message-ID: <200911262248.nAQMmOB2017485@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 16:48:23 2009
New Revision: 89973

URL: http://llvm.org/viewvc/llvm-project?rev=89973&view=rev
Log:
Add a hack for PR5601, a crash on obsolete syntax that we plan to
remove in LLVM 3.0

Modified:
    llvm/trunk/lib/AsmParser/LLParser.cpp

Modified: llvm/trunk/lib/AsmParser/LLParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/AsmParser/LLParser.cpp?rev=89973&r1=89972&r2=89973&view=diff

==============================================================================
--- llvm/trunk/lib/AsmParser/LLParser.cpp (original)
+++ llvm/trunk/lib/AsmParser/LLParser.cpp Thu Nov 26 16:48:23 2009
@@ -2701,6 +2701,10 @@
   // Add all of the arguments we parsed to the function.
   Function::arg_iterator ArgIt = Fn->arg_begin();
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
+    // If we run out of arguments in the Function prototype, exit early.
+    // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above.
+    if (ArgIt == Fn->arg_end()) break;
+    
     // If the argument has a name, insert it into the argument symbol table.
     if (ArgList[i].Name.empty()) continue;
 




From nicholas at mxc.ca  Thu Nov 26 16:54:26 2009
From: nicholas at mxc.ca (Nick Lewycky)
Date: Thu, 26 Nov 2009 22:54:26 -0000
Subject: [llvm-commits] [llvm] r89974 - /llvm/trunk/lib/VMCore/Metadata.cpp
Message-ID: <200911262254.nAQMsQ5X017677@zion.cs.uiuc.edu>

Author: nicholas
Date: Thu Nov 26 16:54:26 2009
New Revision: 89974

URL: http://llvm.org/viewvc/llvm-project?rev=89974&view=rev
Log:
Clean up file, no functionality change.

Modified:
    llvm/trunk/lib/VMCore/Metadata.cpp

Modified: llvm/trunk/lib/VMCore/Metadata.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Metadata.cpp?rev=89974&r1=89973&r2=89974&view=diff

==============================================================================
--- llvm/trunk/lib/VMCore/Metadata.cpp (original)
+++ llvm/trunk/lib/VMCore/Metadata.cpp Thu Nov 26 16:54:26 2009
@@ -33,10 +33,8 @@
   StringMapEntry &Entry = 
     pImpl->MDStringCache.GetOrCreateValue(Str);
   MDString *&S = Entry.getValue();
-  if (S) return S;
-  
-  return S = 
-    new MDString(Context, Entry.getKey());
+  if (!S) S = new MDString(Context, Entry.getKey());
+  return S;
 }
 
 MDString *MDString::get(LLVMContext &Context, const char *Str) {
@@ -44,10 +42,8 @@
   StringMapEntry &Entry = 
     pImpl->MDStringCache.GetOrCreateValue(Str ? StringRef(Str) : StringRef());
   MDString *&S = Entry.getValue();
-  if (S) return S;
-  
-  return S = 
-    new MDString(Context, Entry.getKey());
+  if (!S) new MDString(Context, Entry.getKey());
+  return S;
 }
 
 //===----------------------------------------------------------------------===//
@@ -74,28 +70,19 @@
     ID.AddPointer(Vals[i]);
 
   void *InsertPoint;
-  MDNode *N;
-  {
-    N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint);
-  }  
-  if (N) return N;
-  
-  N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint);
+  MDNode *N = pImpl->MDNodeSet.FindNodeOrInsertPos(ID, InsertPoint);
   if (!N) {
     // InsertPoint will have been set by the FindNodeOrInsertPos call.
     N = new MDNode(Context, Vals, NumVals);
     pImpl->MDNodeSet.InsertNode(N, InsertPoint);
   }
-
   return N;
 }
 
 /// ~MDNode - Destroy MDNode.
 MDNode::~MDNode() {
-  {
-    LLVMContextImpl *pImpl = getType()->getContext().pImpl;
-    pImpl->MDNodeSet.RemoveNode(this);
-  }
+  LLVMContextImpl *pImpl = getType()->getContext().pImpl;
+  pImpl->MDNodeSet.RemoveNode(this);
   delete [] Node;
   Node = NULL;
 }
@@ -241,7 +228,7 @@
   /// the same metadata to In2.
   void copyMD(Instruction *In1, Instruction *In2);
 
-  /// getHandlerNames - Populate client supplied smallvector using custome
+  /// getHandlerNames - Populate client-supplied smallvector using custom
   /// metadata name and ID.
   void getHandlerNames(SmallVectorImpl >&) const;
 
@@ -317,7 +304,7 @@
     }
   }
 }
-  
+
 /// removeAllMetadata - Remove all metadata attached with an instruction.
 void MetadataContextImpl::removeAllMetadata(Instruction *Inst) {
   MetadataStore.erase(Inst);
@@ -454,12 +441,12 @@
 void MetadataContext::addMD(unsigned Kind, MDNode *Node, Instruction *Inst) {
   pImpl->addMD(Kind, Node, Inst);
 }
-  
+
 /// removeMD - Remove metadata of given kind attached with an instuction.
 void MetadataContext::removeMD(unsigned Kind, Instruction *Inst) {
   pImpl->removeMD(Kind, Inst);
 }
-  
+
 /// removeAllMetadata - Remove all metadata attached with an instruction.
 void MetadataContext::removeAllMetadata(Instruction *Inst) {
   pImpl->removeAllMetadata(Inst);




From sabre at nondot.org  Thu Nov 26 17:18:49 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 23:18:49 -0000
Subject: [llvm-commits] [llvm] r89975 -
	/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
Message-ID: <200911262318.nAQNInQO018510@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 17:18:49 2009
New Revision: 89975

URL: http://llvm.org/viewvc/llvm-project?rev=89975&view=rev
Log:
factor some code out into some helper functions.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89975&r1=89974&r2=89975&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 17:18:49 2009
@@ -684,6 +684,33 @@
   }
 }
 
+/// isPHITranslatable - Return true if the specified computation is derived from
+/// a PHI node in the current block and if it is simple enough for us to handle.
+static bool isPHITranslatable(Instruction *Inst) {
+  if (isa(Inst))
+    return true;
+  
+  // TODO: BITCAST, GEP.
+
+  // ...
+  
+  //   cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
+  //   if (isa(PtrInst) || isa(PtrInst))
+  //     cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
+  
+  return false;
+}
+
+/// PHITranslateForPred - Given a computation that satisfied the
+/// isPHITranslatable predicate, see if we can translate the computation into
+/// the specified predecessor block.  If so, return that value.
+static Value *PHITranslateForPred(Instruction *Inst, BasicBlock *Pred) {
+  if (PHINode *PN = dyn_cast(Inst))
+    return PN->getIncomingValueForBlock(Pred);
+  
+  return 0;
+}
+
 
 /// getNonLocalPointerDepFromBB - Perform a dependency query based on
 /// pointer/pointeesize starting at the end of StartBB.  Add any clobber/def
@@ -827,14 +854,18 @@
       NumSortedEntries = Cache->size();
     }
     
-    // If this is directly a PHI node, just use the incoming values for each
-    // pred as the phi translated version.
-    if (PHINode *PtrPHI = dyn_cast(PtrInst)) {
+    // If this is a computation derived from a PHI node, use the suitably
+    // translated incoming values for each pred as the phi translated version.
+    if (isPHITranslatable(PtrInst)) {
       Cache = 0;
       
       for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
         BasicBlock *Pred = *PI;
-        Value *PredPtr = PtrPHI->getIncomingValueForBlock(Pred);
+        Value *PredPtr = PHITranslateForPred(PtrInst, Pred);
+        
+        // If PHI translation fails, bail out.
+        if (PredPtr == 0)
+          goto PredTranslationFailure;
         
         // Check to see if we have already visited this pred block with another
         // pointer.  If so, we can't do this lookup.  This failure can occur
@@ -881,12 +912,7 @@
       SkipFirstBlock = false;
       continue;
     }
-    
-    // TODO: BITCAST, GEP.
-    
-    //   cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
-    //   if (isa(PtrInst) || isa(PtrInst))
-    //     cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
+
   PredTranslationFailure:
     
     if (Cache == 0) {




From nicholas at mxc.ca  Thu Nov 26 17:19:05 2009
From: nicholas at mxc.ca (Nick Lewycky)
Date: Thu, 26 Nov 2009 23:19:05 -0000
Subject: [llvm-commits] [llvm] r89976 - /llvm/trunk/lib/VMCore/Metadata.cpp
Message-ID: <200911262319.nAQNJ67v018528@zion.cs.uiuc.edu>

Author: nicholas
Date: Thu Nov 26 17:19:05 2009
New Revision: 89976

URL: http://llvm.org/viewvc/llvm-project?rev=89976&view=rev
Log:
Fix typo spotted by Gabor Greif.

Modified:
    llvm/trunk/lib/VMCore/Metadata.cpp

Modified: llvm/trunk/lib/VMCore/Metadata.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/VMCore/Metadata.cpp?rev=89976&r1=89975&r2=89976&view=diff

==============================================================================
--- llvm/trunk/lib/VMCore/Metadata.cpp (original)
+++ llvm/trunk/lib/VMCore/Metadata.cpp Thu Nov 26 17:19:05 2009
@@ -218,7 +218,7 @@
   /// addMD - Attach the metadata of given kind to an Instruction.
   void addMD(unsigned Kind, MDNode *Node, Instruction *Inst);
   
-  /// removeMD - Remove metadata of given kind attached with an instuction.
+  /// removeMD - Remove metadata of given kind attached with an instruction.
   void removeMD(unsigned Kind, Instruction *Inst);
   
   /// removeAllMetadata - Remove all metadata attached with an instruction.
@@ -289,7 +289,7 @@
   Info.push_back(std::make_pair(MDKind, Node));
 }
 
-/// removeMD - Remove metadata of given kind attached with an instuction.
+/// removeMD - Remove metadata of given kind attached with an instruction.
 void MetadataContextImpl::removeMD(unsigned Kind, Instruction *Inst) {
   MDStoreTy::iterator I = MetadataStore.find(Inst);
   if (I == MetadataStore.end())
@@ -442,7 +442,7 @@
   pImpl->addMD(Kind, Node, Inst);
 }
 
-/// removeMD - Remove metadata of given kind attached with an instuction.
+/// removeMD - Remove metadata of given kind attached with an instruction.
 void MetadataContext::removeMD(unsigned Kind, Instruction *Inst) {
   pImpl->removeMD(Kind, Inst);
 }




From sabre at nondot.org  Thu Nov 26 17:33:00 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 23:33:00 -0000
Subject: [llvm-commits] [llvm] r89977 -
	/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911262333.nAQNX0Qv018969@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 17:32:59 2009
New Revision: 89977

URL: http://llvm.org/viewvc/llvm-project?rev=89977&view=rev
Log:
convert to filecheck

Modified:
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89977&r1=89976&r2=89977&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 17:32:59 2009
@@ -1,32 +1,36 @@
-; RUN: opt < %s -gvn -S | grep {%cv = phi i32}
-; RUN: opt < %s -gvn -S | grep {%bv = phi i32}
+; RUN: opt < %s -gvn -S | FileCheck %s
+
 target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"
 target triple = "i386-apple-darwin7"
 
-define i32 @g(i32* %b, i32* %c) nounwind {
+define i32 @test1(i32* %b, i32* %c) nounwind {
 entry:
-	%g = alloca i32		;  [#uses=4]
-	%t1 = icmp eq i32* %b, null		;  [#uses=1]
+	%g = alloca i32
+	%t1 = icmp eq i32* %b, null
 	br i1 %t1, label %bb, label %bb1
 
-bb:		; preds = %entry
-	%t2 = load i32* %c, align 4		;  [#uses=1]
-	%t3 = add i32 %t2, 1		;  [#uses=1]
+bb:
+	%t2 = load i32* %c, align 4
+	%t3 = add i32 %t2, 1
 	store i32 %t3, i32* %g, align 4
 	br label %bb2
 
 bb1:		; preds = %entry
-	%t5 = load i32* %b, align 4		;  [#uses=1]
-	%t6 = add i32 %t5, 1		;  [#uses=1]
+	%t5 = load i32* %b, align 4
+	%t6 = add i32 %t5, 1
 	store i32 %t6, i32* %g, align 4
 	br label %bb2
 
 bb2:		; preds = %bb1, %bb
-	%c_addr.0 = phi i32* [ %g, %bb1 ], [ %c, %bb ]		;  [#uses=1]
-	%b_addr.0 = phi i32* [ %b, %bb1 ], [ %g, %bb ]		;  [#uses=1]
-	%cv = load i32* %c_addr.0, align 4		;  [#uses=1]
-	%bv = load i32* %b_addr.0, align 4		;  [#uses=1]
-	%ret = add i32 %cv, %bv		;  [#uses=1]
+	%c_addr.0 = phi i32* [ %g, %bb1 ], [ %c, %bb ]
+	%b_addr.0 = phi i32* [ %b, %bb1 ], [ %g, %bb ]
+	%cv = load i32* %c_addr.0, align 4
+	%bv = load i32* %b_addr.0, align 4
+; CHECK: %bv = phi i32
+; CHECK: %cv = phi i32
+; CHECK-NOT: load
+; CHECK: ret i32
+	%ret = add i32 %cv, %bv
 	ret i32 %ret
 }
 




From sabre at nondot.org  Thu Nov 26 17:41:07 2009
From: sabre at nondot.org (Chris Lattner)
Date: Thu, 26 Nov 2009 23:41:07 -0000
Subject: [llvm-commits] [llvm] r89978 - in /llvm/trunk:
 lib/Analysis/MemoryDependenceAnalysis.cpp lib/Target/README.txt
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911262341.nAQNf7Uf019235@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 17:41:07 2009
New Revision: 89978

URL: http://llvm.org/viewvc/llvm-project?rev=89978&view=rev
Log:
Teach memdep to phi translate bitcasts.  This allows us to compile
the example in GCC PR16799 to:

LBB1_2:                                                     ## %bb1
	movl	%eax, %eax
	subq	%rax, %rdi
	movq	%rdi, (%rcx)
	movl	(%rdi), %eax
	testl	%eax, %eax
	je	LBB1_2

instead of:

LBB1_2:                                                     ## %bb1
	movl	(%rdi), %ecx
	subq	%rcx, %rdi
	movq	%rdi, (%rax)
	cmpl	$0, (%rdi)
	je	LBB1_2


Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/lib/Target/README.txt
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89978&r1=89977&r2=89978&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 17:41:07 2009
@@ -690,10 +690,15 @@
   if (isa(Inst))
     return true;
   
-  // TODO: BITCAST, GEP.
-
-  // ...
+  // We can handle bitcast of a PHI, but the PHI needs to be in the same block
+  // as the bitcast.
+  if (BitCastInst *BC = dyn_cast(Inst))
+    if (PHINode *PN = dyn_cast(BC->getOperand(0)))
+      if (PN->getParent() == BC->getParent())
+        return true;
   
+  // TODO: GEP, ...
+
   //   cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
   //   if (isa(PtrInst) || isa(PtrInst))
   //     cerr << "OP:\t\t\t\t" << *PtrInst->getOperand(0);
@@ -708,6 +713,25 @@
   if (PHINode *PN = dyn_cast(Inst))
     return PN->getIncomingValueForBlock(Pred);
   
+  if (BitCastInst *BC = dyn_cast(Inst)) {
+    PHINode *BCPN = cast(BC->getOperand(0));
+    Value *PHIIn = BCPN->getIncomingValueForBlock(Pred);
+    
+    // Constants are trivial to phi translate.
+    if (Constant *C = dyn_cast(PHIIn))
+      return ConstantExpr::getBitCast(C, BC->getType());
+    
+    // Otherwise we have to see if a bitcasted version of the incoming pointer
+    // is available.  If so, we can use it, otherwise we have to fail.
+    for (Value::use_iterator UI = PHIIn->use_begin(), E = PHIIn->use_end();
+         UI != E; ++UI) {
+      if (BitCastInst *BCI = dyn_cast(*UI))
+        if (BCI->getType() == BC->getType())
+          return BCI;
+    }
+    return 0;
+  }
+
   return 0;
 }
 

Modified: llvm/trunk/lib/Target/README.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/README.txt?rev=89978&r1=89977&r2=89978&view=diff

==============================================================================
--- llvm/trunk/lib/Target/README.txt (original)
+++ llvm/trunk/lib/Target/README.txt Thu Nov 26 17:41:07 2009
@@ -1284,8 +1284,6 @@
 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=34677 (licm does this, LPRE crit edge)
   llvm-gcc t2.c -S -o - -O0 -emit-llvm | llvm-as | opt -mem2reg -simplifycfg -gvn | llvm-dis
 
-http://gcc.gnu.org/bugzilla/show_bug.cgi?id=16799 [BITCAST PHI TRANS]
-
 //===---------------------------------------------------------------------===//
 
 Type based alias analysis:

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89978&r1=89977&r2=89978&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 17:41:07 2009
@@ -4,6 +4,7 @@
 target triple = "i386-apple-darwin7"
 
 define i32 @test1(i32* %b, i32* %c) nounwind {
+; CHECK: @test1
 entry:
 	%g = alloca i32
 	%t1 = icmp eq i32* %b, null
@@ -34,3 +35,28 @@
 	ret i32 %ret
 }
 
+define i8 @test2(i1 %cond, i32* %b, i32* %c) nounwind {
+; CHECK: @test2
+entry:
+	br i1 %cond, label %bb, label %bb1
+
+bb:
+  %b1 = bitcast i32* %b to i8*
+  store i8 4, i8* %b1
+	br label %bb2
+
+bb1:
+  %c1 = bitcast i32* %c to i8*
+  store i8 92, i8* %c1
+	br label %bb2
+
+bb2:
+	%d = phi i32* [ %c, %bb1 ], [ %b, %bb ]
+  %d1 = bitcast i32* %d to i8*
+	%dv = load i8* %d1
+; CHECK: %dv = phi i8
+; CHECK-NOT: load
+; CHECK: ret i8 %dv
+	ret i8 %dv
+}
+




From sabre at nondot.org  Thu Nov 26 18:07:37 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 00:07:37 -0000
Subject: [llvm-commits] [llvm] r89979 - in /llvm/trunk:
 lib/Analysis/MemoryDependenceAnalysis.cpp
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911270007.nAR07cYO019941@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 18:07:37 2009
New Revision: 89979

URL: http://llvm.org/viewvc/llvm-project?rev=89979&view=rev
Log:
teach memdep to do trivial PHI translation of GEPs.  More to
come.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89979&r1=89978&r2=89979&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 18:07:37 2009
@@ -697,7 +697,14 @@
       if (PN->getParent() == BC->getParent())
         return true;
   
-  // TODO: GEP, ...
+  // We can translate a GEP that uses a PHI in the current block for at least
+  // one of its operands.
+  if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
+    for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
+      if (PHINode *PN = dyn_cast(GEP->getOperand(i)))
+        if (PN->getParent() == GEP->getParent())
+          return true;
+  }
 
   //   cerr << "MEMDEP: Could not PHI translate: " << *Pointer;
   //   if (isa(PtrInst) || isa(PtrInst))
@@ -713,6 +720,7 @@
   if (PHINode *PN = dyn_cast(Inst))
     return PN->getIncomingValueForBlock(Pred);
   
+  // Handle bitcast of PHI.
   if (BitCastInst *BC = dyn_cast(Inst)) {
     PHINode *BCPN = cast(BC->getOperand(0));
     Value *PHIIn = BCPN->getIncomingValueForBlock(Pred);
@@ -732,6 +740,39 @@
     return 0;
   }
 
+  // Handle getelementptr with at least one PHI operand.
+  if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
+    SmallVector GEPOps;
+    Value *APHIOp = 0;
+    for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) {
+      GEPOps.push_back(GEP->getOperand(i));
+      if (PHINode *PN = dyn_cast(GEP->getOperand(i)))
+        if (PN->getParent() == GEP->getParent())
+          GEPOps.back() = APHIOp = PN->getIncomingValueForBlock(Pred);
+    }
+    
+    // TODO: Simplify the GEP to handle 'gep x, 0' -> x etc.
+    
+    // Scan to see if we have this GEP available.
+    for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end();
+         UI != E; ++UI) {
+      if (GetElementPtrInst *GEPI = dyn_cast(*UI))
+        if (GEPI->getType() == GEPI->getType() &&
+            GEPI->getNumOperands() == GEPOps.size() &&
+            GEPI->getParent()->getParent() == Inst->getParent()->getParent()) {
+          bool Mismatch = false;
+          for (unsigned i = 0, e = GEPOps.size(); i != e; ++i)
+            if (GEPI->getOperand(i) != GEPOps[i]) {
+              Mismatch = true;
+              break;
+            }
+          if (!Mismatch)
+            return GEPI;
+        }
+    }
+    return 0;
+  }
+  
   return 0;
 }
 

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89979&r1=89978&r2=89979&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 18:07:37 2009
@@ -54,9 +54,35 @@
 	%d = phi i32* [ %c, %bb1 ], [ %b, %bb ]
   %d1 = bitcast i32* %d to i8*
 	%dv = load i8* %d1
-; CHECK: %dv = phi i8
+; CHECK: %dv = phi i8 [ 92, %bb1 ], [ 4, %bb ]
 ; CHECK-NOT: load
 ; CHECK: ret i8 %dv
 	ret i8 %dv
 }
 
+define i32 @test3(i1 %cond, i32* %b, i32* %c) nounwind {
+; CHECK: @test3
+entry:
+	br i1 %cond, label %bb, label %bb1
+
+bb:
+  %b1 = getelementptr i32* %b, i32 17
+  store i32 4, i32* %b1
+	br label %bb2
+
+bb1:
+  %c1 = getelementptr i32* %c, i32 7
+  store i32 82, i32* %c1
+	br label %bb2
+
+bb2:
+	%d = phi i32* [ %c, %bb1 ], [ %b, %bb ]
+	%i = phi i32 [ 7, %bb1 ], [ 17, %bb ]
+  %d1 = getelementptr i32* %d, i32 %i
+	%dv = load i32* %d1
+; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; CHECK-NOT: load
+; CHECK: ret i32 %dv
+	ret i32 %dv
+}
+




From sabre at nondot.org  Thu Nov 26 18:29:05 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 00:29:05 -0000
Subject: [llvm-commits] [llvm] r89980 - in /llvm/trunk:
 include/llvm/Analysis/InstructionSimplify.h
 lib/Analysis/InstructionSimplify.cpp
 lib/Transforms/Scalar/InstructionCombining.cpp
Message-ID: <200911270029.nAR0T6bV020547@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 18:29:05 2009
New Revision: 89980

URL: http://llvm.org/viewvc/llvm-project?rev=89980&view=rev
Log:
factor some instcombine simplifications for getelementptr out to a new 
SimplifyGEPInst method in InstructionSimplify.h.  No functionality change.

Modified:
    llvm/trunk/include/llvm/Analysis/InstructionSimplify.h
    llvm/trunk/lib/Analysis/InstructionSimplify.cpp
    llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp

Modified: llvm/trunk/include/llvm/Analysis/InstructionSimplify.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/InstructionSimplify.h?rev=89980&r1=89979&r2=89980&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Analysis/InstructionSimplify.h (original)
+++ llvm/trunk/include/llvm/Analysis/InstructionSimplify.h Thu Nov 26 18:29:05 2009
@@ -42,6 +42,11 @@
                           const TargetData *TD = 0);
   
 
+  /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
+  /// fold the result.  If not, this returns null.
+  Value *SimplifyGEPInst(Value * const *Ops, unsigned NumOps,
+                         const TargetData *TD = 0);
+  
   //=== Helper functions for higher up the class hierarchy.
   
   

Modified: llvm/trunk/lib/Analysis/InstructionSimplify.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/InstructionSimplify.cpp?rev=89980&r1=89979&r2=89980&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/InstructionSimplify.cpp (original)
+++ llvm/trunk/lib/Analysis/InstructionSimplify.cpp Thu Nov 26 18:29:05 2009
@@ -264,6 +264,34 @@
   return 0;
 }
 
+/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
+/// fold the result.  If not, this returns null.
+Value *llvm::SimplifyGEPInst(Value *const *Ops, unsigned NumOps,
+                             const TargetData *TD) {
+  // getelementptr P -> P.
+  if (NumOps == 1)
+    return Ops[0];
+
+  // TODO.
+  //if (isa(Ops[0]))
+  //  return UndefValue::get(GEP.getType());
+
+  // getelementptr P, 0 -> P.
+  if (NumOps == 2)
+    if (ConstantInt *C = dyn_cast(Ops[1]))
+      if (C->isZero())
+        return Ops[0];
+  
+  // Check to see if this is constant foldable.
+  for (unsigned i = 0; i != NumOps; ++i)
+    if (!isa(Ops[i]))
+      return 0;
+  
+  return ConstantExpr::getGetElementPtr(cast(Ops[0]),
+                                        (Constant *const*)Ops+1, NumOps-1);
+}
+
+
 //=== Helper functions for higher up the class hierarchy.
 
 /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
@@ -309,6 +337,10 @@
   case Instruction::FCmp:
     return SimplifyFCmpInst(cast(I)->getPredicate(),
                             I->getOperand(0), I->getOperand(1), TD);
+  case Instruction::GetElementPtr: {
+    SmallVector Ops(I->op_begin(), I->op_end());
+    return SimplifyGEPInst(&Ops[0], Ops.size(), TD);
+  }
   }
 }
 

Modified: llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp?rev=89980&r1=89979&r2=89980&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/InstructionCombining.cpp Thu Nov 26 18:29:05 2009
@@ -11429,21 +11429,16 @@
 }
 
 Instruction *InstCombiner::visitGetElementPtrInst(GetElementPtrInst &GEP) {
+  SmallVector Ops(GEP.op_begin(), GEP.op_end());
+
+  if (Value *V = SimplifyGEPInst(&Ops[0], Ops.size(), TD))
+    return ReplaceInstUsesWith(GEP, V);
+
   Value *PtrOp = GEP.getOperand(0);
-  // Eliminate 'getelementptr %P, i32 0' and 'getelementptr %P', they are noops.
-  if (GEP.getNumOperands() == 1)
-    return ReplaceInstUsesWith(GEP, PtrOp);
 
   if (isa(GEP.getOperand(0)))
     return ReplaceInstUsesWith(GEP, UndefValue::get(GEP.getType()));
 
-  bool HasZeroPointerIndex = false;
-  if (Constant *C = dyn_cast(GEP.getOperand(1)))
-    HasZeroPointerIndex = C->isNullValue();
-
-  if (GEP.getNumOperands() == 2 && HasZeroPointerIndex)
-    return ReplaceInstUsesWith(GEP, PtrOp);
-
   // Eliminate unneeded casts for indices.
   if (TD) {
     bool MadeChange = false;
@@ -11548,6 +11543,10 @@
       return 0;
     }
     
+    bool HasZeroPointerIndex = false;
+    if (ConstantInt *C = dyn_cast(GEP.getOperand(1)))
+      HasZeroPointerIndex = C->isZero();
+    
     // Transform: GEP (bitcast [10 x i8]* X to [0 x i8]*), i32 0, ...
     // into     : GEP [10 x i8]* X, i32 0, ...
     //




From sabre at nondot.org  Thu Nov 26 18:34:38 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 00:34:38 -0000
Subject: [llvm-commits] [llvm] r89981 - in /llvm/trunk:
 lib/Analysis/MemoryDependenceAnalysis.cpp
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911270034.nAR0YdXq020728@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 18:34:38 2009
New Revision: 89981

URL: http://llvm.org/viewvc/llvm-project?rev=89981&view=rev
Log:
teach phi translation of GEPs to simplify geps like 'gep x, 0'.
This allows us to compile the example from PR5313 into:

LBB1_2:                                                     ## %bb
	incl	%ecx
	movb	%al, (%rsi)
	movslq	%ecx, %rax
	movb	(%rdi,%rax), %al
	testb	%al, %al
	jne	LBB1_2

instead of:

LBB1_2:                                                     ## %bb
	movslq	%eax, %rcx
	incl	%eax
	movb	(%rdi,%rcx), %cl
	movb	%cl, (%rsi)
	movslq	%eax, %rcx
	cmpb	$0, (%rdi,%rcx)
	jne	LBB1_2


Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89981&r1=89980&r2=89981&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 18:34:38 2009
@@ -20,6 +20,7 @@
 #include "llvm/IntrinsicInst.h"
 #include "llvm/Function.h"
 #include "llvm/Analysis/AliasAnalysis.h"
+#include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/STLExtras.h"
@@ -716,7 +717,8 @@
 /// PHITranslateForPred - Given a computation that satisfied the
 /// isPHITranslatable predicate, see if we can translate the computation into
 /// the specified predecessor block.  If so, return that value.
-static Value *PHITranslateForPred(Instruction *Inst, BasicBlock *Pred) {
+static Value *PHITranslateForPred(Instruction *Inst, BasicBlock *Pred,
+                                  const TargetData *TD) {
   if (PHINode *PN = dyn_cast(Inst))
     return PN->getIncomingValueForBlock(Pred);
   
@@ -751,7 +753,9 @@
           GEPOps.back() = APHIOp = PN->getIncomingValueForBlock(Pred);
     }
     
-    // TODO: Simplify the GEP to handle 'gep x, 0' -> x etc.
+    // Simplify the GEP to handle 'gep x, 0' -> x etc.
+    if (Value *V = SimplifyGEPInst(&GEPOps[0], GEPOps.size(), TD))
+      return V;
     
     // Scan to see if we have this GEP available.
     for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end();
@@ -926,7 +930,7 @@
       
       for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
         BasicBlock *Pred = *PI;
-        Value *PredPtr = PHITranslateForPred(PtrInst, Pred);
+        Value *PredPtr = PHITranslateForPred(PtrInst, Pred, TD);
         
         // If PHI translation fails, bail out.
         if (PredPtr == 0)

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89981&r1=89980&r2=89981&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 18:34:38 2009
@@ -86,3 +86,29 @@
 	ret i32 %dv
 }
 
+; PR5313
+define i32 @test4(i1 %cond, i32* %b, i32* %c) nounwind {
+; CHECK: @test4
+entry:
+	br i1 %cond, label %bb, label %bb1
+
+bb:
+  store i32 4, i32* %b
+	br label %bb2
+
+bb1:
+  %c1 = getelementptr i32* %c, i32 7
+  store i32 82, i32* %c1
+	br label %bb2
+
+bb2:
+	%d = phi i32* [ %c, %bb1 ], [ %b, %bb ]
+	%i = phi i32 [ 7, %bb1 ], [ 0, %bb ]
+  %d1 = getelementptr i32* %d, i32 %i
+	%dv = load i32* %d1
+; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; CHECK-NOT: load
+; CHECK: ret i32 %dv
+	ret i32 %dv
+}
+




From sabre at nondot.org  Thu Nov 26 18:35:06 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 00:35:06 -0000
Subject: [llvm-commits] [llvm] r89982 - /llvm/trunk/lib/Target/README.txt
Message-ID: <200911270035.nAR0Z6gj020752@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 18:35:04 2009
New Revision: 89982

URL: http://llvm.org/viewvc/llvm-project?rev=89982&view=rev
Log:
this (and probably several others) are now done.

Modified:
    llvm/trunk/lib/Target/README.txt

Modified: llvm/trunk/lib/Target/README.txt
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/README.txt?rev=89982&r1=89981&r2=89982&view=diff

==============================================================================
--- llvm/trunk/lib/Target/README.txt (original)
+++ llvm/trunk/lib/Target/README.txt Thu Nov 26 18:35:04 2009
@@ -1196,39 +1196,6 @@
 
 GCC PR33344 is a similar case.
 
-//===---------------------------------------------------------------------===//
-
-[PHI TRANSLATE INDEXED GEPs]  PR5313
-
-Load redundancy elimination for simple loop.  This loop:
-
-void append_text(const char* text,unsigned char * const  io) {
-  while(*text)
-    *io=*text++;
-}
-
-Compiles to have a fully redundant load in the loop (%2):
-
-define void @append_text(i8* nocapture %text, i8* nocapture %io) nounwind {
-entry:
-  %0 = load i8* %text, align 1                    ;  [#uses=1]
-  %1 = icmp eq i8 %0, 0                           ;  [#uses=1]
-  br i1 %1, label %return, label %bb
-
-bb:                                               ; preds = %bb, %entry
-  %indvar = phi i32 [ 0, %entry ], [ %tmp, %bb ]  ;  [#uses=2]
-  %text_addr.04 = getelementptr i8* %text, i32 %indvar ;  [#uses=1]
-  %2 = load i8* %text_addr.04, align 1            ;  [#uses=1]
-  store i8 %2, i8* %io, align 1
-  %tmp = add i32 %indvar, 1                       ;  [#uses=2]
-  %scevgep = getelementptr i8* %text, i32 %tmp    ;  [#uses=1]
-  %3 = load i8* %scevgep, align 1                 ;  [#uses=1]
-  %4 = icmp eq i8 %3, 0                           ;  [#uses=1]
-  br i1 %4, label %return, label %bb
-
-return:                                           ; preds = %bb, %entry
-  ret void
-}
 
 //===---------------------------------------------------------------------===//
 




From sabre at nondot.org  Thu Nov 26 19:52:22 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 01:52:22 -0000
Subject: [llvm-commits] [llvm] r89985 - in /llvm/trunk:
 lib/Analysis/MemoryDependenceAnalysis.cpp
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911270152.nAR1qMpO023819@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 19:52:22 2009
New Revision: 89985

URL: http://llvm.org/viewvc/llvm-project?rev=89985&view=rev
Log:
this is causing buildbot failures, disable for now.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89985&r1=89984&r2=89985&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 19:52:22 2009
@@ -700,6 +700,7 @@
   
   // We can translate a GEP that uses a PHI in the current block for at least
   // one of its operands.
+  if (0)
   if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
     for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
       if (PHINode *PN = dyn_cast(GEP->getOperand(i)))

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89985&r1=89984&r2=89985&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 19:52:22 2009
@@ -80,9 +80,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 17, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; CHECK-NOT: load
-; CHECK: ret i32 %dv
+; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; HECK-NOT: load
+; HECK: ret i32 %dv
 	ret i32 %dv
 }
 
@@ -106,9 +106,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 0, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; CHECK-NOT: load
-; CHECK: ret i32 %dv
+; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; HECK-NOT: load
+; HECK: ret i32 %dv
 	ret i32 %dv
 }
 




From sabre at nondot.org  Thu Nov 26 23:19:57 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 05:19:57 -0000
Subject: [llvm-commits] [llvm] r89990 - in /llvm/trunk:
 lib/Analysis/MemoryDependenceAnalysis.cpp
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911270519.nAR5JvmJ030184@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 23:19:56 2009
New Revision: 89990

URL: http://llvm.org/viewvc/llvm-project?rev=89990&view=rev
Log:
try again.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89990&r1=89989&r2=89990&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 23:19:56 2009
@@ -700,7 +700,6 @@
   
   // We can translate a GEP that uses a PHI in the current block for at least
   // one of its operands.
-  if (0)
   if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
     for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
       if (PHINode *PN = dyn_cast(GEP->getOperand(i)))
@@ -747,11 +746,11 @@
   if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
     SmallVector GEPOps;
     Value *APHIOp = 0;
+    BasicBlock *CurBB = GEP->getParent();
     for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) {
-      GEPOps.push_back(GEP->getOperand(i));
-      if (PHINode *PN = dyn_cast(GEP->getOperand(i)))
-        if (PN->getParent() == GEP->getParent())
-          GEPOps.back() = APHIOp = PN->getIncomingValueForBlock(Pred);
+      GEPOps.push_back(GEP->getOperand(i)->DoPHITranslation(CurBB, Pred));
+      if (!isa(GEPOps.back()))
+        APHIOp = GEPOps.back();
     }
     
     // Simplify the GEP to handle 'gep x, 0' -> x etc.
@@ -762,9 +761,9 @@
     for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end();
          UI != E; ++UI) {
       if (GetElementPtrInst *GEPI = dyn_cast(*UI))
-        if (GEPI->getType() == GEPI->getType() &&
+        if (GEPI->getType() == GEP->getType() &&
             GEPI->getNumOperands() == GEPOps.size() &&
-            GEPI->getParent()->getParent() == Inst->getParent()->getParent()) {
+            GEPI->getParent()->getParent() == CurBB->getParent()) {
           bool Mismatch = false;
           for (unsigned i = 0, e = GEPOps.size(); i != e; ++i)
             if (GEPI->getOperand(i) != GEPOps[i]) {

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89990&r1=89989&r2=89990&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 23:19:56 2009
@@ -80,9 +80,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 17, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; HECK-NOT: load
-; HECK: ret i32 %dv
+; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; CHECK-NOT: load
+; CHECK: ret i32 %dv
 	ret i32 %dv
 }
 
@@ -106,9 +106,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 0, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; HECK-NOT: load
-; HECK: ret i32 %dv
+; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; CHECK-NOT: load
+; CHECK: ret i32 %dv
 	ret i32 %dv
 }
 




From sabre at nondot.org  Thu Nov 26 23:53:01 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 05:53:01 -0000
Subject: [llvm-commits] [llvm] r89991 - in /llvm/trunk:
 lib/Analysis/MemoryDependenceAnalysis.cpp
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911270553.nAR5r1Zu031051@zion.cs.uiuc.edu>

Author: lattner
Date: Thu Nov 26 23:53:01 2009
New Revision: 89991

URL: http://llvm.org/viewvc/llvm-project?rev=89991&view=rev
Log:
redisable this, my bootstrap worked because it wasn't an optimized build, whoops.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89991&r1=89990&r2=89991&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Thu Nov 26 23:53:01 2009
@@ -700,6 +700,7 @@
   
   // We can translate a GEP that uses a PHI in the current block for at least
   // one of its operands.
+  if (0)
   if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
     for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
       if (PHINode *PN = dyn_cast(GEP->getOperand(i)))

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89991&r1=89990&r2=89991&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Thu Nov 26 23:53:01 2009
@@ -80,9 +80,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 17, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; CHECK-NOT: load
-; CHECK: ret i32 %dv
+; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; HECK-NOT: load
+; HECK: ret i32 %dv
 	ret i32 %dv
 }
 
@@ -106,9 +106,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 0, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; CHECK-NOT: load
-; CHECK: ret i32 %dv
+; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; HECK-NOT: load
+; HECK: ret i32 %dv
 	ret i32 %dv
 }
 




From sabre at nondot.org  Fri Nov 27 00:31:14 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 06:31:14 -0000
Subject: [llvm-commits] [llvm] r89992 - in /llvm/trunk:
 include/llvm/Analysis/MemoryDependenceAnalysis.h
 lib/Analysis/MemoryDependenceAnalysis.cpp lib/Transforms/Scalar/GVN.cpp
 test/Transforms/GVN/rle-phi-translate.ll
Message-ID: <200911270631.nAR6VETi032167@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 00:31:14 2009
New Revision: 89992

URL: http://llvm.org/viewvc/llvm-project?rev=89992&view=rev
Log:
Fix phi translation in load PRE to agree with the phi 
translation done by memdep, and reenable gep translation 
again.

Modified:
    llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/lib/Transforms/Scalar/GVN.cpp
    llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll

Modified: llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h?rev=89992&r1=89991&r2=89992&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h (original)
+++ llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h Fri Nov 27 00:31:14 2009
@@ -244,6 +244,13 @@
                                       BasicBlock *BB,
                                      SmallVectorImpl &Result);
     
+    /// PHITranslatePointer - Find an available version of the specified value
+    /// PHI translated across the specified edge.  If MemDep isn't able to
+    /// satisfy this request, it returns null.
+    Value *PHITranslatePointer(Value *V,
+                               BasicBlock *CurBB, BasicBlock *PredBB,
+                               const TargetData *TD) const;
+    
     /// removeInstruction - Remove an instruction from the dependence analysis,
     /// updating the dependence of instructions that previously depended on it.
     void removeInstruction(Instruction *InstToRemove);

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89992&r1=89991&r2=89992&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Fri Nov 27 00:31:14 2009
@@ -700,7 +700,6 @@
   
   // We can translate a GEP that uses a PHI in the current block for at least
   // one of its operands.
-  if (0)
   if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
     for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
       if (PHINode *PN = dyn_cast(GEP->getOperand(i)))
@@ -718,8 +717,15 @@
 /// PHITranslateForPred - Given a computation that satisfied the
 /// isPHITranslatable predicate, see if we can translate the computation into
 /// the specified predecessor block.  If so, return that value.
-static Value *PHITranslateForPred(Instruction *Inst, BasicBlock *Pred,
-                                  const TargetData *TD) {
+Value *MemoryDependenceAnalysis::
+PHITranslatePointer(Value *InVal, BasicBlock *CurBB, BasicBlock *Pred,
+                    const TargetData *TD) const {  
+  // If the input value is not an instruction, or if it is not defined in CurBB,
+  // then we don't need to phi translate it.
+  Instruction *Inst = dyn_cast(InVal);
+  if (Inst == 0 || Inst->getParent() != CurBB)
+    return InVal;
+  
   if (PHINode *PN = dyn_cast(Inst))
     return PN->getIncomingValueForBlock(Pred);
   
@@ -931,7 +937,7 @@
       
       for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
         BasicBlock *Pred = *PI;
-        Value *PredPtr = PHITranslateForPred(PtrInst, Pred, TD);
+        Value *PredPtr = PHITranslatePointer(PtrInst, BB, Pred, TD);
         
         // If PHI translation fails, bail out.
         if (PredPtr == 0)

Modified: llvm/trunk/lib/Transforms/Scalar/GVN.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GVN.cpp?rev=89992&r1=89991&r2=89992&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/GVN.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/GVN.cpp Fri Nov 27 00:31:14 2009
@@ -1427,13 +1427,19 @@
 
   // If the loaded pointer is PHI node defined in this block, do PHI translation
   // to get its value in the predecessor.
-  Value *LoadPtr = LI->getOperand(0)->DoPHITranslation(LoadBB, UnavailablePred);
+  Value *LoadPtr = MD->PHITranslatePointer(LI->getOperand(0),
+                                           LoadBB, UnavailablePred, TD);
+  if (LoadPtr == 0) {
+    DEBUG(errs() << "COULDN'T PRE LOAD BECAUSE PTR CAN'T BE PHI TRANSLATED: "
+          << *LI->getOperand(0) << '\n' << *LI << "\n");
+    return false;
+  }
 
   // Make sure the value is live in the predecessor.  If it was defined by a
   // non-PHI instruction in this block, we don't know how to recompute it above.
   if (Instruction *LPInst = dyn_cast(LoadPtr))
     if (!DT->dominates(LPInst->getParent(), UnavailablePred)) {
-      DEBUG(errs() << "COULDN'T PRE LOAD BECAUSE PTR IS UNAVAILABLE IN PRED: "
+      DEBUG(errs() << "COULDN'T PRE LOAD BECAUSE PTR DOES NOT DOMINATE PRED: "
                    << *LPInst << '\n' << *LI << "\n");
       return false;
     }

Modified: llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll?rev=89992&r1=89991&r2=89992&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-phi-translate.ll Fri Nov 27 00:31:14 2009
@@ -80,9 +80,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 17, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; HECK-NOT: load
-; HECK: ret i32 %dv
+; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; CHECK-NOT: load
+; CHECK: ret i32 %dv
 	ret i32 %dv
 }
 
@@ -106,9 +106,9 @@
 	%i = phi i32 [ 7, %bb1 ], [ 0, %bb ]
   %d1 = getelementptr i32* %d, i32 %i
 	%dv = load i32* %d1
-; HECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
-; HECK-NOT: load
-; HECK: ret i32 %dv
+; CHECK: %dv = phi i32 [ 82, %bb1 ], [ 4, %bb ]
+; CHECK-NOT: load
+; CHECK: ret i32 %dv
 	ret i32 %dv
 }
 




From sabre at nondot.org  Fri Nov 27 00:31:56 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 06:31:56 -0000
Subject: [llvm-commits] [llvm] r89993 - in /llvm/trunk/test/Transforms/GVN:
	lpre-basic.ll pre-load.ll
Message-ID: <200911270631.nAR6Vu3l032196@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 00:31:55 2009
New Revision: 89993

URL: http://llvm.org/viewvc/llvm-project?rev=89993&view=rev
Log:
rename test.

Added:
    llvm/trunk/test/Transforms/GVN/pre-load.ll
      - copied unchanged from r89948, llvm/trunk/test/Transforms/GVN/lpre-basic.ll
Removed:
    llvm/trunk/test/Transforms/GVN/lpre-basic.ll

Removed: llvm/trunk/test/Transforms/GVN/lpre-basic.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/lpre-basic.ll?rev=89992&view=auto

==============================================================================
--- llvm/trunk/test/Transforms/GVN/lpre-basic.ll (original)
+++ llvm/trunk/test/Transforms/GVN/lpre-basic.ll (removed)
@@ -1,18 +0,0 @@
-; RUN: opt < %s -gvn -enable-load-pre -S | grep {%PRE = phi}
-
-define i32 @test(i32* %p, i1 %C) {
-block1:
-	br i1 %C, label %block2, label %block3
-
-block2:
- br label %block4
-
-block3:
-  %b = bitcast i32 0 to i32
-  store i32 %b, i32* %p
-  br label %block4
-
-block4:
-  %PRE = load i32* %p
-  ret i32 %PRE
-}




From sabre at nondot.org  Fri Nov 27 00:33:09 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 06:33:09 -0000
Subject: [llvm-commits] [llvm] r89994 -
	/llvm/trunk/test/Transforms/GVN/pre-load.ll
Message-ID: <200911270633.nAR6X9x7032235@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 00:33:09 2009
New Revision: 89994

URL: http://llvm.org/viewvc/llvm-project?rev=89994&view=rev
Log:
filecheckize

Modified:
    llvm/trunk/test/Transforms/GVN/pre-load.ll

Modified: llvm/trunk/test/Transforms/GVN/pre-load.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/pre-load.ll?rev=89994&r1=89993&r2=89994&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/pre-load.ll (original)
+++ llvm/trunk/test/Transforms/GVN/pre-load.ll Fri Nov 27 00:33:09 2009
@@ -1,11 +1,14 @@
-; RUN: opt < %s -gvn -enable-load-pre -S | grep {%PRE = phi}
+; RUN: opt < %s -gvn -enable-load-pre -S | FileCheck %s
 
-define i32 @test(i32* %p, i1 %C) {
+define i32 @test1(i32* %p, i1 %C) {
+; CHECK: @test1
 block1:
 	br i1 %C, label %block2, label %block3
 
 block2:
  br label %block4
+; CHECK: block2:
+; CHECK-NEXT: load i32* %p
 
 block3:
   %b = bitcast i32 0 to i32
@@ -15,4 +18,7 @@
 block4:
   %PRE = load i32* %p
   ret i32 %PRE
+; CHECK: block4:
+; CHECK-NEXT: phi i32
+; CHECK-NEXT: ret i32
 }




From sabre at nondot.org  Fri Nov 27 00:36:28 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 06:36:28 -0000
Subject: [llvm-commits] [llvm] r89995 -
	/llvm/trunk/test/Transforms/GVN/rle-no-phi-translate.ll
Message-ID: <200911270636.nAR6aSBM032342@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 00:36:28 2009
New Revision: 89995

URL: http://llvm.org/viewvc/llvm-project?rev=89995&view=rev
Log:
this test is failing, and is expected to.

Modified:
    llvm/trunk/test/Transforms/GVN/rle-no-phi-translate.ll

Modified: llvm/trunk/test/Transforms/GVN/rle-no-phi-translate.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/rle-no-phi-translate.ll?rev=89995&r1=89994&r2=89995&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/rle-no-phi-translate.ll (original)
+++ llvm/trunk/test/Transforms/GVN/rle-no-phi-translate.ll Fri Nov 27 00:36:28 2009
@@ -1,4 +1,5 @@
-; RUN: opt < %s -gvn -S | grep load
+; RUN: opt < %s -gvn -S | FileCheck %s
+; XFAIL: *
 ; FIXME: This should be promotable, but memdep/gvn don't track values
 ; path/edge sensitively enough.
 
@@ -20,5 +21,8 @@
 	%c_addr.0 = phi i32* [ %b, %entry ], [ %c, %bb ]		;  [#uses=1]
 	%cv = load i32* %c_addr.0, align 4		;  [#uses=1]
 	ret i32 %cv
+; CHECK: bb2:
+; CHECK-NOT: load i32
+; CHECK: ret i32 
 }
 




From sabre at nondot.org  Fri Nov 27 00:42:42 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 06:42:42 -0000
Subject: [llvm-commits] [llvm] r89996 -
	/llvm/trunk/test/Transforms/GVN/pre-load.ll
Message-ID: <200911270642.nAR6ggjW032502@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 00:42:42 2009
New Revision: 89996

URL: http://llvm.org/viewvc/llvm-project?rev=89996&view=rev
Log:
add some tests for memdep phi translation + PRE.

Modified:
    llvm/trunk/test/Transforms/GVN/pre-load.ll

Modified: llvm/trunk/test/Transforms/GVN/pre-load.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/pre-load.ll?rev=89996&r1=89995&r2=89996&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/pre-load.ll (original)
+++ llvm/trunk/test/Transforms/GVN/pre-load.ll Fri Nov 27 00:42:42 2009
@@ -11,8 +11,7 @@
 ; CHECK-NEXT: load i32* %p
 
 block3:
-  %b = bitcast i32 0 to i32
-  store i32 %b, i32* %p
+  store i32 0, i32* %p
   br label %block4
 
 block4:
@@ -22,3 +21,55 @@
 ; CHECK-NEXT: phi i32
 ; CHECK-NEXT: ret i32
 }
+
+define i32 @test2(i32* %p, i32* %q, i1 %C) {
+; CHECK: @test2
+block1:
+	br i1 %C, label %block2, label %block3
+
+block2:
+ br label %block4
+; CHECK: block2:
+; CHECK-NEXT: load i32* %q
+
+block3:
+  store i32 0, i32* %p
+  br label %block4
+
+block4:
+  %P2 = phi i32* [%p, %block3], [%q, %block2]
+  %PRE = load i32* %P2
+  ret i32 %PRE
+; CHECK: block4:
+; CHECK-NEXT: phi i32 [
+; CHECK-NOT: load
+; CHECK: ret i32
+}
+
+define i32 @test3(i32* %p, i32* %q, i32** %Hack, i1 %C) {
+; CHECK: @test3
+block1:
+  %B = getelementptr i32* %q, i32 1
+  store i32* %B, i32** %Hack
+	br i1 %C, label %block2, label %block3
+
+block2:
+ br label %block4
+; CHECK: block2:
+; CHECK-NEXT: load i32* %B
+
+block3:
+  %A = getelementptr i32* %p, i32 1
+  store i32 0, i32* %A
+  br label %block4
+
+block4:
+  %P2 = phi i32* [%p, %block3], [%q, %block2]
+  %P3 = getelementptr i32* %P2, i32 1
+  %PRE = load i32* %P3
+  ret i32 %PRE
+; CHECK: block4:
+; CHECK-NEXT: phi i32 [
+; CHECK-NOT: load
+; CHECK: ret i32
+}




From sabre at nondot.org  Fri Nov 27 02:25:11 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 08:25:11 -0000
Subject: [llvm-commits] [llvm] r89997 - in /llvm/trunk:
 include/llvm/Analysis/MemoryDependenceAnalysis.h
 lib/Analysis/MemoryDependenceAnalysis.cpp lib/Transforms/Scalar/GVN.cpp
 test/Transforms/GVN/pre-load.ll
Message-ID: <200911270825.nAR8PB9g003096@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 02:25:10 2009
New Revision: 89997

URL: http://llvm.org/viewvc/llvm-project?rev=89997&view=rev
Log:
teach GVN's load PRE to insert computations of the address in predecessors
where it is not available.  It's unclear how to get this inserted 
computation into GVN's scalar availability sets, Owen, help? :)

Modified:
    llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
    llvm/trunk/lib/Transforms/Scalar/GVN.cpp
    llvm/trunk/test/Transforms/GVN/pre-load.ll

Modified: llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h?rev=89997&r1=89996&r2=89997&view=diff

==============================================================================
--- llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h (original)
+++ llvm/trunk/include/llvm/Analysis/MemoryDependenceAnalysis.h Fri Nov 27 02:25:10 2009
@@ -250,6 +250,13 @@
     Value *PHITranslatePointer(Value *V,
                                BasicBlock *CurBB, BasicBlock *PredBB,
                                const TargetData *TD) const;
+
+    /// InsertPHITranslatedPointer - Insert a computation of the PHI translated
+    /// version of 'V' for the edge PredBB->CurBB into the end of the PredBB
+    /// block.
+    Value *InsertPHITranslatedPointer(Value *V,
+                                      BasicBlock *CurBB, BasicBlock *PredBB,
+                                      const TargetData *TD) const;
     
     /// removeInstruction - Remove an instruction from the dependence analysis,
     /// updating the dependence of instructions that previously depended on it.

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=89997&r1=89996&r2=89997&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Fri Nov 27 02:25:10 2009
@@ -752,19 +752,35 @@
   // Handle getelementptr with at least one PHI operand.
   if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
     SmallVector GEPOps;
-    Value *APHIOp = 0;
     BasicBlock *CurBB = GEP->getParent();
     for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) {
-      GEPOps.push_back(GEP->getOperand(i)->DoPHITranslation(CurBB, Pred));
-      if (!isa(GEPOps.back()))
-        APHIOp = GEPOps.back();
+      Value *GEPOp = GEP->getOperand(i);
+      // No PHI translation is needed of operands whose values are live in to
+      // the predecessor block.
+      if (!isa(GEPOp) ||
+          cast(GEPOp)->getParent() != CurBB) {
+        GEPOps.push_back(GEPOp);
+        continue;
+      }
+      
+      // If the operand is a phi node, do phi translation.
+      if (PHINode *PN = dyn_cast(GEPOp)) {
+        GEPOps.push_back(PN->getIncomingValueForBlock(Pred));
+        continue;
+      }
+      
+      // Otherwise, we can't PHI translate this random value defined in this
+      // block.
+      return 0;
     }
     
     // Simplify the GEP to handle 'gep x, 0' -> x etc.
     if (Value *V = SimplifyGEPInst(&GEPOps[0], GEPOps.size(), TD))
       return V;
-    
+
+
     // Scan to see if we have this GEP available.
+    Value *APHIOp = GEPOps[0];
     for (Value::use_iterator UI = APHIOp->use_begin(), E = APHIOp->use_end();
          UI != E; ++UI) {
       if (GetElementPtrInst *GEPI = dyn_cast(*UI))
@@ -787,6 +803,52 @@
   return 0;
 }
 
+/// InsertPHITranslatedPointer - Insert a computation of the PHI translated
+/// version of 'V' for the edge PredBB->CurBB into the end of the PredBB
+/// block.
+///
+/// This is only called when PHITranslatePointer returns a value that doesn't
+/// dominate the block, so we don't need to handle the trivial cases here.
+Value *MemoryDependenceAnalysis::
+InsertPHITranslatedPointer(Value *InVal, BasicBlock *CurBB,
+                           BasicBlock *PredBB, const TargetData *TD) const {
+  // If the input value isn't an instruction in CurBB, it doesn't need phi
+  // translation.
+  Instruction *Inst = cast(InVal);
+  assert(Inst->getParent() == CurBB && "Doesn't need phi trans");
+
+  // Handle bitcast of PHI.
+  if (BitCastInst *BC = dyn_cast(Inst)) {
+    PHINode *BCPN = cast(BC->getOperand(0));
+    Value *PHIIn = BCPN->getIncomingValueForBlock(PredBB);
+    
+    // Otherwise insert a bitcast at the end of PredBB.
+    return new BitCastInst(PHIIn, InVal->getType(),
+                           InVal->getName()+".phi.trans.insert",
+                           PredBB->getTerminator());
+  }
+  
+  // Handle getelementptr with at least one PHI operand.
+  if (GetElementPtrInst *GEP = dyn_cast(Inst)) {
+    SmallVector GEPOps;
+    Value *APHIOp = 0;
+    BasicBlock *CurBB = GEP->getParent();
+    for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i) {
+      GEPOps.push_back(GEP->getOperand(i)->DoPHITranslation(CurBB, PredBB));
+      if (!isa(GEPOps.back()))
+        APHIOp = GEPOps.back();
+    }
+    
+    GetElementPtrInst *Result = 
+      GetElementPtrInst::Create(GEPOps[0], GEPOps.begin()+1, GEPOps.end(),
+                                InVal->getName()+".phi.trans.insert",
+                                PredBB->getTerminator());
+    Result->setIsInBounds(GEP->isInBounds());
+    return Result;
+  }
+  
+  return 0;
+}
 
 /// getNonLocalPointerDepFromBB - Perform a dependency query based on
 /// pointer/pointeesize starting at the end of StartBB.  Add any clobber/def

Modified: llvm/trunk/lib/Transforms/Scalar/GVN.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/GVN.cpp?rev=89997&r1=89996&r2=89997&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/GVN.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/GVN.cpp Fri Nov 27 02:25:10 2009
@@ -1425,32 +1425,40 @@
   assert(UnavailablePred != 0 &&
          "Fully available value should be eliminated above!");
 
+  // We don't currently handle critical edges :(
+  if (UnavailablePred->getTerminator()->getNumSuccessors() != 1) {
+    DEBUG(errs() << "COULD NOT PRE LOAD BECAUSE OF CRITICAL EDGE '"
+                 << UnavailablePred->getName() << "': " << *LI << '\n');
+    return false;
+  }
+  
   // If the loaded pointer is PHI node defined in this block, do PHI translation
   // to get its value in the predecessor.
   Value *LoadPtr = MD->PHITranslatePointer(LI->getOperand(0),
                                            LoadBB, UnavailablePred, TD);
-  if (LoadPtr == 0) {
-    DEBUG(errs() << "COULDN'T PRE LOAD BECAUSE PTR CAN'T BE PHI TRANSLATED: "
-          << *LI->getOperand(0) << '\n' << *LI << "\n");
-    return false;
-  }
+  // Make sure the value is live in the predecessor.  MemDep found a computation
+  // of LPInst with the right value, but that does not dominate UnavailablePred,
+  // then we can't use it.
+  if (Instruction *LPInst = dyn_cast_or_null(LoadPtr))
+    if (!DT->dominates(LPInst->getParent(), UnavailablePred))
+      LoadPtr = 0;
 
-  // Make sure the value is live in the predecessor.  If it was defined by a
-  // non-PHI instruction in this block, we don't know how to recompute it above.
-  if (Instruction *LPInst = dyn_cast(LoadPtr))
-    if (!DT->dominates(LPInst->getParent(), UnavailablePred)) {
-      DEBUG(errs() << "COULDN'T PRE LOAD BECAUSE PTR DOES NOT DOMINATE PRED: "
-                   << *LPInst << '\n' << *LI << "\n");
+  // If we don't have a computation of this phi translated value, try to insert
+  // one.
+  if (LoadPtr == 0) {
+    LoadPtr = MD->InsertPHITranslatedPointer(LI->getOperand(0),
+                                             LoadBB, UnavailablePred, TD);
+    if (LoadPtr == 0) {
+      DEBUG(errs() << "COULDN'T INSERT PHI TRANSLATED VALUE OF: "
+                   << *LI->getOperand(0) << "\n");
       return false;
     }
-
-  // We don't currently handle critical edges :(
-  if (UnavailablePred->getTerminator()->getNumSuccessors() != 1) {
-    DEBUG(errs() << "COULD NOT PRE LOAD BECAUSE OF CRITICAL EDGE '"
-                 << UnavailablePred->getName() << "': " << *LI << '\n');
-    return false;
+    
+    // FIXME: This inserts a computation, but we don't tell scalar GVN
+    // optimization stuff about it.  How do we do this?
+    DEBUG(errs() << "INSERTED PHI TRANSLATED VALUE: " << *LoadPtr << "\n");
   }
-
+  
   // Make sure it is valid to move this load here.  We have to watch out for:
   //  @1 = getelementptr (i8* p, ...
   //  test p and branch if == 0

Modified: llvm/trunk/test/Transforms/GVN/pre-load.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Transforms/GVN/pre-load.ll?rev=89997&r1=89996&r2=89997&view=diff

==============================================================================
--- llvm/trunk/test/Transforms/GVN/pre-load.ll (original)
+++ llvm/trunk/test/Transforms/GVN/pre-load.ll Fri Nov 27 02:25:10 2009
@@ -22,6 +22,7 @@
 ; CHECK-NEXT: ret i32
 }
 
+; This is a simple phi translation case.
 define i32 @test2(i32* %p, i32* %q, i1 %C) {
 ; CHECK: @test2
 block1:
@@ -46,6 +47,7 @@
 ; CHECK: ret i32
 }
 
+; This is a PRE case that requires phi translation through a GEP.
 define i32 @test3(i32* %p, i32* %q, i32** %Hack, i1 %C) {
 ; CHECK: @test3
 block1:
@@ -73,3 +75,35 @@
 ; CHECK-NOT: load
 ; CHECK: ret i32
 }
+
+;; Here the loaded address is available, but the computation is in 'block3'
+;; which does not dominate 'block2'.
+define i32 @test4(i32* %p, i32* %q, i32** %Hack, i1 %C) {
+; CHECK: @test4
+block1:
+	br i1 %C, label %block2, label %block3
+
+block2:
+ br label %block4
+; CHECK: block2:
+; CHECK:   load i32*
+; CHECK:   br label %block4
+
+block3:
+  %B = getelementptr i32* %q, i32 1
+  store i32* %B, i32** %Hack
+
+  %A = getelementptr i32* %p, i32 1
+  store i32 0, i32* %A
+  br label %block4
+
+block4:
+  %P2 = phi i32* [%p, %block3], [%q, %block2]
+  %P3 = getelementptr i32* %P2, i32 1
+  %PRE = load i32* %P3
+  ret i32 %PRE
+; CHECK: block4:
+; CHECK-NEXT: phi i32 [
+; CHECK-NOT: load
+; CHECK: ret i32
+}




From sabre at nondot.org  Fri Nov 27 02:32:53 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 08:32:53 -0000
Subject: [llvm-commits] [llvm] r90000 -
	/llvm/trunk/lib/Analysis/ValueTracking.cpp
Message-ID: <200911270832.nAR8WrV4003527@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 02:32:52 2009
New Revision: 90000

URL: http://llvm.org/viewvc/llvm-project?rev=90000&view=rev
Log:
limit the recursion depth of GetLinearExpression.  This
fixes a crash analyzing consumer-lame, which had an "%X = add %X, 1"
in unreachable code.

Modified:
    llvm/trunk/lib/Analysis/ValueTracking.cpp

Modified: llvm/trunk/lib/Analysis/ValueTracking.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/ValueTracking.cpp?rev=90000&r1=89999&r2=90000&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/ValueTracking.cpp (original)
+++ llvm/trunk/lib/Analysis/ValueTracking.cpp Fri Nov 27 02:32:52 2009
@@ -955,8 +955,15 @@
 /// have IntegerType.  Note that this looks through extends, so the high bits
 /// may not be represented in the result.
 static Value *GetLinearExpression(Value *V, APInt &Scale, APInt &Offset,
-                                  const TargetData *TD) {
+                                  const TargetData *TD, unsigned Depth) {
   assert(isa(V->getType()) && "Not an integer value");
+
+  // Limit our recursion depth.
+  if (Depth == 6) {
+    Scale = 1;
+    Offset = 0;
+    return V;
+  }
   
   if (BinaryOperator *BOp = dyn_cast(V)) {
     if (ConstantInt *RHSC = dyn_cast(BOp->getOperand(1))) {
@@ -969,16 +976,16 @@
           break;
         // FALL THROUGH.
       case Instruction::Add:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD, Depth+1);
         Offset += RHSC->getValue();
         return V;
       case Instruction::Mul:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD, Depth+1);
         Offset *= RHSC->getValue();
         Scale *= RHSC->getValue();
         return V;
       case Instruction::Shl:
-        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD);
+        V = GetLinearExpression(BOp->getOperand(0), Scale, Offset, TD, Depth+1);
         Offset <<= RHSC->getValue().getLimitedValue();
         Scale <<= RHSC->getValue().getLimitedValue();
         return V;
@@ -994,7 +1001,7 @@
     unsigned SmallWidth = CastOp->getType()->getPrimitiveSizeInBits();
     Scale.trunc(SmallWidth);
     Offset.trunc(SmallWidth);
-    Value *Result = GetLinearExpression(CastOp, Scale, Offset, TD);
+    Value *Result = GetLinearExpression(CastOp, Scale, Offset, TD, Depth+1);
     Scale.zext(OldWidth);
     Offset.zext(OldWidth);
     return Result;
@@ -1088,7 +1095,7 @@
       // Use GetLinearExpression to decompose the index into a C1*V+C2 form.
       unsigned Width = cast(Index->getType())->getBitWidth();
       APInt IndexScale(Width, 0), IndexOffset(Width, 0);
-      Index = GetLinearExpression(Index, IndexScale, IndexOffset, TD);
+      Index = GetLinearExpression(Index, IndexScale, IndexOffset, TD, 0);
       
       // The GEP index scale ("Scale") scales C1*V+C2, yielding (C1*V+C2)*Scale.
       // This gives us an aggregate computation of (C1*Scale)*V + C2*Scale.




From sabre at nondot.org  Fri Nov 27 02:37:22 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 08:37:22 -0000
Subject: [llvm-commits] [llvm] r90001 -
	/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
Message-ID: <200911270837.nAR8bMGN003677@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 02:37:22 2009
New Revision: 90001

URL: http://llvm.org/viewvc/llvm-project?rev=90001&view=rev
Log:
reduce nesting, no functionality change.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=90001&r1=90000&r2=90001&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Fri Nov 27 02:37:22 2009
@@ -994,62 +994,63 @@
     
     // If this is a computation derived from a PHI node, use the suitably
     // translated incoming values for each pred as the phi translated version.
-    if (isPHITranslatable(PtrInst)) {
-      Cache = 0;
+    if (!isPHITranslatable(PtrInst))
+      goto PredTranslationFailure;
+
+    Cache = 0;
       
-      for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
-        BasicBlock *Pred = *PI;
-        Value *PredPtr = PHITranslatePointer(PtrInst, BB, Pred, TD);
-        
-        // If PHI translation fails, bail out.
-        if (PredPtr == 0)
-          goto PredTranslationFailure;
+    for (BasicBlock **PI = PredCache->GetPreds(BB); *PI; ++PI) {
+      BasicBlock *Pred = *PI;
+      Value *PredPtr = PHITranslatePointer(PtrInst, BB, Pred, TD);
+      
+      // If PHI translation fails, bail out.
+      if (PredPtr == 0)
+        goto PredTranslationFailure;
+      
+      // Check to see if we have already visited this pred block with another
+      // pointer.  If so, we can't do this lookup.  This failure can occur
+      // with PHI translation when a critical edge exists and the PHI node in
+      // the successor translates to a pointer value different than the
+      // pointer the block was first analyzed with.
+      std::pair::iterator, bool>
+        InsertRes = Visited.insert(std::make_pair(Pred, PredPtr));
+
+      if (!InsertRes.second) {
+        // If the predecessor was visited with PredPtr, then we already did
+        // the analysis and can ignore it.
+        if (InsertRes.first->second == PredPtr)
+          continue;
         
-        // Check to see if we have already visited this pred block with another
-        // pointer.  If so, we can't do this lookup.  This failure can occur
-        // with PHI translation when a critical edge exists and the PHI node in
-        // the successor translates to a pointer value different than the
-        // pointer the block was first analyzed with.
-        std::pair::iterator, bool>
-          InsertRes = Visited.insert(std::make_pair(Pred, PredPtr));
-
-        if (!InsertRes.second) {
-          // If the predecessor was visited with PredPtr, then we already did
-          // the analysis and can ignore it.
-          if (InsertRes.first->second == PredPtr)
-            continue;
-          
-          // Otherwise, the block was previously analyzed with a different
-          // pointer.  We can't represent the result of this case, so we just
-          // treat this as a phi translation failure.
-          goto PredTranslationFailure;
-        }
-
-        // FIXME: it is entirely possible that PHI translating will end up with
-        // the same value.  Consider PHI translating something like:
-        // X = phi [x, bb1], [y, bb2].  PHI translating for bb1 doesn't *need*
-        // to recurse here, pedantically speaking.
-        
-        // If we have a problem phi translating, fall through to the code below
-        // to handle the failure condition.
-        if (getNonLocalPointerDepFromBB(PredPtr, PointeeSize, isLoad, Pred,
-                                        Result, Visited))
-          goto PredTranslationFailure;
+        // Otherwise, the block was previously analyzed with a different
+        // pointer.  We can't represent the result of this case, so we just
+        // treat this as a phi translation failure.
+        goto PredTranslationFailure;
       }
-      
-      // Refresh the CacheInfo/Cache pointer so that it isn't invalidated.
-      CacheInfo = &NonLocalPointerDeps[CacheKey];
-      Cache = &CacheInfo->second;
-      NumSortedEntries = Cache->size();
-      
-      // Since we did phi translation, the "Cache" set won't contain all of the
-      // results for the query.  This is ok (we can still use it to accelerate
-      // specific block queries) but we can't do the fastpath "return all
-      // results from the set"  Clear out the indicator for this.
-      CacheInfo->first = BBSkipFirstBlockPair();
-      SkipFirstBlock = false;
-      continue;
+
+      // FIXME: it is entirely possible that PHI translating will end up with
+      // the same value.  Consider PHI translating something like:
+      // X = phi [x, bb1], [y, bb2].  PHI translating for bb1 doesn't *need*
+      // to recurse here, pedantically speaking.
+      
+      // If we have a problem phi translating, fall through to the code below
+      // to handle the failure condition.
+      if (getNonLocalPointerDepFromBB(PredPtr, PointeeSize, isLoad, Pred,
+                                      Result, Visited))
+        goto PredTranslationFailure;
     }
+    
+    // Refresh the CacheInfo/Cache pointer so that it isn't invalidated.
+    CacheInfo = &NonLocalPointerDeps[CacheKey];
+    Cache = &CacheInfo->second;
+    NumSortedEntries = Cache->size();
+    
+    // Since we did phi translation, the "Cache" set won't contain all of the
+    // results for the query.  This is ok (we can still use it to accelerate
+    // specific block queries) but we can't do the fastpath "return all
+    // results from the set"  Clear out the indicator for this.
+    CacheInfo->first = BBSkipFirstBlockPair();
+    SkipFirstBlock = false;
+    continue;
 
   PredTranslationFailure:
     




From sabre at nondot.org  Fri Nov 27 02:40:14 2009
From: sabre at nondot.org (Chris Lattner)
Date: Fri, 27 Nov 2009 08:40:14 -0000
Subject: [llvm-commits] [llvm] r90002 -
	/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
Message-ID: <200911270840.nAR8eEjN005822@zion.cs.uiuc.edu>

Author: lattner
Date: Fri Nov 27 02:40:14 2009
New Revision: 90002

URL: http://llvm.org/viewvc/llvm-project?rev=90002&view=rev
Log:
add comment.

Modified:
    llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp

Modified: llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp?rev=90002&r1=90001&r2=90002&view=diff

==============================================================================
--- llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp (original)
+++ llvm/trunk/lib/Analysis/MemoryDependenceAnalysis.cpp Fri Nov 27 02:40:14 2009
@@ -1004,8 +1004,12 @@
       Value *PredPtr = PHITranslatePointer(PtrInst, BB, Pred, TD);
       
       // If PHI translation fails, bail out.
-      if (PredPtr == 0)
+      if (PredPtr == 0) {
+        // FIXME: Instead of modelling this as a phi trans failure, we should
+        // model this as a clobber in the one predecessor.  This will allow
+        // us to PRE values that are only available in some preds but not all.
         goto PredTranslationFailure;
+      }
       
       // Check to see if we have already visited this pred block with another
       // pointer.  If so, we can't do this lookup.  This failure can occur




From baldrick at free.fr  Fri Nov 27 06:33:24 2009
From: baldrick at free.fr (Duncan Sands)
Date: Fri, 27 Nov 2009 12:33:24 -0000
Subject: [llvm-commits] [llvm] r90003 - /llvm/trunk/docs/LangRef.html
Message-ID: <200911271233.nARCXOwN026794@zion.cs.uiuc.edu>

Author: baldrick
Date: Fri Nov 27 06:33:22 2009
New Revision: 90003

URL: http://llvm.org/viewvc/llvm-project?rev=90003&view=rev
Log:
These code generator limitations have been removed.

Modified:
    llvm/trunk/docs/LangRef.html

Modified: llvm/trunk/docs/LangRef.html
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/docs/LangRef.html?rev=90003&r1=90002&r2=90003&view=diff

==============================================================================
--- llvm/trunk/docs/LangRef.html (original)
+++ llvm/trunk/docs/LangRef.html Fri Nov 27 06:33:22 2009
@@ -1440,11 +1440,6 @@
   
 
 
-Note that the code generator does not yet support large integer types to be
-   used as function return types. The specific limit on how large a return type
-   the code generator can currently handle is target-dependent; currently it's
-   often 64 bits for 32-bit targets and 128 bits for 64-bit targets.
-
 
 
 
@@ -1583,11 +1578,6 @@
    length array type. An implementation of 'pascal style arrays' in LLVM could
    use the type "{ i32, [0 x float]}", for example.
 
-Note that the code generator does not yet support large aggregate types to be
-   used as function return types. The specific limit on how large an aggregate
-   return type the code generator can currently handle is target-dependent, and
-   also dependent on the aggregate element types.
-
 
 
 
@@ -1680,11 +1670,6 @@
   
 
 
-Note that the code generator does not yet support large aggregate types to be
-   used as function return types. The specific limit on how large an aggregate
-   return type the code generator can currently handle is target-dependent, and
-   also dependent on the aggregate element types.
-
 
 
 
@@ -1803,11 +1788,6 @@
   
 
 
-Note that the code generator does not yet support large vector types to be
-   used as function return types. The specific limit on how large a vector
-   return type codegen can currently handle is target-dependent; currently it's
-   often a few times longer than a hardware vector register.
-
 
 
 
@@ -2600,14 +2580,6 @@
   ret { i32, i8 } { i32 4, i8 2 } ; Return a struct of values 4 and 2
 
br
-int mul_add(int x, int y, int z) {
-  return x * y + z;
-}
-
-define i32 @mul_add(i32 %x, i32 %y, i32 %z) {
-entry:
-  %tmp = mul i32 %x, %y
-  %tmp2 = add i32 %tmp, %z
-  ret i32 %tmp2
-}
-
-#include "llvm/Module.h"
-#include "llvm/Function.h"
-#include "llvm/PassManager.h"
-#include "llvm/CallingConv.h"
-#include "llvm/Analysis/Verifier.h"
-#include "llvm/Assembly/PrintModulePass.h"
-#include "llvm/Support/IRBuilder.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm;
-
-Module* makeLLVMModule();
-
-int main(int argc, char**argv) {
-  Module* Mod = makeLLVMModule();
-
-  verifyModule(*Mod, PrintMessageAction);
-
-  PassManager PM;
-  PM.add(createPrintModulePass(&outs()));
-  PM.run(*Mod);
-
-  delete Mod;
-  return 0;
-}
-
-Module* makeLLVMModule() {
-  // Module Construction
-  Module* mod = new Module("test", getGlobalContext());
-
-  Constant* c = mod->getOrInsertFunction("mul_add",
-  /*ret type*/                           IntegerType::get(32),
-  /*args*/                               IntegerType::get(32),
-                                         IntegerType::get(32),
-                                         IntegerType::get(32),
-  /*varargs terminated with null*/       NULL);
-  
-  Function* mul_add = cast<Function>(c);
-  mul_add->setCallingConv(CallingConv::C);
-
-  Function::arg_iterator args = mul_add->arg_begin();
-  Value* x = args++;
-  x->setName("x");
-  Value* y = args++;
-  y->setName("y");
-  Value* z = args++;
-  z->setName("z");
-
-  BasicBlock* block = BasicBlock::Create(getGlobalContext(), "entry", mul_add);
-  IRBuilder<> builder(block);
-
-  Value* tmp = builder.CreateBinOp(Instruction::Mul,
-                                   x, y, "tmp");
-  Value* tmp2 = builder.CreateBinOp(Instruction::Add,
-                                    tmp, z, "tmp2");
-
-  builder.CreateRet(tmp2);
-  
-  return mod;
-}
-
-# c++ -g tut1.cpp `llvm-config --cxxflags --ldflags --libs core` -o tut1
-# ./tut1
-
-unsigned gcd(unsigned x, unsigned y) {
-  if(x == y) {
-    return x;
-  } else if(x < y) {
-    return gcd(x, y - x);
-  } else {
-    return gcd(x - y, y);
-  }
-}
-
-#include "llvm/Module.h"
-#include "llvm/Function.h"
-#include "llvm/PassManager.h"
-#include "llvm/Analysis/Verifier.h"
-#include "llvm/Assembly/PrintModulePass.h"
-#include "llvm/Support/IRBuilder.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm;
-
-Module* makeLLVMModule();
-
-int main(int argc, char**argv) {
-  Module* Mod = makeLLVMModule();
-  
-  verifyModule(*Mod, PrintMessageAction);
-  
-  PassManager PM;
-  PM.add(createPrintModulePass(&outs()));
-  PM.run(*Mod);
-
-  delete Mod;  
-  return 0;
-}
-
-Module* makeLLVMModule() {
-  Module* mod = new Module("tut2");
-  
-  Constant* c = mod->getOrInsertFunction("gcd",
-                                         IntegerType::get(32),
-                                         IntegerType::get(32),
-                                         IntegerType::get(32),
-                                         NULL);
-  Function* gcd = cast<Function>(c);
-  
-  Function::arg_iterator args = gcd->arg_begin();
-  Value* x = args++;
-  x->setName("x");
-  Value* y = args++;
-  y->setName("y");
-
-  BasicBlock* entry = BasicBlock::Create(getGlobalContext(), ("entry", gcd);
-  BasicBlock* ret = BasicBlock::Create(getGlobalContext(), ("return", gcd);
-  BasicBlock* cond_false = BasicBlock::Create(getGlobalContext(), ("cond_false", gcd);
-  BasicBlock* cond_true = BasicBlock::Create(getGlobalContext(), ("cond_true", gcd);
-  BasicBlock* cond_false_2 = BasicBlock::Create(getGlobalContext(), ("cond_false", gcd);
-
-  IRBuilder<> builder(entry);
-  Value* xEqualsY = builder.CreateICmpEQ(x, y, "tmp");
-  builder.CreateCondBr(xEqualsY, ret, cond_false);
-
-  builder.SetInsertPoint(ret);
-  builder.CreateRet(x);
-
-  builder.SetInsertPoint(cond_false);
-  Value* xLessThanY = builder.CreateICmpULT(x, y, "tmp");
-  builder.CreateCondBr(xLessThanY, cond_true, cond_false_2);
-
-  builder.SetInsertPoint(cond_true);
-  Value* yMinusX = builder.CreateSub(y, x, "tmp");
-  std::vector<Value*> args1;
-  args1.push_back(x);
-  args1.push_back(yMinusX);
-  Value* recur_1 = builder.CreateCall(gcd, args1.begin(), args1.end(), "tmp");
-  builder.CreateRet(recur_1);
-  
-  builder.SetInsertPoint(cond_false_2);
-  Value* xMinusY = builder.CreateSub(x, y, "tmp");
-  std::vector<Value*> args2;
-  args2.push_back(xMinusY);
-  args2.push_back(y);
-  Value* recur_2 = builder.CreateCall(gcd, args2.begin(), args2.end(), "tmp");
-  builder.CreateRet(recur_2);
-  
-  return mod;
-}
-
-# c++ -g tut2.cpp `llvm-config --cxxflags --ldflags --libs core` -o tut2
-# ./tut2
-

Syntax: