llvm-symbolizer: teach it about PowerPC64 ELF function descriptors

[foad]

Summary

Teach llvm-symbolizer about PowerPC64 ELF function descriptors. Symbols in the .opd section point to function descriptors, the first word of which is a pointer to the real function. For the purposes of symbolizing we pretend that the symbol points directly to the function.

This is enough to get decent function names in stack traces for unoptimized binaries, which fixes the sanitizer print-stack-trace test on PowerPC64 Linux.

[samsonov]

Thank you for working on this! Please make sure to add a test case in LLVM testsuite as well (it should go to somewhere like test/tools/llvm-symbolizer). Probably the test case would be a tiny powerpc64 binary with no debug info, so that we can ensure we fetch the function name from symbol table correctly.

tools/llvm-symbolizer/LLVMSymbolize.cpp

49

Consider the following approach: if Module->getArch() is Triple::ppc64 (should we also treat Triple::ppc64le?), and you have an .opd section, create a DataExtractor. Then you can pass this DataExtractor down to addSymbol() as an optional argument, and fetch the actual addresses of functions there. It looks weird to create DataExtractor for each and every of thousands of symbols.

106

You can use DataExtractor::getAddress() instead. Consider using isValidOffsetForDataOfSize to verify that the offset into .opd is valid.

tools/llvm-symbolizer/LLVMSymbolize.h

139

This member doesn't look to be required - Functions and Objects maps are built in the constructor, and you only need this section in "addSymbol" implementation.

[foad]

Address Alexey's comments.

[foad]

In D6110#4, @samsonov wrote:

Consider the following approach: if Module->getArch() is Triple::ppc64 (should we also treat Triple::ppc64le?)

There's no need to do this for ppc64le, because it uses the "ELFv2" ABI which doesn't have function descriptors.

[foad]

Inline comment.

tools/llvm-symbolizer/LLVMSymbolize.cpp

91–92

I realise this is a bit ugly. As an alternative I could update DataExtractor::isValidOffset{,ForDataOfSize} to take 64-bit offsets.

[samsonov]

tools/llvm-symbolizer/LLVMSymbolize.cpp

58

I'd prefer Module->isLittleEndian() here.

91

You can then hide this whole block under

if (OpdExtractor) {}

91–92

Yeah, but let's fix DataExtractor later. Note that you can also compare OpdOffset with "uint32_t Offset" you declare below.

tools/llvm-symbolizer/LLVMSymbolize.h

121

Consider making OpdExtractor argument a raw pointer - it is really optional, and you shouldn't need to create DataExtractor object if it's not needed.

[foad]

Change addSymbol to take a (possibly null) pointer instead of a
reference to the DataExtractor.

[samsonov]

LGTM, thanks!

tools/llvm-symbolizer/LLVMSymbolize.cpp

60

Put this under the if-statement, where you define OpdExtractor.

[foad]

• Put assignment to OpdAddress inside the if.
• Use nullptr instead of 0.

include/llvm/Support/DataExtractor.h

public:
   /// Test the availability of \a length bytes of data from \a offset.
   ///
   /// @return
   ///     \b true if \a offset is a valid offset and there are \a
   ///     length bytes available at that offset, \b false otherwise.
   bool isValidOffsetForDataOfSize(uint32_t offset, uint32_t length) const {
     return offset + length >= offset && isValidOffset(offset + length - 1);
   }
+
+  /// Test the availability of enough bytes of data for a pointer from
+  /// \a offset. The size of a pointer is \a getAddressSize().
+  ///
+  /// @return
+  ///     \b true if \a offset is a valid offset and there are enough
+  ///     bytes for a pointer available at that offset, \b false
+  ///     otherwise.
+  bool isValidOffsetForAddress(uint32_t offset) const {
+    return isValidOffsetForDataOfSize(offset, AddressSize);
+  }
 };
 
 } // namespace llvm
 
 #endif

test/tools/llvm-symbolizer/ppc64.test

+// ppc64 was compiled from this source on a big-endian 64-bit PowerPC box
+// with just "clang -nostdlib":
+int foo() { return 0; }
+int bar() { return foo(); }
+int _start() { return bar(); }
+
+RUN: ( echo 0x1000014c ; echo 0x1000018c ; echo 0x100001cc ) | llvm-symbolizer -obj=%p/Inputs/ppc64 | FileCheck %s
+
+CHECK: foo
+CHECK: bar
+CHECK: _start

