[CodeGen] emit CG profile for COFF object file

[zequanwu]

Summary

I forgot to add emission of CG profile for COFF object file, when adding the support(https://reviews.llvm.org/D81775)

[zequanwu]

test case.

[rnk]

lgtm!

I see the assembler support is already there, looks like it works.

[rnk]

llvm/lib/Target/TargetLoweringObjectFile.cpp

164

I had to revert this change in rG90242caca2074dab5a9b76e5bc36d9fafd2179a7. I think the fix might be to return null if the call graph edge target is marked dllimport here.

[zequanwu]

llvm/lib/Target/TargetLoweringObjectFile.cpp

164

I was thinking about a discussion in https://reviews.llvm.org/D81775?id=270540#inline-751699, which might be the cause. I was trying to do the same as ELF. Not sure if that's the cause.

[zequanwu]

Update. Don't emit CGProfileEntry if function has dll import storage class.

[rnk]

lgtm

llvm/lib/Target/TargetLoweringObjectFile.cpp

165

Thanks! You can see the diff here if you are curious:
https://reviews.llvm.org/D87811?vs=292846&id=293899#toc

[zequanwu]

For symbols haven't seen, just set them to external not weak external.

Previously I did it that way, because http://llvm.org/docs/Extensions.html#sht-llvm-call-graph-profile-section-call-graph-profile says

If either symbol is undefined, then that symbol is defined as if .weak symbol has been written at the end of the file.

[zequanwu]

llvm/lib/MC/MCWinCOFFStreamer.cpp

344

It's meaningless to set symbol to WeakExternal and External at same time here. At the end, the symbol just become WeakExternal.

[rnk]

Can you remove the weak external marking in a separate change from relanding? It changes existing functionality of the .cg_profile directive, so it can be committed independently, which is nice for making changes as small and independent as possible.

[zequanwu]

Split changes on .cg_profile to another patch D88456.

[probinson]

Can we have a separate NFC refactor commit, to move that lump of code into its own emitCGProfile method? It might make the functional bits easier to follow. Also we have a private change in that area, and the ping-pong for this change has been a real headache.

[zequanwu]

Will put the refactor part to a separate NFC commit.
Reland this as fix at D88456 seems work. (https://bugs.chromium.org/p/chromium/issues/detail?id=1130780#c18)

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 
 class TargetLoweringObjectFileELF : public TargetLoweringObjectFile {
   bool UseInitArray = false;
   mutable unsigned NextUniqueID = 1;  // ID 0 is reserved for execute-only sections
 
 protected:
   MCSymbolRefExpr::VariantKind PLTRelativeVariantKind =
       MCSymbolRefExpr::VK_None;
-  const TargetMachine *TM = nullptr;
 
 public:
   TargetLoweringObjectFileELF() = default;
   ~TargetLoweringObjectFileELF() override = default;
 
   void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
   /// Emit Obj-C garbage collection and linker options.

llvm/include/llvm/Target/TargetLoweringObjectFile.h

protected:
   unsigned CallSiteEncoding = 0;
 
   /// This section contains the static constructor pointer list.
   MCSection *StaticCtorSection = nullptr;
 
   /// This section contains the static destructor pointer list.
   MCSection *StaticDtorSection = nullptr;
 
+  const TargetMachine *TM = nullptr;
+
 public:
   TargetLoweringObjectFile() = default;
   TargetLoweringObjectFile(const TargetLoweringObjectFile &) = delete;
   TargetLoweringObjectFile &
   operator=(const TargetLoweringObjectFile &) = delete;
   virtual ~TargetLoweringObjectFile();
 
   Mangler &getMangler() const { return *Mang; }
 
   /// This method must be called before any actual lowering is done.  This
   /// specifies the current context for codegen, and gives the lowering
   /// implementations a chance to set up their default sections.
   virtual void Initialize(MCContext &ctx, const TargetMachine &TM);
 
   virtual void emitPersonalityValue(MCStreamer &Streamer, const DataLayout &TM,
                                     const MCSymbol *Sym) const;
 
   /// Emit the module-level metadata that the platform cares about.
   virtual void emitModuleMetadata(MCStreamer &Streamer, Module &M) const {}
 
+  /// Emit Call Graph Profile metadata.
+  virtual void emitCGProfile(MCStreamer &Streamer, Module &M) const;
+
   /// Get the module-level metadata that the platform cares about.
   virtual void getModuleMetadata(Module &M) {}
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   virtual MCSection *getSectionForConstant(const DataLayout &DL,
                                            SectionKind Kind, const Constant *C,
                                            Align &Alignment) const;

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 
 //===----------------------------------------------------------------------===//
 //                                  ELF
 //===----------------------------------------------------------------------===//
 
 void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx,
                                              const TargetMachine &TgtM) {
   TargetLoweringObjectFile::Initialize(Ctx, TgtM);
-  TM = &TgtM;
 
   CodeModel::Model CM = TgtM.getCodeModel();
   InitializeELF(TgtM.Options.UseInitArray);
 
   switch (TgtM.getTargetTriple().getArch()) {
   case Triple::arm:
   case Triple::armeb:
   case Triple::thumb:
if (!Section.empty()) {
     auto *S = C.getELFSection(Section, ELF::SHT_PROGBITS, ELF::SHF_ALLOC);
     Streamer.SwitchSection(S);
     Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
     Streamer.emitInt32(Version);
     Streamer.emitInt32(Flags);
     Streamer.AddBlankLine();
   }
 
-  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
-  M.getModuleFlagsMetadata(ModuleFlags);
-
-  MDNode *CFGProfile = nullptr;
-
-  for (const auto &MFE : ModuleFlags) {
-    StringRef Key = MFE.Key->getString();
-    if (Key == "CG Profile") {
-      CFGProfile = cast<MDNode>(MFE.Val);
-      break;
-    }
-  }
-
-  if (!CFGProfile)
-    return;
-
-  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
-    if (!MDO)
-      return nullptr;
-    auto V = cast<ValueAsMetadata>(MDO);
-    const Function *F = cast<Function>(V->getValue());
-    return TM->getSymbol(F);
-  };
-
-  for (const auto &Edge : CFGProfile->operands()) {
-    MDNode *E = cast<MDNode>(Edge);
-    const MCSymbol *From = GetSym(E->getOperand(0));
-    const MCSymbol *To = GetSym(E->getOperand(1));
-    // Skip null functions. This can happen if functions are dead stripped after
-    // the CGProfile pass has been run.
-    if (!From || !To)
-      continue;
-    uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
-                         ->getValue()
-                         ->getUniqueInteger()
-                         .getZExtValue();
-    Streamer.emitCGProfileEntry(
-        MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C),
-        MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count);
-  }
+  emitCGProfile(Streamer, M);
 }
 
 MCSymbol *TargetLoweringObjectFileELF::getCFIPersonalitySymbol(
     const GlobalValue *GV, const TargetMachine &TM,
     MachineModuleInfo *MMI) const {
   unsigned Encoding = getPersonalityEncoding();
   if ((Encoding & 0x80) == DW_EH_PE_indirect)
     return getContext().getOrCreateSymbol(StringRef("DW.ref.") +
void TargetLoweringObjectFileCOFF::emitModuleMetadata(MCStreamer &Streamer,
                                                       Module &M) const {
   emitLinkerDirectives(Streamer, M);
 
   unsigned Version = 0;
   unsigned Flags = 0;
   StringRef Section;
 
   GetObjCImageInfo(M, Version, Flags, Section);
-  if (Section.empty())
-    return;
-
+  if (!Section.empty()) {
     auto &C = getContext();
-  auto *S = C.getCOFFSection(
-      Section, COFF::IMAGE_SCN_CNT_INITIALIZED_DATA | COFF::IMAGE_SCN_MEM_READ,
+    auto *S = C.getCOFFSection(Section,
+                               COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
+                                   COFF::IMAGE_SCN_MEM_READ,
                                SectionKind::getReadOnly());
     Streamer.SwitchSection(S);
     Streamer.emitLabel(C.getOrCreateSymbol(StringRef("OBJC_IMAGE_INFO")));
     Streamer.emitInt32(Version);
     Streamer.emitInt32(Flags);
     Streamer.AddBlankLine();
   }
 
+  emitCGProfile(Streamer, M);
+}
+
 void TargetLoweringObjectFileCOFF::emitLinkerDirectives(
     MCStreamer &Streamer, Module &M) const {
   if (NamedMDNode *LinkerOptions = M.getNamedMetadata("llvm.linker.options")) {
     // Emit the linker options to the linker .drectve section.  According to the
     // spec, this section is a space-separated string containing flags for
     // linker.
     MCSection *Sec = getDrectveSection();
     Streamer.SwitchSection(Sec);

llvm/lib/MC/MCWinCOFFStreamer.cpp

if (!From->getSymbol().isTemporary() && !To->getSymbol().isTemporary())
     getAssembler().CGProfile.push_back({From, To, Count});
 }
 
 void MCWinCOFFStreamer::finalizeCGProfileEntry(const MCSymbolRefExpr *&SRE) {
   const MCSymbol *S = &SRE->getSymbol();
   bool Created;
   getAssembler().registerSymbol(*S, &Created);
   if (Created) {
-    cast<MCSymbolCOFF>(S)->setIsWeakExternal();
     cast<MCSymbolCOFF>(S)->setExternal(true);
   }
 }
 
 void MCWinCOFFStreamer::finalizeCGProfile() {
   for (MCAssembler::CGProfileEntry &E : getAssembler().CGProfile) {
     finalizeCGProfileEntry(E.From);
     finalizeCGProfileEntry(E.To);
   }

llvm/lib/Target/TargetLoweringObjectFile.cpp

void TargetLoweringObjectFile::Initialize(MCContext &ctx,
   delete Mang;
   Mang = new Mangler();
   InitMCObjectFileInfo(TM.getTargetTriple(), TM.isPositionIndependent(), ctx,
                        TM.getCodeModel() == CodeModel::Large);
 
   // Reset various EH DWARF encodings.
   PersonalityEncoding = LSDAEncoding = TTypeEncoding = dwarf::DW_EH_PE_absptr;
   CallSiteEncoding = dwarf::DW_EH_PE_uleb128;
+
+  this->TM = &TM;
 }
 
 TargetLoweringObjectFile::~TargetLoweringObjectFile() {
   delete Mang;
 }
 
 static bool isNullOrUndef(const Constant *C) {
   // Check that the constant isn't all zeros or undefs.
MCSymbol *TargetLoweringObjectFile::getCFIPersonalitySymbol(
   return TM.getSymbol(GV);
 }
 
 void TargetLoweringObjectFile::emitPersonalityValue(MCStreamer &Streamer,
                                                     const DataLayout &,
                                                     const MCSymbol *Sym) const {
 }
 
+void TargetLoweringObjectFile::emitCGProfile(MCStreamer &Streamer,
+                                             Module &M) const {
+  MCContext &C = getContext();
+  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
+  M.getModuleFlagsMetadata(ModuleFlags);
+
+  MDNode *CFGProfile = nullptr;
+
+  for (const auto &MFE : ModuleFlags) {
+    StringRef Key = MFE.Key->getString();
+    if (Key == "CG Profile") {
+      CFGProfile = cast<MDNode>(MFE.Val);
+      break;
+    }
+  }
+
+  if (!CFGProfile)
+    return;
+
+  auto GetSym = [this](const MDOperand &MDO) -> MCSymbol * {
+    if (!MDO)
+      return nullptr;
+    auto *V = cast<ValueAsMetadata>(MDO);
+    const Function *F = cast<Function>(V->getValue());
+    if (F->hasDLLImportStorageClass())
+      return nullptr;
+    return TM->getSymbol(F);
+  };
+
+  for (const auto &Edge : CFGProfile->operands()) {
+    MDNode *E = cast<MDNode>(Edge);
+    const MCSymbol *From = GetSym(E->getOperand(0));
+    const MCSymbol *To = GetSym(E->getOperand(1));
+    // Skip null functions. This can happen if functions are dead stripped after
+    // the CGProfile pass has been run.
+    if (!From || !To)
+      continue;
+    uint64_t Count = cast<ConstantAsMetadata>(E->getOperand(2))
+                         ->getValue()
+                         ->getUniqueInteger()
+                         .getZExtValue();
+    Streamer.emitCGProfileEntry(
+        MCSymbolRefExpr::create(From, MCSymbolRefExpr::VK_None, C),
+        MCSymbolRefExpr::create(To, MCSymbolRefExpr::VK_None, C), Count);
+  }
+}
 
 /// getKindForGlobal - This is a top-level target-independent classifier for
 /// a global object.  Given a global variable and information from the TM, this
 /// function classifies the global in a target independent manner. This function
 /// may be overridden by the target implementation.
 SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO,
                                                        const TargetMachine &TM){
   assert(!GO->isDeclarationForLinker() &&

llvm/test/MC/COFF/cgprofile.ll

+; RUN: llc -filetype=asm %s -o - -mtriple x86_64-pc-windows-msvc | FileCheck %s
+; RUN: llc -filetype=obj %s -o %t -mtriple x86_64-pc-windows-msvc
+; RUN: llvm-readobj --cg-profile %t | FileCheck %s --check-prefix=OBJ
+
+declare void @b()
+
+define void @a() {
+  call void @b()
+  ret void
+}
+
+define void @freq(i1 %cond) {
+  br i1 %cond, label %A, label %B
+A:
+  call void @a();
+  ret void
+B:
+  call void @b();
+  ret void
+}
+
+!llvm.module.flags = !{!0}
+
+!0 = !{i32 5, !"CG Profile", !1}
+!1 = !{!2, !3, !4, !5}
+!2 = !{void ()* @a, void ()* @b, i64 32}
+!3 = !{void (i1)* @freq, void ()* @a, i64 11}
+!4 = !{void (i1)* @freq, void ()* @b, i64 20}
+!5 = !{void (i1)* @freq, null, i64 20}
+
+; CHECK: .cg_profile a, b, 32
+; CHECK: .cg_profile freq, a, 11
+; CHECK: .cg_profile freq, b, 20
+
+; OBJ: CGProfile [
+; OBJ:  CGProfileEntry {
+; OBJ:    From: a
+; OBJ:    To: b
+; OBJ:    Weight: 32
+; OBJ:  }
+; OBJ:  CGProfileEntry {
+; OBJ:    From: freq
+; OBJ:    To: a
+; OBJ:    Weight: 11
+; OBJ:  }
+; OBJ:  CGProfileEntry {
+; OBJ:    From: freq
+; OBJ:    To: b
+; OBJ:    Weight: 20
+; OBJ:  }
+; OBJ:]

llvm/test/MC/COFF/cgprofile.s

 # CHECK-NEXT: RelocationCount:
 # CHECK-NEXT: LineNumberCount:
 # CHECK-NEXT: Characteristics [ (0x100800)
 # CHECK-NEXT:   IMAGE_SCN_ALIGN_1BYTES (0x100000)
 # CHECK-NEXT:   IMAGE_SCN_LNK_REMOVE (0x800)
 # CHECK-NEXT: ]
 # CHECK-NEXT: SectionData (
 # CHECK-NEXT:   0000: 0A000000 0E000000 20000000 00000000
-# CHECK-NEXT:   0010: 11000000 0A000000 0B000000 00000000
+# CHECK-NEXT:   0010: 0F000000 0A000000 0B000000 00000000
 # CHECK-NEXT:   0020: 0B000000 0C000000 14000000 00000000
 # CHECK-NEXT: )
 
 # CHECK: Symbols [
 # CHECK:      Name: a
 # CHECK-NEXT: Value:
 # CHECK-NEXT: Section: .test
 # CHECK-NEXT: BaseType:

 # CHECK-NEXT: ComplexType:
 # CHECK-NEXT: StorageClass: Static
 # CHECK-NEXT: AuxSymbolCount:
 # CHECK:      Name: b
 # CHECK-NEXT: Value:
 # CHECK-NEXT: Section: IMAGE_SYM_UNDEFINED
 # CHECK-NEXT: BaseType:
 # CHECK-NEXT: ComplexType:
-# CHECK-NEXT: StorageClass: WeakExternal
-# CHECK-NEXT: AuxSymbolCount: 1
-# CHECK-NEXT: AuxWeakExternal {
-# CHECK-NEXT:   Linked: .weak.b.default.late
-# CHECK-NEXT:   Search: Alias
-# CHECK-NEXT: }
-# CHECK:      Name: .weak.b.default.late
-# CHECK-NEXT: Value:
-# CHECK-NEXT: Section: IMAGE_SYM_ABSOLUTE
-# CHECK-NEXT: BaseType:
-# CHECK-NEXT: ComplexType:
 # CHECK-NEXT: StorageClass: External
-# CHECK-NEXT: AuxSymbolCount: 0
+# CHECK-NEXT: AuxSymbolCount:
 # CHECK:      Name: freq
 # CHECK-NEXT: Value:
 # CHECK-NEXT: Section: IMAGE_SYM_UNDEFINED
 # CHECK-NEXT: BaseType:
 # CHECK-NEXT: ComplexType:
-# CHECK-NEXT: StorageClass: WeakExternal
-# CHECK-NEXT: AuxSymbolCount: 1
-# CHECK-NEXT: AuxWeakExternal {
-# CHECK-NEXT:   Linked: .weak.freq.default.late
-# CHECK-NEXT:   Search: Alias
-# CHECK-NEXT: }
-# CHECK:      Name: .weak.freq.default.late
-# CHECK-NEXT: Value:
-# CHECK-NEXT: Section: IMAGE_SYM_ABSOLUTE
-# CHECK-NEXT: BaseType:
-# CHECK-NEXT: ComplexType:
 # CHECK-NEXT: StorageClass: External
-# CHECK-NEXT: AuxSymbolCount: 0
+# CHECK-NEXT: AuxSymbolCount:
 
 # CHECK:      CGProfile [
 # CHECK-NEXT:   CGProfileEntry {
 # CHECK-NEXT:     From: a
 # CHECK-NEXT:     To: b
 # CHECK-NEXT:     Weight: 32
 # CHECK-NEXT:   }
 # CHECK-NEXT:   CGProfileEntry {