[MC] Make MCStreamer aware of AsmParser's StartTokLoc

[MaskRay]

Summary

A SMLoc allows MCStreamer to report location-aware diagnostics, which
were previously done by adding SMLoc to various methods (e.g. emit*) in an ad-hoc way.

Since the file:line is most important, the column is less important and
the start token location suffices in many cases, this patch reverts
b7e7131af2dd7bdb03fa42a3bc1b4bc72ab95ce1

// old
symbol-binding-changed.s:6:8: error: local changed binding to STB_GLOBAL
.globl local
       ^
// new
symbol-binding-changed.s:6:1: error: local changed binding to STB_GLOBAL
.globl local
^

[arichardson]

This seems like a good solution to the problem I'm trying to fix in D89787 and I'll rebase on top of this. Not sure about the name StartTokLocPtr though. Maybe CurrentParserLoc?

llvm/lib/MC/MCParser/AsmParser.cpp

1713

[MaskRay]

In D90511#2365945, @arichardson wrote:

This seems like a good solution to the problem I'm trying to fix in D89787 and I'll rebase on top of this. Not sure about the name StartTokLocPtr though. Maybe CurrentParserLoc?

AsmParser.cpp:1919 has a variable called StartTokLoc. I felt the usage is similar so I picked it. We store the location of the starting token, instead of the current token, so CurrentParserLoc might be inappropriate.

[rnk]

Thanks, looks good to me.

[vitalybuka]

Looks like http://lab.llvm.org:8011/#/builders/99/builds/397/steps/9/logs/stdio is caused by this

[MaskRay]

In D90511#2370257, @vitalybuka wrote:

Looks like http://lab.llvm.org:8011/#/builders/99/builds/397/steps/9/logs/stdio is caused by this

It was an pre-existing problem which has been fixed by bc847b31435e48ad0e54b322a716a4b9f07bc232

[vitalybuka]

In D90511#2370287, @MaskRay wrote:

In D90511#2370257, @vitalybuka wrote:

Looks like http://lab.llvm.org:8011/#/builders/99/builds/397/steps/9/logs/stdio is caused by this

It was an pre-existing problem which has been fixed by bc847b31435e48ad0e54b322a716a4b9f07bc232

It's still broken

[MaskRay]

In D90511#2371796, @vitalybuka wrote:

In D90511#2370287, @MaskRay wrote:

In D90511#2370257, @vitalybuka wrote:

Looks like http://lab.llvm.org:8011/#/builders/99/builds/397/steps/9/logs/stdio is caused by this

It was an pre-existing problem which has been fixed by bc847b31435e48ad0e54b322a716a4b9f07bc232

It's still broken

Did you mean http://lab.llvm.org:8011/#/builders/99/builds/422 ? I think it is due to a different patch. I am going to investigate it

Failed Tests (1):
  Clang-Unit :: Tooling/./ToolingTests/TransformerTest.TemplateInstantiation

==51632==ERROR: AddressSanitizer: stack-use-after-return on address 0x7f0becfa8b00 at pc 0x00000ae0212e bp 0x7ffe5a83f8b0 sp 0x7ffe5a83f8a8
READ of size 8 at 0x7f0becfa8b00 thread T0
    #0 0xae0212d in onStartOfTranslationUnit /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/ASTMatchers/ASTMatchFinder.cpp:391:11
    #1 0xae0212d in clang::ast_matchers::MatchFinder::matchAST(clang::ASTContext&) /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/ASTMatchers/ASTMatchFinder.cpp:1234:11
    #2 0xecb767e in clang::ParseAST(clang::Sema&, bool, bool) /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/Parse/ParseAST.cpp:171:13
    #3 0xb3e7ab4 in clang::FrontendAction::Execute() /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/Frontend/FrontendAction.cpp:949:8
