Home | History | Annotate | Download | only in llvm-readobj 
      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_TOOLS_LLVM_READOBJ_STREAMWRITER_H
     11 #define LLVM_TOOLS_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(char             Value) : Value(static_cast<unsigned char>(Value)) { }
     38   HexNumber(signed char      Value) : Value(static_cast<unsigned char>(Value)) { }
     39   HexNumber(signed short     Value) : Value(static_cast<unsigned short>(Value)) { }
     40   HexNumber(signed int       Value) : Value(static_cast<unsigned int>(Value)) { }
     41   HexNumber(signed long      Value) : Value(static_cast<unsigned long>(Value)) { }
     42   HexNumber(signed long long Value) : Value(static_cast<unsigned long long>(Value)) { }
     43   HexNumber(unsigned char      Value) : Value(Value) { }
     44   HexNumber(unsigned short     Value) : Value(Value) { }
     45   HexNumber(unsigned int       Value) : Value(Value) { }
     46   HexNumber(unsigned long      Value) : Value(Value) { }
     47   HexNumber(unsigned long long Value) : Value(Value) { }
     48   uint64_t Value;
     49 };
     50 
     51 raw_ostream &operator<<(raw_ostream &OS, const HexNumber& Value);
     52 
     53 class StreamWriter {
     54 public:
     55   StreamWriter(raw_ostream &OS)
     56     : OS(OS)
     57     , IndentLevel(0) {
     58   }
     59 
     60   void flush() {
     61     OS.flush();
     62   }
     63 
     64   void indent(int Levels = 1) {
     65     IndentLevel += Levels;
     66   }
     67 
     68   void unindent(int Levels = 1) {
     69     IndentLevel = std::max(0, IndentLevel - Levels);
     70   }
     71 
     72   void printIndent() {
     73     for (int i = 0; i < IndentLevel; ++i)
     74       OS << "  ";
     75   }
     76 
     77   template<typename T>
     78   HexNumber hex(T Value) {
     79     return HexNumber(Value);
     80   }
     81 
     82   template<typename T, typename TEnum>
     83   void printEnum(StringRef Label, T Value,
     84                  ArrayRef<EnumEntry<TEnum> > EnumValues) {
     85     StringRef Name;
     86     bool Found = false;
     87     for (const auto &EnumItem : EnumValues) {
     88       if (EnumItem.Value == Value) {
     89         Name = EnumItem.Name;
     90         Found = true;
     91         break;
     92       }
     93     }
     94 
     95     if (Found) {
     96       startLine() << Label << ": " << Name << " (" << hex(Value) << ")\n";
     97     } else {
     98       startLine() << Label << ": " << hex(Value) << "\n";
     99     }
    100   }
    101 
    102   template <typename T, typename TFlag>
    103   void printFlags(StringRef Label, T Value, ArrayRef<EnumEntry<TFlag>> Flags,
    104                   TFlag EnumMask1 = {}, TFlag EnumMask2 = {},
    105                   TFlag EnumMask3 = {}) {
    106     typedef EnumEntry<TFlag> FlagEntry;
    107     typedef SmallVector<FlagEntry, 10> FlagVector;
    108     FlagVector SetFlags;
    109 
    110     for (const auto &Flag : Flags) {
    111       if (Flag.Value == 0)
    112         continue;
    113 
    114       TFlag EnumMask{};
    115       if (Flag.Value & EnumMask1)
    116         EnumMask = EnumMask1;
    117       else if (Flag.Value & EnumMask2)
    118         EnumMask = EnumMask2;
    119       else if (Flag.Value & EnumMask3)
    120         EnumMask = EnumMask3;
    121       bool IsEnum = (Flag.Value & EnumMask) != 0;
    122       if ((!IsEnum && (Value & Flag.Value) == Flag.Value) ||
    123           (IsEnum  && (Value & EnumMask) == Flag.Value)) {
    124         SetFlags.push_back(Flag);
    125       }
    126     }
    127 
    128     std::sort(SetFlags.begin(), SetFlags.end(), &flagName<TFlag>);
    129 
    130     startLine() << Label << " [ (" << hex(Value) << ")\n";
    131     for (const auto &Flag : SetFlags) {
    132       startLine() << "  " << Flag.Name << " (" << hex(Flag.Value) << ")\n";
    133     }
    134     startLine() << "]\n";
    135   }
    136 
    137   template<typename T>
    138   void printFlags(StringRef Label, T Value) {
    139     startLine() << Label << " [ (" << hex(Value) << ")\n";
    140     uint64_t Flag = 1;
    141     uint64_t Curr = Value;
    142     while (Curr > 0) {
    143       if (Curr & 1)
    144         startLine() << "  " << hex(Flag) << "\n";
    145       Curr >>= 1;
    146       Flag <<= 1;
    147     }
    148     startLine() << "]\n";
    149   }
    150 
    151   void printNumber(StringRef Label, uint64_t Value) {
    152     startLine() << Label << ": " << Value << "\n";
    153   }
    154 
    155   void printNumber(StringRef Label, uint32_t Value) {
    156     startLine() << Label << ": " << Value << "\n";
    157   }
    158 
    159   void printNumber(StringRef Label, uint16_t Value) {
    160     startLine() << Label << ": " << Value << "\n";
    161   }
    162 
    163   void printNumber(StringRef Label, uint8_t Value) {
    164     startLine() << Label << ": " << unsigned(Value) << "\n";
    165   }
    166 
    167   void printNumber(StringRef Label, int64_t Value) {
    168     startLine() << Label << ": " << Value << "\n";
    169   }
    170 
    171   void printNumber(StringRef Label, int32_t Value) {
    172     startLine() << Label << ": " << Value << "\n";
    173   }
    174 
    175   void printNumber(StringRef Label, int16_t Value) {
    176     startLine() << Label << ": " << Value << "\n";
    177   }
    178 
    179   void printNumber(StringRef Label, int8_t Value) {
    180     startLine() << Label << ": " << int(Value) << "\n";
    181   }
    182 
    183   void printBoolean(StringRef Label, bool Value) {
    184     startLine() << Label << ": " << (Value ? "Yes" : "No") << '\n';
    185   }
    186 
    187   template <typename T>
    188   void printList(StringRef Label, const T &List) {
    189     startLine() << Label << ": [";
    190     bool Comma = false;
    191     for (const auto &Item : List) {
    192       if (Comma)
    193         OS << ", ";
    194       OS << Item;
    195       Comma = true;
    196     }
    197     OS << "]\n";
    198   }
    199 
    200   template <typename T>
    201   void printHexList(StringRef Label, const T &List) {
    202     startLine() << Label << ": [";
    203     bool Comma = false;
    204     for (const auto &Item : List) {
    205       if (Comma)
    206         OS << ", ";
    207       OS << hex(Item);
    208       Comma = true;
    209     }
    210     OS << "]\n";
    211   }
    212 
    213   template<typename T>
    214   void printHex(StringRef Label, T Value) {
    215     startLine() << Label << ": " << hex(Value) << "\n";
    216   }
    217 
    218   template<typename T>
    219   void printHex(StringRef Label, StringRef Str, T Value) {
    220     startLine() << Label << ": " << Str << " (" << hex(Value) << ")\n";
    221   }
    222 
    223   void printString(StringRef Label, StringRef Value) {
    224     startLine() << Label << ": " << Value << "\n";
    225   }
    226 
    227   void printString(StringRef Label, const std::string &Value) {
    228     startLine() << Label << ": " << Value << "\n";
    229   }
    230 
    231   template<typename T>
    232   void printNumber(StringRef Label, StringRef Str, T Value) {
    233     startLine() << Label << ": " << Str << " (" << Value << ")\n";
    234   }
    235 
    236   void printBinary(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value) {
    237     printBinaryImpl(Label, Str, Value, false);
    238   }
    239 
    240   void printBinary(StringRef Label, StringRef Str, ArrayRef<char> Value) {
    241     auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
    242                           Value.size());
    243     printBinaryImpl(Label, Str, V, false);
    244   }
    245 
    246   void printBinary(StringRef Label, ArrayRef<uint8_t> Value) {
    247     printBinaryImpl(Label, StringRef(), Value, false);
    248   }
    249 
    250   void printBinary(StringRef Label, ArrayRef<char> Value) {
    251     auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
    252                           Value.size());
    253     printBinaryImpl(Label, StringRef(), V, false);
    254   }
    255 
    256   void printBinary(StringRef Label, StringRef Value) {
    257     auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
    258                           Value.size());
    259     printBinaryImpl(Label, StringRef(), V, false);
    260   }
    261 
    262   void printBinaryBlock(StringRef Label, StringRef Value) {
    263     auto V = makeArrayRef(reinterpret_cast<const uint8_t*>(Value.data()),
    264                           Value.size());
    265     printBinaryImpl(Label, StringRef(), V, true);
    266   }
    267 
    268   raw_ostream& startLine() {
    269     printIndent();
    270     return OS;
    271   }
    272 
    273   raw_ostream& getOStream() {
    274     return OS;
    275   }
    276 
    277 private:
    278   template<typename T>
    279   static bool flagName(const EnumEntry<T>& lhs, const EnumEntry<T>& rhs) {
    280     return lhs.Name < rhs.Name;
    281   }
    282 
    283   void printBinaryImpl(StringRef Label, StringRef Str, ArrayRef<uint8_t> Value,
    284                        bool Block);
    285 
    286   raw_ostream &OS;
    287   int IndentLevel;
    288 };
    289 
    290 struct DictScope {
    291   DictScope(StreamWriter& W, StringRef N) : W(W) {
    292     W.startLine() << N << " {\n";
    293     W.indent();
    294   }
    295 
    296   ~DictScope() {
    297     W.unindent();
    298     W.startLine() << "}\n";
    299   }
    300 
    301   StreamWriter& W;
    302 };
    303 
    304 struct ListScope {
    305   ListScope(StreamWriter& W, StringRef N) : W(W) {
    306     W.startLine() << N << " [\n";
    307     W.indent();
    308   }
    309 
    310   ~ListScope() {
    311     W.unindent();
    312     W.startLine() << "]\n";
    313   }
    314 
    315   StreamWriter& W;
    316 };
    317 
    318 } // namespace llvm
    319 
    320 #endif
    321