Changeset 615

Timestamp:

Aug 16, 2003, 9:31:23 PM (22 years ago)

Author:

zap

Message:

.

Location:

trunk/src/gcc/gcc/config/i386

Files:

• emx.c (modified) (6 diffs, 1 prop)
• i386-protos.h (modified) (1 diff, 1 prop)
• i386.c (modified) (4 diffs, 1 prop)

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

@@ -95 +95 @@
 #endif
 
-
 tree ix86_handle_vacpp_attribute (tree *node, tree name, tree args,
   int flags, bool *no_add_attrs)
@@ -113 +112 @@
            an attached attribute (either optlink or system).
            This is the only part which is changing the mangling. */
+
+        type = TREE_TYPE (*node);
+
+        if (ix86_check_append_attr (type, name, no_add_attrs))
+          break;
+
         if (is_attribute_p ("system", name))
           {
@@ -122 +127 @@
                 CLASSTYPE_DECLARED_CLASS (meaning it doesn't apply to plain
                 structs/unions) ? */
-            if (   TREE_CODE (TREE_TYPE (*node)) != METHOD_TYPE
+            if (   TREE_CODE (type) != METHOD_TYPE
                 && (   !(context = DECL_CONTEXT (*node))
                     || (   TREE_CODE (context) != RECORD_TYPE
@@ -171 +176 @@
         /* The attribute should really be attached to our _TYPE
            rather than to the _DECL. */
-        type = TREE_TYPE (*node);
         TYPE_ATTRIBUTES (type) = chainon (TYPE_ATTRIBUTES (type),
                                           tree_cons (name, args, NULL_TREE));
@@ -192 +196 @@
             || TREE_CODE (type) == METHOD_TYPE)
           {
+            if (ix86_check_append_attr (type, name, no_add_attrs))
+              break;
+
             /* Attach the attribute to the (FUNCTION|METHOD)_TYPE node */
             TYPE_ATTRIBUTES (type) = chainon (TYPE_ATTRIBUTES (type),
@@ -198 +205 @@
             break;
           }
-        warning ("`%s' attribute only applies to functions and function types (typecode=%d)",
-                 IDENTIFIER_POINTER (name), type ? (int)TREE_CODE (type) : -1);
+        warning ("`%s' attribute only applies to functions and function types",
+                 IDENTIFIER_POINTER (name));
         *no_add_attrs = true;
         break;

trunk/src/gcc/gcc/config/i386/i386-protos.h

@@ -183 +183 @@
 
 #ifdef TREE_CODE
+extern int ix86_check_append_attr PARAMS ((tree, tree, bool *));
+
 extern int ix86_return_pops_args PARAMS ((tree, tree, int));
 extern tree ix86_build_va_list PARAMS ((void));

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

@@ -1296 +1296 @@
 };
 
+/* Check if we don't have incompatible calling conversion attributes */
+int
+ix86_check_append_attr (tree type, tree name, bool *no_add_attrs)
+{
+  /* ??? use ix86_comp_type_attributes maybe ??? */
+  unsigned i;
+  const char *exclname;
+  static const char *cc [] =
+  {
+    "cdecl",
+    "stdcall",
+    "regparm",
+#ifdef TARGET_SYSTEM_DECL_ATTRIBUTES
+    "system",
+#endif
+#ifdef TARGET_OPTLINK_DECL_ATTRIBUTES
+    "optlink",
+#endif
+  };
+
+  exclname = IDENTIFIER_POINTER (name);
+  if (exclname [0] == '_')
+    {
+      /* Remove leading and trailing underscores */
+      const char *x1, *x2;
+      char *newname;
+      x1 = exclname + 1;
+      while (*x1 == '_')
+        x1++;
+      x2 = strchr (x1, 0);
+      while (x2 [-1] == '_' && x2 > x1)
+        x2--;
+      newname = alloca (x2 - x1 + 1);
+      memcpy (newname, x1, x2 - x1);
+      newname [x2 - x1] = 0;
+      exclname = newname;
+    }
+
+  for (i = 0; i < sizeof (cc) / sizeof (const char *); i++)
+    if (lookup_attribute (cc [i], TYPE_ATTRIBUTES (type)))
+      {
+        /* Warn if we have another calling convention attribute and it is
+           different from the currently processed attribute. If there is
+           already an attribute with the same name attached, silently ignore
+           currently processed attribute. */
+        if (strcmp (exclname, cc [i]))
+          warning ("`%s' attribute is incompatible with earlier defined `%s' attribute",
+                   IDENTIFIER_POINTER (name), cc [i]);
+        *no_add_attrs = true;
+        return -1;
+      }
+
+  return 0;
+}
+
 /* Handle a "cdecl" or "stdcall" attribute;
    arguments as in struct attribute_spec.handler.  */
@@ -1322 +1377 @@
     }
 
+  /* Check if the attributes are compatible */
+  if (ix86_check_append_attr (*node, name, no_add_attrs))
+    return NULL_TREE;
+
   return NULL_TREE;
 }
@@ -1363 +1422 @@
     }
 
+  /* Check if the attributes are compatible */
+  if (ix86_check_append_attr (*node, name, no_add_attrs))
+    return NULL_TREE;
+
   return NULL_TREE;
 }
