[M3devel] FW: m3_load/m3_store/bit_field_ref lose offset??

Jay jay.krell at cornell.edu
Sat Nov 8 16:45:15 CET 2008


truncated as usual...along with losing a lot of whitespace..
Let's see...


Tony, how about switching these #if's?
I explain some of why below.

static void
m3_store (tree v, int o, tree src_t, m3_type src_T, tree dst_t, m3_type dst_T)
{
  tree val;
#if 0
  if (o != 0 || TREE_TYPE (v) != dst_t) {
    v = m3_build3 (BIT_FIELD_REF, dst_t, v, TYPE_SIZE (dst_t),
     bitsize_int (o));
  }
#else
  /* failsafe, but inefficient */
  if (o != 0 || TREE_TYPE (v) != dst_t) {
    v = m3_build1 (ADDR_EXPR, t_addr, v);
    v = m3_build2 (PLUS_EXPR, t_addr, v, size_int (o / BITS_PER_UNIT));
    v = m3_build1 (INDIRECT_REF, dst_t,
     m3_cast (build_pointer_type (dst_t), v));
  }
#endif
  TREE_THIS_VOLATILE (v) = 1; /* force this to avoid aliasing problems */
  val = m3_cast (src_t, EXPR_REF (-1));
  if (src_T != dst_T) {
    val = m3_build1 (CONVERT_EXPR, dst_t, val);
  }
  add_stmt (build2 (MODIFY_EXPR, dst_t, v, val));
  EXPR_POP ();
}
m3_load (tree v, int o, tree src_t, m3_type src_T, tree dst_t, m3_type dst_T)
{
#if 0
  if (o != 0 || TREE_TYPE (v) != src_t) {
    v = m3_build3 (BIT_FIELD_REF, src_t, v, TYPE_SIZE (src_t),
     bitsize_int (o));
  }
#else
  /* failsafe, but inefficient */
  if (o != 0 || TREE_TYPE (v) != src_t) {
    v = m3_build1 (ADDR_EXPR, t_addr, v);
    v = m3_build2 (PLUS_EXPR, t_addr, v, size_int (o / BITS_PER_UNIT));
    v = m3_build1 (INDIRECT_REF, src_t,
     m3_cast (build_pointer_type (src_t), v));
  }
#endif
  TREE_THIS_VOLATILE (v) = 1; /* force this to avoid aliasing problems */
  if (src_T != dst_T) {
    v = m3_build1 (CONVERT_EXPR, dst_t, v);
  }
  EXPR_PUSH (v);
}

I'm working on MIPS64_OPENBSD (OpenBSD on an SGI O2).
In an early version it seems that many loads/stores of global variables is wrong.
The "first" code affected is RTLinker_ExpandModuleTable.

PROCEDURE ExpandModuleTable () =
  CONST InitialTableSize = 500;
  VAR new_mods: ADDRESS;  n_bytes: INTEGER;
  BEGIN
    IF (modules = NIL) THEN
      (* first time... *)
      max_modules := InitialTableSize;
      modules := Cstdlib.malloc (InitialTableSize * BYTESIZE (RT0.ModulePtr));
      IF (modules = NIL) THEN Cstdlib.abort (); END;
    ELSE
      n_bytes := max_modules * BYTESIZE (RT0.ModulePtr);
      new_mods := Cstdlib.malloc (n_bytes + n_bytes);
      IF (new_mods = NIL) THEN Cstdlib.abort (); END;
      EVAL Cstring.memcpy (new_mods, modules, n_bytes);
      Cstdlib.free (modules);
      modules := new_mods;
      INC (max_modules, max_modules);
    END;
  END ExpandModuleTable;

It should read back modules as NIL.
What happens is it reads back modules as not NIL,
and then max_modules should also be zero, but is "large", leading to malloc to fail,
and abort called.

The output of cm3cg -y is reasonable.
It indicates offset loads.

What is incorrect is that in many loads and stores, but not all, the
offsets are lost.

(923) begin_procedure
  procedure RTLinker__ExpandModuleTable
 RTLinker__ExpandModuleTable(924) set_source_line
  source line  208
