diff --git a/lib/Sema/Sema.h b/lib/Sema/Sema.h
index faaeb79..d04394d 100644
--- a/lib/Sema/Sema.h
+++ b/lib/Sema/Sema.h
@@ -2355,11 +2355,17 @@
   /// This routine is only used by the following two methods. C99 6.5.16.
   AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
   
-  // CheckSingleAssignmentConstraints - Currently used by ActOnCallExpr,
+  // CheckSingleAssignmentConstraints - Currently used by 
   // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking, 
   // this routine performs the default function/array converions.
   AssignConvertType CheckSingleAssignmentConstraints(QualType lhs, 
                                                      Expr *&rExpr);
+
+  // \brief If the lhs type is a transparent union, check whether we
+  // can initialize the transparent union with the given expression.
+  AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs, 
+                                                             Expr *&rExpr);
+
   // CheckCompoundAssignmentConstraints - Type check without performing any 
   // conversions. For compound assignments, the "Check...Operands" methods 
   // perform the necessary conversions. 
diff --git a/lib/Sema/SemaDeclAttr.cpp b/lib/Sema/SemaDeclAttr.cpp
index 2df4e36..df4fd4d 100644
--- a/lib/Sema/SemaDeclAttr.cpp
+++ b/lib/Sema/SemaDeclAttr.cpp
@@ -1178,36 +1178,63 @@
     return;
   }
 
-  // FIXME: This shouldn't be restricted to typedefs
+  // Try to find the underlying union declaration.
+  RecordDecl *RD = 0;
   TypedefDecl *TD = dyn_cast<TypedefDecl>(d);
-  if (!TD || !TD->getUnderlyingType()->isUnionType()) {
+  if (TD && TD->getUnderlyingType()->isUnionType())
+    RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
+  else
+    RD = dyn_cast<RecordDecl>(d);
+
+  if (!RD || !RD->isUnion()) {
     S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type)
       << "transparent_union" << 1 /*union*/;
     return;
   }
 
-  RecordDecl* RD = TD->getUnderlyingType()->getAsUnionType()->getDecl();
+  if (!RD->isDefinition()) {
+    S.Diag(Attr.getLoc(), 
+        diag::warn_transparent_union_attribute_not_definition);
+    return;
+  }
 
-  // FIXME: Should we do a check for RD->isDefinition()?
+  RecordDecl::field_iterator Field = RD->field_begin(S.Context),
+                          FieldEnd = RD->field_end(S.Context);
+  if (Field == FieldEnd) {
+    S.Diag(Attr.getLoc(), diag::warn_transparent_union_attribute_zero_fields);
+    return;
+  }
 
