[IRGen] Fix lowering of int_instrprof_increment

Update our usage of llvm's coverage API and fix the way we lower
instrprof_increment intrinsics.

This keeps us up-to-date with llvm/stable and makes instrumented IR
easier to read.

Author: vedantk

lib/IRGen/GenCoverage.cpp

@@ -29,25 +29,22 @@
 using namespace swift;
 using namespace irgen;
 
+using llvm::coverage::CovMapVersion;
 using llvm::coverage::CounterMappingRegion;
 
-// This is disabled for some reason.
-#define DISABLE_COVERAGE_MAPPING
-
-#ifndef DISABLE_COVERAGE_MAPPING
 static bool isMachO(IRGenModule &IGM) {
   return SwiftTargetInfo::get(IGM).OutputObjectFormat == llvm::Triple::MachO;
 }
 
 static StringRef getCoverageSection(IRGenModule &IGM) {
   return llvm::getInstrProfCoverageSectionName(isMachO(IGM));
 }
-#endif
+
+static StringRef getProfNamesSection(IRGenModule &IGM) {
+  return llvm::getInstrProfNameSectionName(isMachO(IGM));
+}
 
 void IRGenModule::emitCoverageMapping() {
-#ifdef DISABLE_COVERAGE_MAPPING
-  return;
-#else
   const auto &Mappings = SILMod->getCoverageMapList();
   // If there aren't any coverage maps, there's nothing to emit.
   if (Mappings.empty())
@@ -71,21 +68,20 @@ void IRGenModule::emitCoverageMapping() {
   }
 
   // Encode the filenames first.
-  std::string EncodedDataBuf;
-  llvm::raw_string_ostream OS(EncodedDataBuf);
+  std::string FilenamesAndCoverageMappings;
+  llvm::raw_string_ostream OS(FilenamesAndCoverageMappings);
   llvm::coverage::CoverageFilenamesSectionWriter(FilenameRefs).write(OS);
   size_t FilenamesSize = OS.str().size();
   size_t CurrentSize, PrevSize = FilenamesSize;
 
   // Now we need to build up the list of function records.
   llvm::LLVMContext &Ctx = LLVMContext;
   auto *Int32Ty = llvm::Type::getInt32Ty(Ctx);
-  auto *Int64Ty = llvm::Type::getInt64Ty(Ctx);
-  auto *Int8PtrTy = llvm::Type::getInt8PtrTy(Ctx);
 
-#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) LLVMType,
   llvm::Type *FunctionRecordTypes[] = {
+#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) LLVMType,
 #include "llvm/ProfileData/InstrProfData.inc"
+#undef COVMAP_FUNC_RECORD
   };
 
   auto FunctionRecordTy =
@@ -107,19 +103,31 @@ void IRGenModule::emitCoverageMapping() {
                                             Regions);
     W.write(OS);
 
-    auto *NameVal = llvm::ConstantDataArray::getString(Ctx, M.getName(), false);
-    auto *NameVar = new llvm::GlobalVariable(
-        *getModule(), NameVal->getType(), true,
-        llvm::GlobalValue::LinkOnceAnyLinkage, NameVal,
-        llvm::getInstrProfNameVarPrefix() + M.getName());
+    std::string NameValue = llvm::getPGOFuncName(
+        M.getName(), llvm::GlobalValue::LinkOnceAnyLinkage, M.getFile());
+    llvm::GlobalVariable *NamePtr = llvm::createPGOFuncNameVar(
+        *getModule(), llvm::GlobalValue::LinkOnceAnyLinkage, NameValue);
+
+    // The instr-profiling pass in llvm typically sets the function name ptr's
+    // section. We do it here because (1) SIL's int_instrprof_increment does not
+    // use this exact GlobalVariable, so llvm misses it and (2) we shouldn't
+    // expose all name ptrs to llvm via the getCoverageUnusedNamesVarName() API.
+    NamePtr->setSection(getProfNamesSection(*this));
+    NamePtr->setAlignment(1);
 
     CurrentSize = OS.str().size();
+    unsigned MappingLen = CurrentSize - PrevSize;
+    StringRef CoverageMapping(OS.str().c_str() + PrevSize, MappingLen);
+
+    uint64_t FuncHash = M.getHash();
+
     // Create a record for this function.
     llvm::Constant *FunctionRecordVals[] = {
-        llvm::ConstantExpr::getBitCast(NameVar, Int8PtrTy),
-        llvm::ConstantInt::get(Int32Ty, M.getName().size()),
-        llvm::ConstantInt::get(Int32Ty, CurrentSize - PrevSize),
-        llvm::ConstantInt::get(Int64Ty, M.getHash())};
+#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Init,
+#include "llvm/ProfileData/InstrProfData.inc"
+#undef COVMAP_FUNC_RECORD
+    };
+
     FunctionRecords.push_back(llvm::ConstantStruct::get(
         FunctionRecordTy, makeArrayRef(FunctionRecordVals)));
     PrevSize = CurrentSize;
