[pypy-commit] pypy reverse-debugger: Renames

arigo pypy.commits at gmail.com
Mon Jun 6 02:54:18 EDT 2016


Author: Armin Rigo <arigo at tunes.org>
Branch: reverse-debugger
Changeset: r84959:76bf391f9e87
Date: 2016-06-06 08:32 +0200
http://bitbucket.org/pypy/pypy/changeset/76bf391f9e87/

Log:	Renames

diff --git a/rpython/config/translationoption.py b/rpython/config/translationoption.py
--- a/rpython/config/translationoption.py
+++ b/rpython/config/translationoption.py
@@ -278,9 +278,9 @@
 
     BoolOption("split_gc_address_space",
                "Ensure full separation of GC and non-GC pointers", default=False),
-    BoolOption("reversedb",
+    BoolOption("reverse_debugger",
                "Give an executable that writes a log file for reverse debugging",
-               default=False, cmdline='--reversedb',
+               default=False, cmdline='--revdb',
                requires=[('translation.split_gc_address_space', True),
                          ('translation.jit', False)]),
 ])
diff --git a/rpython/translator/c/database.py b/rpython/translator/c/database.py
--- a/rpython/translator/c/database.py
+++ b/rpython/translator/c/database.py
@@ -33,12 +33,12 @@
                  thread_enabled=False,
                  sandbox=False,
                  split_gc_address_space=False,
-                 reversedb=False):
+                 reverse_debugger=False):
         self.translator = translator
         self.standalone = standalone
         self.sandbox    = sandbox
         self.split_gc_address_space = split_gc_address_space
-        self.reversedb  = reversedb
+        self.reverse_debugger       = reverse_debugger
         if gcpolicyclass is None:
             gcpolicyclass = gc.RefcountingGcPolicy
         self.gcpolicy = gcpolicyclass(self, thread_enabled)
diff --git a/rpython/translator/c/funcgen.py b/rpython/translator/c/funcgen.py
--- a/rpython/translator/c/funcgen.py
+++ b/rpython/translator/c/funcgen.py
@@ -2,7 +2,6 @@
 from rpython.translator.c.support import cdecl
 from rpython.translator.c.support import llvalue_from_constant, gen_assignments
 from rpython.translator.c.support import c_string_constant, barebonearray
-from rpython.translator.c.primitive import PRIMITIVE_FLOATS, PRIMITIVE_TWO_LONGS
 from rpython.flowspace.model import Variable, Constant
 from rpython.rtyper.lltypesystem.lltype import (Ptr, Void, Bool, Signed, Unsigned,
     SignedLongLong, Float, UnsignedLongLong, Char, UniChar, ContainerType,
@@ -425,16 +424,6 @@
     def OP_JIT_CONDITIONAL_CALL(self, op):
         return 'abort();  /* jit_conditional_call */'
 
-    def _reverse_db_emit(self, T, value):
-        if T is Void:
-            return '/* rpy_reverse_db_emit_void(%s); */' % (value,)
-        elif T in PRIMITIVE_FLOATS:
-            return 'rpy_reverse_db_emit_float(%s);' % (value,)
-        elif T in PRIMITIVE_TWO_LONGS:
-            return 'rpy_reverse_db_emit_two_longs(%s);' % (value,)
-        else:
-            return 'rpy_reverse_db_emit((Signed)%s);' % (value,)
-
     # low-level operations
     def generic_get(self, op, sourceexpr):
         T = self.lltypemap(op.result)
@@ -442,10 +431,12 @@
         result = '%s = %s;' % (newvalue, sourceexpr)
         if T is Void:
             result = '/* %s */' % result
-        if self.db.reversedb:
+        if self.db.reverse_debugger:
             S = self.lltypemap(op.args[0]).TO
             if S._gckind != 'gc' and not S._hints.get('is_excdata'):
-                result += '\t' + self._reverse_db_emit(T, newvalue)
+                from rpython.translator.revdb import revdb_genc
+                result += '\t' + revdb_genc.emit(self.lltypename(op.result),
+                                                 newvalue)
         return result
 
     def generic_set(self, op, targetexpr):
diff --git a/rpython/translator/c/genc.py b/rpython/translator/c/genc.py
--- a/rpython/translator/c/genc.py
+++ b/rpython/translator/c/genc.py
@@ -115,8 +115,8 @@
     def get_eci(self):
         pypy_include_dir = py.path.local(__file__).join('..')
         include_dirs = [pypy_include_dir]
-        if self.config.translation.reversedb:
-            include_dirs.append(pypy_include_dir.join('..', 'reversedb'))
+        if self.config.translation.reverse_debugger:
+            include_dirs.append(pypy_include_dir.join('..', 'revdb'))
         return ExternalCompilationInfo(include_dirs=include_dirs)
 
     def build_database(self):
@@ -136,7 +136,8 @@
                               sandbox=self.config.translation.sandbox,
                               split_gc_address_space=
                                  self.config.translation.split_gc_address_space,
-                              reversedb=self.config.translation.reversedb)
+                              reverse_debugger=
+                                 self.config.translation.reverse_debugger)
         self.db = db
 
         # give the gc a chance to register interest in the start-up functions it
