[gcc/ChangeLog]

[pf3gnuchains/gcc-fork.git] / gcc / c-typeck.c

diff --git a/gcc/c-typeck.c b/gcc/c-typeck.c
index d71b990..33c19da 100644 (file)
--- a/gcc/c-typeck.c
+++ b/gcc/c-typeck.c
@@ -1715,7 +1715,7 @@ build_external_ref (tree id, int fun)
 {
   tree ref;
   tree decl = lookup_name (id);
-  tree objc_ivar = lookup_objc_ivar (id);
+  tree objc_ivar = objc_lookup_ivar (id);
 
   if (decl && decl != error_mark_node)
     {
@@ -2514,44 +2514,24 @@ build_unary_op (enum tree_code code, tree xarg, int flag)
                                          TREE_READONLY (arg),
                                          TREE_THIS_VOLATILE (arg));
 
-      argtype = build_pointer_type (argtype);
-
       if (!c_mark_addressable (arg))
        return error_mark_node;
 
-      {
-       tree addr;
-
-       if (TREE_CODE (arg) == COMPONENT_REF)
-         {
-           tree field = TREE_OPERAND (arg, 1);
-
-           addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), flag);
-
-           if (DECL_C_BIT_FIELD (field))
-             {
-               error ("attempt to take address of bit-field structure member `%s'",
-                      IDENTIFIER_POINTER (DECL_NAME (field)));
-               return error_mark_node;
-             }
+      if (TREE_CODE (arg) == COMPONENT_REF
+         && DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1)))
+       {
+         error ("attempt to take address of bit-field structure member `%D'",
+                TREE_OPERAND (arg, 1));
+         return error_mark_node;
+       }
 
-           addr = fold (build2 (PLUS_EXPR, argtype,
-                                convert (argtype, addr),
-                                convert (argtype, byte_position (field))));
-           
-           /* If the folded PLUS_EXPR is not a constant address, wrap
-               it in an ADDR_EXPR.  */
-           if (!TREE_CONSTANT (addr))
-             addr = build1 (ADDR_EXPR, argtype, arg);
-         }
-       else
-         addr = build1 (ADDR_EXPR, argtype, arg);
+      argtype = build_pointer_type (argtype);
+      val = build1 (ADDR_EXPR, argtype, arg);
 
-       if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
-         TREE_INVARIANT (addr) = TREE_CONSTANT (addr) = 1;
+      if (TREE_CODE (arg) == COMPOUND_LITERAL_EXPR)
+       TREE_INVARIANT (val) = TREE_CONSTANT (val) = 1;
 
-       return addr;
-      }
+      return val;
 
     default:
       break;
@@ -2922,8 +2902,10 @@ build_c_cast (tree type, tree expr)
   /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing
      only in <protocol> qualifications.  But when constructing cast expressions,
      the protocols do matter and must be kept around.  */
-  if (!c_dialect_objc () || !objc_is_object_ptr (type))
-    type = TYPE_MAIN_VARIANT (type);
+  if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr)))
+    return build1 (NOP_EXPR, type, expr);
+
+  type = TYPE_MAIN_VARIANT (type);
 
   if (TREE_CODE (type) == ARRAY_TYPE)
     {
@@ -7581,31 +7563,3 @@ build_binary_op (enum tree_code code, tree orig_op0, tree orig_op1,
     return result;
   }
 }
-
-/* Build the result of __builtin_offsetof.  TYPE is the first argument to
-   offsetof, i.e. a type.  LIST is a tree_list that encodes component and
-   array references; PURPOSE is set for the former and VALUE is set for
-   the later.  */
-
-tree
-build_offsetof (tree type, tree list)
-{
-  tree t;
-
-  /* Build "*(type *)0".  */
-  t = convert (build_pointer_type (type), null_pointer_node);
-  t = build_indirect_ref (t, "");
-
-  /* Build COMPONENT and ARRAY_REF expressions as needed.  */
-  for (list = nreverse (list); list ; list = TREE_CHAIN (list))
-    if (TREE_PURPOSE (list))
-      t = build_component_ref (t, TREE_PURPOSE (list));
-    else
-      t = build_array_ref (t, TREE_VALUE (list));
-
-  /* Finalize the offsetof expression.  For now all we need to do is take
-     the address of the expression we created, and cast that to an integer
-     type; this mirrors the traditional macro implementation of offsetof.  */
-  t = build_unary_op (ADDR_EXPR, t, 0);
-  return convert (size_type_node, t);
-}