[LTO][MC] Discard non-prevailing defined symbols in module-level assembly

[ychen]

Summary

This is the alternative approach to D96931.

In LTO, for each module with inlineasm block, prepend directive ".lto_discard <sym>, <sym>*" to the beginning of the inline
asm. ".lto_discard" is both a module inlineasm block marker and (optionally) provides a list of symbols to be discarded.

In MC while emitting for inlineasm, discard symbol binding & symbol
definitions according to ".lto_disard".

[MaskRay]

Thanks for the patch. Will take a closer look, but at a glance this looks quite good.

.module may feel like a GNU as directive. I suggest .lto_module so that it is clear the directive is LTO internal stuff.

Alternatively, you can make .lto_discard reset the symbol list, then .lto_discard is sufficient and .module will not be needed.

llvm/lib/MC/MCParser/AsmParser.cpp

5844

Add some comments about their usage in LTO.

[MaskRay]

llvm/lib/LTO/LTO.cpp

756

DenseSet<CachedHashStringRef>

std::set is inefficient. If you don't order guarantee, prefer an unordered container.

llvm/lib/MC/MCParser/AsmParser.cpp

1894

Needs a test/MC/ELF test that reassignment does not error.

llvm/lib/MC/MCParser/ELFAsmParser.cpp

185

Needs a test/MC/ELF test that reassignment does not error.

llvm/test/LTO/X86/weak-asm.ll

13

Drop -o - if you use <

[ychen]

• Use SmallSet for NonPrevailingAsmSymbols since it allocates less than DenseSet
• Rename .module to .lto_module

[ychen]

llvm/lib/LTO/LTO.cpp

756

Agreed that std::set is not the most appropriate one. I used the SmallSet to fit the use case better. DenseSet seems allocate more than needed for the usage.

llvm/lib/MC/MCParser/AsmParser.cpp

1894

Something like llvm/test/MC/AsmParser/reassign.s for this patch?

[MaskRay]

llvm/lib/MC/MCParser/AsmParser.cpp

1894

Yes.

What do you think of dropping .lto_module? One directive .lto_discard is enough.

[ychen]

In D98762#2630923, @MaskRay wrote:

Alternatively, you can make .lto_discard reset the symbol list, then .lto_discard is sufficient and .module will not be needed.

Thanks for the review. Yeah, if we keep the ".lto_discard" then ".module" is not needed. In that case, it has to be legal to use ".lto_discard" without trailing symbols since a marker is still needed to separate the inlineasm block for each module. Otherwise, asm symbols in an irrelevant module could be discarded incorrectly.

[ychen]

I mean ".lto_module" reveals the marker function explicitly. I'm fine with only using ".lto_discard" though. I could add comments to explain the usage above parseDirectiveLTODiscard. Please let me know your preference.

[ychen]

• Add additional tests
• Add the missing case for .global

[MaskRay]

In D98762#2632337, @ychen wrote:

I mean ".lto_module" reveals the marker function explicitly. I'm fine with only using ".lto_discard" though. I could add comments to explain the usage above parseDirectiveLTODiscard. Please let me know your preference.

I prefer only using .lto_discard. .lto_module adds unneeded code.

[ychen]

• Simplify code by not using .lto_module

[ychen]

In D98762#2633802, @MaskRay wrote:

In D98762#2632337, @ychen wrote:

I mean ".lto_module" reveals the marker function explicitly. I'm fine with only using ".lto_discard" though. I could add comments to explain the usage above parseDirectiveLTODiscard. Please let me know your preference.

I prefer only using .lto_discard. .lto_module adds unneeded code.

Makes sense. Patch updated.

[MaskRay]

Mostly looks good.

llvm/lib/LTO/LTO.cpp

808

https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

Use braces for the else block to keep it uniform with the then block.

831

If the previous .lto_discard directive is not empty, you'll need to reset the list to empty, otherwise can this discard some prevailing symbols?

llvm/test/MC/ELF/lto-discard.s

9 ↗

