This is the mail archive of the gcc@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

different address spaces


I have redone the implementation of the eeprom attribute in my prototype.
It is now a cleaner solution, but requires larger changes in the core,
but the changes in the core should not affect any backend/frontend, if
it does not uses them (except a missing case in tree_copy_mem_area, which
will cause an assertion to fail).

The patches are against the CVS of 20050412.

The changes in the core are:
1) MEM_REF_FLAGS introduced (http://www.auto.tuwien.ac.at/~mkoegler/gcc/memref.patch)
The flags are stored in u.fld[2].rt_int of MEM.
A new target hook is introduced, which takes an expression, decl or type
and calculates the target specific MEM_REF_FLAGS.

In set_mem_attributes_minus_bitops (as well es set_mem_attr_from reg),
MEM_REF_FLAGS is initialized from the provided expression.

The most relevant diffs are:
Index: rtl.def
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.def,v
retrieving revision 1.100
diff -u -r1.100 rtl.def
--- rtl.def     22 Jan 2005 22:48:57 -0000      1.100
+++ rtl.def     27 Apr 2005 17:46:53 -0000
@@ -385,8 +385,9 @@

 /* A memory location; operand is the address.  The second operand is the
    alias set to which this MEM belongs.  We use `0' instead of `w' for this
-   field so that the field need not be specified in machine descriptions.  */
-DEF_RTL_EXPR(MEM, "mem", "e0", RTX_OBJ)
+   field so that the field need not be specified in machine descriptions.
+   the third the memory flags */
+DEF_RTL_EXPR(MEM, "mem", "e00", RTX_OBJ)

 /* Reference to an assembler label in the code for this function.
    The operand is a CODE_LABEL found in the insn chain.
Index: rtl.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/rtl.h,v
retrieving revision 1.543
diff -u -r1.543 rtl.h
--- rtl.h       25 Mar 2005 02:23:57 -0000      1.543
+++ rtl.h       27 Apr 2005 17:46:53 -0000
@@ -1080,6 +1080,9 @@
    in the block and provide defaults if none specified.  */
 #define MEM_ATTRS(RTX) X0MEMATTR (RTX, 1)

+/* A set of flags on a mem */
+#define MEM_REF_FLAGS(RTX)     X0INT ((RTX), 2)
+
 /* The register attribute block.  We provide access macros for each value
    in the block and provide defaults if none specified.  */
 #define REG_ATTRS(RTX) X0REGATTR (RTX, 2)
Index: target.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/target.h,v
retrieving revision 1.131
diff -u -r1.131 target.h
--- target.h    12 Apr 2005 06:33:23 -0000      1.131
+++ target.h    27 Apr 2005 17:46:53 -0000
@@ -514,6 +514,9 @@
      to be checked for va_list references.  */
   bool (*stdarg_optimize_hook) (struct stdarg_info *ai, tree lhs, tree rhs);

+  /* extracts MEM_REF_FLAGS out of a tree expression */
+  int (*extract_mem_ref_flags) (tree t);
+
   /* Functions relating to calls - argument passing, returns, etc.  */
   struct calls {
     bool (*promote_function_args) (tree fntype);
Index: emit-rtl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/emit-rtl.c,v
retrieving revision 1.436
diff -u -r1.436 emit-rtl.c
--- emit-rtl.c  25 Mar 2005 02:23:57 -0000      1.436
+++ emit-rtl.c  27 Apr 2005 17:46:50 -0000
@@ -1449,6 +1453,8 @@
   if (t == NULL_TREE)
     return;

+  MEM_REF_FLAGS(ref) = targetm.extract_mem_ref_flags (t);
+
   type = TYPE_P (t) ? t : TREE_TYPE (t);
   if (type == error_mark_node)
     return;
@@ -1685,6 +1691,10 @@
     = get_mem_attrs (MEM_ALIAS_SET (mem), REG_EXPR (reg),
                     GEN_INT (REG_OFFSET (reg)),
                     MEM_SIZE (mem), MEM_ALIGN (mem), GET_MODE (mem));
+
+  if(REG_EXPR (reg))
+    MEM_REF_FLAGS(mem) = targetm.extract_mem_ref_flags (REG_EXPR (reg));
+
 }

 /* Set the alias set of MEM to SET.  */

2) Handling of the eeprom attribute (http://www.auto.tuwien.ac.at/~mkoegler/gcc/addr.patch)
As my old solution had too much problem, I tried a clean implementation, which provided
something, like in DTR18037.

First a new type for storing memory address spaces was introduced. At the moment, it is implemented
as an integer. The value 0 is used as NO_MEM_AREA, which means, that no memory has been
assiged. This value is useful for finding missing initialization of a memory address space variable.
Value 1 is DEFAULT_MEM_AREA, which is the usually adress space, including stack and data segement.
As the memory area is only used in the backend code, the EEPROM address space is not defined here.
As I have not changed the parser, the address space is initialized using an attribute.

The address space attribute has been adden to the following tree constructs:
*TYPE_MEM_AREA: memory area of the pointer target, for other types unused
*DECL_MEM_AREA: memory area, where a variable is located (used for var_decls)
*EXPR_MEM_AREA: current memory area. Basically it is only needed for component_ref, indirect_ref
or an array_ref. As eg. a compound_expr may appear in place of a of a decl, such expression
inherit the MEM_AREA from their "return" expression

For copying the MEM_AREA from a DECL or EXPR to a EXPR, tree_copy_mem_area was written.
It takes care of all possiblities, I have noticed.

As each creation of a INDIRECT_REF, ARRAY_REF or COMPONENT_REF in an optimizer need also
to copy the MEM_AREA, special build function (build*_REF) were written, which set MEM_AREA.
So most changes in the patch consists only of a change of the function call.

To build1_INDIRECT_REF, as first argument, not the element type, but the complete pointer type
or the evaluation expression is passed. In few cases, the memory area of the pointer is not available.
For these, another solution to get the memory area, is needed.

So far, I have tested it with a part of C frontend. It need more testing (as well as correction of
missing MEM_AREAs in expressions). Other frontends will propably also need some modifications,
if they should provide the correct value for MEM_AREA.

Important part of the patch:
Index: tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.h,v
retrieving revision 1.714
diff -u -r1.714 tree.h
--- tree.h      9 Apr 2005 17:19:03 -0000       1.714
+++ tree.h      27 Apr 2005 17:46:55 -0000
@@ -27,6 +27,10 @@
 #include "statistics.h"
 #include "vec.h"

+#define NO_MEM_AREA 0
+#define DEFAULT_MEM_AREA 1
+typedef int memory_area_t;
+
 /* Codes of tree nodes */

 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
@@ -1173,6 +1177,8 @@
 /* In a LOOP_EXPR node.  */
 #define LOOP_EXPR_BODY(NODE) TREE_OPERAND_CHECK_CODE (NODE, LOOP_EXPR, 0)

+#define EXPR_MEM_AREA(NODE) (EXPR_CHECK (NODE)->exp.area)
+
 #ifdef USE_MAPPED_LOCATION
 /* The source location of this expression.  Non-tree_exp nodes such as
    decls and constants can be shared among multiple locations, so
@@ -1292,6 +1298,7 @@
   struct tree_common common;
   source_locus locus;
   int complexity;
+  memory_area_t area;
   tree block;
   tree GTY ((special ("tree_exp"),
             desc ("TREE_CODE ((tree) &%0)")))
@@ -1543,6 +1550,7 @@
 #define TYPE_MAIN_VARIANT(NODE) (TYPE_CHECK (NODE)->type.main_variant)
 #define TYPE_CONTEXT(NODE) (TYPE_CHECK (NODE)->type.context)
 #define TYPE_LANG_SPECIFIC(NODE) (TYPE_CHECK (NODE)->type.lang_specific)
+#define TYPE_MEM_AREA(NODE) (TYPE_CHECK (NODE)->type.area)

 /* For a VECTOR_TYPE node, this describes a different type which is emitted
    in the debugging output.  We use this to describe a vector as a
@@ -1740,6 +1748,7 @@
   HOST_WIDE_INT alias_set;
   /* Points to a structure whose details depend on the language in use.  */
   struct lang_type *lang_specific;
+  memory_area_t area;
 };
 ^L
 /* Define accessor macros for information about type inheritance
@@ -1921,6 +1930,8 @@
     NULL_TREE or a TRANSLATION_UNIT_DECL if the given decl has "file
     scope".  */
 #define DECL_CONTEXT(NODE) (DECL_CHECK (NODE)->decl.context)
