Fix bad regexp

[pf3gnuchains/gcc-fork.git] / gcc / c-objc-common.c

diff --git a/gcc/c-objc-common.c b/gcc/c-objc-common.c
index be3b847..df16be1 100644 (file)
--- a/gcc/c-objc-common.c
+++ b/gcc/c-objc-common.c
@@ -31,9 +31,17 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include "toplev.h"
 #include "diagnostic.h"
 #include "tree-inline.h"
+#include "varray.h"
+#include "ggc.h"
+#include "langhooks.h"
 
 static int c_tree_printer PARAMS ((output_buffer *));
 static tree inline_forbidden_p PARAMS ((tree *, int *, void *));
+static void expand_deferred_fns PARAMS ((void));
+static tree start_cdtor        PARAMS ((int));
+static void finish_cdtor PARAMS ((tree));
+
+static varray_type deferred_fns;
 
 int
 c_missing_noreturn_ok_p (decl)
@@ -52,6 +60,9 @@ int
 c_disregard_inline_limits (fn)
      tree fn;
 {
+  if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) != NULL)
+    return 1;
+
   return DECL_DECLARED_INLINE_P (fn) && DECL_EXTERNAL (fn);
 }
 
@@ -135,6 +146,10 @@ c_cannot_inline_tree_fn (fnp)
   tree fn = *fnp;
   tree t;
 
+  if (flag_really_no_inline
+      && lookup_attribute ("always_inline", DECL_ATTRIBUTES (fn)) == NULL)
+    return 1;
+
   if (! function_attribute_inlinable_p (fn))
     {
       DECL_UNINLINABLE (fn) = 1;
@@ -194,6 +209,20 @@ c_cannot_inline_tree_fn (fnp)
   return 0;
 }
 
+/* Called from check_global_declarations.  */
+
+bool
+c_warn_unused_global_decl (decl)
+     tree decl;
+{
+  if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
+    return false;
+  if (DECL_IN_SYSTEM_HEADER (decl))
+    return false;
+
+  return true;
+}
+
 /* Initialization common to C and Objective-C front ends.  */
 const char *
 c_objc_common_init (filename)
@@ -202,13 +231,9 @@ c_objc_common_init (filename)
   c_init_decl_processing ();
 
   filename = c_common_init (filename);
+  if (filename == NULL)
+    return NULL;
 
-  add_c_tree_codes ();
-
-  save_lang_status = &push_c_function_context;
-  restore_lang_status = &pop_c_function_context;
-  mark_lang_status = &mark_c_function_context;
-  lang_expand_expr = c_expand_expr;
   lang_expand_decl_stmt = c_expand_decl_stmt;
 
   /* These were not defined in the Objective-C front end, but I'm
@@ -227,9 +252,133 @@ c_objc_common_init (filename)
        mesg_implicit_function_declaration = 0;
     }
 
+  VARRAY_TREE_INIT (deferred_fns, 32, "deferred_fns");
+  ggc_add_tree_varray_root (&deferred_fns, 1);
+
   return filename;
 }
 
+/* Register a function tree, so that its optimization and conversion
+   to RTL is only done at the end of the compilation.  */
+
+int
+defer_fn (fn)
+     tree fn;
+{
+  VARRAY_PUSH_TREE (deferred_fns, fn);
+
+  return 1;
+}
+
+/* Expand deferred functions for C and ObjC.  */
+
+static void
+expand_deferred_fns ()
+{
+  unsigned int i;
+
+  for (i = 0; i < VARRAY_ACTIVE_SIZE (deferred_fns); i++)
+    {
+      tree decl = VARRAY_TREE (deferred_fns, i);
+
+      if (! TREE_ASM_WRITTEN (decl))
+       {
+         /* For static inline functions, delay the decision whether to
+            emit them or not until wrapup_global_declarations.  */
+         if (! TREE_PUBLIC (decl))
+           DECL_DEFER_OUTPUT (decl) = 1;
+         c_expand_deferred_function (decl);
+       }
+    }
+
+  VARRAY_FREE (deferred_fns);
+}
+
+static tree
+start_cdtor (method_type)
+     int method_type;
+{
+  tree fnname = get_file_function_name (method_type);
+  tree void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
+  tree body;
+
+  start_function (void_list_node_1,
+                 build_nt (CALL_EXPR, fnname,
+                           tree_cons (NULL_TREE, NULL_TREE, void_list_node_1),
+                           NULL_TREE),
+                 NULL_TREE);
+  store_parm_decls ();
+
+  current_function_cannot_inline
+    = "static constructors and destructors cannot be inlined";
+
+  body = c_begin_compound_stmt ();
+
+  pushlevel (0);
+  clear_last_expr ();
+  add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
+
+  return body;
+}
+
+static void
+finish_cdtor (body)
+     tree body;
+{
+  tree scope;
+  tree block;
+
+  scope = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
+  block = poplevel (0, 0, 0);
+  SCOPE_STMT_BLOCK (TREE_PURPOSE (scope)) = block;
+  SCOPE_STMT_BLOCK (TREE_VALUE (scope)) = block;
+
+  RECHAIN_STMTS (body, COMPOUND_BODY (body));
+
+  finish_function (0, 0);
+}
+
+/* Called at end of parsing, but before end-of-file processing.  */
+
+void
+c_objc_common_finish_file ()
+{
+  expand_deferred_fns ();
+
+  if (static_ctors)
+    {
+      tree body = start_cdtor ('I');
+
+      for (; static_ctors; static_ctors = TREE_CHAIN (static_ctors))
+       c_expand_expr_stmt (build_function_call (TREE_VALUE (static_ctors),
+                                                NULL_TREE));
+
+      finish_cdtor (body);
+    }
+
+  if (static_dtors)
+    {
+      tree body = start_cdtor ('D');
+
+      for (; static_dtors; static_dtors = TREE_CHAIN (static_dtors))
+       c_expand_expr_stmt (build_function_call (TREE_VALUE (static_dtors),
+                                                NULL_TREE));
+
+      finish_cdtor (body);
+    }
+
+  {
+    int flags;
+    FILE *stream = dump_begin (TDI_all, &flags);
+
+    if (stream)
+      {
+       dump_node (getdecls (), flags & ~TDF_SLIM, stream);
+       dump_end (TDI_all, stream);
+      }
+  }
+}
+
 /* Called during diagnostic message formatting process to print a
    source-level entity onto BUFFER.  The meaning of the format specifiers
    is as follows:
@@ -254,7 +403,7 @@ c_tree_printer (buffer)
     case 'T':
       {
         const char *n = DECL_NAME (t)
-          ? (*decl_printable_name) (t, 2)
+          ? (*lang_hooks.decl_printable_name) (t, 2)
           : "({anonymous})";
         output_add_string (buffer, n);
       }