lib/DebugInfo/CodeView/CVTypeVisitor.cpp

   1 //===- CVTypeVisitor.cpp ----------------------------------------*- 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 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
  10
  11 #include "llvm/DebugInfo/CodeView/CodeViewError.h"
  12 #include "llvm/DebugInfo/CodeView/TypeCollection.h"
  13 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
  14 #include "llvm/DebugInfo/CodeView/TypeRecordMapping.h"
  15 #include "llvm/DebugInfo/CodeView/TypeVisitorCallbackPipeline.h"
  16 #include "llvm/Support/BinaryByteStream.h"
  17 #include "llvm/Support/BinaryStreamReader.h"
  18
  19 using namespace llvm;
  20 using namespace llvm::codeview;
  21
  22
  23 template <typename T>
  24 static Error visitKnownRecord(CVType &Record, TypeVisitorCallbacks &Callbacks) {
  25   TypeRecordKind RK = static_cast<TypeRecordKind>(Record.kind());
  26   T KnownRecord(RK);
  27   if (auto EC = Callbacks.visitKnownRecord(Record, KnownRecord))
  28     return EC;
  29   return Error::success();
  30 }
  31
  32 template <typename T>
  33 static Error visitKnownMember(CVMemberRecord &Record,
  34                               TypeVisitorCallbacks &Callbacks) {
  35   TypeRecordKind RK = static_cast<TypeRecordKind>(Record.Kind);
  36   T KnownRecord(RK);
  37   if (auto EC = Callbacks.visitKnownMember(Record, KnownRecord))
  38     return EC;
  39   return Error::success();
  40 }
  41
  42 static Error visitMemberRecord(CVMemberRecord &Record,
  43                                TypeVisitorCallbacks &Callbacks) {
  44   if (auto EC = Callbacks.visitMemberBegin(Record))
  45     return EC;
  46
  47   switch (Record.Kind) {
  48   default:
  49     if (auto EC = Callbacks.visitUnknownMember(Record))
  50       return EC;
  51     break;
  52 #define MEMBER_RECORD(EnumName, EnumVal, Name)                                 \
  53   case EnumName: {                                                             \
  54     if (auto EC = visitKnownMember<Name##Record>(Record, Callbacks))           \
  55       return EC;                                                               \
  56     break;                                                                     \
  57   }
  58 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                \
  59   MEMBER_RECORD(EnumVal, EnumVal, AliasName)
  60 #define TYPE_RECORD(EnumName, EnumVal, Name)
  61 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
  62 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
  63   }
  64
  65   if (auto EC = Callbacks.visitMemberEnd(Record))
  66     return EC;
  67
  68   return Error::success();
  69 }
  70
  71 namespace {
  72
  73 class CVTypeVisitor {
  74 public:
  75   explicit CVTypeVisitor(TypeVisitorCallbacks &Callbacks);
  76
  77   Error visitTypeRecord(CVType &Record, TypeIndex Index);
  78   Error visitTypeRecord(CVType &Record);
  79
  80   /// Visits the type records in Data. Sets the error flag on parse failures.
  81   Error visitTypeStream(const CVTypeArray &Types);
  82   Error visitTypeStream(CVTypeRange Types);
  83   Error visitTypeStream(TypeCollection &Types);
  84
  85   Error visitMemberRecord(CVMemberRecord Record);
  86   Error visitFieldListMemberStream(BinaryStreamReader &Stream);
  87
  88 private:
  89   Error finishVisitation(CVType &Record);
  90
  91   /// The interface to the class that gets notified of each visitation.
  92   TypeVisitorCallbacks &Callbacks;
  93 };
  94
  95 CVTypeVisitor::CVTypeVisitor(TypeVisitorCallbacks &Callbacks)
  96     : Callbacks(Callbacks) {}
  97
  98 Error CVTypeVisitor::finishVisitation(CVType &Record) {
  99   switch (Record.kind()) {
 100   default:
 101     if (auto EC = Callbacks.visitUnknownType(Record))
 102       return EC;
 103     break;
 104 #define TYPE_RECORD(EnumName, EnumVal, Name)                                   \
 105   case EnumName: {                                                             \
 106     if (auto EC = visitKnownRecord<Name##Record>(Record, Callbacks))           \
 107       return EC;                                                               \
 108     break;                                                                     \
 109   }
 110 #define TYPE_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)                  \
 111   TYPE_RECORD(EnumVal, EnumVal, AliasName)
 112 #define MEMBER_RECORD(EnumName, EnumVal, Name)
 113 #define MEMBER_RECORD_ALIAS(EnumName, EnumVal, Name, AliasName)
 114 #include "llvm/DebugInfo/CodeView/CodeViewTypes.def"
 115   }
 116
 117   if (auto EC = Callbacks.visitTypeEnd(Record))
 118     return EC;
 119
 120   return Error::success();
 121 }
 122
 123 Error CVTypeVisitor::visitTypeRecord(CVType &Record, TypeIndex Index) {
 124   if (auto EC = Callbacks.visitTypeBegin(Record, Index))
 125     return EC;
 126
 127   return finishVisitation(Record);
 128 }
 129
 130 Error CVTypeVisitor::visitTypeRecord(CVType &Record) {
 131   if (auto EC = Callbacks.visitTypeBegin(Record))
 132     return EC;
 133
 134   return finishVisitation(Record);
 135 }
 136
 137 Error CVTypeVisitor::visitMemberRecord(CVMemberRecord Record) {
 138   return ::visitMemberRecord(Record, Callbacks);
 139 }
 140
 141 /// Visits the type records in Data. Sets the error flag on parse failures.
 142 Error CVTypeVisitor::visitTypeStream(const CVTypeArray &Types) {
 143   for (auto I : Types) {
 144     if (auto EC = visitTypeRecord(I))
 145       return EC;
 146   }
 147   return Error::success();
 148 }
 149
 150 Error CVTypeVisitor::visitTypeStream(CVTypeRange Types) {
 151   for (auto I : Types) {
 152     if (auto EC = visitTypeRecord(I))
 153       return EC;
 154   }
 155   return Error::success();
 156 }
 157
 158 Error CVTypeVisitor::visitTypeStream(TypeCollection &Types) {
 159   Optional<TypeIndex> I = Types.getFirst();
 160   while (I) {
 161     CVType Type = Types.getType(*I);
 162     if (auto EC = visitTypeRecord(Type, *I))
 163       return EC;
 164     I = Types.getNext(*I);
 165   }
 166   return Error::success();
 167 }
 168
 169 Error CVTypeVisitor::visitFieldListMemberStream(BinaryStreamReader &Reader) {
 170   TypeLeafKind Leaf;
 171   while (!Reader.empty()) {
 172     if (auto EC = Reader.readEnum(Leaf))
 173       return EC;
 174
 175     CVMemberRecord Record;
 176     Record.Kind = Leaf;
 177     if (auto EC = ::visitMemberRecord(Record, Callbacks))
 178       return EC;
 179   }
 180
 181   return Error::success();
 182 }
 183
 184 struct FieldListVisitHelper {
 185   FieldListVisitHelper(TypeVisitorCallbacks &Callbacks, ArrayRef<uint8_t> Data,
 186                        VisitorDataSource Source)
 187       : Stream(Data, llvm::support::little), Reader(Stream),
 188         Deserializer(Reader),
 189         Visitor((Source == VDS_BytesPresent) ? Pipeline : Callbacks) {
 190     if (Source == VDS_BytesPresent) {
 191       Pipeline.addCallbackToPipeline(Deserializer);
 192       Pipeline.addCallbackToPipeline(Callbacks);
 193     }
 194   }
 195
 196   BinaryByteStream Stream;
 197   BinaryStreamReader Reader;
 198   FieldListDeserializer Deserializer;
 199   TypeVisitorCallbackPipeline Pipeline;
 200   CVTypeVisitor Visitor;
 201 };
 202
 203 struct VisitHelper {
 204   VisitHelper(TypeVisitorCallbacks &Callbacks, VisitorDataSource Source)
 205       : Visitor((Source == VDS_BytesPresent) ? Pipeline : Callbacks) {
 206     if (Source == VDS_BytesPresent) {
 207       Pipeline.addCallbackToPipeline(Deserializer);
 208       Pipeline.addCallbackToPipeline(Callbacks);
 209     }
 210   }
 211
 212   TypeDeserializer Deserializer;
 213   TypeVisitorCallbackPipeline Pipeline;
 214   CVTypeVisitor Visitor;
 215 };
 216 }
 217
 218 Error llvm::codeview::visitTypeRecord(CVType &Record, TypeIndex Index,
 219                                       TypeVisitorCallbacks &Callbacks,
 220                                       VisitorDataSource Source) {
 221   VisitHelper V(Callbacks, Source);
 222   return V.Visitor.visitTypeRecord(Record, Index);
 223 }
 224
 225 Error llvm::codeview::visitTypeRecord(CVType &Record,
 226                                       TypeVisitorCallbacks &Callbacks,
 227                                       VisitorDataSource Source) {
 228   VisitHelper V(Callbacks, Source);
 229   return V.Visitor.visitTypeRecord(Record);
 230 }
 231
 232 Error llvm::codeview::visitTypeStream(const CVTypeArray &Types,
 233                                       TypeVisitorCallbacks &Callbacks,
 234                                       VisitorDataSource Source) {
 235   VisitHelper V(Callbacks, Source);
 236   return V.Visitor.visitTypeStream(Types);
 237 }
 238
 239 Error llvm::codeview::visitTypeStream(CVTypeRange Types,
 240                                       TypeVisitorCallbacks &Callbacks) {
 241   VisitHelper V(Callbacks, VDS_BytesPresent);
 242   return V.Visitor.visitTypeStream(Types);
 243 }
 244
 245 Error llvm::codeview::visitTypeStream(TypeCollection &Types,
 246                                       TypeVisitorCallbacks &Callbacks) {
 247   // When the internal visitor calls Types.getType(Index) the interface is
 248   // required to return a CVType with the bytes filled out.  So we can assume
 249   // that the bytes will be present when individual records are visited.
 250   VisitHelper V(Callbacks, VDS_BytesPresent);
 251   return V.Visitor.visitTypeStream(Types);
 252 }
 253
 254 Error llvm::codeview::visitMemberRecord(CVMemberRecord Record,
 255                                         TypeVisitorCallbacks &Callbacks,
 256                                         VisitorDataSource Source) {
 257   FieldListVisitHelper V(Callbacks, Record.Data, Source);
 258   return V.Visitor.visitMemberRecord(Record);
 259 }
 260
 261 Error llvm::codeview::visitMemberRecord(TypeLeafKind Kind,
 262                                         ArrayRef<uint8_t> Record,
 263                                         TypeVisitorCallbacks &Callbacks) {
 264   CVMemberRecord R;
 265   R.Data = Record;
 266   R.Kind = Kind;
 267   return visitMemberRecord(R, Callbacks, VDS_BytesPresent);
 268 }
 269
 270 Error llvm::codeview::visitMemberRecordStream(ArrayRef<uint8_t> FieldList,
 271                                               TypeVisitorCallbacks &Callbacks) {
 272   FieldListVisitHelper V(Callbacks, FieldList, VDS_BytesPresent);
 273   return V.Visitor.visitFieldListMemberStream(V.Reader);
 274 }