Author: Antonio Cuni <anto.c...@gmail.com>
Branch: x86-dump-labels
Changeset: r44098:e720a9242b6b
Date: 2011-05-12 14:01 +0200
http://bitbucket.org/pypy/pypy/changeset/e720a9242b6b/
Log: rename labels to ops_offset, which is clearer
diff --git a/pypy/jit/backend/model.py b/pypy/jit/backend/model.py
--- a/pypy/jit/backend/model.py
+++ b/pypy/jit/backend/model.py
@@ -59,11 +59,11 @@
looptoken.compiled_loop_token and stick extra attributes
on it to point to the compiled loop in assembler.
- Optionally, return a ``labels`` dictionary, which maps each operation
- to its offset in the compiled code. The ``labels`` dictionary is then
+ Optionally, return a ``ops_offset`` dictionary, which maps each
operation
+ to its offset in the compiled code. The ``ops_offset`` dictionary is
then
used by the operation logger to print the offsets in the log. The
offset representing the end of the last operation is stored in
- ``labels[None]``: note that this might not coincide with the end of
+ ``ops_offset[None]``: note that this might not coincide with the end of
the loop, because usually in the loop footer there is code which does
not belong to any particular operation.
"""
@@ -74,7 +74,7 @@
"""Assemble the bridge.
The FailDescr is the descr of the original guard that failed.
- Optionally, return a ``labels`` dictionary. See the docstring of
+ Optionally, return a ``ops_offset`` dictionary. See the docstring of
``compiled_loop`` for more informations about it.
"""
raise NotImplementedError
diff --git a/pypy/jit/backend/x86/assembler.py
b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -361,12 +361,12 @@
frame_depth + param_depth)
self.patch_pending_failure_recoveries(rawstart)
#
- labels = self.mc.labels
+ ops_offset = self.mc.ops_offset
if not we_are_translated():
# used only by looptoken.dump() -- useful in tests
looptoken._x86_rawstart = rawstart
looptoken._x86_fullsize = fullsize
- looptoken._x86_labels = labels
+ looptoken._x86_ops_offset = ops_offset
looptoken._x86_bootstrap_code = rawstart + bootstrappos
looptoken._x86_loop_code = rawstart + self.looppos
@@ -377,7 +377,7 @@
name = "Loop # %s: %s" % (looptoken.number, funcname)
self.cpu.profile_agent.native_code_written(name,
rawstart, fullsize)
- return labels
+ return ops_offset
def assemble_bridge(self, faildescr, inputargs, operations,
original_loop_token, log):
@@ -427,14 +427,14 @@
faildescr._x86_bridge_param_depth = param_depth
# patch the jump from original guard
self.patch_jump_for_descr(faildescr, rawstart)
- labels = self.mc.labels
+ ops_offset = self.mc.ops_offset
self.teardown()
# oprofile support
if self.cpu.profile_agent is not None:
name = "Bridge # %s: %s" % (descr_number, funcname)
self.cpu.profile_agent.native_code_written(name,
rawstart, fullsize)
- return labels
+ return ops_offset
def write_pending_failure_recoveries(self):
# for each pending guard, generate the code of the recovery stub
diff --git a/pypy/jit/backend/x86/codebuf.py b/pypy/jit/backend/x86/codebuf.py
--- a/pypy/jit/backend/x86/codebuf.py
+++ b/pypy/jit/backend/x86/codebuf.py
@@ -27,17 +27,18 @@
# at [p-4:p] encode an absolute address that will need to be
# made relative.
self.relocations = []
+ #
# ResOperation --> offset in the assembly.
- # labels[None] represents the beginning of the code after the last op
- # (i.e., the tail of the loop
- self.labels = {}
+ # ops_offset[None] represents the beginning of the code after the last
op
+ # (i.e., the tail of the loop)
+ self.ops_offset = {}
def add_pending_relocation(self):
self.relocations.append(self.get_relative_pos())
def mark_op(self, op):
pos = self.get_relative_pos()
- self.labels[op] = pos
+ self.ops_offset[op] = pos
def copy_to_raw_memory(self, addr):
self._copy_to_raw_memory(addr)
diff --git a/pypy/jit/backend/x86/runner.py b/pypy/jit/backend/x86/runner.py
--- a/pypy/jit/backend/x86/runner.py
+++ b/pypy/jit/backend/x86/runner.py
@@ -66,7 +66,8 @@
"""
from pypy.jit.backend.x86.tool.viewcode import machine_code_dump
data = []
- label_list = [(offset, name) for name, offset in
looptoken._x86_labels.iteritems()]
+ label_list = [(offset, name) for name, offset in
+ looptoken._x86_ops_offset.iteritems()]
label_list.sort()
addr = looptoken._x86_rawstart
src = rffi.cast(rffi.CCHARP, addr)
diff --git a/pypy/jit/backend/x86/test/test_runner.py
b/pypy/jit/backend/x86/test/test_runner.py
--- a/pypy/jit/backend/x86/test/test_runner.py
+++ b/pypy/jit/backend/x86/test/test_runner.py
@@ -390,7 +390,7 @@
res = self.cpu.get_latest_value_int(0)
assert res == 20
- def test_labels(self):
+ def test_ops_offset(self):
from pypy.rlib import debug
i0 = BoxInt()
i1 = BoxInt()
@@ -403,17 +403,16 @@
]
inputargs = [i0]
debug._log = dlog = debug.DebugLog()
- labels = self.cpu.compile_loop(inputargs, operations, looptoken)
+ ops_offset = self.cpu.compile_loop(inputargs, operations, looptoken)
debug._log = None
#
- # check the labels saved on the looptoken
- assert labels is looptoken._x86_labels
+ assert ops_offset is looptoken._x86_ops_offset
# getfield_raw/int_add/setfield_raw + ops + None
- assert len(labels) == 3 + len(operations) + 1
- assert (labels[operations[0]] <=
- labels[operations[1]] <=
- labels[operations[2]] <=
- labels[None])
+ assert len(ops_offset) == 3 + len(operations) + 1
+ assert (ops_offset[operations[0]] <=
+ ops_offset[operations[1]] <=
+ ops_offset[operations[2]] <=
+ ops_offset[None])
class TestDebuggingAssembler(object):
def setup_method(self, meth):
diff --git a/pypy/jit/metainterp/compile.py b/pypy/jit/metainterp/compile.py
--- a/pypy/jit/metainterp/compile.py
+++ b/pypy/jit/metainterp/compile.py
@@ -162,8 +162,8 @@
metainterp_sd.profiler.start_backend()
debug_start("jit-backend")
try:
- labels = metainterp_sd.cpu.compile_loop(loop.inputargs,
loop.operations,
- loop.token)
+ ops_offset = metainterp_sd.cpu.compile_loop(loop.inputargs,
loop.operations,
+ loop.token)
finally:
debug_stop("jit-backend")
metainterp_sd.profiler.end_backend()
@@ -175,7 +175,7 @@
loop._ignore_during_counting = True
metainterp_sd.log("compiled new " + type)
#
- metainterp_sd.logger_ops.log_loop(loop.inputargs, loop.operations, n,
type, labels)
+ metainterp_sd.logger_ops.log_loop(loop.inputargs, loop.operations, n,
type, ops_offset)
short = loop.token.short_preamble
if short:
metainterp_sd.logger_ops.log_short_preamble(short[-1].inputargs,
@@ -192,8 +192,8 @@
metainterp_sd.profiler.start_backend()
debug_start("jit-backend")
try:
- labels = metainterp_sd.cpu.compile_bridge(faildescr, inputargs,
operations,
- original_loop_token)
+ ops_offset = metainterp_sd.cpu.compile_bridge(faildescr, inputargs,
operations,
+ original_loop_token)
finally:
debug_stop("jit-backend")
metainterp_sd.profiler.end_backend()
@@ -202,7 +202,7 @@
metainterp_sd.log("compiled new bridge")
#
n = metainterp_sd.cpu.get_fail_descr_number(faildescr)
- metainterp_sd.logger_ops.log_bridge(inputargs, operations, n, labels)
+ metainterp_sd.logger_ops.log_bridge(inputargs, operations, n, ops_offset)
#
if metainterp_sd.warmrunnerdesc is not None: # for tests
metainterp_sd.warmrunnerdesc.memory_manager.keep_loop_alive(
diff --git a/pypy/jit/metainterp/logger.py b/pypy/jit/metainterp/logger.py
--- a/pypy/jit/metainterp/logger.py
+++ b/pypy/jit/metainterp/logger.py
@@ -14,33 +14,33 @@
self.ts = metainterp_sd.cpu.ts
self.guard_number = guard_number
- def log_loop(self, inputargs, operations, number=0, type=None,
labels=None):
+ def log_loop(self, inputargs, operations, number=0, type=None,
ops_offset=None):
if type is None:
debug_start("jit-log-noopt-loop")
- self._log_operations(inputargs, operations, labels)
+ self._log_operations(inputargs, operations, ops_offset)
debug_stop("jit-log-noopt-loop")
else:
debug_start("jit-log-opt-loop")
debug_print("# Loop", number, ":", type,
"with", len(operations), "ops")
- self._log_operations(inputargs, operations, labels)
+ self._log_operations(inputargs, operations, ops_offset)
debug_stop("jit-log-opt-loop")
- def log_bridge(self, inputargs, operations, number=-1, labels=None):
+ def log_bridge(self, inputargs, operations, number=-1, ops_offset=None):
if number == -1:
debug_start("jit-log-noopt-bridge")
- self._log_operations(inputargs, operations, labels)
+ self._log_operations(inputargs, operations, ops_offset)
debug_stop("jit-log-noopt-bridge")
else:
debug_start("jit-log-opt-bridge")
debug_print("# bridge out of Guard", number,
"with", len(operations), "ops")
- self._log_operations(inputargs, operations, labels)
+ self._log_operations(inputargs, operations, ops_offset)
debug_stop("jit-log-opt-bridge")
def log_short_preamble(self, inputargs, operations):
debug_start("jit-log-short-preamble")
- self._log_operations(inputargs, operations, labels=None)
+ self._log_operations(inputargs, operations, ops_offset=None)
debug_stop("jit-log-short-preamble")
def repr_of_descr(self, descr):
@@ -75,11 +75,11 @@
else:
return '?'
- def _log_operations(self, inputargs, operations, labels):
+ def _log_operations(self, inputargs, operations, ops_offset):
if not have_debug_prints():
return
- if labels is None:
- labels = {}
+ if ops_offset is None:
+ ops_offset = {}
memo = {}
if inputargs is not None:
args = ", ".join([self.repr_of_arg(memo, arg) for arg in
inputargs])
@@ -91,7 +91,7 @@
reclev = op.getarg(1).getint()
debug_print("debug_merge_point('%s', %s)" % (loc, reclev))
continue
- offset = labels.get(op, -1)
+ offset = ops_offset.get(op, -1)
if offset == -1:
s_offset = ""
else:
@@ -117,8 +117,8 @@
fail_args = ''
debug_print(s_offset + res + op.getopname() +
'(' + args + ')' + fail_args)
- if labels and None in labels:
- offset = labels[None]
+ if ops_offset and None in ops_offset:
+ offset = ops_offset[None]
debug_print("+%d: # --end of the loop--" % offset)
diff --git a/pypy/jit/metainterp/test/test_compile.py
b/pypy/jit/metainterp/test/test_compile.py
--- a/pypy/jit/metainterp/test/test_compile.py
+++ b/pypy/jit/metainterp/test/test_compile.py
@@ -34,7 +34,7 @@
self.seen.append((inputargs, operations, token))
class FakeLogger(object):
- def log_loop(self, inputargs, operations, number=0, type=None,
labels=None):
+ def log_loop(self, inputargs, operations, number=0, type=None,
ops_offset=None):
pass
class FakeState(object):
diff --git a/pypy/jit/metainterp/test/test_logger.py
b/pypy/jit/metainterp/test/test_logger.py
--- a/pypy/jit/metainterp/test/test_logger.py
+++ b/pypy/jit/metainterp/test/test_logger.py
@@ -31,10 +31,10 @@
return log_stream.getvalue()
class Logger(logger.Logger):
- def log_loop(self, loop, namespace={}, labels=None):
+ def log_loop(self, loop, namespace={}, ops_offset=None):
self.namespace = namespace
return capturing(logger.Logger.log_loop, self,
- loop.inputargs, loop.operations, labels=labels)
+ loop.inputargs, loop.operations,
ops_offset=ops_offset)
def repr_of_descr(self, descr):
for k, v in self.namespace.items():
@@ -179,7 +179,7 @@
assert output.splitlines()[0] == "# bridge out of Guard 3 with 0 ops"
pure_parse(output)
- def test_labels(self):
+ def test_ops_offset(self):
inp = '''
[i0]
i1 = int_add(i0, 1)
@@ -188,13 +188,13 @@
'''
loop = pure_parse(inp)
ops = loop.operations
- labels = {
+ ops_offset = {
ops[0]: 10,
ops[2]: 30,
None: 40
}
logger = Logger(self.make_metainterp_sd())
- output = logger.log_loop(loop, labels=labels)
+ output = logger.log_loop(loop, ops_offset=ops_offset)
assert output.strip() == """
[i0]
+10: i2 = int_add(i0, 1)
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
http://mail.python.org/mailman/listinfo/pypy-commit
