tools/llvm-readobj/StreamWriter.h

   1 //===-- StreamWriter.h ----------------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLVM_READOBJ_STREAMWRITER_H
  11 #define LLVM_READOBJ_STREAMWRITER_H
  12
  13 #include "llvm/ADT/ArrayRef.h"
  14 #include "llvm/ADT/SmallVector.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/Support/DataTypes.h"
  17 #include "llvm/Support/Endian.h"
  18 #include "llvm/Support/raw_ostream.h"
  19 #include <algorithm>
  20
  21 using namespace llvm;
  22 using namespace llvm::support;
  23
  24 namespace llvm {
  25
  26 template<typename T>
  27 struct EnumEntry {
  28   StringRef Name;
  29   T Value;
  30 };
  31
  32 struct HexNumber {
  33   // To avoid sign-extension we have to explicitly cast to the appropriate
  34   // unsigned type. The overloads are here so that every type that is implicitly
  35   // convertible to an integer (including enums and endian helpers) can be used
  36   // without requiring type traits or call-site changes.
  37   HexNumber(int8_t   Value) : Value(static_cast<uint8_t >(Value)) { }
  38   HexNumber(int16_t  Value) : Value(static_cast<uint16_t>(Value)) { }
  39   HexNumber(int32_t  Value) : Value(static_cast<uint32_t>(Value)) { }
  40   HexNumber(int64_t  Value) : Value(static_cast<uint64_t>(Value)) { }
  41   HexNumber(uint8_t  Value) : Value(Value) { }
  42   HexNumber(uint16_t Value) : Value(Value) { }
  43   HexNumber(uint32_t Value) : Value(Value) { }
  44   HexNumber(uint64_t Value) : Value(Value) { }
  45   uint64_t Value;
  46 };
  47
  48 raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value);
  49
  50 class StreamWriter {
  51 public:
  52   StreamWriter(raw_ostream &OS)
  53     : OS(OS)
  54     , IndentLevel(0) {
  55   }
  56
  57   void flush() {
  58     OS.flush();
  59   }
  60
  61   void indent(int Levels = 1) {
  62     IndentLevel += Levels;
  63   }
  64
  65   void unindent(int Levels = 1) {
  66     IndentLevel = std::max(0, IndentLevel - Levels);
  67   }
  68
  69   void printIndent() {
  70     for (int i = 0; i < IndentLevel; ++i)
  71       OS << "  ";
  72   }
  73
  74   template<typename T>
  75   HexNumber hex(T Value) {
  76     return HexNumber(Value);
  77   }
  78
  79   template<typename T, typename TEnum>
  80   void printEnum(StringRef Label, T Value,
  81                  ArrayRef<EnumEntry<TEnum> > EnumValues) {
  82     StringRef Name;
  83     bool Found = false;
  84     for (size_t i = 0; i < EnumValues.size(); ++i) {
  85       if (EnumValues[i].Value == Value) {
  86         Name = EnumValues[i].Name;
  87         Found = true;
  88         break;
  89       }
  90     }
  91
  92     if (Found) {
  93       startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
  94     } else {
  95       startLine() << Label << ": " << hex(Value) << "\n";
  96     }
  97   }
  98
  99   template<typename T, typename TFlag>
 100   void printFlags(StringRef Label, T Value, ArrayRef<EnumEntry<TFlag> > Flags,
 101                   TFlag EnumMask = TFlag(0)) {
 102     typedef EnumEntry<TFlag> FlagEntry;
 103     typedef SmallVector<FlagEntry, 10> FlagVector;
 104     FlagVector SetFlags;
 105
 106     for (typename ArrayRef<FlagEntry>::const_iterator I = Flags.begin(),
 107                                                  E = Flags.end(); I != E; ++I) {
 108       if (I->Value == 0)
 109         continue;
 110
 111       bool IsEnum = (I->Value & EnumMask) != 0;
 112       if ((!IsEnum && (Value & I->Value) == I->Value) ||
 113           (IsEnum  && (Value & EnumMask) == I->Value)) {
 114         SetFlags.push_back(*I);
 115       }
 116     }
 117
 118     std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
 119
 120     startLine() << Label << " [ (" << hex(Value) << ")\n";
 121     for (typename FlagVector::const_iterator I = SetFlags.begin(),
 122                                              E = SetFlags.end();
 123                                              I != E; ++I) {
 124       startLine() << "  " << I->Name << " (" << hex(I->Value) << ")\n";
 125     }
 126     startLine() << "]\n";
 127   }
 128
 129   template<typename T>
 130   void printFlags(StringRef Label, T Value) {
 131     startLine() << Label << " [ (" << hex(Value) << ")\n";
 132     uint64_t Flag = 1;
 133     uint64_t Curr = Value;
 134     while (Curr > 0) {
 135       if (Curr & 1)
 136         startLine() << "  " << hex(Flag) << "\n";
 137       Curr >>= 1;
 138       Flag <<= 1;
 139     }
 140     startLine() << "]\n";
 141   }
 142
 143   void printNumber(StringRef Label, uint64_t Value) {
 144     startLine() << Label << ": " << Value << "\n";
 145   }
 146
 147   void printNumber(StringRef Label, uint32_t Value) {
 148     startLine() << Label << ": " << Value << "\n";
 149   }
 150
 151   void printNumber(StringRef Label, uint16_t Value) {
 152     startLine() << Label << ": " << Value << "\n";
 153   }
 154
 155   void printNumber(StringRef Label, uint8_t Value) {
 156     startLine() << Label << ": " << unsigned(Value) << "\n";
 157   }
 158
 159   void printNumber(StringRef Label, int64_t Value) {
 160     startLine() << Label << ": " << Value << "\n";
 161   }
 162
 163   void printNumber(StringRef Label, int32_t Value) {
 164     startLine() << Label << ": " << Value << "\n";
 165   }
 166
 167   void printNumber(StringRef Label, int16_t Value) {
 168     startLine() << Label << ": " << Value << "\n";
 169   }
 170
 171   void printNumber(StringRef Label, int8_t Value) {
 172     startLine() << Label << ": " << int(Value) << "\n";
 173   }
 174
 175   template<typename T>
 176   void printHex(StringRef Label, T Value) {
 177     startLine() << Label << ": " << hex(Value) << "\n";
 178   }
 179
 180   template<typename T>
 181   void printHex(StringRef Label, StringRef Str, T Value) {
 182     startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n";
 183   }
 184
 185   void printString(StringRef Label, StringRef Value) {
 186     startLine() << Label << ": " << Value << "\n";
 187   }
 188
 189   void printString(StringRef Label, const std::string &Value) {
 190     startLine() << Label << ": " << Value << "\n";
 191   }
 192
 193   template<typename T>
 194   void printNumber(StringRef Label, StringRef Str, T Value) {
 195     startLine() << Label << ": " << Str << " (" << Value << ")\n";
 196   }
 197
 198   void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) {
 199     printBinaryImpl(Label, Str, Value, false);
 200   }
 201
 202   void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) {
 203     ArrayRef<uint8_t> V(reinterpret_cast<const uint8_t*>(Value.data()),
 204                         Value.size());
 205     printBinaryImpl(Label, Str, V, false);
 206   }
 207
 208   void printBinary(StringRef Label, ArrayRef<uint8_t> Value) {
 209     printBinaryImpl(Label, StringRef(), Value, false);
 210   }
 211
 212   void printBinary(StringRef Label, ArrayRef<char> Value) {
 213     ArrayRef<uint8_t> V(reinterpret_cast<const uint8_t*>(Value.data()),
 214                         Value.size());
 215     printBinaryImpl(Label, StringRef(), V, false);
 216   }
 217
 218   void printBinary(StringRef Label, StringRef Value) {
 219     ArrayRef<uint8_t> V(reinterpret_cast<const uint8_t*>(Value.data()),
 220                         Value.size());
 221     printBinaryImpl(Label, StringRef(), V, false);
 222   }
 223
 224   void printBinaryBlock(StringRef Label, StringRef Value) {
 225     ArrayRef<uint8_t> V(reinterpret_cast<const uint8_t*>(Value.data()),
 226                         Value.size());
 227     printBinaryImpl(Label, StringRef(), V, true);
 228   }
 229
 230   raw_ostream& startLine() {
 231     printIndent();
 232     return OS;
 233   }
 234
 235   raw_ostream& getOStream() {
 236     return OS;
 237   }
 238
 239 private:
 240   template<typename T>
 241   static bool flagName(const EnumEntry<T>& lhs, const EnumEntry<T>& rhs) {
 242     return lhs.Name < rhs.Name;
 243   }
 244
 245   void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,
 246                        bool Block);
 247
 248   raw_ostream &OS;
 249   int IndentLevel;
 250 };
 251
 252 struct DictScope {
 253   DictScope(StreamWriter& W, StringRef N) : W(W) {
 254     W.startLine() << N << " {\n";
 255     W.indent();
 256   }
 257
 258   ~DictScope() {
 259     W.unindent();
 260     W.startLine() << "}\n";
 261   }
 262
 263   StreamWriter& W;
 264 };
 265
 266 struct ListScope {
 267   ListScope(StreamWriter& W, StringRef N) : W(W) {
 268     W.startLine() << N << " [\n";
 269     W.indent();
 270   }
 271
 272   ~ListScope() {
 273     W.unindent();
 274     W.startLine() << "]\n";
 275   }
 276
 277   StreamWriter& W;
 278 };
 279
 280 } // namespace llvm
 281
 282 #endif