tools/llvm-symbolizer/LLVMSymbolize.h

 //===----------------------------------------------------------------------===//
 #ifndef LLVM_TOOLS_LLVM_SYMBOLIZER_LLVMSYMBOLIZE_H
 #define LLVM_TOOLS_LLVM_SYMBOLIZER_LLVMSYMBOLIZE_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <map>
 #include <memory>
 #include <string>
 
 namespace llvm {
 
 typedef DILineInfoSpecifier::FunctionNameKind FunctionNameKind;
DIInliningInfo symbolizeInlinedCode(
       uint64_t ModuleOffset, const LLVMSymbolizer::Options &Opts) const;
   bool symbolizeData(uint64_t ModuleOffset, std::string &Name, uint64_t &Start,
                      uint64_t &Size) const;
 
 private:
   bool getNameFromSymbolTable(SymbolRef::Type Type, uint64_t Address,
                               std::string &Name, uint64_t &Addr,
                               uint64_t &Size) const;
-  void addSymbol(const SymbolRef &Symbol);
+  // For big-endian PowerPC64 ELF, OpdAddress is the address of the .opd
+  // (function descriptor) section and OpdExtractor refers to its contents.
+  void addSymbol(const SymbolRef &Symbol,
+                 DataExtractor *OpdExtractor = nullptr,
+                 uint64_t OpdAddress = 0);
   ObjectFile *Module;
   std::unique_ptr<DIContext> DebugInfoContext;
 
   struct SymbolDesc {
     uint64_t Addr;
     // If size is 0, assume that symbol occupies the whole memory range up to
     // the following symbol.
     uint64_t Size;
     friend bool operator<(const SymbolDesc &s1, const SymbolDesc &s2) {
       return s1.Addr < s2.Addr;
     }
   };
   std::map<SymbolDesc, StringRef> Functions;
   std::map<SymbolDesc, StringRef> Objects;
 };
 
 } // namespace symbolize
 } // namespace llvm
 
 #endif

tools/llvm-symbolizer/LLVMSymbolize.cpp

 getDILineInfoSpecifier(const LLVMSymbolizer::Options &Opts) {
   return DILineInfoSpecifier(
       DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
       Opts.PrintFunctions);
 }
 
 ModuleInfo::ModuleInfo(ObjectFile *Obj, DIContext *DICtx)
     : Module(Obj), DebugInfoContext(DICtx) {
+  std::unique_ptr<DataExtractor> OpdExtractor;
+  uint64_t OpdAddress = 0;
+  // Find the .opd (function descriptor) section if any, for big-endian
+  // PowerPC64 ELF.
+  if (Module->getArch() == Triple::ppc64) {
+    for (section_iterator Section : Module->sections()) {
+      StringRef Name;
+      if (!error(Section->getName(Name)) && Name == ".opd") {
+        StringRef Data;
+        if (!error(Section->getContents(Data))) {
+          OpdExtractor.reset(new DataExtractor(Data, Module->isLittleEndian(),
+                                               Module->getBytesInAddress()));
+          OpdAddress = Section->getAddress();
+        }
+        break;
+      }
+    }
+  }
   for (const SymbolRef &Symbol : Module->symbols()) {
-    addSymbol(Symbol);
+    addSymbol(Symbol, OpdExtractor.get(), OpdAddress);
   }
   bool NoSymbolTable = (Module->symbol_begin() == Module->symbol_end());
   if (NoSymbolTable && Module->isELF()) {
     // Fallback to dynamic symbol table, if regular symbol table is stripped.
     std::pair<symbol_iterator, symbol_iterator> IDyn =
         getELFDynamicSymbolIterators(Module);
     for (symbol_iterator si = IDyn.first, se = IDyn.second; si != se; ++si) {
-      addSymbol(*si);
+      addSymbol(*si, OpdExtractor.get(), OpdAddress);
     }
   }
 }
 
-void ModuleInfo::addSymbol(const SymbolRef &Symbol) {
+void ModuleInfo::addSymbol(const SymbolRef &Symbol, DataExtractor *OpdExtractor,
+                           uint64_t OpdAddress) {
   SymbolRef::Type SymbolType;
   if (error(Symbol.getType(SymbolType)))
     return;
   if (SymbolType != SymbolRef::ST_Function && SymbolType != SymbolRef::ST_Data)
     return;
   uint64_t SymbolAddress;
   if (error(Symbol.getAddress(SymbolAddress)) ||
       SymbolAddress == UnknownAddressOrSize)
     return;
+  if (OpdExtractor) {
+    // For big-endian PowerPC64 ELF, symbols in the .opd section refer to
+    // function descriptors. The first word of the descriptor is a pointer to
+    // the function's code.
+    // For the purposes of symbolization, pretend the symbol's address is that
+    // of the function's code, not the descriptor.
+    uint64_t OpdOffset = SymbolAddress - OpdAddress;
+    uint32_t OpdOffset32 = OpdOffset;
+    if (OpdOffset == OpdOffset32 && 
+        OpdExtractor->isValidOffsetForAddress(OpdOffset32))
+      SymbolAddress = OpdExtractor->getAddress(&OpdOffset32);
+  }
   uint64_t SymbolSize;
   // Getting symbol size is linear for Mach-O files, so assume that symbol
   // occupies the memory range up to the following symbol.
   if (isa<MachOObjectFile>(Module))
     SymbolSize = 0;
   else if (error(Symbol.getSize(SymbolSize)) ||
            SymbolSize == UnknownAddressOrSize)
     return;
   StringRef SymbolName;
   if (error(Symbol.getName(SymbolName)))
     return;
   // Mach-O symbol table names have leading underscore, skip it.