@@ -1474 +1537 @@
      tree type2;
 {
-  /* Check for mismatch of non-default calling convention.  */
-  const char *const rtdstr = TARGET_RTD ? "cdecl" : "stdcall";
-
-/*
-@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ TODO: check for optlink and system
-#ifdef SUBTARGET_COMP_TYPE_ATTRIBUTES
-  SUBTARGET_COMP_TYPE_ATTRIBUTES
+  unsigned i;
+  unsigned char cc1 = 0, cc2 = 0;
+  static struct
+  {
+    const char *attr;
+    unsigned char flag;
+  } typecode [] =
+  {
+    { "cdecl",   0x10 },
+    { "stdcall", 0x20 },
+    { "regparm", 0x30 },
+#ifdef TARGET_SYSTEM_DECL_ATTRIBUTES
+    { "system",  0x11 },
 #endif
-*/
-
+#ifdef TARGET_OPTLINK_DECL_ATTRIBUTES
+    { "optlink", 0x40 },
+#endif
+  };
+
+  /* The following calling conventions have meaning only for functions */
   if (TREE_CODE (type1) != FUNCTION_TYPE)
     return 1;
 
-  /* Check for mismatched return types (cdecl vs stdcall).  */
-  if (!lookup_attribute (rtdstr, TYPE_ATTRIBUTES (type1))
-      != !lookup_attribute (rtdstr, TYPE_ATTRIBUTES (type2)))
+  /* The function may have only one calling convention.
+   * For simplicity we translate the calling conversion attribute
+   * to a numeric constant, then the numbers are compared.
+   *
+   * If the top 4 bits are the same, the types are compatible
+   * (e.g. issue a warning but allow the operation).
+   */
+
+  for (i = 0; i < sizeof (typecode) / sizeof (typecode [0]); i++)
+    {
+      if (lookup_attribute (typecode [i].attr, TYPE_ATTRIBUTES (type1)))
+        cc1 = typecode [i].flag;
+      if (lookup_attribute (typecode [i].attr, TYPE_ATTRIBUTES (type2)))
+        cc2 = typecode [i].flag;
+    }
+
+  if (!cc1)
+    cc1 = TARGET_RTD ? 0x20 : 0x10;
+  if (!cc2)
+    cc2 = TARGET_RTD ? 0x20 : 0x10;
+
+  /* If calling conventions are the same, its okay */
+  if (cc1 == cc2)
+    return 1;
+
+  /* If they are not compatible, return 0 */
+  if ((cc1 ^ cc2) & 0xf0)
     return 0;
-  return 1;
+
+  /* They are nearly compatible, issue a warning */
+  return 2;
 }