[PGO] Detect more structural changes with the stable hash

[vsk]

Summary

Lifting from Bob Wilson's notes: The hash value that we compute and
store in PGO profile data to detect out-of-date profiles does not
include enough information. This means that many significant changes to
the source will not cause compiler warnings about the profile being out
of date, and worse, we may continue to use the outdated profile data to
make bad optimization decisions. There is some tension here because
some source changes won't affect PGO and we don't want to invalidate the
profile unnecessarily.

This patch adds a new hashing scheme which is more sensitive to loop
nesting, conditions, and out-of-order control flow. Here are examples
which show snippets which get the same hash under the current scheme,
and different hashes under the new scheme:

Loop Nesting Example

// Snippet 1
while (foo()) {
  while (bar()) {}
}

// Snippet 2
while (foo()) {}
while (bar()) {}

Condition Example

// Snippet 1
if (foo())
  bar();
baz();

// Snippet 2
if (foo())
  bar();
else
  baz();

Out-of-order Control Flow Example

// Snippet 1
while (foo()) {
  if (bar()) {}
  baz();
}

// Snippet 2
while (foo()) {
  if (bar())
    continue;
  baz();
}

In each of these cases, it's useful to differentiate between the
snippets because swapping their profiles gives bad optimization hints.

The new hashing scheme considers some logical operators in an effort to
detect more changes in conditions. This isn't a perfect scheme. E.g, it
does not produce the same hash for these equivalent snippets:

// Snippet 1
bool c = !a || b;
if (d && e) {}

// Snippet 2
bool f = d && e;
bool c = !a || b;
if (f) {}

This would require an expensive data flow analysis. Short of that, the
new hashing scheme looks reasonably complete, based on a scan over the
statements we place counters on.

Profiles which use the old version of the PGO hash remain valid and can
be used without issue (there are tests in tree which check this).

rdar://17068282

[arphaman]

lib/CodeGen/CodeGenPGO.cpp

193

Am I missing something or will this call always return the same type as before since the first if will weed out statements which have hash only in v2 (since getHashType(PGO_HASH_V1, S) will return None for the new statements)?

[bob.wilson]

I'm excited to see some progress on this, but since there is overhead to adding a new hashing scheme, I think we should do more before introducing a new scheme. One of the problems with the previous scheme is that is did not take into account nesting. Distinguishing an if-statement from an if-else statement is good but we also need to distinguish what code is inside the then-block, else-block, and the code afterward. As it stands, I believe the following are all hashed the same, even with this patch:

Loop after the if-else:

if (condition1())
  x = 1;
else
  x = 2;
while (condition2()) body();

Loop in the else-block:

if (condition1())
  x = 1;
else
  while (condition2()) body();

Loop in the then-block:

if (condition1()) {
  while (condition2()) body();
} else
  x = 2

It would be good to fix that.

[vsk]

Apart from Alex's point, this patch is missing a compatibility test for v5 of the profile format, and is missing coverage for the new entries in HashType.

lib/CodeGen/CodeGenPGO.cpp

193

You're right, I need to rethink this. At the moment, the hash only changes for IfStmts which have Else blocks.

[vsk]

• Handle loop nesting, conditions, and out-of-order control flow.
• Improve test coverage. Add a format compatibility test, and check that functions which were previously hashed the same way get different hashes now.

[vsk]

• Consider logical nots and some binary comparison operators in the hash, per an offline conversation with @bogner

[arphaman]

Generally it LG

lib/CodeGen/CodeGenPGO.cpp

237

What about ObjCAtTryStmt?

296

Might as well include the ObjCAtThrowStmt as well.

[vsk]

lib/CodeGen/CodeGenPGO.cpp

237

I thought about this, but: we don't place a counter on ObjC at-try's, so it seems a bit moot to invalidate the profile if we see one change.

296

If profiling at-try isn't very important, I'm not sure the hash should be sensitive to at-throw either. I do see situations where it could be helpful, but IMO the potential benefit is outweighed by having extra invalidations.

[arphaman]

ok, sgtm

[vsk]

Thanks for the review Alex. There hasn't been any more feedback so I'll commit this soon.