@@ -218,8 +219,8 @@
             defines['COUNT_OP_MALLOCS'] = 1
         if self.config.translation.sandbox:
             defines['RPY_SANDBOXED'] = 1
-        if self.config.translation.reversedb:
-            defines['RPY_REVERSE_DB'] = 1
+        if self.config.translation.reverse_debugger:
+            defines['RPY_REVERSE_DEBUGGER'] = 1
         if CBuilder.have___thread is None:
             CBuilder.have___thread = self.translator.platform.check___thread()
         if not self.standalone:
@@ -846,9 +847,9 @@
     ]
     if _CYGWIN:
         files.append(srcdir / 'cygwin_wait.c')
-    if database.reversedb:
-        from rpython.translator.reversedb import rdb_genc
-        files += rdb_genc.extra_files()
+    if database.reverse_debugger:
+        from rpython.translator.revdb import revdb_genc
+        files += revdb_genc.extra_files()
     return eci.merge(ExternalCompilationInfo(separate_module_files=files))
 
 
diff --git a/rpython/translator/c/primitive.py b/rpython/translator/c/primitive.py
--- a/rpython/translator/c/primitive.py
+++ b/rpython/translator/c/primitive.py
@@ -223,11 +223,6 @@
     Address:  name_address,
     GCREF:    name_gcref,
     }
