[lld] [LinkerScript] Handle symbols defined in linker scripts

[rafaelauler]

Summary

This patch plays on top of D8157 because it needs the expression
evaluation mechanism working in DefaultLayout.

Puts symbols defined in linker script expressions in a runtime file that is
added as input to the resolver, making the input object files see symbols
defined in linker scripts.

[ruiu]

It looks like you added absolute symbols in the writer, so these absolute symbols don't exist when symbol names are resolved. For example, if your hello world program has a reference to MYSTRING, it fails to link. Is this what you expected?

[rafaelauler]

For now I just used the same mechanism used to add other linker-defined symbols such as _bss_start, etc. I plan to later change this to be more precise.

BTW the linking does not fail, I tested it with another test case that actually depended on MYSTRING and it worked. Not sure if this is the expected behavior though, as I said, I just mimicked the behavior for other linker-defined symbols.

[rafaelauler]

Oh you meant, the linking will fail because it is done in the writer (a final step)? No, this is added before the resolver gets called.

[ruiu]

Ah, I missed that point. You added symbols to Runtime file, so they are present when the core linker works. LGTM.

[davide]

JFYI, handling of aforementioned symbols isn't completely correct. See D8241 for details.

[rafaelauler]

Thanks for pointing out Davide, I saw this patch. But there are two things that are not correct in init_array:

First, lld couldn't resolve the correct address of init array. This does not affect my patch because I get my addresses from the linker script symbol table.

Second, the symbol is ABS in lld, but in GNU ld it is not. This also happens for symbols defined in linker scripts. As I mentioned, I plan to later change this to emulate the behaviour of GNU ld. However, I'm not sure if this is strictly necessary. I'll do this when I find a test case that proved LLD's way to be incorrect.

[davide]

Yeah, that's definitely lower priority. The patch looks good to me otherwise, please go for it. I have an use case for this patch in FreeBSD.

[davide]

Can this be closed?

include/lld/ReaderWriter/ELFLinkingContext.h

public:
   void setCollectStats(bool s) { _collectStats = s; }
 
   // --wrap option.
   void addWrapForSymbol(StringRef sym) { _wrapCalls.insert(sym); }
 
   const llvm::StringSet<> &wrapCalls() const { return _wrapCalls; }
 
   script::Sema &linkerScriptSema() { return _linkerScriptSema; }
+  const script::Sema &linkerScriptSema() const { return _linkerScriptSema; }
 
 private:
   ELFLinkingContext() = delete;
 
 protected:
   ELFLinkingContext(llvm::Triple, std::unique_ptr<TargetHandlerBase>);
 
   Writer &writer() const override;

include/lld/ReaderWriter/LinkerScript.h

 #define LLD_READER_WRITER_LINKER_SCRIPT_H
 
 #include "lld/Core/Error.h"
 #include "lld/Core/LLVM.h"
 #include "lld/Core/range.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <system_error>
 #include <unordered_map>
public:
   /// to the same set of expressions because of wildcards rules.
   std::vector<const SymbolAssignment *> getExprs(const SectionKey &key);
 
   /// Evaluate a single linker script expression according to our current
   /// context (symbol table). This function is *not* constant because it can
   /// update our symbol table with new symbols calculated in this expression.
   std::error_code evalExpr(const SymbolAssignment *assgn, uint64_t &curPos);
 
