[llvm][misexpect] Re-enable MisExpect for SampleProfiling

[paulkirth]

Summary

MisExpect was occasionally crashing under SampleProfiling, due to a division by zero.
We worked around that in D124302 by changing the assert to an early return.
This patch is intended to add a test case for the crashing scenario and
re-enable MisExpect for SampleProfiling.

[paulkirth]

use smaller test-case for crashing input.

[paulkirth]

As a general note, the test here will fail by design with the assertion in MisExpect.cpp re-enabled. That is the case I'm trying to fix/understand and address. We should probably still land the test, but the assertion will have to be removed unless we figure out a way to address the underlying issues.

[paulkirth]

@tejohnson I have a test case that encapsulates when SampleProfiling crashes we saw w/ misexpect a while ago.

What I've been trying to figure out is how a profile ever gets zero weights like this.

My understanding of the PGO pipeline is that there are 3 modes where profiling weights are added: Front End Instrumentation inserted by clang, IR profiles, and SampleProfiling. My understanding was also that these modes were incompatible with one another, so you wouldn't have weights added by multiple sources, e.g., IR and Sample Profiling.

Given that model, I designed MissExpect to infer based on the profiling mode, if an existing weight should be interpreted as added by an llvm.expect intrinsic or not. Both sample profiles, and IR profiles occur after llvm.expect intrinsics are lowered, so they assume any existing weights are from annotations. When using Clang based instrumentation we assume that all existing weights come from profiles and we instead do the check when llvm.expect intrinsics are lowered. Given that model, I'm not sure how a program ever gets a set of branch weights that are all zeros.

Our checks for MisExpect in Sample profiles examine the branch weights on an instruction just prior to the profiling weight being added. There shouldn't be an opportunity for branch weights to be added to the instruction prior to this point, except from intrinsic lowering. We know that expect intrinsics won't do that, so we can safely ignore that possibility.

The only other scenario I can think of is that profiles are being mixed (e.g. Sample + IR) or that old bitcode with existing weights is being compiled again. If either case is legal then I we may need to consider a new design that can handle those scenarios.

[tejohnson]

In D124481#3532977, @paulkirth wrote:

@tejohnson I have a test case that encapsulates when SampleProfiling crashes we saw w/ misexpect a while ago.

Won't this patch if committed trigger the failure again?

What I've been trying to figure out is how a profile ever gets zero weights like this.

Can you use the original failing test case to dig into this more? Looks like it was XFDO from the internal Google bug. Reach out to me internally if you need help reproducing that.

My understanding of the PGO pipeline is that there are 3 modes where profiling weights are added: Front End Instrumentation inserted by clang, IR profiles, and SampleProfiling. My understanding was also that these modes were incompatible with one another, so you wouldn't have weights added by multiple sources, e.g., IR and Sample Profiling.

I believe it is possible to combine IR and SamplePGO profiles, but it doesn't look like that is the case in the failing test case.

[paulkirth]

In D124481#3534375, @tejohnson wrote:

Won't this patch if committed trigger the failure again?

Yes, it will. I'm still trying to figure the situation out, but I wanted to create a case that triggers the crash with the assert, and determine if we can fix the underlying problem before going back to early return.

Can you use the original failing test case to dig into this more? Looks like it was XFDO from the internal Google bug. Reach out to me internally if you need help reproducing that.

I used that case to determine that the underlying issue is that branch weights are added that have 0 total weight across all branches. I even ran llvm-reduce over the internal example, and it came out remarkably similar to the misexpect-zero.ll test.

I believe it is possible to combine IR and SamplePGO profiles, but it doesn't look like that is the case in the failing test case.

I went back and reviewed the code in SampleProfile, and I think I understand the source of the bug, but I'm not sure exactly how to solve it completely.

When I reimplemented MisExpect, I failed to notice that part of SampleProfiling behaves very differently than when I first implemented it in 2019.

The comment in SampleProfile.cpp just below the call into misexpect illustrates the problem:

// OverwriteExistingWeights. In ThinLTO, the profile annotation is done
// twice. If the first annotation already set the weights, the second pass
// does not need to set it. With OverwriteExistingWeights, Blocks with zero
// weight should have their existing metadata (possibly annotated by LTO
// prelink) cleared.

