GCC-3.4.6源代码学习笔记（127）

5.12.4.2.3.2.  为 base-clause 构建节点

注意参数 base 在我们的例子中指向的 BOUND_TEMPLATE_TEMPLATE_PARM 节点， access 是 access_public_node 。

 

2242   tree

2243   finish_base_specifier (tree base, tree access, bool virtual_p)                 in semantics.c

2244   {

2245     tree result;

2246  

2247     if (base == error_mark_node)

2248     {

2249       error ("invalid base-class specification");

2250       result = NULL_TREE;

2251     }

2252     else if (! is_aggr_type (base, 1))

2253       result = NULL_TREE;

2254     else

2255     {

2256       if (cp_type_quals (base) != 0)

2257       {

2258         error ("base class `%T' has cv qualifiers", base);

2259         base = TYPE_MAIN_VARIANT (base);

2260       }

2261       result = build_tree_list (access, base);

2262       TREE_VIA_VIRTUAL (result) = virtual_p;

2263     }

2264  

2265     return result;

2266   }

 

在为基类构建了节点后，在前端中这些基类被串接在一起来代表 base-clause 。

5.12.4.2.3.2.1.          填充 binfo

从 cp_parser_base_clause 返回，在 cp_parser_class_head 的 12339 行，由 bases 指向先前所构建的节点 BOUND_TEMPLATE_TEMPLATE_PARM ，而 type 则是代表“ SmallObject ”的 RECORD_TYPE 。记得在构建这个 RECORD_TYPE 时，还构建了一个空的 binfo 节点。现在这个节点将根据刚才解析的 base-clause 来填充。

 

9615   void

9616   xref_basetypes (tree ref, tree base_list)                                                             in decl.c

