src/kits/debugger/dwarf/TypeUnit.h

   1 /*
   2  * Copyright 2013, Rene Gollent, rene@gollent.com.
   3  * Distributed under the terms of the MIT License.
   4  */
   5 #ifndef TYPE_UNIT_H
   6 #define TYPE_UNIT_H
   7
   8
   9 #include <ObjectList.h>
  10 #include <String.h>
  11
  12 #include "BaseUnit.h"
  13
  14
  15 class DIETypeUnit;
  16
  17
  18 class TypeUnit : public BaseUnit {
  19 public:
  20                                                                 TypeUnit(off_t headerOffset,
  21                                                                         off_t contentOffset,
  22                                                                         off_t totalSize,
  23                                                                         off_t abbreviationOffset,
  24                                                                         off_t typeOffset,
  25                                                                         uint8 addressSize,
  26                                                                         uint64 typeSignature,
  27                                                                         bool isDwarf64);
  28                                                                 ~TypeUnit();
  29
  30                         uint64                          Signature() const       { return fSignature; }
  31
  32                         off_t                           TypeOffset() const      { return fTypeOffset; }
  33
  34
  35                         DIETypeUnit*            UnitEntry() const       { return fUnitEntry; }
  36                         void                            SetUnitEntry(DIETypeUnit* entry);
  37
  38                         DebugInfoEntry*         TypeEntry() const;
  39                         void                            SetTypeEntry(DebugInfoEntry* entry);
  40
  41         virtual dwarf_unit_kind         Kind() const;
  42
  43 private:
  44                         DIETypeUnit*            fUnitEntry;
  45                         DebugInfoEntry*         fTypeEntry;
  46                         uint64                          fSignature;
  47                         off_t                           fTypeOffset;
  48 };
  49
  50
  51 struct TypeUnitTableEntry {
  52         uint64                                  signature;
  53         TypeUnit*                               unit;
  54         TypeUnitTableEntry*             next;
  55
  56         TypeUnitTableEntry(uint64 signature, TypeUnit* unit)
  57                 :
  58                 signature(signature),
  59                 unit(unit)
  60         {
  61         }
  62 };
  63
  64
  65 struct TypeUnitTableHashDefinition {
  66         typedef uint64                                  KeyType;
  67         typedef TypeUnitTableEntry              ValueType;
  68
  69         size_t HashKey(uint64 key) const
  70         {
  71                 return (size_t)key;
  72         }
  73
  74         size_t Hash(TypeUnitTableEntry* value) const
  75         {
  76                 return HashKey(value->signature);
  77         }
  78
  79         bool Compare(uint64 key, TypeUnitTableEntry* value) const
  80         {
  81                 return value->signature == key;
  82         }
  83
  84         TypeUnitTableEntry*& GetLink(TypeUnitTableEntry* value) const
  85         {
  86                 return value->next;
  87         }
  88 };
  89
  90
  91 #endif  // TYPE_UNIT_H