+  /// Retrieve the set of symbols defined in linker script expressions.
+  const llvm::StringSet<> &getScriptDefinedSymbols() const;
+
+  /// Queries the linker script symbol table for the value of a given symbol.
+  /// This function must be called after linker script expressions evaluation
+  /// has been performed (by calling evalExpr() for all expressions).
+  uint64_t getLinkerScriptExprValue(StringRef name) const;
+
   void dump() const;
 
 private:
   /// A custom hash operator to teach the STL how to handle our custom keys.
   /// This will be used in our hash table mapping Sections to a Layout Order
   /// number (caching results).
   struct SectionKeyHash {
     int64_t operator()(const SectionKey &k) const {
private:
 
   std::vector<std::unique_ptr<Parser>> _scripts;
   std::vector<const Command *> _layoutCommands;
   std::unordered_multimap<std::string, int> _memberToLayoutOrder;
   std::vector<std::pair<StringRef, int>> _memberNameWildcards;
   mutable std::unordered_map<SectionKey, int, SectionKeyHash, SectionKeyEq>
       _cacheSectionOrder, _cacheExpressionOrder;
   llvm::DenseSet<int> _deliveredExprs;
+  mutable llvm::StringSet<> _definedSymbols;
 
   Expression::SymbolTableTy _symbolTable;
 };
 
 llvm::BumpPtrAllocator &Command::getAllocator() const {
   return _ctx.getAllocator();
 }
 llvm::BumpPtrAllocator &Expression::getAllocator() const {
   return _ctx.getAllocator();
 }
 } // end namespace script
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/DynamicLibraryWriter.h

 //===----------------------------------------------------------------------===//
 //  DynamicLibraryWriter Class
 //===----------------------------------------------------------------------===//
 template<class ELFT>
 class DynamicLibraryWriter : public OutputELFWriter<ELFT> {
 public:
   DynamicLibraryWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
       : OutputELFWriter<ELFT>(context, layout),
-        _runtimeFile(new CRuntimeFile<ELFT>(context)) {}
+        _runtimeFile(new RuntimeFile<ELFT>(context, "C runtime")) {}
 
 protected:
   virtual void buildDynamicSymbolTable(const File &file);
   virtual void addDefaultAtoms();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
   virtual void finalizeDefaultAtomValues();
 
 protected:
-  std::unique_ptr<CRuntimeFile<ELFT> > _runtimeFile;
+  std::unique_ptr<RuntimeFile<ELFT> > _runtimeFile;
 };
 
 //===----------------------------------------------------------------------===//
 //  DynamicLibraryWriter
 //===----------------------------------------------------------------------===//
 template <class ELFT>
 void DynamicLibraryWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   // Add all the defined symbols to the dynamic symbol table

lib/ReaderWriter/ELF/ELFFile.h

protected:
   /// \brief The LinkingContext.
   ELFLinkingContext &_ctx;
 
   // Wrap map
   llvm::StringMap<UndefinedAtom *> _wrapSymbolMap;
 };
 
 /// \brief All atoms are owned by a File. To add linker specific atoms
-/// the atoms need to be inserted to a file called (CRuntimeFile) which
+/// the atoms need to be inserted to a file called (RuntimeFile) which
 /// are basically additional symbols required by libc and other runtime
 /// libraries part of executing a program. This class provides support
 /// for adding absolute symbols and undefined symbols
-template <class ELFT> class CRuntimeFile : public ELFFile<ELFT> {
+template <class ELFT> class RuntimeFile : public ELFFile<ELFT> {
 public:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
-  CRuntimeFile(ELFLinkingContext &context, StringRef name = "C runtime")
+  RuntimeFile(ELFLinkingContext &context, StringRef name)
       : ELFFile<ELFT>(name, context) {}
 
   /// \brief add a global absolute atom
   virtual Atom *addAbsoluteAtom(StringRef symbolName) {
     assert(!symbolName.empty() && "AbsoluteAtoms must have a name");
     Elf_Sym *symbol = new (this->_readerStorage) Elf_Sym;
     symbol->st_name = 0;
     symbol->st_value = 0;
virtual Atom *addUndefinedAtom(StringRef symbolName) {
     symbol->setBindingAndType(llvm::ELF::STB_GLOBAL, llvm::ELF::STT_NOTYPE);
     symbol->st_other = llvm::ELF::STV_DEFAULT;
     symbol->st_size = 0;
     auto newAtom = this->handleUndefinedSymbol(symbolName, symbol);
     this->_undefinedAtoms._atoms.push_back(*newAtom);
     return *newAtom;
   }
 
-  // cannot add atoms to C Runtime file
+  // cannot add atoms to Runtime file
   virtual void addAtom(const Atom &) {
     llvm_unreachable("cannot add atoms to Runtime files");
   }
 };
 
 template <class ELFT>
 ErrorOr<std::unique_ptr<ELFFile<ELFT>>>
 ELFFile<ELFT>::create(std::unique_ptr<MemoryBuffer> mb,

lib/ReaderWriter/ELF/ExecutableWriter.h

 //===----------------------------------------------------------------------===//
 //  ExecutableWriter Class
 //===----------------------------------------------------------------------===//
 template<class ELFT>
 class ExecutableWriter : public OutputELFWriter<ELFT> {
 public:
   ExecutableWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
       : OutputELFWriter<ELFT>(context, layout),
-        _runtimeFile(new CRuntimeFile<ELFT>(context)) {}
+        _runtimeFile(new RuntimeFile<ELFT>(context, "C runtime")) {}
 
 protected:
   virtual void buildDynamicSymbolTable(const File &file);
   virtual void addDefaultAtoms();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
   virtual void finalizeDefaultAtomValues();
   virtual void createDefaultSections();
 
   virtual bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
     return this->_layout.isCopied(sla);
   }
 
   unique_bump_ptr<InterpSection<ELFT>> _interpSection;
-  std::unique_ptr<CRuntimeFile<ELFT> > _runtimeFile;
+  std::unique_ptr<RuntimeFile<ELFT> > _runtimeFile;
 };
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter
 //===----------------------------------------------------------------------===//
 template<class ELFT>
 void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   for (auto sec : this->_layout.sections())
void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
 
   OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
 }
 
 /// \brief Add absolute symbols by default. These are linker added
 /// absolute symbols
 template<class ELFT>
 void ExecutableWriter<ELFT>::addDefaultAtoms() {
+  OutputELFWriter<ELFT>::addDefaultAtoms();
   _runtimeFile->addUndefinedAtom(this->_context.entrySymbolName());
   _runtimeFile->addAbsoluteAtom("__bss_start");
   _runtimeFile->addAbsoluteAtom("__bss_end");
   _runtimeFile->addAbsoluteAtom("_end");
   _runtimeFile->addAbsoluteAtom("end");
   _runtimeFile->addAbsoluteAtom("__preinit_array_start");
   _runtimeFile->addAbsoluteAtom("__preinit_array_end");
   _runtimeFile->addAbsoluteAtom("__init_array_start");
_interpSection.reset(new (this->_alloc) InterpSection<ELFT>(
         this->_context.getInterpreter()));
     this->_layout.addSection(_interpSection.get());
   }
 }
 
 /// Finalize the value of all the absolute symbols that we
 /// created
 template <class ELFT> void ExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
