[InstrProf] Fix Windows cross compilation TODOs to fix failing tests

[rnk]

Summary

Coverage and profiling tests have been failing on Windows since r300279:
http://lab.llvm.org:8011/builders/clang-x86-windows-msvc2015/builds/4061

Pass the object format to the section name lookup functions rather than
the Module, since we can compute the object format from the object file.
Add a helper to ObjectFile that can get the object format in Triple
enum.

There is a complication around MachO, which is that sometimes we want
DATA,llvm_foo,regular,live_support and sometimes we just want
__llvm_foo. Typically llvm-cov wants the bare section name without the
segment and flags, because it's looking the section name up in an
executable. Currently I have a hack in the coverage reader to pretend
that MachO files have an unknown object file type to suppress the
segment prefix, but we can probably come up with a better API than that.

[davidxl]

Can you extract the getObjectFormat Triple interface into a separate patch?

vsk has a bigger cleanup plan (to expose sectionKind) for more interface unification. Perhaps we can wait for that patch (after getObjectFormat patch is in)?

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

655

Using 'unknown object' kind seems like a hack. What vsk had in mind is to restore addsegment parameter but with default to false.

[vsk]

I repackaged this patch a bit and checked it in as r300381.

clang/lib/CodeGen/CoverageMappingGen.cpp

struct CounterCoverageMappingBuilder
 
   void VisitLambdaExpr(const LambdaExpr *LE) {
     // Lambdas are treated as their own functions for now, so we shouldn't
     // propagate counts into them.
   }
 };
 
 std::string getCoverageSection(const CodeGenModule &CGM) {
-  return llvm::getInstrProfCoverageSectionName(&CGM.getModule());
+  return llvm::getInstrProfCoverageSectionName(
+      CGM.getContext().getTargetInfo().getTriple().getObjectFormat());
 }
 
 std::string normalizeFilename(StringRef Filename) {
   llvm::SmallString<256> Path(Filename);
   llvm::sys::fs::make_absolute(Path);
   llvm::sys::path::remove_dots(Path, /*remove_dot_dots=*/true);
   return Path.str().str();
 }

llvm/include/llvm/Object/ObjectFile.h

 // This file declares a file format independent ObjectFile class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_OBJECT_OBJECTFILE_H
 #define LLVM_OBJECT_OBJECTFILE_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Object/SymbolicFile.h"
 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <cstring>
 
public:
   ///        file format.
   virtual uint8_t getBytesInAddress() const = 0;
 
   virtual StringRef getFileFormatName() const = 0;
   virtual /* Triple::ArchType */ unsigned getArch() const = 0;
   virtual SubtargetFeatures getFeatures() const = 0;
   virtual void setARMSubArch(Triple &TheTriple) const { }
 
