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

5.13.5.      代码分析及优化

5.13.5.1.              预备知识- 别名集分析

5.13.5.1.1.        别名集概念

在维基百科（ wikipedia ）中，给出了如下的别名集的一个很好的解释。

别名分析 是在编译器理论中的一个技术，用于确定一个存储位置是否可能以多个方式访问。两个指针通常被认为别名，如果它们指向同一个位置。 别名分析技术通常分为流 - 敏感（ flow-sensitivity ）及上下文 - 敏感（ context-sensitivity ）。它们可以确定可能别名（ may-alias ）或必须别名（ must-alias ）的信息。术语别名分析 通常与术语指向分析 互用，一个具体的案例。 别名分析做什么用？ 大体上，别名分析确定不同的内存引用是否指向内存的同一个区域。这允许编译器确定在程序中，一个语句将影响哪些变量。例如，考虑下面访问结构体成员的代码： ...; p.foo = 1; q.foo = 2; i = p.foo + 3; ... 这里有 3 个可能的别名情形： 变量 p 及 q 不能是别名。 变量 p 及 q 必定是别名。 在编译时刻，不能确定地决定 p 及 q 是否是别名。 如果 p 及 q 不能是别名，那么 i = p.foo + 3; 可以被改为 i = 4 。如果 p 及 q 必须是别名，那么 i = p.foo + 3; 可以被改为 i = 5 。在这 2 个情形下，通过该别名的了解，我们可以执行优化。另一方面，如果不能知道 p 及 q 是否是别名，那么就不能执行优化，而必须执行完整的代码来得到结果。两个内存引用被称为具有一个可能别名（ may-alias ）的关系，如果它们的别名使用是未知的。 执行别名分析 在别名分析中，我们把程序的内存分成别名组（ alias classes ）。别名组是不相接的位置集合，它们彼此间不是别名。为了这里的讨论，假定这里执行的优化发生在程序的一个低级的中间表达方式中。这即是说该程序已经被编译成二元操作（ binary operation ），跳转（ jump ），寄存器间转移（ moves between registers ），寄存器到内存转移（ moves from registers to memory ），内存到寄存器转移（ moves from memory to registers ），分支（ branche ），及函数调用、返回（ function calls/returns ）。 基于类型的别名分析 如果被编译的语言是类型安全的，编译器的类型检查器是正确的，并且该语言缺少创建引用局部变量的指针的能力，（例如 ML ， Haskell 或 Java ）那么可以进行某些有用的优化。在有很多情况下，我们知道两个内存位置必须在不同的别名组中： 1.       两个不同类型的变量不能在同一个别名组中，因为强类型，没有内存引用（即，内存位置的引用不能直接改变）语言的一个属性是，不同类型的两个变量不能同时共享同一个内存位置。 2.       相对当前栈框的局部分配，不能与之前其它栈框中的分配，在同一个别名组中。这个情形是因为新的内存分配必须与其它内存分配不相邻。 3.       每个记录（ record ）类型的每个记录域（ record field ）有其自己的别名组，大体上，因为类型规则（ typing discipline ）通常仅允许别名相同类型的记录。因为一个类型的所有记录在内存中将被以相同格式存储，一个域不能是它自身的别名。 4.       类似地，一个给定类型的每个数组有其自己的别名组。 当对代码执行别名分析时，对内存的每次存、取，需要用其组别标记。那么我们具有这个有用的属性，给定具有 i ， j 别名组的内存位置 Ai 及 Bj ，如果 i = j ，则 Ai 可能别名（ may-alias ）于 Bj ，而如果 ，则这些内存位置将不是别名。 基于流的别名分析 基于流的别名分析，不同于基于类型的别名分析，可以被应用于一个具有引用或类型转换（ type-casting ）的语言的程序中。具有流的分析可以被用于代替或补充基于类型的分析。在基于流的分析中，为每个内存位置，每个地址被使用的全局及局部变量，构建新的别名组。随着时间的推移，引用可能指向多于一个值，并因而属于多个别名组。这意味着每个内存位置具有一组别名组，而不是单个别名组。