Looking at the blame, this was changed back in 2021, and I missed that difference when I started working on this again. Previously there was no mention of ThinLTO here, and I failed to account for that scenario and the fact that an existing branch weight may have an origin other that form a lowered llvm.expect intrinsic.

An option to work around this is to only do MisExpect checking when MaxWeight > 0, which will ensure that at least one branch weight will be non-zero.

It doesn't solve the issue that there are times when a pre-existing weight doesn't imply that it comes from llvm.expect, and I really don't have a good answer to how we can address that (and also the fact that you can mix IR and sample profiling).

One option would be to augment branch weight metadata to identify how it was added: via profile or annotation. I'm not convinced that's a great idea, since it would require updates to all the parts of llvm that add branch weights., and increases the size of metadata for a single diagnostic.

[paulkirth]

So after looking at this for a while, I think the core issue is that MisExpect needs some kind of provenance information about whether or not the branch weight originates from an llvm.expect intrinsic. If we could know that, then MisExpect diagnostics should be correct even if you run several profiling passes or combine different types of profiling, since we would only report issues on branch weights that had the correct provenance.

I see two basic ways to do that:

1. Add a new field to MD_prof that carries the provenance
2. Add an external piece of metadata that describes the same thing

I think the best option is to simply add that information into the branch weight metadata directly, so add an extra field that is an enum or another piece of metadata that describes whether or not it comes from an expect intrinsic. That would avoid inventing any additional machinery to correctly update the branch weight and also some additional metadata that may be there.

Changing the layout of MD_prof seems to be problematic though, especially given that we need to maintain backwards compatibility. I think the normal way to transition these changes is to introduce a replacement metadata and use that everywhere instead of the old version. the bitcode reader can then automatically update the old MD -> the new one. This seems like it may be a lot to do, given that all LLVM tests that have branch weights would need to be updated (at least the FileCheck portions if nothing else). That can probably be done w/ a good regex, but its a large invasive change which is enough to make me hesitant.

@tejohnson what are your thoughts on this approach? Do you think this would be a good direction to pursue? Are there other factors that I've failed to consider?

[paulkirth]

Rebase and restore assertion.

A follow up patch will try to address the problem of provenance tracking.

[paulkirth]

Remove FIXME, since we're re-enabling the call to checkExpectAnnotations

[tejohnson]

LGTM but I think the change title should also include the fact that misexpect is being reenabled for sample profiling

[paulkirth]

Update patch title

llvm/lib/Transforms/IPO/SampleProfile.cpp

 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/IPO/ProfiledCallGraph.h"
 #include "llvm/Transforms/IPO/SampleContextTracker.h"
 #include "llvm/Transforms/IPO/SampleProfileProbe.h"
 #include "llvm/Transforms/Instrumentation.h"
 #include "llvm/Transforms/Utils/CallPromotionUtils.h"
 #include "llvm/Transforms/Utils/Cloning.h"
+#include "llvm/Transforms/Utils/MisExpect.h"
 #include "llvm/Transforms/Utils/SampleProfileLoaderBaseImpl.h"
 #include "llvm/Transforms/Utils/SampleProfileLoaderBaseUtil.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <functional>
 #include <limits>
 #include <map>
for (unsigned I = 0; I < TI->getNumSuccessors(); ++I) {
       if (Weight != 0) {
         if (Weight > MaxWeight) {
           MaxWeight = Weight;
           MaxDestInst = Succ->getFirstNonPHIOrDbgOrLifetime();
         }
       }
     }
 
-    // FIXME: Re-enable for sample profiling after investigating why the sum
-    // of branch weights can be 0
-    //
-    // misexpect::checkExpectAnnotations(*TI, Weights, /*IsFrontend=*/false);
+    misexpect::checkExpectAnnotations(*TI, Weights, /*IsFrontend=*/false);
 
     uint64_t TempWeight;
     // Only set weights if there is at least one non-zero weight.
     // In any other case, let the analyzer set weights.
     // Do not set weights if the weights are present unless under
     // OverwriteExistingWeights. In ThinLTO, the profile annotation is done
     // twice. If the first annotation already set the weights, the second pass
     // does not need to set it. With OverwriteExistingWeights, Blocks with zero

