Changeset 666 for trunk/src

Timestamp:

Sep 9, 2003, 1:17:27 AM (22 years ago)

Author:

bird

Message:

#572: Fixing calling conventions again... not 100 cleaned up yet.

Location:

trunk/src/gcc/gcc/config/i386

Files:

• emx.c (modified) (7 diffs, 1 prop)
• i386.c (modified) (7 diffs, 1 prop)

trunk/src/gcc/gcc/config/i386/emx.c

@@ -31 +31 @@
 #include "flags.h"
 #include "i386-protos.h"
+#include "diagnostic.h"
 
 /* The size of the target's pointer type.  */
@@ -72 +73 @@
 }
 
-static void dump (tree node);
-static void dump (tree node)
+const char *birddump_callingconv(tree node);
+const char *birddump_callingconv(tree node)
+{
+    static const char *apsz[] = {"system", "optlink", "stdcall"};
+    static const char *psznone = "none";
+    static const char *pszdefault = "default";
+    tree        attr;
+    unsigned    i;
+
+    if (!node)
+        return psznone;
+
+    attr = (DECL_P (node) ? DECL_ATTRIBUTES (node) : TYPE_ATTRIBUTES (node));
+    if (!attr)
+        return pszdefault;
+
+    for (i = 0; i < sizeof(apsz) / sizeof(apsz[0]); i++)
+        if (node && attr && lookup_attribute (apsz[i], attr))
+            return apsz[i];
+
+    return pszdefault;
+}
+
+void birddump (tree node);
+void birddump (tree node)
 {
     tree type, type2, context, name;
@@ -83 +107 @@
     context = DECL_P (node) ? DECL_CONTEXT (node) : NULL_TREE;
     name = DECL_P (node) ? DECL_NAME (node) : NULL_TREE;
-    fprintf(stderr, "dbg: node=%d %s type=%d %s type_type=%d %s context=%d %s name=%s\n",
-            TREE_CODE(node), code(node),
-            type ? (int)TREE_CODE(type) : -1, code(type),
-            type2 ? (int)TREE_CODE(type2) : -1, code(type2),
-            context ? (int)TREE_CODE(context) : -1, code(context),
+
+    fprintf(stderr, "dbg: node=%d %s %p %s  type=%d %s %p %s  type_type=%d %s %p %s  context=%d %s %p  name=%s\n",
+            TREE_CODE(node), code(node), (void*)node, birddump_callingconv(node),
+            type ? (int)TREE_CODE(type) : -1, code(type), (void*)type, birddump_callingconv(type),
+            type2 ? (int)TREE_CODE(type2) : -1, code(type2), (void*)type2, birddump_callingconv(type2),
+            context ? (int)TREE_CODE(context) : -1, code(context), (void*)context,
             name ? IDENTIFIER_POINTER (name) : "<none>");
 }
 
 #define dfprintf(a) fprintf a
-#define DUMP(node) dump(node)
+#define DUMP(node) birddump(node)
 #else
 #define dfprintf(a) do {} while (0)
@@ -112 +137 @@
     return 0;
 
+  /* Only functions declarations are subject to mangling. */
+  if (TREE_CODE (decl) != FUNCTION_DECL)
+    return 0;
+
+  dfprintf((stderr, "emx_c_set_decl_assembler_name\n"));
+  DUMP(decl);
+
   recurse++;
-
   type = TREE_TYPE (decl);
 
@@ -205 +236 @@
 }
 
+#if 0 /* choose between the smaller non working version, and the
+         large ugly one which is working. */
+
 tree emx_handle_vacpp_attribute (tree *node, tree name, tree args,
   int flags, bool *no_add_attrs)
 {
+  tree *type;
   (void) args;
   (void) flags;
 
+  dfprintf((stderr, "emx_handle_vacpp_attribute\n"));
   DUMP (*node);
 
@@ -233 +269 @@
     return NULL_TREE;
 
+  /* Now, a new type with our attribute please!
+     If the FUNCTION_TYPE/METHOD_TYPE already have the attribute associated,
+     there is no need to duplicate the type.
+     @todo: I'm unsure wether or not we should do this from node and down... */
+  for (type = node;
+       TREE_CODE (*type) != FUNCTION_TYPE && TREE_CODE (*type) != METHOD_TYPE;
+       type = &TREE_TYPE (*type))
+      /* do nothing */;
+
+  if (lookup_attribute (IDENTIFIER_POINTER (name), TYPE_ATTRIBUTES (*type)))
+      return NULL_TREE;
+
+  *type = build_type_copy (*type);
+  *type = build_type_attribute_variant (*type, tree_cons (name, args, TYPE_ATTRIBUTES (*type)) );
+  /**no_add_attrs = true; ?? */
+
+  dfprintf((stderr, "emx_handle_vacpp_attribute: new type (%p)\n", (void*)type));
+  DUMP (*node);
   return NULL_TREE;
 }