毫无疑问，在 GNU C++ 中，基于流的分析及基于类型的分析都使用了。正如我们已经看到的，对于消耗内存的项（主要是声明及常量），它们具有关联的 MEM 节点。

在编译器中，赋给 MEM 的别名集帮助后端确定哪个 MEM 是其他 MEM 的别名。大体上，两个具有不同别名集的 MEM 不能互为别名，除了一个重要的例外。

考虑形如： struct S { int i; double d; };

对一个‘ S ’的存储可以是某些具有类型‘ int ’或类型‘ double ’的东西的别名（事实上，在 C++ 中，必须是指针或引用）。（不过，对一个‘ int ’的存储不能是一个‘ double ’的存储的别名，反之亦然）。我们通过一个如下的树结构来表示：

           struct S

            /   /

   /     /

        |/_     _/|

        int    double

（箭头是有方向的，并指向下）。在这个情形下，我们称对应‘ struct S ’的别名集为‘超集’，而那些对应‘ int ’及‘ double ’的别名集为‘子集’。

为了查看两个别名集是否可以指向同一块内存，我们必须检查别名集之一是否是其他别名集的子集。不过，我们不需要跟踪过去的直接后代，因为我们把所有孙辈传播到上一级。

别名集 0 隐含地是所有其他别名集的一个超集。不过，对于别名集 0 ，并没有真正的对应的项。尝试显式地构建 0 的一个子集是一个错误。

5.13.5.1.2.        数据结构

换句话说，别名集被用于描述在程序中所访问的内存块的层次及关系。出于这个目的，编译器为别名集定义了结构体 alias_set_entry 。

 

77    struct alias_set_entry GTY(())                                                                     in alias.c

78    {

79      /* The alias set number, as stored in MEM_ALIAS_SET.  */

80      HOST_WIDE_INT alias_set;

81   

82      /* The children of the alias set. These are not just the immediate

83        children, but, in fact, all descendants. So, if we have:

84   

85           struct T { struct S s; float f; }

86   

87        continuing our example above, the children here will be all of

88        `int', `double', `float', and `struct S'.  */

89      splay_tree GTY((param1_is (int), param2_is (int))) children;

90   

91      /* Nonzero if would have a child of zero: this effectively makes this

92        alias set the same as alias set zero.  */

93      int has_zero_child;

94    };

95    typedef struct alias_set_entry *alias_set_entry;

 

其中，在 80 行的域 alias_set ，如果是 0 ，表示关联的 MEM 不在任一别名集中，并且可能是任何对象的别名（事实上，如果使用了别名分析， alias_set 不应该是 0 ，参见下面）。这个 alias_set 也作为别名集的唯一的 id 。在 89 行，域 children 是伸展树的一个指针。这个伸展树是一种二叉树，使用 alias_set 作为排序键值。在这个伸展树的节点中，其 value 域是不使用的。因此看到每个对应别名集的 alias_set_entry 都将保存一个伸展树，如果它别名于其他别名集。并且在树中节点的位置足以描述这个别名关系。

为别名集分配新的 alias_set_entry 由下面的 new_alias_set 完成。如果优化选项高于 -O2 ，设置标记 flag_strict_aliasing ，为之我们应该执行依赖于语言的别名分析。

 

614  HOST_WIDE_INT

615  new_alias_set (void)                                                                                   in alias.c

616  {

617    if (flag_strict_aliasing )

618    {

619      if (!alias_sets )

620        VARRAY_GENERIC_PTR_INIT (alias_sets , 10, "alias sets");

621      else

622        VARRAY_GROW (alias_sets , last_alias_set + 2);

623      return ++last_alias_set ;

624    }

625    else

626      return 0;

627  }

 

全局变量 last_alias_set 记录到此为止所分配的 alias_set_entry 的数目，它将被设置在这次分配的 alias_set_entry 的 alias_set 中。

