llvm/tools/llvm-readobj/ObjDumper.cpp

   1 //===-- ObjDumper.cpp - Base dumper class -----------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 ///
   9 /// \file
  10 /// This file implements ObjDumper.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ObjDumper.h"
  15 #include "llvm-readobj.h"
  16 #include "llvm/Object/Archive.h"
  17 #include "llvm/Object/Decompressor.h"
  18 #include "llvm/Object/ObjectFile.h"
  19 #include "llvm/Support/Error.h"
  20 #include "llvm/Support/FormatVariadic.h"
  21 #include "llvm/Support/ScopedPrinter.h"
  22 #include "llvm/Support/SystemZ/zOSSupport.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <map>
  25
  26 namespace llvm {
  27
  28 static inline Error createError(const Twine &Msg) {
  29   return createStringError(object::object_error::parse_failed, Msg);
  30 }
  31
  32 ObjDumper::ObjDumper(ScopedPrinter &Writer, StringRef ObjName) : W(Writer) {
  33   // Dumper reports all non-critical errors as warnings.
  34   // It does not print the same warning more than once.
  35   WarningHandler = [=](const Twine &Msg) {
  36     if (Warnings.insert(Msg.str()).second)
  37       reportWarning(createError(Msg), ObjName);
  38     return Error::success();
  39   };
  40 }
  41
  42 ObjDumper::~ObjDumper() {}
  43
  44 void ObjDumper::reportUniqueWarning(Error Err) const {
  45   reportUniqueWarning(toString(std::move(Err)));
  46 }
  47
  48 void ObjDumper::reportUniqueWarning(const Twine &Msg) const {
  49   cantFail(WarningHandler(Msg),
  50            "WarningHandler should always return ErrorSuccess");
  51 }
  52
  53 static void printAsPrintable(raw_ostream &W, const uint8_t *Start, size_t Len) {
  54   for (size_t i = 0; i < Len; i++)
  55     W << (isPrint(Start[i]) ? static_cast<char>(Start[i]) : '.');
  56 }
  57
  58 void ObjDumper::printAsStringList(StringRef StringContent,
  59                                   size_t StringDataOffset) {
  60   size_t StrSize = StringContent.size();
  61   if (StrSize == 0)
  62     return;
  63   if (StrSize < StringDataOffset) {
  64     reportUniqueWarning("offset (0x" + Twine::utohexstr(StringDataOffset) +
  65                         ") is past the end of the contents (size 0x" +
  66                         Twine::utohexstr(StrSize) + ")");
  67     return;
  68   }
  69
  70   const uint8_t *StrContent = StringContent.bytes_begin();
  71   // Some formats contain additional metadata at the start which should not be
  72   // interpreted as strings. Skip these bytes, but account for them in the
  73   // string offsets.
  74   const uint8_t *CurrentWord = StrContent + StringDataOffset;
  75   const uint8_t *StrEnd = StringContent.bytes_end();
  76
  77   while (CurrentWord <= StrEnd) {
  78     size_t WordSize = strnlen(reinterpret_cast<const char *>(CurrentWord),
  79                               StrEnd - CurrentWord);
  80     if (!WordSize) {
  81       CurrentWord++;
  82       continue;
  83     }
  84     W.startLine() << format("[%6tx] ", CurrentWord - StrContent);
  85     printAsPrintable(W.startLine(), CurrentWord, WordSize);
  86     W.startLine() << '\n';
  87     CurrentWord += WordSize + 1;
  88   }
  89 }
  90
  91 void ObjDumper::printFileSummary(StringRef FileStr, object::ObjectFile &Obj,
  92                                  ArrayRef<std::string> InputFilenames,
  93                                  const object::Archive *A) {
  94   W.startLine() << "\n";
  95   W.printString("File", FileStr);
  96   W.printString("Format", Obj.getFileFormatName());
  97   W.printString("Arch", Triple::getArchTypeName(Obj.getArch()));
  98   W.printString("AddressSize",
  99                 std::string(formatv("{0}bit", 8 * Obj.getBytesInAddress())));
 100   this->printLoadName();
 101 }
 102
 103 static std::vector<object::SectionRef>
 104 getSectionRefsByNameOrIndex(const object::ObjectFile &Obj,
 105                             ArrayRef<std::string> Sections) {
 106   std::vector<object::SectionRef> Ret;
 107   std::map<std::string, bool> SecNames;
 108   std::map<unsigned, bool> SecIndices;
 109   unsigned SecIndex;
 110   for (StringRef Section : Sections) {
 111     if (!Section.getAsInteger(0, SecIndex))
 112       SecIndices.emplace(SecIndex, false);
 113     else
 114       SecNames.emplace(std::string(Section), false);
 115   }
 116
 117   SecIndex = Obj.isELF() ? 0 : 1;
 118   for (object::SectionRef SecRef : Obj.sections()) {
 119     StringRef SecName = unwrapOrError(Obj.getFileName(), SecRef.getName());
 120     auto NameIt = SecNames.find(std::string(SecName));
 121     if (NameIt != SecNames.end())
 122       NameIt->second = true;
 123     auto IndexIt = SecIndices.find(SecIndex);
 124     if (IndexIt != SecIndices.end())
 125       IndexIt->second = true;
 126     if (NameIt != SecNames.end() || IndexIt != SecIndices.end())
 127       Ret.push_back(SecRef);
 128     SecIndex++;
 129   }
 130
 131   for (const std::pair<const std::string, bool> &S : SecNames)
 132     if (!S.second)
 133       reportWarning(
 134           createError(formatv("could not find section '{0}'", S.first).str()),
 135           Obj.getFileName());
 136
 137   for (std::pair<unsigned, bool> S : SecIndices)
 138     if (!S.second)
 139       reportWarning(
 140           createError(formatv("could not find section {0}", S.first).str()),
 141           Obj.getFileName());
 142
 143   return Ret;
 144 }
 145
 146 static void maybeDecompress(const object::ObjectFile &Obj,
 147                             StringRef SectionName, StringRef &SectionContent,
 148                             SmallString<0> &Out) {
 149   Expected<object::Decompressor> Decompressor = object::Decompressor::create(
 150       SectionName, SectionContent, Obj.isLittleEndian(), Obj.is64Bit());
 151   if (!Decompressor)
 152     reportWarning(Decompressor.takeError(), Obj.getFileName());
 153   else if (auto Err = Decompressor->resizeAndDecompress(Out))
 154     reportWarning(std::move(Err), Obj.getFileName());
 155   else
 156     SectionContent = Out;
 157 }
 158
 159 void ObjDumper::printSectionsAsString(const object::ObjectFile &Obj,
 160                                       ArrayRef<std::string> Sections,
 161                                       bool Decompress) {
 162   SmallString<0> Out;
 163   bool First = true;
 164   for (object::SectionRef Section :
 165        getSectionRefsByNameOrIndex(Obj, Sections)) {
 166     StringRef SectionName = unwrapOrError(Obj.getFileName(), Section.getName());
 167
 168     if (!First)
 169       W.startLine() << '\n';
 170     First = false;
 171     W.startLine() << "String dump of section '" << SectionName << "':\n";
 172
 173     StringRef SectionContent =
 174         unwrapOrError(Obj.getFileName(), Section.getContents());
 175     if (Decompress && Section.isCompressed())
 176       maybeDecompress(Obj, SectionName, SectionContent, Out);
 177     printAsStringList(SectionContent);
 178   }
 179 }
 180
 181 void ObjDumper::printSectionsAsHex(const object::ObjectFile &Obj,
 182                                    ArrayRef<std::string> Sections,
 183                                    bool Decompress) {
 184   SmallString<0> Out;
 185   bool First = true;
 186   for (object::SectionRef Section :
 187        getSectionRefsByNameOrIndex(Obj, Sections)) {
 188     StringRef SectionName = unwrapOrError(Obj.getFileName(), Section.getName());
 189
 190     if (!First)
 191       W.startLine() << '\n';
 192     First = false;
 193     W.startLine() << "Hex dump of section '" << SectionName << "':\n";
 194
 195     StringRef SectionContent =
 196         unwrapOrError(Obj.getFileName(), Section.getContents());
 197     if (Decompress && Section.isCompressed())
 198       maybeDecompress(Obj, SectionName, SectionContent, Out);
 199     const uint8_t *SecContent = SectionContent.bytes_begin();
 200     const uint8_t *SecEnd = SecContent + SectionContent.size();
 201
 202     for (const uint8_t *SecPtr = SecContent; SecPtr < SecEnd; SecPtr += 16) {
 203       const uint8_t *TmpSecPtr = SecPtr;
 204       uint8_t i;
 205       uint8_t k;
 206
 207       W.startLine() << format_hex(Section.getAddress() + (SecPtr - SecContent),
 208                                   10);
 209       W.startLine() << ' ';
 210       for (i = 0; TmpSecPtr < SecEnd && i < 4; ++i) {
 211         for (k = 0; TmpSecPtr < SecEnd && k < 4; k++, TmpSecPtr++) {
 212           uint8_t Val = *(reinterpret_cast<const uint8_t *>(TmpSecPtr));
 213           W.startLine() << format_hex_no_prefix(Val, 2);
 214         }
 215         W.startLine() << ' ';
 216       }
 217
 218       // We need to print the correct amount of spaces to match the format.
 219       // We are adding the (4 - i) last rows that are 8 characters each.
 220       // Then, the (4 - i) spaces that are in between the rows.
 221       // Least, if we cut in a middle of a row, we add the remaining characters,
 222       // which is (8 - (k * 2)).
 223       if (i < 4)
 224         W.startLine() << format("%*c", (4 - i) * 8 + (4 - i), ' ');
 225       if (k < 4)
 226         W.startLine() << format("%*c", 8 - k * 2, ' ');
 227
 228       TmpSecPtr = SecPtr;
 229       for (i = 0; TmpSecPtr + i < SecEnd && i < 16; ++i)
 230         W.startLine() << (isPrint(TmpSecPtr[i])
 231                               ? static_cast<char>(TmpSecPtr[i])
 232                               : '.');
 233
 234       W.startLine() << '\n';
 235     }
 236   }
 237 }
 238
 239 } // namespace llvm