Object: Move attribute calculation into RecordStreamer. NFC

[vitalybuka]

Summary

Preparation for D44274

[• espindola]

llvm/include/llvm/MC/MCStreamer.h

530 ↗

(On Diff #137658)

I think we have to keep an emit method for this. See https://reviews.llvm.org/D44283.

I am sorry for the current state that symver handling is at. It is basically an 7 year old hack that never got cleaned up.

[vitalybuka]

rebase on D44283

[• espindola]

llvm/lib/Object/RecordStreamer.cpp

24 ↗

(On Diff #137685)

Starting the name with Get suggests this return the name. Maybe RecordMangledName?

33 ↗

(On Diff #137685)

While you are here, could you add Ifuncs? Probably the best way is to just use global_values().

llvm/lib/Object/RecordStreamer.h

71 ↗

(On Diff #137685)

Start new functions with a lowercase letter.

[vitalybuka]

addressing comments and rebase

[vitalybuka]

clang-format

[• rafael]

LGTM

Vitaly Buka via Phabricator via llvm-commits
<[e-mail]> writes:

vitalybuka updated this revision to Diff 137808.
vitalybuka added a comment.

clang-format

https://reviews.llvm.org/D44276

Files:

llvm/lib/Object/ModuleSymbolTable.cpp
llvm/lib/Object/RecordStreamer.cpp
llvm/lib/Object/RecordStreamer.h

Index: llvm/lib/Object/RecordStreamer.h

• llvm/lib/Object/RecordStreamer.h

+++ llvm/lib/Object/RecordStreamer.h
@@ -20,25 +20,35 @@

namespace llvm {

+class GlobalValue;
+class Module;
+
class RecordStreamer : public MCStreamer {
public:

enum State { NeverSeen, Global, Defined, DefinedGlobal, DefinedWeak, Used,
             UndefinedWeak};

private:
+ const Module &M;

StringMap<State> Symbols;
// Map of aliases created by .symver directives, saved so we can update
// their symbol binding after parsing complete. This maps from each
// aliasee to its list of aliases.
DenseMap<const MCSymbol *, std::vector<MCSymbol *>> SymverAliasMap;

+ Mapping from mangled name to GV.
+ StringMap<const GlobalValue *> MangledNameMap;
+
+ / Get the state recorded for the given symbol.
+ State getSymbolState(const MCSymbol *Sym);
+

void markDefined(const MCSymbol &Symbol);
void markGlobal(const MCSymbol &Symbol, MCSymbolAttr Attribute);
void markUsed(const MCSymbol &Symbol);
void visitUsedSymbol(const MCSymbol &Sym) override;

public:

• RecordStreamer(MCContext &Context);

+ RecordStreamer(MCContext &Context, const Module &M);

using const_iterator = StringMap<State>::const_iterator;

@@ -56,18 +66,9 @@

/// Record .symver aliases for later processing.
void emitELFSymverDirective(StringRef AliasName,
                            const MCSymbol *Aliasee) override;

• /// Return the map of .symver aliasee to associated aliases.
• DenseMap<const MCSymbol *, std::vector<MCSymbol *>> &symverAliases() {
• return SymverAliasMap;
• } -
• /// Get the state recorded for the given symbol.
• State getSymbolState(const MCSymbol *Sym) {
• auto SI = Symbols.find(Sym->getName());
• if (SI == Symbols.end())
• return NeverSeen;
• return SI->second;
• }

+ Ensure ELF .symver aliases get the same binding as the defined symbol
+ they alias with.
+ void emitSymverAttributes();
};

} // end namespace llvm

Index: llvm/lib/Object/RecordStreamer.cpp

• llvm/lib/Object/RecordStreamer.cpp

+++ llvm/lib/Object/RecordStreamer.cpp
@@ -8,11 +8,29 @@
===----------------------------------------------------------------------===

#include "RecordStreamer.h"
+#include "llvm/IR/Mangler.h"
+#include "llvm/IR/Module.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCSymbol.h"

using namespace llvm;

+static void initMangledNameMap(const Module &M,
+ StringMap<const GlobalValue *> &MangledNameMap) {
+ The name in the assembler will be mangled, but the name in the IR
+ might not, so we first compute a mapping from mangled name to GV.
+ Mangler Mang;
+ SmallString<64> MangledName;
+ for (const GlobalValue &GV : M.global_values()) {
+ if (!GV.hasName())
+ continue;
+ MangledName.clear();
+ MangledName.reserve(GV.getName().size() + 1);
+ Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
+ MangledNameMap[MangledName] = &GV;
+ }
+}
+
void RecordStreamer::markDefined(const MCSymbol &Symbol) {

State &S = Symbols[Symbol.getName()];
switch (S) {

@@ -71,7 +89,10 @@

void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }

-RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
+RecordStreamer::RecordStreamer(MCContext &Context, const Module &M)
+ : MCStreamer(Context), M(M) {
+ initMangledNameMap(M, MangledNameMap);
+}

RecordStreamer::const_iterator RecordStreamer::begin() {

return Symbols.begin();

@@ -113,10 +134,66 @@

markDefined(*Symbol);

}

+RecordStreamer::State RecordStreamer::getSymbolState(const MCSymbol *Sym) {
+ auto SI = Symbols.find(Sym->getName());
+ if (SI == Symbols.end())
+ return NeverSeen;
+ return SI->second;
+}
+
void RecordStreamer::emitELFSymverDirective(StringRef AliasName,

                                          const MCSymbol *Aliasee) {
MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);

+ TODO: Handle "@@@". Depending on SymbolAttribute value it needs to be
+ converted into @ or @@.

const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
EmitAssignment(Alias, Value);
SymverAliasMap[Aliasee].push_back(Alias);

}
+
+void RecordStreamer::emitSymverAttributes() {
+ Walk all the recorded .symver aliases, and set up the binding
+ for each alias.
+ for (auto &Symver : SymverAliasMap) {
+ const MCSymbol *Aliasee = Symver.first;
+ MCSymbolAttr Attr = MCSA_Invalid;
+
+ First check if the aliasee binding was recorded in the asm.
+ switch (getSymbolState(Aliasee)) {
+ case RecordStreamer::Global:
+ case RecordStreamer::DefinedGlobal:
+ Attr = MCSA_Global;
+ break;
+ case RecordStreamer::UndefinedWeak:
+ case RecordStreamer::DefinedWeak:
+ Attr = MCSA_Weak;
+ break;
+ default:
+ break;
+ }
+
+ If we don't have a symbol attribute from assembly, then check if
+ the aliasee was defined in the IR.
+ if (Attr == MCSA_Invalid) {
+ const auto *GV = M.getNamedValue(Aliasee->getName());
+ if (!GV) {
+ auto MI = MangledNameMap.find(Aliasee->getName());
+ if (MI != MangledNameMap.end())
+ GV = MI->second;
+ else
+ continue;
+ }
+ if (GV->hasExternalLinkage())
+ Attr = MCSA_Global;
+ else if (GV->hasLocalLinkage())
+ Attr = MCSA_Local;
+ else if (GV->isWeakForLinker())
+ Attr = MCSA_Weak;
+ }
+ if (Attr == MCSA_Invalid)
+ continue;
+ Set the detected binding on each alias with this aliasee.
+ for (auto &Alias : Symver.second)
+ EmitSymbolAttribute(Alias, Attr);
+ }
+}

Index: llvm/lib/Object/ModuleSymbolTable.cpp

• llvm/lib/Object/ModuleSymbolTable.cpp

+++ llvm/lib/Object/ModuleSymbolTable.cpp
@@ -24,7 +24,6 @@
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
@@ -69,81 +68,6 @@

});

}

- Ensure ELF .symver aliases get the same binding as the defined symbol
- they alias with.
-static void handleSymverAliases(const Module &M, RecordStreamer &Streamer) {

• if (Streamer.symverAliases().empty())
• return; -
• // The name in the assembler will be mangled, but the name in the IR
• // might not, so we first compute a mapping from mangled name to GV.
• Mangler Mang;
• SmallString<64> MangledName;
• StringMap<const GlobalValue *> MangledNameMap;
• auto GetMangledName = [&](const GlobalValue &GV) {
• if (!GV.hasName())
• return; -
• MangledName.clear();
• MangledName.reserve(GV.getName().size() + 1);
• Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
• MangledNameMap[MangledName] = &GV;
• };
• for (const Function &F : M)
• GetMangledName(F);
• for (const GlobalVariable &GV : M.globals())
• GetMangledName(GV);
• for (const GlobalAlias &GA : M.aliases())
• GetMangledName(GA); -
• // Walk all the recorded .symver aliases, and set up the binding
• // for each alias.
• for (auto &Symver : Streamer.symverAliases()) {
• const MCSymbol *Aliasee = Symver.first;
• MCSymbolAttr Attr = MCSA_Invalid; -
• // First check if the aliasee binding was recorded in the asm.
• RecordStreamer::State state = Streamer.getSymbolState(Aliasee);
• switch (state) {
• case RecordStreamer::Global:
• case RecordStreamer::DefinedGlobal:
• Attr = MCSA_Global;
• break;
• case RecordStreamer::UndefinedWeak:
• case RecordStreamer::DefinedWeak:
• Attr = MCSA_Weak;
• break;
• default:
• break;
• } -
• // If we don't have a symbol attribute from assembly, then check if
• // the aliasee was defined in the IR.
• if (Attr == MCSA_Invalid) {
• const auto *GV = M.getNamedValue(Aliasee->getName());
• if (!GV) {
• auto MI = MangledNameMap.find(Aliasee->getName());
• if (MI != MangledNameMap.end())
• GV = MI->second;
• else
• continue;
• }
• if (GV->hasExternalLinkage())
• Attr = MCSA_Global;
• else if (GV->hasLocalLinkage())
• Attr = MCSA_Local;
• else if (GV->isWeakForLinker())
• Attr = MCSA_Weak;
• }
• if (Attr == MCSA_Invalid)
• continue; -
• // Set the detected binding on each alias with this aliasee.
• for (auto &Alias : Symver.second)
• Streamer.EmitSymbolAttribute(Alias, Attr);
• }

-}

• void ModuleSymbolTable::CollectAsmSymbols( const Module &M, function_ref<void(StringRef, BasicSymbolRef::Flags)> AsmSymbol) {

@@ -176,7 +100,7 @@

MCObjectFileInfo MOFI;
MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
MOFI.InitMCObjectFileInfo(TT, /*PIC*/ false, MCCtx);

• RecordStreamer Streamer(MCCtx);

+ RecordStreamer Streamer(MCCtx, M);

T->createNullTargetStreamer(Streamer);
 
std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));