`

[MaskRay]

In D90511#2371912, @MaskRay wrote:

In D90511#2371796, @vitalybuka wrote:

In D90511#2370287, @MaskRay wrote:

In D90511#2370257, @vitalybuka wrote:

Looks like http://lab.llvm.org:8011/#/builders/99/builds/397/steps/9/logs/stdio is caused by this

It was an pre-existing problem which has been fixed by bc847b31435e48ad0e54b322a716a4b9f07bc232

It's still broken

Did you mean http://lab.llvm.org:8011/#/builders/99/builds/422 ? I think it is due to a different patch. I am going to investigate it

Failed Tests (1):
  Clang-Unit :: Tooling/./ToolingTests/TransformerTest.TemplateInstantiation

==51632==ERROR: AddressSanitizer: stack-use-after-return on address 0x7f0becfa8b00 at pc 0x00000ae0212e bp 0x7ffe5a83f8b0 sp 0x7ffe5a83f8a8
READ of size 8 at 0x7f0becfa8b00 thread T0
    #0 0xae0212d in onStartOfTranslationUnit /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/ASTMatchers/ASTMatchFinder.cpp:391:11
    #1 0xae0212d in clang::ast_matchers::MatchFinder::matchAST(clang::ASTContext&) /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/ASTMatchers/ASTMatchFinder.cpp:1234:11
    #2 0xecb767e in clang::ParseAST(clang::Sema&, bool, bool) /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/Parse/ParseAST.cpp:171:13
    #3 0xb3e7ab4 in clang::FrontendAction::Execute() /b/sanitizer-x86_64-linux-bootstrap/build/llvm-project/clang/lib/Frontend/FrontendAction.cpp:949:8
`

@vitalybuka Fixed ASAN_OPTIONS=detect_stack_use_after_return=1 ..../tools/clang/unittests/Tooling/ToolingTests --gtest_filter='*TransformerTest.TemplateInstantiation' in 96ed6793b35e8267b0c94ebe69ae94f07024f476. The relevant code was last touched in 2019 so I wonder why it only failed recently...

llvm/include/llvm/MC/MCELFStreamer.h

public:
   void InitSections(bool NoExecStack) override;
   void changeSection(MCSection *Section, const MCExpr *Subsection) override;
   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void emitLabelAtPos(MCSymbol *Symbol, SMLoc Loc, MCFragment *F,
                       uint64_t Offset) override;
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
   void emitThumbFunc(MCSymbol *Func) override;
   void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc Loc = SMLoc()) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitELFSymverDirective(StringRef AliasName,
                               const MCSymbol *Aliasee) override;
 

llvm/include/llvm/MC/MCStreamer.h

class MCStreamer {
   /// Tracks an index to represent the order a symbol was emitted in.
   /// Zero means we did not emit that symbol.
   DenseMap<const MCSymbol *, unsigned> SymbolOrdering;
 
   /// This is stack of current and previous section values saved by
   /// PushSection.
   SmallVector<std::pair<MCSectionSubPair, MCSectionSubPair>, 4> SectionStack;
 
+  /// Pointer to the parser's SMLoc if available. This is used to provide
+  /// locations for diagnostics.
+  const SMLoc *StartTokLocPtr = nullptr;
+
   /// The next unique ID to use when creating a WinCFI-related section (.pdata
   /// or .xdata). This ID ensures that we have a one-to-one mapping from
   /// code section to unwind info section, which MSVC's incremental linker
   /// requires.
   unsigned NextWinCFIID = 0;
 
   bool UseAssemblerInfoForParsing;
 
public:
 
   void visitUsedExpr(const MCExpr &Expr);
   virtual void visitUsedSymbol(const MCSymbol &Sym);
 
   void setTargetStreamer(MCTargetStreamer *TS) {
     TargetStreamer.reset(TS);
   }
 
+  void setStartTokLocPtr(const SMLoc *Loc) { StartTokLocPtr = Loc; }
+  SMLoc getStartTokLoc() const {
+    return StartTokLocPtr ? *StartTokLocPtr : SMLoc();
+  }
+
   /// State management
   ///
   virtual void reset();
 
   MCContext &getContext() const { return Context; }
 
   virtual MCAssembler *getAssemblerPtr() { return nullptr; }
 
public:
   /// This corresponds to an assembler statement such as:
   ///  .weakref alias, symbol
   ///
   /// \param Alias - The alias that is being created.
   /// \param Symbol - The symbol being aliased.
   virtual void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
 
   /// Add the given \p Attribute to \p Symbol.
-  virtual bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                                   SMLoc Loc = SMLoc()) = 0;
+  virtual bool emitSymbolAttribute(MCSymbol *Symbol,
+                                   MCSymbolAttr Attribute) = 0;
 
   /// Set the \p DescValue for the \p Symbol.
   ///
   /// \param Symbol - The symbol to have its n_desc field set.
   /// \param DescValue - The value to set into the n_desc field.
   virtual void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
 
   /// Start emitting COFF symbol definition

