不正经

这个屌丝很懒，什么也没留下！

热门标签

GCC-3.4.6源代码学习笔记（166)_gcc编译器alias_set_type

作者：不正经 | 2024-03-28 10:48:29

踩

gcc编译器alias_set_type

5.13.5.1.3. 准备别名集

构建别名集的入口是下面的 get_alias_set 。类型节点及声明节点可以要求别名分析，不过声明的别名集由其底层类型的别名集确定。在 467 行的条件选出声明的节点。在 C++ 前端， 475 行的钩子 get_alias_set 指向 cxx_get_alias_set 。这个函数主要处理类型定义节点，我们暂时不管这个函数。

449 HOST_WIDE_INT

450 get_alias_set (tree t) in alias.c

451 {

452 HOST_WIDE_INT set;

453

454 /* If we're not doing any alias analysis, just assume everything

455 aliases everything else. Also return 0 if this or its type is

456 an error. */

457 if (! flag_strict_aliasing || t == error_mark_node

458 || (! TYPE_P (t)

459 && (TREE_TYPE (t) == 0 || TREE_TYPE (t) == error_mark_node)))

460 return 0;

461

462 /* We can be passed either an expression or a type. This and the

463 language-specific routine may make mutually-recursive calls to each other

464 to figure out what to do. At each juncture, we see if this is a tree

465 that the language may need to handle specially. First handle things that

466 aren't types. */

467 if (! TYPE_P (t))

468 {

469 tree inner = t;

470 tree placeholder_ptr = 0;

471

472 /* Remove any nops, then give the language a chance to do

473 something with this tree before we look at it. */

474 STRIP_NOPS (t);

475 set = (*lang_hooks .get_alias_set ) (t);

476 if (set != -1)

477 return set;

478

479 /* First see if the actual object referenced is an INDIRECT_REF from a

480 restrict-qualified pointer or a "void *". Replace

481 PLACEHOLDER_EXPRs. */

482 while (TREE_CODE (inner) == PLACEHOLDER_EXPR

483 || handled_component_p (inner))

484 {

485 if (TREE_CODE (inner) == PLACEHOLDER_EXPR)

486 inner = find_placeholder (inner, &placeholder_ptr);

487 else

488 inner = TREE_OPERAND (inner, 0);

489

490 STRIP_NOPS (inner);

491 }

492

493 /* Check for accesses through restrict-qualified pointers. */

494 if (TREE_CODE (inner) == INDIRECT_REF)

495 {

496 tree decl = find_base_decl (TREE_OPERAND (inner, 0));

497

498 if (decl && DECL_POINTER_ALIAS_SET_KNOWN_P (decl))

499 {

500 /* If we haven't computed the actual alias set, do it now. */

501 if (DECL_POINTER_ALIAS_SET (decl) == -2)

502 {

503 tree pointed_to_type = TREE_TYPE (TREE_TYPE (decl));

504

505 /* No two restricted pointers can point at the same thing.

506 However, a restricted pointer can point at the same thing

507 as an unrestricted pointer, if that unrestricted pointer

508 is based on the restricted pointer. So, we make the

509 alias set for the restricted pointer a subset of the

510 alias set for the type pointed to by the type of the

511 decl. */

512 HOST_WIDE_INT pointed_to_alias_set

513 = get_alias_set (pointed_to_type);

514

515 if (pointed_to_alias_set == 0)

516 /* It's not legal to make a subset of alias set zero. */

517 DECL_POINTER_ALIAS_SET (decl) = 0;

518 else if (AGGREGATE_TYPE_P (pointed_to_type))

519 /* For an aggregate, we must treat the restricted

520 pointer the same as an ordinary pointer. If we

521 were to make the type pointed to by the

522 restricted pointer a subset of the pointed-to

523 type, then we would believe that other subsets

524 of the pointed-to type (such as fields of that

525 type) do not conflict with the type pointed to

526 by the restricted pointer. */

527 DECL_POINTER_ALIAS_SET (decl)

528 = pointed_to_alias_set;

529 else

530 {

531 DECL_POINTER_ALIAS_SET (decl) = new_alias_set ();

532 record_alias_subset (pointed_to_alias_set,

533 DECL_POINTER_ALIAS_SET (decl));

534 }

535 }

536

537 /* We use the alias set indicated in the declaration. */

538 return DECL_POINTER_ALIAS_SET (decl);

539 }

540

541 /* If we have an INDIRECT_REF via a void pointer, we don't

542 know anything about what that might alias. */

543 else if (TREE_CODE (TREE_TYPE (inner)) == VOID_TYPE)

544 return 0;

545 }

546

547 /* Otherwise, pick up the outermost object that we could have a pointer

548 to, processing conversion and PLACEHOLDER_EXPR as above. */

549 placeholder_ptr = 0;

550 while (TREE_CODE (t) == PLACEHOLDER_EXPR

551 || (handled_component_p (t) && ! can_address_p (t)))

552 {

553 if (TREE_CODE (t) == PLACEHOLDER_EXPR)

554 t = find_placeholder (t, &placeholder_ptr);

555 else

556 t = TREE_OPERAND (t, 0);

557

558 STRIP_NOPS (t);

559 }

560

561 /* If we've already determined the alias set for a decl, just return

562 it. This is necessary for C++ anonymous unions, whose component

563 variables don't look like union members (boo!). */

564 if (TREE_CODE (t) == VAR_DECL

565 && DECL_RTL_SET_P (t) && GET_CODE (DECL_RTL (t)) == MEM)

566 return MEM_ALIAS_SET (DECL_RTL (t));

567

568 /* Now all we care about is the type. */

569 t = TREE_TYPE (t);

570 }

上面的 INDIRECT_REF 节点，在 C++ 语言中，代表一个使用了指针或引用的表达式（例如， char *p; ），显然其所援引的对象的别名集正是我们需要的。那么 find_base_decl 找出这个表达式所基于的 DECL （例如，在‘ a[i] ’中，这将是‘ a ’）。而如果没有这样的 DECL ，或者不能确定一个唯一的 DECL ，则返回 NULL_TREE 。

361 static tree

362 find_base_decl (tree t) in alias.c

363 {

364 tree d0, d1, d2;

365

366 if (t == 0 || t == error_mark_node || ! POINTER_TYPE_P (TREE_TYPE (t)))

367 return 0;

368

369 /* If this is a declaration, return it. */

370 if (TREE_CODE_CLASS (TREE_CODE (t)) == 'd')

371 return t;

372

373 /* Handle general expressions. It would be nice to deal with

374 COMPONENT_REFs here. If we could tell that `a' and `b' were the

375 same, then `a->f' and `b->f' are also the same. */

376 switch (TREE_CODE_CLASS (TREE_CODE (t)))

377 {

378 case '1':

379 return find_base_decl (TREE_OPERAND (t, 0));

380

381 case '2':

382 /* Return 0 if found in neither or both are the same. */

383 d0 = find_base_decl (TREE_OPERAND (t, 0));

384 d1 = find_base_decl (TREE_OPERAND (t, 1));

385 if (d0 == d1)

386 return d0;

387 else if (d0 == 0)

388 return d1;

389 else if (d1 == 0)

390 return d0;

391 else

392 return 0;

393

394 case '3':

395 d0 = find_base_decl (TREE_OPERAND (t, 0));

396 d1 = find_base_decl (TREE_OPERAND (t, 1));

397 d2 = find_base_decl (TREE_OPERAND (t, 2));

398

399 /* Set any nonzero values from the last, then from the first. */

400 if (d1 == 0) d1 = d2;

401 if (d0 == 0) d0 = d1;

402 if (d1 == 0) d1 = d0;

403 if (d2 == 0) d2 = d1;

404

405 /* At this point all are nonzero or all are zero. If all three are the

406 same, return it. Otherwise, return zero. */

407 return (d0 == d1 && d1 == d2) ? d0 : 0;

408

409 default :

410 return 0;

411 }

412 }

如果我们找出基于的 DECL ，回到 498 行的 get_alias_set ， DECL_POINTER_ALIAS_SET 如果不是 -1 ， DECL_POINTER_ALIAS_SET_KNOWN_P 则是 true （ -1 意味着对于该声明还没有计算别名集）。另外如果 DECL_POINTER_ALIAS_SET 返回 -2 ，它表示我们需要为这个指针建造一个唯一的别名集（它仅应用于使用 GNU 扩展关键字 restrict 来约束指针别名的情形，参见 c_apply_type_quals_to_decl ），这需要特别的处理。

restrict 指针限定词可以被应用于一个数据指针来表示，在指针声明的作用域中，所有对这个数据的访问，将仅限于通过这个指针，而不通过其他指针。关键字 __restrict__ 因而使能编译器，在基于给定的一个对象不能通过其它指针来改变的前提下，执行某些优化。例如，声明“ int f ( int * restrict x, int * restrict y) ”意味着由指针 x 指向的地址中的内容，仅能通过这个指针来改变。因此如下计算别名集是安全的。

那么在 get_alias_set 的 503 行，在这里 decl 是基底 DECL ，它必须具有间接类型（指针或引用），因此 pointed_to_type 保存了间接类型所援引的类型。接着在 512 行， get_alias_set 被递归调用来制定出这个类型的别名集。因此在 518 行，如果 pointed_to_type 指向聚集类型，对于这个类型的别名集应该已经在 512 行的调用中被计算出来，为这个指针使用这个别名集（为聚集类型计算别名集由 record_component_aliases 完成，我们将很快看到）。

而如果该指针不是聚集类型，进入 get_alias_set 中 529 行的代码块，保守然而正确，把所有被这个类型的指针所指向的声明，组合入以这个指针类型为根节点的别名集树中（不过注意到 decl 的别名集除了本身，不是其它对象的别名，因为它被声明为“ restrict ”）。

那么如果来到 get_alias_set 的 549 行，要么因为其内部不是 INDIRECT_REF ，或其别名集未知。对于这个情形，我们根据类型节点来计算别名集。

WITH_RECORD_EXPR 及 PLACEHOLDER_EXPR 节点用在那些具有类型，在这些类型的对象中的某些域，包含了一个值用于计算其它域的偏移量或大小，及或该类型的大小，的语言中。这些域的位置及或大小，在相同类型的不同对象中，可以不同；甚至是在其作用域中的同一个对象中也可以这样。在 Ada 中，具有判别（ discriminants ）的记录类型（ record type ），或 Pascal 中的概要类型（ schema type ）就是这样类型的代表。对于 C++ 前端，我们不需要操心这些节点。

get_alias_set (continue)

572 /* Variant qualifiers don't affect the alias set, so get the main

573 variant. If this is a type with a known alias set, return it. */

574 t = TYPE_MAIN_VARIANT (t);

575 if (TYPE_ALIAS_SET_KNOWN_P (t))

576 return TYPE_ALIAS_SET (t);

577

578 /* See if the language has special handling for this type. */

579 set = (*lang_hooks .get_alias_set ) (t);

580 if (set != -1)

581 return set;

582

583 /* There are no objects of FUNCTION_TYPE, so there's no point in

584 using up an alias set for them. (There are, of course, pointers

585 and references to functions, but that's different.) */

586 else if (TREE_CODE (t) == FUNCTION_TYPE)

587 set = 0;

588

589 /* Unless the language specifies otherwise, let vector types alias

590 their components. This avoids some nasty type punning issues in

591 normal usage. And indeed lets vectors be treated more like an

592 array slice. */

593 else if (TREE_CODE (t) == VECTOR_TYPE)

594 set = get_alias_set (TREE_TYPE (t));

595

596 else

597 /* Otherwise make a new alias set for this type. */

598 set = new_alias_set ();

599

600 TYPE_ALIAS_SET (t) = set;

601

602 /* If this is an aggregate type, we must record any component aliasing

603 information. */

604 if (AGGREGATE_TYPE_P (t) || TREE_CODE (t) == COMPLEX_TYPE)

605 record_component_aliases (t);

606

607 return set;

608 }

