2017-06-16 06:24:24 +08:00
|
|
|
//===- FormatUtil.h ------------------------------------------- *- C++ --*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef LLVM_TOOLS_LLVMPDBUTIL_FORMAT_UTIL_H
|
|
|
|
#define LLVM_TOOLS_LLVMPDBUTIL_FORMAT_UTIL_H
|
|
|
|
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
2017-08-21 22:53:25 +08:00
|
|
|
#include "llvm/DebugInfo/CodeView/CodeView.h"
|
2017-06-16 06:24:24 +08:00
|
|
|
#include "llvm/Support/Endian.h"
|
|
|
|
#include "llvm/Support/FormatAdapters.h"
|
|
|
|
#include "llvm/Support/FormatVariadic.h"
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
#include <type_traits>
|
|
|
|
|
|
|
|
namespace llvm {
|
|
|
|
namespace pdb {
|
|
|
|
|
2017-07-06 05:54:58 +08:00
|
|
|
std::string truncateStringBack(StringRef S, uint32_t MaxLen);
|
[llvm-pdbutil] Improve diff mode.
We're getting to the point that some MS tools (e.g. DIA) can recognize
our PDBs but others (e.g. link.exe) cannot. I think the way forward is
to improve our tooling to help us find differences more easily. For
example, if we can compile the same program with clang-cl and cl and
have a tool tell us all the places where the PDBs differ, this could
tell us what we're doing wrong. It's tricky though, because there are a
lot of "benign" differences in a PDB. For example, if the string table
in one PDB consists of "foo" followed by "bar" and in the other PDB it
consists of "bar" followed by "foo", this is not necessarily a critical
difference, as long as the uses of these strings also refer to the
correct location. On the other hand, if the second PDB doesn't even
contain the string "foo" at all, this is a critical difference.
diff mode has been in llvm-pdbutil for quite a while, but because of the
above challenge along with some others, it's been hard to make it
useful. I think this patch addresses that. It looks for all the same
things, but it now prints the output in tabular format (carefully
formatted and aligned into tables and fields), and it highlights
critical differences in red, non-critical differences in yellow, and
identical fields in green. This makes it easy to spot the places we
differ, and the general concept of outputting arbitrary fields in
tabular format can be extended to provide analysis into many of the
different types of information that show up in a PDB.
Differential Revision: https://reviews.llvm.org/D35039
llvm-svn: 307421
2017-07-08 02:45:37 +08:00
|
|
|
std::string truncateStringMiddle(StringRef S, uint32_t MaxLen);
|
2017-07-06 13:33:32 +08:00
|
|
|
std::string truncateStringFront(StringRef S, uint32_t MaxLen);
|
2017-07-06 05:54:58 +08:00
|
|
|
std::string truncateQuotedNameFront(StringRef Label, StringRef Name,
|
|
|
|
uint32_t MaxLen);
|
|
|
|
std::string truncateQuotedNameBack(StringRef Label, StringRef Name,
|
|
|
|
uint32_t MaxLen);
|
|
|
|
|
2017-06-16 06:24:24 +08:00
|
|
|
#define PUSH_MASKED_FLAG(Enum, Mask, TheOpt, Value, Text) \
|
|
|
|
if (Enum::TheOpt == (Value & Mask)) \
|
|
|
|
Opts.push_back(Text);
|
|
|
|
|
|
|
|
#define PUSH_FLAG(Enum, TheOpt, Value, Text) \
|
|
|
|
PUSH_MASKED_FLAG(Enum, Enum::TheOpt, TheOpt, Value, Text)
|
|
|
|
|
|
|
|
#define RETURN_CASE(Enum, X, Ret) \
|
|
|
|
case Enum::X: \
|
|
|
|
return Ret;
|
|
|
|
|
2017-07-06 13:33:32 +08:00
|
|
|
template <typename T> std::string formatUnknownEnum(T Value) {
|
2017-06-16 06:24:24 +08:00
|
|
|
return formatv("unknown ({0})",
|
|
|
|
static_cast<typename std::underlying_type<T>::type>(Value))
|
|
|
|
.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::string formatSegmentOffset(uint16_t Segment, uint32_t Offset);
|
|
|
|
|
2017-08-12 04:46:28 +08:00
|
|
|
enum class CharacteristicStyle {
|
|
|
|
HeaderDefinition, // format as windows header definition
|
|
|
|
Descriptive, // format as human readable words
|
|
|
|
};
|
|
|
|
std::string formatSectionCharacteristics(
|
|
|
|
uint32_t IndentLevel, uint32_t C, uint32_t FlagsPerLine,
|
|
|
|
StringRef Separator,
|
|
|
|
CharacteristicStyle Style = CharacteristicStyle::HeaderDefinition);
|
|
|
|
|
2017-06-16 06:24:24 +08:00
|
|
|
std::string typesetItemList(ArrayRef<std::string> Opts, uint32_t IndentLevel,
|
|
|
|
uint32_t GroupSize, StringRef Sep);
|
|
|
|
|
|
|
|
std::string typesetStringList(uint32_t IndentLevel,
|
|
|
|
ArrayRef<StringRef> Strings);
|
|
|
|
|
2017-08-21 22:53:25 +08:00
|
|
|
std::string formatChunkKind(codeview::DebugSubsectionKind Kind,
|
|
|
|
bool Friendly = true);
|
|
|
|
std::string formatSymbolKind(codeview::SymbolKind K);
|
2017-09-01 04:43:22 +08:00
|
|
|
StringRef formatTypeLeafKind(codeview::TypeLeafKind K);
|
2017-08-21 22:53:25 +08:00
|
|
|
|
2017-06-16 06:24:24 +08:00
|
|
|
/// Returns the number of digits in the given integer.
|
|
|
|
inline int NumDigits(uint64_t N) {
|
|
|
|
if (N < 10ULL)
|
|
|
|
return 1;
|
|
|
|
if (N < 100ULL)
|
|
|
|
return 2;
|
|
|
|
if (N < 1000ULL)
|
|
|
|
return 3;
|
|
|
|
if (N < 10000ULL)
|
|
|
|
return 4;
|
|
|
|
if (N < 100000ULL)
|
|
|
|
return 5;
|
|
|
|
if (N < 1000000ULL)
|
|
|
|
return 6;
|
|
|
|
if (N < 10000000ULL)
|
|
|
|
return 7;
|
|
|
|
if (N < 100000000ULL)
|
|
|
|
return 8;
|
|
|
|
if (N < 1000000000ULL)
|
|
|
|
return 9;
|
|
|
|
if (N < 10000000000ULL)
|
|
|
|
return 10;
|
|
|
|
if (N < 100000000000ULL)
|
|
|
|
return 11;
|
|
|
|
if (N < 1000000000000ULL)
|
|
|
|
return 12;
|
|
|
|
if (N < 10000000000000ULL)
|
|
|
|
return 13;
|
|
|
|
if (N < 100000000000000ULL)
|
|
|
|
return 14;
|
|
|
|
if (N < 1000000000000000ULL)
|
|
|
|
return 15;
|
|
|
|
if (N < 10000000000000000ULL)
|
|
|
|
return 16;
|
|
|
|
if (N < 100000000000000000ULL)
|
|
|
|
return 17;
|
|
|
|
if (N < 1000000000000000000ULL)
|
|
|
|
return 18;
|
|
|
|
if (N < 10000000000000000000ULL)
|
|
|
|
return 19;
|
|
|
|
return 20;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace detail {
|
|
|
|
template <typename T>
|
|
|
|
struct EndianAdapter final
|
|
|
|
: public FormatAdapter<support::detail::packed_endian_specific_integral<
|
|
|
|
T, support::little, support::unaligned>> {
|
|
|
|
using EndianType =
|
|
|
|
support::detail::packed_endian_specific_integral<T, support::little,
|
|
|
|
support::unaligned>;
|
|
|
|
|
|
|
|
explicit EndianAdapter(EndianType &&Item)
|
|
|
|
: FormatAdapter<EndianType>(std::move(Item)) {}
|
|
|
|
|
|
|
|
void format(llvm::raw_ostream &Stream, StringRef Style) {
|
|
|
|
format_provider<T>::format(static_cast<T>(this->Item), Stream, Style);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
detail::EndianAdapter<T>
|
|
|
|
fmtle(support::detail::packed_endian_specific_integral<T, support::little,
|
|
|
|
support::unaligned>
|
|
|
|
Value) {
|
|
|
|
return detail::EndianAdapter<T>(std::move(Value));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} // namespace llvm
|
|
|
|
#endif
|