xref: /freebsd/contrib/llvm-project/llvm/tools/llvm-readobj/ObjDumper.cpp (revision 439352ac8257c8419cb4a662abb7f260f31f9932)
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
240