llvm/include/llvm/MC/MCWasmStreamer.h

public:
 
   /// \name MCStreamer Interface
   /// @{
 
   void changeSection(MCSection *Section, const MCExpr *Subsection) override;
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
   void emitThumbFunc(MCSymbol *Func) override;
   void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   void emitELFSize(MCSymbol *Symbol, const MCExpr *Value) override;
 
   void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;

llvm/include/llvm/MC/MCWinCOFFStreamer.h

public:
 
   /// \name MCStreamer interface
   /// \{
 
   void InitSections(bool NoExecStack) override;
   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
   void emitThumbFunc(MCSymbol *Func) override;
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc Loc = SMLoc()) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void BeginCOFFSymbolDef(MCSymbol const *Symbol) override;
   void EmitCOFFSymbolStorageClass(int StorageClass) override;
   void EmitCOFFSymbolType(int Type) override;
   void EndCOFFSymbolDef() override;
   void EmitCOFFSafeSEH(MCSymbol const *Symbol) override;
   void EmitCOFFSymbolIndex(MCSymbol const *Symbol) override;
   void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;

llvm/include/llvm/MC/MCXCOFFStreamer.h

 namespace llvm {
 
 class MCXCOFFStreamer : public MCObjectStreamer {
 public:
   MCXCOFFStreamer(MCContext &Context, std::unique_ptr<MCAsmBackend> MAB,
                   std::unique_ptr<MCObjectWriter> OW,
                   std::unique_ptr<MCCodeEmitter> Emitter);
 
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc Loc = SMLoc()) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
   void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,
                     SMLoc Loc = SMLoc()) override;
   void emitInstToData(const MCInst &Inst, const MCSubtargetInfo &) override;
   void emitXCOFFLocalCommonSymbol(MCSymbol *LabelSym, uint64_t Size,
                                   MCSymbol *CsectSym,

llvm/lib/MC/MCAsmStreamer.cpp

public:
   void emitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor,
                       unsigned Update, VersionTuple SDKVersion) override;
   void emitBuildVersion(unsigned Platform, unsigned Major, unsigned Minor,
                         unsigned Update, VersionTuple SDKVersion) override;
   void emitThumbFunc(MCSymbol *Func) override;
 
   void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
   void emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
 
   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void BeginCOFFSymbolDef(const MCSymbol *Symbol) override;
   void EmitCOFFSymbolStorageClass(int StorageClass) override;
   void EmitCOFFSymbolType(int Type) override;
   void EndCOFFSymbolDef() override;
   void EmitCOFFSafeSEH(MCSymbol const *Symbol) override;
   void EmitCOFFSymbolIndex(MCSymbol const *Symbol) override;
void MCAsmStreamer::emitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
   OS << ".weakref ";
   Alias->print(OS, MAI);
   OS << ", ";
   Symbol->print(OS, MAI);
   EmitEOL();
 }
 
 bool MCAsmStreamer::emitSymbolAttribute(MCSymbol *Symbol,
-                                        MCSymbolAttr Attribute, SMLoc) {
+                                        MCSymbolAttr Attribute) {
   switch (Attribute) {
   case MCSA_Invalid: llvm_unreachable("Invalid symbol attribute");
   case MCSA_ELF_TypeFunction:    /// .type _foo, STT_FUNC  # aka @function
   case MCSA_ELF_TypeIndFunction: /// .type _foo, STT_GNU_IFUNC
   case MCSA_ELF_TypeObject:      /// .type _foo, STT_OBJECT  # aka @object
   case MCSA_ELF_TypeTLS:         /// .type _foo, STT_TLS     # aka @tls_object
   case MCSA_ELF_TypeCommon:      /// .type _foo, STT_COMMON  # aka @common
   case MCSA_ELF_TypeNoType:      /// .type _foo, STT_NOTYPE  # aka @notype

llvm/lib/MC/MCELFStreamer.cpp

if (T1 == Type)
       return T2;
     if (T2 == Type)
       return T1;
   }
 
   return T2;
 }
 
-bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute,
-                                        SMLoc Loc) {
+bool MCELFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   auto *Symbol = cast<MCSymbolELF>(S);
 
   // Adding a symbol attribute always introduces the symbol, note that an
   // important side effect of calling registerSymbol here is to register
   // the symbol with the assembler.
   getAssembler().registerSymbol(*Symbol);
 
   // The implementation of symbol attributes is designed to match 'as', but it
case MCSA_ELF_TypeGnuUniqueObject:
     Symbol->setExternal(true);
     break;
 
   case MCSA_Global:
     // For `.weak x; .global x`, GNU as sets the binding to STB_WEAK while we
     // traditionally set the binding to STB_GLOBAL. This is error-prone, so we
     // error on such cases. Note, we also disallow changed binding from .local.
     if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_GLOBAL)
-      getContext().reportError(Loc, Symbol->getName() +
-                                        " changed binding to STB_GLOBAL");
+      getContext().reportError(getStartTokLoc(),
+                               Symbol->getName() +
     Symbol->setBinding(ELF::STB_GLOBAL);
     Symbol->setExternal(true);
     break;
 
   case MCSA_WeakReference:
   case MCSA_Weak:
     // For `.global x; .weak x`, both MC and GNU as set the binding to STB_WEAK.
     // We emit a warning for now but may switch to an error in the future.
     if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_WEAK)
-      getContext().reportWarning(Loc, Symbol->getName() +
-                                          " changed binding to STB_WEAK");
+      getContext().reportWarning(
+          getStartTokLoc(), Symbol->getName() + " changed binding to STB_WEAK");
     Symbol->setBinding(ELF::STB_WEAK);
     Symbol->setExternal(true);
     break;
 
   case MCSA_Local:
     if (Symbol->isBindingSet() && Symbol->getBinding() != ELF::STB_LOCAL)
-      getContext().reportError(Loc, Symbol->getName() +
-                                        " changed binding to STB_LOCAL");
+      getContext().reportError(getStartTokLoc(),
+                               Symbol->getName() +
     Symbol->setBinding(ELF::STB_LOCAL);
     Symbol->setExternal(false);
     break;
 
   case MCSA_ELF_TypeFunction:
     Symbol->setType(CombineSymbolTypes(Symbol->getType(), ELF::STT_FUNC));
     break;
 

llvm/lib/MC/MCMachOStreamer.cpp

public:
   void emitAssemblerFlag(MCAssemblerFlag Flag) override;
   void emitLinkerOptions(ArrayRef<std::string> Options) override;
   void emitDataRegion(MCDataRegionType Kind) override;
   void emitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor,
                       unsigned Update, VersionTuple SDKVersion) override;
   void emitBuildVersion(unsigned Platform, unsigned Major, unsigned Minor,
                         unsigned Update, VersionTuple SDKVersion) override;
   void emitThumbFunc(MCSymbol *Func) override;
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc Loc = SMLoc()) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
   void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,

 
 void MCMachOStreamer::emitThumbFunc(MCSymbol *Symbol) {
   // Remember that the function is a thumb function. Fixup and relocation
   // values will need adjusted.
   getAssembler().setIsThumbFunc(Symbol);
   cast<MCSymbolMachO>(Symbol)->setThumbFunc();
 }
 
-bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym, MCSymbolAttr Attribute,
-                                          SMLoc) {
+bool MCMachOStreamer::emitSymbolAttribute(MCSymbol *Sym,
+                                          MCSymbolAttr Attribute) {
   MCSymbolMachO *Symbol = cast<MCSymbolMachO>(Sym);
 
   // Indirect symbols are handled differently, to match how 'as' handles
   // them. This makes writing matching .o files easier.
   if (Attribute == MCSA_IndirectSymbol) {
     // Note that we intentionally cannot use the symbol data here; this is
     // important for matching the string table that 'as' generates.
     IndirectSymbolData ISD;

llvm/lib/MC/MCNullStreamer.cpp

public:
     MCNullStreamer(MCContext &Context) : MCStreamer(Context) {}
 
     /// @name MCStreamer Interface
     /// @{
 
     bool hasRawTextSupport() const override { return true; }
     void emitRawTextImpl(StringRef String) override {}
 
-    bool emitSymbolAttribute(MCSymbol *, MCSymbolAttr, SMLoc) override {
+    bool emitSymbolAttribute(MCSymbol *Symbol,
+                             MCSymbolAttr Attribute) override {
       return true;
     }
 
     void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                           unsigned ByteAlignment) override {}
     void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                       uint64_t Size = 0, unsigned ByteAlignment = 0,
                       SMLoc Loc = SMLoc()) override {}

llvm/lib/MC/MCParser/AsmParser.cpp

private:
   AsmLexer Lexer;
   MCContext &Ctx;
   MCStreamer &Out;
   const MCAsmInfo &MAI;
   SourceMgr &SrcMgr;
   SourceMgr::DiagHandlerTy SavedDiagHandler;
   void *SavedDiagContext;
   std::unique_ptr<MCAsmParserExtension> PlatformParser;
+  SMLoc StartTokLoc;
 
   /// This is the current buffer index we're lexing from as managed by the
   /// SourceMgr object.
   unsigned CurBuffer;
 
   AsmCond TheCondState;
   std::vector<AsmCond> TheCondStack;
 
: Lexer(MAI), Ctx(Ctx), Out(Out), MAI(MAI), SrcMgr(SM),
       CurBuffer(CB ? CB : SM.getMainFileID()), MacrosEnabledFlag(true) {
   HadError = false;
   // Save the old handler.
   SavedDiagHandler = SrcMgr.getDiagHandler();
   SavedDiagContext = SrcMgr.getDiagContext();
   // Set our own handler which calls the saved handler.
   SrcMgr.setDiagHandler(DiagHandler, this);
   Lexer.setBuffer(SrcMgr.getMemoryBuffer(CurBuffer)->getBuffer());
+  // Make MCStreamer aware of the StartTokLoc for locations in diagnostics.
+  Out.setStartTokLocPtr(&StartTokLoc);
 
   // Initialize the platform / file format parser.
   switch (Ctx.getObjectFileInfo()->getObjectFileType()) {
   case MCObjectFileInfo::IsCOFF:
     PlatformParser.reset(createCOFFAsmParser());
     break;
   case MCObjectFileInfo::IsMachO:
     PlatformParser.reset(createDarwinAsmParser());
AsmParser::AsmParser(SourceMgr &SM, MCContext &Ctx, MCStreamer &Out,
 
   NumOfMacroInstantiations = 0;
 }
 
 AsmParser::~AsmParser() {
   assert((HadError || ActiveMacros.empty()) &&
          "Unexpected active macro instantiation!");
 
+  // Remove MCStreamer's reference to the parser SMLoc.
+  Out.setStartTokLocPtr(nullptr);
   // Restore the saved diagnostics handler and context for use during
   // finalization.
   SrcMgr.setDiagHandler(SavedDiagHandler, SavedDiagContext);
 }
 
 void AsmParser::printMacroInstantiations() {
   // Print the active macro instantiation stack.
   for (std::vector<MacroInstantiation *>::const_reverse_iterator
if (Lexer.is(AsmToken::EndOfStatement)) {
     Lex();
     return false;
   }
   // Statements always start with an identifier.
   AsmToken ID = getTok();
   SMLoc IDLoc = ID.getLoc();
   StringRef IDVal;
   int64_t LocalLabelVal = -1;
+  StartTokLoc = ID.getLoc();
   if (Lexer.is(AsmToken::HashDirective))
     return parseCppHashLineFilenameComment(IDLoc,
                                            !isInsideMacroInstantiation());
 
   // Allow an integer followed by a ':' as a directional local label.
   if (Lexer.is(AsmToken::Integer)) {
     LocalLabelVal = getTok().getIntVal();
     if (LocalLabelVal < 0) {
auto parseOp = [&]() -> bool {
     if (parseIdentifier(Name))
       return Error(Loc, "expected identifier");
     MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
 
     // Assembler local symbols don't make any sense here. Complain loudly.
     if (Sym->isTemporary())
       return Error(Loc, "non-local symbol required");
 
-    if (!getStreamer().emitSymbolAttribute(Sym, Attr, Loc))
+    if (!getStreamer().emitSymbolAttribute(Sym, Attr))
       return Error(Loc, "unable to emit symbol attribute");
     return false;
   };
 
   if (parseMany(parseOp))
     return addErrorSuffix(" in directive");
   return false;
 }

llvm/lib/MC/MCParser/ELFAsmParser.cpp

MCSymbolAttr Attr = StringSwitch<MCSymbolAttr>(Directive)
     .Case(".hidden", MCSA_Hidden)
     .Case(".internal", MCSA_Internal)
     .Case(".protected", MCSA_Protected)
     .Default(MCSA_Invalid);
   assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     while (true) {
       StringRef Name;
-      SMLoc Loc = getTok().getLoc();
+
       if (getParser().parseIdentifier(Name))
         return TokError("expected identifier in directive");
 
       MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
 
-      getStreamer().emitSymbolAttribute(Sym, Attr, Loc);
+      getStreamer().emitSymbolAttribute(Sym, Attr);
 
       if (getLexer().is(AsmToken::EndOfStatement))
         break;
 
       if (getLexer().isNot(AsmToken::Comma))
         return TokError("unexpected token in directive");
       Lex();
     }

llvm/lib/MC/MCWasmStreamer.cpp

 void MCWasmStreamer::emitWeakReference(MCSymbol *Alias,
                                        const MCSymbol *Symbol) {
   getAssembler().registerSymbol(*Symbol);
   const MCExpr *Value = MCSymbolRefExpr::create(
       Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext());
   Alias->setVariableValue(Value);
 }
 
-bool MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute,
-                                         SMLoc) {
+bool MCWasmStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   assert(Attribute != MCSA_IndirectSymbol && "indirect symbols not supported");
 
   auto *Symbol = cast<MCSymbolWasm>(S);
 
   // Adding a symbol attribute always introduces the symbol; note that an
   // important side effect of calling registerSymbol here is to register the
   // symbol with the assembler.
   getAssembler().registerSymbol(*Symbol);

llvm/lib/MC/MCWinCOFFStreamer.cpp

case MCAF_SubsectionsViaSymbols:
     llvm_unreachable("COFF doesn't support .subsections_via_symbols");
   }
 }
 
 void MCWinCOFFStreamer::emitThumbFunc(MCSymbol *Func) {
   llvm_unreachable("not implemented");
 }
 
-bool MCWinCOFFStreamer::emitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute,
-                                            SMLoc) {
+bool MCWinCOFFStreamer::emitSymbolAttribute(MCSymbol *S,
+                                            MCSymbolAttr Attribute) {
   auto *Symbol = cast<MCSymbolCOFF>(S);
   getAssembler().registerSymbol(*Symbol);
 
   switch (Attribute) {
   default: return false;
   case MCSA_WeakReference:
   case MCSA_Weak:
     Symbol->setIsWeakExternal();

llvm/lib/MC/MCXCOFFStreamer.cpp

 
 MCXCOFFStreamer::MCXCOFFStreamer(MCContext &Context,
                                  std::unique_ptr<MCAsmBackend> MAB,
                                  std::unique_ptr<MCObjectWriter> OW,
                                  std::unique_ptr<MCCodeEmitter> Emitter)
     : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
                        std::move(Emitter)) {}
 
-bool MCXCOFFStreamer::emitSymbolAttribute(MCSymbol *Sym, MCSymbolAttr Attribute,
-                                          SMLoc) {
+bool MCXCOFFStreamer::emitSymbolAttribute(MCSymbol *Sym,
+                                          MCSymbolAttr Attribute) {
   auto *Symbol = cast<MCSymbolXCOFF>(Sym);
   getAssembler().registerSymbol(*Symbol);
 
   switch (Attribute) {
   case MCSA_Global:
   case MCSA_Extern:
     Symbol->setStorageClass(XCOFF::C_EXT);
     Symbol->setExternal(true);

llvm/lib/Object/RecordStreamer.h

private:
   void visitUsedSymbol(const MCSymbol &Sym) override;
 
 public:
   RecordStreamer(MCContext &Context, const Module &M);
 
   void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
   void emitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
   void emitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc Loc) override;
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
   void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc = SMLoc()) override;
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override;
 
   // Ignore COFF-specific directives; we do not need any information from them,
   // but the default implementation of these methods crashes, so we override
   // them with versions that do nothing.

llvm/lib/Object/RecordStreamer.cpp

 }
 
 void RecordStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
   markDefined(*Symbol);
   MCStreamer::emitAssignment(Symbol, Value);
 }
 
 bool RecordStreamer::emitSymbolAttribute(MCSymbol *Symbol,
-                                         MCSymbolAttr Attribute, SMLoc) {
+                                         MCSymbolAttr Attribute) {
   if (Attribute == MCSA_Global || Attribute == MCSA_Weak)
     markGlobal(*Symbol, Attribute);
   if (Attribute == MCSA_LazyReference)
     markUsed(*Symbol);
   return true;
 }
 
 void RecordStreamer::emitZerofill(MCSection *Section, MCSymbol *Symbol,
for (auto AliasName : Symver.second) {
       // TODO: Handle "@@@". Depending on SymbolAttribute value it needs to be
       // converted into @ or @@.
       const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
       if (IsDefined)
         markDefined(*Alias);
       // Don't use EmitAssignment override as it always marks alias as defined.
       MCStreamer::emitAssignment(Alias, Value);
       if (Attr != MCSA_Invalid)
-        emitSymbolAttribute(Alias, Attr, SMLoc());
+        emitSymbolAttribute(Alias, Attr);
     }
   }
 }

llvm/test/MC/ELF/symbol-binding-changed.s

 # RUN: not llvm-mc -filetype=obj -triple=x86_64 %s -o /dev/null 2>&1 | FileCheck %s --implicit-check-not=error:
 
-# CHECK: {{.*}}.s:[[#@LINE+3]]:8: error: local changed binding to STB_GLOBAL
+# CHECK: {{.*}}.s:[[#@LINE+3]]:1: error: local changed binding to STB_GLOBAL
 local:
 .local local
 .globl local
 
 ## `.globl x; .weak x` matches the GNU as behavior. We issue a warning for now.
-# CHECK: {{.*}}.s:[[#@LINE+3]]:7: warning: global changed binding to STB_WEAK
+# CHECK: {{.*}}.s:[[#@LINE+3]]:1: warning: global changed binding to STB_WEAK
 global:
 .global global
 .weak global
 
-# CHECK: {{.*}}.s:[[#@LINE+3]]:8: error: weak changed binding to STB_LOCAL
+# CHECK: {{.*}}.s:[[#@LINE+3]]:1: error: weak changed binding to STB_LOCAL
 weak:
 .weak weak
 .local weak
 
 # CHECK-NOT: error:
 multi_local:
 .local multi_local
 .local multi_local
 multi_global:
 .global multi_global
 .global multi_global
 multi_weak:
 .weak multi_weak
 .weak multi_weak

llvm/tools/llvm-exegesis/lib/SnippetFile.cpp

public:
   }
 
   unsigned numInvalidComments() const { return InvalidComments; }
 
 private:
   // We only care about instructions, we don't implement this part of the API.
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override {}
-  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute,
-                           SMLoc) override {
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
     return false;
   }
   void emitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                             unsigned ValueSize,
                             unsigned MaxBytesToEmit) override {}
   void emitZerofill(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc) override {}
 

llvm/tools/llvm-mca/CodeRegionGenerator.cpp

MCStreamerWrapper(MCContext &Context, mca::CodeRegions &R)
       : MCStreamer(Context), Regions(R) {}
 
   // We only want to intercept the emission of new instructions.
   virtual void emitInstruction(const MCInst &Inst,
                                const MCSubtargetInfo & /* unused */) override {
     Regions.addInstruction(Inst);
   }
 
-  bool emitSymbolAttribute(MCSymbol *, MCSymbolAttr, SMLoc) override {
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
     return true;
   }
 
   void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                         unsigned ByteAlignment) override {}
   void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,
                     SMLoc Loc = SMLoc()) override {}

llvm/unittests/CodeGen/TestAsmPrinter.h

 
 class MockMCStreamer : public MCStreamer {
 public:
   explicit MockMCStreamer(MCContext *Ctx);
   ~MockMCStreamer();
 
   // These methods are pure virtual in MCStreamer, thus, have to be overridden:
 
-  MOCK_METHOD3(emitSymbolAttribute,
-               bool(MCSymbol *Symbol, MCSymbolAttr Attribute, SMLoc Loc));
+  MOCK_METHOD2(emitSymbolAttribute,
+               bool(MCSymbol *Symbol, MCSymbolAttr Attribute));
   MOCK_METHOD3(emitCommonSymbol,
                void(MCSymbol *Symbol, uint64_t Size, unsigned ByteAlignment));
   MOCK_METHOD5(emitZerofill,
                void(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                     unsigned ByteAlignment, SMLoc Loc));
 
   // The following are mock methods to be used in tests.