Disable lifetime-start-on-first-use analysis.

[thanm]

Summary

Turn off lifetime-start-on-first-use enhancement for the moment
pending a fix for bug 27903.

Bug: 27903

[tejohnson]

Couple of minor comments, otherwise LGTM. Thanks!

lib/CodeGen/StackColoring.cpp

78

LLVM tends to use "PR27903" when referring to bug ids. Also "FIXME" instead of "NB"

test/CodeGen/X86/StackColoring.ll

549

If this test case is exposing the bug, probably a FIXME with the expected output once this is corrected would be good.

[thanm]

Thanks. Fixed the issues you cited, will post a revised patch.

test/CodeGen/X86/StackColoring.ll

549

Yes. this test case is exposing the bug. I will try to make the comment clearer.

[thanm]

Incorporate code review suggestions by Teresa.

lib/CodeGen/StackColoring.cpp

 ProtectFromEscapedAllocas("protect-from-escaped-allocas",
                           cl::init(false), cl::Hidden,
                           cl::desc("Do not optimize lifetime zones that "
                                    "are broken"));
 
 /// Enable enhanced dataflow scheme for lifetime analysis (treat first
 /// use of stack slot as start of slot lifetime, as opposed to looking
 /// for LIFETIME_START marker). See "Implementation notes" below for
-/// more info.
+/// more info. NB: set to false for the moment due to Bug 27903.
 static cl::opt<bool>
 LifetimeStartOnFirstUse("stackcoloring-lifetime-start-on-first-use",
-        cl::init(true), cl::Hidden,
+        cl::init(false), cl::Hidden,
         cl::desc("Treat stack lifetimes as starting on first use, not on START marker."));
 
 
 STATISTIC(NumMarkerSeen,  "Number of lifetime markers found.");
 STATISTIC(StackSpaceSaved, "Number of bytes saved due to merging slots.");
 STATISTIC(StackSlotMerged, "Number of stack slot merged.");
 STATISTIC(EscapedAllocas, "Number of allocas that escaped the lifetime region");
 

test/CodeGen/X86/StackColoring.ll

+; RUN: llc -mcpu=corei7 -no-stack-coloring=false -stackcoloring-lifetime-start-on-first-use=true < %s | FileCheck %s --check-prefix=FIRSTUSE --check-prefix=CHECK
 ; RUN: llc -mcpu=corei7 -no-stack-coloring=false < %s | FileCheck %s --check-prefix=YESCOLOR --check-prefix=CHECK
 ; RUN: llc -mcpu=corei7 -no-stack-coloring=true  < %s | FileCheck %s --check-prefix=NOCOLOR --check-prefix=CHECK
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.8.0"
 
 ;CHECK-LABEL: myCall_w2:
 ;YESCOLOR: subq  $144, %rsp
bb2:
   %t6 = add i32 %t3, %t4
   %t7 = add i32 %t5, %t6
   ret i32 %t7
 bb3:
   ret i32 0
 }
 
 ;CHECK-LABEL: myCall_w4:
-;YESCOLOR: subq  $120, %rsp
+;FIRSTUSE: subq  $120, %rsp
+;YESCOLOR: subq  $200, %rsp
 ;NOCOLOR: subq  $408, %rsp
 
 define i32 @myCall_w4(i32 %in) {
 entry:
   %a1 = alloca [14 x i8*], align 8
   %a2 = alloca [13 x i8*], align 8
   %a3 = alloca [12 x i8*], align 8
   %a4 = alloca [11 x i8*], align 8

 }
 
 ; In this case 'itar1' and 'itar2' can't be overlapped if we treat
 ; lifetime.start as the beginning of the lifetime, but we can
 ; overlap if we consider first use of the slot as lifetime
 ; start. See llvm bug 25776.
 
 ;CHECK-LABEL: ifthen_twoslots:
-;YESCOLOR: subq  $536, %rsp
+;FIRSTUSE: subq  $536, %rsp
+;YESCOLOR: subq $1048, %rsp
 ;NOCOLOR: subq  $1048, %rsp
 
 define i32 @ifthen_twoslots(i32 %x) #0 {
 entry:
   %retval = alloca i32, align 4
   %x.addr = alloca i32, align 4
   %itar1 = alloca [128 x i32], align 16
   %itar2 = alloca [128 x i32], align 16

 
 ; This function is intended to test the case where you
 ; have a reference to a stack slot that lies outside of
 ; the START/END lifetime markers-- the flow analysis
 ; should catch this and build the lifetime based on the
 ; markers only.
 
 ;CHECK-LABEL: while_loop:
-;YESCOLOR: subq  $1032, %rsp
+;FIRSTUSE: subq  $1032, %rsp
+;YESCOLOR: subq  $1544, %rsp
 ;NOCOLOR: subq  $1544, %rsp
 
 define i32 @while_loop(i32 %x) #0 {
 entry:
   %b1 = alloca [128 x i32], align 16
   %b2 = alloca [128 x i32], align 16
   %b3 = alloca [128 x i32], align 16
   %tmp = bitcast [128 x i32]* %b1 to i8*
if.end.loopexit:                                  ; preds = %while.body
   br label %if.end
 
 if.end:                                           ; preds = %if.end.loopexit, %if.else, %if.then
   call void @llvm.lifetime.end(i64 512, i8* %tmp1) #3
   call void @llvm.lifetime.end(i64 512, i8* %tmp) #3
   ret i32 0
 }
 
+; Test case motivated by Bug 27903. Same routine inlined multiple times
+; into a caller results in a multi-segment lifetime, but the second
+; lifetime has no explicit references to the stack slot.
+
+;CHECK-LABEL: twobod_b27903:
+;FIRSTUSE: subq  $56, %rsp
+;YESCOLOR: subq  $96, %rsp
+;NOCOLOR: subq  $96, %rsp
+
+define i32 @twobod_b27903(i32 %y, i32 %x) {
+entry:
+  %buffer.i = alloca [12 x i32], align 16
+  %abc = alloca [12 x i32], align 16
+  %tmp = bitcast [12 x i32]* %buffer.i to i8*
+  call void @llvm.lifetime.start(i64 48, i8* %tmp)
+  %idxprom.i = sext i32 %y to i64
+  %arrayidx.i = getelementptr inbounds [12 x i32], [12 x i32]* %buffer.i, i64 0, i64 %idxprom.i
+  call void @inita(i32* %arrayidx.i)
+  %add.i = add nsw i32 %x, %y
+  call void @llvm.lifetime.end(i64 48, i8* %tmp)
+  %tobool = icmp eq i32 %y, 0
+  br i1 %tobool, label %if.end, label %if.then
+
+if.then:                                          ; preds = %entry
+  %tmp1 = bitcast [12 x i32]* %abc to i8*
+  call void @llvm.lifetime.start(i64 48, i8* %tmp1)
+  %arrayidx = getelementptr inbounds [12 x i32], [12 x i32]* %abc, i64 0, i64 %idxprom.i
+  call void @inita(i32* %arrayidx)
+  call void @llvm.lifetime.start(i64 48, i8* %tmp)
+  call void @inita(i32* %arrayidx.i)
+  %add.i9 = add nsw i32 %add.i, %y
+  call void @llvm.lifetime.end(i64 48, i8* %tmp)
+  call void @llvm.lifetime.end(i64 48, i8* %tmp1)
+  br label %if.end
+
+if.end:                                           ; preds = %if.then, %entry
+  %x.addr.0 = phi i32 [ %add.i9, %if.then ], [ %add.i, %entry ]
+  ret i32 %x.addr.0
+}
+
 declare void @inita(i32*) #2
 
 declare void @bar([100 x i32]* , [100 x i32]*) nounwind
 
 declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind
 
 declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind
 
 declare i32 @foo(i32, i8*)