lib/CodeGen/CodeGenPGO.cpp

 }
 
 void CodeGenPGO::setFuncName(llvm::Function *Fn) {
   setFuncName(Fn->getName(), Fn->getLinkage());
   // Create PGOFuncName meta data.
   llvm::createPGOFuncNameMetadata(*Fn, FuncName);
 }
 
+/// The version of the PGO hash algorithm.
+enum PGOHashVersion : unsigned {
+  PGO_HASH_V1,
+  PGO_HASH_V2,
+
+  // Keep this set to the latest hash version.
+  PGO_HASH_LATEST = PGO_HASH_V2
+};
+
 namespace {
 /// \brief Stable hasher for PGO region counters.
 ///
 /// PGOHash produces a stable hash of a given function's control flow.
 ///
 /// Changing the output of this hash will invalidate all previously generated
 /// profiles -- i.e., don't do it.
 ///
 /// \note  When this hash does eventually change (years?), we still need to
 /// support old hashes.  We'll need to pull in the version number from the
 /// profile data format and use the matching hash function.
 class PGOHash {
   uint64_t Working;
   unsigned Count;
+  PGOHashVersion HashVersion;
   llvm::MD5 MD5;
 
   static const int NumBitsPerType = 6;
   static const unsigned NumTypesPerWord = sizeof(uint64_t) * 8 / NumBitsPerType;
   static const unsigned TooBig = 1u << NumBitsPerType;
 
 public:
   /// \brief Hash values for AST nodes.
enum HashType : unsigned char {
     DefaultStmt,
     IfStmt,
     CXXTryStmt,
     CXXCatchStmt,
     ConditionalOperator,
     BinaryOperatorLAnd,
     BinaryOperatorLOr,
     BinaryConditionalOperator,
+    // The preceding values are available with PGO_HASH_V1.
+
+    EndOfScope,
+    IfThenBranch,
+    IfElseBranch,
+    GotoStmt,
+    IndirectGotoStmt,
+    BreakStmt,
+    ContinueStmt,
+    ReturnStmt,
+    ThrowExpr,
+    // The preceding values are available with PGO_HASH_V2.
 
     // Keep this last.  It's for the static assert that follows.
     LastHashType
   };
   static_assert(LastHashType <= TooBig, "Too many types in HashType");
 
-  // TODO: When this format changes, take in a version number here, and use the
-  // old hash calculation for file formats that used the old hash.
-  PGOHash() : Working(0), Count(0) {}
+  PGOHash(PGOHashVersion HashVersion)
+      : Working(0), Count(0), HashVersion(HashVersion), MD5() {}
   void combine(HashType Type);
   uint64_t finalize();
+  PGOHashVersion getHashVersion() const { return HashVersion; }
 };
 const int PGOHash::NumBitsPerType;
 const unsigned PGOHash::NumTypesPerWord;
 const unsigned PGOHash::TooBig;
 
+/// Get the PGO hash version used in the given indexed profile.
+static PGOHashVersion getPGOHashVersion(llvm::IndexedInstrProfReader *PGOReader,
+                                        CodeGenModule &CGM) {
+  if (PGOReader->getVersion() <= 4)
+    return PGO_HASH_V1;
+  return PGO_HASH_V2;
+}
+
 /// A RecursiveASTVisitor that fills a map of statements to PGO counters.
 struct MapRegionCounters : public RecursiveASTVisitor<MapRegionCounters> {
+  using Base = RecursiveASTVisitor<MapRegionCounters>;
+
   /// The next counter value to assign.
   unsigned NextCounter;
   /// The function hash.
   PGOHash Hash;
   /// The map of statements to counters.
   llvm::DenseMap<const Stmt *, unsigned> &CounterMap;
 
-  MapRegionCounters(llvm::DenseMap<const Stmt *, unsigned> &CounterMap)
-      : NextCounter(0), CounterMap(CounterMap) {}
+  MapRegionCounters(PGOHashVersion HashVersion,
+                    llvm::DenseMap<const Stmt *, unsigned> &CounterMap)
+      : NextCounter(0), Hash(HashVersion), CounterMap(CounterMap) {}
 
   // Blocks and lambdas are handled as separate functions, so we need not
   // traverse them in the parent context.
   bool TraverseBlockExpr(BlockExpr *BE) { return true; }
   bool TraverseLambdaBody(LambdaExpr *LE) { return true; }
   bool TraverseCapturedStmt(CapturedStmt *CS) { return true; }
 
   bool VisitDecl(const Decl *D) {
bool VisitDecl(const Decl *D) {
     case Decl::Block:
     case Decl::Captured:
       CounterMap[D->getBody()] = NextCounter++;
       break;
     }
     return true;
   }
 
-  bool VisitStmt(const Stmt *S) {
-    auto Type = getHashType(S);
-    if (Type == PGOHash::None)
-      return true;
-
+  /// If \p S gets a fresh counter, update the counter mappings. Return the
+  /// V1 hash of \p S.
+  PGOHash::HashType updateCounterMappings(Stmt *S) {
+    auto Type = getHashType(PGO_HASH_V1, S);
+    if (Type != PGOHash::None)
       CounterMap[S] = NextCounter++;
+    return Type;
+  }
+
+  /// Include \p S in the function hash.
+  bool VisitStmt(Stmt *S) {
+    auto Type = updateCounterMappings(S);
+    if (Hash.getHashVersion() != PGO_HASH_V1)
+      Type = getHashType(Hash.getHashVersion(), S);
+    if (Type != PGOHash::None)
       Hash.combine(Type);
     return true;
   }
-  PGOHash::HashType getHashType(const Stmt *S) {
+
+  bool TraverseIfStmt(IfStmt *If) {
+    // If we used the V1 hash, use the default traversal.
+    if (Hash.getHashVersion() == PGO_HASH_V1)
+      return Base::TraverseIfStmt(If);
+
+    // Otherwise, keep track of which branch we're in while traversing.
+    VisitStmt(If);
+    for (Stmt *CS : If->children()) {
+      if (!CS)
+        continue;
+      if (CS == If->getThen())
+        Hash.combine(PGOHash::IfThenBranch);
+      else if (CS == If->getElse())
+        Hash.combine(PGOHash::IfElseBranch);
+      TraverseStmt(CS);
+    }
+    Hash.combine(PGOHash::EndOfScope);
+    return true;
+  }
+
+// If the statement type \p N is nestable, and its nesting impacts profile
+// stability, define a custom traversal which tracks the end of the statement
+// in the hash (provided we're not using the V1 hash).
+#define DEFINE_NESTABLE_TRAVERSAL(N)                                           \
+  bool Traverse##N(N *S) {                                                     \
+    Base::Traverse##N(S);                                                      \
+    if (Hash.getHashVersion() != PGO_HASH_V1)                                  \
+      Hash.combine(PGOHash::EndOfScope);                                       \
+    return true;                                                               \
+  }
+
+  DEFINE_NESTABLE_TRAVERSAL(WhileStmt)
+  DEFINE_NESTABLE_TRAVERSAL(DoStmt)
+  DEFINE_NESTABLE_TRAVERSAL(ForStmt)
+  DEFINE_NESTABLE_TRAVERSAL(CXXForRangeStmt)
+  DEFINE_NESTABLE_TRAVERSAL(ObjCForCollectionStmt)
+  DEFINE_NESTABLE_TRAVERSAL(CXXTryStmt)
+  DEFINE_NESTABLE_TRAVERSAL(CXXCatchStmt)
+
+  /// Get version \p HashVersion of the PGO hash for \p S.
+  PGOHash::HashType getHashType(PGOHashVersion HashVersion, const Stmt *S) {
     switch (S->getStmtClass()) {
     default:
       break;
     case Stmt::LabelStmtClass:
       return PGOHash::LabelStmt;
     case Stmt::WhileStmtClass:
       return PGOHash::WhileStmt;
     case Stmt::DoStmtClass:
case Stmt::BinaryOperatorClass: {
       const BinaryOperator *BO = cast<BinaryOperator>(S);
       if (BO->getOpcode() == BO_LAnd)
         return PGOHash::BinaryOperatorLAnd;
       if (BO->getOpcode() == BO_LOr)
         return PGOHash::BinaryOperatorLOr;
       break;
     }
     }
+
+    if (HashVersion == PGO_HASH_V2) {
+      switch (S->getStmtClass()) {
+      default:
+        break;
+      case Stmt::GotoStmtClass:
+        return PGOHash::GotoStmt;
+      case Stmt::IndirectGotoStmtClass:
+        return PGOHash::IndirectGotoStmt;
+      case Stmt::BreakStmtClass:
+        return PGOHash::BreakStmt;
+      case Stmt::ContinueStmtClass:
+        return PGOHash::ContinueStmt;
+      case Stmt::ReturnStmtClass:
+        return PGOHash::ReturnStmt;
+      case Stmt::CXXThrowExprClass:
+        return PGOHash::ThrowExpr;
+      }
+    }
+
     return PGOHash::None;
   }
 };
 
 /// A StmtVisitor that propagates the raw counts through the AST and
 /// records the count at statements where the value may change.
 struct ComputeRegionCounts : public ConstStmtVisitor<ComputeRegionCounts> {
   /// PGO state.
if (PGOReader) {
     SourceManager &SM = CGM.getContext().getSourceManager();
     loadRegionCounts(PGOReader, SM.isInMainFile(D->getLocation()));
     computeRegionCounts(D);
     applyFunctionAttributes(PGOReader, Fn);
   }
 }
 
 void CodeGenPGO::mapRegionCounters(const Decl *D) {
+  // Use the latest hash version when inserting instrumentation, but use the
+  // version in the indexed profile if we're reading PGO data.
+  PGOHashVersion HashVersion = PGO_HASH_LATEST;
+  if (auto *PGOReader = CGM.getPGOReader())
+    HashVersion = getPGOHashVersion(PGOReader, CGM);
+
   RegionCounterMap.reset(new llvm::DenseMap<const Stmt *, unsigned>);
-  MapRegionCounters Walker(*RegionCounterMap);
+  MapRegionCounters Walker(HashVersion, *RegionCounterMap);
   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
     Walker.TraverseDecl(const_cast<FunctionDecl *>(FD));
   else if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D))
     Walker.TraverseDecl(const_cast<ObjCMethodDecl *>(MD));
   else if (const BlockDecl *BD = dyn_cast_or_null<BlockDecl>(D))
     Walker.TraverseDecl(const_cast<BlockDecl *>(BD));
   else if (const CapturedDecl *CD = dyn_cast_or_null<CapturedDecl>(D))
     Walker.TraverseDecl(const_cast<CapturedDecl *>(CD));

test/Profile/Inputs/c-captured.proftext

 c-captured.c:__captured_stmt
-10
+42129
 2
 1
 1
 
 c-captured.c:__captured_stmt.1
-266
[phone]
 3
 1
 10
 1
 
 main
-0
+24
 1
 1
 
 debug_captured
-650
[phone]
 3
 1
 1
 1
 

test/Profile/Inputs/c-counter-overflows.proftext

 main
-285734896137
+15677647491548331042
 8
 1
 68719476720
 64424509425
 68719476720
 21474836475
 21474836475
 21474836475
 4294967295
 

test/Profile/Inputs/c-general.proftext

 simple_loops
-16515
[phone]
 4
 1
 100
 100
 75
 
 conditionals
-74917022372782735
+9182750830229735592
 11
 1
 100
 50
 50
 33
 33
 16
 99
 100
 99
 100
 
 early_exits
-44128811889290
+2096025839707925103
 9
 1
 0
 51
 1
 25
 1
 25
 1
 0
 
 jumps
-2016037664281362839
+9928654741622472118
 22
 1
 1
 0
 1
 0
 0
 1

 1
 1
 10
 0
 10
 9
 
 switches
-2745195701975551402
+927929336721735363
 19
 1
 1
 1
 15
 7
 1
 0
 2
 2
 3
 3
 4
 4
 0
 4
 4
 5
 1
 0
 
 big_switch
-10218718452081869619
+10628738888926557271
 17
 1
 32
 32
 1
 0
 1
 1
 11
 11
 1
 1
 15
 15
 1
 1
 2
 2
 
 boolean_operators
-291222909838
[phone]
 8
 1
 100
 34
 66
 17
 34
 33
 50
 
 boolop_loops
-9760565944591
+6737083463331999740
 9
 1
 50
 51
 50
 26
 50
 51
 50
 26
 
 conditional_operator
 848
 3
 1
 0
 1
 
 do_fallthrough
-16586
[phone]
 4
 1
 10
 2
 8
 
 main
-0
+24
 1
 1
 
 c-general.c:static_func
-4
+273
 2
 1
 10
 

test/Profile/Inputs/c-unprofiled-blocks.proftext

 never_called
-44257542701577
+11157373158354158598
 9
 0
 0
 0
 0
 0
 0
 0
 0
 0
 
 main
-1
+24
 1
 1
 
 dead_code
-2859007309808137
+13352299962037520200
 10
 1
 0
 0
 0
 0
 0
 0
 0
 0
 0
 

test/Profile/Inputs/cxx-class.proftext

 _Z14simple_wrapperv
-4
+273
 2
 1
 100
 
 main
-0
+24
 1
 1
 
 _ZN6SimpleD1Ev
-10
+42129
 2
 0
 0
 
 _ZN6SimpleD2Ev
-10
+42129
 2
 100
 99
 
 _ZN6Simple6methodEv
-10
+42129
 2
 100
 99
 
 _ZN6SimpleC1Ei
-10
+42129
 2
 0
 0
 
 _ZN6SimpleC2Ei
-10
+42129
 2
 100
 99
 
 _ZN7DerivedC1Ev
-10
+42129
 2
 100
 99
 
 _ZN7DerivedD2Ev
-10
+42129
 2
 100
 99

test/Profile/Inputs/cxx-lambda.proftext

 cxx-lambda.cpp:_ZZ7lambdasvENK3$_0clEi
-654
[phone]
 3
 10
 9
 9
 
 main
-0
+24
 1
 1
 
 _Z7lambdasv
-41226
[phone]
 4
 1
 1
 10
 1
 

test/Profile/Inputs/cxx-rangefor.proftext

 _Z9range_forv
-0x000000000014a28a
+14946179421184099787
 5
 1
 4
 1
 1
 1
 
 main
-0
+24
 1
 1

test/Profile/Inputs/cxx-templates.proftext

 main
-0
+24
 1
 1
 
 _Z4loopILj0EEvv
-4
+273
 2
 1
 0
 
 _Z4loopILj100EEvv
-4
+273
 2
 1
 100
 

test/Profile/Inputs/cxx-throws.proftext

 _Z6throwsv
-18359008150154
+11182018916418797286
 9
 1
 100
 100
 66
 33
 17
 50
 33
 100
 
 _Z11unreachablei
-0x28a
[phone]
 3
 1
 1
 0
 
 main
-0x2cc
[phone]
 3
 1
 1
 1

test/Profile/Inputs/func-entry.proftext

 foo
-0
+24
 1
 1000
 
 main
-4
+17496
 2
 1
 10000

test/Profile/Inputs/gcc-flag-compatibility.proftext

 main
-4
+17496
 2
 1
 100

test/Profile/Inputs/objc-general.proftext

 objc-general.m:__13+[A foreach:]_block_invoke
-10
+42129
 2
 2
 1
 
 objc-general.m:+[A foreach:]
-6
+401
 2
 1
 2
 
 main
-0
+24
 1
 1
 
+consecutive_objc_for_ranges
+1642897
+3
+0
+0
+0
+
+nested_objc_for_ranges
+1598545
+3
+0
+0
+0

test/Profile/Inputs/objcxx-hash-v2.proftext

+_Z18loop_in_then_blockv
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z22consecutive_for_rangesv
+# Func Hash:
+1380689
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z15consecutive_dosv
+# Func Hash:
+856273
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z16nested_try_catchv
+# Func Hash:
[phone]
+# Num Counters:
+5
+# Counter Values:
+0
+0
+0
+0
+0
+
+_Z11direct_gotov
+# Func Hash:
+1281
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+main
+# Func Hash:
+24
+# Num Counters:
+1
+# Counter Values:
+1
+
+_Z9has_throwv
+# Func Hash:
+25
+# Num Counters:
+1
+# Counter Values:
+0
+
+_Z21consecutive_try_catchv
+# Func Hash:
[phone]
+# Num Counters:
+5
+# Counter Values:
+0
+0
+0
+0
+0
+
+_Z11loop_returnv
+# Func Hash:
+17937
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+_Z18if_inside_of_whilev
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z10loop_breakv
+# Func Hash:
+17809
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+_Z19if_outside_of_whilev
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z13loop_continuev
+# Func Hash:
+17873
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+_Z8no_gotosv
+# Func Hash:
+1
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+_Z8no_throwv
+# Func Hash:
+0
+# Num Counters:
+1
+# Counter Values:
+0
+
+_Z10loop_emptyv
+# Func Hash:
+273
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+_Z10nested_dosv
+# Func Hash:
+799825
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z18loop_after_if_elsev
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z18loop_in_else_blockv
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z17if_outside_of_forv
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z16if_inside_of_forv
+# Func Hash:
[phone]
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+
+_Z13indirect_gotov
+# Func Hash:
+1345
+# Num Counters:
+2
+# Counter Values:
+0
+0
+
+_Z17nested_for_rangesv
+# Func Hash:
+1332305
+# Num Counters:
+3
+# Counter Values:
+0
+0
+0
+

test/Profile/c-outdated-data.c

 // Test that outdated data is ignored.
 
 // FIXME: It would be nice to use -verify here instead of FileCheck, but -verify
 // doesn't play well with warnings that have no line number.
 
 // RUN: llvm-profdata merge %S/Inputs/c-outdated-data.proftext -o %t.profdata
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name c-outdated-data.c %s -o /dev/null -emit-llvm -fprofile-instrument-use-path=%t.profdata 2>&1 | FileCheck %s -check-prefix=NO_MISSING
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name c-outdated-data.c %s -o /dev/null -emit-llvm -Wprofile-instr-missing -fprofile-instrument-use-path=%t.profdata 2>&1 | FileCheck %s -check-prefix=WITH_MISSING
 
-// NO_MISSING: warning: profile data may be out of date: of 3 functions, 1 has mismatched data that will be ignored
+// NO_MISSING: warning: profile data may be out of date: of 3 functions, 2 have mismatched data that will be ignored
 // NO_MISSING-NOT: 1 has no data
 
-// WITH_MISSING: warning: profile data may be out of date: of 3 functions, 1 has mismatched data that will be ignored
+// WITH_MISSING: warning: profile data may be out of date: of 3 functions, 2 have mismatched data that will be ignored
 // WITH_MISSING: warning: profile data may be incomplete: of 3 functions, 1 has no data
 
 void no_usable_data() {
   int i = 0;
 
   if (i) {}
 }
 
 void no_data() {
 }
 
 int main(int argc, const char *argv[]) {
   no_usable_data();
   return 0;
 }

test/Profile/objc-general.m

 // Test instrumentation of general constructs in objective C.
 
 // RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name objc-general.m %s -o - -emit-llvm -fblocks -fprofile-instrument=clang | FileCheck -check-prefix=PGOGEN %s
 
 // RUN: llvm-profdata merge %S/Inputs/objc-general.proftext -o %t.profdata
-// RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name objc-general.m %s -o - -emit-llvm -fblocks -fprofile-instrument-use-path=%t.profdata | FileCheck -check-prefix=PGOUSE %s
+// RUN: %clang_cc1 -triple x86_64-apple-macosx10.9 -main-file-name objc-general.m %s -o - -emit-llvm -fblocks -fprofile-instrument-use-path=%t.profdata 2>&1 | FileCheck -check-prefix=PGOUSE %s
+
+// PGOUSE-NOT: warning: profile data may be out of date
 
 #ifdef HAVE_FOUNDATION
 
 // Use this to build an instrumented version to regenerate the input file.
 #import <Foundation/Foundation.h>
 
 #else
 
^{ static int init = 0;
       // PGOUSE: br {{.*}} !prof ![[BL1:[0-9]+]]
        if (init)
          result = x;
        init = 1; }();
   }
 }
 @end
 