+
+#else
+
+/* This is the working version which we belive duplicate some which could be
+   done by the generic attribute stuff in GCC... */
+tree emx_handle_vacpp_attribute (tree *node, tree name, tree args,
+  int flags, bool *no_add_attrs)
+{
+  tree type;
+
+  dfprintf((stderr, "emx_handle_vacpp_attribute: node=%p\n", node));
+  DUMP (*node);
+
+  switch (TREE_CODE (*node))
+    {
+      /* Declarations!
+         We need to attach the attribute to the type of the declaration.
+         (Name mangling is done by emx_c_set_decl_assembler_name().)  */
+      case FUNCTION_DECL:/* Function declaration. */
+      case TYPE_DECL:    /* Function or function pointer type. */
+      case FIELD_DECL:   /* Function pointer (or function?) as a struct, union or class member. */
+      case PARM_DECL:    /* Function pointer as a parameter. */
+      case VAR_DECL:     /* Function pointer variable. */
+        /* If this is a type declaration with our attribute, we allow it
+           only if it is a pointer-to-a-function type or a function type. */
+        type = TREE_TYPE (*node);
+        if (TREE_CODE (type) == POINTER_TYPE)
+          type = TREE_TYPE(type);
+        if (   TREE_CODE (type) != FUNCTION_TYPE
+            && TREE_CODE (type) != METHOD_TYPE)
+          {
+            warning ("`%s' attribute only applies to functions and function types, not to '%T'.",
+                     IDENTIFIER_POINTER (name), type);
+            *no_add_attrs = true;
+            break;
+          }
+
+        if (ix86_check_append_attr (type, name, no_add_attrs))
+          break;
+
+        /* If required we'll make a variant of the type for this attribute. */
+        if (!lookup_attribute (IDENTIFIER_POINTER (name),
+                               TYPE_ATTRIBUTES (type)))
+          {
+            tree *ptype = node;
+            while (*ptype != type)
+                ptype = &TREE_TYPE (*ptype);
+            *ptype = build_type_copy (*ptype);
+            *ptype = build_type_attribute_variant (
+                *ptype, tree_cons (name, args, TYPE_ATTRIBUTES (*ptype)) );
+            dfprintf((stderr, "emx_handle_vacpp_attribute: new type\n"));
+            DUMP(*node);
+          }
+        else
+          dfprintf((stderr, "emx_handle_vacpp_attribute: use old type\n"));
+        *no_add_attrs = true;
+        break;
+
+
+      /* Types!
+         For types involving functions we need to convince decl_attributes()
+         (and its callers) to supply a declaration so we safely can change
+         the type. */
+      case POINTER_TYPE:
+        /* We allow:
+           This being the return type of a function which is coming soon.
+           This being a function pointer which declaration is coming next.
+           Everything else is considered inappropriate use of the attribute. */
+        if (   !(flags & ATTR_FLAG_FUNCTION_NEXT)
+            && (    !(flags & ATTR_FLAG_DECL_NEXT)
+                ||  !(type = TREE_TYPE (*node))
+                || (   TREE_CODE (type) != FUNCTION_TYPE
+                    && TREE_CODE (type) != METHOD_TYPE)))
+        {
+            warning ("`%s' attribute only applies to functions and function types",
+                     IDENTIFIER_POINTER (name));
+            *no_add_attrs = true;
+            break;
+        }
+        /* fall thru */
+      case FUNCTION_TYPE:
+      case METHOD_TYPE:
+#if 0 /* bird: This fixes optlink/tst4.c and doesn't seem to break anything.
+               If set to true we are in some cases imposing _Optlink onto following
+               declarations. This is weird stuff!
+            !! This problem is actually what we see with the other implementation!! */
+        *no_add_attrs = true;
+#endif
+        return tree_cons (name, args, NULL_TREE);
+
+      default:
+        warning ("`%s' attribute only applies to functions and function types (code=%d)",
+                 IDENTIFIER_POINTER (name), TREE_CODE (*node));
+        *no_add_attrs = true;
+        break;
+    }
+
+  return NULL_TREE;
+}
+#endif
 
 void
