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. */
+
+
+
+
+
+
         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 () != 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)
           {
+
+
+
             /* 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_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 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 /* Handle a "cdecl" or "stdcall" attribute;
    arguments as in struct attribute_spec.handler.  */
@@ -1322 +1377 @@
     }
 
+
+
+
+
   return NULL_TREE;
 }
@@ -1363 +1422 @@
     }
 
+
+
+
+
   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;
 }