(On Diff #331590)

There needs to be a test checking that .lto_discard without arguments works.
You can use --defsym to place multiple tests in one file if keeping them in one file can help readers.
See some existing --defsym tests for example.

[ychen]

• address comments

[ychen]

llvm/lib/LTO/LTO.cpp

831

NonPrevailingAsmSymbols is empty initially for each module and the module without inlineasm block is not considered. I think it should be fine?

[MaskRay]

llvm/lib/LTO/LTO.cpp

756

Use 2 to be consistent with SmallSet<StringRef, 2> LTODiscardSymbols;

831

I am thinking whether this scenario may happen and drop the prevailing foo accidentally.

.lto_discard foo
non-prevailing foo
prevailing foo

Perhaps this is impossible.

834

Don't dicard a symbol if there is a live .symver for it. better to have a test.

llvm/test/MC/ELF/lto-discard.s

3 ↗

(On Diff #331620)

-filetype=asm does not have effects. You need a -filetype=obj test to show that the foo definition is ignored.

[ychen]

• beef up inline-asm-lto-discard.ll test

[ychen]

• Add a test case for .symver
• Rename test file properly

[ychen]

llvm/test/MC/ELF/lto-discard.s

3 ↗

(On Diff #331620)

I'm checking .lto_discard is no-op here..

inline-asm-lto-discard.ll is beefed up to test this.

[MaskRay]

In D98762#2635362, @ychen wrote:

• Add a test case for .symver
• Rename test file properly

Oh I missed EnableLTODiscardSymbols, which is different in LTO and non-LTO. Isn't it a unneeded implementation detail? You can just let .lto_discard unconditionally prevent definitions.
Yes, the name is a bit misnomer here, but that does not matter if you document clearly that it is an implementation detail of inline asm handling in LTO so that users will not misuse it.

[ychen]

• Drop unnecessary EnableLTODiscardSymbols to make the implementation simpler.

[MaskRay]

llvm/lib/MC/MCParser/AsmParser.cpp

5846

The LTO library emits this directive to discard non-prevailing symbols. We ignore symbol assignments and attribute changes for the specified symbols.

5853

You can add a --defsym=ERR=1 RUN line to the test/MC/ELF test to check the diagnostic message and position. See relocation-alias.s and `reloc-directive.s for examples.

llvm/test/LTO/X86/inline-asm-lto-discard2.ll

5 ↗

(On Diff #331665)

Nit: -filetype=asm is the default. Delete

[MaskRay]

PS: ".lto_discard" is not strictly required but it would make the MC change much simpler. I didn't add any standalone MC tests because the only client for these two directives should be LTO.

Please fix the description.

[ychen]

• Add additional test cases based on comments.

[ychen]

@MaskRay Thanks a lot for the feedbacks.

llvm/include/llvm/MC/MCContext.h

public:
     MCContext(const MCContext &) = delete;
     MCContext &operator=(const MCContext &) = delete;
     ~MCContext();
 
     const SourceMgr *getSourceManager() const { return SrcMgr; }
 
     void initInlineSourceManager();
     SourceMgr *getInlineSourceManager() {
-      assert(InlineSrcMgr);
       return InlineSrcMgr.get();
     }
     std::vector<const MDNode *> &getLocInfos() { return LocInfos; }
     void setDiagnosticHandler(DiagHandlerTy DiagHandler) {
       this->DiagHandler = DiagHandler;
     }
 
     const MCAsmInfo *getAsmInfo() const { return MAI; }

llvm/include/llvm/MC/MCParser/MCAsmParser.h

public:
   void setShowParsedOperands(bool Value) { ShowParsedOperands = Value; }
 
   /// Run the parser on the input source buffer.
   virtual bool Run(bool NoInitialTextSection, bool NoFinalize = false) = 0;
 
   virtual void setParsingMSInlineAsm(bool V) = 0;
   virtual bool isParsingMSInlineAsm() = 0;
 
+  virtual bool discardLTOSymbol(StringRef) const { return false; }
+
   virtual bool isParsingMasm() const { return false; }
 
   virtual bool defineMacro(StringRef Name, StringRef Value) { return true; }
 
   virtual bool lookUpField(StringRef Name, AsmFieldInfo &Info) const {
     return true;
   }
   virtual bool lookUpField(StringRef Base, StringRef Member,

llvm/lib/LTO/LTO.cpp

 //===-LTO.cpp - LLVM Link Time Optimizer ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements functions and classes used to support LTO.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/LTO/LTO.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/StackSafetyAnalysis.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/Config/llvm-config.h"
while (MsymI != MsymE) {
           !(Flags & object::BasicSymbolRef::SF_FormatSpecific))
         return;
       ++MsymI;
     }
   };
   Skip();
 
   std::set<const Comdat *> NonPrevailingComdats;
+  std::set<StringRef> NonPrevailingAsmSymbols;
   for (const InputFile::Symbol &Sym : Syms) {
     assert(ResI != ResE);
     SymbolResolution Res = *ResI++;
 
     assert(MsymI != MsymE);
     ModuleSymbolTable::Symbol Msym = *MsymI++;
     Skip();
 
if (GlobalValue *GV = Msym.dyn_cast<GlobalValue *>()) {
 
       // Set the 'local' flag based on the linker resolution for this symbol.
       if (Res.FinalDefinitionInLinkageUnit) {
         GV->setDSOLocal(true);
         if (GV->hasDLLImportStorageClass())
           GV->setDLLStorageClass(GlobalValue::DLLStorageClassTypes::
                                  DefaultStorageClass);
       }
-    }
+    } else if (auto *AS = Msym.dyn_cast<ModuleSymbolTable::AsmSymbol *>()) {
+      // Collect non-prevailing symbols.
+      if (!Res.Prevailing)
+        NonPrevailingAsmSymbols.insert(AS->first);
+    } else
+      llvm_unreachable("unknown symbol type");
+
     // Common resolution: collect the maximum size/alignment over all commons.
     // We also record if we see an instance of a common as prevailing, so that
     // if none is prevailing we can ignore it later.
     if (Sym.isCommon()) {
       // FIXME: We should figure out what to do about commons defined by asm.
       // For now they aren't reported correctly by ModuleSymbolTable.
       auto &CommonRes = RegularLTO.Commons[std::string(Sym.getIRName())];
       CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
       MaybeAlign SymAlign(Sym.getCommonAlignment());
       if (SymAlign)
         CommonRes.Align = max(*SymAlign, CommonRes.Align);
       CommonRes.Prevailing |= Res.Prevailing;
     }
-
   }
+
   if (!M.getComdatSymbolTable().empty())
     for (GlobalValue &GV : M.global_values())
       handleNonPrevailingComdat(GV, NonPrevailingComdats);
+
+  // Prepend ".module" to each module inline asm block. Also emit a
+  // ".lto_discard <sym>, <sym>*" directive if needed.
+  if (!M.getModuleInlineAsm().empty()) {
+    std::string NewIA = ".module\n";
+    if (!NonPrevailingAsmSymbols.empty()) {
+      // Don't dicard a symbol if there is a live .symver for it.
+      ModuleSymbolTable::CollectAsmSymvers(
+          M, [&](StringRef Name, StringRef Alias) {
+            if (!NonPrevailingAsmSymbols.count(Alias))
+              NonPrevailingAsmSymbols.erase(Name);
+          });
+      NewIA +=
+          ".lto_discard " + llvm::join(NonPrevailingAsmSymbols, ", ") + "\n";
+    }
+    M.setModuleInlineAsm(NewIA + M.getModuleInlineAsm());
+  }
+
   assert(MsymI == MsymE);
   return std::move(Mod);
 }
 
 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
                           bool LivenessFromIndex) {
   std::vector<GlobalValue *> Keep;
   for (GlobalValue *GV : Mod.Keep) {

llvm/lib/MC/MCParser/AsmParser.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecord.h"

 #include "llvm/MC/MCValue.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SMLoc.h"
+#include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cctype>
 #include <climits>
 #include <cstddef>
 #include <cstdint>
private:
   CppHashInfoTy CppHashInfo;
 
   /// The filename from the first cpp hash file line comment, if any.
   StringRef FirstCppHashFilename;
 
   /// List of forward directional labels for diagnosis at the end.
   SmallVector<std::tuple<SMLoc, CppHashInfoTy, MCSymbol *>, 4> DirLabels;
 
+  bool EnableLTODiscardSymbols = false;
+  SmallSet<StringRef, 2> LTODiscardSymbols;
+
   /// AssemblerDialect. ~OU means unset value and use value provided by MAI.
   unsigned AssemblerDialect = ~0U;
 
   /// is Darwin compatibility enabled?
   bool IsDarwin = false;
 
   /// Are we parsing ms-style inline assembly?
   bool ParsingMSInlineAsm = false;
public:
   void setParsingMSInlineAsm(bool V) override {
     ParsingMSInlineAsm = V;
     // When parsing MS inline asm, we must lex 0b1101 and 0ABCH as binary and
     // hex integer literals.
     Lexer.setLexMasmIntegers(V);
   }
   bool isParsingMSInlineAsm() override { return ParsingMSInlineAsm; }
 
+  bool discardLTOSymbol(StringRef Name) const override {
+    if (!LTODiscardSymbols.empty())
+      assert(EnableLTODiscardSymbols);
+    return LTODiscardSymbols.contains(Name);
+  }
+
   bool parseMSInlineAsm(void *AsmLoc, std::string &AsmString,
                         unsigned &NumOutputs, unsigned &NumInputs,
                         SmallVectorImpl<std::pair<void *,bool>> &OpDecls,
                         SmallVectorImpl<std::string> &Constraints,
                         SmallVectorImpl<std::string> &Clobbers,
                         const MCInstrInfo *MII, const MCInstPrinter *IP,
                         MCAsmParserSemaCallback &SI) override;
 
enum DirectiveKind {
     DK_ULEB128,
     DK_ERR,
     DK_ERROR,
     DK_WARNING,
     DK_PRINT,
     DK_ADDRSIG,
     DK_ADDRSIG_SYM,
     DK_PSEUDO_PROBE,
+    DK_MOUDLE,
+    DK_LTO_DISCARD,
     DK_END
   };
 
   /// Maps directive name --> DirectiveKind enum, for
   /// directives parsed by this class.
   StringMap<DirectiveKind> DirectiveKindMap;
 
   // Codeview def_range type parsing.
private:
   bool parseDirectiveWarning(SMLoc DirectiveLoc);
 
   // .print <double-quotes-string>
   bool parseDirectivePrint(SMLoc DirectiveLoc);
 
   // .pseudoprobe
   bool parseDirectivePseudoProbe();
 
+  // ".module"
+  bool parseDirectiveModule();
+
+  // ".lto_discard"
+  bool parseDirectiveLTODiscard();
+
   // Directives to support address-significance tables.
   bool parseDirectiveAddrsig();
   bool parseDirectiveAddrsigSym();
 
   void initializeDirectiveKindMap();
   void initializeCVDefRangeTypeMap();
 };
 
if (getContext().getGenDwarfFileNumber() == 0) {
     getContext().setGenDwarfFileNumber(getStreamer().emitDwarfFileDirective(
         /*CUID=*/0, getContext().getCompilationDir(), RootFile.Name,
         RootFile.Checksum, RootFile.Source));
   }
   return true;
 }
 
 bool AsmParser::Run(bool NoInitialTextSection, bool NoFinalize) {
+  // Only enable EnableLTODiscardSymbols for inline assembly.
+  SaveAndRestore<bool> SaveLTODiscard(EnableLTODiscardSymbols,
+                                      Ctx.getInlineSourceManager() != nullptr);
+  LTODiscardSymbols.clear();
+
   // Create the initial section, if requested.
   if (!NoInitialTextSection)
     Out.InitSections(false);
 
   // Prime the lexer.
   Lex();
 
   HadError = false;
bool AsmParser::parseStatement(ParseStatementInfo &Info,
   }
 
   // Handle conditional assembly here before checking for skipping.  We
   // have to do this so that .endif isn't skipped in a ".if 0" block for
   // example.
   StringMap<DirectiveKind>::const_iterator DirKindIt =
       DirectiveKindMap.find(IDVal.lower());
   DirectiveKind DirKind = (DirKindIt == DirectiveKindMap.end())
-
                               ? DK_NO_DIRECTIVE
                               : DirKindIt->getValue();
   switch (DirKind) {
   default:
     break;
   case DK_IF:
   case DK_IFEQ:
   case DK_IFGE:
case AsmToken::Colon: {
     }
 
     // Consume any end of statement token, if present, to avoid spurious
     // AddBlankLine calls().
     if (getTok().is(AsmToken::EndOfStatement)) {
       Lex();
     }
 
+    if (discardLTOSymbol(IDVal))
+      return false;
+
     getTargetParser().doBeforeLabelEmit(Sym);
 
     // Emit the label.
     if (!getTargetParser().isParsingMSInlineAsm())
       Out.emitLabel(Sym, IDLoc);
 
     // If we are generating dwarf for assembly source files then gather the
     // info to make a dwarf label entry for this label if needed.
if (IDVal.startswith(".") && IDVal != ".") {
     case DK_PRINT:
       return parseDirectivePrint(IDLoc);
     case DK_ADDRSIG:
       return parseDirectiveAddrsig();
     case DK_ADDRSIG_SYM:
       return parseDirectiveAddrsigSym();
     case DK_PSEUDO_PROBE:
       return parseDirectivePseudoProbe();
+    case DK_MOUDLE:
+      return parseDirectiveModule();
+    case DK_LTO_DISCARD:
+      return parseDirectiveLTODiscard();
     }
 
     return Error(IDLoc, "unknown directive");
   }
 
   // __asm _emit or __asm __emit
   if (ParsingMSInlineAsm && (IDVal == "_emit" || IDVal == "__emit" ||
                              IDVal == "_EMIT" || IDVal == "__EMIT"))
bool AsmParser::parseAssignment(StringRef Name, bool allow_redef,
 
   if (!Sym) {
     // In the case where we parse an expression starting with a '.', we will
     // not generate an error, nor will we create a symbol.  In this case we
     // should just return out.
     return false;
   }
 
+  if (discardLTOSymbol(Name))
+    return false;
+
   // Do the assignment.
   Out.emitAssignment(Sym, Value);
   if (NoDeadStrip)
     Out.emitSymbolAttribute(Sym, MCSA_NoDeadStrip);
 
   return false;
 }
 
void AsmParser::initializeDirectiveKindMap() {
   DirectiveKindMap[".ds.p"] = DK_DS_P;
   DirectiveKindMap[".ds.s"] = DK_DS_S;
   DirectiveKindMap[".ds.w"] = DK_DS_W;
   DirectiveKindMap[".ds.x"] = DK_DS_X;
   DirectiveKindMap[".print"] = DK_PRINT;
   DirectiveKindMap[".addrsig"] = DK_ADDRSIG;
   DirectiveKindMap[".addrsig_sym"] = DK_ADDRSIG_SYM;
   DirectiveKindMap[".pseudoprobe"] = DK_PSEUDO_PROBE;
+  DirectiveKindMap[".module"] = DK_MOUDLE;
+  DirectiveKindMap[".lto_discard"] = DK_LTO_DISCARD;
 }
 
 MCAsmMacro *AsmParser::parseMacroLikeBody(SMLoc DirectiveLoc) {
   AsmToken EndToken, StartToken = getTok();
 
   unsigned NestLevel = 0;
   while (true) {
     // Check whether we have reached the end of the file.
bool AsmParser::parseDirectivePseudoProbe() {
 
   if (parseEOL())
     return true;
 
   getStreamer().emitPseudoProbe(Guid, Index, Type, Attr, InlineStack);
   return false;
 }
 
+bool AsmParser::parseDirectiveModule() {
+  if (parseEOL())
+    return true;
+  LTODiscardSymbols.clear();
+  return false;
+}
+
+/// parseDirectiveLTODiscard
+///  ::= ".lto_discard" [ identifier ( , identifier )* ]
+bool AsmParser::parseDirectiveLTODiscard() {
+  auto parseOp = [&]() -> bool {
+    StringRef Name;
+    SMLoc Loc = getTok().getLoc();
+    if (parseIdentifier(Name))
+      return Error(Loc, "expected identifier");
+    if (EnableLTODiscardSymbols)
+      LTODiscardSymbols.insert(Name);
+    return false;
+  };
+
+  if (parseMany(parseOp))
+    return addErrorSuffix(" in directive");
+  return false;
+}
+
 // We are comparing pointers, but the pointers are relative to a single string.
 // Thus, this should always be deterministic.
 static int rewritesSort(const AsmRewrite *AsmRewriteA,
                         const AsmRewrite *AsmRewriteB) {
   if (AsmRewriteA->Loc.getPointer() < AsmRewriteB->Loc.getPointer())
     return -1;
   if (AsmRewriteB->Loc.getPointer() < AsmRewriteA->Loc.getPointer())
     return 1;

llvm/lib/MC/MCParser/ELFAsmParser.cpp

bool ELFAsmParser::ParseDirectiveSymbolAttribute(StringRef Directive, SMLoc) {
   assert(Attr != MCSA_Invalid && "unexpected symbol attribute directive!");
   if (getLexer().isNot(AsmToken::EndOfStatement)) {
     while (true) {
       StringRef Name;
 
       if (getParser().parseIdentifier(Name))
         return TokError("expected identifier in directive");
 
+      if (getParser().discardLTOSymbol(Name)) {
+        if (getLexer().is(AsmToken::EndOfStatement))
+          break;
+        continue;
+      }
+
       MCSymbol *Sym = getContext().getOrCreateSymbol(Name);
 
       getStreamer().emitSymbolAttribute(Sym, Attr);
 
       if (getLexer().is(AsmToken::EndOfStatement))
         break;
 
       if (getLexer().isNot(AsmToken::Comma))

llvm/test/LTO/X86/weak-asm.ll

+; Check that non-prevailing symbols in module inline assembly are discarded
+; during regular LTO otherwise the final symbol binding could be wrong.
+
+; RUN: split-file %s %t
+; RUN: opt %t/t1.ll -o %t1
+; RUN: opt %t/t2.ll -o %t2
+; RUN: opt %t/t3.ll -o %t3
+
+; RUN: llvm-lto2 run -o %to1 -save-temps %t1 %t2 \
+; RUN:  -r %t1,foo,px \
+; RUN:  -r %t2,foo, \
+; RUN:  -r %t2,bar,pl
+; RUN: llvm-dis < %to1.0.0.preopt.bc -o - | FileCheck %s --check-prefix=ASM1
+; RUN: llvm-nm %to1.0 | FileCheck %s --check-prefix=SYM
+; RUN: llvm-objdump -d --disassemble-symbols=foo %to1.0 \
+; RUN:   | FileCheck %s --check-prefix=DEF
+
+; RUN: llvm-lto2 run -o %to2 -save-temps %t2 %t3 \
+; RUN:  -r %t2,foo, \
+; RUN:  -r %t2,bar,pl \
+; RUN:  -r %t3,foo,px
+; RUN: llvm-dis < %to2.0.0.preopt.bc -o - | FileCheck %s --check-prefix=ASM2
+; RUN: llvm-nm %to2.0 | FileCheck %s --check-prefix=SYM
+; RUN: llvm-objdump -d --disassemble-symbols=foo %to2.0 \
+; RUN:   | FileCheck %s --check-prefix=DEF
+
+; ASM1:      module asm ".module"
+; ASM1-NEXT: module asm ".lto_discard foo"
+; ASM1-NEXT: module asm ".weak foo"
+; ASM1-NEXT: module asm ".equ foo,bar"
+
+; ASM2:      module asm ".module"
+; ASM2-NEXT: module asm ".lto_discard foo"
+; ASM2-NEXT: module asm ".weak foo"
+; ASM2-NEXT: module asm ".equ foo,bar"
+; ASM2-NEXT: module asm ".module"
+; ASM2-NEXT: module asm " .global foo ; foo: leal    2(%rdi), %eax"
+
+; SYM: T foo
+
+; DEF: leal    2(%rdi), %eax
+
+;--- t1.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+define dso_local i32 @foo(i32 %0) {
+  %2 = add nsw i32 %0, 2
+  ret i32 %2
+}
+
+;--- t2.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+module asm ".weak foo"
+module asm ".equ foo,bar"
+
[e-mail] = appending global [1 x i8*] [i8* bitcast (i32 (i32)* @bar to i8*)], section "llvm.metadata"
+
+define internal i32 @bar(i32 %0) {
+  %2 = add nsw i32 %0, 1
+  ret i32 %2
+}
+
+;--- t3.ll
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+module asm " .global foo ; foo: leal    2(%rdi), %eax"