<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[176233] trunk/Source/JavaScriptCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/176233">176233</a></dd>
<dt>Author</dt> <dd>mark.lam@apple.com</dd>
<dt>Date</dt> <dd>2014-11-17 14:03:04 -0800 (Mon, 17 Nov 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>Add printing functionality in JITted code for debugging purposes.
<https://webkit.org/b/138660>
Reviewed by Geoffrey Garen.
Sometimes, for debugging, it'd be nice to be able to just print the
values of constants or registers used in JITted code, or even just
a string to log that certain pieces of JITted code have been executed.
Using the JIT probe mechanism, we can make this happen.
* assembler/ARMv7Assembler.h:
* assembler/AbstractMacroAssembler.h:
(JSC::AbstractMacroAssembler::CPUState::registerName):
(JSC::AbstractMacroAssembler::CPUState::registerValue):
(JSC::AbstractMacroAssembler::print):
(JSC::AbstractMacroAssembler::PrintArg::PrintArg):
(JSC::AbstractMacroAssembler::appendPrintArg):
(JSC::AbstractMacroAssembler::printInternal):
(JSC::AbstractMacroAssembler::printCallback):
* assembler/MacroAssemblerARM.cpp:
(JSC::MacroAssemblerARM::printCPURegisters):
(JSC::MacroAssemblerARM::printRegister):
* assembler/MacroAssemblerARM.h:
* assembler/MacroAssemblerARMv7.cpp:
(JSC::MacroAssemblerARMv7::printCPURegisters):
(JSC::MacroAssemblerARMv7::printRegister):
* assembler/MacroAssemblerARMv7.h:
* assembler/MacroAssemblerX86Common.cpp:
(JSC::MacroAssemblerX86Common::printRegister):
* assembler/MacroAssemblerX86Common.h:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerARMv7Assemblerh">trunk/Source/JavaScriptCore/assembler/ARMv7Assembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerAbstractMacroAssemblerh">trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMcpp">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7cpp">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commoncpp">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/ChangeLog 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -1,3 +1,36 @@
</span><ins>+2014-11-17 Mark Lam <mark.lam@apple.com>
+
+ Add printing functionality in JITted code for debugging purposes.
+ <https://webkit.org/b/138660>
+
+ Reviewed by Geoffrey Garen.
+
+ Sometimes, for debugging, it'd be nice to be able to just print the
+ values of constants or registers used in JITted code, or even just
+ a string to log that certain pieces of JITted code have been executed.
+ Using the JIT probe mechanism, we can make this happen.
+
+ * assembler/ARMv7Assembler.h:
+ * assembler/AbstractMacroAssembler.h:
+ (JSC::AbstractMacroAssembler::CPUState::registerName):
+ (JSC::AbstractMacroAssembler::CPUState::registerValue):
+ (JSC::AbstractMacroAssembler::print):
+ (JSC::AbstractMacroAssembler::PrintArg::PrintArg):
+ (JSC::AbstractMacroAssembler::appendPrintArg):
+ (JSC::AbstractMacroAssembler::printInternal):
+ (JSC::AbstractMacroAssembler::printCallback):
+ * assembler/MacroAssemblerARM.cpp:
+ (JSC::MacroAssemblerARM::printCPURegisters):
+ (JSC::MacroAssemblerARM::printRegister):
+ * assembler/MacroAssemblerARM.h:
+ * assembler/MacroAssemblerARMv7.cpp:
+ (JSC::MacroAssemblerARMv7::printCPURegisters):
+ (JSC::MacroAssemblerARMv7::printRegister):
+ * assembler/MacroAssemblerARMv7.h:
+ * assembler/MacroAssemblerX86Common.cpp:
+ (JSC::MacroAssemblerX86Common::printRegister):
+ * assembler/MacroAssemblerX86Common.h:
+
</ins><span class="cx"> 2014-11-17 Anders Carlsson <andersca@apple.com>
</span><span class="cx">
</span><span class="cx"> Fix JavaScriptCore build with newer versions of clang.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerARMv7Assemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/ARMv7Assembler.h (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/ARMv7Assembler.h 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/ARMv7Assembler.h 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -205,7 +205,7 @@
</span><span class="cx"> return (FPDoubleRegisterID)(reg >> 1);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-} // namespace ARMRegister
</del><ins>+} // namespace ARMRegisters
</ins><span class="cx">
</span><span class="cx"> class ARMv7Assembler;
</span><span class="cx"> class ARMThumbImmediate {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerAbstractMacroAssemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/AbstractMacroAssembler.h 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -844,6 +844,55 @@
</span><span class="cx"> _type _regName;
</span><span class="cx"> FOR_EACH_CPU_REGISTER(DECLARE_REGISTER)
</span><span class="cx"> #undef DECLARE_REGISTER
</span><ins>+
+ static const char* registerName(RegisterID regID)
+ {
+ switch (regID) {
+ #define DECLARE_REGISTER(_type, _regName) \
+ case RegisterID::_regName: \
+ return #_regName;
+ FOR_EACH_CPU_GPREGISTER(DECLARE_REGISTER)
+ #undef DECLARE_REGISTER
+ }
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+
+ static const char* registerName(FPRegisterID regID)
+ {
+ switch (regID) {
+ #define DECLARE_REGISTER(_type, _regName) \
+ case FPRegisterID::_regName: \
+ return #_regName;
+ FOR_EACH_CPU_FPREGISTER(DECLARE_REGISTER)
+ #undef DECLARE_REGISTER
+ }
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+
+ void* registerValue(RegisterID regID)
+ {
+ switch (regID) {
+ #define DECLARE_REGISTER(_type, _regName) \
+ case RegisterID::_regName: \
+ return _regName;
+ FOR_EACH_CPU_GPREGISTER(DECLARE_REGISTER)
+ #undef DECLARE_REGISTER
+ }
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+
+ double registerValue(FPRegisterID regID)
+ {
+ switch (regID) {
+ #define DECLARE_REGISTER(_type, _regName) \
+ case FPRegisterID::_regName: \
+ return _regName;
+ FOR_EACH_CPU_FPREGISTER(DECLARE_REGISTER)
+ #undef DECLARE_REGISTER
+ }
+ RELEASE_ASSERT_NOT_REACHED();
+ }
+
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> struct ProbeContext;
</span><span class="lines">@@ -891,9 +940,42 @@
</span><span class="cx"> #undef INDENT
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ // This is a marker type only used with print(). See print() below for details.
+ struct AllRegisters { };
</ins><span class="cx">
</span><ins>+ // Emits code which will print debugging info at runtime. The type of values that
+ // can be printed is encapsulated in the PrintArg struct below. Here are some
+ // examples:
+ //
+ // print("Hello world\n"); // Emits code to print the string.
+ //
+ // CodeBlock* cb = ...;
+ // print(cb); // Emits code to print the pointer value.
+ //
+ // RegisterID regID = ...;
+ // print(regID); // Emits code to print the register value (not the id).
+ //
+ // // Emits code to print all registers. Unlike other items, this prints
+ // // multiple lines as follows:
+ // // cpu {
+ // // eax: 0x123456789
+ // // ebx: 0x000000abc
+ // // ...
+ // // }
+ // print(AllRegisters());
+ //
+ // // Print multiple things at once. This incurs the probe overhead only once
+ // // to print all the items.
+ // print("cb:", cb, " regID:", regID, " cpu:\n", AllRegisters());
+
+ template<typename... Arguments>
+ void print(Arguments... args)
+ {
+ printInternal(static_cast<MacroAssemblerType*>(this), args...);
+ }
+
</ins><span class="cx"> // This function will be called by printCPU() to print the contents of the
</span><del>- // target specific registers which are saved away in the CPUInfo struct.
</del><ins>+ // target specific registers which are saved away in the CPUState struct.
</ins><span class="cx"> // printCPURegisters() should make use of printIndentation() to print the
</span><span class="cx"> // registers with the appropriate amount of indentation.
</span><span class="cx"> //
</span><span class="lines">@@ -903,14 +985,25 @@
</span><span class="cx">
</span><span class="cx"> static void printCPURegisters(CPUState&, int indentation = 0);
</span><span class="cx">
</span><del>- // This function emits code to preserve the CPUInfo (e.g. registers),
- // call a user supplied probe function, and restore the CPUInfo before
</del><ins>+ // This function will be called by print() to print the contents of a
+ // specific register (from the CPUState) in line with other items in the
+ // print stream. Hence, no indentation is needed.
+ //
+ // Note: printRegister() should be implemented by the target specific
+ // MacroAssembler. These prototypes are only provided here to document their
+ // interface.
+
+ static void printRegister(CPUState&, RegisterID);
+ static void printRegister(CPUState&, FPRegisterID);
+
+ // This function emits code to preserve the CPUState (e.g. registers),
+ // call a user supplied probe function, and restore the CPUState before
</ins><span class="cx"> // continuing with other JIT generated code.
</span><span class="cx"> //
</span><span class="cx"> // The user supplied probe function will be called with a single pointer to
</span><span class="cx"> // a ProbeContext struct (defined above) which contains, among other things,
</span><del>- // the preserved CPUInfo. This allows the user probe function to inspect
- // the CPUInfo at that point in the JIT generated code.
</del><ins>+ // the preserved CPUState. This allows the user probe function to inspect
+ // the CPUState at that point in the JIT generated code.
</ins><span class="cx"> //
</span><span class="cx"> // If the user probe function alters the register values in the ProbeContext,
</span><span class="cx"> // the altered values will be loaded into the CPU registers when the probe
</span><span class="lines">@@ -1085,8 +1178,144 @@
</span><span class="cx"> {
</span><span class="cx"> AssemblerType::replaceWithAddressComputation(label.dataLocation());
</span><span class="cx"> }
</span><del>-};
</del><span class="cx">
</span><ins>+private:
+
+#if ENABLE(MASM_PROBE)
+
+ struct PrintArg {
+
+ enum class Type {
+ AllRegisters,
+ RegisterID,
+ FPRegisterID,
+ ConstCharPtr,
+ ConstVoidPtr,
+ IntptrValue,
+ UintptrValue,
+ };
+
+ PrintArg(AllRegisters&)
+ : type(Type::AllRegisters)
+ {
+ }
+
+ PrintArg(RegisterID regID)
+ : type(Type::RegisterID)
+ {
+ u.gpRegisterID = regID;
+ }
+
+ PrintArg(FPRegisterID regID)
+ : type(Type::FPRegisterID)
+ {
+ u.fpRegisterID = regID;
+ }
+
+ PrintArg(const char* ptr)
+ : type(Type::ConstCharPtr)
+ {
+ u.constCharPtr = ptr;
+ }
+
+ PrintArg(const void* ptr)
+ : type(Type::ConstVoidPtr)
+ {
+ u.constVoidPtr = ptr;
+ }
+
+ PrintArg(int value)
+ : type(Type::IntptrValue)
+ {
+ u.intptrValue = value;
+ }
+
+ PrintArg(unsigned value)
+ : type(Type::UintptrValue)
+ {
+ u.intptrValue = value;
+ }
+
+ PrintArg(intptr_t value)
+ : type(Type::IntptrValue)
+ {
+ u.intptrValue = value;
+ }
+
+ PrintArg(uintptr_t value)
+ : type(Type::UintptrValue)
+ {
+ u.uintptrValue = value;
+ }
+
+ Type type;
+ union {
+ RegisterID gpRegisterID;
+ FPRegisterID fpRegisterID;
+ const char* constCharPtr;
+ const void* constVoidPtr;
+ intptr_t intptrValue;
+ uintptr_t uintptrValue;
+ } u;
+ };
+
+ typedef Vector<PrintArg> PrintArgsList;
+
+ template<typename FirstArg, typename... Arguments>
+ static void appendPrintArg(PrintArgsList* argsList, FirstArg& firstArg, Arguments... otherArgs)
+ {
+ argsList->append(PrintArg(firstArg));
+ appendPrintArg(argsList, otherArgs...);
+ }
+
+ static void appendPrintArg(PrintArgsList*) { }
+
+
+ template<typename... Arguments>
+ static void printInternal(MacroAssemblerType* masm, Arguments... args)
+ {
+ auto argsList = std::make_unique<PrintArgsList>();
+ appendPrintArg(argsList.get(), args...);
+ masm->probe(printCallback, argsList.release());
+ }
+
+ static void printCallback(ProbeContext* context)
+ {
+ typedef PrintArg Arg;
+ PrintArgsList& argsList =
+ *reinterpret_cast<PrintArgsList*>(context->arg1);
+ for (size_t i = 0; i < argsList.size(); i++) {
+ auto& arg = argsList[i];
+ switch (arg.type) {
+ case Arg::Type::AllRegisters:
+ MacroAssemblerType::printCPU(context->cpu);
+ break;
+ case Arg::Type::RegisterID:
+ MacroAssemblerType::printRegister(context->cpu, arg.u.gpRegisterID);
+ break;
+ case Arg::Type::FPRegisterID:
+ MacroAssemblerType::printRegister(context->cpu, arg.u.fpRegisterID);
+ break;
+ case Arg::Type::ConstCharPtr:
+ dataLog(arg.u.constCharPtr);
+ break;
+ case Arg::Type::ConstVoidPtr:
+ dataLogF("%p", arg.u.constVoidPtr);
+ break;
+ case Arg::Type::IntptrValue:
+ dataLog(arg.u.intptrValue);
+ break;
+ case Arg::Type::UintptrValue:
+ dataLog(arg.u.uintptrValue);
+ break;
+ }
+ }
+ }
+
+#endif // ENABLE(MASM_PROBE)
+
+}; // class AbstractMacroAssembler
+
</ins><span class="cx"> } // namespace JSC
</span><span class="cx">
</span><span class="cx"> #endif // ENABLE(ASSEMBLER)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.cpp (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.cpp 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.cpp 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -101,25 +101,47 @@
</span><span class="cx">
</span><span class="cx"> void MacroAssemblerARM::printCPURegisters(CPUState& cpu, int indentation)
</span><span class="cx"> {
</span><del>- #define DUMP_GPREGISTER(_type, _regName) { \
</del><ins>+ #define PRINT_GPREGISTER(_type, _regName) { \
</ins><span class="cx"> int32_t value = reinterpret_cast<int32_t>(cpu._regName); \
</span><span class="cx"> INDENT, dataLogF("%5s: 0x%08x %d\n", #_regName, value, value) ; \
</span><span class="cx"> }
</span><del>- FOR_EACH_CPU_GPREGISTER(DUMP_GPREGISTER)
- FOR_EACH_CPU_SPECIAL_REGISTER(DUMP_GPREGISTER)
- #undef DUMP_GPREGISTER
</del><ins>+ FOR_EACH_CPU_GPREGISTER(PRINT_GPREGISTER)
+ FOR_EACH_CPU_SPECIAL_REGISTER(PRINT_GPREGISTER)
+ #undef PRINT_GPREGISTER
</ins><span class="cx">
</span><del>- #define DUMP_FPREGISTER(_type, _regName) { \
</del><ins>+ #define PRINT_FPREGISTER(_type, _regName) { \
</ins><span class="cx"> uint64_t* u = reinterpret_cast<uint64_t*>(&cpu._regName); \
</span><span class="cx"> double* d = reinterpret_cast<double*>(&cpu._regName); \
</span><span class="cx"> INDENT, dataLogF("%5s: 0x%016llx %.13g\n", #_regName, *u, *d); \
</span><span class="cx"> }
</span><del>- FOR_EACH_CPU_FPREGISTER(DUMP_FPREGISTER)
- #undef DUMP_FPREGISTER
</del><ins>+ FOR_EACH_CPU_FPREGISTER(PRINT_FPREGISTER)
+ #undef PRINT_FPREGISTER
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #undef INDENT
</span><span class="cx">
</span><ins>+void MacroAssemblerARM::printRegister(MacroAssemblerARM::CPUState& cpu, RegisterID regID)
+{
+ const char* name = CPUState::registerName(regID);
+ union {
+ void* voidPtr;
+ intptr_t intptrValue;
+ } u;
+ u.voidPtr = cpu.registerValue(regID);
+ dataLogF("%s:<%p %ld>", name, u.voidPtr, u.intptrValue);
+}
+
+void MacroAssemblerARM::printRegister(MacroAssemblerARM::CPUState& cpu, FPRegisterID regID)
+{
+ const char* name = CPUState::registerName(regID);
+ union {
+ double doubleValue;
+ uint64_t uint64Value;
+ } u;
+ u.doubleValue = cpu.registerValue(regID);
+ dataLogF("%s:<0x%016llx %.13g>", name, u.uint64Value, u.doubleValue);
+}
+
</ins><span class="cx"> extern "C" void ctiMasmProbeTrampoline();
</span><span class="cx">
</span><span class="cx"> // For details on "What code is emitted for the probe?" and "What values are in
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM.h 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -1436,6 +1436,8 @@
</span><span class="cx"> // Methods required by the MASM_PROBE mechanism as defined in
</span><span class="cx"> // AbstractMacroAssembler.h.
</span><span class="cx"> static void printCPURegisters(CPUState&, int indentation = 0);
</span><ins>+ static void printRegister(CPUState&, RegisterID);
+ static void printRegister(CPUState&, FPRegisterID);
</ins><span class="cx"> void probe(ProbeFunction, void* arg1 = 0, void* arg2 = 0);
</span><span class="cx"> #endif // ENABLE(MASM_PROBE)
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.cpp (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.cpp 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.cpp 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -1,5 +1,5 @@
</span><span class="cx"> /*
</span><del>- * Copyright (C) 2013 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2013, 2014 Apple Inc. All rights reserved.
</ins><span class="cx"> *
</span><span class="cx"> * Redistribution and use in source and binary forms, with or without
</span><span class="cx"> * modification, are permitted provided that the following conditions
</span><span class="lines">@@ -36,25 +36,47 @@
</span><span class="cx">
</span><span class="cx"> void MacroAssemblerARMv7::printCPURegisters(CPUState& cpu, int indentation)
</span><span class="cx"> {
</span><del>- #define DUMP_GPREGISTER(_type, _regName) { \
</del><ins>+ #define PRINT_GPREGISTER(_type, _regName) { \
</ins><span class="cx"> int32_t value = reinterpret_cast<int32_t>(cpu._regName); \
</span><span class="cx"> INDENT, dataLogF("%5s: 0x%08x %d\n", #_regName, value, value) ; \
</span><span class="cx"> }
</span><del>- FOR_EACH_CPU_GPREGISTER(DUMP_GPREGISTER)
- FOR_EACH_CPU_SPECIAL_REGISTER(DUMP_GPREGISTER)
- #undef DUMP_GPREGISTER
</del><ins>+ FOR_EACH_CPU_GPREGISTER(PRINT_GPREGISTER)
+ FOR_EACH_CPU_SPECIAL_REGISTER(PRINT_GPREGISTER)
+ #undef PRINT_GPREGISTER
</ins><span class="cx">
</span><del>- #define DUMP_FPREGISTER(_type, _regName) { \
</del><ins>+ #define PRINT_FPREGISTER(_type, _regName) { \
</ins><span class="cx"> uint64_t* u = reinterpret_cast<uint64_t*>(&cpu._regName); \
</span><span class="cx"> double* d = reinterpret_cast<double*>(&cpu._regName); \
</span><span class="cx"> INDENT, dataLogF("%5s: 0x%016llx %.13g\n", #_regName, *u, *d); \
</span><span class="cx"> }
</span><del>- FOR_EACH_CPU_FPREGISTER(DUMP_FPREGISTER)
- #undef DUMP_FPREGISTER
</del><ins>+ FOR_EACH_CPU_FPREGISTER(PRINT_FPREGISTER)
+ #undef PRINT_FPREGISTER
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #undef INDENT
</span><span class="cx">
</span><ins>+void MacroAssemblerARMv7::printRegister(MacroAssemblerARMv7::CPUState& cpu, RegisterID regID)
+{
+ const char* name = CPUState::registerName(regID);
+ union {
+ void* voidPtr;
+ intptr_t intptrValue;
+ } u;
+ u.voidPtr = cpu.registerValue(regID);
+ dataLogF("%s:<%p %ld>", name, u.voidPtr, u.intptrValue);
+}
+
+void MacroAssemblerARMv7::printRegister(MacroAssemblerARMv7::CPUState& cpu, FPRegisterID regID)
+{
+ const char* name = CPUState::registerName(regID);
+ union {
+ double doubleValue;
+ uint64_t uint64Value;
+ } u;
+ u.doubleValue = cpu.registerValue(regID);
+ dataLogF("%s:<0x%016llx %.13g>", name, u.uint64Value, u.doubleValue);
+}
+
</ins><span class="cx"> extern "C" void ctiMasmProbeTrampoline();
</span><span class="cx">
</span><span class="cx"> // For details on "What code is emitted for the probe?" and "What values are in
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -1905,6 +1905,8 @@
</span><span class="cx"> // Methods required by the MASM_PROBE mechanism as defined in
</span><span class="cx"> // AbstractMacroAssembler.h.
</span><span class="cx"> static void printCPURegisters(CPUState&, int indentation = 0);
</span><ins>+ static void printRegister(CPUState&, RegisterID);
+ static void printRegister(CPUState&, FPRegisterID);
</ins><span class="cx"> void probe(ProbeFunction, void* arg1 = 0, void* arg2 = 0);
</span><span class="cx"> #endif // ENABLE(MASM_PROBE)
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commoncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -62,6 +62,28 @@
</span><span class="cx">
</span><span class="cx"> #undef INDENT
</span><span class="cx">
</span><ins>+void MacroAssemblerX86Common::printRegister(MacroAssemblerX86Common::CPUState& cpu, RegisterID regID)
+{
+ const char* name = CPUState::registerName(regID);
+ union {
+ void* voidPtr;
+ intptr_t intptrValue;
+ } u;
+ u.voidPtr = cpu.registerValue(regID);
+ dataLogF("%s:<%p %ld>", name, u.voidPtr, u.intptrValue);
+}
+
+void MacroAssemblerX86Common::printRegister(MacroAssemblerX86Common::CPUState& cpu, FPRegisterID regID)
+{
+ const char* name = CPUState::registerName(regID);
+ union {
+ double doubleValue;
+ uint64_t uint64Value;
+ } u;
+ u.doubleValue = cpu.registerValue(regID);
+ dataLogF("%s:<0x%016llx %.13g>", name, u.uint64Value, u.doubleValue);
+}
+
</ins><span class="cx"> extern "C" void ctiMasmProbeTrampoline();
</span><span class="cx">
</span><span class="cx"> // What code is emitted for the probe?
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (176232 => 176233)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2014-11-17 21:59:03 UTC (rev 176232)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2014-11-17 22:03:04 UTC (rev 176233)
</span><span class="lines">@@ -1,5 +1,5 @@
</span><span class="cx"> /*
</span><del>- * Copyright (C) 2008 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2008, 2014 Apple Inc. All rights reserved.
</ins><span class="cx"> *
</span><span class="cx"> * Redistribution and use in source and binary forms, with or without
</span><span class="cx"> * modification, are permitted provided that the following conditions
</span><span class="lines">@@ -1473,6 +1473,8 @@
</span><span class="cx"> // Methods required by the MASM_PROBE mechanism as defined in
</span><span class="cx"> // AbstractMacroAssembler.h.
</span><span class="cx"> static void printCPURegisters(CPUState&, int indentation = 0);
</span><ins>+ static void printRegister(CPUState&, RegisterID);
+ static void printRegister(CPUState&, FPRegisterID);
</ins><span class="cx"> void probe(ProbeFunction, void* arg1 = 0, void* arg2 = 0);
</span><span class="cx"> #endif // ENABLE(MASM_PROBE)
</span><span class="cx">
</span></span></pre>
</div>
</div>
</body>
</html>