Index: tree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/tree.c,v
retrieving revision 1.472
diff -u -r1.472 tree.c
--- tree.c      30 Mar 2005 21:34:29 -0000      1.472
+++ tree.c      27 Apr 2005 17:46:55 -0000
@@ -6664,4 +6676,47 @@
   return result;
 }

+void
+tree_copy_mem_area (tree to, tree from)
+{
+  if(!from)
+    EXPR_MEM_AREA(to)=NO_MEM_AREA;
+  else if(TREE_CODE(from)==INTEGER_CST)
+    EXPR_MEM_AREA(to)=DEFAULT_MEM_AREA;
+  else if(TREE_CODE(from)==STRING_CST)
+    EXPR_MEM_AREA(to)=DEFAULT_MEM_AREA;
+  else if(DECL_P(from))
+    EXPR_MEM_AREA(to)=DECL_MEM_AREA(from);
+  else
+    EXPR_MEM_AREA(to)=EXPR_MEM_AREA(from);
+}
+
+tree
+build1_INDIRECT_REF (tree type, tree pointer)
+{
+  tree t = build1 (INDIRECT_REF, TREE_TYPE (type), pointer);
+  if(TREE_CODE(type)==ARRAY_REF||TREE_CODE(type)==ARRAY_RANGE_REF||TREE_CODE(type)==INDIRECT_REF||TREE_CODE(type)==COMPONENT_REF)
+    EXPR_MEM_AREA(t) = EXPR_MEM_AREA(type);
+  else
+    EXPR_MEM_AREA(t) = TYPE_MEM_AREA(type);
+  return t;
+}
+
+tree
+build3_COMPONENT_REF (tree a, tree b, tree c, tree d)
+{
+  tree t;
+  t = build3 (COMPONENT_REF, a, b, c, d);
+  tree_copy_mem_area (t, b);
+  return t;
+}
+tree build4_ARRAY_REF (tree a, tree b, tree c, tree d, tree e)
+{
+  tree t;
+  t = build4 (ARRAY_REF, a, b, c, d, e);
+  tree_copy_mem_area (t, b);
+  return t;
+}
+
+
Index: c-typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v
retrieving revision 1.431
diff -u -r1.431 c-typeck.c
--- c-typeck.c  9 Apr 2005 03:18:07 -0000       1.431
+++ c-typeck.c  27 Apr 2005 17:46:50 -0000
@@ -1595,6 +1597,8 @@
          if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum))
            TREE_THIS_VOLATILE (ref) = 1;