@@ -195,7 +119,7 @@

if (Parser->Run(false))
  return;

• handleSymverAliases(M, Streamer);

+ Streamer.emitSymverAttributes();

for (auto &KV : Streamer) {
  StringRef Key = KV.first();

---

llvm-commits mailing list
[e-mail]
http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits

[• espindola]

Do you have commit access?

[vitalybuka]

yes, I can commit
but I need to update the patch again.
after Peters comments about deferred processing I don't need MangledName as member

[vitalybuka]

Remove RecordStreamer::MangledNameMap

[• rafael]

LGTM

Vitaly Buka via Phabricator <[e-mail]> writes:

vitalybuka updated this revision to Diff 137854.
vitalybuka added a comment.
This revision is now accepted and ready to land.

Remove RecordStreamer::MangledNameMap

https://reviews.llvm.org/D44276

Files:

llvm/lib/Object/ModuleSymbolTable.cpp
llvm/lib/Object/RecordStreamer.cpp
llvm/lib/Object/RecordStreamer.h

Index: llvm/lib/Object/RecordStreamer.h

• llvm/lib/Object/RecordStreamer.h

+++ llvm/lib/Object/RecordStreamer.h
@@ -20,25 +20,32 @@

namespace llvm {

+class GlobalValue;
+class Module;
+
class RecordStreamer : public MCStreamer {
public:

enum State { NeverSeen, Global, Defined, DefinedGlobal, DefinedWeak, Used,
             UndefinedWeak};

private:
+ const Module &M;

StringMap<State> Symbols;
// Map of aliases created by .symver directives, saved so we can update
// their symbol binding after parsing complete. This maps from each
// aliasee to its list of aliases.

• DenseMap<const MCSymbol *, std::vector<MCSymbol *>> SymverAliasMap;

+ DenseMap<const MCSymbol *, std::vector<StringRef>> SymverAliasMap;
+
+ /// Get the state recorded for the given symbol.
+ State getSymbolState(const MCSymbol *Sym);

void markDefined(const MCSymbol &Symbol);
void markGlobal(const MCSymbol &Symbol, MCSymbolAttr Attribute);
void markUsed(const MCSymbol &Symbol);
void visitUsedSymbol(const MCSymbol &Sym) override;

public:

• RecordStreamer(MCContext &Context);

+ RecordStreamer(MCContext &Context, const Module &M);

using const_iterator = StringMap<State>::const_iterator;

@@ -56,18 +63,9 @@

/// Record .symver aliases for later processing.
void emitELFSymverDirective(StringRef AliasName,
                            const MCSymbol *Aliasee) override;

• /// Return the map of .symver aliasee to associated aliases.
• DenseMap<const MCSymbol *, std::vector<MCSymbol *>> &symverAliases() {
• return SymverAliasMap;
• } -
• /// Get the state recorded for the given symbol.
• State getSymbolState(const MCSymbol *Sym) {
• auto SI = Symbols.find(Sym->getName());
• if (SI == Symbols.end())
• return NeverSeen;
• return SI->second;
• }

+ Emit ELF .symver aliases and ensure they have the same binding as the
+ defined symbol they alias with.
+ void flushSymverDirectives();
};

} // end namespace llvm

Index: llvm/lib/Object/RecordStreamer.cpp

• llvm/lib/Object/RecordStreamer.cpp

+++ llvm/lib/Object/RecordStreamer.cpp
@@ -8,6 +8,8 @@
===----------------------------------------------------------------------===

#include "RecordStreamer.h"
+#include "llvm/IR/Mangler.h"
+#include "llvm/IR/Module.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCSymbol.h"

@@ -71,7 +73,8 @@

void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }

-RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
+RecordStreamer::RecordStreamer(MCContext &Context, const Module &M)
+ : MCStreamer(Context), M(M) {}

RecordStreamer::const_iterator RecordStreamer::begin() {

return Symbols.begin();

@@ -113,10 +116,82 @@

markDefined(*Symbol);

}

+RecordStreamer::State RecordStreamer::getSymbolState(const MCSymbol *Sym) {
+ auto SI = Symbols.find(Sym->getName());
+ if (SI == Symbols.end())
+ return NeverSeen;
+ return SI->second;
+}
+
void RecordStreamer::emitELFSymverDirective(StringRef AliasName,

const MCSymbol *Aliasee) {

• MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
• const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
• EmitAssignment(Alias, Value);
• SymverAliasMap[Aliasee].push_back(Alias);

+ SymverAliasMap[Aliasee].push_back(AliasName);
+}
+
+void RecordStreamer::flushSymverDirectives() {
+ Mapping from mangled name to GV.
+ StringMap<const GlobalValue *> MangledNameMap;
+ The name in the assembler will be mangled, but the name in the IR
+ might not, so we first compute a mapping from mangled name to GV.
+ Mangler Mang;
+ SmallString<64> MangledName;
+ for (const GlobalValue &GV : M.global_values()) {
+ if (!GV.hasName())
+ continue;
+ MangledName.clear();
+ MangledName.reserve(GV.getName().size() + 1);
+ Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
+ MangledNameMap[MangledName] = &GV;
+ }
+
+ Walk all the recorded .symver aliases, and set up the binding
+ for each alias.
+ for (auto &Symver : SymverAliasMap) {
+ const MCSymbol *Aliasee = Symver.first;
+ MCSymbolAttr Attr = MCSA_Invalid;
+
+ First check if the aliasee binding was recorded in the asm.
+ RecordStreamer::State state = getSymbolState(Aliasee);
+ switch (state) {
+ case RecordStreamer::Global:
+ case RecordStreamer::DefinedGlobal:
+ Attr = MCSA_Global;
+ break;
+ case RecordStreamer::UndefinedWeak:
+ case RecordStreamer::DefinedWeak:
+ Attr = MCSA_Weak;
+ break;
+ default:
+ break;
+ }
+
+ If we don't have a symbol attribute from assembly, then check if
+ the aliasee was defined in the IR.
+ if (Attr == MCSA_Invalid) {
+ const auto *GV = M.getNamedValue(Aliasee->getName());
+ if (!GV) {
+ auto MI = MangledNameMap.find(Aliasee->getName());
+ if (MI != MangledNameMap.end())
+ GV = MI->second;
+ }
+ if (GV) {
+ if (GV->hasExternalLinkage())
+ Attr = MCSA_Global;
+ else if (GV->hasLocalLinkage())
+ Attr = MCSA_Local;
+ else if (GV->isWeakForLinker())
+ Attr = MCSA_Weak;
+ }
+ }
+ Set the detected binding on each alias with this aliasee.
+ for (auto AliasName : Symver.second) {
+ MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
+ TODO: Handle "@@@". Depending on SymbolAttribute value it needs to be
+ // converted into @ or @@.
+ const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
+ EmitAssignment(Alias, Value);
+ if (Attr != MCSA_Invalid)
+ EmitSymbolAttribute(Alias, Attr);
+ }
+ }
}

