[Profiler] Fix up a couple uses of emitProfilerIncrement

Remove a case where we know we don't have a
profiler, and avoid incrementing for a distributed
factory method. Otherwise such cases could pass
a null ASTNode, which will become an assertion
failure in a future commit.

While we're here, let's standardize on emitting
the profiler increment for function entry after
the prolog, as if there's e.g an unreachable
parameter, the increment can be safely elided
anyway.

Author: hamishknight

lib/SILGen/SILGenConstructor.cpp

@@ -695,8 +695,6 @@ void SILGenFunction::emitClassConstructorAllocator(ConstructorDecl *ctor) {
   SILValue initedSelfValue = emitApplyWithRethrow(Loc, initVal.forward(*this),
                                                   initTy, subMap, args);
 
-  emitProfilerIncrement(ctor->getTypecheckedBody());
-
   // Return the initialized 'self'.
   B.createReturn(ImplicitReturnLocation(Loc), initedSelfValue);
 }

lib/SILGen/SILGenFunction.cpp

@@ -537,7 +537,6 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
   MagicFunctionName = SILGenModule::getMagicFunctionName(fd);
 
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(SILDeclRef(fd));
-  emitProfilerIncrement(fd->getTypecheckedBody());
   emitProlog(captureInfo, fd->getParameters(), fd->getImplicitSelfDecl(), fd,
              fd->getResultInterfaceType(), fd->hasThrows(), fd->getThrowsLoc());
 
@@ -547,7 +546,9 @@ void SILGenFunction::emitFunction(FuncDecl *fd) {
   } else {
     prepareEpilog(fd->getResultInterfaceType(),
                   fd->hasThrows(), CleanupLocation(fd));
-    
+
+    emitProfilerIncrement(fd->getTypecheckedBody());
+
     // Emit the actual function body as usual
     emitStmt(fd->getTypecheckedBody());
 
@@ -564,12 +565,12 @@ void SILGenFunction::emitClosure(AbstractClosureExpr *ace) {
   auto resultIfaceTy = ace->getResultType()->mapTypeOutOfContext();
   auto captureInfo = SGM.M.Types.getLoweredLocalCaptures(
     SILDeclRef(ace));
-  emitProfilerIncrement(ace);
   emitProlog(captureInfo, ace->getParameters(), /*selfParam=*/nullptr,
              ace, resultIfaceTy, ace->isBodyThrowing(), ace->getLoc(),
              SGM.M.Types.getConstantAbstractionPattern(SILDeclRef(ace)));
   prepareEpilog(resultIfaceTy, ace->isBodyThrowing(), CleanupLocation(ace));
 
+  emitProfilerIncrement(ace);
   if (auto *ce = dyn_cast<ClosureExpr>(ace)) {
     emitStmt(ce->getBody());
   } else {
@@ -1170,6 +1171,11 @@ void SILGenFunction::emitProfilerIncrement(ASTNode N) {
   assert(CounterIt != RegionCounterMap.end() &&
          "cannot increment non-existent counter");
 
+  // If we're at an unreachable point, the increment can be elided as the
+  // counter cannot be incremented.
+  if (!B.hasValidInsertionPoint())
+    return;
+
   B.createIncrementProfilerCounter(
       getLocation(N), CounterIt->second, SP->getPGOFuncName(),
       SP->getNumRegionCounters(), SP->getPGOFuncHash());

test/Profiler/coverage_closure_returns_never.swift

@@ -1,8 +1,10 @@
 // RUN: %target-swift-frontend -Xllvm -sil-full-demangle -profile-generate -profile-coverage-mapping -emit-sil -module-name coverage_closure_returns_never %s | %FileCheck %s
 
+// We don't need to emit the increment_profiler_counter, as the function is
+// uncallable.
 // CHECK-LABEL: closure #1 (Swift.Never) -> Swift.Never in coverage_closure_returns_never.closure_with_fatal_error(Swift.Array<Swift.Never>) -> ()
-// CHECK: increment_profiler_counter 0
-// CHECK-NEXT: [[LOAD:%.*]] = load {{.*}} : $*Never
+// CHECK-NOT:  increment_profiler_counter
+// CHECK:      [[LOAD:%.*]] = load {{.*}} : $*Never
 // CHECK-NEXT: debug_value [[LOAD]] : $Never
 // CHECK-NEXT: unreachable
 

test/Profiler/coverage_non_constructible_enum.swift

@@ -2,9 +2,11 @@
 
 // Reduced from Carthage (https://github.com/Carthage/Carthage).
 enum NoError: Error, Equatable {
+// We don't need to emit the increment_profiler_counter, as the function is
+// uncallable.
 // CHECK-LABEL: static coverage_non_constructible_enum.NoError.== infix
-// CHECK: increment_profiler_counter
-// CHECK: unreachable
+// CHECK-NOT:   increment_profiler_counter
+// CHECK:       unreachable
 
 // CHECK-LABEL: sil_coverage_map {{.*}} static coverage_non_constructible_enum.NoError.== infix
 // CHECK-NEXT: [[@LINE+1]]:54 -> [[@LINE+3]]:4 : 0