9617   {

9618     /* In the declaration `A : X, Y, ... Z' we mark all the types

9619       (A, X, Y, ..., Z) so we can check for duplicates.  */

9620     tree *basep;

9621  

9622     int i;

9623     enum tag_types tag_code;

9624  

9625     if (ref == error_mark_node)

9626       return ;

9627  

9628     if (TREE_CODE (ref) == UNION_TYPE)

9629     {

9630       error ("derived union `%T' invalid", ref);

9631       return ;

9632     }

9633  

9634     tag_code = (CLASSTYPE_DECLARED_CLASS (ref) ? class_type : record_type);

9635  

9636     /* First, make sure that any templates in base-classes are

9637       instantiated. This ensures that if we call ourselves recursively

9638       we do not get confused about which classes are marked and which

9639       are not.  */

9640     basep = &base_list;

9641     while (*basep)

9642     {

9643       tree basetype = TREE_VALUE (*basep);

9644       if (!(processing_template_decl && uses_template_parms (basetype))

9645           && !complete_type_or_else (basetype, NULL))

9646         /* An incomplete type. Remove it from the list.  */

9647         *basep = TREE_CHAIN (*basep);

9648       else

9649         basep = &TREE_CHAIN (*basep);

9650     }

9651  

9652     SET_CLASSTYPE_MARKED (ref);

9653     i = list_length (base_list);

9654     if (i)

9655     {

9656       tree binfo = TYPE_BINFO (ref);

9657       tree binfos = make_tree_vec (i);

9658       tree accesses = make_tree_vec (i);

9659        

9660       BINFO_BASETYPES (binfo) = binfos;

9661       BINFO_BASEACCESSES (binfo) = accesses;

9662    

9663       for (i = 0; base_list; base_list = TREE_CHAIN (base_list))

9664       {

9665         tree access = TREE_PURPOSE (base_list);

9666         int via_virtual = TREE_VIA_VIRTUAL (base_list);

9667         tree basetype = TREE_VALUE (base_list);

9668          tree base_binfo;

9669         

9670         if (access == access_default_node)

9671            /* The base of a derived struct is public by default.  */

9672           access = (tag_code == class_type

9673                   ? access_private_node : access_public_node);

9674         

9675         if (basetype && TREE_CODE (basetype) == TYPE_DECL)

9676           basetype = TREE_TYPE (basetype);

9677         if (!basetype

9678            || (TREE_CODE (basetype) != RECORD_TYPE

9679              && TREE_CODE (basetype) != TYPENAME_TYPE

9680              && TREE_CODE (basetype) != TEMPLATE_TYPE_PARM

9681              && TREE_CODE (basetype) != BOUND_TEMPLATE_TEMPLATE_PARM))

9682         {

9683           error ("base type `%T' fails to be a struct or class type",

9684                 basetype);

9685           continue ;

9686         }

9687         

9688         if (CLASSTYPE_MARKED (basetype))

9689         {

9690           if (basetype == ref)

9691             error ("recursive type `%T' undefined", basetype);

9692           else

9693             error ("duplicate base type `%T' invalid", basetype);

9694           continue ;

9695         }

9696         

9697         if (TYPE_FOR_JAVA (basetype)

9698            && (current_lang_depth () == 0))

9699           TYPE_FOR_JAVA (ref) = 1;

9700         

9701         if (CLASS_TYPE_P (basetype))

9702          {

9703           base_binfo = TYPE_BINFO (basetype);

9704            /* This flag will be in the binfo of the base type, we must

9705              clear it after copying the base binfos.  */

9706            BINFO_DEPENDENT_BASE_P (base_binfo)

9707                 = dependent_type_p (basetype);

9708         }

9709         else

9710           base_binfo = make_binfo (size_zero_node, basetype,

9711                                 NULL_TREE, NULL_TREE);

9712         

9713         TREE_VEC_ELT (binfos, i) = base_binfo;

9714         TREE_VEC_ELT (accesses, i) = access;

9715         /* This flag will be in the binfo of the base type, we must

9716           clear it after copying the base binfos.  */

9717         TREE_VIA_VIRTUAL (base_binfo) = via_virtual;

9718         

9719         SET_CLASSTYPE_MARKED (basetype);

9720         

9721          /* We are free to modify these bits because they are meaningless

9722           at top level, and BASETYPE is a top-level type.  */

9723         if (via_virtual || TYPE_USES_VIRTUAL_BASECLASSES (basetype))

9724         {

9725           TYPE_USES_VIRTUAL_BASECLASSES (ref) = 1;

9726            /* Converting to a virtual base class requires looking

9727              up the offset of the virtual base.  */

9728            TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;

9729         }

9730         

9731         if (CLASS_TYPE_P (basetype))

9732         {

9733           TYPE_HAS_NEW_OPERATOR (ref)

9734               |= TYPE_HAS_NEW_OPERATOR (basetype);

9735           TYPE_HAS_ARRAY_NEW_OPERATOR (ref)

9736               |= TYPE_HAS_ARRAY_NEW_OPERATOR (basetype);

9737           TYPE_GETS_DELETE (ref) |= TYPE_GETS_DELETE (basetype);

9738           /* If the base-class uses multiple inheritance, so do we.  */

9739           TYPE_USES_MULTIPLE_INHERITANCE (ref)

9740               |= TYPE_USES_MULTIPLE_INHERITANCE (basetype);

9741           /* Likewise, if converting to a base of the base may require

9742             code, then we may need to generate code to convert to a

9743             base as well.  */

9744            TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref)

9745               |= TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (basetype);

9746         }

9747         i++;

9748       }

9749       if (i)

9750         TREE_VEC_LENGTH (accesses) = TREE_VEC_LENGTH (binfos) = i;

9751       else

9752         BINFO_BASEACCESSES (binfo) = BINFO_BASETYPES (binfo) = NULL_TREE;

9753        

9754       if (i > 1)

9755       {

9756         TYPE_USES_MULTIPLE_INHERITANCE (ref) = 1;

9757         /* If there is more than one non-empty they cannot be at the same

9758            address.  */

9759         TYPE_BASE_CONVS_MAY_REQUIRE_CODE_P (ref) = 1;

9760       }

9761     }

9762    

9763     /* Copy the base binfos, collect the virtual bases and set the

9764       inheritance order chain.  */

9765     copy_base_binfos (TYPE_BINFO (ref), ref, NULL_TREE);

9766     CLASSTYPE_VBASECLASSES (ref) = nreverse (CLASSTYPE_VBASECLASSES (ref));

9767  

9768     if (TYPE_FOR_JAVA (ref))

9769     {

9770       if (TYPE_USES_MULTIPLE_INHERITANCE (ref))

9771         error ("Java class '%T' cannot have multiple bases", ref);

9772       if (CLASSTYPE_VBASECLASSES (ref))

9773         error ("Java class '%T' cannot have virtual bases", ref);

9774     }

9775  

9776     /* Unmark all the types.  */

9777     while (i--)