@@ -265 +419 @@
   }
 }
+
+/* Adds calling convention to a function dump. (diagnostic) */
+void emx_print_callingconvention (tree type, struct output_buffer *scratch_buffer)
+{
+  const char *conv = NULL;
+
+  if (lookup_attribute ("system", TYPE_ATTRIBUTES (type)))
+    conv = "_System ";
+  else if (lookup_attribute ("optlink", TYPE_ATTRIBUTES (type)))
+    conv = "_Optlink ";
+  else if (lookup_attribute ("stdcall", TYPE_ATTRIBUTES (type)))
+    conv = "__stdcall ";
+  else if (lookup_attribute ("cdecl", TYPE_ATTRIBUTES (type)))
+    conv = "__cdecl ";
+
+  if (conv)
+    output_add_string(scratch_buffer, conv);
+
+}
+

trunk/src/gcc/gcc/config/i386/i386.c

@@ -1273 +1273 @@
 {
   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
+#ifdef EMX /** @todo: ugly stuff, cleanup later. */
+  /* Stdcall attribute says callee is responsible for popping arguments
+     if they are not variable.  */
+  { "stdcall",   0, 0, false, false, false, ix86_handle_system_attribute },
+  /* Cdecl attribute says the callee is a normal C declaration */
+  { "cdecl",     0, 0, false, false, false, ix86_handle_system_attribute },
+#else
   /* Stdcall attribute says callee is responsible for popping arguments
      if they are not variable.  */
@@ -1278 +1285 @@
   /* Cdecl attribute says the callee is a normal C declaration */
   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cdecl_attribute },
+#endif
   /* Regparm attribute specifies how many integer arguments are to be
      passed in registers.  */
@@ -1286 +1294 @@
   { "shared",    0, 0, true,  false, false, ix86_handle_shared_attribute },
 #endif
+#ifdef EMX /** @todo: ugly stuff, cleanup later. */
+#ifdef TARGET_SYSTEM_DECL_ATTRIBUTES
+  /* System says the function is extern "C" and is not underscored. */
+  { "system",    0, 0, false, false, false, ix86_handle_system_attribute },
+#endif
+#ifdef TARGET_OPTLINK_DECL_ATTRIBUTES
+  /* Optlink is like regparm with a few differences */
+  { "optlink",   0, 0, false, false, false, ix86_handle_optlink_attribute },
+#endif
+#else
 #ifdef TARGET_SYSTEM_DECL_ATTRIBUTES
   /* System says the function is extern "C" and is not underscored. */
@@ -1293 +1311 @@
   /* Optlink is like regparm with a few differences */
   { "optlink",   0, 0, false, true,  true,  ix86_handle_optlink_attribute },
+#endif
 #endif
   { NULL,        0, 0, false, false, false, NULL }
@@ -1558 +1577 @@
   unsigned i, cc1 = 0, cc2 = 0;
 
-  /* The following calling conventions have meaning only for functions */
-  if (TREE_CODE (type1) != FUNCTION_TYPE)
+  /* The following calling conventions have meaning only for functions,
+     methods and pointers to such. */
+  if (TREE_CODE (type1) == POINTER_TYPE)
+      type1 = TREE_TYPE(type1);
+  if (TREE_CODE (type2) == POINTER_TYPE)
+      type2 = TREE_TYPE(type2);
+  if (   TREE_CODE (type1) != FUNCTION_TYPE
+      && TREE_CODE (type1) != METHOD_TYPE
+      && TREE_CODE (type2) != FUNCTION_TYPE
+      && TREE_CODE (type2) != METHOD_TYPE)
     return 1;
 
-/*@@@todo: this doesn't work yet because of some bug somewhere inside gcc.
-testcase for both C and C++:
-  void f (); static void (* _Optlink x) () = f;           <-- compiles ok
-testcase for C++:
-  void _Optlink f (); static void (* _Optlink x) () = f;  <-- bad types
-*/
-#if __ANNOYING_BUG_IN_GCC_IS_FINALLY_FIXED
   /* The function may have only one calling convention.
    * For simplicity we translate the calling conversion attribute
@@ -1576 +1596 @@
    * (e.g. issue a warning but allow the operation).
    */
-
   for (i = 0; ix86_attribute_table [i].name; i++)
     if (ix86_attribute_codes [i] & IX86_ATTR_TYPE_CALLCONV)
@@ -1601 +1620 @@
   /* They are nearly compatible */
   return 2;
-#else
-  return 1;
-#endif
 }