首先，检查是否有语言给出的提示。对于 C++ ，下面的钩子 get_alias_set 指向 cxx_get_alias_set 。

回忆对于非 POD 类， CLASSTYPE_AS_BASE 是一个去掉虚拟基类的 RECORD_TYPE 节点，并且其 TYPE_CONTEXT 指向该类的 RECORD_TYPE ，因此如果 t 是非 POD 类的 CLASSTYPE_AS_BASE ，断言“ CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t ”是 true （而对于 POD 类， CLASSTYPE_AS_BASE 是该类的 RECORD_TYPE ，因此该断言是 false ）。

因此 295 行的条件断定 t 封闭在一个类中，并且它是封闭类的基类部分。

292 static HOST_WIDE_INT

293 cxx_get_alias_set (tree t) in cp-lang.c

294 {

295 if (TREE_CODE (t) == RECORD_TYPE

296 && TYPE_CONTEXT (t) && CLASS_TYPE_P (TYPE_CONTEXT (t))

297 && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t)

298 /* The base variant of a type must be in the same alias set as the

299 complete type. */

300 return get_alias_set (TYPE_CONTEXT (t));

301

302 if (/* It's not yet safe to use alias sets for some classes in C++. */

303 ! ok_to_generate_alias_set_for_type (t)

304 /* Nor is it safe to use alias sets for pointers-to-member

305 functions, due to the fact that there may be more than one

306 RECORD_TYPE type corresponding to the same pointer-to-member

307 type. */

308 || TYPE_PTRMEMFUNC_P (t))

309 return 0;

310

311 return c_common_get_alias_set (t);

312 }