+         tree_copy_mem_area(ref,datum);
+
          if (TREE_DEPRECATED (subdatum))
            warn_deprecated_use (subdatum);

@@ -1658,6 +1662,7 @@
          TREE_SIDE_EFFECTS (ref)
            = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer);
          TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
+         EXPR_MEM_AREA (ref) = TYPE_MEM_AREA(type);
          return ref;
        }
     }
@@ -1784,6 +1789,9 @@
               in an inline function.
               Hope it doesn't break something else.  */
            | TREE_THIS_VOLATILE (array));
+
+      tree_copy_mem_area(rval,array);
+
       return require_complete_type (fold (rval));
     }
   else
@@ -2070,6 +2078,7 @@

   result = build3 (CALL_EXPR, TREE_TYPE (fntype),
                   function, coerced_params, NULL_TREE);
+  EXPR_MEM_AREA (result) = DEFAULT_MEM_AREA;
   TREE_SIDE_EFFECTS (result) = 1;

   if (require_constant_value)

3) Use of this function in the port:
As I have not change the frontend, I created two attributes:
1) A decl attribute eeprom
2) A type attribute eepromt for marking pointers:

Usage example:
struct x y __attribute__ ((eeprom));
typedef struct x* ax __attribute__ ((eepromt));

important code:
/* Handle a "eeprom" attribute; arguments as in
   struct attribute_spec.handler.  */
static tree
m68hc05_handle_eeprom_attribute (tree * node, tree name,
                                 tree args ATTRIBUTE_UNUSED,
                                 int flags ATTRIBUTE_UNUSED,
                                 bool * no_add_attrs)
{
  if(POINTER_TYPE_P(*node))
    {
      *node = copy_node (*node);
      TYPE_MEM_AREA(*node)=2;
    }
  else if(DECL_P(*node)&&TREE_CODE(*node)!=TYPE_DECL)
    {
      *node = copy_node (*node);
      DECL_MEM_AREA(*node)=2;
    }
  else
    warning ("%qs attribute does not apply",
             IDENTIFIER_POINTER (name));

  return NULL_TREE;
}
const struct attribute_spec m68hc05_attribute_table[] = {
  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
  {"eepromt", 0, 0, false, true, false, m68hc05_handle_eeprom_attribute},
  {"eeprom", 0, 0, true, false, false, m68hc05_handle_eeprom_attribute},
};

/* HOOK for TARGET_EXTRACT_MEM_REF_FLAGS, does the following:
   *check the memory area for eeprom, and return 1, if it is set.
   *stop at unset memory areas
*/

static int
m68hc05_extract_mem_ref_flags (tree expr)
{
  tree t;
  int ref=0;
  if(TREE_CODE(expr)==IMAGPART_EXPR||TREE_CODE(expr)==REALPART_EXPR)
    expr=TREE_OPERAND (expr, 0);
  if(TYPE_P(expr)||TREE_CODE(expr)==STRING_CST||TREE_CODE(expr)==COMPLEX_CST)
    {
      ref=DEFAULT_MEM_AREA;
    }
  else if(DECL_P(expr))
    {
      ref=DECL_MEM_AREA(expr);
    }
  else if(EXPR_P(expr))
    {
      ref=EXPR_MEM_AREA(expr);
    }
  gcc_assert(ref);
  if(ref==2)
    return 1;
  else
    return 0;
}

// my predicate to check for eeprom address space

int
eeprom_operand (op, mode)
     rtx op;
     enum machine_mode mode;
{
  tree t = 0;
  int deref = 0;
  if (mode == VOIDmode)
    mode = GET_MODE (op);
  if (GET_MODE (op) != mode)
    return 0;
  if (!MEM_P (op))
    return 0;

  if (MEM_P (op) && (MEM_REF_FLAGS (op) & 1))
    return 1;
  else
    return 0;
}

The rest is the same, as I described it before.

I hope, that it is understandable, what I am doing.

Adding a syntax for in the C frontend for the address space modifiers
is not an priority for me, as the two attribute solution should
work. An important part, that is still missing, is the type
compatibility checking between pointers to different memory areas.
At the moment, even no warning is issued. I itend to introduce a new
target hook for this, which checks, if two memory areas are compatible.

Comments?

mfg Martin Kögler
PS: Please CC me on replies.



Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]