-  // FIXME: This isn't supposed to be restricted to pointers, but otherwise
-  // we might silently generate incorrect code; see following code
-  for (RecordDecl::field_iterator Field = RD->field_begin(S.Context),
-                               FieldEnd = RD->field_end(S.Context);
-       Field != FieldEnd; ++Field) {
-    if (!Field->getType()->isPointerType()) {
-      S.Diag(Attr.getLoc(), diag::warn_transparent_union_nonpointer);
+  FieldDecl *FirstField = *Field;
+  QualType FirstType = FirstField->getType();
+  if (FirstType->isFloatingType() || FirstType->isVectorType()) {
+    S.Diag(FirstField->getLocation(), 
+           diag::warn_transparent_union_attribute_floating);
+    return;
+  }
+
+  uint64_t FirstSize = S.Context.getTypeSize(FirstType);
+  uint64_t FirstAlign = S.Context.getTypeAlign(FirstType);
+  for (; Field != FieldEnd; ++Field) {
+    QualType FieldType = Field->getType();
+    if (S.Context.getTypeSize(FieldType) != FirstSize ||
+        S.Context.getTypeAlign(FieldType) != FirstAlign) {
+      // Warn if we drop the attribute.
+      bool isSize = S.Context.getTypeSize(FieldType) != FirstSize;
+      unsigned FieldBits = isSize? S.Context.getTypeSize(FieldType) 
+                                 : S.Context.getTypeAlign(FieldType);
+      S.Diag(Field->getLocation(), 
+          diag::warn_transparent_union_attribute_field_size_align)
+        << isSize << Field->getDeclName() << FieldBits;
+      unsigned FirstBits = isSize? FirstSize : FirstAlign;
+      S.Diag(FirstField->getLocation(), 
+             diag::note_transparent_union_first_field_size_align)
+        << isSize << FirstBits;
       return;
     }
   }
 
-  // FIXME: This is a complete hack; we should be properly propagating
-  // transparent_union through Sema.  That said, this is close enough to
-  // correctly compile all the common cases of transparent_union without
-  // errors or warnings
-  QualType NewTy = S.Context.VoidPtrTy;
-  NewTy.addConst();
-  TD->setUnderlyingType(NewTy);
+  RD->addAttr(::new (S.Context) TransparentUnionAttr());
 }
 
 static void HandleAnnotateAttr(Decl *d, const AttributeList &Attr, Sema &S) {
diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 99ed741..2de1ef3 100644
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -3124,6 +3124,73 @@
   return Incompatible;
 }
 
+/// \brief Constructs a transparent union from an expression that is
+/// used to initialize the transparent union.
+static void ConstructTransparentUnion(ASTContext &C, Expr *&E, 
+                                      QualType UnionType, FieldDecl *Field) {
+  // Build an initializer list that designates the appropriate member
+  // of the transparent union.
+  InitListExpr *Initializer = new (C) InitListExpr(SourceLocation(),
+                                                   &E, 1,
+                                                   SourceLocation());
+  Initializer->setType(UnionType);
+  Initializer->setInitializedFieldInUnion(Field);
+
+  // Build a compound literal constructing a value of the transparent
+  // union type from this initializer list.
+  E = new (C) CompoundLiteralExpr(SourceLocation(), UnionType, Initializer,
+                                  false);
+}
+
+Sema::AssignConvertType
+Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) {
+  QualType FromType = rExpr->getType();
+
+  // If the ArgType is a Union type, we want to handle a potential 
+  // transparent_union GCC extension.
+  const RecordType *UT = ArgType->getAsUnionType();
+  if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
+    return Incompatible;
+
+  // The field to initialize within the transparent union.
+  RecordDecl *UD = UT->getDecl();
+  FieldDecl *InitField = 0;
+  // It's compatible if the expression matches any of the fields.
+  for (RecordDecl::field_iterator it = UD->field_begin(Context),
+         itend = UD->field_end(Context);
+       it != itend; ++it) {
+    if (it->getType()->isPointerType()) {
+      // If the transparent union contains a pointer type, we allow:
+      // 1) void pointer
+      // 2) null pointer constant
+      if (FromType->isPointerType())
+        if (FromType->getAsPointerType()->getPointeeType()->isVoidType()) {
+          ImpCastExprToType(rExpr, it->getType());
+          InitField = *it;
+          break;
+        }
+      
+      if (rExpr->isNullPointerConstant(Context)) {
+        ImpCastExprToType(rExpr, it->getType());
+        InitField = *it;
+        break;
+      }
+    }
+
+    if (CheckAssignmentConstraints(it->getType(), rExpr->getType())
+          == Compatible) {
+      InitField = *it;
+      break;
+    }
+  }
+
+  if (!InitField)
+    return Incompatible;
+
+  ConstructTransparentUnion(Context, rExpr, ArgType, InitField);
+  return Compatible;
+}
+
 Sema::AssignConvertType
 Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) {
   if (getLangOptions().CPlusPlus) {
@@ -3169,7 +3236,7 @@
   // so that we can use references in built-in functions even in C.
   // The getNonReferenceType() call makes sure that the resulting expression
   // does not have reference type.
-  if (rExpr->getType() != lhsType)
+  if (result != Incompatible && rExpr->getType() != lhsType)
     ImpCastExprToType(rExpr, lhsType.getNonReferenceType());
   return result;
 }
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index f4b6598..ab66939 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -1888,9 +1888,13 @@
   if (!getLangOptions().CPlusPlus) {
     // In C, argument passing is the same as performing an assignment.
     QualType FromType = From->getType();
+    
     AssignConvertType ConvTy =
       CheckSingleAssignmentConstraints(ToType, From);
-
+    if (ConvTy != Compatible &&
+        CheckTransparentUnionArgumentConstraints(ToType, From) == Compatible)
+      ConvTy = Compatible;
+    
     return DiagnoseAssignmentResult(ConvTy, From->getLocStart(), ToType,
                                     FromType, From, Flavor);
   }