llvm/lib/Transforms/Utils/MisExpect.cpp

void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights,
   uint64_t TotalBranchWeight =
       LikelyBranchWeight + (UnlikelyBranchWeight * NumUnlikelyTargets);
 
   // FIXME: When we've addressed sample profiling, restore the assertion
   //
   // We cannot calculate branch probability if either of these invariants aren't
   // met. However, MisExpect diagnostics should not prevent code from compiling,
   // so we simply forgo emitting diagnostics here, and return early.
+  // assert((TotalBranchWeight >= LikelyBranchWeight) && (TotalBranchWeight > 0)
+  //              && "TotalBranchWeight is less than the Likely branch weight");
   if ((TotalBranchWeight == 0) || (TotalBranchWeight <= LikelyBranchWeight))
     return;
 
   // To determine our threshold value we need to obtain the branch probability
   // for the weights added by llvm.expect and use that proportion to calculate
   // our threshold based on the collected profile data.
   auto LikelyProbablilty = BranchProbability::getBranchProbability(
       LikelyBranchWeight, TotalBranchWeight);

llvm/test/Transforms/SampleProfile/Inputs/misexpect.prof

+main:15680:2500
+ 1: 2500
+ 4: 1000
+ 5: 1000
+ 6: 800
+ 7: 500
+ 9: 10226
+ 10: 2243
+ 16: 0
+ 18: 0

llvm/test/Transforms/SampleProfile/misexpect-zero.ll

+; Ensure MisExpect does not crash when given branches with zero weights
+
+; RUN: opt < %s -passes="sample-profile" -sample-profile-file=%S/Inputs/misexpect.prof -pgo-warn-misexpect -S 2>&1  | FileCheck %s
+
+define i32 @main() #0 !dbg !36 {
+ ; CHECK-LABEL: @main(
+; CHECK-NEXT: for.cond:
+; CHECK-NEXT: %0 = load i32, i32* null, align 4, !dbg !44
+; CHECK-NEXT: br i1 false, label %for.body, label %for.end, !prof !49
+; CHECK: for.body:
+; CHECK-NEXT: ret i32 0
+; CHECK: for.end:
+; CHECK-NEXT: ret i32 0
+; NOT: warning:
+for.cond:
+  %0 = load i32, i32* null, align 4, !dbg !43
+  br i1 false, label %for.body, label %for.end, !prof !48
+
+for.body:                                         ; preds = %for.cond
+  ret i32 0
+
+for.end:                                          ; preds = %for.cond
+  ret i32 0
+}
+
+; Function Attrs: nocallback nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { "use-sample-profile" }
+attributes #1 = { nocallback nofree nosync nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!5, !6, !7}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 248211) (llvm/trunk 248217)", isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug, enums: !2, retainedTypes: !3)
+!1 = !DIFile(filename: "test.cc", directory: "/ssd/llvm_commit")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIBasicType(name: "double", size: 64, align: 64, encoding: DW_ATE_float)
+!5 = !{i32 2, !"Dwarf Version", i32 4}
+!6 = !{i32 2, !"Debug Info Version", i32 3}
+!7 = !{i32 1, !"ProfileSummary", !8}
+!8 = !{!9, !10, !11, !12, !13, !14, !15, !16, !17, !18}
+!9 = !{!"ProfileFormat", !"SampleProfile"}
+!10 = !{!"TotalCount", i64 0}
+!11 = !{!"MaxCount", i64 0}
+!12 = !{!"MaxInternalCount", i64 0}
+!13 = !{!"MaxFunctionCount", i64 0}
+!14 = !{!"NumCounts", i64 9}
+!15 = !{!"NumFunctions", i64 1}
+!16 = !{!"IsPartialProfile", i64 0}
+!17 = !{!"PartialProfileRatio", double 0.000000e+00}
+!18 = !{!"DetailedSummary", !19}
+!19 = !{!20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35}
+!20 = !{i32 10000, i64 0, i32 0}
+!21 = !{i32 100000, i64 0, i32 0}
+!22 = !{i32 200000, i64 0, i32 0}
+!23 = !{i32 300000, i64 0, i32 0}
+!24 = !{i32 400000, i64 0, i32 0}
+!25 = !{i32 500000, i64 0, i32 0}
+!26 = !{i32 600000, i64 0, i32 0}
+!27 = !{i32 700000, i64 0, i32 0}
+!28 = !{i32 800000, i64 0, i32 0}
+!29 = !{i32 900000, i64 0, i32 0}
+!30 = !{i32 950000, i64 0, i32 0}
+!31 = !{i32 990000, i64 0, i32 0}
+!32 = !{i32 999000, i64 0, i32 0}
+!33 = !{i32 999900, i64 0, i32 0}
+!34 = !{i32 999990, i64 0, i32 0}
+!35 = !{i32 999999, i64 0, i32 0}
+!36 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 4, type: !37, scopeLine: 4, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!37 = !DISubroutineType(types: !38)
+!38 = !{!39, !39, !40}
+!39 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!40 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !41, size: 64, align: 64)
+!41 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !42, size: 64, align: 64)
+!42 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!43 = !DILocation(line: 11, column: 22, scope: !44)
+!44 = distinct !DILexicalBlock(scope: !45, file: !1, line: 11, column: 6)
+!45 = distinct !DILexicalBlock(scope: !46, file: !1, line: 11, column: 6)
+!46 = distinct !DILexicalBlock(scope: !47, file: !1, line: 9, column: 21)
+!47 = distinct !DILexicalBlock(scope: !36, file: !1, line: 9, column: 8)
+; These branch weights shouldn't be removed by these passes
+; CHECK: !{{[0-9]+}} = !{!"branch_weights", i32 0, i32 0}
+!48 = !{!"branch_weights", i32 0, i32 0}

