Changeset 676

Timestamp:

Sep 9, 2003, 8:37:41 PM (22 years ago)

Author:

bird

Message:

#631: return struct for system and optlink calling conventions.

Location:

trunk/src/gcc/gcc

Files:

• calls.c (modified) (1 diff, 1 prop)
• config/i386/emx.c (modified) (2 diffs, 1 prop)
• config/i386/emx.h (modified) (1 diff, 1 prop)
• cp/decl.c (modified) (1 diff, 1 prop)
• cp/semantics.c (modified) (1 diff, 1 prop)
• expr.c (modified) (1 diff, 1 prop)
• function.c (modified) (5 diffs, 1 prop)
• integrate.c (modified) (2 diffs, 1 prop)
• reg-stack.c (modified) (1 diff, 1 prop)
• tree.h (modified) (1 diff, 1 prop)

trunk/src/gcc/gcc/calls.c

@@ -2274 +2274 @@
 
   /* Cater to broken compilers.  */
-  if (aggregate_value_p (exp))
+  if (aggregate_value_p2 (exp, fndecl))                                         /* bird: #631: return struct */
     {
       /* This call returns a big structure.  */

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

@@ -130 +130 @@
   tree id, type;
   int rc = 1;
-
+  
+  /*
   dfprintf((stderr, "emx_c_set_decl_assembler_name\n"));
   DUMP(decl);
+  */
 
   /* Sometimes we recursively call DECL_ASSEMBLER_NAME to apply the default
@@ -421 +423 @@
   }
 }
+
+
+/* Checks if the function is using either optlink or system calling convention
+   and returns 1 in those cases forcing the return value to be in memory.
+   The problem (#631) was that structures less than 8 bytes were returned in 
+   registers. _System and _Optlink requires them to be passed in as a hidden
+   parameter.
+   @type is the return type.
+   @fntype is function type, call expression, function declaration or null.
+   The return value is 1 to force the return value into memory. Return 0 if we
+   don't know. */
+
+int emx_return_in_memory_with_fntype (tree type, tree fntype)
+{
+  /* (from aggregate_value_p() CVS trunk) */
+  if (fntype)
+    switch (TREE_CODE (fntype))
+      {
+      case CALL_EXPR:
+        fntype = get_callee_fndecl (fntype);
+        fntype = fntype ? TREE_TYPE (fntype) : 0;
+        break;
+      case FUNCTION_DECL:
+        fntype = TREE_TYPE (fntype);
+        break;
+      case FUNCTION_TYPE:
+      case METHOD_TYPE:
+        break;
+      case IDENTIFIER_NODE:
+        fntype = 0;
+        break;
+      default:
+        /* We don't expect other rtl types here.  */
+        abort();
+      }
+
+  /* (future targetm.calls.return_in_memory additions) */
+  if (fntype
+   && AGGREGATE_TYPE_P (type)
+   && (   lookup_attribute ("optlink", TYPE_ATTRIBUTES (fntype))
+       || lookup_attribute ("system", TYPE_ATTRIBUTES (fntype))))
+    {
+      dfprintf((stderr, "emx_return_in_memory_with_fntype: returns 1\n"));
+      return 1;
+    }
+
+  /* return ix86_return_in_memory (exp); - future */
+  dfprintf((stderr, "emx_return_in_memory_with_fntype: returns 0\n"));
+  return 0;
+}
+

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

@@ -108 +108 @@
 #define TARGET_CXX_SET_DECL_ASSEMBLER_NAME(decl) \
   (emx_c_set_decl_assembler_name (decl, DECL_LANG_SPECIFIC(decl) && DECL_FUNCTION_MEMBER_P (decl)))
+
+/* #631: Hack (temporary, will be fixed properly 3.4.x it seems) for _Optlink and
+   _System functions which returns structures. (breaks some tcpip stuff.) */
+extern int emx_return_in_memory_with_fntype PARAMS ((tree type, tree fntype));
+#define RETURN_IN_MEMORY_WITH_FNTYPE emx_return_in_memory_with_fntype
 
 /* This macros will stick a label to exception table for current file,

trunk/src/gcc/gcc/cp/decl.c

@@ -14337 +14337 @@
          simpler, since we don't have to worry about promoted modes.  */
       if (r != error_mark_node
-          && aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
+          && aggregate_value_p2 (TREE_TYPE (TREE_TYPE (fndecl)), fndecl))       /* bird: #631: return struct */
         {
           DECL_ALIGN (r) = DECL_ALIGN (DECL_RESULT (fndecl));

trunk/src/gcc/gcc/cp/semantics.c

@@ -2229 +2229 @@
   copy_from_buffer_p = 0;
 #ifdef PCC_STATIC_STRUCT_RETURN  
-  if (!AGGR_INIT_VIA_CTOR_P (aggr_init_expr) && aggregate_value_p (type))
+  if (!AGGR_INIT_VIA_CTOR_P (aggr_init_expr) && aggregate_value_p2 (type, fn))  /* bird: #631: return struct */
     {
       int old_ac = flag_access_control;

trunk/src/gcc/gcc/expr.c

@@ -3791 +3791 @@
      needs to be done.  Handling this in the normal way is safe because no
      computation is done before the call.  */
-  if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p (from)
+  if (TREE_CODE (from) == CALL_EXPR && ! aggregate_value_p2 (from, from)        /* bird: #631: return struct */
       && TREE_CODE (TYPE_SIZE (TREE_TYPE (from))) == INTEGER_CST
       && ! ((TREE_CODE (to) == VAR_DECL || TREE_CODE (to) == PARM_DECL)

trunk/src/gcc/gcc/function.c

@@ -4278 +4278 @@
    EXP may be a type node or an expression (whose type is tested).  */
 
+/* bird: #631: We need this change now to get _System and _Optlink working on 
+   the EMX target. In the CVS trunk aggregate_value_p is extended with fntype 
+   so this hack will eventually go away.  */
+#ifdef RETURN_IN_MEMORY_WITH_FNTYPE
 int
 aggregate_value_p (exp)
      tree exp;
 {
+  return aggregate_value_p2 (exp, NULL_TREE);
+}
+
+int
+aggregate_value_p2 (exp, fntype)
+     tree exp, fntype;
+#else
+int
+aggregate_value_p (exp)
+     tree exp;
+#endif
+{
   int i, regno, nregs;
   rtx reg;
@@ -4289 +4305 @@
   if (TREE_CODE (type) == VOID_TYPE)
     return 0;
+  #ifdef RETURN_IN_MEMORY_WITH_FNTYPE /* bird: #631: return struct */
+  if (RETURN_IN_MEMORY_WITH_FNTYPE(type, fntype))
+    return 1;
+  #endif 
   if (RETURN_IN_MEMORY (type))
     return 1;
@@ -4386 +4406 @@
 
   /* If struct value address is treated as the first argument, make it so.  */
-  if (aggregate_value_p (DECL_RESULT (fndecl))
+  if (aggregate_value_p2 (DECL_RESULT (fndecl), fndecl)                         /* bird: #631: return struct */
       && ! current_function_returns_pcc_struct
       && struct_value_incoming_rtx == 0)
@@ -6408 +6428 @@
 
   /* Set flags used by final.c.  */
-  if (aggregate_value_p (DECL_RESULT (subr)))
+  if (aggregate_value_p2 (DECL_RESULT (subr), subr))                            /* bird: #631: return struct */
     {
 #ifdef PCC_STATIC_STRUCT_RETURN
@@ -6585 +6605 @@
 
   /* Decide whether to return the value in memory or in a register.  */
-  if (aggregate_value_p (DECL_RESULT (subr)))
+  if (aggregate_value_p2 (DECL_RESULT (subr), subr))                            /* bird: #631: return struct */
     {
       /* Returning something that won't go in a register.  */

trunk/src/gcc/gcc/integrate.c

@@ -1030 +1030 @@
         {
           if (! structure_value_addr
-              || ! aggregate_value_p (DECL_RESULT (fndecl)))
+              || ! aggregate_value_p2 (DECL_RESULT (fndecl), fndecl))           /* bird: #631: return struct */
             abort ();
 
@@ -1285 +1285 @@
   if (target
       && TYPE_MODE (TREE_TYPE (TREE_TYPE (fndecl))) == BLKmode
-      && ! aggregate_value_p (TREE_TYPE (TREE_TYPE (fndecl))))
+      && ! aggregate_value_p2 (TREE_TYPE (TREE_TYPE (fndecl)), fndecl))         /* bird: #631: return struct */
     target = copy_blkmode_from_reg (0, target, TREE_TYPE (TREE_TYPE (fndecl)));
 

trunk/src/gcc/gcc/reg-stack.c

@@ -832 +832 @@
   /* If the value is supposed to be returned in memory, then clearly
      it is not returned in a stack register.  */
-  if (aggregate_value_p (DECL_RESULT (decl)))
+  if (aggregate_value_p2 (DECL_RESULT (decl), decl))                            /* bird: #631: return struct */
     return 0;
 

trunk/src/gcc/gcc/tree.h

@@ -3020 +3020 @@
 extern void preserve_rtl_expr_temps     PARAMS ((tree));
 extern int aggregate_value_p            PARAMS ((tree));
+#ifdef RETURN_IN_MEMORY_WITH_FNTYPE                                             /* bird: #631: return struct */
+extern int aggregate_value_p2           PARAMS ((tree, tree));
+#else
+#define aggregate_value_p2(exp, fntype) aggregate_value_p (exp)
+#endif
 extern void free_temps_for_rtl_expr     PARAMS ((tree));
 extern void instantiate_virtual_regs    PARAMS ((tree, rtx));