(stabs) Inheritance

Info Catalog

(stabs) Virtual Methods

(stabs) Cplusplus

(stabs) Virtual Base Classes

 
 Inheritance
 ===========
 
    Stabs describing C++ derived classes include additional sections that
 describe the inheritance hierarchy of the class.  A derived class stab
 also encodes the number of base classes.  For each base class it tells
 if the base class is virtual or not, and if the inheritance is private
 or public.  It also gives the offset into the object of the portion of
 the object corresponding to each base class.
 
    This additional information is embedded in the class stab following
 the number of bytes in the struct.  First the number of base classes
 appears bracketed by an exclamation point and a comma.
 
    Then for each base type there repeats a series: a virtual character,
 a visibility character, a number, a comma, another number, and a
 semi-colon.
 
    The virtual character is `1' if the base class is virtual and `0' if
 not.  The visibility character is `2' if the derivation is public, `1'
 if it is protected, and `0' if it is private.  Debuggers should ignore
 virtual or visibility characters they do not recognize, and assume a
 reasonable default (such as public and non-virtual) (GDB 4.11 does not,
 but this should be fixed in the next GDB release).
 
    The number following the virtual and visibility characters is the
 offset from the start of the object to the part of the object
 pertaining to the base class.
 
    After the comma, the second number is a type_descriptor for the base
 type.  Finally a semi-colon ends the series, which repeats for each
 base class.
 
    The source below defines three base classes `A', `B', and `C' and
 the derived class `D'.
 
      class A {
      public:
              int Adat;
              virtual int A_virt (int arg) { return arg; };
      };
      
      class B {
      public:
              int B_dat;
              virtual int B_virt (int arg) {return arg; };
      };
      
      class C {
      public:
              int Cdat;
              virtual int C_virt (int arg) {return arg; };
      };
      
      class D : A, virtual B, public C {
      public:
              int Ddat;
              virtual int A_virt (int arg ) { return arg+1; };
              virtual int B_virt (int arg)  { return arg+2; };
              virtual int C_virt (int arg)  { return arg+3; };
              virtual int D_virt (int arg)  { return arg; };
      };
 
    Class stabs similar to the ones described earlier are generated for
 each base class.
 
      .stabs "A:T20=s8Adat:1,0,32;$vf20:21=*22=ar1;0;1;17,32;
              A_virt::23=##1;:i;2A*-2147483647;20;;;~%20;",128,0,0,0
      
      .stabs "B:Tt25=s8Bdat:1,0,32;$vf25:21,32;B_virt::26=##1;
              :i;2A*-2147483647;25;;;~%25;",128,0,0,0
      
      .stabs "C:Tt28=s8Cdat:1,0,32;$vf28:21,32;C_virt::29=##1;
              :i;2A*-2147483647;28;;;~%28;",128,0,0,0
 
    In the stab describing derived class `D' below, the information about
 the derivation of this class is encoded as follows.
 
      .stabs "derived_class_name:symbol_descriptors(struct tag&type)=
              type_descriptor(struct)struct_bytes(32)!num_bases(3),
              base_virtual(no)inheritance_public(no)base_offset(0),
              base_class_type_ref(A);
              base_virtual(yes)inheritance_public(no)base_offset(NIL),
              base_class_type_ref(B);
              base_virtual(no)inheritance_public(yes)base_offset(64),
              base_class_type_ref(C); ...
 
      .stabs "D:Tt31=s32!3,000,20;100,25;0264,28;$vb25:24,128;Ddat:
              1,160,32;A_virt::32=##1;:i;2A*-2147483647;20;;B_virt:
              :32:i;2A*-2147483647;25;;C_virt::32:i;2A*-2147483647;
              28;;D_virt::32:i;2A*-2147483646;31;;;~%20;",128,0,0,0
 

Info Catalog

(stabs) Virtual Methods

(stabs) Cplusplus

(stabs) Virtual Base Classes