对于来到 302 行的情形， ok_to_generate_alias_set_for_type 检查该类型对于别名是否安全。

首先，具有虚拟基类的类不是别名安全的。例如：

class A { ... };

class B : public virtual A { ... } ;

class C : public virtual A { ... } ;

class D : public B, C { ... } ;

虽然 D 派生自 B ，在 D 中，基类 B 与类 B 的布局不同，即便 B 是空类。记得 250 行的断言 CLASS_TYPE_P ，对于非 POD 类的 CLASSTYPE_AS_BASE ，是 false 。

类似的，如果一个类含有一个类型是包含虚拟基类的其它类的域，这个类型也不是别名安全的（两者被视为可能别名（ may-alias ））。

239 static bool

240 ok_to_generate_alias_set_for_type (tree t) in cp-lang.c

241 {

242 if (TYPE_PTRMEMFUNC_P (t))

243 return true;

244 if (AGGREGATE_TYPE_P (t))

245 {

246 if ((TREE_CODE (t) == RECORD_TYPE) || (TREE_CODE (t) == UNION_TYPE))

247 {

248 tree fields;

249 /* Backend-created structs are safe. */

250 if (! CLASS_TYPE_P (t))

251 return true;

252 /* PODs are safe. */

253 if (! CLASSTYPE_NON_POD_P(t))

254 return true;

255 /* Classes with virtual baseclasses are not. */

256 if (TYPE_USES_VIRTUAL_BASECLASSES (t))

257 return false;

258 /* Recursively check the base classes. */

259 if (TYPE_BINFO (t) != NULL && TYPE_BINFO_BASETYPES (t) != NULL)

260 {

261 int i;

262 for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (t)); i++)

263 {

264 tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (t), i);

265 if (!ok_to_generate_alias_set_for_type (BINFO_TYPE (binfo)))

266 return false;

267 }

268 }