-PRIMITIVE_FLOATS = set([Float, SingleFloat, LongFloat])
-if SignedLongLong is Signed:
-    PRIMITIVE_TWO_LONGS = set([])
-else:
-    PRIMITIVE_TWO_LONGS = set([SignedLongLong, UnsignedLongLong])
 
 PrimitiveType = {
     SignedLongLong:   'long long @',
diff --git a/rpython/translator/c/src/entrypoint.c b/rpython/translator/c/src/entrypoint.c
--- a/rpython/translator/c/src/entrypoint.c
+++ b/rpython/translator/c/src/entrypoint.c
@@ -82,7 +82,7 @@
     pypy_asm_stack_bottom();
     instrument_setup();
 
-#ifdef RPY_REVERSE_DB
+#ifdef RPY_REVERSE_DEBUGGER
     rpy_reverse_db_setup(argc, argv);
 #endif
 
diff --git a/rpython/translator/c/src/g_include.h b/rpython/translator/c/src/g_include.h
--- a/rpython/translator/c/src/g_include.h
+++ b/rpython/translator/c/src/g_include.h
@@ -51,6 +51,6 @@
 #include "src/cygwin_wait.h"
 #endif
 
-#ifdef RPY_REVERSE_DB
-#include "rdb-src/rdb_include.h"
+#ifdef RPY_REVERSE_DEBUGGER
+#include "rdb-src/revdb_include.h"
 #endif
diff --git a/rpython/translator/reversedb/__init__.py b/rpython/translator/revdb/__init__.py
rename from rpython/translator/reversedb/__init__.py
rename to rpython/translator/revdb/__init__.py
diff --git a/rpython/translator/reversedb/rdb-src/rdb.c b/rpython/translator/revdb/rdb-src/revdb.c
rename from rpython/translator/reversedb/rdb-src/rdb.c
rename to rpython/translator/revdb/rdb-src/revdb.c
--- a/rpython/translator/reversedb/rdb-src/rdb.c
+++ b/rpython/translator/revdb/rdb-src/revdb.c
@@ -4,14 +4,14 @@
 #include <fcntl.h>
 #include <unistd.h>
 
-#include "rdb-src/rdb_include.h"
+#include "rdb-src/revdb_include.h"
 
 #define RDB_SIGNATURE   0x0A424452    /* "RDB\n" */
 #define RDB_VERSION     0x00FF0001
 
 
-Signed *rpy_rev_buf_p, *rpy_rev_buf_end;
-static Signed rpy_rev_buffer[2048];
+rpy_revdb_t rpy_revdb;
+static char rpy_rev_buffer[16384];
 static int rpy_rev_fileno = -1;
 
 
@@ -20,30 +20,29 @@
 {
     /* init-time setup */
 
-    char *filename = getenv("PYPYRDB");
+    char *filename = getenv("PYPYREVDB");
 
-    rpy_rev_buf_p = rpy_rev_buffer;
-    rpy_rev_buf_end = rpy_rev_buffer +
-        sizeof(rpy_rev_buffer) / sizeof(rpy_rev_buffer[0]);
+    rpy_revdb.buf_p = rpy_rev_buffer;
+    rpy_revdb.buf_limit = rpy_rev_buffer + sizeof(rpy_rev_buffer) - 32;
 
     if (filename && *filename) {
-        putenv("PYPYRDB=");
+        putenv("PYPYREVDB=");
         rpy_rev_fileno = open(filename, O_WRONLY | O_CLOEXEC |
                               O_CREAT | O_NOCTTY | O_TRUNC, 0600);
         if (rpy_rev_fileno < 0) {
-            fprintf(stderr, "Fatal error: can't create PYPYRDB file '%s'\n",
+            fprintf(stderr, "Fatal error: can't create PYPYREVDB file '%s'\n",
                     filename);
             abort();
         }
         atexit(rpy_reverse_db_flush);
     }
 
-    rpy_reverse_db_emit(RDB_SIGNATURE);
-    rpy_reverse_db_emit(RDB_VERSION);
-    rpy_reverse_db_emit(0);
-    rpy_reverse_db_emit(0);
-    rpy_reverse_db_emit(argc);
-    rpy_reverse_db_emit((Signed)argv);
+    rpy_reverse_db_EMIT(Signed _e=RDB_SIGNATURE);
+    rpy_reverse_db_EMIT(Signed _e=RDB_VERSION);
+    rpy_reverse_db_EMIT(Signed _e=0);
+    rpy_reverse_db_EMIT(Signed _e=0);
+    rpy_reverse_db_EMIT(Signed _e=argc);
+    rpy_reverse_db_EMIT(void *_e=argv);
 }
 
 RPY_EXTERN
@@ -51,11 +50,11 @@
 {
     /* write the current buffer content to the OS */
 
-    ssize_t size = (rpy_rev_buf_p - rpy_rev_buffer) * sizeof(rpy_rev_buffer[0]);
-    rpy_rev_buf_p = rpy_rev_buffer;
+    ssize_t size = rpy_revdb.buf_p - rpy_rev_buffer;
+    rpy_revdb.buf_p = rpy_rev_buffer;
     if (size > 0 && rpy_rev_fileno >= 0) {
         if (write(rpy_rev_fileno, rpy_rev_buffer, size) != size) {
-            fprintf(stderr, "Fatal error: writing to PYPYRDB file: %m\n");
+            fprintf(stderr, "Fatal error: writing to PYPYREVDB file: %m\n");
             abort();
         }
     }
diff --git a/rpython/translator/reversedb/rdb-src/rdb_include.h b/rpython/translator/revdb/rdb-src/revdb_include.h
rename from rpython/translator/reversedb/rdb-src/rdb_include.h
rename to rpython/translator/revdb/rdb-src/revdb_include.h
--- a/rpython/translator/reversedb/rdb-src/rdb_include.h
+++ b/rpython/translator/revdb/rdb-src/revdb_include.h
@@ -4,29 +4,12 @@
 RPY_EXTERN void rpy_reverse_db_flush(void);
 
 
-RPY_EXTERN Signed *rpy_rev_buf_p, *rpy_rev_buf_end;
+typedef struct { char *buf_p, *buf_limit; } rpy_revdb_t;
+RPY_EXTERN rpy_revdb_t rpy_revdb;
 
-
-static inline void rpy_reverse_db_emit(Signed value) {
-    *(rpy_rev_buf_p++) = value;
-    if (rpy_rev_buf_p == rpy_rev_buf_end)
-        rpy_reverse_db_flush();
-}
-
-static inline void rpy_reverse_db_emit_float(double value) {
-    /* xxx for 'long double' this can loose some precision */
-    Signed sval[sizeof(double) / SIZEOF_LONG];
-    memcpy(sval, &value, sizeof(value));
-    rpy_reverse_db_emit(sval[0]);
-    if (SIZEOF_LONG < sizeof(double))  /* assume len(sval) is exactly 1 or 2 */
-        rpy_reverse_db_emit(sval[1]);
-}
-
-static inline void rpy_reverse_db_emit_two_longs(long long value)
-{
-    Signed sval[2];
-    assert(SIZEOF_LONG * 2 == SIZEOF_LONG_LONG);
-    memcpy(sval, &value, sizeof(value));
-    rpy_reverse_db_emit(sval[0]);
-    rpy_reverse_db_emit(sval[1]);
-}
+#define rpy_reverse_db_EMIT(decl_e)   do {                              \
+        decl_e;                                                         \
+        memcpy(rpy_revdb.buf_p, &_e, sizeof(_e));                       \
+        if ((rpy_revdb.buf_p += sizeof(_e)) > rpy_revdb.buf_limit)      \
+            rpy_reverse_db_flush();                                     \
+} while (0)
diff --git a/rpython/translator/reversedb/rdb_genc.py b/rpython/translator/revdb/revdb_genc.py
rename from rpython/translator/reversedb/rdb_genc.py
rename to rpython/translator/revdb/revdb_genc.py
--- a/rpython/translator/reversedb/rdb_genc.py
+++ b/rpython/translator/revdb/revdb_genc.py
@@ -1,7 +1,15 @@
 import py
+from rpython.rtyper.lltypesystem import lltype, rffi
+from rpython.translator.c.support import cdecl
+
 
 def extra_files():
     srcdir = py.path.local(__file__).join('..', 'rdb-src')
     return [
-        srcdir / 'rdb.c',
+        srcdir / 'revdb.c',
     ]
+
+def emit(tp, value):
+    if tp == 'void @':
+        return '/* void */'
+    return 'rpy_reverse_db_EMIT(%s=%s);' % (cdecl(tp, '_e'), value)
diff --git a/rpython/translator/reversedb/test/__init__.py b/rpython/translator/revdb/test/__init__.py
rename from rpython/translator/reversedb/test/__init__.py
rename to rpython/translator/revdb/test/__init__.py
diff --git a/rpython/translator/reversedb/test/test_basic.py b/rpython/translator/revdb/test/test_basic.py
rename from rpython/translator/reversedb/test/test_basic.py
rename to rpython/translator/revdb/test/test_basic.py
--- a/rpython/translator/reversedb/test/test_basic.py
+++ b/rpython/translator/revdb/test/test_basic.py
@@ -3,37 +3,36 @@
 import array, struct
 from rpython.tool.udir import udir
 from rpython.translator.interactive import Translation
+from rpython.rlib.rarithmetic import LONG_BIT
 
 
 class RDB(object):
     def __init__(self, filename):
-        f = open(filename, 'rb')
-        f.seek(0, 2)
-        filesize = f.tell()
-        f.seek(0, 0)
-        self.items = array.array("l")
-        self.items.fromfile(f, filesize / struct.calcsize("l"))
-        f.close()
+        with open(filename, 'rb') as f:
+            self.buffer = f.read()
         #
-        assert self.items[0] == 0x0A424452
-        assert self.items[1] == 0x00FF0001
-        assert self.items[2] == 0
-        assert self.items[3] == 0
-        self.argc = self.items[4]
-        self.argv = self.items[5]
-        self.cur = 6
+        self.cur = 0
+        x = self.next(); assert x == 0x0A424452
+        x = self.next(); assert x == 0x00FF0001
+        x = self.next(); assert x == 0
+        x = self.next(); assert x == 0
+        self.argc = self.next()
+        self.argv = self.next()
 
-    def next(self):
-        n = self.cur
-        self.cur = n + 1
-        return self.items[n]
+    def next(self, mode='P'):
+        p = self.cur
+        self.cur = p + struct.calcsize(mode)
+        return struct.unpack_from(mode, self.buffer, p)[0]
+
+    def done(self):
+        return self.cur == len(self.buffer)
 
 
 class TestBasic(object):
 
     def getcompiled(self, entry_point, argtypes, backendopt=True):
         t = Translation(entry_point, None, gc="boehm")
-        t.config.translation.reversedb = True
+        t.config.translation.reverse_debugger = True
         t.config.translation.rweakref = False
         if not backendopt:
             t.disable(["backendopt_lltype"])
@@ -47,7 +46,7 @@
 
         def run(*argv):
             env = os.environ.copy()
-            env['PYPYRDB'] = self.rdbname
+            env['PYPYREVDB'] = self.rdbname
             stdout = t.driver.cbuilder.cmdexec(' '.join(argv), env=env)
             return stdout
         return run
@@ -70,17 +69,17 @@
             s = []
             # first we determine the length of the "char *p"
             while True:
-                c = rdb.next()
-                if c == 0:
+                c = rdb.next('c')
+                if c == '\x00':
                     break
-                s.append(chr(c))
+                s.append(c)
             # then we really read the "char *" and copy it into a rpy string
             # (that's why this time we don't read the final \0)
             for c1 in s:
-                c2 = rdb.next()
-                assert c2 == ord(c1)
+                c2 = rdb.next('c')
+                assert c2 == c1
             got.append(''.join(s))
         # that's all that should get from this simple example
-        assert rdb.cur == len(rdb.items)
+        assert rdb.done()
         #
         assert got == [self.exename, 'abc', 'd']


More information about the pypy-commit mailing list