------------------------------------------------------------------------

r13008 | tom | 2012-09-21 10:57:46 +0200 (Fri, 21 Sep 2012) | 3 lines

When processing DW_OP_plus_uconst make sure we record an add, not

whatever binary operation we happened to see last.

------------------------------------------------------------------------

r13009 | tom | 2012-09-21 11:04:27 +0200 (Fri, 21 Sep 2012) | 2 lines

Rename CfiOp to CfiBinop in preparation for adding unary operators.

------------------------------------------------------------------------

r13010 | tom | 2012-09-21 11:12:30 +0200 (Fri, 21 Sep 2012) | 3 lines

Implement some extra DW_OPs - more constants and some unary operators.

Patch from Mark Wielaard on BZ#307038.

------------------------------------------------------------------------

Index: valgrind/coregrind/m_debuginfo/readdwarf.c

===================================================================

--- valgrind/coregrind/m_debuginfo/readdwarf.c	(revision 13007)

+++ valgrind/coregrind/m_debuginfo/readdwarf.c	(working copy)

@@ -2728,12 +2728,13 @@

          sp--;                                     \

       } while (0)

-   Int    ix, ix2, reg;

-   UChar  opcode;

-   Word   sw;

-   UWord  uw;

-   CfiOp  op;

-   HChar* opname;

+   Int      ix, ix2, reg;

+   UChar    opcode;

+   Word     sw;

+   UWord    uw;

+   CfiUnop  uop;

+   CfiBinop bop;

+   HChar*   opname;

    Int sp; /* # of top element: valid is -1 .. N_EXPR_STACK-1 */

    Int stack[N_EXPR_STACK];  /* indices into ctx->exprs */

@@ -2752,7 +2753,7 @@

       if (ctxs->cfa_is_regoff) {

          /* cfa is reg +/- offset */

          ix = ML_(CfiExpr_Binop)( dst,

-                 Cop_Add,

+                 Cbinop_Add,

                  ML_(CfiExpr_DwReg)( dst, ctxs->cfa_reg ),

                  ML_(CfiExpr_Const)( dst, (UWord)(Word)ctxs->cfa_off )

               );

@@ -2778,7 +2779,7 @@

            break;

       }

-      op = 0; opname = NULL; /* excessively conservative */