269 /* Check all the fields. */

270 for (fields = TYPE_FIELDS (t); fields; fields = TREE_CHAIN (fields))

271 {

272 if (TREE_CODE (fields) != FIELD_DECL)

273 continue ;

274 if (! ok_to_generate_alias_set_for_type (TREE_TYPE (fields)))

275 return false;

276 }

277 return true;

278 }

279 else if (TREE_CODE (t) == ARRAY_TYPE)

280 return ok_to_generate_alias_set_for_type (TREE_TYPE (t));

281 else

282 /* This should never happen, we dealt with all the aggregate

283 types that can appear in C++ above. */

284 abort ();

285 }

286 else

287 return true;

288 }

接着考虑下面的例子：

extern "C" int printf(const char *,...);

class A {

protected : int i ;

public :

void f1 () { printf ("%d/n", i); }

A () : i (0) {}

};

class B : public A {

public :

void f1 () { printf ("%d/n", i); }

B () { i = 2 ; }

};

int main () {

void (A::*pf1) () = &A::f1;

B b;

(b.*pf1)(); // output “2”

A a ;

(a.*pf1)() ; // output “0”

return 0;

}

它输出“ 2, 0 ”，无疑 pf1 同时访问不同的对象。因此要小心处理成员指针别名集。在这里这样的指针被视为可能别名（ may-alias ）（ cxx_get_alias_set 的 308 行）。