+  OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
   auto bssStartAtomIter = this->_layout.findAbsoluteAtom("__bss_start");
   auto bssEndAtomIter = this->_layout.findAbsoluteAtom("__bss_end");
   auto underScoreEndAtomIter = this->_layout.findAbsoluteAtom("_end");
   auto endAtomIter = this->_layout.findAbsoluteAtom("end");
 
   auto startEnd = [&](StringRef sym, StringRef sec) -> void {
     std::string start = ("__" + sym + "_start").str();
     std::string end = ("__" + sym + "_end").str();

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h

 #include "ELFFile.h"
 
 namespace lld {
 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 class HexagonLinkingContext;
 
 template <class HexagonELFType> class HexagonRuntimeFile
-  : public CRuntimeFile<HexagonELFType> {
+  : public RuntimeFile<HexagonELFType> {
 public:
   HexagonRuntimeFile(HexagonLinkingContext &context)
-      : CRuntimeFile<HexagonELFType>(context, "Hexagon runtime file") {}
+      : RuntimeFile<HexagonELFType>(context, "Hexagon runtime file") {}
 };
 } // elf
 } // lld
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_EXECUTABLE_ATOM_H

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

private:
   MipsGOTSection<ELFType> *_gotSection;
   MipsPLTSection<ELFType> *_pltSection;
   llvm::Optional<AtomLayout *> _gpAtom;
   llvm::Optional<AtomLayout *> _gpDispAtom;
 };
 
 /// \brief Mips Runtime file.
 template <class ELFType>