Index: llvm/lib/Object/ModuleSymbolTable.cpp

• llvm/lib/Object/ModuleSymbolTable.cpp

+++ llvm/lib/Object/ModuleSymbolTable.cpp
@@ -24,7 +24,6 @@
#include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/Mangler.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
@@ -69,81 +68,6 @@

});

}

- Ensure ELF .symver aliases get the same binding as the defined symbol
- they alias with.
-static void handleSymverAliases(const Module &M, RecordStreamer &Streamer) {

• if (Streamer.symverAliases().empty())
• return; -
• // The name in the assembler will be mangled, but the name in the IR
• // might not, so we first compute a mapping from mangled name to GV.
• Mangler Mang;
• SmallString<64> MangledName;
• StringMap<const GlobalValue *> MangledNameMap;
• auto GetMangledName = [&](const GlobalValue &GV) {
• if (!GV.hasName())
• return; -
• MangledName.clear();
• MangledName.reserve(GV.getName().size() + 1);
• Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
• MangledNameMap[MangledName] = &GV;
• };
• for (const Function &F : M)
• GetMangledName(F);
• for (const GlobalVariable &GV : M.globals())
• GetMangledName(GV);
• for (const GlobalAlias &GA : M.aliases())
• GetMangledName(GA); -
• // Walk all the recorded .symver aliases, and set up the binding
• // for each alias.
• for (auto &Symver : Streamer.symverAliases()) {
• const MCSymbol *Aliasee = Symver.first;
• MCSymbolAttr Attr = MCSA_Invalid; -
• // First check if the aliasee binding was recorded in the asm.
• RecordStreamer::State state = Streamer.getSymbolState(Aliasee);
• switch (state) {
• case RecordStreamer::Global:
• case RecordStreamer::DefinedGlobal:
• Attr = MCSA_Global;
• break;
• case RecordStreamer::UndefinedWeak:
• case RecordStreamer::DefinedWeak:
• Attr = MCSA_Weak;
• break;
• default:
• break;
• } -
• // If we don't have a symbol attribute from assembly, then check if
• // the aliasee was defined in the IR.
• if (Attr == MCSA_Invalid) {
• const auto *GV = M.getNamedValue(Aliasee->getName());
• if (!GV) {
• auto MI = MangledNameMap.find(Aliasee->getName());
• if (MI != MangledNameMap.end())
• GV = MI->second;
• else
• continue;
• }
• if (GV->hasExternalLinkage())
• Attr = MCSA_Global;
• else if (GV->hasLocalLinkage())
• Attr = MCSA_Local;
• else if (GV->isWeakForLinker())
• Attr = MCSA_Weak;
• }
• if (Attr == MCSA_Invalid)
• continue; -
• // Set the detected binding on each alias with this aliasee.
• for (auto &Alias : Symver.second)
• Streamer.EmitSymbolAttribute(Alias, Attr);
• }

-}