9778     {

9779       tree basetype = BINFO_TYPE (BINFO_BASETYPE (TYPE_BINFO (ref), i));

9780        

9781       CLEAR_CLASSTYPE_MARKED (basetype);

9782       if (CLASS_TYPE_P (basetype))

9783       {

9784         TREE_VIA_VIRTUAL (TYPE_BINFO (basetype)) = 0;

9785         BINFO_DEPENDENT_BASE_P (TYPE_BINFO (basetype)) = 0;

9786       }

9787     }

9788     CLEAR_CLASSTYPE_MARKED (ref);

9789   }

 

注意在 9645 行，在 base-clause 不能出现未完成的类。而在 9765 行，基类本身有可能从其他类派生，因此需要深拷贝所有相关的 binfo 。看到对于指定的类， binfo 节点，以深度优先、由左至右为序，形成了一个链表。

 

577    tree

578    copy_base_binfos (tree binfo, tree t, tree prev)                                                         in tree.c

579    {

580      tree binfos = BINFO_BASETYPES (binfo);

581      int n, ix;

582   

583      if (prev)

584        TREE_CHAIN (prev) = binfo;

585      prev = binfo;

586     

587      if (binfos == NULL_TREE)

588        return prev;

589   

590      n = TREE_VEC_LENGTH (binfos);

591     

592      /* Now copy the structure beneath BINFO.  */

593      for (ix = 0; ix != n; ix++)

594      {

595        tree base_binfo = TREE_VEC_ELT (binfos, ix);

596        tree new_binfo = NULL_TREE;

597   

598        if (!CLASS_TYPE_P (BINFO_TYPE (base_binfo)))

599        {

600          my_friendly_assert (binfo == TYPE_BINFO (t), 20030204);

601          

602          new_binfo = base_binfo;

603          TREE_CHAIN (prev) = new_binfo;

604          prev = new_binfo;

605          BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;

606          BINFO_DEPENDENT_BASE_P (new_binfo) = 1;

607        }

608        else if (TREE_VIA_VIRTUAL (base_binfo))

609        {

610          new_binfo = purpose_member (BINFO_TYPE (base_binfo),

611                                     CLASSTYPE_VBASECLASSES (t));

612          if (new_binfo)

613            new_binfo = TREE_VALUE (new_binfo);

614        }

615         

616        if (!new_binfo)

617        {

618          new_binfo = make_binfo (BINFO_OFFSET (base_binfo),

619                                base_binfo, NULL_TREE,

620                                BINFO_VIRTUALS (base_binfo));

621          prev = copy_base_binfos (new_binfo, t, prev);

622          if (TREE_VIA_VIRTUAL (base_binfo))

623          {

624            CLASSTYPE_VBASECLASSES (t)

625                = tree_cons (BINFO_TYPE (new_binfo), new_binfo,

626                            CLASSTYPE_VBASECLASSES (t));

627            TREE_VIA_VIRTUAL (new_binfo) = 1;

628            BINFO_INHERITANCE_CHAIN (new_binfo) = TYPE_BINFO (t);

629          }

630          else

631            BINFO_INHERITANCE_CHAIN (new_binfo) = binfo;

632        }

633        TREE_VEC_ELT (binfos, ix) = new_binfo;

634      }

635   

636      return prev;

637    }

 

虚拟继承是例外，在这个情形下，被虚拟继承的基类只能有一个实例出现在派生树中。因此如果该实例已经存在，创建一个引用而不是拷贝（注意每个类都有自己的派生树）。例如：

class A { … };

class B: virtual public A { … };

class C: virtual public A { … };

class D: public B, C { … };

在类 D 中，仅含有一个 A 的 binfo 。而在类 B 和 C 中，同样都有一个 A 的 binfo （类 D ， C ， B 具有不同的派生树，在 D 的派生树中，有 C 和 B 的 binfo 的拷贝）。

注意到对于 BOUND_TEMPLATE_TEMPLATE_PARM. 节点， CLASS_TYPE_P 返回 false 。这是隐含构建的聚合类型，不需要真正的拷贝。那么“ SmallObject ”和“ ThreadingModel ”的 binfo 填充如下。

（ 点此打开 ）

图 114 ：填充 binfo

5.12.4.3.              解析 class-definition

那么接下来，解析器将处理 class-definition 部分。它与我们在前面章节所看到处理过程几乎一样。这里我们跳过它。