除了类的处理， C++ 前端与 C 前端共享下面的函数来处理 C 中存在的类型。首先对于 union 成员的直接访问，它与该 union 中其它成员互为别名。对该情形的注释解释到，在 C 标准中，通过取其地址来设置这个域是不允许的，其行为是由实现定义的，【 6 】也给出了一个解释。

-fstrict-aliasing

² 允许编译器为正在编译的语言采用最严格的可用的别名规则。对于C （及C++ ），这激活基于表达式类型的优化。特别的，一个类型的一个对象被假定不会作为另一个类型的一个对象，存在相同地址上，除非这些类型几乎相同。例如，一个 unsigned int 可以是一个 int 的别名，但不是一个 void* 或 double 的别名。而一个字符类型是其它类型的可能别名。

特别注意像这样的代码：

union a_union {

int i;

double d;

};

int f() {

a_union t;

t.d = 3.0;

return t.i;

}

从最近写入的成员以外的成员中读出（称为“类型双关语， type-punning ”）是个普通的做法。即便使用‘ -fstrict-aliasing ’，也允许类型双关语，假定该内存通过这个 union 类型访问。因此，上面的代码将以期望的方式工作。不过，下面的代码不一定：

int f() {

a_union t;

int* ip;

t.d = 3.0;

ip = &t.i;

return *ip;

}

类似地，通过获取地址访问，转换其结果指针并提领这个结果具有未定义的行为，即便该转换使用一个 union 类型，即：

int f() {

double d = 3.0;

return ((union a_union *) &d)->i;

}

选项‘ -fstrict-aliasing ’在‘ -O2 ’，‘ -O3 ’，‘ -Os ’水平下使能。

紧接着在下面，我们将看到一个由类型双关语产生错误代码的例子。这个例子可以很好地解释为什么这里可能有未定义行为。不过， GCC 不给出警告，如果我们如上面那样行为不良。除了这个情形，非类型的 t 被踢开。

2848 HOST_WIDE_INT

2849 c_common_get_alias_set (tree t) n c-common.c

2850 {

2851 tree u;

2852

2853 /* Permit type-punning when accessing a union, provided the access

2854 is directly through the union. For example, this code does not

2855 permit taking the address of a union member and then storing

2856 through it. Even the type-punning allowed here is a GCC

2857 extension, albeit a common and useful one; the C standard says

2858 that such accesses have implementation-defined behavior. */

2859 for (u = t;

2860 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;

2861 u = TREE_OPERAND (u, 0))

2862 if (TREE_CODE (u) == COMPONENT_REF

2863 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)

2864 return 0;

2865

2866 /* That's all the expressions we handle specially. */

2867 if (! TYPE_P (t))

2868 return -1;

2869

2870 /* The C standard guarantees that any object may be accessed via an

2871 lvalue that has character type. */

2872 if (t == char_type_node

2873 || t == signed_char_type_node

2874 || t == unsigned_char_type_node)

2875 return 0;

2876

2877 /* If it has the may_alias attribute, it can alias anything. */

2878 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))