+  Triple::ObjectFormatType getTripleObjectFormat() const;
+
   /// Returns platform-specific object flags, if any.
   virtual std::error_code getPlatformFlags(unsigned &Result) const {
     Result = 0;
     return object_error::invalid_file_type;
   }
 
   virtual std::error_code
     getBuildAttributes(ARMAttributeParser &Attributes) const {

llvm/include/llvm/ProfileData/InstrProf.h

 
 #ifndef LLVM_PROFILEDATA_INSTRPROF_H
 #define LLVM_PROFILEDATA_INSTRPROF_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/ProfileSummary.h"
 #include "llvm/ProfileData/InstrProfData.inc"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"

 class InstrProfSymtab;
 class Instruction;
 class MDNode;
 class Module;
 
 /// Return the name of data section containing profile counter variables.
 /// If M is null, the target platform is assumed to be the same as
 /// the host machine, and the segment prefix will not be added.
-std::string getInstrProfCountersSectionName(const Module *M = nullptr);
+std::string getInstrProfCountersSectionName(Triple::ObjectFormatType OF);
 
 /// Return the name of data section containing names of instrumented
 /// functions. If M is null, the target platform is assumed to be the same as
 /// the host machine, nor will segment prefix be added.
-std::string getInstrProfNameSectionName(const Module *M = nullptr);
+std::string getInstrProfNameSectionName(Triple::ObjectFormatType OF);
 
 /// Return the name of the data section containing per-function control
 /// data. If M is null, the target platform is assumed to be the same as
 /// the host machine, and the segment prefix will not be added.
-std::string getInstrProfDataSectionName(const Module *M = nullptr);
+std::string getInstrProfDataSectionName(Triple::ObjectFormatType OF);
 
 /// Return the name of data section containing pointers to value profile
 /// counters/nodes. If M is null, the target platform is assumed to be
 /// the same as the host machine, and the segment prefix will not be added.
-std::string getInstrProfValuesSectionName(const Module *M = nullptr);
+std::string getInstrProfValuesSectionName(Triple::ObjectFormatType OF);
 
 /// Return the name of data section containing nodes holdling value
 /// profiling data. If M is null, the target platform is assumed to be
 /// the same as the host machine, and the segment prefix will not be added.
-std::string getInstrProfVNodesSectionName(const Module *M = nullptr);
+std::string getInstrProfVNodesSectionName(Triple::ObjectFormatType OF);
 
 /// Return the name profile runtime entry point to do value profiling
 /// for a given site.
 inline StringRef getInstrProfValueProfFuncName() {
   return INSTR_PROF_VALUE_PROF_FUNC_STR;
 }
 
 /// Return the name profile runtime entry point to do value range profiling.
 inline StringRef getInstrProfValueRangeProfFuncName() {
   return INSTR_PROF_VALUE_RANGE_PROF_FUNC_STR;
 }
 
 /// Return the name of the section containing function coverage mapping
 /// data.
-std::string getInstrProfCoverageSectionName(const Module *M = nullptr);
+std::string getInstrProfCoverageSectionName(Triple::ObjectFormatType OF);
 
 /// Return the name prefix of variables containing instrumented function names.
 inline StringRef getInstrProfNameVarPrefix() { return "__profn_"; }
 
 /// Return the name prefix of variables containing per-function control data.
 inline StringRef getInstrProfDataVarPrefix() { return "__profd_"; }
 
 /// Return the name prefix of profile counter variables.

llvm/include/llvm/Transforms/InstrProfiling.h

public:
   InstrProfiling(const InstrProfOptions &Options) : Options(Options) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
   bool run(Module &M, const TargetLibraryInfo &TLI);
 
 private:
   InstrProfOptions Options;
   Module *M;
+  Triple TT;
   const TargetLibraryInfo *TLI;
   struct PerFunctionProfileData {
     uint32_t NumValueSites[IPVK_Last + 1];
     GlobalVariable *RegionCounters = nullptr;
     GlobalVariable *DataVar = nullptr;
 
     PerFunctionProfileData() {
       memset(NumValueSites, 0, sizeof(uint32_t) * (IPVK_Last + 1));

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 static SectionKind
 getELFKindForNamedSection(StringRef Name, SectionKind K) {
   // N.B.: The defaults used in here are no the same ones used in MC.
   // We follow gcc, MC follows gas. For example, given ".section .eh_frame",
   // both gas and MC will produce a section with no flags. Given
   // section(".eh_frame") gcc will produce:
   //
   //   .section   .eh_frame,"a",@progbits
-  
-  // TODO: to support Win->ELF cross compilation with coverage properly,
-  // need to pass the module pointer to the following call.
-  if (Name == getInstrProfCoverageSectionName())
+  if (Name == getInstrProfCoverageSectionName(Triple::ELF))
     return SectionKind::getMetadata();
 
   if (Name.empty() || Name[0] != '.') return K;
 
   // Some lame default implementation based on some magic section names.
   if (Name == ".bss" ||
       Name.startswith(".bss.") ||
       Name.startswith(".gnu.linkonce.b.") ||

llvm/lib/Object/ObjectFile.cpp

 //===- ObjectFile.cpp - File format independent object file -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a file format independent ObjectFile class.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
uint64_t ObjectFile::getSymbolValue(DataRefImpl Ref) const {
   uint32_t Flags = getSymbolFlags(Ref);
   if (Flags & SymbolRef::SF_Undefined)
     return 0;
   if (Flags & SymbolRef::SF_Common)
     return getCommonSymbolSize(Ref);
   return getSymbolValueImpl(Ref);
 }
 
+Triple::ObjectFormatType ObjectFile::getTripleObjectFormat() const {
+  if (isCOFF())
+    return Triple::COFF;
+  if (isMachO())
+    return Triple::MachO;
+  if (isELF())
+    return Triple::ELF;
+  return Triple::UnknownObjectFormat;
+}
+
 std::error_code ObjectFile::printSymbolName(raw_ostream &OS,
                                             DataRefImpl Symb) const {
   Expected<StringRef> Name = getSymbolName(Symb);
   if (!Name)
     return errorToErrorCode(Name.takeError());
   OS << *Name;
   return std::error_code();
 }

llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp

if (auto *Universal = dyn_cast<MachOUniversalBinary>(Bin.get())) {
     // We can only handle object files.
     return make_error<CoverageMapError>(coveragemap_error::malformed);
 
   // The coverage uses native pointer sizes for the object it's written in.
   BytesInAddress = OF->getBytesInAddress();
   Endian = OF->isLittleEndian() ? support::endianness::little
                                 : support::endianness::big;
 
-  // Look for the sections that we are interested in.
-  // TODO: with the current getInstrProfXXXSectionName interfaces, the
-  // the coverage reader host tool is limited to read coverage section on
-  // binaries with compatible profile section naming scheme as the host
-  // platform. Currently, COFF format binaries have different section
-  // naming scheme from the all the rest.
-  auto NamesSection = lookupSection(*OF, getInstrProfNameSectionName());
+  // Look for the sections that we are interested in.  We want the section name
+  // without the MachO segment, so use the "unknown" object file type to get the
+  // unprefixed, unsuffixed section name.
+  auto ObjFormat = OF->getTripleObjectFormat();
+  if (ObjFormat == Triple::MachO)
+    ObjFormat = Triple::UnknownObjectFormat;
+  auto NamesSection =
+      lookupSection(*OF, getInstrProfNameSectionName(ObjFormat));
   if (auto E = NamesSection.takeError())
     return E;
-  auto CoverageSection = lookupSection(*OF, getInstrProfCoverageSectionName());
+  auto CoverageSection =
+      lookupSection(*OF, getInstrProfCoverageSectionName(ObjFormat));
   if (auto E = CoverageSection.takeError())
     return E;
 
   // Get the contents of the given sections.
   if (auto EC = CoverageSection->getContents(CoverageMapping))
     return errorCodeToError(EC);
   if (Error E = ProfileNames.create(*NamesSection))
     return E;

llvm/lib/ProfileData/InstrProf.cpp

 
 const char *InstrProfSectNamePrefix[] = {
 #define INSTR_PROF_SECT_ENTRY(Kind, SectName, SectNameCommon, SectNameCoff,    \
                               Prefix)                                          \
   Prefix,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
-std::string getInstrProfSectionName(const Module *M, InstrProfSectKind Kind) {
-
-  if (!M)
-    return InstrProfSectName[Kind];
-
-  bool AddSegment = Triple(M->getTargetTriple()).isOSBinFormatMachO();
+std::string getInstrProfSectionName(Triple::ObjectFormatType OF,
+                                    InstrProfSectKind Kind) {
   std::string SectName;
-  if (Triple(M->getTargetTriple()).isOSBinFormatCOFF())
+  if (OF == Triple::COFF)
     SectName = InstrProfSectNameCoff[Kind];
   else
     SectName = InstrProfSectNameCommon[Kind];
 
-  if (AddSegment) {
+  if (OF == Triple::MachO) {
     SectName = InstrProfSectNamePrefix[Kind] + SectName;
     if (Kind == IPSK_data) {
       SectName += ",regular,live_support";
     }
   }
   return SectName;
 }
 
 } // namespace
 
 namespace llvm {
 
-std::string getInstrProfCountersSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_cnts);
+std::string getInstrProfCountersSectionName(Triple::ObjectFormatType OF) {
+  return getInstrProfSectionName(OF, IPSK_cnts);
 }
 
-std::string getInstrProfNameSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_name);
+std::string getInstrProfNameSectionName(Triple::ObjectFormatType OF) {
+  return getInstrProfSectionName(OF, IPSK_name);
 }
 
-std::string getInstrProfDataSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_data);
+std::string getInstrProfDataSectionName(Triple::ObjectFormatType OF) {
+  return getInstrProfSectionName(OF, IPSK_data);
 }
 
-std::string getInstrProfValuesSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_vals);
+std::string getInstrProfValuesSectionName(Triple::ObjectFormatType OF) {
+  return getInstrProfSectionName(OF, IPSK_vals);
 }
 
-std::string getInstrProfVNodesSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_vnodes);
+std::string getInstrProfVNodesSectionName(Triple::ObjectFormatType OF) {
+  return getInstrProfSectionName(OF, IPSK_vnodes);
 }
 
-std::string getInstrProfCoverageSectionName(const Module *M) {
-  return getInstrProfSectionName(M, IPSK_covmap);
+std::string getInstrProfCoverageSectionName(Triple::ObjectFormatType OF) {
+  return getInstrProfSectionName(OF, IPSK_covmap);
 }
 
 void SoftInstrProfErrors::addError(instrprof_error IE) {
   if (IE == instrprof_error::success)
     return;
 
   if (FirstError == instrprof_error::success)
     FirstError = IE;

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

INITIALIZE_PASS_END(
     "Frontend instrumentation-based coverage lowering.", false, false)
 
 ModulePass *
 llvm::createInstrProfilingLegacyPass(const InstrProfOptions &Options) {
   return new InstrProfilingLegacyPass(Options);
 }
 
 bool InstrProfiling::isMachO() const {
-  return Triple(M->getTargetTriple()).isOSBinFormatMachO();
+  return TT.isOSBinFormatMachO();
 }
 
 /// Get the section name for the counter variables.
 std::string InstrProfiling::getCountersSection() const {
-  return getInstrProfCountersSectionName(M);
+  return getInstrProfCountersSectionName(TT.getObjectFormat());
 }
 
 /// Get the section name for the name variables.
 std::string InstrProfiling::getNameSection() const {
-  return getInstrProfNameSectionName(M);
+  return getInstrProfNameSectionName(TT.getObjectFormat());
 }
 
 /// Get the section name for the profile data variables.
 std::string InstrProfiling::getDataSection() const {
-  return getInstrProfDataSectionName(M);
+  return getInstrProfDataSectionName(TT.getObjectFormat());
 }
 
 /// Get the section name for the coverage mapping data.
 std::string InstrProfiling::getCoverageSection() const {
-  return getInstrProfCoverageSectionName(M);
+  return getInstrProfCoverageSectionName(TT.getObjectFormat());
 }
 
 static InstrProfIncrementInst *castToIncrementInst(Instruction *Instr) {
   InstrProfIncrementInst *Inc = dyn_cast<InstrProfIncrementInstStep>(Instr);
   if (Inc)
     return Inc;
   return dyn_cast<InstrProfIncrementInst>(Instr);
 }
 
 bool InstrProfiling::run(Module &M, const TargetLibraryInfo &TLI) {
   bool MadeChange = false;
 
   this->M = &M;
   this->TLI = &TLI;
   NamesVar = nullptr;
   NamesSize = 0;
   ProfileDataMap.clear();
   UsedVars.clear();
   getMemOPSizeRangeFromOption(MemOPSizeRange, MemOPSizeRangeStart,
                               MemOPSizeRangeLast);
+  TT = Triple(M.getTargetTriple());
 
   // We did not know how many value sites there would be inside
   // the instrumented function. This is counting the number of instrumented
   // target value sites to enter it as field in the profile data variable.
   for (Function &F : M) {
     InstrProfIncrementInst *FirstProfIncInst = nullptr;
     for (BasicBlock &BB : F)
       for (auto I = BB.begin(), E = BB.end(); I != E; I++)
if (ValueProfileStaticAlloc && !needsRuntimeRegistrationOfSectionRange(*M)) {
     if (NS) {
       ArrayType *ValuesTy = ArrayType::get(Type::getInt64Ty(Ctx), NS);
 
       auto *ValuesVar =
           new GlobalVariable(*M, ValuesTy, false, NamePtr->getLinkage(),
                              Constant::getNullValue(ValuesTy),
                              getVarName(Inc, getInstrProfValuesVarPrefix()));
       ValuesVar->setVisibility(NamePtr->getVisibility());
-      ValuesVar->setSection(getInstrProfValuesSectionName(M));
+      ValuesVar->setSection(
+          getInstrProfValuesSectionName(TT.getObjectFormat()));
       ValuesVar->setAlignment(8);
       ValuesVar->setComdat(ProfileVarsComdat);
       ValuesPtrExpr =
           ConstantExpr::getBitCast(ValuesVar, Type::getInt8PtrTy(Ctx));
     }
   }
 
   // Create data variable.

 #include "llvm/ProfileData/InstrProfData.inc"
   };
   auto *VNodeTy = StructType::get(Ctx, makeArrayRef(VNodeTypes));
 
   ArrayType *VNodesTy = ArrayType::get(VNodeTy, NumCounters);
   auto *VNodesVar = new GlobalVariable(
       *M, VNodesTy, false, GlobalValue::PrivateLinkage,
       Constant::getNullValue(VNodesTy), getInstrProfVNodesVarName());
-  VNodesVar->setSection(getInstrProfVNodesSectionName(M));
+  VNodesVar->setSection(getInstrProfVNodesSectionName(TT.getObjectFormat()));
   UsedVars.push_back(VNodesVar);
 }
 
 void InstrProfiling::emitNameData() {
   std::string UncompressedData;
 
   if (ReferencedNames.empty())
     return;
void InstrProfiling::emitInitialization() {
 
   if (!InstrProfileOutput.empty()) {
     // Create variable for profile name.
     Constant *ProfileNameConst =
         ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
     GlobalVariable *ProfileNameVar = new GlobalVariable(
         *M, ProfileNameConst->getType(), true, GlobalValue::WeakAnyLinkage,
         ProfileNameConst, INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR));
-    Triple TT(M->getTargetTriple());
     if (TT.supportsCOMDAT()) {
       ProfileNameVar->setLinkage(GlobalValue::ExternalLinkage);
       ProfileNameVar->setComdat(M->getOrInsertComdat(
           StringRef(INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR))));
     }
   }
 
   Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());

llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp

 static bool shouldInstrumentReadWriteFromAddress(const Module *M, Value *Addr) {
   // Peel off GEPs and BitCasts.
   Addr = Addr->stripInBoundsOffsets();
 
   if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Addr)) {
     if (GV->hasSection()) {
       StringRef SectionName = GV->getSection();
       // Check if the global is in the PGO counters section.
-      if (SectionName.endswith(getInstrProfCountersSectionName(M)))
+      auto OF = Triple(M->getTargetTriple()).getObjectFormat();
+      if (SectionName.endswith(getInstrProfCountersSectionName(OF)))
         return false;
     }
 
     // Check if the global is private gcov data.
     if (GV->getName().startswith("__llvm_gcov") ||
         GV->getName().startswith("__llvm_gcda"))
       return false;
   }

llvm/tools/llvm-cov/TestingSupport.cpp

int convertForTestingMain(int argc, const char *argv[]) {
   ObjectFile *OF = ObjErr.get().getBinary();
   auto BytesInAddress = OF->getBytesInAddress();
   if (BytesInAddress != 8) {
     errs() << "error: 64 bit binary expected\n";
     return 1;
   }
 
   // Look for the sections that we are interested in.
+  auto ObjFormat = OF->getTripleObjectFormat();
   int FoundSectionCount = 0;
   SectionRef ProfileNames, CoverageMapping;
   for (const auto &Section : OF->sections()) {
     StringRef Name;
     if (Section.getName(Name))
       return 1;
-    // TODO: with the current getInstrProfXXXSectionName interfaces, the
-    // the  host tool is limited to read coverage section on
-    // binaries with compatible profile section naming scheme as the host
-    // platform. Currently, COFF format binaries have different section
-    // naming scheme from the all the rest.
-    if (Name == llvm::getInstrProfNameSectionName()) {
+    if (Name == llvm::getInstrProfNameSectionName(ObjFormat)) {
       ProfileNames = Section;
-    } else if (Name == llvm::getInstrProfCoverageSectionName()) {
+    } else if (Name == llvm::getInstrProfCoverageSectionName(ObjFormat)) {
       CoverageMapping = Section;
     } else
       continue;
     ++FoundSectionCount;
   }
   if (FoundSectionCount != 2)
     return 1;