-class MipsRuntimeFile final : public CRuntimeFile<ELFType> {
+class MipsRuntimeFile final : public RuntimeFile<ELFType> {
 public:
   MipsRuntimeFile(MipsLinkingContext &ctx)
-      : CRuntimeFile<ELFType>(ctx, "Mips runtime file") {}
+      : RuntimeFile<ELFType>(ctx, "Mips runtime file") {}
 };
 
 /// \brief Auxiliary class holds relocation's names table.
 class MipsRelocationStringTable {
   static const Registry::KindStrings kindStrings[];
 
 public:
   static void registerTable(Registry &registry);

lib/ReaderWriter/ELF/OutputELFWriter.h

 /// can be overridden and an appropriate writer be created
 template<class ELFT>
 class OutputELFWriter : public ELFWriter {
 public:
   typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
   typedef Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef Elf_Dyn_Impl<ELFT> Elf_Dyn;
 
-  OutputELFWriter(const ELFLinkingContext &context, TargetLayout<ELFT> &layout);
+  OutputELFWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout);
 
 protected:
   // build the sections that need to be created
   virtual void createDefaultSections();
 
   // Build all the output sections
   void buildChunks(const File &file) override;
 
protected:
   // Build the section header table
   virtual void buildSectionHeaderTable();
 
   // Assign sections that have no segments such as the symbol table,
   // section header table, string table etc
   virtual void assignSectionsWithNoSegments();
 
   // Add default atoms that need to be present in the output file
-  virtual void addDefaultAtoms() = 0;
+  virtual void addDefaultAtoms();
 
   // Add any runtime files and their atoms to the output
   bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   // Finalize the default atom values
-  virtual void finalizeDefaultAtomValues() = 0;
+  virtual void finalizeDefaultAtomValues();
 
   // This is called by the write section to apply relocations
   uint64_t addressOfAtom(const Atom *atom) override {
     auto addr = _atomToAddressMap.find(atom);
     return addr == _atomToAddressMap.end() ? 0 : addr->second;
   }
 
   // This is a hook for creating default dynamic entries
protected:
 
   /// \brief Create DT_NEEDED dynamic tage for the shared library.
   virtual bool isNeededTagRequired(const SharedLibraryAtom *sla) const {
     return false;
   }
 
   llvm::BumpPtrAllocator _alloc;
 
-  const ELFLinkingContext &_context;
+  ELFLinkingContext &_context;
   TargetHandler<ELFT> &_targetHandler;
 
   typedef llvm::DenseMap<const Atom *, uint64_t> AtomToAddress;
   AtomToAddress _atomToAddressMap;
   TargetLayout<ELFT> &_layout;
   unique_bump_ptr<ELFHeader<ELFT>> _elfHeader;
   unique_bump_ptr<ProgramHeader<ELFT>> _programHeader;
   unique_bump_ptr<SymbolTable<ELFT>> _symtab;
   unique_bump_ptr<StringTable<ELFT>> _strtab;
   unique_bump_ptr<StringTable<ELFT>> _shstrtab;
   unique_bump_ptr<SectionHeader<ELFT>> _shdrtab;
   unique_bump_ptr<EHFrameHeader<ELFT>> _ehFrameHeader;
   /// \name Dynamic sections.
   /// @{
   unique_bump_ptr<DynamicTable<ELFT>> _dynamicTable;
   unique_bump_ptr<DynamicSymbolTable<ELFT>> _dynamicSymbolTable;
   unique_bump_ptr<StringTable<ELFT>> _dynamicStringTable;
   unique_bump_ptr<HashSection<ELFT>> _hashTable;
   llvm::StringSet<> _soNeeded;
   /// @}
+  std::unique_ptr<RuntimeFile<ELFT>> _scriptFile;
 
 private:
   static StringRef maybeGetSOName(Node *node);
 };
 
 //===----------------------------------------------------------------------===//
 //  OutputELFWriter
 //===----------------------------------------------------------------------===//
 template <class ELFT>
-OutputELFWriter<ELFT>::OutputELFWriter(const ELFLinkingContext &context,
+OutputELFWriter<ELFT>::OutputELFWriter(ELFLinkingContext &context,
                                        TargetLayout<ELFT> &layout)
     : _context(context), _targetHandler(context.getTargetHandler<ELFT>()),
-      _layout(layout) {}
+      _layout(layout),
+      _scriptFile(new RuntimeFile<ELFT>(context, "Linker script runtime")) {}
 
 template <class ELFT>
 void OutputELFWriter<ELFT>::buildChunks(const File &file) {
   ScopedTask task(getDefaultDomain(), "buildChunks");
   for (const DefinedAtom *definedAtom : file.defined()) {
     DefinedAtom::ContentType contentType = definedAtom->contentType();
     // Dont add COMDAT group atoms and GNU linkonce atoms, as they are used for
     // symbol resolution.
void OutputELFWriter<ELFT>::assignSectionsWithNoSegments() {
   }
   _layout.assignFileOffsetsForMiscSections();
   for (auto sec : _layout.sections())
     if (auto section = dyn_cast<Section<ELFT>>(sec))
       if (!DefaultLayout<ELFT>::hasOutputSegment(section))
         _shdrtab->updateSection(section);
 }
 
+template <class ELFT> void OutputELFWriter<ELFT>::addDefaultAtoms() {
+  const llvm::StringSet<> &symbols =
+      _context.linkerScriptSema().getScriptDefinedSymbols();
+  for (auto &sym : symbols)
+    _scriptFile->addAbsoluteAtom(sym.getKey());
+}
+
 template <class ELFT>
 bool OutputELFWriter<ELFT>::createImplicitFiles(
-    std::vector<std::unique_ptr<File>> &) {
+    std::vector<std::unique_ptr<File>> &result) {
+  result.push_back(std::move(_scriptFile));
   return true;
 }
 
+template <class ELFT>
+void OutputELFWriter<ELFT>::finalizeDefaultAtomValues() {
+  const llvm::StringSet<> &symbols =
+      _context.linkerScriptSema().getScriptDefinedSymbols();
+  for (auto &sym : symbols) {
+    uint64_t res =
+        _context.linkerScriptSema().getLinkerScriptExprValue(sym.getKey());
+    auto a = _layout.findAbsoluteAtom(sym.getKey());
+    (*a)->_virtualAddr = res;
+  }
+}
+
 template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
   _elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_context));
   _programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_context));
   _layout.setHeader(_elfHeader.get());
   _layout.setProgramHeader(_programHeader.get());
 
   _symtab = std::move(this->createSymbolTable());
   _strtab.reset(new (_alloc) StringTable<ELFT>(

lib/ReaderWriter/LinkerScript.cpp

if (assgn->symbol() == ".") {
     curPos = result;
     return std::error_code();
   }
 
   _symbolTable[assgn->symbol()] = result;
   return std::error_code();
 }
 
+const llvm::StringSet<> &Sema::getScriptDefinedSymbols() const {
+  // Do we have cached results?
+  if (!_definedSymbols.empty())
+    return _definedSymbols;
+
+  // Populate our defined set and return it
+  for (auto cmd : _layoutCommands)
+    if (auto sa = dyn_cast<SymbolAssignment>(cmd)) {
+      StringRef symbol = sa->symbol();
+      if (!symbol.empty() && symbol != ".")
+        _definedSymbols.insert(symbol);
+    }
+
+  return _definedSymbols;
+}
+
+uint64_t Sema::getLinkerScriptExprValue(StringRef name) const {
+  auto it = _symbolTable.find(name);
+  assert (it != _symbolTable.end() && "Invalid symbol name!");
+  return it->second;
+}
+
 void Sema::dump() const {
   raw_ostream &os = llvm::outs();
   os << "Linker script semantics dump\n";
   int num = 0;
   for (auto &parser : _scripts) {
     os << "Dumping script #" << ++num << ":\n";
     parser->get()->dump(os);
     os << "\n";

test/elf/linkerscript/Inputs/simple.o.yaml

+---
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  OSABI:           ELFOSABI_GNU
+  Type:            ET_REL
+  Machine:         EM_X86_64
+Sections:        
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         B80100000048C7C70100000048C7C60000000048C7C20E0000000F05C3E8DEFFFFFFB83C0000000F05C3
+  - Name:            .rela.text
+    Type:            SHT_RELA
+    Link:            .symtab
+    AddressAlign:    0x0000000000000008
+    Info:            .text
+    Relocations:     
+      - Offset:          0x000000000000000F
+        Symbol:          .data
+        Type:            R_X86_64_32S
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         48656C6C6F2C20576F726C64210A00
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+Symbols:         
+  Local:           
+    - Name:            main
+      Section:         .text
+    - Name:            msg
+      Section:         .data
+    - Name:            .text
+      Type:            STT_SECTION
+      Section:         .text
+    - Name:            .data
+      Type:            STT_SECTION
+      Section:         .data
+    - Name:            .bss
+      Type:            STT_SECTION
+      Section:         .bss
+  Global:          
+    - Name:            _start
+      Section:         .text
+      Value:           0x000000000000001D
+...

test/elf/linkerscript/symbol-definition.test

+/*
+We test whether we can define symbols in a linker script and have them exported
+to the output file symbol table.
+
+This test uses a single X86-64 input object, simple.o, created with the
+following X86-64 assembly code:
+
+*** simple.S:
+
+(command line clang -c simple.S -o simple.o)
+
+      .text
+      main:
+        mov $1, %eax
+        movq $1, %rdi
+        movq $msg, %rsi
+        movq $14, %rdx
+        syscall
+        ret
+
+        .globl _start
+      _start:
+        call  main
+        mov $60, %eax
+        syscall
+        ret
+
+      .data
+      msg: .asciz "Hello, World!\n"
+
+
+We use the following linker script for this test:
+*/
+
+ENTRY(_start)
+
+SECTIONS
+{
+  . = 0x500000;
+  .text : { *(.text) }
+  MYSTRING = .;
+  .data : { *(.data) }
+}
+
+/*
+RUN: mkdir -p %T
+RUN: yaml2obj -format=elf %p/Inputs/simple.o.yaml -o=%T/simple.o
+
+RUN: lld -flavor gnu  -target x86_64 -T %s %T/simple.o -static -o %t1
+RUN: llvm-readobj -symbols %t1 | FileCheck -check-prefix CHECKSYMS %s
+
+CHECKSYMS:      Name: MYSTRING
+CHECKSYMS-NEXT: Value: 0x501000
+*/