retdec
metadata_tables.h
Go to the documentation of this file.
1 
7 #ifndef RETDEC_FILEFORMAT_TYPES_DOTNET_HEADERS_METADATA_TABLES_H
8 #define RETDEC_FILEFORMAT_TYPES_DOTNET_HEADERS_METADATA_TABLES_H
9 
10 #include <cstdint>
11 #include <type_traits>
12 
15 
16 namespace retdec {
17 namespace fileformat {
18 
19 //
20 // Flags enumerations
21 //
22 
24 {
25  // Visibility flags
26  TypeVisibilityMask = 0x00000007,
27  TypeNotPublic = 0x00000000,
28  TypePublic = 0x00000001,
29  TypeNestedPublic = 0x00000002,
30  TypeNestedPrivate = 0x00000003,
31  TypeNestedFamily = 0x00000004,
32  TypeNestedAssembly = 0x00000005,
33  TypeNestedFamANDAssem = 0x00000006,
34  TypeNestedFamORAssem = 0x00000007,
35  // Layout flags - we do not care
36  // ClassSemantics flags
37  TypeClassSemanticsMask = 0x00000020,
38  TypeClass = 0x00000000,
39  TypeInterface = 0x00000020,
40  // special semantics
41  TypeClassAbstract = 0x00000080,
42  TypeClassSealed = 0x00000100,
43  TypeClassSpecialName = 0x00000400,
44  // StringFormat flags
45  TypeStringFormatMask = 0x00030000,
46  TypeAnsiClass = 0x00000000,
47  TypeUnicodeClass = 0x00010000,
48  TypeAutoClass = 0x00020000,
49  TypeCustomFormatClass = 0x00030000
50 };
51 
53 {
54  // Field access flags
55  FieldAccessMask = 0x0007,
57  FieldPrivate = 0x0001,
58  FieldFamANDAssem = 0x0002,
59  FieldAssembly = 0x0003,
60  FieldFamily = 0x0004,
61  FieldFamORAssem = 0x0005,
62  FieldPublic = 0x0006,
63  // special
64  FieldStatic = 0x0010,
65  FieldInitOnly = 0x0020,
66  FieldLiteral = 0x0040,
68  FieldSpecialName = 0x0200
69  // Interop attributes - we do not care
70  // Additional flags - we do not care
71 };
72 
74 {
75  // Member access flags
78  MethodPrivate = 0x0001,
80  MethodAssem = 0x0003,
81  MethodFamily = 0x0004,
82  MethodFamORAssem = 0x0005,
83  MethodPublic = 0x0006,
84  // special flags
85  MethodStatic = 0x0010,
86  MethodFinal = 0x0020,
87  MethodVirtual = 0x0040,
88  MethodHideBySig = 0x0080,
89  // Vtable layout mask - we do not care
90  // additional special flags
91  MethodStrict = 0x0200,
92  MethodAbstract = 0x0400,
93  MethodSpecialName = 0x0800
94  // Interop attributes - we do not care
95  // Additional flags - we do not care
96 };
97 
99 {
100  ParamIn = 0x0001,
101  ParamOut = 0x0002,
102  ParamOptional = 0x0010,
103  ParamHasDefault = 0x1000,
104  ParamHasFieldMarshal = 0x2000
105 };
106 
107 //
108 // Index types
109 //
110 
111 struct Index
112 {
113  protected:
114  std::uint64_t index = 0;
115 
116  constexpr std::uint64_t maskForBits(std::uint64_t bits) const { return (1ULL << bits) - 1; }
117  public:
118  std::uint64_t getRawIndex() const { return index; }
119  virtual std::uint64_t getIndex() const = 0;
120 
121  void setIndex(std::uint64_t newIndex) { index = newIndex; }
122 };
123 
124 struct CompoundIndex : public Index
125 {
126  public:
127  virtual bool getTable(MetadataTableType& result) const = 0;
128 };
129 
130 struct StringStreamIndex : public Index
131 {
132  virtual std::uint64_t getIndex() const override { return index; }
133 };
134 
135 struct BlobStreamIndex : public Index
136 {
137  virtual std::uint64_t getIndex() const override { return index; }
138 };
139 
140 struct GuidStreamIndex : public Index
141 {
142  virtual std::uint64_t getIndex() const override { return index; }
143 };
144 
145 struct FieldTableIndex : public Index
146 {
147  virtual std::uint64_t getIndex() const override { return index; }
148 };
149 
150 struct MethodDefTableIndex : public Index
151 {
152  virtual std::uint64_t getIndex() const override { return index; }
153 };
154 
155 struct ParamTableIndex : public Index
156 {
157  virtual std::uint64_t getIndex() const override { return index; }
158 };
159 
160 struct TypeDefTableIndex : public Index
161 {
162  virtual std::uint64_t getIndex() const override { return index; }
163 };
164 
165 struct EventTableIndex : public Index
166 {
167  virtual std::uint64_t getIndex() const override { return index; }
168 };
169 
170 struct PropertyTableIndex : public Index
171 {
172  virtual std::uint64_t getIndex() const override { return index; }
173 };
174 
175 struct ModuleRefTableIndex : public Index
176 {
177  virtual std::uint64_t getIndex() const override { return index; }
178 };
179 
181 {
182  virtual std::uint64_t getIndex() const override { return index; }
183 };
184 
186 {
187  virtual std::uint64_t getIndex() const override { return index; }
188 };
189 
191 {
192  virtual std::uint64_t getIndex() const override { return index >> 2; }
193  virtual bool getTable(MetadataTableType& result) const override
194  {
195  switch (index & maskForBits(2))
196  {
197  case 0:
199  break;
200  case 1:
202  break;
203  case 2:
205  break;
206  default:
207  return false;
208  }
209 
210  return true;
211  }
212 };
213 
214 struct HasConstant : public CompoundIndex
215 {
216  virtual std::uint64_t getIndex() const override { return index >> 2; }
217  virtual bool getTable(MetadataTableType& result) const override
218  {
219  switch (index & maskForBits(2))
220  {
221  case 0:
222  result = MetadataTableType::Field;
223  break;
224  case 1:
225  result = MetadataTableType::Param;
226  break;
227  case 2:
229  break;
230  default:
231  return false;
232  }
233 
234  return true;
235  }
236 };
237 
239 {
240  virtual std::uint64_t getIndex() const override { return index >> 5; }
241  virtual bool getTable(MetadataTableType& result) const override
242  {
243  switch (index & maskForBits(5))
244  {
245  case 0:
247  break;
248  case 1:
249  result = MetadataTableType::Field;
250  break;
251  case 2:
253  break;
254  case 3:
256  break;
257  case 4:
258  result = MetadataTableType::Param;
259  break;
260  case 5:
262  break;
263  case 6:
265  break;
266  case 7:
267  result = MetadataTableType::Module;
268  break;
269  case 8:
271  break;
272  case 9:
274  break;
275  case 10:
276  result = MetadataTableType::Event;
277  break;
278  case 11:
280  break;
281  case 12:
283  break;
284  case 13:
286  break;
287  case 14:
289  break;
290  case 15:
292  break;
293  case 16:
294  result = MetadataTableType::File;
295  break;
296  case 17:
298  break;
299  case 18:
301  break;
302  case 19:
304  break;
305  case 20:
307  break;
308  case 21:
310  break;
311  default:
312  return false;
313  }
314 
315  return true;
316  }
317 };
318 
320 {
321  virtual std::uint64_t getIndex() const override { return index >> 1; }
322  virtual bool getTable(MetadataTableType& result) const override
323  {
324  switch (index & maskForBits(1))
325  {
326  case 0:
327  result = MetadataTableType::Field;
328  break;
329  case 1:
330  result = MetadataTableType::Param;
331  break;
332  default:
333  return false;
334  }
335 
336  return true;
337  }
338 };
339 
341 {
342  virtual std::uint64_t getIndex() const override { return index >> 2; }
343  virtual bool getTable(MetadataTableType& result) const override
344  {
345  switch (index & maskForBits(2))
346  {
347  case 0:
349  break;
350  case 1:
352  break;
353  case 2:
355  break;
356  default:
357  return false;
358  }
359 
360  return true;
361  }
362 };
363 
365 {
366  virtual std::uint64_t getIndex() const override { return index >> 3; }
367  virtual bool getTable(MetadataTableType& result) const override
368  {
369  switch (index & maskForBits(3))
370  {
371  case 0:
373  break;
374  case 1:
376  break;
377  case 2:
379  break;
380  case 3:
382  break;
383  case 4:
385  break;
386  default:
387  return false;
388  }
389 
390  return true;
391  }
392 };
393 
395 {
396  virtual std::uint64_t getIndex() const override { return index >> 1; }
397  virtual bool getTable(MetadataTableType& result) const override
398  {
399  switch (index & maskForBits(1))
400  {
401  case 0:
402  result = MetadataTableType::Event;
403  break;
404  case 1:
406  break;
407  default:
408  return false;
409  }
410 
411  return true;
412  }
413 };
414 
416 {
417  virtual std::uint64_t getIndex() const override { return index >> 1; }
418  virtual bool getTable(MetadataTableType& result) const override
419  {
420  switch (index & maskForBits(1))
421  {
422  case 0:
424  break;
425  case 1:
427  break;
428  default:
429  return false;
430  }
431 
432  return true;
433  }
434 };
435 
437 {
438  virtual std::uint64_t getIndex() const override { return index >> 1; }
439  virtual bool getTable(MetadataTableType& result) const override
440  {
441  switch (index & maskForBits(1))
442  {
443  case 0:
444  result = MetadataTableType::Field;
445  break;
446  case 1:
448  break;
449  default:
450  return false;
451  }
452 
453  return true;
454  }
455 };
456 
458 {
459  virtual std::uint64_t getIndex() const override { return index >> 2; }
460  virtual bool getTable(MetadataTableType& result) const override
461  {
462  switch (index & maskForBits(2))
463  {
464  case 0:
465  result = MetadataTableType::File;
466  break;
467  case 1:
469  break;
470  case 2:
472  break;
473  default:
474  return false;
475  }
476 
477  return true;
478  }
479 };
480 
482 {
483  virtual std::uint64_t getIndex() const override { return index >> 3; }
484  virtual bool getTable(MetadataTableType& result) const override
485  {
486  switch (index & maskForBits(3))
487  {
488  case 2:
490  break;
491  case 3:
493  break;
494  default:
495  return false;
496  }
497 
498  return true;
499  }
500 };
501 
503 {
504  virtual std::uint64_t getIndex() const override { return index >> 2; }
505  virtual bool getTable(MetadataTableType& result) const override
506  {
507  switch (index & maskForBits(2))
508  {
509  case 0:
510  result = MetadataTableType::Module;
511  break;
512  case 1:
514  break;
515  case 2:
517  break;
518  case 3:
520  break;
521  default:
522  return false;
523  }
524 
525  return true;
526  }
527 };
528 
530 {
531  virtual std::uint64_t getIndex() const override { return index >> 1; }
532  virtual bool getTable(MetadataTableType& result) const override
533  {
534  switch (index & maskForBits(1))
535  {
536  case 0:
538  break;
539  case 1:
541  break;
542  default:
543  return false;
544  }
545 
546  return true;
547  }
548 };
549 
550 //
551 // Table records
552 //
553 
554 class InvalidDotnetRecordError : public std::exception
555 {
556 public:
559 
560  virtual const char* what() const noexcept { return "Invalid .NET record"; }
561 };
562 
567 {
568  virtual ~BaseRecord() = default;
569 
570  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) = 0;
571 
572 protected:
573  template <typename T>
574  T loadUInt(const FileFormat* file, std::uint64_t& address);
575 
576  template <typename T>
577  std::uint32_t getIndexSize(const MetadataStream* stream);
578 
579  template <typename T>
580  T loadIndex(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address)
581  {
582  std::uint64_t val;
583  if (getIndexSize<T>(stream) == 2)
584  {
585  if (!file->get2Byte(address, val))
586  throw InvalidDotnetRecordError();
587 
588  address += 2;
589  }
590  else
591  {
592  if (!file->get4Byte(address, val))
593  throw InvalidDotnetRecordError();
594 
595  address += 4;
596  }
597 
598  T index;
599  index.setIndex(val);
600  return index;
601  }
602 };
603 
604 template <> std::uint8_t BaseRecord::loadUInt<std::uint8_t>(const FileFormat* file, std::uint64_t& address);
605 template <> std::uint16_t BaseRecord::loadUInt<std::uint16_t>(const FileFormat* file, std::uint64_t& address);
606 template <> std::uint32_t BaseRecord::loadUInt<std::uint32_t>(const FileFormat* file, std::uint64_t& address);
607 
608 struct DotnetModule : public BaseRecord
609 {
610  std::uint16_t generation;
615 
616  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
617  {
618  generation = loadUInt<std::uint16_t>(file, address);
619  name = loadIndex<StringStreamIndex>(file, stream, address);
620  mvId = loadIndex<GuidStreamIndex>(file, stream, address);
621  encId = loadIndex<GuidStreamIndex>(file, stream, address);
622  encBaseId = loadIndex<GuidStreamIndex>(file, stream, address);
623  }
624 };
625 
626 struct TypeRef : public BaseRecord
627 {
631 
632  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
633  {
634  resolutionScope = loadIndex<ResolutionScope>(file, stream, address);
635  typeName = loadIndex<StringStreamIndex>(file, stream, address);
636  typeNamespace = loadIndex<StringStreamIndex>(file, stream, address);
637  }
638 };
639 
640 struct TypeDef : public BaseRecord
641 {
642  std::uint32_t flags;
648 
649  bool isNonPublic() const { return (flags & TypeVisibilityMask) == TypeNotPublic; }
650  bool isPublic() const { return (flags & TypeVisibilityMask) == TypePublic; }
651  bool isNestedPublic() const { return (flags & TypeVisibilityMask) == TypeNestedPublic; }
654  bool isClass() const { return (flags & TypeClassSemanticsMask) == TypeClass; }
655  bool isInterface() const { return (flags & TypeClassSemanticsMask) == TypeInterface; }
656  bool isAbstract() const { return flags & TypeClassAbstract; }
657  bool isSealed() const { return flags & TypeClassSealed; }
658  bool hasAnsiName() const { return (flags & TypeStringFormatMask) == TypeAnsiClass; }
660 
661  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
662  {
663  flags = loadUInt<std::uint32_t>(file, address);
664  typeName = loadIndex<StringStreamIndex>(file, stream, address);
665  typeNamespace = loadIndex<StringStreamIndex>(file, stream, address);
666  extends = loadIndex<TypeDefOrRef>(file, stream, address);
667  fieldList = loadIndex<FieldTableIndex>(file, stream, address);
668  methodList = loadIndex<MethodDefTableIndex>(file, stream, address);
669  }
670 };
671 
672 struct FieldPtr : public BaseRecord
673 {
675 
676  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
677  {
678  field = loadIndex<FieldTableIndex>(file, stream, address);
679  }
680 };
681 
682 struct Field : public BaseRecord
683 {
684  std::uint16_t flags;
687 
688  bool isPublic() const { return (flags & FieldAccessMask) == FieldPublic; }
689  bool isProtected() const { return (flags & FieldAccessMask) == FieldFamily; }
690  bool isPrivate() const { return (flags & FieldAccessMask) == FieldPrivate; }
691  bool isStatic() const { return flags & FieldStatic; }
692 
693  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
694  {
695  flags = loadUInt<std::uint16_t>(file, address);
696  name = loadIndex<StringStreamIndex>(file, stream, address);
697  signature = loadIndex<BlobStreamIndex>(file, stream, address);
698  }
699 };
700 
701 struct MethodPtr : public BaseRecord
702 {
704 
705  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
706  {
707  method = loadIndex<MethodDefTableIndex>(file, stream, address);
708  }
709 };
710 
711 struct MethodDef : public BaseRecord
712 {
713  std::uint32_t rva;
714  std::uint16_t implFlags;
715  std::uint16_t flags;
719 
720  bool isPublic() const { return (flags & MethodMemberAccessMask) == MethodPublic; }
721  bool isPrivate() const { return (flags & MethodMemberAccessMask) == MethodPrivate; }
722  bool isProtected() const { return (flags & MethodMemberAccessMask) == MethodFamily; }
723  bool isStatic() const { return flags & MethodStatic; }
724  bool isVirtual() const { return flags & MethodVirtual; }
725  bool isFinal() const { return flags & MethodFinal; }
726  bool isAbstract() const { return flags & MethodAbstract; }
727 
728  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
729  {
730  rva = loadUInt<std::uint32_t>(file, address);
731  implFlags = loadUInt<std::uint16_t>(file, address);
732  flags = loadUInt<std::uint16_t>(file, address);
733  name = loadIndex<StringStreamIndex>(file, stream, address);
734  signature = loadIndex<BlobStreamIndex>(file, stream, address);
735  paramList = loadIndex<ParamTableIndex>(file, stream, address);
736  }
737 };
738 
739 struct ParamPtr : public BaseRecord
740 {
742 
743  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
744  {
745  param = loadIndex<ParamTableIndex>(file, stream, address);
746  }
747 };
748 
749 struct Param : public BaseRecord
750 {
751  std::uint16_t flags;
752  std::uint16_t sequence;
754 
755  bool isOut() const { return flags & ParamOut; }
756 
757  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
758  {
759  flags = loadUInt<std::uint16_t>(file, address);
760  sequence = loadUInt<std::uint16_t>(file, address);
761  name = loadIndex<StringStreamIndex>(file, stream, address);
762  }
763 };
764 
765 struct InterfaceImpl : public BaseRecord
766 {
769 
770  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
771  {
772  classType = loadIndex<TypeDefTableIndex>(file, stream, address);
773  interfaceType = loadIndex<TypeDefOrRef>(file, stream, address);
774  }
775 };
776 
777 struct MemberRef : public BaseRecord
778 {
782 
783  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
784  {
785  classType = loadIndex<MemberRefParent>(file, stream, address);
786  name = loadIndex<StringStreamIndex>(file, stream, address);
787  signature = loadIndex<BlobStreamIndex>(file, stream, address);
788  }
789 };
790 
791 struct Constant : public BaseRecord
792 {
793  std::uint8_t type;
796 
797  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
798  {
799  type = loadUInt<std::uint8_t>(file, address);
800  address += 1; // 1-byte always 0 padding
801  parent = loadIndex<HasConstant>(file, stream, address);
802  value = loadIndex<BlobStreamIndex>(file, stream, address);
803  }
804 };
805 
807 {
811 
812  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
813  {
814  parent = loadIndex<HasCustomAttribute>(file, stream, address);
815  type = loadIndex<CustomAttributeType>(file, stream, address);
816  value = loadIndex<BlobStreamIndex>(file, stream, address);
817  }
818 };
819 
820 struct FieldMarshal : public BaseRecord
821 {
824 
825  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
826  {
827  parent = loadIndex<HasFieldMarshal>(file, stream, address);
828  nativeType = loadIndex<BlobStreamIndex>(file, stream, address);
829  }
830 };
831 
832 struct DeclSecurity : public BaseRecord
833 {
834  std::uint16_t action;
837 
838  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
839  {
840  action = loadUInt<std::uint16_t>(file, address);
841  parent = loadIndex<HasDeclSecurity>(file, stream, address);
842  permissionSet = loadIndex<BlobStreamIndex>(file, stream, address);
843  }
844 };
845 
846 struct ClassLayout : public BaseRecord
847 {
848  std::uint16_t packingSize;
849  std::uint32_t classSize;
851 
852  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
853  {
854  packingSize = loadUInt<std::uint16_t>(file, address);
855  classSize = loadUInt<std::uint32_t>(file, address);
856  parent = loadIndex<TypeDefTableIndex>(file, stream, address);
857  }
858 };
859 
860 struct FieldLayout : public BaseRecord
861 {
862  std::uint32_t offset;
864 
865  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
866  {
867  offset = loadUInt<std::uint32_t>(file, address);
868  field = loadIndex<FieldTableIndex>(file, stream, address);
869  }
870 };
871 
872 struct StandAloneSig : public BaseRecord
873 {
875 
876  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
877  {
878  signature = loadIndex<BlobStreamIndex>(file, stream, address);
879  }
880 };
881 
882 struct EventMap : public BaseRecord
883 {
886 
887  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
888  {
889  parent = loadIndex<TypeDefTableIndex>(file, stream, address);
890  eventList = loadIndex<EventTableIndex>(file, stream, address);
891  }
892 };
893 
894 struct Event : public BaseRecord
895 {
896  std::uint16_t eventFlags;
899 
900  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
901  {
902  eventFlags = loadUInt<std::uint16_t>(file, address);
903  name = loadIndex<StringStreamIndex>(file, stream, address);
904  eventType = loadIndex<TypeDefOrRef>(file, stream, address);
905  }
906 };
907 
908 struct PropertyPtr : public BaseRecord
909 {
911 
912  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
913  {
914  property = loadIndex<PropertyTableIndex>(file, stream, address);
915  }
916 };
917 
918 struct PropertyMap : public BaseRecord
919 {
922 
923  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
924  {
925  parent = loadIndex<TypeDefTableIndex>(file, stream, address);
926  propertyList = loadIndex<PropertyTableIndex>(file, stream, address);
927  }
928 };
929 
930 struct Property : public BaseRecord
931 {
932  std::uint16_t flags;
935 
936  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
937  {
938  flags = loadUInt<std::uint16_t>(file, address);
939  name = loadIndex<StringStreamIndex>(file, stream, address);
940  type = loadIndex<BlobStreamIndex>(file, stream, address);
941  }
942 };
943 
945 {
946  std::uint16_t semantics;
949 
950  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
951  {
952  semantics = loadUInt<std::uint16_t>(file, address);
953  method = loadIndex<MethodDefTableIndex>(file, stream, address);
954  association = loadIndex<HasSemantics>(file, stream, address);
955  }
956 };
957 
958 struct MethodImpl : public BaseRecord
959 {
963 
964  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
965  {
966  classType = loadIndex<TypeDefTableIndex>(file, stream, address);
967  methodBody = loadIndex<MethodDefOrRef>(file, stream, address);
968  methodDeclaration = loadIndex<MethodDefOrRef>(file, stream, address);
969  }
970 };
971 
972 struct ModuleRef : public BaseRecord
973 {
975 
976  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
977  {
978  name = loadIndex<StringStreamIndex>(file, stream, address);
979  }
980 };
981 
982 struct TypeSpec : public BaseRecord
983 {
985 
986  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
987  {
988  signature = loadIndex<BlobStreamIndex>(file, stream, address);
989  }
990 };
991 
992 struct ImplMap : public BaseRecord
993 {
994  std::uint16_t mappingFlags;
998 
999  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1000  {
1001  mappingFlags = loadUInt<std::uint16_t>(file, address);
1002  memberForwarded = loadIndex<MemberForwarded>(file, stream, address);
1003  importName = loadIndex<StringStreamIndex>(file, stream, address);
1004  importScope = loadIndex<ModuleRefTableIndex>(file, stream, address);
1005  }
1006 };
1007 
1008 struct FieldRVA : public BaseRecord
1009 {
1010  std::uint32_t rva;
1012 
1013  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1014  {
1015  rva = loadUInt<std::uint32_t>(file, address);
1016  field = loadIndex<FieldTableIndex>(file, stream, address);
1017  }
1018 };
1019 
1020 struct ENCLog : public BaseRecord
1021 {
1022  std::uint32_t token;
1023  std::uint32_t funcCode;
1024 
1025  virtual void load(const FileFormat* file, const MetadataStream*, std::uint64_t& address) override
1026  {
1027  token = loadUInt<std::uint32_t>(file, address);
1028  funcCode = loadUInt<std::uint32_t>(file, address);
1029  }
1030 };
1031 
1032 struct ENCMap : public BaseRecord
1033 {
1034  std::uint32_t token;
1035 
1036  virtual void load(const FileFormat* file, const MetadataStream*, std::uint64_t& address) override
1037  {
1038  token = loadUInt<std::uint32_t>(file, address);
1039  }
1040 };
1041 
1042 struct Assembly : public BaseRecord
1043 {
1044  std::uint32_t hashAlgId;
1045  std::uint16_t majorVersion;
1046  std::uint16_t minorVersion;
1047  std::uint16_t buildNumber;
1048  std::uint16_t revisionNumber;
1049  std::uint32_t flags;
1053 
1054  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1055  {
1056  hashAlgId = loadUInt<std::uint32_t>(file, address);
1057  majorVersion = loadUInt<std::uint16_t>(file, address);
1058  minorVersion = loadUInt<std::uint16_t>(file, address);
1059  buildNumber = loadUInt<std::uint16_t>(file, address);
1060  revisionNumber = loadUInt<std::uint16_t>(file, address);
1061  flags = loadUInt<std::uint32_t>(file, address);
1062  publicKey = loadIndex<BlobStreamIndex>(file, stream, address);
1063  name = loadIndex<StringStreamIndex>(file, stream, address);
1064  culture = loadIndex<StringStreamIndex>(file, stream, address);
1065  }
1066 };
1067 
1069 {
1070  std::uint32_t processor;
1071 
1072  virtual void load(const FileFormat* file, const MetadataStream*, std::uint64_t& address) override
1073  {
1074  processor = loadUInt<std::uint32_t>(file, address);
1075  }
1076 };
1077 
1078 struct AssemblyOS : public BaseRecord
1079 {
1080  std::uint32_t osPlatformId;
1081  std::uint32_t osMajorVersion;
1082  std::uint32_t osMinorVersion;
1083 
1084  virtual void load(const FileFormat* file, const MetadataStream*, std::uint64_t& address) override
1085  {
1086  osPlatformId = loadUInt<std::uint32_t>(file, address);
1087  osMajorVersion = loadUInt<std::uint32_t>(file, address);
1088  osMinorVersion = loadUInt<std::uint32_t>(file, address);
1089  }
1090 };
1091 
1092 struct AssemblyRef : public BaseRecord
1093 {
1094  std::uint16_t majorVersion;
1095  std::uint16_t minorVersion;
1096  std::uint16_t buildNumber;
1097  std::uint16_t revisionNumber;
1098  std::uint32_t flags;
1103 
1104  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1105  {
1106  majorVersion = loadUInt<std::uint16_t>(file, address);
1107  minorVersion = loadUInt<std::uint16_t>(file, address);
1108  buildNumber = loadUInt<std::uint16_t>(file, address);
1109  revisionNumber = loadUInt<std::uint16_t>(file, address);
1110  flags = loadUInt<std::uint32_t>(file, address);
1111  publicKeyOrToken = loadIndex<BlobStreamIndex>(file, stream, address);
1112  name = loadIndex<StringStreamIndex>(file, stream, address);
1113  culture = loadIndex<StringStreamIndex>(file, stream, address);
1114  hashValue = loadIndex<BlobStreamIndex>(file, stream, address);
1115  }
1116 };
1117 
1119 {
1120  std::uint32_t processor;
1122 
1123  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1124  {
1125  processor = loadUInt<std::uint32_t>(file, address);
1126  assemblyRef = loadIndex<AssemblyRefTableIndex>(file, stream, address);
1127  }
1128 };
1129 
1130 struct AssemblyRefOS : public BaseRecord
1131 {
1132  std::uint32_t osPlatformId;
1133  std::uint32_t osMajorVersion;
1134  std::uint32_t osMinorVersion;
1136 
1137  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1138  {
1139  osPlatformId = loadUInt<std::uint32_t>(file, address);
1140  osMajorVersion = loadUInt<std::uint32_t>(file, address);
1141  osMinorVersion = loadUInt<std::uint32_t>(file, address);
1142  assemblyRef = loadIndex<AssemblyRefTableIndex>(file, stream, address);
1143  }
1144 };
1145 
1146 struct File : public BaseRecord
1147 {
1148  std::uint32_t flags;
1151 
1152  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1153  {
1154  flags = loadUInt<std::uint32_t>(file, address);
1155  name = loadIndex<StringStreamIndex>(file, stream, address);
1156  hashValue = loadIndex<BlobStreamIndex>(file, stream, address);
1157  }
1158 };
1159 
1160 struct ExportedType : public BaseRecord
1161 {
1162  std::uint32_t flags;
1163  std::uint32_t typeDefId;
1167 
1168  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1169  {
1170  flags = loadUInt<std::uint32_t>(file, address);
1171  typeDefId = loadUInt<std::uint32_t>(file, address);
1172  typeName = loadIndex<StringStreamIndex>(file, stream, address);
1173  typeNamespace = loadIndex<StringStreamIndex>(file, stream, address);
1174  implementation = loadIndex<Implementation>(file, stream, address);
1175  }
1176 };
1177 
1179 {
1180  std::uint32_t offset;
1181  std::uint32_t flags;
1184 
1185  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1186  {
1187  offset = loadUInt<std::uint32_t>(file, address);
1188  flags = loadUInt<std::uint32_t>(file, address);
1189  name = loadIndex<StringStreamIndex>(file, stream, address);
1190  implementation = loadIndex<Implementation>(file, stream, address);
1191  }
1192 };
1193 
1194 struct NestedClass : public BaseRecord
1195 {
1198 
1199  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1200  {
1201  nestedClass = loadIndex<TypeDefTableIndex>(file, stream, address);
1202  enclosingClass = loadIndex<TypeDefTableIndex>(file, stream, address);
1203  }
1204 };
1205 
1206 struct GenericParam : public BaseRecord
1207 {
1208  std::uint16_t number;
1209  std::uint16_t flags;
1212 
1213  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1214  {
1215  number = loadUInt<std::uint16_t>(file, address);
1216  flags = loadUInt<std::uint16_t>(file, address);
1217  owner = loadIndex<TypeDefOrMethodDef>(file, stream, address);
1218  name = loadIndex<StringStreamIndex>(file, stream, address);
1219  }
1220 };
1221 
1222 struct MethodSpec : public BaseRecord
1223 {
1226 
1227  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1228  {
1229  method = loadIndex<MethodDefOrRef>(file, stream, address);
1230  instantiation = loadIndex<BlobStreamIndex>(file, stream, address);
1231  }
1232 };
1233 
1235 {
1238 
1239  virtual void load(const FileFormat* file, const MetadataStream* stream, std::uint64_t& address) override
1240  {
1241  owner = loadIndex<GenericParamTableIndex>(file, stream, address);
1242  constraint = loadIndex<TypeDefOrRef>(file, stream, address);
1243  }
1244 };
1245 
1246 } // namespace fileformat
1247 } // namespace retdec
1248 
1249 #endif
Definition: file_format.h:45
Definition: metadata_tables.h:555
virtual const char * what() const noexcept
Definition: metadata_tables.h:560
InvalidDotnetRecordError() noexcept
Definition: metadata_tables.h:557
InvalidDotnetRecordError(const InvalidDotnetRecordError &) noexcept=default
Definition: metadata_stream.h:21
bool get4Byte(std::uint64_t address, std::uint64_t &res, Endianness e=Endianness::UNKNOWN) const
Definition: byte_value_storage.cpp:321
bool get2Byte(std::uint64_t address, std::uint64_t &res, Endianness e=Endianness::UNKNOWN) const
Definition: byte_value_storage.cpp:303
Definition of FileFormat class.
Class for #~ Stream.
FieldFlags
Definition: metadata_tables.h:53
@ FieldAssembly
Definition: metadata_tables.h:59
@ FieldAccessMask
Definition: metadata_tables.h:55
@ FieldFamANDAssem
Definition: metadata_tables.h:58
@ FieldFamily
Definition: metadata_tables.h:60
@ FieldLiteral
Definition: metadata_tables.h:66
@ FieldCompilerControlled
Definition: metadata_tables.h:56
@ FieldFamORAssem
Definition: metadata_tables.h:61
@ FieldInitOnly
Definition: metadata_tables.h:65
@ FieldPublic
Definition: metadata_tables.h:62
@ FieldStatic
Definition: metadata_tables.h:64
@ FieldPrivate
Definition: metadata_tables.h:57
@ FieldSpecialName
Definition: metadata_tables.h:68
@ FieldNotSerialized
Definition: metadata_tables.h:67
MetadataTableType
Definition: metadata_table.h:17
MethodFlags
Definition: metadata_tables.h:74
@ MethodAssem
Definition: metadata_tables.h:80
@ MethodSpecialName
Definition: metadata_tables.h:93
@ MethodHideBySig
Definition: metadata_tables.h:88
@ MethodStrict
Definition: metadata_tables.h:91
@ MethodFinal
Definition: metadata_tables.h:86
@ MethodPublic
Definition: metadata_tables.h:83
@ MethodVirtual
Definition: metadata_tables.h:87
@ MethodCompilerControlled
Definition: metadata_tables.h:77
@ MethodMemberAccessMask
Definition: metadata_tables.h:76
@ MethodAbstract
Definition: metadata_tables.h:92
@ MethodFamily
Definition: metadata_tables.h:81
@ MethodFamORAssem
Definition: metadata_tables.h:82
@ MethodPrivate
Definition: metadata_tables.h:78
@ MethodStatic
Definition: metadata_tables.h:85
@ MethodFamANDAssem
Definition: metadata_tables.h:79
TypeDefFlags
Definition: metadata_tables.h:24
@ TypeNestedFamORAssem
Definition: metadata_tables.h:34
@ TypeAutoClass
Definition: metadata_tables.h:48
@ TypeVisibilityMask
Definition: metadata_tables.h:26
@ TypeNestedFamANDAssem
Definition: metadata_tables.h:33
@ TypeNotPublic
Definition: metadata_tables.h:27
@ TypeNestedAssembly
Definition: metadata_tables.h:32
@ TypeUnicodeClass
Definition: metadata_tables.h:47
@ TypeClassAbstract
Definition: metadata_tables.h:41
@ TypeClassSealed
Definition: metadata_tables.h:42
@ TypeNestedFamily
Definition: metadata_tables.h:31
@ TypeNestedPrivate
Definition: metadata_tables.h:30
@ TypeClassSpecialName
Definition: metadata_tables.h:43
@ TypeStringFormatMask
Definition: metadata_tables.h:45
@ TypeNestedPublic
Definition: metadata_tables.h:29
@ TypeClass
Definition: metadata_tables.h:38
@ TypeCustomFormatClass
Definition: metadata_tables.h:49
@ TypePublic
Definition: metadata_tables.h:28
@ TypeAnsiClass
Definition: metadata_tables.h:46
@ TypeInterface
Definition: metadata_tables.h:39
@ TypeClassSemanticsMask
Definition: metadata_tables.h:37
ParamFlags
Definition: metadata_tables.h:99
@ ParamHasFieldMarshal
Definition: metadata_tables.h:104
@ ParamOut
Definition: metadata_tables.h:101
@ ParamOptional
Definition: metadata_tables.h:102
@ ParamHasDefault
Definition: metadata_tables.h:103
@ ParamIn
Definition: metadata_tables.h:100
Definition: archive_wrapper.h:19
Definition: metadata_tables.h:1079
virtual void load(const FileFormat *file, const MetadataStream *, std::uint64_t &address) override
Definition: metadata_tables.h:1084
std::uint32_t osPlatformId
Definition: metadata_tables.h:1080
std::uint32_t osMajorVersion
Definition: metadata_tables.h:1081
std::uint32_t osMinorVersion
Definition: metadata_tables.h:1082
Definition: metadata_tables.h:1069
virtual void load(const FileFormat *file, const MetadataStream *, std::uint64_t &address) override
Definition: metadata_tables.h:1072
std::uint32_t processor
Definition: metadata_tables.h:1070
Definition: metadata_tables.h:1131
std::uint32_t osMinorVersion
Definition: metadata_tables.h:1134
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1137
std::uint32_t osMajorVersion
Definition: metadata_tables.h:1133
AssemblyRefTableIndex assemblyRef
Definition: metadata_tables.h:1135
std::uint32_t osPlatformId
Definition: metadata_tables.h:1132
Definition: metadata_tables.h:1119
std::uint32_t processor
Definition: metadata_tables.h:1120
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1123
AssemblyRefTableIndex assemblyRef
Definition: metadata_tables.h:1121
Definition: metadata_tables.h:181
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:182
Definition: metadata_tables.h:1093
BlobStreamIndex hashValue
Definition: metadata_tables.h:1102
std::uint16_t minorVersion
Definition: metadata_tables.h:1095
std::uint16_t majorVersion
Definition: metadata_tables.h:1094
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1104
std::uint32_t flags
Definition: metadata_tables.h:1098
std::uint16_t buildNumber
Definition: metadata_tables.h:1096
StringStreamIndex name
Definition: metadata_tables.h:1100
StringStreamIndex culture
Definition: metadata_tables.h:1101
std::uint16_t revisionNumber
Definition: metadata_tables.h:1097
BlobStreamIndex publicKeyOrToken
Definition: metadata_tables.h:1099
Definition: metadata_tables.h:1043
std::uint32_t hashAlgId
Definition: metadata_tables.h:1044
std::uint16_t buildNumber
Definition: metadata_tables.h:1047
std::uint16_t revisionNumber
Definition: metadata_tables.h:1048
BlobStreamIndex publicKey
Definition: metadata_tables.h:1050
StringStreamIndex culture
Definition: metadata_tables.h:1052
std::uint32_t flags
Definition: metadata_tables.h:1049
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1054
std::uint16_t minorVersion
Definition: metadata_tables.h:1046
StringStreamIndex name
Definition: metadata_tables.h:1051
std::uint16_t majorVersion
Definition: metadata_tables.h:1045
Definition: metadata_tables.h:567
T loadIndex(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address)
Definition: metadata_tables.h:580
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address)=0
std::uint32_t getIndexSize(const MetadataStream *stream)
virtual ~BaseRecord()=default
T loadUInt(const FileFormat *file, std::uint64_t &address)
Definition: metadata_tables.h:136
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:137
Definition: metadata_tables.h:847
TypeDefTableIndex parent
Definition: metadata_tables.h:850
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:852
std::uint16_t packingSize
Definition: metadata_tables.h:848
std::uint32_t classSize
Definition: metadata_tables.h:849
Definition: metadata_tables.h:125
virtual bool getTable(MetadataTableType &result) const =0
Definition: metadata_tables.h:792
std::uint8_t type
Definition: metadata_tables.h:793
BlobStreamIndex value
Definition: metadata_tables.h:795
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:797
HasConstant parent
Definition: metadata_tables.h:794
Definition: metadata_tables.h:482
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:484
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:483
Definition: metadata_tables.h:807
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:812
CustomAttributeType type
Definition: metadata_tables.h:809
HasCustomAttribute parent
Definition: metadata_tables.h:808
BlobStreamIndex value
Definition: metadata_tables.h:810
Definition: metadata_tables.h:833
HasDeclSecurity parent
Definition: metadata_tables.h:835
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:838
std::uint16_t action
Definition: metadata_tables.h:834
BlobStreamIndex permissionSet
Definition: metadata_tables.h:836
Definition: metadata_tables.h:609
std::uint16_t generation
Definition: metadata_tables.h:610
GuidStreamIndex mvId
Definition: metadata_tables.h:612
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:616
StringStreamIndex name
Definition: metadata_tables.h:611
GuidStreamIndex encBaseId
Definition: metadata_tables.h:614
GuidStreamIndex encId
Definition: metadata_tables.h:613
Definition: metadata_tables.h:1021
std::uint32_t token
Definition: metadata_tables.h:1022
std::uint32_t funcCode
Definition: metadata_tables.h:1023
virtual void load(const FileFormat *file, const MetadataStream *, std::uint64_t &address) override
Definition: metadata_tables.h:1025
Definition: metadata_tables.h:1033
virtual void load(const FileFormat *file, const MetadataStream *, std::uint64_t &address) override
Definition: metadata_tables.h:1036
std::uint32_t token
Definition: metadata_tables.h:1034
Definition: metadata_tables.h:883
EventTableIndex eventList
Definition: metadata_tables.h:885
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:887
TypeDefTableIndex parent
Definition: metadata_tables.h:884
Definition: metadata_tables.h:166
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:167
Definition: metadata_tables.h:895
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:900
TypeDefOrRef eventType
Definition: metadata_tables.h:898
StringStreamIndex name
Definition: metadata_tables.h:897
std::uint16_t eventFlags
Definition: metadata_tables.h:896
Definition: metadata_tables.h:1161
Implementation implementation
Definition: metadata_tables.h:1166
StringStreamIndex typeName
Definition: metadata_tables.h:1164
std::uint32_t flags
Definition: metadata_tables.h:1162
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1168
std::uint32_t typeDefId
Definition: metadata_tables.h:1163
StringStreamIndex typeNamespace
Definition: metadata_tables.h:1165
Definition: metadata_tables.h:861
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:865
FieldTableIndex field
Definition: metadata_tables.h:863
std::uint32_t offset
Definition: metadata_tables.h:862
Definition: metadata_tables.h:821
HasFieldMarshal parent
Definition: metadata_tables.h:822
BlobStreamIndex nativeType
Definition: metadata_tables.h:823
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:825
Definition: metadata_tables.h:673
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:676
FieldTableIndex field
Definition: metadata_tables.h:674
Definition: metadata_tables.h:1009
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1013
std::uint32_t rva
Definition: metadata_tables.h:1010
FieldTableIndex field
Definition: metadata_tables.h:1011
Definition: metadata_tables.h:146
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:147
Definition: metadata_tables.h:683
bool isPublic() const
Definition: metadata_tables.h:688
std::uint16_t flags
Definition: metadata_tables.h:684
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:693
bool isPrivate() const
Definition: metadata_tables.h:690
StringStreamIndex name
Definition: metadata_tables.h:685
BlobStreamIndex signature
Definition: metadata_tables.h:686
bool isStatic() const
Definition: metadata_tables.h:691
bool isProtected() const
Definition: metadata_tables.h:689
Definition: metadata_tables.h:1147
StringStreamIndex name
Definition: metadata_tables.h:1149
BlobStreamIndex hashValue
Definition: metadata_tables.h:1150
std::uint32_t flags
Definition: metadata_tables.h:1148
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1152
Definition: metadata_tables.h:1235
GenericParamTableIndex owner
Definition: metadata_tables.h:1236
TypeDefOrRef constraint
Definition: metadata_tables.h:1237
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1239
Definition: metadata_tables.h:186
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:187
Definition: metadata_tables.h:1207
std::uint16_t number
Definition: metadata_tables.h:1208
StringStreamIndex name
Definition: metadata_tables.h:1211
TypeDefOrMethodDef owner
Definition: metadata_tables.h:1210
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1213
std::uint16_t flags
Definition: metadata_tables.h:1209
Definition: metadata_tables.h:141
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:142
Definition: metadata_tables.h:215
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:217
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:216
Definition: metadata_tables.h:239
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:240
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:241
Definition: metadata_tables.h:341
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:342
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:343
Definition: metadata_tables.h:320
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:322
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:321
Definition: metadata_tables.h:395
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:397
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:396
Definition: metadata_tables.h:993
std::uint16_t mappingFlags
Definition: metadata_tables.h:994
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:999
MemberForwarded memberForwarded
Definition: metadata_tables.h:995
StringStreamIndex importName
Definition: metadata_tables.h:996
ModuleRefTableIndex importScope
Definition: metadata_tables.h:997
Definition: metadata_tables.h:458
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:459
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:460
Definition: metadata_tables.h:112
std::uint64_t index
Definition: metadata_tables.h:114
constexpr std::uint64_t maskForBits(std::uint64_t bits) const
Definition: metadata_tables.h:116
virtual std::uint64_t getIndex() const =0
void setIndex(std::uint64_t newIndex)
Definition: metadata_tables.h:121
std::uint64_t getRawIndex() const
Definition: metadata_tables.h:118
Definition: metadata_tables.h:766
TypeDefOrRef interfaceType
Definition: metadata_tables.h:768
TypeDefTableIndex classType
Definition: metadata_tables.h:767
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:770
Definition: metadata_tables.h:1179
std::uint32_t offset
Definition: metadata_tables.h:1180
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1185
Implementation implementation
Definition: metadata_tables.h:1183
StringStreamIndex name
Definition: metadata_tables.h:1182
std::uint32_t flags
Definition: metadata_tables.h:1181
Definition: metadata_tables.h:437
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:438
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:439
Definition: metadata_tables.h:365
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:367
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:366
Definition: metadata_tables.h:778
MemberRefParent classType
Definition: metadata_tables.h:779
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:783
BlobStreamIndex signature
Definition: metadata_tables.h:781
StringStreamIndex name
Definition: metadata_tables.h:780
Definition: metadata_tables.h:416
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:418
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:417
Definition: metadata_tables.h:151
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:152
Definition: metadata_tables.h:712
bool isAbstract() const
Definition: metadata_tables.h:726
StringStreamIndex name
Definition: metadata_tables.h:716
BlobStreamIndex signature
Definition: metadata_tables.h:717
bool isPrivate() const
Definition: metadata_tables.h:721
std::uint16_t implFlags
Definition: metadata_tables.h:714
bool isProtected() const
Definition: metadata_tables.h:722
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:728
std::uint16_t flags
Definition: metadata_tables.h:715
ParamTableIndex paramList
Definition: metadata_tables.h:718
bool isVirtual() const
Definition: metadata_tables.h:724
bool isPublic() const
Definition: metadata_tables.h:720
std::uint32_t rva
Definition: metadata_tables.h:713
bool isFinal() const
Definition: metadata_tables.h:725
bool isStatic() const
Definition: metadata_tables.h:723
Definition: metadata_tables.h:959
MethodDefOrRef methodBody
Definition: metadata_tables.h:961
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:964
MethodDefOrRef methodDeclaration
Definition: metadata_tables.h:962
TypeDefTableIndex classType
Definition: metadata_tables.h:960
Definition: metadata_tables.h:702
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:705
MethodDefTableIndex method
Definition: metadata_tables.h:703
Definition: metadata_tables.h:945
std::uint16_t semantics
Definition: metadata_tables.h:946
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:950
MethodDefTableIndex method
Definition: metadata_tables.h:947
HasSemantics association
Definition: metadata_tables.h:948
Definition: metadata_tables.h:1223
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1227
BlobStreamIndex instantiation
Definition: metadata_tables.h:1225
MethodDefOrRef method
Definition: metadata_tables.h:1224
Definition: metadata_tables.h:176
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:177
Definition: metadata_tables.h:973
StringStreamIndex name
Definition: metadata_tables.h:974
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:976
Definition: metadata_tables.h:1195
TypeDefTableIndex enclosingClass
Definition: metadata_tables.h:1197
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:1199
TypeDefTableIndex nestedClass
Definition: metadata_tables.h:1196
Definition: metadata_tables.h:740
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:743
ParamTableIndex param
Definition: metadata_tables.h:741
Definition: metadata_tables.h:156
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:157
Definition: metadata_tables.h:750
std::uint16_t sequence
Definition: metadata_tables.h:752
bool isOut() const
Definition: metadata_tables.h:755
StringStreamIndex name
Definition: metadata_tables.h:753
std::uint16_t flags
Definition: metadata_tables.h:751
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:757
Definition: metadata_tables.h:919
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:923
TypeDefTableIndex parent
Definition: metadata_tables.h:920
PropertyTableIndex propertyList
Definition: metadata_tables.h:921
Definition: metadata_tables.h:909
PropertyTableIndex property
Definition: metadata_tables.h:910
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:912
Definition: metadata_tables.h:171
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:172
Definition: metadata_tables.h:931
StringStreamIndex name
Definition: metadata_tables.h:933
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:936
BlobStreamIndex type
Definition: metadata_tables.h:934
std::uint16_t flags
Definition: metadata_tables.h:932
Definition: metadata_tables.h:503
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:504
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:505
Definition: metadata_tables.h:873
BlobStreamIndex signature
Definition: metadata_tables.h:874
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:876
Definition: metadata_tables.h:131
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:132
Definition: metadata_tables.h:530
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:531
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:532
Definition: metadata_tables.h:191
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:192
virtual bool getTable(MetadataTableType &result) const override
Definition: metadata_tables.h:193
Definition: metadata_tables.h:161
virtual std::uint64_t getIndex() const override
Definition: metadata_tables.h:162
Definition: metadata_tables.h:641
FieldTableIndex fieldList
Definition: metadata_tables.h:646
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:661
bool isSealed() const
Definition: metadata_tables.h:657
bool isNestedProtected() const
Definition: metadata_tables.h:653
bool isAbstract() const
Definition: metadata_tables.h:656
bool isNestedPrivate() const
Definition: metadata_tables.h:652
TypeDefOrRef extends
Definition: metadata_tables.h:645
bool hasAnsiName() const
Definition: metadata_tables.h:658
bool isClass() const
Definition: metadata_tables.h:654
bool isInterface() const
Definition: metadata_tables.h:655
bool isPublic() const
Definition: metadata_tables.h:650
StringStreamIndex typeNamespace
Definition: metadata_tables.h:644
bool isNestedPublic() const
Definition: metadata_tables.h:651
bool isNonPublic() const
Definition: metadata_tables.h:649
StringStreamIndex typeName
Definition: metadata_tables.h:643
bool hasUnicodeName() const
Definition: metadata_tables.h:659
std::uint32_t flags
Definition: metadata_tables.h:642
MethodDefTableIndex methodList
Definition: metadata_tables.h:647
Definition: metadata_tables.h:627
ResolutionScope resolutionScope
Definition: metadata_tables.h:628
StringStreamIndex typeName
Definition: metadata_tables.h:629
StringStreamIndex typeNamespace
Definition: metadata_tables.h:630
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:632
Definition: metadata_tables.h:983
BlobStreamIndex signature
Definition: metadata_tables.h:984
virtual void load(const FileFormat *file, const MetadataStream *stream, std::uint64_t &address) override
Definition: metadata_tables.h:986