而函数 record_alias_subset ，通过把 subset 插入由 superset 为根节点的树来构建别名树，使得 superset 成为 subset 的超集。

 

642  void

643  record_alias_subset (HOST_WIDE_INT superset, HOST_WIDE_INT subset) in alias.c

644  {

645    alias_set_entry superset_entry;

646    alias_set_entry subset_entry;

647 

648    /* It is possible in complex type situations for both sets to be the same,

649      i n which case we can ignore this operation.  */

650    if (superset == subset)

651      return ;

652 

653    if (superset == 0)

654      abort ();

655 

656    superset_entry = get_alias_set_entry (superset);

657    if (superset_entry == 0)

658    {

659      /* Create an entry for the SUPERSET, so that we have a place to

660        attach the SUBSET.  */

661      superset_entry = ggc_alloc (sizeof (struct alias_set_entry));

662      superset_entry->alias_set = superset;

663      superset_entry->children

664          = splay_tree_new_ggc (splay_tree_compare_ints);

665      superset_entry->has_zero_child = 0;

666      VARRAY_GENERIC_PTR (alias_sets , superset) = superset_entry;

667    }

668 

669    if (subset == 0)

670      superset_entry->has_zero_child = 1;

671    else

672    {

673      subset_entry = get_alias_set_entry (subset);

674      /* If there is an entry for the subset, enter all of its children

675        (if they are not already present) as children of the SUPERSET.  */

676      if (subset_entry)

677      {

678        if (subset_entry->has_zero_child)

679          superset_entry->has_zero_child = 1;

680 

681        splay_tree_foreach (subset_entry->children, insert_subset_children,

682                         superset_entry->children);

683      }

684 

685      /* Enter the SUBSET itself as a child of the SUPERSET.  */

686      splay_tree_insert (superset_entry->children,

687                     (splay_tree_key) subset, 0);

688    }

689  }

 

看到构建具有值 0 的超集是不允许的，因为别名集 0 必须被局限在某些别名集中，以表示其对其限制集的全面访问性。没有这个限制，就有可能构建一个以别名集 0 为根的树；这肯定会使编译器崩溃。注意到在 669 行，如果子集是 0 ，将不会构建真正的实体，而仅是提醒这个超集具有值 0 的后代。而 678 行表明这个标记将被传播入父辈中。

上面的标记 has_zero_child 主要用在由下面函数执行的别名集冲突检查。如果指定的两个别名集可能冲突，它返回 1 ，表明关联的对象可能彼此别名。

 

260  int

261  alias_sets_conflict_p (HOST_WIDE_INT set1, HOST_WIDE_INT set2)               in alias.c

262  {

263    alias_set_entry ase;

264 

265    /* If have no alias set information for one of the operands, we have

266      to assume it can alias anything.  */

267    if (set1 == 0 || set2 == 0

268        /* If the two alias sets are the same, they may alias.  */

269        || set1 == set2)

270      return 1;

271 

272    /* See if the first alias set is a subset of the second.  */

273    ase = get_alias_set_entry (set1);

274    if (ase != 0

275        && (ase->has_zero_child

276            || splay_tree_lookup (ase->children,

277                               (splay_tree_key) set2)))

278      return 1;

279 

280    /* Now do the same, but with the alias sets reversed.  */

281    ase = get_alias_set_entry (set2);

282    if (ase != 0

283        && (ase->has_zero_child

284             || splay_tree_lookup (ase->children,

285                               (splay_tree_key) set1)))

286      return 1;

287 

288    /* The two alias sets are distinct and neither one is the

289      child of the other. Therefore, they cannot alias.  */

290    return 0;

291  }

 

这个函数应该被仔细使用。参数 set1 及 set2 背后的树对象必须在同一个类型树上（而作为结果 set1 及 set2 ，如果非 0 ，来自别名集的同一棵树）。看到可能别名（ may-alias ）是一个保守的预测，如果两个对象具有相同的成员布局（因而导致 set1 等于 set2 ），它们被视为可能别名。