+      uop = 0; bop = 0; opname = NULL; /* excessively conservative */

       opcode = *expr++;

       switch (opcode) {

@@ -2798,7 +2799,7 @@

             vg_assert(reg >= 0 && reg <= 31);

             sw = read_leb128S( &expr );

             ix = ML_(CfiExpr_Binop)( dst,

-                    Cop_Add,

+                    Cbinop_Add,

                     ML_(CfiExpr_DwReg)( dst, reg ),

                     ML_(CfiExpr_Const)( dst, (UWord)sw )

                  );

@@ -2822,7 +2823,7 @@

             PUSH( ML_(CfiExpr_Const)( dst, uw ) );

             POP( ix );

             POP( ix2 );

-            PUSH( ML_(CfiExpr_Binop)( dst, op, ix2, ix ) );

+            PUSH( ML_(CfiExpr_Binop)( dst, Cbinop_Add, ix2, ix ) );

             if (ddump_frames)

                VG_(printf)("DW_OP_plus_uconst: %lu", uw);

             break;

@@ -2836,6 +2837,15 @@

                VG_(printf)("DW_OP_const4s: %ld", sw);

             break;

+         case DW_OP_const2s:

+            /* push: 16-bit signed immediate */

+            sw = read_le_s_encoded_literal( expr, 2 );

+            expr += 2;

+            PUSH( ML_(CfiExpr_Const)( dst, (UWord)sw ) );

+            if (ddump_frames)

+               VG_(printf)("DW_OP_const2s: %ld", sw);

+            break;

+

          case DW_OP_const1s:

             /* push: 8-bit signed immediate */

             sw = read_le_s_encoded_literal( expr, 1 );

@@ -2845,34 +2855,74 @@

                VG_(printf)("DW_OP_const1s: %ld", sw);

             break;

+         case DW_OP_const1u:

+            /* push: 8-bit unsigned immediate */

+            uw = read_le_u_encoded_literal( expr, 1 );

+            expr += 1;

+            PUSH( ML_(CfiExpr_Const)( dst, uw ) );

+            if (ddump_frames)

+               VG_(printf)("DW_OP_const1: %lu", uw);

+            break;

+

+         case DW_OP_const2u:

+            /* push: 16-bit unsigned immediate */

+            uw = read_le_u_encoded_literal( expr, 2 );

+            expr += 2;

+            PUSH( ML_(CfiExpr_Const)( dst, uw ) );

+            if (ddump_frames)

+               VG_(printf)("DW_OP_const2: %lu", uw);

+            break;

+

+         case DW_OP_const4u:

+            /* push: 32-bit unsigned immediate */

+            uw = read_le_u_encoded_literal( expr, 4 );

+            expr += 4;

+            PUSH( ML_(CfiExpr_Const)( dst, uw ) );

+            if (ddump_frames)

+               VG_(printf)("DW_OP_const4: %lu", uw);

+            break;

+

+         case DW_OP_abs:

+            uop = Cunop_Abs; opname = "abs"; goto unop;

+         case DW_OP_neg:

+            uop = Cunop_Neg; opname = "neg"; goto unop;

+         case DW_OP_not:

+            uop = Cunop_Not; opname = "not"; goto unop;

+         unop:

+            POP( ix );

+            PUSH( ML_(CfiExpr_Unop)( dst, uop, ix ) );

+            if (ddump_frames)

+               VG_(printf)("DW_OP_%s", opname);

+            break;

+

          case DW_OP_minus:

-            op = Cop_Sub; opname = "minus"; goto binop;

+            bop = Cbinop_Sub; opname = "minus"; goto binop;

          case DW_OP_plus:

-            op = Cop_Add; opname = "plus"; goto binop;

+            bop = Cbinop_Add; opname = "plus"; goto binop;

          case DW_OP_and:

-            op = Cop_And; opname = "and"; goto binop;

+            bop = Cbinop_And; opname = "and"; goto binop;

          case DW_OP_mul:

-            op = Cop_Mul; opname = "mul"; goto binop;

+            bop = Cbinop_Mul; opname = "mul"; goto binop;

          case DW_OP_shl:

-            op = Cop_Shl; opname = "shl"; goto binop;

+            bop = Cbinop_Shl; opname = "shl"; goto binop;

          case DW_OP_shr:

-            op = Cop_Shr; opname = "shr"; goto binop;

+            bop = Cbinop_Shr; opname = "shr"; goto binop;

          case DW_OP_eq:

-            op = Cop_Eq; opname = "eq"; goto binop;

+            bop = Cbinop_Eq; opname = "eq"; goto binop;

          case DW_OP_ge:

-            op = Cop_Ge; opname = "ge"; goto binop;

+            bop = Cbinop_Ge; opname = "ge"; goto binop;

          case DW_OP_gt:

-            op = Cop_Gt; opname = "gt"; goto binop;

+            bop = Cbinop_Gt; opname = "gt"; goto binop;

          case DW_OP_le:

-            op = Cop_Le; opname = "le"; goto binop;

+            bop = Cbinop_Le; opname = "le"; goto binop;

          case DW_OP_lt:

-            op = Cop_Lt; opname = "lt"; goto binop;

+            bop = Cbinop_Lt; opname = "lt"; goto binop;

          case DW_OP_ne:

-            op = Cop_Ne; opname = "ne"; goto binop;

+            bop = Cbinop_Ne; opname = "ne"; goto binop;

          binop:

             POP( ix );

             POP( ix2 );

-            PUSH( ML_(CfiExpr_Binop)( dst, op, ix2, ix ) );

+            PUSH( ML_(CfiExpr_Binop)( dst, bop, ix2, ix ) );

             if (ddump_frames)

                VG_(printf)("DW_OP_%s", opname);

             break;

Index: coregrind/m_debuginfo/debuginfo.c

===================================================================

--- valgrind/coregrind/m_debuginfo/debuginfo.c	(revision 13007)

+++ valgrind/coregrind/m_debuginfo/debuginfo.c	(working copy)

@@ -2051,30 +2051,40 @@

 UWord evalCfiExpr ( XArray* exprs, Int ix, 

                     CfiExprEvalContext* eec, Bool* ok )

 {

-   UWord wL, wR;

+   UWord w, wL, wR;

    Addr  a;

    CfiExpr* e;

    vg_assert(sizeof(Addr) == sizeof(UWord));

    e = VG_(indexXA)( exprs, ix );

    switch (e->tag) {

+      case Cex_Unop:

+         w = evalCfiExpr( exprs, e->Cex.Unop.ix, eec, ok );

+         if (!(*ok)) return 0;

+         switch (e->Cex.Unop.op) {

+            case Cunop_Abs: return (Word) w < 0 ? - w : w;

+            case Cunop_Neg: return - (Word) w;

+            case Cunop_Not: return ~ w;

+            default: goto unhandled;

+         }

+         /*NOTREACHED*/

       case Cex_Binop:

          wL = evalCfiExpr( exprs, e->Cex.Binop.ixL, eec, ok );

          if (!(*ok)) return 0;

          wR = evalCfiExpr( exprs, e->Cex.Binop.ixR, eec, ok );

          if (!(*ok)) return 0;

          switch (e->Cex.Binop.op) {

-            case Cop_Add: return wL + wR;

-            case Cop_Sub: return wL - wR;

-            case Cop_And: return wL & wR;

-            case Cop_Mul: return wL * wR;

-            case Cop_Shl: return wL << wR;

-            case Cop_Shr: return wL >> wR;

-            case Cop_Eq: return wL == wR ? 1 : 0;

-            case Cop_Ge: return (Word) wL >= (Word) wR ? 1 : 0;

-            case Cop_Gt: return (Word) wL > (Word) wR ? 1 : 0;

-            case Cop_Le: return (Word) wL <= (Word) wR ? 1 : 0;

-            case Cop_Lt: return (Word) wL < (Word) wR ? 1 : 0;

-            case Cop_Ne: return wL != wR ? 1 : 0;

+            case Cbinop_Add: return wL + wR;

+            case Cbinop_Sub: return wL - wR;

+            case Cbinop_And: return wL & wR;

+            case Cbinop_Mul: return wL * wR;

+            case Cbinop_Shl: return wL << wR;

+            case Cbinop_Shr: return wL >> wR;

+            case Cbinop_Eq: return wL == wR ? 1 : 0;

+            case Cbinop_Ge: return (Word) wL >= (Word) wR ? 1 : 0;

+            case Cbinop_Gt: return (Word) wL > (Word) wR ? 1 : 0;

+            case Cbinop_Le: return (Word) wL <= (Word) wR ? 1 : 0;

+            case Cbinop_Lt: return (Word) wL < (Word) wR ? 1 : 0;

+            case Cbinop_Ne: return wL != wR ? 1 : 0;

             default: goto unhandled;

          }

          /*NOTREACHED*/

Index: valgrind/coregrind/m_debuginfo/storage.c

===================================================================

--- valgrind/coregrind/m_debuginfo/storage.c	(revision 13007)

+++ valgrind/coregrind/m_debuginfo/storage.c	(working copy)

@@ -585,10 +585,19 @@

    e.Cex.Const.con = con;

    return (Int)VG_(addToXA)( dst, &e );

 }

-Int ML_(CfiExpr_Binop)( XArray* dst, CfiOp op, Int ixL, Int ixR )

+Int ML_(CfiExpr_Unop)( XArray* dst, CfiUnop op, Int ix )

 {

    CfiExpr e;

    VG_(memset)( &e, 0, sizeof(e) );

+   e.tag = Cex_Unop;

+   e.Cex.Unop.op  = op;

+   e.Cex.Unop.ix = ix;

+   return (Int)VG_(addToXA)( dst, &e );

+}

+Int ML_(CfiExpr_Binop)( XArray* dst, CfiBinop op, Int ixL, Int ixR )

+{

+   CfiExpr e;

+   VG_(memset)( &e, 0, sizeof(e) );

    e.tag = Cex_Binop;

    e.Cex.Binop.op  = op;

    e.Cex.Binop.ixL = ixL;

@@ -612,25 +621,35 @@

    return (Int)VG_(addToXA)( dst, &e );

 }

-static void ppCfiOp ( CfiOp op ) 

+static void ppCfiUnop ( CfiUnop op ) 

 {

    switch (op) {

-      case Cop_Add: VG_(printf)("+"); break;

-      case Cop_Sub: VG_(printf)("-"); break;

-      case Cop_And: VG_(printf)("&";; break;

-      case Cop_Mul: VG_(printf)("*"); break;

-      case Cop_Shl: VG_(printf)("<<"); break;

-      case Cop_Shr: VG_(printf)(">>"); break;

-      case Cop_Eq: VG_(printf)("=="); break;

-      case Cop_Ge: VG_(printf)(">="); break;

-      case Cop_Gt: VG_(printf)(">"); break;

-      case Cop_Le: VG_(printf)("<="); break;

-      case Cop_Lt: VG_(printf)("<"); break;

-      case Cop_Ne: VG_(printf)("!="); break;

-      default:      vg_assert(0);

+      case Cunop_Abs: VG_(printf)("abs"); break;

+      case Cunop_Neg: VG_(printf)("-"); break;

+      case Cunop_Not: VG_(printf)("~"); break;

+      default:        vg_assert(0);

    }

 }

+static void ppCfiBinop ( CfiBinop op ) 

+{

+   switch (op) {

+      case Cbinop_Add: VG_(printf)("+"); break;

+      case Cbinop_Sub: VG_(printf)("-"); break;

+      case Cbinop_And: VG_(printf)("&";; break;

+      case Cbinop_Mul: VG_(printf)("*"); break;

+      case Cbinop_Shl: VG_(printf)("<<"); break;

+      case Cbinop_Shr: VG_(printf)(">>"); break;

+      case Cbinop_Eq:  VG_(printf)("=="); break;

+      case Cbinop_Ge:  VG_(printf)(">="); break;

+      case Cbinop_Gt:  VG_(printf)(">"); break;

+      case Cbinop_Le:  VG_(printf)("<="); break;

+      case Cbinop_Lt:  VG_(printf)("<"); break;

+      case Cbinop_Ne:  VG_(printf)("!="); break;

+      default:         vg_assert(0);

+   }

+}

+

 static void ppCfiReg ( CfiReg reg )

 {

    switch (reg) {

@@ -664,11 +683,17 @@

       case Cex_Const: 

          VG_(printf)("0x%lx", e->Cex.Const.con); 

          break;

+      case Cex_Unop: 

+         ppCfiUnop(e->Cex.Unop.op);

+         VG_(printf)("(");

+         ML_(ppCfiExpr)(src, e->Cex.Unop.ix);

+         VG_(printf)(")");

+         break;

       case Cex_Binop: 

          VG_(printf)("(");

          ML_(ppCfiExpr)(src, e->Cex.Binop.ixL);

          VG_(printf)(")");

-         ppCfiOp(e->Cex.Binop.op);

+         ppCfiBinop(e->Cex.Binop.op);

          VG_(printf)("(");

          ML_(ppCfiExpr)(src, e->Cex.Binop.ixR);

          VG_(printf)(")");

Index: valgrind/coregrind/m_debuginfo/priv_storage.h

===================================================================

--- valgrind/coregrind/m_debuginfo/priv_storage.h	(revision 13007)

+++ valgrind/coregrind/m_debuginfo/priv_storage.h	(working copy)

@@ -279,23 +279,31 @@

 typedef

    enum {

-      Cop_Add=0x321,

-      Cop_Sub,

-      Cop_And,

-      Cop_Mul,

-      Cop_Shl,

-      Cop_Shr,

-      Cop_Eq,

-      Cop_Ge,

-      Cop_Gt,

-      Cop_Le,

-      Cop_Lt,

-      Cop_Ne

+      Cunop_Abs=0x231,

+      Cunop_Neg,

+      Cunop_Not

    }

-   CfiOp;

+   CfiUnop;

 typedef

    enum {

+      Cbinop_Add=0x321,

+      Cbinop_Sub,

+      Cbinop_And,

+      Cbinop_Mul,

+      Cbinop_Shl,

+      Cbinop_Shr,

+      Cbinop_Eq,

+      Cbinop_Ge,

+      Cbinop_Gt,

+      Cbinop_Le,

+      Cbinop_Lt,

+      Cbinop_Ne

+   }

+   CfiBinop;

+

+typedef

+   enum {

       Creg_IA_SP=0x213,

       Creg_IA_BP,

       Creg_IA_IP,

@@ -313,6 +321,7 @@

       Cex_Undef=0x123,

       Cex_Deref,

       Cex_Const,

+      Cex_Unop,

       Cex_Binop,

       Cex_CfiReg,

       Cex_DwReg

@@ -332,7 +341,11 @@

             UWord con;

          } Const;

          struct {

-            CfiOp op;

+            CfiUnop op;

+            Int ix;

+         } Unop;

+         struct {

+            CfiBinop op;

             Int ixL;

             Int ixR;

          } Binop;

@@ -350,7 +363,8 @@

 extern Int ML_(CfiExpr_Undef) ( XArray* dst );

 extern Int ML_(CfiExpr_Deref) ( XArray* dst, Int ixAddr );

 extern Int ML_(CfiExpr_Const) ( XArray* dst, UWord con );

-extern Int ML_(CfiExpr_Binop) ( XArray* dst, CfiOp op, Int ixL, Int ixR );

+extern Int ML_(CfiExpr_Unop)  ( XArray* dst, CfiUnop op, Int ix );

+extern Int ML_(CfiExpr_Binop) ( XArray* dst, CfiBinop op, Int ixL, Int ixR );

 extern Int ML_(CfiExpr_CfiReg)( XArray* dst, CfiReg reg );

 extern Int ML_(CfiExpr_DwReg) ( XArray* dst, Int reg );