retdec
pdb_types.h
Go to the documentation of this file.
1 
7 #ifndef RETDEC_PDBPARSER_PDB_TYPES_H
8 #define RETDEC_PDBPARSER_PDB_TYPES_H
9 
10 #include <cstdio>
11 
14 
15 namespace retdec {
16 namespace pdbparser {
17 
18 // PDB type definition
19 class PDBTypeDef;
20 // PDB type definition map (key is type index)
21 typedef std::map<int, PDBTypeDef *> PDBTypeDefIndexMap;
22 // PDB type definition map - for fully defined types (key is type name)
23 typedef std::map<std::string, PDBTypeDef *> PDBTypeDefNameMap;
24 
25 // =================================================================
26 // PDB TYPE FIELD STRUCTURES
27 // =================================================================
28 
29 // Field type
31 {
33 };
34 
35 // Enum member
36 typedef struct _PDBTypeFieldEnumerate
37 {
38  int value;
39  char * name;
41 
42 // Struct or union member
43 typedef struct _PDBTypeFieldMember
44 {
45  int offset;
48  char * name;
50 
51 // General type field
52 typedef struct _PDBTypeField
53 {
55  union
56  {
59  };
61 
62 // =================================================================
63 // PDB TYPE CLASSES
64 // =================================================================
65 
66 // Type class
68 {
69  PDBTYPE_BASE, PDBTYPE_FIELDLIST, // Auxiliary only
74  PDBTYPE_ARGLIST, // Auxiliary only
79 };
80 
81 // Type definition (base class)
82 // Class fully defined here
84 {
85  // Constructor and destructor
86  protected:
87  PDBTypeDef(int ind, ePDBTypeClass c, int bts = 0) :
88  type_index(ind), type_class(c), size_bytes(bts)
89  {
90  }
91  ;
92  public:
93  virtual ~PDBTypeDef(void)
94  {
95  }
96  ;
97 
98  // Basic methods - parse and dump
99 // matula, this triggers clang warning, since 'parse' methods in child classes have different signature.
100  virtual void dump(bool nested = false)
101  {
102  if (!nested)
103  printf("/* %04x (%d bytes) */\n", type_index, size_bytes);
104  }
105  ;
106  virtual bool is_fully_defined(void)
107  {
108  return false;
109  }
110  ;
111  virtual std::string to_llvm(void)
112  {
113  return get_default_llvm();
114  }
115  ;
116  virtual std::string to_llvm_identified(void)
117  {
118  return to_llvm();
119  }
120  ;
121  std::string get_default_llvm(void)
122  {
123  return "i32";
124  }
125  ;
126 
127  // Basic members
131 };
132 
134 {
142 };
143 
144 // Base type
145 class PDBTypeBase : public PDBTypeDef
146 {
147  public:
148  // Constructor and destructor
149  PDBTypeBase(int ind, ePDBBaseType t, bool ptr, int bits, const char * desc) :
150  PDBTypeDef(ind, PDBTYPE_BASE, (ptr) ? 4 : bits / 8), base_type(t), is_pointer(ptr), size_bits(bits), description(
151  desc)
152  {
153  }
154  ;
155  virtual ~PDBTypeBase(void)
156  {
157  }
158  ;
159 
160  // Basic methods - parse and dump
161  virtual void parse(lfRecord *, int, PDBTypeDefIndexMap &)
162  {
163  }
164  ;
165  virtual void dump(bool nested = false);
166  virtual bool is_fully_defined(void)
167  {
168  return true;
169  }
170  ;
171  virtual std::string to_llvm(void);
172  virtual std::string to_llvm_identified(void)
173  {
174  return to_llvm();
175  }
176  ;
177 
178  // Type-specific members
179  ePDBBaseType base_type; // Base type (void, int, float...)
180  bool is_pointer; // Is pointer?
181  int size_bits; // Number of bits
182  const char * description; // Textual description
183 };
184 
185 // Field list (auxiliary type only!!!)
187 {
188  public:
189  // Constructor and destructor
190  PDBTypeFieldList(int ind) :
192  {
193  }
194  ;
195  virtual ~PDBTypeFieldList(void)
196  {
197  }
198  ;
199 
200  // Basic methods - parse and dump
201  virtual void parse(lfFieldList *record, int size, PDBTypeDefIndexMap &types);
202  virtual void dump(bool nested = false);
203  virtual bool is_fully_defined(void)
204  {
205  return false;
206  }
207  ;
208  virtual std::string to_llvm(void)
209  {
210  return get_default_llvm();
211  }
212  ;
213  virtual std::string to_llvm_identified(void)
214  {
215  return to_llvm();
216  }
217  ;
218 
219  // Type-specific members
220  std::vector<PDBTypeField> fields; // Fields
221 };
222 
223 // Enum
224 class PDBTypeEnum : public PDBTypeDef
225 {
226  public:
227  // Constructor and destructor
228  PDBTypeEnum(int ind) :
229  PDBTypeDef(ind, PDBTYPE_ENUM), enum_count(0), enum_members(nullptr), enum_name(nullptr)
230  {
231  }
232  ;
233  virtual ~PDBTypeEnum(void)
234  {
235  if (enum_members != nullptr)
236  delete[] enum_members;
237  }
238  ;
239 
240  // Basic methods - parse and dump
241  virtual void parse(lfEnum *record, int size, PDBTypeDefIndexMap &types);
242  virtual void dump(bool nested = false);
243  virtual bool is_fully_defined(void)
244  {
245  return enum_members != nullptr;
246  }
247  ;
248  virtual std::string to_llvm(void);
249  virtual std::string to_llvm_identified(void)
250  {
251  return to_llvm();
252  }
253  ;
254 
255  // Type-specific members
256  unsigned int enum_count; // Number of members
258  char * enum_name; // Enum name
259 };
260 
261 // Array
262 class PDBTypeArray : public PDBTypeDef
263 {
264  public:
265  // Constructor and destructor
266  PDBTypeArray(int ind) :
268  0), array_idxtype_def(nullptr), array_count(0)
269  {
270  }
271  ;
272  virtual ~PDBTypeArray(void)
273  {
274  }
275  ;
276 
277  // Basic methods - parse and dump
278  virtual void parse(lfArray *record, int size, PDBTypeDefIndexMap &types);
279  virtual void dump(bool nested = false);
280  virtual bool is_fully_defined(void)
281  {
282  return true;
283  }
284  ;
285  virtual std::string to_llvm(void);
286  virtual std::string to_llvm_identified(void)
287  {
288  return to_llvm();
289  }
290  ;
291 
292  // Type-specific members
293  int array_elemtype_index; // Element type index
294  PDBTypeDef * array_elemtype_def; // Element type definition
295  int array_idxtype_index; // Indexing type index
296  PDBTypeDef * array_idxtype_def; // Indexing type definition
297  int array_count; // Number of elements
298 };
299 
300 // Pointer
302 {
303  public:
304  // Constructor and destructor
305  PDBTypePointer(int ind) :
307  {
308  }
309  ;
310  virtual ~PDBTypePointer(void)
311  {
312  }
313  ;
314 
315  // Basic methods - parse and dump
316  virtual void parse(lfPointer *record, int size, PDBTypeDefIndexMap &types);
317  virtual void dump(bool nested = false);
318  virtual bool is_fully_defined(void)
319  {
320  return true;
321  }
322  ;
323  virtual std::string to_llvm(void);
324  virtual std::string to_llvm_identified(void)
325  {
326  return to_llvm();
327  }
328  ;
329 
330  // Type-specific members
331  int ptr_utype_index; // Underlying type index
332  PDBTypeDef * ptr_utype_def; // Underlying type definition
333 };
334 
335 // Constant
336 class PDBTypeConst : public PDBTypeDef
337 {
338  public:
339  // Constructor and destructor
340  PDBTypeConst(int ind) :
342  {
343  }
344  ;
345  virtual ~PDBTypeConst(void)
346  {
347  }
348  ;
349 
350  // Basic methods - parse and dump
351  virtual void parse(lfModifier *record, int, PDBTypeDefIndexMap &types);
352  virtual void dump(bool nested = false);
353  virtual bool is_fully_defined(void)
354  {
355  return true;
356  }
357  ;
358  virtual std::string to_llvm(void);
359  virtual std::string to_llvm_identified(void)
360  {
361  return to_llvm();
362  }
363  ;
364 
365  // Type-specific members
366  int const_utype_index; // Underlying type index
367  PDBTypeDef * const_utype_def; // Underlying type definition
368 };
369 
370 // Argument list (auxiliary type only!!!)
371 // Class fully defined here
373 {
374  public:
375  // Constructor and destructor
376  PDBTypeArglist(int ind) :
377  PDBTypeDef(ind, PDBTYPE_ARGLIST), arglist(nullptr)
378  {
379  }
380  ;
381  virtual ~PDBTypeArglist(void)
382  {
383  }
384  ;
385 
386  // Basic methods - parse and dump
387  virtual void parse(lfArgList *record, int, PDBTypeDefIndexMap &)
388  {
389  arglist = record;
390  }
391  ;
392  virtual void dump(bool nested = false)
393  {
394  PDBTypeDef::dump(nested);
395  if (!nested)
396  printf("/* Argument list */\n");
397  }
398  ;
399  virtual bool is_fully_defined(void)
400  {
401  return false;
402  }
403  ;
404  virtual std::string to_llvm(void)
405  {
406  return "...";
407  }
408  ;
409  virtual std::string to_llvm_identified(void)
410  {
411  return to_llvm();
412  }
413  ;
414 
415  // Type-specific members
416  lfArgList * arglist; // Argument list record
417 };
418 
419 // Function argument
420 typedef struct _PDBTypeFuncArg
421 {
425 
426 // Function declaration
428 {
429  public:
430  // Constructor and destructor
431  PDBTypeFunction(int ind) :
434  nullptr), func_thistype_index(0), func_thistype_def(nullptr)
435  {
436  }
437  ;
438  virtual ~PDBTypeFunction(void)
439  {
440  if (func_args != nullptr)
441  delete[] func_args;
442  }
443  ;
444 
445  // Basic methods - parse and dump
446  virtual void parse(lfProc *record, int size, PDBTypeDefIndexMap &types);
447  void parse_mfunc(lfMFunc *record, int size, PDBTypeDefIndexMap &types);
448  virtual void dump(bool nested = false);
449  virtual bool is_fully_defined(void)
450  {
451  return func_args != nullptr;
452  }
453  ;
454  virtual std::string to_llvm(void);
455  virtual std::string to_llvm_identified(void)
456  {
457  return to_llvm();
458  }
459  ;
460 
461  // Type-specific members
462  int func_rettype_index; // Return value type index
463  PDBTypeDef * func_rettype_def; // Return value type definition
464  int func_calltype; // Calling convention
465  int func_args_count; // Number of arguments
466  PDBTypeFuncArg * func_args; // Arguments
467  bool func_is_variadic; // Variadic parameters function
468  bool func_is_clsmember; // Function is class method
469  int func_clstype_index; // Parent class type index
470  PDBTypeDef * func_clstype_def; // Parent class type definition
471  int func_thistype_index; // This-parameter type index
472  PDBTypeDef * func_thistype_def; // This-parameter class type definition
473 };
474 
475 // Struct
476 class PDBTypeStruct : public PDBTypeDef
477 {
478  public:
479  // Constructor and destructor
480  PDBTypeStruct(int ind) :
482  {
483  }
484  ;
485  virtual ~PDBTypeStruct(void)
486  {
487  }
488  ;
489 
490  // Basic methods - parse and dump
491  virtual void parse(lfStructure *record, int size, PDBTypeDefIndexMap &types);
492  virtual void dump(bool nested = false);
493  virtual bool is_fully_defined(void)
494  {
495  return struct_count > 0;
496  }
497  ;
498  virtual std::string to_llvm(void);
499  virtual std::string to_llvm_identified(void);
500 
501  // Type-specific members
502  unsigned int struct_count; // Number of members
503  std::vector<PDBTypeFieldMember *> struct_members; // Members
504  std::string struct_name; // Struct name
505 };
506 
507 // Union
508 class PDBTypeUnion : public PDBTypeDef
509 {
510  public:
511  // Constructor and destructor
512  PDBTypeUnion(int ind) :
513  PDBTypeDef(ind, PDBTYPE_UNION), union_count(0), union_name(nullptr)
514  {
515  }
516  ;
517  virtual ~PDBTypeUnion(void)
518  {
519  }
520  ;
521 
522  // Basic methods - parse and dump
523  virtual void parse(lfUnion *record, int size, PDBTypeDefIndexMap &types);
524  virtual void dump(bool nested = false);
525  virtual bool is_fully_defined(void)
526  {
527  return union_count > 0;
528  }
529  ;
530  virtual std::string to_llvm(void);
531  virtual std::string to_llvm_identified(void)
532  {
533  return to_llvm();
534  }
535  ;
536 
537  // Type-specific members
538  unsigned int union_count; // Number of members
539  std::vector<PDBTypeFieldMember *> union_members; // Members
540  char * union_name; // Union name
541 };
542 
543 // Class
544 class PDBTypeClass : public PDBTypeDef
545 {
546  public:
547  // Constructor and destructor
548  PDBTypeClass(int ind) :
549  PDBTypeDef(ind, PDBTYPE_CLASS), class_count(0), class_name(nullptr)
550  {
551  }
552  ;
553  virtual ~PDBTypeClass(void)
554  {
555  }
556  ;
557 
558  // Basic methods - parse and dump
559  virtual void parse(lfClass *record, int size, PDBTypeDefIndexMap &types);
560  virtual void dump(bool nested = false);
561  virtual bool is_fully_defined(void)
562  {
563  return class_count > 0;
564  }
565  ;
566  virtual std::string to_llvm(void);
567  virtual std::string to_llvm_identified(void)
568  {
569  return to_llvm();
570  }
571  ;
572 
573  // Type-specific members
574  unsigned int class_count; // Number of members
575  char * class_name; // Class name
576  //TODO methods, attributes, etc...
577 };
578 
579 // =================================================================
580 // MAIN CLASS PDBTypes
581 // =================================================================
582 
583 class PDBTypes
584 {
585  public:
586  // Constructor and destructor
588  pdb_tpi_size(s->size), pdb_tpi_data(s->data), parsed(false), tpi_header(
589  reinterpret_cast<HDR *>(s->data))
590  {
591  }
592  ;
593  ~PDBTypes(void);
594 
595  // Action methods
596  void parse_types(void);
597 
598  // Getting methods
600  {
601  if (!parsed)
602  return nullptr;
603  else
604  return types[index];
605  }
606  ;
608  {
609  if (!parsed)
610  return nullptr;
611  else
612  return types_byname[name];
613  }
614  ;
615 
616  // Printing methods
617  void dump_types(void);
618  void print_types(void);
619 
620  public:
621  // Internal functions
623 
624  // Variables
625  unsigned int pdb_tpi_size; // size of TPI stream
626  char * pdb_tpi_data; // data from TPI stream
627  bool parsed; // types are parsed
628 
629  // Data structure pointers
631 
632  // Data containers
633  PDBTypeDefIndexMap types; // Map of type definitions (key is type index)
634  PDBTypeDefIndexMap types_fully_defined; // Map of fully defined types (key is type index)
635  PDBTypeDefNameMap types_byname; // Map of fully defined types (key is type name)
636 };
637 
638 } // namespace pdbparser
639 } // namespace retdec
640 
641 #endif
Definition: pdb_types.h:373
virtual void parse(lfArgList *record, int, PDBTypeDefIndexMap &)
Definition: pdb_types.h:387
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:409
virtual bool is_fully_defined(void)
Definition: pdb_types.h:399
PDBTypeArglist(int ind)
Definition: pdb_types.h:376
lfArgList * arglist
Definition: pdb_types.h:413
virtual std::string to_llvm(void)
Definition: pdb_types.h:404
virtual void dump(bool nested=false)
Definition: pdb_types.h:392
virtual ~PDBTypeArglist(void)
Definition: pdb_types.h:381
Definition: pdb_types.h:263
PDBTypeArray(int ind)
Definition: pdb_types.h:266
PDBTypeDef * array_elemtype_def
Definition: pdb_types.h:294
int array_count
Definition: pdb_types.h:297
int array_elemtype_index
Definition: pdb_types.h:290
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:262
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:286
virtual ~PDBTypeArray(void)
Definition: pdb_types.h:272
int array_idxtype_index
Definition: pdb_types.h:295
virtual void parse(lfArray *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:229
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:248
virtual bool is_fully_defined(void)
Definition: pdb_types.h:280
PDBTypeDef * array_idxtype_def
Definition: pdb_types.h:296
Definition: pdb_types.h:146
PDBTypeBase(int ind, ePDBBaseType t, bool ptr, int bits, const char *desc)
Definition: pdb_types.h:149
ePDBBaseType base_type
Definition: pdb_types.h:176
bool is_pointer
Definition: pdb_types.h:180
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:27
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:172
virtual void parse(lfRecord *, int, PDBTypeDefIndexMap &)
Definition: pdb_types.h:161
const char * description
Definition: pdb_types.h:182
int size_bits
Definition: pdb_types.h:181
virtual bool is_fully_defined(void)
Definition: pdb_types.h:166
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:35
virtual ~PDBTypeBase(void)
Definition: pdb_types.h:155
Definition: pdb_types.h:545
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:645
virtual ~PDBTypeClass(void)
Definition: pdb_types.h:553
virtual bool is_fully_defined(void)
Definition: pdb_types.h:561
char * class_name
Definition: pdb_types.h:575
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:567
virtual void parse(lfClass *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:625
unsigned int class_count
Definition: pdb_types.h:571
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:637
PDBTypeClass(int ind)
Definition: pdb_types.h:548
Definition: pdb_types.h:337
int const_utype_index
Definition: pdb_types.h:363
virtual void parse(lfModifier *record, int, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:315
PDBTypeDef * const_utype_def
Definition: pdb_types.h:367
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:359
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:323
virtual bool is_fully_defined(void)
Definition: pdb_types.h:353
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:335
virtual ~PDBTypeConst(void)
Definition: pdb_types.h:345
PDBTypeConst(int ind)
Definition: pdb_types.h:340
Definition: pdb_types.h:84
virtual bool is_fully_defined(void)
Definition: pdb_types.h:106
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:116
std::string get_default_llvm(void)
Definition: pdb_types.h:121
virtual std::string to_llvm(void)
Definition: pdb_types.h:111
virtual ~PDBTypeDef(void)
Definition: pdb_types.h:93
virtual void dump(bool nested=false)
Definition: pdb_types.h:100
PDBTypeDef(int ind, ePDBTypeClass c, int bts=0)
Definition: pdb_types.h:87
int type_index
Definition: pdb_types.h:125
int size_bytes
Definition: pdb_types.h:130
ePDBTypeClass type_class
Definition: pdb_types.h:129
Definition: pdb_types.h:225
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:218
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:198
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:249
virtual ~PDBTypeEnum(void)
Definition: pdb_types.h:233
unsigned int enum_count
Definition: pdb_types.h:253
PDBTypeFieldEnumerate ** enum_members
Definition: pdb_types.h:257
char * enum_name
Definition: pdb_types.h:258
PDBTypeEnum(int ind)
Definition: pdb_types.h:228
virtual void parse(lfEnum *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:171
virtual bool is_fully_defined(void)
Definition: pdb_types.h:243
Definition: pdb_types.h:187
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:213
PDBTypeFieldList(int ind)
Definition: pdb_types.h:190
virtual ~PDBTypeFieldList(void)
Definition: pdb_types.h:195
virtual bool is_fully_defined(void)
Definition: pdb_types.h:203
std::vector< PDBTypeField > fields
Definition: pdb_types.h:217
virtual std::string to_llvm(void)
Definition: pdb_types.h:208
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:158
virtual void parse(lfFieldList *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:79
Definition: pdb_types.h:428
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:455
int func_clstype_index
Definition: pdb_types.h:469
PDBTypeDef * func_rettype_def
Definition: pdb_types.h:463
virtual void parse(lfProc *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:346
int func_thistype_index
Definition: pdb_types.h:471
bool func_is_variadic
Definition: pdb_types.h:467
int func_calltype
Definition: pdb_types.h:464
virtual bool is_fully_defined(void)
Definition: pdb_types.h:449
int func_rettype_index
Definition: pdb_types.h:459
PDBTypeFuncArg * func_args
Definition: pdb_types.h:466
PDBTypeDef * func_thistype_def
Definition: pdb_types.h:472
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:461
void parse_mfunc(lfMFunc *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:379
PDBTypeDef * func_clstype_def
Definition: pdb_types.h:470
bool func_is_clsmember
Definition: pdb_types.h:468
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:412
int func_args_count
Definition: pdb_types.h:465
virtual ~PDBTypeFunction(void)
Definition: pdb_types.h:438
PDBTypeFunction(int ind)
Definition: pdb_types.h:431
Definition: pdb_types.h:302
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:303
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:285
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:324
PDBTypeDef * ptr_utype_def
Definition: pdb_types.h:332
virtual ~PDBTypePointer(void)
Definition: pdb_types.h:310
virtual bool is_fully_defined(void)
Definition: pdb_types.h:318
int ptr_utype_index
Definition: pdb_types.h:328
PDBTypePointer(int ind)
Definition: pdb_types.h:305
virtual void parse(lfPointer *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:276
Definition: pdb_types.h:477
virtual void parse(lfStructure *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:472
virtual std::string to_llvm_identified(void)
Definition: pdb_types.cpp:554
virtual ~PDBTypeStruct(void)
Definition: pdb_types.h:485
PDBTypeStruct(int ind)
Definition: pdb_types.h:480
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:528
std::vector< PDBTypeFieldMember * > struct_members
Definition: pdb_types.h:503
unsigned int struct_count
Definition: pdb_types.h:502
std::string struct_name
Definition: pdb_types.h:504
virtual bool is_fully_defined(void)
Definition: pdb_types.h:493
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:503
Definition: pdb_types.h:509
virtual bool is_fully_defined(void)
Definition: pdb_types.h:525
virtual ~PDBTypeUnion(void)
Definition: pdb_types.h:517
virtual void parse(lfUnion *record, int size, PDBTypeDefIndexMap &types)
Definition: pdb_types.cpp:565
virtual std::string to_llvm(void)
Definition: pdb_types.cpp:614
std::vector< PDBTypeFieldMember * > union_members
Definition: pdb_types.h:539
unsigned int union_count
Definition: pdb_types.h:535
PDBTypeUnion(int ind)
Definition: pdb_types.h:512
char * union_name
Definition: pdb_types.h:540
virtual void dump(bool nested=false)
Definition: pdb_types.cpp:589
virtual std::string to_llvm_identified(void)
Definition: pdb_types.h:531
Definition: pdb_types.h:584
~PDBTypes(void)
Definition: pdb_types.cpp:1281
void dump_types(void)
Definition: pdb_types.cpp:1255
PDBTypes(PDBStream *s)
Definition: pdb_types.h:587
HDR * tpi_header
Definition: pdb_types.h:630
PDBTypeDef * get_type_by_name(char *name)
Definition: pdb_types.h:607
void parse_types(void)
Definition: pdb_types.cpp:1070
unsigned int pdb_tpi_size
Definition: pdb_types.h:625
void print_types(void)
Definition: pdb_types.cpp:1262
bool parsed
Definition: pdb_types.h:627
PDBTypeDefIndexMap types_fully_defined
Definition: pdb_types.h:634
char * pdb_tpi_data
Definition: pdb_types.h:626
PDBTypeDef * get_type_by_index(int index)
Definition: pdb_types.h:599
PDBTypeDefIndexMap types
Definition: pdb_types.h:633
PDBTypeDefNameMap types_byname
Definition: pdb_types.h:635
PDB info.
struct retdec::pdbparser::_PDBTypeField PDBTypeField
ePDBFieldType
Definition: pdb_types.h:31
@ PDBFIELD_MEMBER
Definition: pdb_types.h:32
@ PDBFIELD_ENUMERATE
Definition: pdb_types.h:32
ePDBBaseType
Definition: pdb_types.h:134
@ PDBBASETYPE_VARIADIC
Definition: pdb_types.h:141
@ PDBBASETYPE_BOOL
Definition: pdb_types.h:136
@ PDBBASETYPE_INT_UNSIGNED
Definition: pdb_types.h:138
@ PDBBASETYPE_INT_SIGNED
Definition: pdb_types.h:137
@ PDBBASETYPE_HRESULT
Definition: pdb_types.h:140
@ PDBBASETYPE_FLOAT
Definition: pdb_types.h:139
@ PDBBASETYPE_VOID
Definition: pdb_types.h:135
std::map< int, PDBTypeDef * > PDBTypeDefIndexMap
Definition: pdb_types.h:19
struct retdec::pdbparser::_PDBTypeFieldEnumerate PDBTypeFieldEnumerate
std::map< std::string, PDBTypeDef * > PDBTypeDefNameMap
Definition: pdb_types.h:23
struct retdec::pdbparser::_PDBTypeFuncArg PDBTypeFuncArg
struct retdec::pdbparser::_PDBTypeFieldMember PDBTypeFieldMember
ePDBTypeClass
Definition: pdb_types.h:68
@ PDBTYPE_ARRAY
Definition: pdb_types.h:71
@ PDBTYPE_BASE
Definition: pdb_types.h:69
@ PDBTYPE_UNION
Definition: pdb_types.h:77
@ PDBTYPE_POINTER
Definition: pdb_types.h:72
@ PDBTYPE_ARGLIST
Definition: pdb_types.h:74
@ PDBTYPE_ENUM
Definition: pdb_types.h:70
@ PDBTYPE_CLASS
Definition: pdb_types.h:78
@ PDBTYPE_STRUCT
Definition: pdb_types.h:76
@ PDBTYPE_FIELDLIST
Definition: pdb_types.h:69
@ PDBTYPE_FUNCTION
Definition: pdb_types.h:75
@ PDBTYPE_CONST
Definition: pdb_types.h:73
Definition: archive_wrapper.h:19
Definition: pdb_info.h:1058
Definition: pdb_utils.h:95
char * name
Definition: pdb_types.h:39
int value
Definition: pdb_types.h:38
Definition: pdb_types.h:44
char * name
Definition: pdb_types.h:48
PDBTypeDef * type_def
Definition: pdb_types.h:47
int offset
Definition: pdb_types.h:45
int type_index
Definition: pdb_types.h:46
Definition: pdb_types.h:53
PDBTypeFieldEnumerate Enumerate
Definition: pdb_types.h:57
PDBTypeFieldMember Member
Definition: pdb_types.h:58
ePDBFieldType field_type
Definition: pdb_types.h:54
Definition: pdb_types.h:421
int type_index
Definition: pdb_types.h:422
PDBTypeDef * type_def
Definition: pdb_types.h:423
Definition: pdb_info.h:1380
Definition: pdb_info.h:1166
Definition: pdb_info.h:1200
Definition: pdb_info.h:1247
Definition: pdb_info.h:1544
Definition: pdb_info.h:1353
Definition: pdb_info.h:1151
Definition: pdb_info.h:1268
Definition: pdb_info.h:1332
Definition: pdb_info.h:1228
Definition: pdb_info.h:1556