• void ModuleSymbolTable::CollectAsmSymbols( const Module &M, function_ref<void(StringRef, BasicSymbolRef::Flags)> AsmSymbol) {

@@ -176,7 +100,7 @@

MCObjectFileInfo MOFI;
MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
MOFI.InitMCObjectFileInfo(TT, /*PIC*/ false, MCCtx);

• RecordStreamer Streamer(MCCtx);

+ RecordStreamer Streamer(MCCtx, M);

T->createNullTargetStreamer(Streamer);
 
std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));

@@ -195,7 +119,7 @@

if (Parser->Run(false))
  return;

• handleSymverAliases(M, Streamer);

+ Streamer.flushSymverDirectives();

for (auto &KV : Streamer) {
  StringRef Key = KV.first();

[vitalybuka]

rebase

llvm/trunk/lib/Object/ModuleSymbolTable.cpp

 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/Mangler.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCParser/MCAsmParser.h"
 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
void ModuleSymbolTable::addModule(Module *M) {
   for (GlobalValue &GV : M->global_values())
     SymTab.push_back(&GV);
 
   CollectAsmSymbols(*M, [this](StringRef Name, BasicSymbolRef::Flags Flags) {
     SymTab.push_back(new (AsmSymbols.Allocate()) AsmSymbol(Name, Flags));
   });
 }
 
-// Ensure ELF .symver aliases get the same binding as the defined symbol
-// they alias with.
-static void handleSymverAliases(const Module &M, RecordStreamer &Streamer) {
-  if (Streamer.symverAliases().empty())
-    return;
-
-  // The name in the assembler will be mangled, but the name in the IR
-  // might not, so we first compute a mapping from mangled name to GV.
-  Mangler Mang;
-  SmallString<64> MangledName;
-  StringMap<const GlobalValue *> MangledNameMap;
-  auto GetMangledName = [&](const GlobalValue &GV) {
-    if (!GV.hasName())
-      return;
-
-    MangledName.clear();
-    MangledName.reserve(GV.getName().size() + 1);
-    Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
-    MangledNameMap[MangledName] = &GV;
-  };
-  for (const Function &F : M)
-    GetMangledName(F);
-  for (const GlobalVariable &GV : M.globals())
-    GetMangledName(GV);
-  for (const GlobalAlias &GA : M.aliases())
-    GetMangledName(GA);
-
-  // Walk all the recorded .symver aliases, and set up the binding
-  // for each alias.
-  for (auto &Symver : Streamer.symverAliases()) {
-    const MCSymbol *Aliasee = Symver.first;
-    MCSymbolAttr Attr = MCSA_Invalid;
-
-    // First check if the aliasee binding was recorded in the asm.
-    RecordStreamer::State state = Streamer.getSymbolState(Aliasee);
-    switch (state) {
-    case RecordStreamer::Global:
-    case RecordStreamer::DefinedGlobal:
-      Attr = MCSA_Global;
-      break;
-    case RecordStreamer::UndefinedWeak:
-    case RecordStreamer::DefinedWeak:
-      Attr = MCSA_Weak;
-      break;
-    default:
-      break;
-    }
-
-    // If we don't have a symbol attribute from assembly, then check if
-    // the aliasee was defined in the IR.
-    if (Attr == MCSA_Invalid) {
-      const auto *GV = M.getNamedValue(Aliasee->getName());
-      if (!GV) {
-        auto MI = MangledNameMap.find(Aliasee->getName());
-        if (MI != MangledNameMap.end())
-          GV = MI->second;
-        else
-          continue;
-      }
-      if (GV->hasExternalLinkage())
-        Attr = MCSA_Global;
-      else if (GV->hasLocalLinkage())
-        Attr = MCSA_Local;
-      else if (GV->isWeakForLinker())
-        Attr = MCSA_Weak;
-    }
-    if (Attr == MCSA_Invalid)
-      continue;
-
-    // Set the detected binding on each alias with this aliasee.
-    for (auto &Alias : Symver.second)
-      Streamer.EmitSymbolAttribute(Alias, Attr);
-  }
-}
-
 void ModuleSymbolTable::CollectAsmSymbols(
     const Module &M,
     function_ref<void(StringRef, BasicSymbolRef::Flags)> AsmSymbol) {
   StringRef InlineAsm = M.getModuleInlineAsm();
   if (InlineAsm.empty())
     return;
 
   std::string Err;
void ModuleSymbolTable::CollectAsmSymbols(
 
   std::unique_ptr<MCInstrInfo> MCII(T->createMCInstrInfo());
   if (!MCII)
     return;
 
   MCObjectFileInfo MOFI;
   MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
   MOFI.InitMCObjectFileInfo(TT, /*PIC*/ false, MCCtx);
-  RecordStreamer Streamer(MCCtx);
+  RecordStreamer Streamer(MCCtx, M);
   T->createNullTargetStreamer(Streamer);
 
   std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));
   SourceMgr SrcMgr;
   SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
   std::unique_ptr<MCAsmParser> Parser(
       createMCAsmParser(SrcMgr, MCCtx, Streamer, *MAI));
 
   MCTargetOptions MCOptions;
   std::unique_ptr<MCTargetAsmParser> TAP(
       T->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
   if (!TAP)
     return;
 
   Parser->setTargetParser(*TAP);
   if (Parser->Run(false))
     return;
 
-  handleSymverAliases(M, Streamer);
+  Streamer.flushSymverDirectives();
 
   for (auto &KV : Streamer) {
     StringRef Key = KV.first();
     RecordStreamer::State Value = KV.second;
     // FIXME: For now we just assume that all asm symbols are executable.
     uint32_t Res = BasicSymbolRef::SF_Executable;
     switch (Value) {
     case RecordStreamer::NeverSeen:

llvm/trunk/lib/Object/RecordStreamer.h

 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/SMLoc.h"
 #include <vector>
 
 namespace llvm {
 
+class GlobalValue;
+class Module;
+
 class RecordStreamer : public MCStreamer {
 public:
   enum State { NeverSeen, Global, Defined, DefinedGlobal, DefinedWeak, Used,
                UndefinedWeak};
 
 private:
+  const Module &M;
   StringMap<State> Symbols;
   // Map of aliases created by .symver directives, saved so we can update
   // their symbol binding after parsing complete. This maps from each
   // aliasee to its list of aliases.
-  DenseMap<const MCSymbol *, std::vector<MCSymbol *>> SymverAliasMap;
+  DenseMap<const MCSymbol *, std::vector<StringRef>> SymverAliasMap;
+
+  /// Get the state recorded for the given symbol.
+  State getSymbolState(const MCSymbol *Sym);
 
   void markDefined(const MCSymbol &Symbol);
   void markGlobal(const MCSymbol &Symbol, MCSymbolAttr Attribute);
   void markUsed(const MCSymbol &Symbol);
   void visitUsedSymbol(const MCSymbol &Sym) override;
 
 public:
-  RecordStreamer(MCContext &Context);
+  RecordStreamer(MCContext &Context, const Module &M);
 
   using const_iterator = StringMap<State>::const_iterator;
 
   const_iterator begin();
   const_iterator end();
   void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
                        bool) override;
   void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
   bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void EmitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment) override;
   void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
   /// Record .symver aliases for later processing.
   void emitELFSymverDirective(StringRef AliasName,
                               const MCSymbol *Aliasee) override;
-  /// Return the map of .symver aliasee to associated aliases.
-  DenseMap<const MCSymbol *, std::vector<MCSymbol *>> &symverAliases() {
-    return SymverAliasMap;
-  }
-
-  /// Get the state recorded for the given symbol.
-  State getSymbolState(const MCSymbol *Sym) {
-    auto SI = Symbols.find(Sym->getName());
-    if (SI == Symbols.end())
-      return NeverSeen;
-    return SI->second;
-  }
+  // Emit ELF .symver aliases and ensure they have the same binding as the
+  // defined symbol they alias with.
+  void flushSymverDirectives();
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_OBJECT_RECORDSTREAMER_H

llvm/trunk/lib/Object/RecordStreamer.cpp

 //===-- RecordStreamer.cpp - Record asm defined and used symbols ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "RecordStreamer.h"
+#include "llvm/IR/Mangler.h"
+#include "llvm/IR/Module.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSymbol.h"
 
 using namespace llvm;
 
 void RecordStreamer::markDefined(const MCSymbol &Symbol) {
   State &S = Symbols[Symbol.getName()];
   switch (S) {
void RecordStreamer::markUsed(const MCSymbol &Symbol) {
   case Used:
     S = Used;
     break;
   }
 }
 
 void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }
 
-RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
+RecordStreamer::RecordStreamer(MCContext &Context, const Module &M)
+    : MCStreamer(Context), M(M) {}
 
 RecordStreamer::const_iterator RecordStreamer::begin() {
   return Symbols.begin();
 }
 
 RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
 
 void RecordStreamer::EmitInstruction(const MCInst &Inst,
void RecordStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
   markDefined(*Symbol);
 }
 
 void RecordStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                       unsigned ByteAlignment) {
   markDefined(*Symbol);
 }
 
+RecordStreamer::State RecordStreamer::getSymbolState(const MCSymbol *Sym) {
+  auto SI = Symbols.find(Sym->getName());
+  if (SI == Symbols.end())
+    return NeverSeen;
+  return SI->second;
+}
+
 void RecordStreamer::emitELFSymverDirective(StringRef AliasName,
                                             const MCSymbol *Aliasee) {
+  SymverAliasMap[Aliasee].push_back(AliasName);
+}
+
+void RecordStreamer::flushSymverDirectives() {
+  // Mapping from mangled name to GV.
+  StringMap<const GlobalValue *> MangledNameMap;
+  // The name in the assembler will be mangled, but the name in the IR
+  // might not, so we first compute a mapping from mangled name to GV.
+  Mangler Mang;
+  SmallString<64> MangledName;
+  for (const GlobalValue &GV : M.global_values()) {
+    if (!GV.hasName())
+      continue;
+    MangledName.clear();
+    MangledName.reserve(GV.getName().size() + 1);
+    Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
+    MangledNameMap[MangledName] = &GV;
+  }
+
+  // Walk all the recorded .symver aliases, and set up the binding
+  // for each alias.
+  for (auto &Symver : SymverAliasMap) {
+    const MCSymbol *Aliasee = Symver.first;
+    MCSymbolAttr Attr = MCSA_Invalid;
+
+    // First check if the aliasee binding was recorded in the asm.
+    RecordStreamer::State state = getSymbolState(Aliasee);
+    switch (state) {
+    case RecordStreamer::Global:
+    case RecordStreamer::DefinedGlobal:
+      Attr = MCSA_Global;
+      break;
+    case RecordStreamer::UndefinedWeak:
+    case RecordStreamer::DefinedWeak:
+      Attr = MCSA_Weak;
+      break;
+    default:
+      break;
+    }
+
+    // If we don't have a symbol attribute from assembly, then check if
+    // the aliasee was defined in the IR.
+    if (Attr == MCSA_Invalid) {
+      const auto *GV = M.getNamedValue(Aliasee->getName());
+      if (!GV) {
+        auto MI = MangledNameMap.find(Aliasee->getName());
+        if (MI != MangledNameMap.end())
+          GV = MI->second;
+      }
+      if (GV) {
+        if (GV->hasExternalLinkage())
+          Attr = MCSA_Global;
+        else if (GV->hasLocalLinkage())
+          Attr = MCSA_Local;
+        else if (GV->isWeakForLinker())
+          Attr = MCSA_Weak;
+      }
+    }
+    // Set the detected binding on each alias with this aliasee.
+    for (auto AliasName : Symver.second) {
       MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
+      // TODO: Handle "@@@". Depending on SymbolAttribute value it needs to be
+      // converted into @ or @@.
       const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
       EmitAssignment(Alias, Value);
-  SymverAliasMap[Aliasee].push_back(Alias);
+      if (Attr != MCSA_Invalid)
+        EmitSymbolAttribute(Alias, Attr);
+    }
+  }
 }