2879 return 0;

2880

2881 /* The C standard specifically allows aliasing between signed and

2882 unsigned variants of the same type. We treat the signed

2883 variant as canonical. */

2884 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))

2885 {

2886 tree t1 = c_common_signed_type (t);

2887

2888 /* t1 == t can happen for boolean nodes which are always unsigned. */

2889 if (t1 != t)

2890 return get_alias_set (t1);

2891 }

2892 else if (POINTER_TYPE_P (t))

2893 {

2894 tree t1;

2895

2896 /* Unfortunately, there is no canonical form of a pointer type.

2897 I n particular, if we have `typedef int I', then `int *', and

2898 `I *' are different types. So, we have to pick a canonical

2899 representative. We do this below.

2900

2901 Technically, this approach is actually more conservative that

2902 it needs to be. In particular, `const int *' and `int *'

2903 should be in different alias sets, according to the C and C++

2904 standard, since their types are not the same, and so,

2905 technically, an `int **' and `const int **' cannot point at

2906 the same thing.

2907

2908 But, the standard is wrong. In particular, this code is

2909 legal C++:

2910

2911 int *ip;

2912 int **ipp = &ip;

2913 const int* const* cipp = &ipp;

2914

2915 And, it doesn't make sense for that to be legal unless you

2916 can dereference IPP and CIPP. So, we ignore cv-qualifiers on

2917 the pointed-to types. This issue has been reported to the

2918 C++ committee. */

2919 t1 = build_type_no_quals (t);

2920 if (t1 != t)

2921 return get_alias_set (t1);

2922 }

2923

2924 return -1;

2925 }

上面在 2872 行，事实上将覆盖两个情形。即是形如：“ char c; ”及“ char *pc; ”的声明。对于前者，“ c ”不能是别的对象的别名，不需要构建别名集（而考虑 short 类型的情形，它是一个 2 个字节的组合，因而这两个字节可以是 short 类型的别名，而且其别名集必须包含在 short 的别名集中，前端必须为这个类型准备一个别名集，就像我们在代码中所见），而后者可以是任意可以通过一个左值访问对象的别名。不过对于后者，每次它指向特定的对象，将通过 get_alias_set 494 行的代码块得到其别名集，而且这个别名集可能不再是 0 （对于 C 形式的类型转换，它返回 0 ）。

在这里，显然对于间接引用（ indirect reference ，即指针或引用类型）之外的声明将共享它们基于的类的别名集。例如：“ short j , k, l; ”，在这个语句中，变量 j ， k 及 l 将具有相同的类型 short 的别名集。不过，这个别名集将被忽略，因为这些变量不能互为别名。现在如果我们把这个语句改为：“ short j, k, l, *p; ”，现在 j ， k ， l 及指针 p 将共享 short 的别名集。因此前端可以知道 p 可能是 j ， k 或 l 的别名。

接着考虑语句“ short j, k; char *p; ”， j 及 k 共享 short 的别名集，不过现在 p 没有别名集，因为 get_alias_set （准确地说，是 c_common_get_alias_set ）为之返回 0 。就这个语句而言，前端将不会把 p 视为 j 或 k 的别名。如果我们加入一个语句：“ p = &j; ”，在 C++ 中，这将触发隐式转换错误。那么如果我们加入一个语句：“ p = (char*)&j; ”，前端检查 p 及 j 别名集的交集。检查将通过，因为 p 具有超集 0 （记住真正的超集 0 ，没有被构建出来），并为这个转换产生代码。然而， p 的别名集总是保持为 0 ，这意味着它可以是任意可以通过左值访问的对象的别名。这个假定可以防止编译器采用容易出错的过度优化。不过这也是今后改进的地方，进一步细化别名集。