llvm/test/Transforms/SampleProfile/misexpect.ll

+; Test that misexpect diagnostics are issued in sample profiling
+; RUN: opt < %s -passes="function(lower-expect),sample-profile" -sample-profile-file=%S/Inputs/misexpect.prof -pgo-warn-misexpect -S 2>&1  | FileCheck %s --check-prefix=WARNING
+
+; Test that if expect intrinsics are not lowered, then no diagnostics are issued
+; RUN: opt < %s -passes="sample-profile" -sample-profile-file=%S/Inputs/misexpect.prof -pgo-warn-misexpect -S 2>&1  | FileCheck %s --check-prefix=NONE
+
+; Original C++ code for this test case:
+;
+; #include <stdio.h>
+; #include <stdlib.h>
+
+; int main(int argc, char *argv[]) {
+;   if (argc < 2)
+;     return 1;
+;   double result;
+;   int limit = atoi(argv[1]);
+;   if (limit > 100) {
+;     double s = 23.041968 * atoi(argv[2]);
+;     for (int u = 0; u < limit; u++) {
+;       double x = s;
+;       s = x + 3.049 + (double)u;
+;       s -= s + 3.94 / x * 0.32;
+;     }
+;     result = s;
+;   } else {
+;     result = atoi(argv[2]);
+;   }
+;   printf("result is %lf\n", result);
+;   return 0;
+; }
+
+; WARNING-DAG: warning: test.cc:9:14: 20.06%
+; WARNING-DAG: warning: test.cc:11:24: 92.74%
+
+; NONE-NOT: warning: test.cc:9:14: 20.06%
+; NONE-NOT: warning: test.cc:11:24: 92.74%
+
+@.str = private unnamed_addr constant [15 x i8] c"result is %lf\0A\00", align 1
+
+; Function Attrs: uwtable
+define i32 @main(i32 %argc, i8** %argv) #0 !dbg !6 {
+
+entry:
+  %retval = alloca i32, align 4
+  %argc.addr = alloca i32, align 4
+  %argv.addr = alloca i8**, align 8
+  %result = alloca double, align 8
+  %limit = alloca i32, align 4
+  %s = alloca double, align 8
+  %u = alloca i32, align 4
+  %x = alloca double, align 8
+  store i32 0, i32* %retval, align 4
+  store i32 %argc, i32* %argc.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %argc.addr, metadata !16, metadata !17), !dbg !18
+  store i8** %argv, i8*** %argv.addr, align 8
+  call void @llvm.dbg.declare(metadata i8*** %argv.addr, metadata !19, metadata !17), !dbg !20
+  %0 = load i32, i32* %argc.addr, align 4, !dbg !21
+  %cmp = icmp slt i32 %0, 2, !dbg !23
+  br i1 %cmp, label %if.then, label %if.end, !dbg !24
+
+if.then:                                          ; preds = %entry
+  store i32 1, i32* %retval, align 4, !dbg !25
+  br label %return, !dbg !25
+
+if.end:                                           ; preds = %entry
+  call void @llvm.dbg.declare(metadata double* %result, metadata !26, metadata !17), !dbg !27
+  call void @llvm.dbg.declare(metadata i32* %limit, metadata !28, metadata !17), !dbg !29
+  %1 = load i8**, i8*** %argv.addr, align 8, !dbg !30
+  %arrayidx = getelementptr inbounds i8*, i8** %1, i64 1, !dbg !30
+  %2 = load i8*, i8** %arrayidx, align 8, !dbg !30
+  %call = call i32 @atoi(i8* %2) #4, !dbg !31
+  store i32 %call, i32* %limit, align 4, !dbg !29
+  %3 = load i32, i32* %limit, align 4, !dbg !32
+  %exp = call i32 @llvm.expect.i32(i32 %3, i32 0)
+  %tobool = icmp ne i32 %exp, 0, !dbg !34
+  br i1 %tobool, label %if.then.2, label %if.else, !dbg !35
+
+if.then.2:                                        ; preds = %if.end
+  call void @llvm.dbg.declare(metadata double* %s, metadata !36, metadata !17), !dbg !38
+  %4 = load i8**, i8*** %argv.addr, align 8, !dbg !39
+  %arrayidx3 = getelementptr inbounds i8*, i8** %4, i64 2, !dbg !39
+  %5 = load i8*, i8** %arrayidx3, align 8, !dbg !39
+  %call4 = call i32 @atoi(i8* %5) #4, !dbg !40
+  %conv = sitofp i32 %call4 to double, !dbg !40
+  %mul = fmul double 0x40370ABE6A337A81, %conv, !dbg !41
+  store double %mul, double* %s, align 8, !dbg !38
+  call void @llvm.dbg.declare(metadata i32* %u, metadata !42, metadata !17), !dbg !44
+  store i32 0, i32* %u, align 4, !dbg !44
+  br label %for.cond, !dbg !45
+
+for.cond:                                         ; preds = %for.inc, %if.then.2
+  %6 = load i32, i32* %u, align 4, !dbg !46
+  %7 = load i32, i32* %limit, align 4, !dbg !48
+  %expval = call i32 @llvm.expect.i32(i32 %6, i32 1)
+  %cmp5 = icmp ne i32 %expval, 0, !dbg !49
+  br i1 %cmp5, label %for.body, label %for.end, !dbg !50
+
+for.body:                                         ; preds = %for.cond
+  call void @llvm.dbg.declare(metadata double* %x, metadata !51, metadata !17), !dbg !53
+  %8 = load double, double* %s, align 8, !dbg !54
+  store double %8, double* %x, align 8, !dbg !53
+  %9 = load double, double* %x, align 8, !dbg !55
+  %add = fadd double %9, 3.049000e+00, !dbg !56
+  %10 = load i32, i32* %u, align 4, !dbg !57
+  %conv6 = sitofp i32 %10 to double, !dbg !57
+  %add7 = fadd double %add, %conv6, !dbg !58
+  store double %add7, double* %s, align 8, !dbg !59
+  %11 = load double, double* %s, align 8, !dbg !60
+  %12 = load double, double* %x, align 8, !dbg !61
+  %div = fdiv double 3.940000e+00, %12, !dbg !62
+  %mul8 = fmul double %div, 3.200000e-01, !dbg !63
+  %add9 = fadd double %11, %mul8, !dbg !64
+  %13 = load double, double* %s, align 8, !dbg !65
+  %sub = fsub double %13, %add9, !dbg !65
+  store double %sub, double* %s, align 8, !dbg !65
+  br label %for.inc, !dbg !66
+
+for.inc:                                          ; preds = %for.body
+  %14 = load i32, i32* %u, align 4, !dbg !67
+  %inc = add nsw i32 %14, 1, !dbg !67
+  store i32 %inc, i32* %u, align 4, !dbg !67
+  br label %for.cond, !dbg !68
+
+for.end:                                          ; preds = %for.cond
+  %15 = load double, double* %s, align 8, !dbg !69
+  store double %15, double* %result, align 8, !dbg !70
+  br label %if.end.13, !dbg !71
+
+if.else:                                          ; preds = %if.end
+  %16 = load i8**, i8*** %argv.addr, align 8, !dbg !72
+  %arrayidx10 = getelementptr inbounds i8*, i8** %16, i64 2, !dbg !72
+  %17 = load i8*, i8** %arrayidx10, align 8, !dbg !72
+  %call11 = call i32 @atoi(i8* %17) #4, !dbg !74
+  %conv12 = sitofp i32 %call11 to double, !dbg !74
+  store double %conv12, double* %result, align 8, !dbg !75
+  br label %if.end.13
+
+if.end.13:                                        ; preds = %if.else, %for.end
+  %18 = load double, double* %result, align 8, !dbg !76
+  %call14 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i32 0, i32 0), double %18), !dbg !77
+  store i32 0, i32* %retval, align 4, !dbg !78
+  br label %return, !dbg !78
+
+return:                                           ; preds = %if.end.13, %if.then
+  %19 = load i32, i32* %retval, align 4, !dbg !79
+  ret i32 %19, !dbg !79
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind readonly
+declare i32 @atoi(i8*) #2
+
+declare i32 @printf(i8*, ...) #3
+
+; Function Attrs: nounwind readnone willreturn
+declare i32 @llvm.expect.i32(i32, i32) #5
+
+
+attributes #0 = { uwtable "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" "use-sample-profile" }
+attributes #1 = { nounwind readnone }
+attributes #2 = { nounwind readonly "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #3 = { "disable-tail-calls"="false" "less-precise-fpmad"="false" "frame-pointer"="all" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+sse,+sse2" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #4 = { nounwind readonly }
+attributes #5 = { nounwind readnone willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!13, !14}
+!llvm.ident = !{!15}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.8.0 (trunk 248211) (llvm/trunk 248217)", isOptimized: false, runtimeVersion: 0, emissionKind: NoDebug, enums: !2, retainedTypes: !3)
+!1 = !DIFile(filename: "test.cc", directory: "/ssd/llvm_commit")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIBasicType(name: "double", size: 64, align: 64, encoding: DW_ATE_float)
+!6 = distinct !DISubprogram(name: "main", scope: !1, file: !1, line: 4, type: !7, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!7 = !DISubroutineType(types: !8)
+!8 = !{!9, !9, !10}
+!9 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !11, size: 64, align: 64)
+!11 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !12, size: 64, align: 64)
+!12 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!13 = !{i32 2, !"Dwarf Version", i32 4}
+!14 = !{i32 2, !"Debug Info Version", i32 3}
+!15 = !{!"clang version 3.8.0 (trunk 248211) (llvm/trunk 248217)"}
+!16 = !DILocalVariable(name: "argc", arg: 1, scope: !6, file: !1, line: 4, type: !9)
+!17 = !DIExpression()
+!18 = !DILocation(line: 4, column: 15, scope: !6)
+!19 = !DILocalVariable(name: "argv", arg: 2, scope: !6, file: !1, line: 4, type: !10)
+!20 = !DILocation(line: 4, column: 27, scope: !6)
+!21 = !DILocation(line: 5, column: 8, scope: !22)
+!22 = distinct !DILexicalBlock(scope: !6, file: !1, line: 5, column: 8)
+!23 = !DILocation(line: 5, column: 13, scope: !22)
+!24 = !DILocation(line: 5, column: 8, scope: !6)
+!25 = !DILocation(line: 6, column: 6, scope: !22)
+!26 = !DILocalVariable(name: "result", scope: !6, file: !1, line: 7, type: !4)
+!27 = !DILocation(line: 7, column: 11, scope: !6)
+!28 = !DILocalVariable(name: "limit", scope: !6, file: !1, line: 8, type: !9)
+!29 = !DILocation(line: 8, column: 8, scope: !6)
+!30 = !DILocation(line: 8, column: 21, scope: !6)
+!31 = !DILocation(line: 8, column: 16, scope: !6)
+!32 = !DILocation(line: 9, column: 8, scope: !33)
+!33 = distinct !DILexicalBlock(scope: !6, file: !1, line: 9, column: 8)
+!34 = !DILocation(line: 9, column: 14, scope: !33)
+!35 = !DILocation(line: 9, column: 8, scope: !6)
+!36 = !DILocalVariable(name: "s", scope: !37, file: !1, line: 10, type: !4)
+!37 = distinct !DILexicalBlock(scope: !33, file: !1, line: 9, column: 21)
+!38 = !DILocation(line: 10, column: 13, scope: !37)
+!39 = !DILocation(line: 10, column: 34, scope: !37)
+!40 = !DILocation(line: 10, column: 29, scope: !37)
+!41 = !DILocation(line: 10, column: 27, scope: !37)
+!42 = !DILocalVariable(name: "u", scope: !43, file: !1, line: 11, type: !9)
+!43 = distinct !DILexicalBlock(scope: !37, file: !1, line: 11, column: 6)
+!44 = !DILocation(line: 11, column: 15, scope: !43)
+!45 = !DILocation(line: 11, column: 11, scope: !43)
+!46 = !DILocation(line: 11, column: 22, scope: !47)
+!47 = distinct !DILexicalBlock(scope: !43, file: !1, line: 11, column: 6)
+!48 = !DILocation(line: 11, column: 26, scope: !47)
+!49 = !DILocation(line: 11, column: 24, scope: !47)
+!50 = !DILocation(line: 11, column: 6, scope: !43)
+!51 = !DILocalVariable(name: "x", scope: !52, file: !1, line: 12, type: !4)
+!52 = distinct !DILexicalBlock(scope: !47, file: !1, line: 11, column: 38)
+!53 = !DILocation(line: 12, column: 15, scope: !52)
+!54 = !DILocation(line: 12, column: 19, scope: !52)
+!55 = !DILocation(line: 13, column: 12, scope: !52)
+!56 = !DILocation(line: 13, column: 14, scope: !52)
+!57 = !DILocation(line: 13, column: 32, scope: !52)
+!58 = !DILocation(line: 13, column: 22, scope: !52)
+!59 = !DILocation(line: 13, column: 10, scope: !52)
+!60 = !DILocation(line: 14, column: 13, scope: !52)
+!61 = !DILocation(line: 14, column: 24, scope: !52)
+!62 = !DILocation(line: 14, column: 22, scope: !52)
+!63 = !DILocation(line: 14, column: 26, scope: !52)
+!64 = !DILocation(line: 14, column: 15, scope: !52)
+!65 = !DILocation(line: 14, column: 10, scope: !52)
+!66 = !DILocation(line: 15, column: 6, scope: !52)
+!67 = !DILocation(line: 11, column: 34, scope: !47)
+!68 = !DILocation(line: 11, column: 6, scope: !47)
+!69 = !DILocation(line: 16, column: 15, scope: !37)
+!70 = !DILocation(line: 16, column: 13, scope: !37)
+!71 = !DILocation(line: 17, column: 4, scope: !37)
+!72 = !DILocation(line: 18, column: 20, scope: !73)
+!73 = distinct !DILexicalBlock(scope: !33, file: !1, line: 17, column: 11)
+!74 = !DILocation(line: 18, column: 15, scope: !73)
+!75 = !DILocation(line: 18, column: 13, scope: !73)
+!76 = !DILocation(line: 20, column: 30, scope: !6)
+!77 = !DILocation(line: 20, column: 4, scope: !6)
+!78 = !DILocation(line: 21, column: 4, scope: !6)
+!79 = !DILocation(line: 22, column: 2, scope: !6)