Hi, This implements a GNU C extension: two types are compatible if they appear as a function argument, one of the types is a transparent union type and the other type is compatible with a union member.
OK to commit? Thanks, -- Peter
>From 03ef77882cd0406d5e1304538e71e40c6f49d7a2 Mon Sep 17 00:00:00 2001 From: Peter Collingbourne <[email protected]> Date: Sat, 23 Oct 2010 01:44:40 +0100 Subject: [PATCH] Implement GNU C extension: two types are compatible if they appear as a function argument, one of the types is a transparent union type and the other type is compatible with a union member --- include/clang/AST/ASTContext.h | 6 ++++ lib/AST/ASTContext.cpp | 50 ++++++++++++++++++++++++++++++++++++- test/CodeGen/transparent-union.c | 5 +++- test/Sema/transparent-union.c | 18 +++++++++++++ 4 files changed, 76 insertions(+), 3 deletions(-) diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h index 0a960ab..9954355 100644 --- a/include/clang/AST/ASTContext.h +++ b/include/clang/AST/ASTContext.h @@ -1275,6 +1275,12 @@ public: bool Unqualified = false); QualType mergeFunctionTypes(QualType, QualType, bool OfBlockPointer=false, bool Unqualified = false); + QualType mergeFunctionArgumentTypes(QualType, QualType, + bool OfBlockPointer=false, + bool Unqualified = false); + QualType mergeTransparentUnionType(QualType, QualType, + bool OfBlockPointer=false, + bool Unqualified = false); QualType mergeObjCGCQualifiers(QualType, QualType); diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp index c7b014e..3ac296a 100644 --- a/lib/AST/ASTContext.cpp +++ b/lib/AST/ASTContext.cpp @@ -4673,6 +4673,51 @@ bool ASTContext::typesAreBlockPointerCompatible(QualType LHS, QualType RHS) { return !mergeTypes(LHS, RHS, true).isNull(); } +/// mergeTransparentUnionType - if T is a transparent union type and a member +/// of T is compatible with SubType, return the merged type, else return +/// QualType() +QualType ASTContext::mergeTransparentUnionType(QualType T, QualType SubType, + bool OfBlockPointer, + bool Unqualified) { + if (const RecordType *UT = T->getAsUnionType()) { + RecordDecl *UD = UT->getDecl(); + if (UD->hasAttr<TransparentUnionAttr>()) { + for (RecordDecl::field_iterator it = UD->field_begin(), + itend = UD->field_end(); it != itend; ++it) { + QualType ET = it->getType(); + QualType MT = mergeTypes(ET, SubType, OfBlockPointer, Unqualified); + if (!MT.isNull()) + return MT; + } + } + } + + return QualType(); +} + +/// mergeFunctionArgumentTypes - merge two types which appear as function +/// argument types +QualType ASTContext::mergeFunctionArgumentTypes(QualType lhs, QualType rhs, + bool OfBlockPointer, + bool Unqualified) { + if (!getLangOptions().CPlusPlus && getLangOptions().GNUMode) { + // GNU extension: two types are compatible if they appear as a function + // argument, one of the types is a transparent union type and the other + // type is compatible with a union member + QualType lmerge = mergeTransparentUnionType(lhs, rhs, OfBlockPointer, + Unqualified); + if (!lmerge.isNull()) + return lmerge; + + QualType rmerge = mergeTransparentUnionType(rhs, lhs, OfBlockPointer, + Unqualified); + if (!rmerge.isNull()) + return rmerge; + } + + return mergeTypes(lhs, rhs, OfBlockPointer, Unqualified); +} + QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, bool OfBlockPointer, bool Unqualified) { @@ -4750,8 +4795,9 @@ QualType ASTContext::mergeFunctionTypes(QualType lhs, QualType rhs, for (unsigned i = 0; i < lproto_nargs; i++) { QualType largtype = lproto->getArgType(i).getUnqualifiedType(); QualType rargtype = rproto->getArgType(i).getUnqualifiedType(); - QualType argtype = mergeTypes(largtype, rargtype, OfBlockPointer, - Unqualified); + QualType argtype = mergeFunctionArgumentTypes(largtype, rargtype, + OfBlockPointer, + Unqualified); if (argtype.isNull()) return QualType(); if (Unqualified) diff --git a/test/CodeGen/transparent-union.c b/test/CodeGen/transparent-union.c index 9f1cdda..0bdbd57 100644 --- a/test/CodeGen/transparent-union.c +++ b/test/CodeGen/transparent-union.c @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm -o %t %s +// RUN: %clang_cc1 -Werror -triple i386-unknown-unknown -emit-llvm -o %t %s // RUN: FileCheck < %t %s // // FIXME: Note that we don't currently get the ABI right here. f0() should be @@ -12,9 +12,12 @@ void f0(transp_t0 obj); // CHECK: define void @f1_0(i32* %a0) // CHECK: call void @f0(%union.anon* byval %{{.*}}) +// CHECK: call void %{{.*}}(i8* %{{[a-z0-9]*}}) // CHECK: } void f1_0(int *a0) { + void (*f0p)(void *) = f0; f0(a0); + f0p(a0); } void f1_1(int *a0) { diff --git a/test/Sema/transparent-union.c b/test/Sema/transparent-union.c index 27d5c24..d13b404 100644 --- a/test/Sema/transparent-union.c +++ b/test/Sema/transparent-union.c @@ -17,6 +17,24 @@ void g(int *ip, float *fp, char *cp) { tu.ip = ip; } +/* Test ability to redeclare a function taking a transparent_union arg + with various compatible and incompatible argument types. */ + +void fip(TU); +void fip(int *i) {} + +void ffp(TU); +void ffp(float *f) {} + +void fvp(TU); // expected-note{{previous declaration is here}} +void fvp(void *p) {} // expected-error{{conflicting types}} + +void fsp(TU); // expected-note{{previous declaration is here}} +void fsp(short *s) {} // expected-error{{conflicting types}} + +void fi(TU); // expected-note{{previous declaration is here}} +void fi(int i) {} // expected-error{{conflicting types}} + /* FIXME: we'd like to just use an "int" here and align it differently from the normal "int", but if we do so we lose the alignment information from the typedef within the compiler. */ -- 1.7.1
_______________________________________________ cfe-commits mailing list [email protected] http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