+void nested_objc_for_ranges(NSArray *arr) {
+  int x = 0;
+  for (id a in arr)
+    for (id b in arr)
+      ++x;
+}
+
+void consecutive_objc_for_ranges(NSArray *arr) {
+  int x = 0;
+  for (id a in arr) {}
+  for (id b in arr)
+    ++x;
+}
+
 // PGOUSE-DAG: ![[FR1]] = !{!"branch_weights", i32 2, i32 3}
 // PGOUSE-DAG: ![[FR2]] = !{!"branch_weights", i32 3, i32 2}
 // PGOUSE-DAG: ![[BL1]] = !{!"branch_weights", i32 2, i32 2}
 
 int main(int argc, const char *argv[]) {
   A *a = [[A alloc] init];
   NSArray *array = [NSArray arrayWithObjects: @"0", @"1", (void*)0];
   [A foreach: array];
   return 0;
 }

test/Profile/objcxx-hash-v2.mm

+// REQUIRES: shell
+
+// Check that all of the hashes in this file are unique (i.e, that none of the
+// profiles for these functions are mutually interchangeable).
+//
+// RUN: llvm-profdata show -all-functions %S/Inputs/objcxx-hash-v2.profdata.v5 | grep "Hash: 0x" | sort > %t.hashes
+// RUN: uniq %t.hashes > %t.hashes.unique
+// RUN: diff %t.hashes %t.hashes.unique
+
+// RUN: llvm-profdata merge %S/Inputs/objcxx-hash-v2.proftext -o %t.profdata
+// RUN: %clang_cc1 -std=c++11 -fexceptions -fcxx-exceptions -triple x86_64-apple-macosx10.9 -main-file-name objcxx-hash-v2.mm %s -o /dev/null -emit-llvm -fprofile-instrument-use-path=%t.profdata 2>&1 | FileCheck %s -allow-empty
+// RUN: %clang_cc1 -std=c++11 -fexceptions -fcxx-exceptions -triple x86_64-apple-macosx10.9 -main-file-name objcxx-hash-v2.mm %s -o /dev/null -emit-llvm -fprofile-instrument-use-path=%S/Inputs/objcxx-hash-v2.profdata.v5 2>&1 | FileCheck %s -allow-empty
+
+// CHECK-NOT: warning: profile data may be out of date
+
+int x;
+int arr[1] = {0};
+
+void loop_after_if_else() {
+  if (1)
+    x = 1;
+  else
+    x = 2;
+  while (0)
+    ++x;
+}
+
+void loop_in_then_block() {
+  if (1) {
+    while (0)
+      ++x;
+  } else {
+    x = 2;
+  }
+}
+
+void loop_in_else_block() {
+  if (1) {
+    x = 1;
+  } else {
+    while (0)
+      ++x;
+  }
+}
+
+void if_inside_of_for() {
+  for (x = 0; x < 0; ++x) {
+    x = 1;
+    if (1)
+      x = 2;
+  }
+}
+
+void if_outside_of_for() {
+  for (x = 0; x < 0; ++x)
+    x = 1;
+  if (1)
+    x = 2;
+}
+
+void if_inside_of_while() {
+  while (0) {
+    x = 1;
+    if (1)
+      x = 2;
+  }
+}
+
+void if_outside_of_while() {
+  while (0)
+    x = 1;
+  if (1)
+    x = 2;
+}
+
+void nested_dos() {
+  do {
+    do {
+      ++x;
+    } while (0);
+  } while (0);
+}
+
+void consecutive_dos() {
+  do {
+  } while (0);
+  do {
+    ++x;
+  } while (0);
+}
+
+void loop_empty() {
+  for (x = 0; x < 5; ++x) {}
+}
+
+void loop_return() {
+  for (x = 0; x < 5; ++x)
+    return;
+}
+
+void loop_continue() {
+  for (x = 0; x < 5; ++x)
+    continue;
+}
+
+void loop_break() {
+  for (x = 0; x < 5; ++x)
+    break;
+}
+
+void no_gotos() {
+  static void *dispatch[] = {&&done};
+  x = 0;
+done:
+  ++x;
+}
+
+void direct_goto() {
+  static void *dispatch[] = {&&done};
+  x = 0;
+  goto done;
+done:
+  ++x;
+}
+
+void indirect_goto() {
+  static void *dispatch[] = {&&done};
+  x = 0;
+  goto *dispatch[x];
+done:
+  ++x;
+}
+
+void nested_for_ranges() {
+  for (int a : arr)
+    for (int b : arr)
+      ++x;
+}
+
+void consecutive_for_ranges() {
+  for (int a : arr) {}
+  for (int b : arr)
+    ++x;
+}
+
+void nested_try_catch() {
+  try {
+    try {
+      ++x;
+    } catch (...) {}
+  } catch (...) {}
+}
+
+void consecutive_try_catch() {
+  try {} catch (...) {}
+  try {
+    ++x;
+  } catch (...) {}
+}
+
+void no_throw() {}
+
+void has_throw() {
+  throw 0;
+}
+
+int main() {
+  return 0;
+}