(925) load_nil
(926) store
  store (M3_AJWxb1_new_mods) offset 0x0 src_t 0xb dst_t 0xb
(927) set_source_line
  source line  207
(928) set_source_line
  source line  210
(929) load_nil
(930) load
  m3cg_load (MM_RTLinker): offset 0x440, convert 0xb -> 0xb

Here is the incorrect code:

 .globl RTLinker__ExpandModuleTable
 .stabd 46,0,0
 .stabn 68,0,206,.LM108
.LM108:
.LFBB8:
 .set nomips16
 .ent RTLinker__ExpandModuleTable
RTLinker__ExpandModuleTable:
 .frame $fp,64,$31  # vars= 32, regs= 3/0, args= 0, gp= 0
 .mask 0xd0000000,-8
 .fmask 0x00000000,0
 daddiu $sp,$sp,-64
 sd $31,56($sp)
 sd $fp,48($sp)
 sd $28,40($sp)
 move $fp,$sp
 lui $28,%hi(%neg(%gp_rel(RTLinker__ExpandModuleTable)))
 daddu $28,$28,$25
 daddiu $28,$28,%lo(%neg(%gp_rel(RTLinker__ExpandModuleTable)))
.LBB9:
 .stabn 68,0,208,.LM109
.LM109:
 sd $0,16($fp)
 .stabn 68,0,210,.LM110
.LM110:
 dla $2,MM_RTLinker
 ld $2,0($2)      << WRONG
 bne $2,$0,.L61
 .stabn 68,0,212,.LM111
.LM111:
 dla $3,MM_RTLinker
 ld $2,128($3)
 andi $2,$2,0x0
 ori $2,$2,0x1f4
 sd $2,128($3)
 .stabn 68,0,213,.LM112
.LM112:
 li $4,4000   # 0xfa0
 jal malloc
 sd $2,0($fp)
 ld $4,0($fp)
 dla $3,MM_RTLinker
 ld $2,136($3)
 andi $2,$2,0x0
 or $2,$4,$2
 sd $2,136($3)     << OK, offset seems low, but it agrees with elsewhere 
 .stabn 68,0,214,.LM113
.LM113:
 dla $2,MM_RTLinker
 ld $2,0($2)       << WRONG 
 bne $2,$0,.L65
 jal abort
 b .L65
.L61:
 .stabn 68,0,216,.LM114
.LM114:
 dla $2,MM_RTLinker
 ld $2,0($2)        << WRONG 
 dsll $2,$2,3
 sd $2,8($fp)
 .stabn 68,0,217,.LM115
.LM115:
 ld $3,8($fp)
 ld $2,8($fp)
 daddu $2,$3,$2
 move $4,$2
 jal malloc
 sd $2,0($fp)
 ld $2,0($fp)
 sd $2,16($fp)
 .stabn 68,0,218,.LM116
.LM116:
 ld $2,16($fp)
 bne $2,$0,.L64
 jal abort
.L64:
 .stabn 68,0,219,.LM117
.LM117:
 ld $4,16($fp)
 dla $2,MM_RTLinker
 ld $2,0($2)          << WRONG
 ld $3,8($fp)
 move $5,$2
 move $6,$3
 jal memcpy
 sd $2,0($fp)
 .stabn 68,0,220,.LM118
.LM118:
 dla $2,MM_RTLinker
 ld $2,0($2)           << WRONG
 move $4,$2
 jal free
 .stabn 68,0,221,.LM119
.LM119:
 ld $4,16($fp)
 dla $3,MM_RTLinker
 ld $2,136($3)         << OK
 andi $2,$2,0x0
 or $2,$4,$2
 sd $2,136($3)         << OK 
 .stabn 68,0,222,.LM120
.LM120:
 dla $2,MM_RTLinker
 ld $3,0($2)           << WRONG
 dla $2,MM_RTLinker
 ld $2,0($2)           << WRONG
 daddu $4,$3,$2
 dla $3,MM_RTLinker
 ld $2,128($3)         << OK
 andi $2,$2,0x0
 or $2,$2,$4
 sd $2,128($3)         << OK