@@ -133,32 +141,43 @@ void IRGenModule::emitCoverageMapping() {
     for (size_t I = 0, S = 8 - Rem; I < S; ++I)
       OS << '\0';
   }
-  auto *EncodedData =
+  auto *FilenamesAndMappingsVal =
       llvm::ConstantDataArray::getString(Ctx, OS.str(), false);
 
   auto *RecordsTy =
       llvm::ArrayType::get(FunctionRecordTy, FunctionRecords.size());
   auto *RecordsVal = llvm::ConstantArray::get(RecordsTy, FunctionRecords);
 
-  // Now we embed everything into a constant with a well-known name.
-  auto *CovDataTy =
-      llvm::StructType::get(Ctx, {Int32Ty, Int32Ty, Int32Ty, Int32Ty, RecordsTy,
-                                  EncodedData->getType()});
-  llvm::Constant *TUDataVals[] = {
-      llvm::ConstantInt::get(Int32Ty, FunctionRecords.size()),
-      llvm::ConstantInt::get(Int32Ty, FilenamesSize),
-      llvm::ConstantInt::get(Int32Ty, CoverageMappingSize),
-      llvm::ConstantInt::get(Int32Ty, llvm::coverage::CoverageMappingVersion1),
-      RecordsVal,
-      EncodedData};
-  auto CovDataVal =
+  // Create the coverage data header.
+  llvm::Type *CovDataHeaderTypes[] = {
+#define COVMAP_HEADER(Type, LLVMType, Name, Init) LLVMType,
+#include "llvm/ProfileData/InstrProfData.inc"
+#undef COVMAP_HEADER
+  };
+  auto *CovDataHeaderTy =
+      llvm::StructType::get(Ctx, makeArrayRef(CovDataHeaderTypes));
+  llvm::Constant *CovDataHeaderVals[] = {
+#define COVMAP_HEADER(Type, LLVMType, Name, Init) Init,
+#include "llvm/ProfileData/InstrProfData.inc"
+#undef COVMAP_HEADER
+  };
+  auto *CovDataHeaderVal = llvm::ConstantStruct::get(
+      CovDataHeaderTy, makeArrayRef(CovDataHeaderVals));
+
+  // Combine the header, function records, and mappings together.
+  llvm::Type *CovDataTypes[] = {CovDataHeaderTy, RecordsTy,
+                                FilenamesAndMappingsVal->getType()};
+  auto *CovDataTy = llvm::StructType::get(Ctx, makeArrayRef(CovDataTypes));
+  llvm::Constant *TUDataVals[] = {CovDataHeaderVal, RecordsVal,
+                                  FilenamesAndMappingsVal};
+  auto *CovDataVal =
       llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals));
