llvm-6502/tools/llvm-readobj/StreamWriter.h

297 lines
7.7 KiB
C++

//===-- StreamWriter.h ----------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_LLVM_READOBJ_STREAMWRITER_H
#define LLVM_TOOLS_LLVM_READOBJ_STREAMWRITER_H
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DataTypes.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
using namespace llvm;
using namespace llvm::support;
namespace llvm {
template<typename T>
struct EnumEntry {
StringRef Name;
T Value;
};
struct HexNumber {
// To avoid sign-extension we have to explicitly cast to the appropriate
// unsigned type. The overloads are here so that every type that is implicitly
// convertible to an integer (including enums and endian helpers) can be used
// without requiring type traits or call-site changes.
HexNumber(int8_t Value) : Value(static_cast<uint8_t >(Value)) { }
HexNumber(int16_t Value) : Value(static_cast<uint16_t>(Value)) { }
HexNumber(int32_t Value) : Value(static_cast<uint32_t>(Value)) { }
HexNumber(int64_t Value) : Value(static_cast<uint64_t>(Value)) { }
HexNumber(uint8_t Value) : Value(Value) { }
HexNumber(uint16_t Value) : Value(Value) { }
HexNumber(uint32_t Value) : Value(Value) { }
HexNumber(uint64_t Value) : Value(Value) { }
uint64_t Value;
};
raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value);
class StreamWriter {
public:
StreamWriter(raw_ostream &OS)
: OS(OS)
, IndentLevel(0) {
}
void flush() {
OS.flush();
}
void indent(int Levels = 1) {
IndentLevel += Levels;
}
void unindent(int Levels = 1) {
IndentLevel = std::max(0, IndentLevel - Levels);
}
void printIndent() {
for (int i = 0; i < IndentLevel; ++i)
OS << " ";
}
template<typename T>
HexNumber hex(T Value) {
return HexNumber(Value);
}
template<typename T, typename TEnum>
void printEnum(StringRef Label, T Value,
ArrayRef<EnumEntry<TEnum> > EnumValues) {
StringRef Name;
bool Found = false;
for (const auto &EnumItem : EnumValues) {
if (EnumItem.Value == Value) {
Name = EnumItem.Name;
Found = true;
break;
}
}
if (Found) {
startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
} else {
startLine() << Label << ": " << hex(Value) << "\n";
}
}
template<typename T, typename TFlag>
void printFlags(StringRef Label, T Value, ArrayRef<EnumEntry<TFlag> > Flags,
TFlag EnumMask = TFlag(0)) {
typedef EnumEntry<TFlag> FlagEntry;
typedef SmallVector<FlagEntry, 10> FlagVector;
FlagVector SetFlags;
for (const auto &Flag : Flags) {
if (Flag.Value == 0)
continue;
bool IsEnum = (Flag.Value & EnumMask) != 0;
if ((!IsEnum && (Value & Flag.Value) == Flag.Value) ||
(IsEnum && (Value & EnumMask) == Flag.Value)) {
SetFlags.push_back(Flag);
}
}
std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
startLine() << Label << " [ (" << hex(Value) << ")\n";
for (const auto &Flag : SetFlags) {
startLine() << " " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
}
startLine() << "]\n";
}
template<typename T>
void printFlags(StringRef Label, T Value) {
startLine() << Label << " [ (" << hex(Value) << ")\n";
uint64_t Flag = 1;
uint64_t Curr = Value;
while (Curr > 0) {
if (Curr & 1)
startLine() << " " << hex(Flag) << "\n";
Curr >>= 1;
Flag <<= 1;
}
startLine() << "]\n";
}
void printNumber(StringRef Label, uint64_t Value) {
startLine() << Label << ": " << Value << "\n";
}
void printNumber(StringRef Label, uint32_t Value) {
startLine() << Label << ": " << Value << "\n";
}
void printNumber(StringRef Label, uint16_t Value) {
startLine() << Label << ": " << Value << "\n";
}
void printNumber(StringRef Label, uint8_t Value) {
startLine() << Label << ": " << unsigned(Value) << "\n";
}
void printNumber(StringRef Label, int64_t Value) {
startLine() << Label << ": " << Value << "\n";
}
void printNumber(StringRef Label, int32_t Value) {
startLine() << Label << ": " << Value << "\n";
}
void printNumber(StringRef Label, int16_t Value) {
startLine() << Label << ": " << Value << "\n";
}
void printNumber(StringRef Label, int8_t Value) {
startLine() << Label << ": " << int(Value) << "\n";
}
void printBoolean(StringRef Label, bool Value) {
startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n';
}
template <typename T_>
void printList(StringRef Label, const SmallVectorImpl<T_> &List) {
startLine() << Label << ": [";
bool Comma = false;
for (const auto &Item : List) {
if (Comma)
OS << ", ";
OS << Item;
Comma = true;
}
OS << "]\n";
}
template<typename T>
void printHex(StringRef Label, T Value) {
startLine() << Label << ": " << hex(Value) << "\n";
}
template<typename T>
void printHex(StringRef Label, StringRef Str, T Value) {
startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n";
}
void printString(StringRef Label, StringRef Value) {
startLine() << Label << ": " << Value << "\n";
}
void printString(StringRef Label, const std::string &Value) {
startLine() << Label << ": " << Value << "\n";
}
template<typename T>
void printNumber(StringRef Label, StringRef Str, T Value) {
startLine() << Label << ": " << Str << " (" << Value << ")\n";
}
void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) {
printBinaryImpl(Label, Str, Value, false);
}
void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
Value.size());
printBinaryImpl(Label, Str, V, false);
}
void printBinary(StringRef Label, ArrayRef<uint8_t> Value) {
printBinaryImpl(Label, StringRef(), Value, false);
}
void printBinary(StringRef Label, ArrayRef<char> Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
Value.size());
printBinaryImpl(Label, StringRef(), V, false);
}
void printBinary(StringRef Label, StringRef Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
Value.size());
printBinaryImpl(Label, StringRef(), V, false);
}
void printBinaryBlock(StringRef Label, StringRef Value) {
auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
Value.size());
printBinaryImpl(Label, StringRef(), V, true);
}
raw_ostream& startLine() {
printIndent();
return OS;
}
raw_ostream& getOStream() {
return OS;
}
private:
template<typename T>
static bool flagName(const EnumEntry<T>& lhs, const EnumEntry<T>& rhs) {
return lhs.Name < rhs.Name;
}
void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,
bool Block);
raw_ostream &OS;
int IndentLevel;
};
struct DictScope {
DictScope(StreamWriter& W, StringRef N) : W(W) {
W.startLine() << N << " {\n";
W.indent();
}
~DictScope() {
W.unindent();
W.startLine() << "}\n";
}
StreamWriter& W;
};
struct ListScope {
ListScope(StreamWriter& W, StringRef N) : W(W) {
W.startLine() << N << " [\n";
W.indent();
}
~ListScope() {
W.unindent();
W.startLine() << "]\n";
}
StreamWriter& W;
};
} // namespace llvm
#endif