.L65:
.LBE9:
 .stabn 68,0,224,.LM121
.LM121:
 move $sp,$fp
 ld $31,56($sp)
 ld $fp,48($sp)
 ld $28,40($sp)
 daddiu $sp,$sp,64
 j $31
 .end RTLinker__ExpandModuleTable

Here is corrected code:

RTLinker__ExpandModuleTable:
 .frame $fp,64,$31  # vars= 32, regs= 3/0, args= 0, gp= 0
 .mask 0xd0000000,-8
 .fmask 0x00000000,0
 daddiu $sp,$sp,-64
 sd $31,56($sp)
 sd $fp,48($sp)
 sd $28,40($sp)
 move $fp,$sp
 lui $28,%hi(%neg(%gp_rel(RTLinker__ExpandModuleTable)))
 daddu $28,$28,$25
 daddiu $28,$28,%lo(%neg(%gp_rel(RTLinker__ExpandModuleTable)))
.LBB9:
 .stabn 68,0,208,.LM109
.LM109:
 sd $0,16($fp)
 .stabn 68,0,210,.LM110
.LM110:
 dla $2,MM_RTLinker
 daddiu $2,$2,136     << CORRECT (offset seems low, but at least it isn't zero) 
 ld $2,0($2)
 bne $2,$0,.L61
 .stabn 68,0,212,.LM111
.LM111:
 dla $2,MM_RTLinker
 daddiu $3,$2,128     << CORRECT 
 li $2,500   # 0x1f4
 sd $2,0($3)
 .stabn 68,0,213,.LM112
.LM112:
 li $4,4000   # 0xfa0
 jal malloc
 sd $2,0($fp)
 dla $2,MM_RTLinker
 daddiu $3,$2,136      << CORRECT 
 ld $2,0($fp)
 sd $2,0($3)
 .stabn 68,0,214,.LM113
.LM113:
 dla $2,MM_RTLinker
 daddiu $2,$2,136      << CORRECT 
 ld $2,0($2)
 bne $2,$0,.L65
 jal abort
 b .L65
.L61:

I still dump core with this change, but I get much further.
I have not tested this change at all otherwise -- i.e. on working platforms.

I have not debugged through the gcc/m3cg code to see why
the offsets are only sometimes lost, or why other platforms
have no problem. Is MIPS's "global pointer" unusual these days?
I know SPARC has similar, and all the non-x86, non-AMD64 NT platforms
had similar, but that's essentially nothing now (I'm not counting IA64).
I know Linux has PLT (procedure linkage table) and GOT (global offset table).
Same thing?
I haven't looked much at other MIPS ports yet.

http://modula3.elegosoft.com/cgi-bin/cvsweb.cgi/cm3/m3-sys/m3cc/gcc/gcc/m3cg/parse.c.diff?r1=1.7;r2=1.8

is what made it look about like it does -- in particularing using BIT_FIELD_REF.

1.7:

static void m3_load (v, o, src_t, src_T, dest_t, dest_T) /* GCC32OK */
     tree v;
     int o;
     tree src_t, dest_t;
     m3_type src_T, dest_T;
{
  if (o == 0 && TREE_TYPE (v) == src_t) {
    EXPR_PUSH (v);
  } else {
    tree adr = m3_build1 (ADDR_EXPR, t_addr, v);
    if (o != 0) {
      adr = m3_build2 (PLUS_EXPR, t_addr, adr, size_int (o / BITS_PER_UNIT));
    }
    EXPR_PUSH (m3_build1 (INDIRECT_REF, src_t,
                          m3_cast (build_pointer_type (src_t), adr)));
  }
#if 1
  if (src_T != dest_T) {
    EXPR_REF (-1) = m3_build1 (CONVERT_EXPR, dest_t, EXPR_REF (-1));
  }
  if (debug_vars) {
    const char *name = "noname";
    if (v != 0 && DECL_NAME(v) != 0) {
      name = IDENTIFIER_POINTER(DECL_NAME(v));
    }
    fprintf(stderr, "  m3_load (%s): offset %d, convert %d -> %d\n", name,
            o, src_T, dest_T);
  }
#else
  if (src_T != dest_T) {
    if (IS_INTEGER_TYPE(dest_T) && dest_t != t_int) {
      EXPR_REF (-1) = m3_build1 (CONVERT_EXPR, t_int, EXPR_REF (-1));
    } else if (IS_WORD_TYPE(dest_T) && dest_t != t_word) {
      EXPR_REF (-1) = m3_build1 (CONVERT_EXPR, t_word, EXPR_REF (-1));
    } else if (IS_INTEGER_TYPE(dest_T) || IS_WORD_TYPE(dest_T)) {
      /* okay */
    } else {
      fatal_error("m3load: cannot convert types: src_t %d dest_t %d\n",
                  src_T, dest_T);
    }
  }
#endif
}
static void
m3_store (v, o, src_t, dest_t)  /* GCC32OK */
     tree v;
     int o;
     tree src_t, dest_t;
{
  tree lhs, rhs;
  if (TREE_TYPE (EXPR_REF (-1)) == src_t) {
    rhs = EXPR_REF (-1);
  } else {
    rhs = m3_cast (src_t, EXPR_REF (-1));
  }
  if (o == 0 && TREE_TYPE (v) == dest_t) {
    lhs = v;
  } else {
    tree f = make_node (FIELD_DECL);
    TREE_TYPE (f) = dest_t;
    DECL_ALIGN (f) = TYPE_ALIGN (dest_t);
    DECL_SIZE (f) = TYPE_SIZE (dest_t);
    DECL_MODE (f) = TYPE_MODE (dest_t);
    DECL_FIELD_OFFSET (f) = size_int (o / BITS_PER_UNIT);
    DECL_FIELD_BIT_OFFSET (f) = bitsize_int (o % BITS_PER_UNIT);
    DECL_FIELD_CONTEXT (f) = TREE_TYPE (v);
    lhs = m3_build2 (COMPONENT_REF, dest_t, v, f);
  }
#if 1
    expand_assignment (lhs, m3_build1 (CONVERT_EXPR, dest_t, rhs), 0, 0);
#else
  if (dest_t ==  NULL) {
    expand_assignment (lhs, rhs, 0, 0);
  } else {
    expand_assignment (lhs, m3_build1 (CONVERT_EXPR, dest_t, rhs), 0, 0);
  }
#endif
  EXPR_POP ();
}

1.8:
static void
m3_load (tree v, int o,
  tree src_t, m3_type src_T,
  tree dst_t, m3_type dst_T) /* GCC32OK */
{
  if (o == 0 && TREE_TYPE (v) == src_t) {
    EXPR_PUSH (v);
  } else {
    EXPR_PUSH (m3_build3 (BIT_FIELD_REF, src_t, v, TYPE_SIZE (src_t),
     bitsize_int (o)));
  }
  if (src_T != dst_T) {
    EXPR_REF (-1) = m3_build1 (CONVERT_EXPR, dst_t, EXPR_REF (-1));
  }
  if (option_vars_trace) {
    const char *name = "noname";
    if (v != 0 && DECL_NAME(v) != 0) {
      name = IDENTIFIER_POINTER(DECL_NAME(v));
    }
    fprintf(stderr, "  m3_load (%s): offset %d, convert %d -> %d\n", name,
     o, src_T, dst_T);
  }
}
static void
m3_store (tree v, int o, tree src_t, tree dst_t)  /* GCC32OK */
{
  tree lhs, rhs;
  if (TREE_TYPE (EXPR_REF (-1)) == src_t) {
    rhs = EXPR_REF (-1);
  } else {
    rhs = m3_cast (src_t, EXPR_REF (-1));
  }
  if (o == 0 && TREE_TYPE (v) == dst_t) {
    lhs = v;
  } else {
    lhs = m3_build3 (BIT_FIELD_REF, dst_t, v, TYPE_SIZE (dst_t),
       bitsize_int (o));
  }
  if (src_t != dst_t) {
    rhs = m3_build1 (CONVERT_EXPR, dst_t, rhs);
  }
  expand_assignment (lhs, rhs, 0, 0);
  EXPR_POP ();
}

 - Jay


More information about the M3devel mailing list