在上面 2884 行，具有不同符号的整数类型也共享相同的别名集。

2878 行提到了一个有趣的 GNU C++ 属性“ may_alias ”。【 6 】给出细节。

may_alias

² 通过具有这个属性的类型指针的访问不受基于类型别名分析的支配，而是被假定为可以是任意类型对象的别名。在 6.5/7 的上下文中，一个左值表达式提领这样的一个指针被处理作仿佛其具有一个字符类型。参见‘ -fstrict-aliasing ’有关别名问题的更多信息。这个扩展用于支持某些向量（ vector ） API ，其中一个向量类型的指针被允许作为不同向量类型指针的别名。注意到具有这个属性的一个类型的一个对象不具有特别的语义。使用的例子：

typedef short __attribute__ ((__may_alias__ )) short_a;

int main (void) {

int a = 0x12345678;

short_a *b = (short_a *) &a;

b[1] = 0;

if (a == 0x12345678)

abort();

exit(0);

}

如果在变量声明中使用 short 替换 short_a ，当使用‘ -fstrict-aliasing ’编译时，上面程序将执行 abort ，这个选项，在当前 GCC 版本中，在‘ -O2 ’或以上默认打开。

在上面的例子中，换句话来说，使用 short 替换 short_a 产生了不正确的代码。不过你可以使用 –Wstrict-aliasing 来找出可能破坏别名的指针。例如，在这里使用这个选项，编译器给出一个警告：“ test2.cpp:4: warning: dereferencing type-punned pointer will break strict-aliasing rules ”。

然后，如果 cxx_get_alias_set 返回 -1 以外的值，要么找到了别名集，或者这个对象不能是别名（即， char 类型）。否则，需要前进。看到在 get_alias_set 的 598 行，这个类型被赋予独一无二的别名集，并将被该类型的声明所共享。而对于聚集类型或包含多于一个成分的类型，其别名集应该包含其域的别名集。下面的函数 record_omponent_aliases 以这个方式构建这个别名集。 709 行的断言 TYPE_NONALIASED_COMPONENT ，如果是 true ，表明不允许获取该类型一个成分的地址。

697 void

698 record_component_aliases (tree type) in alias.c

699 {

700 HOST_WIDE_INT superset = get_alias_set (type);

701 tree field;

702

703 if (superset == 0)

704 return ;

705

706 switch (TREE_CODE (type))

707 {

708 case ARRAY_TYPE:

709 if (! TYPE_NONALIASED_COMPONENT (type))

710 record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));

711 break ;

712

713 case RECORD_TYPE:

714 case UNION_TYPE:

715 case QUAL_UNION_TYPE:

716 /* Recursively record aliases for the base classes, if there are any. */

717 if (TYPE_BINFO (type) != NULL && TYPE_BINFO_BASETYPES (type) != NULL)

718 {

719 int i;

720 for (i = 0; i < TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); i++)

721 {

722 tree binfo = TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), i);

723 record_alias_subset (superset,

724 get_alias_set (BINFO_TYPE (binfo)));

725 }

726 }

727 for (field = TYPE_FIELDS (type); field != 0; field = TREE_CHAIN (field))

728 if (TREE_CODE (field) == FIELD_DECL && ! DECL_NONADDRESSABLE_P (field))

729 record_alias_subset (superset, get_alias_set (TREE_TYPE (field)));

730 break ;

731

732 case COMPLEX_TYPE:

733 record_alias_subset (superset, get_alias_set (TREE_TYPE (type)));

734 break ;

735

736 default :

737 break ;

738 }

739 }

注意到在这个聚集类型中，比如，类型为 short 的域将使用类型 short 的别名集，这意味着它将与这个类型的其它声明共享这个别名集。通过这个方式，如果有一个 short 类型的指针，编译器可以断定这个指针是这个域及其它声明的可能别名，避免过度优化。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/329670