+
   auto CovData = new llvm::GlobalVariable(
       *getModule(), CovDataTy, true, llvm::GlobalValue::InternalLinkage,
       CovDataVal, llvm::getCoverageMappingVarName());
   CovData->setSection(getCoverageSection(*this));
   CovData->setAlignment(8);
 
   addUsedGlobal(CovData);
-#endif
 }

lib/IRGen/GenFunc.cpp

@@ -85,11 +85,13 @@
 #include "clang/AST/RecordLayout.h"
 #include "clang/CodeGen/CodeGenABITypes.h"
 #include "clang/CodeGen/ModuleBuilder.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/CallSite.h"
+#include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/ADT/StringSwitch.h"
 
@@ -1725,6 +1727,36 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, Identifier FnId,
   // If this is an LLVM IR intrinsic, lower it to an intrinsic call.
   const IntrinsicInfo &IInfo = IGF.IGM.SILMod->getIntrinsicInfo(FnId);
   llvm::Intrinsic::ID IID = IInfo.ID;
+
+  // Calls to the int_instrprof_increment intrinsic are emitted during SILGen.
+  // At that stage, the function name GV used by the profiling pass is hidden.
+  // Fix the intrinsic call here by pointing it to the correct GV.
+  if (IID == llvm::Intrinsic::instrprof_increment) {
+    // Extract the function name.
+    auto *NameGEP = cast<llvm::User>(args.claimNext());
+    auto *NameGV = cast<llvm::GlobalVariable>(NameGEP->getOperand(0));
+    auto *NameC = NameGV->getInitializer();
+    StringRef Name = cast<llvm::ConstantDataArray>(NameC)->getRawDataValues();
+
+    // Find the existing function name pointer.
+    std::string NameValue = llvm::getInstrProfNameVarPrefix();
+    NameValue += Name;
+    StringRef ProfName = StringRef(NameValue).rtrim(StringRef("\0", 1));
+    auto *FuncNamePtr = IGF.IGM.Module.getNamedGlobal(ProfName);
+    assert(FuncNamePtr && "No function name pointer for counter update");
+
+    // Create a GEP into the function name.
+    llvm::SmallVector<llvm::Value *, 2> Indices(2, NameGEP->getOperand(1));
+    auto *FuncName = llvm::GetElementPtrInst::CreateInBounds(
+        FuncNamePtr, makeArrayRef(Indices), "", IGF.Builder.GetInsertBlock());
+
+    // Replace the placeholder value with the new GEP.
+    Explosion replacement;
+    replacement.add(FuncName);
+    replacement.add(args.claimAll());
+    args = std::move(replacement);
+  }
+
   if (IID != llvm::Intrinsic::not_intrinsic) {
     SmallVector<llvm::Type*, 4> ArgTys;
     for (auto T : IInfo.Types)

lib/SILGen/SILGenProfiling.cpp

@@ -673,14 +673,12 @@ void SILGenProfiling::emitCounterIncrement(SILGenBuilder &Builder,ASTNode Node){
 
   SILLocation Loc = getLocation(Node);
   SILValue Args[] = {
-      // TODO: In C++ we give this string linkage that matches the functions, so
-      // that it's uniqued appropriately across TUs.
+      // The intrinsic must refer to the function profiling name var, which is
+      // inaccessible during SILGen. Rely on irgen to rewrite the function name.
       Builder.createStringLiteral(Loc, StringRef(CurrentFuncName),
                                   StringLiteralInst::Encoding::UTF8),
       Builder.createIntegerLiteral(Loc, Int64Ty, FunctionHash),
       Builder.createIntegerLiteral(Loc, Int32Ty, NumRegionCounters),
-      // TODO: Should we take care to emit only one copy of each of the above
-      // three literals per function?
       Builder.createIntegerLiteral(Loc, Int32Ty, CounterIt->second)};
   Builder.createBuiltin(Loc, C.getIdentifier("int_instrprof_increment"),
                         SGM.Types.getEmptyTupleType(), {}, Args);