No subject
Fri Mar 7 15:32:22 PST 2014
ng its buffer (or writting anything
into it really). This was obviously already the case, but that was hard t=
o prove from LinkBuffer::copyCompactAndLinkCode().
To make this easier to work with, I changed all the assembler specific fu=
nction to be static. This way we know
exactly what code access the Assembler instance. The code that does acces=
s the instance is then moved
at the beginning, before we modify anything.
The function recordLinkOffsets() that was on the MacroAssembler and copie=
d in Assembler was moved directly
to LinkBuffer. This make the modification of AssemblerData completely exp=
licit, and that code is specific
to LinkBuffer anyway (see LinkBuffer::executableOffsetFor()).
-- Perf impact --
This does not put us exactly at before <a href=3D"http://trac.webkit.org/=
projects/webkit/changeset/164548">r164548</a> due to the missing inline b=
uffer. Still, it is very close.
On ARMv7, this reduces the time spent in Assembler by half. On the CSS JI=
T, this reduces the compilation
time by ~20%.
I could not measure any difference on x86_64.
* assembler/ARM64Assembler.h:
(JSC::ARM64Assembler::jumpSizeDelta):
(JSC::ARM64Assembler::canCompact):
(JSC::ARM64Assembler::computeJumpType):
(JSC::ARM64Assembler::link):
(JSC::ARM64Assembler::recordLinkOffsets): Deleted.
* assembler/ARMv7Assembler.h:
(JSC::ARMv7Assembler::ifThenElseConditionBit):
(JSC::ARMv7Assembler::ifThenElse):
(JSC::ARMv7Assembler::jumpSizeDelta):
(JSC::ARMv7Assembler::canCompact):
(JSC::ARMv7Assembler::computeJumpType):
(JSC::ARMv7Assembler::link):
(JSC::ARMv7Assembler::linkJumpT1):
(JSC::ARMv7Assembler::linkJumpT3):
(JSC::ARMv7Assembler::linkConditionalJumpT4):
(JSC::ARMv7Assembler::linkConditionalBX):
(JSC::ARMv7Assembler::recordLinkOffsets): Deleted.
* assembler/AssemblerBuffer.h:
(JSC::AssemblerData::AssemblerData):
(JSC::AssemblerData::operator=3D):
(JSC::AssemblerData::~AssemblerData):
(JSC::AssemblerData::buffer):
(JSC::AssemblerData::capacity):
(JSC::AssemblerData::grow):
(JSC::AssemblerBuffer::AssemblerBuffer):
(JSC::AssemblerBuffer::isAvailable):
(JSC::AssemblerBuffer::data):
(JSC::AssemblerBuffer::releaseAssemblerData):
(JSC::AssemblerBuffer::putIntegral):
(JSC::AssemblerBuffer::putIntegralUnchecked):
(JSC::AssemblerBuffer::append):
(JSC::AssemblerBuffer::grow):
(JSC::AssemblerBuffer::~AssemblerBuffer): Deleted.
(JSC::AssemblerBuffer::storage): Deleted.
* assembler/LinkBuffer.cpp:
(JSC::recordLinkOffsets):
(JSC::LinkBuffer::copyCompactAndLinkCode):
* assembler/LinkBuffer.h:
(JSC::LinkBuffer::LinkBuffer):
(JSC::LinkBuffer::executableOffsetFor):
* assembler/MacroAssemblerARM64.h:
(JSC::MacroAssemblerARM64::canCompact):
(JSC::MacroAssemblerARM64::computeJumpType):
(JSC::MacroAssemblerARM64::jumpSizeDelta):
(JSC::MacroAssemblerARM64::link):
(JSC::MacroAssemblerARM64::recordLinkOffsets): Deleted.
* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::canCompact):
(JSC::MacroAssemblerARMv7::computeJumpType):
(JSC::MacroAssemblerARMv7::jumpSizeDelta):
(JSC::MacroAssemblerARMv7::link):
(JSC::MacroAssemblerARMv7::recordLinkOffsets): Deleted.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href=3D"#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScri=
ptCore/ChangeLog</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerARM64Assemblerh">trunk/=
Source/JavaScriptCore/assembler/ARM64Assembler.h</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerARMv7Assemblerh">trunk/=
Source/JavaScriptCore/assembler/ARMv7Assembler.h</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerAssemblerBufferh">trunk=
/Source/JavaScriptCore/assembler/AssemblerBuffer.h</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerLinkBuffercpp">trunk/So=
urce/JavaScriptCore/assembler/LinkBuffer.cpp</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerLinkBufferh">trunk/Sour=
ce/JavaScriptCore/assembler/LinkBuffer.h</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h">t=
runk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h</a></li>
<li><a href=3D"#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h">t=
runk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h</a></li>
</ul>
</div>
<div id=3D"patch">
<h3>Diff</h3>
<a id=3D"trunkSourceJavaScriptCoreChangeLog"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLo=
g (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/ChangeLog 2014-07-15=
23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/ChangeLog 2014-07-15 23:59:14 UTC (rev 17=
1123)
</span><span class=3D"lines">@@ -1,3 +1,102 @@
</span><ins>+2014-07-15 Benjamin Poulain <benjamin at webkit.org>
+
+ Reduce the overhead of updating the AssemblerBuffer
+ https://bugs.webkit.org/show_bug.cgi?id=3D134659
+
+ Reviewed by Gavin Barraclough.
+
+ In r164548, the linker was changed to allow the LinkBuffer to su=
rvive its MacroAssembler.
+ That feature is useful for JSC to get offsets inside a linked bu=
ffer in order to jump directly
+ there.
+
+ On ARM, we use branch compaction and we need to keep the "c=
ompaction offset" somewher to be able
+ to get the real address of a lable. That is done by reusing the =
memory of AssemblerData.
+
+ To share the memory between LinkBuffer and the Assembler, r16454=
8 moved the AssemblerData into
+ a ref-counted object. Unfortunately, the extra complexity relate=
d to the new AssemblerData was enough
+ to make clang give up a bunch of optimizations.
+
+ This patch solve (some of) the problems by making AssemblerBuffe=
r and AssemblerData super low overhead structures.
+ In particular, the grow() function becomes 8 Thumb instructions,=
which is easily inlined everywhere it is used.
+
+ Instead of sharing ownership between the Assembler and LinkBuffe=
r, LinkBuffer now takes full ownership of
+ the AssemblerData. I feel this is also safer since LinkBuffer is=
reusing the AssemblerData is a very
+ specific way that would make it unusable for the Assembler.
+
+ -- Technical details --
+
+ From LinkBuffer, we don't want to ever access the Assembler afte=
r releasing its buffer (or writting anything
+ into it really). This was obviously already the case, but that w=
as hard to prove from LinkBuffer::copyCompactAndLinkCode().
+ To make this easier to work with, I changed all the assembler sp=
ecific function to be static. This way we know
+ exactly what code access the Assembler instance. The code that d=
oes access the instance is then moved
+ at the beginning, before we modify anything.
+
+ The function recordLinkOffsets() that was on the MacroAssembler =
and copied in Assembler was moved directly
+ to LinkBuffer. This make the modification of AssemblerData compl=
etely explicit, and that code is specific
+ to LinkBuffer anyway (see LinkBuffer::executableOffsetFor()).
+
+ -- Perf impact --
+
+ This does not put us exactly at before r164548 due to the missin=
g inline buffer. Still, it is very close.
+ On ARMv7, this reduces the time spent in Assembler by half. On t=
he CSS JIT, this reduces the compilation
+ time by ~20%.
+
+ I could not measure any difference on x86_64.
+
+ * assembler/ARM64Assembler.h:
+ (JSC::ARM64Assembler::jumpSizeDelta):
+ (JSC::ARM64Assembler::canCompact):
+ (JSC::ARM64Assembler::computeJumpType):
+ (JSC::ARM64Assembler::link):
+ (JSC::ARM64Assembler::recordLinkOffsets): Deleted.
+ * assembler/ARMv7Assembler.h:
+ (JSC::ARMv7Assembler::ifThenElseConditionBit):
+ (JSC::ARMv7Assembler::ifThenElse):
+ (JSC::ARMv7Assembler::jumpSizeDelta):
+ (JSC::ARMv7Assembler::canCompact):
+ (JSC::ARMv7Assembler::computeJumpType):
+ (JSC::ARMv7Assembler::link):
+ (JSC::ARMv7Assembler::linkJumpT1):
+ (JSC::ARMv7Assembler::linkJumpT3):
+ (JSC::ARMv7Assembler::linkConditionalJumpT4):
+ (JSC::ARMv7Assembler::linkConditionalBX):
+ (JSC::ARMv7Assembler::recordLinkOffsets): Deleted.
+ * assembler/AssemblerBuffer.h:
+ (JSC::AssemblerData::AssemblerData):
+ (JSC::AssemblerData::operator=3D):
+ (JSC::AssemblerData::~AssemblerData):
+ (JSC::AssemblerData::buffer):
+ (JSC::AssemblerData::capacity):
+ (JSC::AssemblerData::grow):
+ (JSC::AssemblerBuffer::AssemblerBuffer):
+ (JSC::AssemblerBuffer::isAvailable):
+ (JSC::AssemblerBuffer::data):
+ (JSC::AssemblerBuffer::releaseAssemblerData):
+ (JSC::AssemblerBuffer::putIntegral):
+ (JSC::AssemblerBuffer::putIntegralUnchecked):
+ (JSC::AssemblerBuffer::append):
+ (JSC::AssemblerBuffer::grow):
+ (JSC::AssemblerBuffer::~AssemblerBuffer): Deleted.
+ (JSC::AssemblerBuffer::storage): Deleted.
+ * assembler/LinkBuffer.cpp:
+ (JSC::recordLinkOffsets):
+ (JSC::LinkBuffer::copyCompactAndLinkCode):
+ * assembler/LinkBuffer.h:
+ (JSC::LinkBuffer::LinkBuffer):
+ (JSC::LinkBuffer::executableOffsetFor):
+ * assembler/MacroAssemblerARM64.h:
+ (JSC::MacroAssemblerARM64::canCompact):
+ (JSC::MacroAssemblerARM64::computeJumpType):
+ (JSC::MacroAssemblerARM64::jumpSizeDelta):
+ (JSC::MacroAssemblerARM64::link):
+ (JSC::MacroAssemblerARM64::recordLinkOffsets): Deleted.
+ * assembler/MacroAssemblerARMv7.h:
+ (JSC::MacroAssemblerARMv7::canCompact):
+ (JSC::MacroAssemblerARMv7::computeJumpType):
+ (JSC::MacroAssemblerARMv7::jumpSizeDelta):
+ (JSC::MacroAssemblerARMv7::link):
+ (JSC::MacroAssemblerARMv7::recordLinkOffsets): Deleted.
+
</ins><span class=3D"cx"> 2014-07-15 Mark Hahnenberg <mhahnenberg at ap=
ple.com>
</span><span class=3D"cx">=20
</span><span class=3D"cx"> Stores to PropertyTable use the Struct=
ure as the owner
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerARM64Assemblerh"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/ARM64Assembler.h (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/ARM64Assem=
bler.h 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/ARM64Assembler.h 2014-07-15 23:=
59:14 UTC (rev 171123)
</span><span class=3D"lines">@@ -2877,20 +2877,20 @@
</span><span class=3D"cx">=20
</span><span class=3D"cx"> // Assembler admin methods:
</span><span class=3D"cx">=20
</span><del>- int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLi=
nkType) { return JUMP_ENUM_SIZE(jumpType) - JUMP_ENUM_SIZE(jumpLinkType);=
}
</del><ins>+ static int jumpSizeDelta(JumpType jumpType, JumpLinkType =
jumpLinkType) { return JUMP_ENUM_SIZE(jumpType) - JUMP_ENUM_SIZE(jumpLink=
Type); }
</ins><span class=3D"cx">=20
</span><span class=3D"cx"> static ALWAYS_INLINE bool linkRecordSource=
Comparator(const LinkRecord& a, const LinkRecord& b)
</span><span class=3D"cx"> {
</span><span class=3D"cx"> return a.from() < b.from();
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- bool canCompact(JumpType jumpType)
</del><ins>+ static bool canCompact(JumpType jumpType)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> // Fixed jumps cannot be compacted
</span><span class=3D"cx"> return (jumpType =3D=3D JumpNoConditio=
n) || (jumpType =3D=3D JumpCondition) || (jumpType =3D=3D JumpCompareAndB=
ranch) || (jumpType =3D=3D JumpTestBit);
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- JumpLinkType computeJumpType(JumpType jumpType, const ui=
nt8_t* from, const uint8_t* to)
</del><ins>+ static JumpLinkType computeJumpType(JumpType jumpType, co=
nst uint8_t* from, const uint8_t* to)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> switch (jumpType) {
</span><span class=3D"cx"> case JumpFixed:
</span><span class=3D"lines">@@ -2942,29 +2942,20 @@
</span><span class=3D"cx"> return LinkJumpNoCondition;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- JumpLinkType computeJumpType(LinkRecord& record, con=
st uint8_t* from, const uint8_t* to)
</del><ins>+ static JumpLinkType computeJumpType(LinkRecord& recor=
d, const uint8_t* from, const uint8_t* to)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> JumpLinkType linkType =3D computeJumpT=
ype(record.type(), from, to);
</span><span class=3D"cx"> record.setLinkType(linkType);
</span><span class=3D"cx"> return linkType;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- void recordLinkOffsets(int32_t regionStart, int32_t regi=
onEnd, int32_t offset)
- {
- int32_t ptr =3D regionStart / sizeof(int32_t);
- const int32_t end =3D regionEnd / sizeof(int32_t);
- int32_t* offsets =3D static_cast<int32_t*>(m_buffer.data()=
);
- while (ptr < end)
- offsets[ptr++] =3D offset;
- }
-
</del><span class=3D"cx"> Vector<LinkRecord, 0, UnsafeVectorOverfl=
ow>& jumpsToLink()
</span><span class=3D"cx"> {
</span><span class=3D"cx"> std::sort(m_jumpsToLink.begin(), m_jum=
psToLink.end(), linkRecordSourceComparator);
</span><span class=3D"cx"> return m_jumpsToLink;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- void ALWAYS_INLINE link(LinkRecord& record, uint8_t*=
from, uint8_t* to)
</del><ins>+ static void ALWAYS_INLINE link(LinkRecord& record, ui=
nt8_t* from, uint8_t* to)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> switch (record.linkType()) {
</span><span class=3D"cx"> case LinkJumpNoCondition:
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerARMv7Assemblerh"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/ARMv7Assembler.h (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/ARMv7Assem=
bler.h 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/ARMv7Assembler.h 2014-07-15 23:=
59:14 UTC (rev 171123)
</span><span class=3D"lines">@@ -1,5 +1,5 @@
</span><span class=3D"cx"> /*
</span><del>- * Copyright (C) 2009, 2010, 2012, 2013 Apple Inc. All right=
s reserved.
</del><ins>+ * Copyright (C) 2009, 2010, 2012, 2013, 2014 Apple Inc. All =
rights reserved.
</ins><span class=3D"cx"> * Copyright (C) 2010 University of Szeged
</span><span class=3D"cx"> *
</span><span class=3D"cx"> * Redistribution and use in source and binary=
forms, with or without
</span><span class=3D"lines">@@ -805,11 +805,11 @@
</span><span class=3D"cx"> class ARMInstructionFormatter;
</span><span class=3D"cx">=20
</span><span class=3D"cx"> // false means else!
</span><del>- bool ifThenElseConditionBit(Condition condition, bool is=
If)
</del><ins>+ static bool ifThenElseConditionBit(Condition condition, b=
ool isIf)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> return isIf ? (condition & 1) : !(=
condition & 1);
</span><span class=3D"cx"> }
</span><del>- uint8_t ifThenElse(Condition condition, bool inst2if, bo=
ol inst3if, bool inst4if)
</del><ins>+ static uint8_t ifThenElse(Condition condition, bool inst2=
if, bool inst3if, bool inst4if)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> int mask =3D (ifThenElseConditionBit(c=
ondition, inst2if) << 3)
</span><span class=3D"cx"> | (ifThenElseConditionBit(conditio=
n, inst3if) << 2)
</span><span class=3D"lines">@@ -818,7 +818,7 @@
</span><span class=3D"cx"> ASSERT((condition !=3D ConditionAL) ||=
!(mask & (mask - 1)));
</span><span class=3D"cx"> return (condition << 4) | mask;
</span><span class=3D"cx"> }
</span><del>- uint8_t ifThenElse(Condition condition, bool inst2if, bo=
ol inst3if)
</del><ins>+ static uint8_t ifThenElse(Condition condition, bool inst2=
if, bool inst3if)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> int mask =3D (ifThenElseConditionBit(c=
ondition, inst2if) << 3)
</span><span class=3D"cx"> | (ifThenElseConditionBit(conditio=
n, inst3if) << 2)
</span><span class=3D"lines">@@ -826,7 +826,7 @@
</span><span class=3D"cx"> ASSERT((condition !=3D ConditionAL) ||=
!(mask & (mask - 1)));
</span><span class=3D"cx"> return (condition << 4) | mask;
</span><span class=3D"cx"> }
</span><del>- uint8_t ifThenElse(Condition condition, bool inst2if)
</del><ins>+ static uint8_t ifThenElse(Condition condition, bool inst2=
if)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> int mask =3D (ifThenElseConditionBit(c=
ondition, inst2if) << 3)
</span><span class=3D"cx"> | 4;
</span><span class=3D"lines">@@ -834,7 +834,7 @@
</span><span class=3D"cx"> return (condition << 4) | mask;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- uint8_t ifThenElse(Condition condition)
</del><ins>+ static uint8_t ifThenElse(Condition condition)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> int mask =3D 8;
</span><span class=3D"cx"> return (condition << 4) | mask;
</span><span class=3D"lines">@@ -2087,7 +2087,7 @@
</span><span class=3D"cx"> return b.m_offset - a.m_offset;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLi=
nkType) { return JUMP_ENUM_SIZE(jumpType) - JUMP_ENUM_SIZE(jumpLinkType);=
}
</del><ins>+ static int jumpSizeDelta(JumpType jumpType, JumpLinkType =
jumpLinkType) { return JUMP_ENUM_SIZE(jumpType) - JUMP_ENUM_SIZE(jumpLink=
Type); }
</ins><span class=3D"cx"> =20
</span><span class=3D"cx"> // Assembler admin methods:
</span><span class=3D"cx">=20
</span><span class=3D"lines">@@ -2096,7 +2096,7 @@
</span><span class=3D"cx"> return a.from() < b.from();
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- bool canCompact(JumpType jumpType)
</del><ins>+ static bool canCompact(JumpType jumpType)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> // The following cannot be compacted:
</span><span class=3D"cx"> // JumpFixed: represents custom jump=
sequence
</span><span class=3D"lines">@@ -2105,7 +2105,7 @@
</span><span class=3D"cx"> return (jumpType =3D=3D JumpNoConditio=
n) || (jumpType =3D=3D JumpCondition);
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- JumpLinkType computeJumpType(JumpType jumpType, const ui=
nt8_t* from, const uint8_t* to)
</del><ins>+ static JumpLinkType computeJumpType(JumpType jumpType, co=
nst uint8_t* from, const uint8_t* to)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> if (jumpType =3D=3D JumpFixed)
</span><span class=3D"cx"> return LinkInvalid;
</span><span class=3D"lines">@@ -2149,29 +2149,20 @@
</span><span class=3D"cx"> return LinkConditionalBX;
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- JumpLinkType computeJumpType(LinkRecord& record, con=
st uint8_t* from, const uint8_t* to)
</del><ins>+ static JumpLinkType computeJumpType(LinkRecord& recor=
d, const uint8_t* from, const uint8_t* to)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> JumpLinkType linkType =3D computeJumpT=
ype(record.type(), from, to);
</span><span class=3D"cx"> record.setLinkType(linkType);
</span><span class=3D"cx"> return linkType;
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- void recordLinkOffsets(int32_t regionStart, int32_t regi=
onEnd, int32_t offset)
- {
- int32_t ptr =3D regionStart / sizeof(int32_t);
- const int32_t end =3D regionEnd / sizeof(int32_t);
- int32_t* offsets =3D static_cast<int32_t*>(m_formatter.dat=
a());
- while (ptr < end)
- offsets[ptr++] =3D offset;
- }
- =20
</del><span class=3D"cx"> Vector<LinkRecord, 0, UnsafeVectorOverfl=
ow>& jumpsToLink()
</span><span class=3D"cx"> {
</span><span class=3D"cx"> std::sort(m_jumpsToLink.begin(), m_jum=
psToLink.end(), linkRecordSourceComparator);
</span><span class=3D"cx"> return m_jumpsToLink;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- void ALWAYS_INLINE link(LinkRecord& record, uint8_t*=
from, uint8_t* to)
</del><ins>+ static void ALWAYS_INLINE link(LinkRecord& record, ui=
nt8_t* from, uint8_t* to)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> switch (record.linkType()) {
</span><span class=3D"cx"> case LinkJumpT1:
</span><span class=3D"lines">@@ -2622,7 +2613,7 @@
</span><span class=3D"cx"> return ((relative << 7) >>=
7) =3D=3D relative;
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- void linkJumpT1(Condition cond, uint16_t* instruction, v=
oid* target)
</del><ins>+ static void linkJumpT1(Condition cond, uint16_t* instruct=
ion, void* target)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> // FIMXE: this should be up in the Mac=
roAssembler layer. :-( =20
</span><span class=3D"cx"> ASSERT(!(reinterpret_cast<intptr_t&=
gt;(instruction) & 1));
</span><span class=3D"lines">@@ -2658,7 +2649,7 @@
</span><span class=3D"cx"> instruction[-1] =3D OP_B_T2 | ((relati=
ve & 0xffe) >> 1);
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- void linkJumpT3(Condition cond, uint16_t* instruction, v=
oid* target)
</del><ins>+ static void linkJumpT3(Condition cond, uint16_t* instruct=
ion, void* target)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> // FIMXE: this should be up in the Mac=
roAssembler layer. :-(
</span><span class=3D"cx"> ASSERT(!(reinterpret_cast<intptr_t&=
gt;(instruction) & 1));
</span><span class=3D"lines">@@ -2691,7 +2682,7 @@
</span><span class=3D"cx"> instruction[-1] =3D OP_B_T4b | ((relat=
ive & 0x800000) >> 10) | ((relative & 0x400000) >> 11=
) | ((relative & 0xffe) >> 1);
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- void linkConditionalJumpT4(Condition cond, uint16_t* ins=
truction, void* target)
</del><ins>+ static void linkConditionalJumpT4(Condition cond, uint16_=
t* instruction, void* target)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> // FIMXE: this should be up in the Mac=
roAssembler layer. :-( =20
</span><span class=3D"cx"> ASSERT(!(reinterpret_cast<intptr_t&=
gt;(instruction) & 1));
</span><span class=3D"lines">@@ -2717,7 +2708,7 @@
</span><span class=3D"cx"> instruction[-1] =3D OP_BX | (JUMP_TEMP=
ORARY_REGISTER << 3);
</span><span class=3D"cx"> }
</span><span class=3D"cx"> =20
</span><del>- void linkConditionalBX(Condition cond, uint16_t* instruc=
tion, void* target)
</del><ins>+ static void linkConditionalBX(Condition cond, uint16_t* i=
nstruction, void* target)
</ins><span class=3D"cx"> {
</span><span class=3D"cx"> // FIMXE: this should be up in the Mac=
roAssembler layer. :-( =20
</span><span class=3D"cx"> ASSERT(!(reinterpret_cast<intptr_t&=
gt;(instruction) & 1));
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerAssemblerBufferh"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/AssemblerBuffer.h (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/AssemblerB=
uffer.h 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/AssemblerBuffer.h 2014-07-15 23=
:59:14 UTC (rev 171123)
</span><span class=3D"lines">@@ -1,5 +1,5 @@
</span><span class=3D"cx"> /*
</span><del>- * Copyright (C) 2008, 2012 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2008, 2012, 2014 Apple Inc. All rights reser=
ved.
</ins><span class=3D"cx"> *
</span><span class=3D"cx"> * Redistribution and use in source and binary=
forms, with or without
</span><span class=3D"cx"> * modification, are permitted provided that t=
he following conditions
</span><span class=3D"lines">@@ -59,32 +59,69 @@
</span><span class=3D"cx"> uint32_t m_offset;
</span><span class=3D"cx"> };
</span><span class=3D"cx">=20
</span><del>- struct AssemblerData : public RefCounted<AssemblerDat=
a> {
- static const int inlineCapacity =3D 128;
</del><ins>+ class AssemblerData {
+ public:
+ AssemblerData()
+ : m_buffer(nullptr)
+ , m_capacity(0)
+ {
+ }
</ins><span class=3D"cx">=20
</span><del>- AssemblerData() : m_data(inlineCapacity) { }
- =20
- typedef Vector<char, inlineCapacity, UnsafeVectorOverflow>=
DataVector;
- DataVector m_data;
</del><ins>+ AssemblerData(unsigned initialCapacity)
+ {
+ m_capacity =3D fastMallocGoodSize(initialCapacity);
+ m_buffer =3D static_cast<char*>(fastMalloc(m_capacity)=
);
+ }
+
+ AssemblerData(AssemblerData&& other)
+ {
+ m_buffer =3D other.m_buffer;
+ other.m_buffer =3D nullptr;
+ m_capacity =3D other.m_capacity;
+ other.m_capacity =3D 0;
+ }
+
+ AssemblerData& operator=3D(AssemblerData&& other)
+ {
+ m_buffer =3D other.m_buffer;
+ other.m_buffer =3D nullptr;
+ m_capacity =3D other.m_capacity;
+ other.m_capacity =3D 0;
+ return *this;
+ }
+
+ ~AssemblerData()
+ {
+ fastFree(m_buffer);
+ }
+
+ char* buffer() const { return m_buffer; }
+
+ unsigned capacity() const { return m_capacity; }
+
+ void grow(unsigned extraCapacity =3D 0)
+ {
+ m_capacity =3D fastMallocGoodSize(m_capacity + m_capacity / =
2 + extraCapacity);
+ m_buffer =3D static_cast<char*>(fastRealloc(m_buffer, =
m_capacity));
+ }
+
+ private:
+ char* m_buffer;
+ unsigned m_capacity;
</ins><span class=3D"cx"> };
</span><span class=3D"cx">=20
</span><span class=3D"cx"> class AssemblerBuffer {
</span><ins>+ static const int initialCapacity =3D 128;
</ins><span class=3D"cx"> public:
</span><span class=3D"cx"> AssemblerBuffer()
</span><del>- : m_storage(adoptRef(new AssemblerData()))
- , m_buffer(m_storage->m_data.begin())
- , m_capacity(AssemblerData::inlineCapacity)
</del><ins>+ : m_storage(initialCapacity)
</ins><span class=3D"cx"> , m_index(0)
</span><span class=3D"cx"> {
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- ~AssemblerBuffer()
- {
- }
-
</del><span class=3D"cx"> bool isAvailable(int space)
</span><span class=3D"cx"> {
</span><del>- return m_index + space <=3D m_capacity;
</del><ins>+ return m_index + space <=3D m_storage.capacity=
();
</ins><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> void ensureSpace(int space)
</span><span class=3D"lines">@@ -98,21 +135,6 @@
</span><span class=3D"cx"> return !(m_index & (alignment =
- 1));
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><del>- template<typename IntegralType>
- void putIntegral(IntegralType value)
- {
- ensureSpace(sizeof(IntegralType));
- putIntegralUnchecked(value);
- }
-
- template<typename IntegralType>
- void putIntegralUnchecked(IntegralType value)
- {
- ASSERT(isAvailable(sizeof(IntegralType)));
- *reinterpret_cast_ptr<IntegralType*>(m_buffer + m_inde=
x) =3D value;
- m_index +=3D sizeof(IntegralType);
- }
-
</del><span class=3D"cx"> void putByteUnchecked(int8_t value) { p=
utIntegralUnchecked(value); }
</span><span class=3D"cx"> void putByte(int8_t value) { putIntegr=
al(value); }
</span><span class=3D"cx"> void putShortUnchecked(int16_t value) =
{ putIntegralUnchecked(value); }
</span><span class=3D"lines">@@ -124,7 +146,7 @@
</span><span class=3D"cx">=20
</span><span class=3D"cx"> void* data() const
</span><span class=3D"cx"> {
</span><del>- return m_buffer;
</del><ins>+ return m_storage.buffer();
</ins><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> size_t codeSize() const
</span><span class=3D"lines">@@ -138,32 +160,46 @@
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> unsigned debugOffset() { return m_inde=
x; }
</span><del>- =20
- AssemblerData* storage() { return m_storage.get(); }
</del><span class=3D"cx">=20
</span><ins>+ AssemblerData releaseAssemblerData() { return WTF::m=
ove(m_storage); }
+
</ins><span class=3D"cx"> protected:
</span><ins>+ template<typename IntegralType>
+ void putIntegral(IntegralType value)
+ {
+ unsigned nextIndex =3D m_index + sizeof(IntegralType);
+ if (UNLIKELY(nextIndex > m_storage.capacity()))
+ grow();
+ ASSERT(isAvailable(sizeof(IntegralType)));
+ *reinterpret_cast_ptr<IntegralType*>(m_storage.buffer(=
) + m_index) =3D value;
+ m_index =3D nextIndex;
+ }
+
+ template<typename IntegralType>
+ void putIntegralUnchecked(IntegralType value)
+ {
+ ASSERT(isAvailable(sizeof(IntegralType)));
+ *reinterpret_cast_ptr<IntegralType*>(m_storage.buffer(=
) + m_index) =3D value;
+ m_index +=3D sizeof(IntegralType);
+ }
+
</ins><span class=3D"cx"> void append(const char* data, int size)
</span><span class=3D"cx"> {
</span><span class=3D"cx"> if (!isAvailable(size))
</span><span class=3D"cx"> grow(size);
</span><span class=3D"cx">=20
</span><del>- memcpy(m_buffer + m_index, data, size);
</del><ins>+ memcpy(m_storage.buffer() + m_index, data, size);
</ins><span class=3D"cx"> m_index +=3D size;
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> void grow(int extraCapacity =3D 0)
</span><span class=3D"cx"> {
</span><del>- m_capacity +=3D m_capacity / 2 + extraCapacity;
-
- m_storage->m_data.grow(m_capacity);
- m_buffer =3D m_storage->m_data.begin();
</del><ins>+ m_storage.grow(extraCapacity);
</ins><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> private:
</span><del>- RefPtr<AssemblerData> m_storage;
- char* m_buffer;
- int m_capacity;
- int m_index;
</del><ins>+ AssemblerData m_storage;
+ unsigned m_index;
</ins><span class=3D"cx"> };
</span><span class=3D"cx">=20
</span><span class=3D"cx"> } // namespace JSC
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerLinkBuffercpp"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/LinkBuffer.cpp (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/LinkBuffer=
.cpp 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/LinkBuffer.cpp 2014-07-15 23:59=
:14 UTC (rev 171123)
</span><span class=3D"lines">@@ -77,6 +77,15 @@
</span><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> #if ENABLE(BRANCH_COMPACTION)
</span><ins>+static ALWAYS_INLINE void recordLinkOffsets(AssemblerData&am=
p; assemblerData, int32_t regionStart, int32_t regionEnd, int32_t offset)
+{
+ int32_t ptr =3D regionStart / sizeof(int32_t);
+ const int32_t end =3D regionEnd / sizeof(int32_t);
+ int32_t* offsets =3D reinterpret_cast<int32_t*>(assemblerData.=
buffer());
+ while (ptr < end)
+ offsets[ptr++] =3D offset;
+}
+
</ins><span class=3D"cx"> template <typename InstructionType>
</span><span class=3D"cx"> void LinkBuffer::copyCompactAndLinkCode(MacroA=
ssembler& macroAssembler, void* ownerUID, JITCompilationEffort effort=
)
</span><span class=3D"cx"> {
</span><span class=3D"lines">@@ -84,11 +93,12 @@
</span><span class=3D"cx"> allocate(m_initialSize, ownerUID, effort);
</span><span class=3D"cx"> if (didFailToAllocate())
</span><span class=3D"cx"> return;
</span><del>- uint8_t* inData =3D (uint8_t*)macroAssembler.unlinkedCod=
e();
</del><ins>+ Vector<LinkRecord, 0, UnsafeVectorOverflow>& ju=
mpsToLink =3D macroAssembler.jumpsToLink();
+ m_assemblerStorage =3D macroAssembler.m_assembler.buffer().releaseAs=
semblerData();
+ uint8_t* inData =3D reinterpret_cast<uint8_t*>(m_assemblerStor=
age.buffer());
</ins><span class=3D"cx"> uint8_t* outData =3D reinterpret_cast<ui=
nt8_t*>(m_code);
</span><span class=3D"cx"> int readPtr =3D 0;
</span><span class=3D"cx"> int writePtr =3D 0;
</span><del>- Vector<LinkRecord, 0, UnsafeVectorOverflow>& j=
umpsToLink =3D macroAssembler.jumpsToLink();
</del><span class=3D"cx"> unsigned jumpCount =3D jumpsToLink.size();
</span><span class=3D"cx"> for (unsigned i =3D 0; i < jumpCount; +=
+i) {
</span><span class=3D"cx"> int offset =3D readPtr - writePtr;
</span><span class=3D"lines">@@ -104,7 +114,7 @@
</span><span class=3D"cx"> ASSERT(!(writePtr % 2));
</span><span class=3D"cx"> while (copySource !=3D copyEnd)
</span><span class=3D"cx"> *copyDst++ =3D *copySource++;
</span><del>- macroAssembler.recordLinkOffsets(readPtr, jumpsToLin=
k[i].from(), offset);
</del><ins>+ recordLinkOffsets(m_assemblerStorage, readPtr, jumpsT=
oLink[i].from(), offset);
</ins><span class=3D"cx"> readPtr +=3D regionSize;
</span><span class=3D"cx"> writePtr +=3D regionSize;
</span><span class=3D"cx"> =20
</span><span class=3D"lines">@@ -116,26 +126,26 @@
</span><span class=3D"cx"> else
</span><span class=3D"cx"> target =3D outData + jumpsToLink[i=
].to() - executableOffsetFor(jumpsToLink[i].to());
</span><span class=3D"cx"> =20
</span><del>- JumpLinkType jumpLinkType =3D macroAssembler.compute=
JumpType(jumpsToLink[i], outData + writePtr, target);
</del><ins>+ JumpLinkType jumpLinkType =3D MacroAssembler::compute=
JumpType(jumpsToLink[i], outData + writePtr, target);
</ins><span class=3D"cx"> // Compact branch if we can...
</span><del>- if (macroAssembler.canCompact(jumpsToLink[i].type())=
) {
</del><ins>+ if (MacroAssembler::canCompact(jumpsToLink[i].type())=
) {
</ins><span class=3D"cx"> // Step back in the write stream
</span><del>- int32_t delta =3D macroAssembler.jumpSizeDelta(j=
umpsToLink[i].type(), jumpLinkType);
</del><ins>+ int32_t delta =3D MacroAssembler::jumpSizeDelta(j=
umpsToLink[i].type(), jumpLinkType);
</ins><span class=3D"cx"> if (delta) {
</span><span class=3D"cx"> writePtr -=3D delta;
</span><del>- macroAssembler.recordLinkOffsets(jumpsToLink=
[i].from() - delta, readPtr, readPtr - writePtr);
</del><ins>+ recordLinkOffsets(m_assemblerStorage, jumpsTo=
Link[i].from() - delta, readPtr, readPtr - writePtr);
</ins><span class=3D"cx"> }
</span><span class=3D"cx"> }
</span><span class=3D"cx"> jumpsToLink[i].setFrom(writePtr);
</span><span class=3D"cx"> }
</span><span class=3D"cx"> // Copy everything after the last jump
</span><span class=3D"cx"> memcpy(outData + writePtr, inData + readPt=
r, m_initialSize - readPtr);
</span><del>- macroAssembler.recordLinkOffsets(readPtr, m_initialSize,=
readPtr - writePtr);
</del><ins>+ recordLinkOffsets(m_assemblerStorage, readPtr, m_initialS=
ize, readPtr - writePtr);
</ins><span class=3D"cx"> =20
</span><span class=3D"cx"> for (unsigned i =3D 0; i < jumpCount; +=
+i) {
</span><span class=3D"cx"> uint8_t* location =3D outData + jumpsT=
oLink[i].from();
</span><span class=3D"cx"> uint8_t* target =3D outData + jumpsToL=
ink[i].to() - executableOffsetFor(jumpsToLink[i].to());
</span><del>- macroAssembler.link(jumpsToLink[i], location, target=
);
</del><ins>+ MacroAssembler::link(jumpsToLink[i], location, target=
);
</ins><span class=3D"cx"> }
</span><span class=3D"cx">=20
</span><span class=3D"cx"> jumpsToLink.clear();
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerLinkBufferh"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/LinkBuffer.h (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/LinkBuffer=
.h 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/LinkBuffer.h 2014-07-15 23:59:1=
4 UTC (rev 171123)
</span><span class=3D"lines">@@ -87,7 +87,6 @@
</span><span class=3D"cx"> #endif
</span><span class=3D"cx"> , m_didAllocate(false)
</span><span class=3D"cx"> , m_code(0)
</span><del>- , m_storage(macroAssembler.m_assembler.buffer().stor=
age())
</del><span class=3D"cx"> , m_vm(&vm)
</span><span class=3D"cx"> #ifndef NDEBUG
</span><span class=3D"cx"> , m_completed(false)
</span><span class=3D"lines">@@ -103,7 +102,6 @@
</span><span class=3D"cx"> #endif
</span><span class=3D"cx"> , m_didAllocate(false)
</span><span class=3D"cx"> , m_code(code)
</span><del>- , m_storage(macroAssembler.m_assembler.buffer().stor=
age())
</del><span class=3D"cx"> , m_vm(&vm)
</span><span class=3D"cx"> #ifndef NDEBUG
</span><span class=3D"cx"> , m_completed(false)
</span><span class=3D"lines">@@ -250,7 +248,8 @@
</span><span class=3D"cx"> {
</span><span class=3D"cx"> return m_code;
</span><span class=3D"cx"> }
</span><del>- =20
</del><ins>+
+ // FIXME: this does not account for the AssemblerData size!
</ins><span class=3D"cx"> size_t size()
</span><span class=3D"cx"> {
</span><span class=3D"cx"> return m_size;
</span><span class=3D"lines">@@ -262,7 +261,7 @@
</span><span class=3D"cx"> {
</span><span class=3D"cx"> if (!location)
</span><span class=3D"cx"> return 0;
</span><del>- return bitwise_cast<int32_t*>(m_storage->m_=
data.begin())[location / sizeof(int32_t) - 1];
</del><ins>+ return bitwise_cast<int32_t*>(m_assemblerStorag=
e.buffer())[location / sizeof(int32_t) - 1];
</ins><span class=3D"cx"> }
</span><span class=3D"cx"> #endif
</span><span class=3D"cx"> =20
</span><span class=3D"lines">@@ -303,10 +302,10 @@
</span><span class=3D"cx"> size_t m_size;
</span><span class=3D"cx"> #if ENABLE(BRANCH_COMPACTION)
</span><span class=3D"cx"> size_t m_initialSize;
</span><ins>+ AssemblerData m_assemblerStorage;
</ins><span class=3D"cx"> #endif
</span><span class=3D"cx"> bool m_didAllocate;
</span><span class=3D"cx"> void* m_code;
</span><del>- RefPtr<AssemblerData> m_storage;
</del><span class=3D"cx"> VM* m_vm;
</span><span class=3D"cx"> #ifndef NDEBUG
</span><span class=3D"cx"> bool m_completed;
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/MacroAssemblerARM64.h (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/MacroAssem=
blerARM64.h 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2014-07-1=
5 23:59:14 UTC (rev 171123)
</span><span class=3D"lines">@@ -64,12 +64,11 @@
</span><span class=3D"cx">=20
</span><span class=3D"cx"> Vector<LinkRecord, 0, UnsafeVectorOverf=
low>& jumpsToLink() { return m_assembler.jumpsToLink(); }
</span><span class=3D"cx"> void* unlinkedCode() { return m_assembler.=
unlinkedCode(); }
</span><del>- bool canCompact(JumpType jumpType) { return m_assembler.=
canCompact(jumpType); }
- JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from,=
const uint8_t* to) { return m_assembler.computeJumpType(jumpType, from, =
to); }
- JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* =
from, const uint8_t* to) { return m_assembler.computeJumpType(record, fro=
m, to); }
- void recordLinkOffsets(int32_t regionStart, int32_t regionEnd, int32=
_t offset) {return m_assembler.recordLinkOffsets(regionStart, regionEnd, =
offset); }
- int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { re=
turn m_assembler.jumpSizeDelta(jumpType, jumpLinkType); }
- void link(LinkRecord& record, uint8_t* from, uint8_t* to) { retu=
rn m_assembler.link(record, from, to); }
</del><ins>+ static bool canCompact(JumpType jumpType) { return ARM64A=
ssembler::canCompact(jumpType); }
+ static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t=
* from, const uint8_t* to) { return ARM64Assembler::computeJumpType(jumpT=
ype, from, to); }
+ static JumpLinkType computeJumpType(LinkRecord& record, const ui=
nt8_t* from, const uint8_t* to) { return ARM64Assembler::computeJumpType(=
record, from, to); }
+ static int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkTyp=
e) { return ARM64Assembler::jumpSizeDelta(jumpType, jumpLinkType); }
+ static void link(LinkRecord& record, uint8_t* from, uint8_t* to)=
{ return ARM64Assembler::link(record, from, to); }
</ins><span class=3D"cx">=20
</span><span class=3D"cx"> static const Scale ScalePtr =3D TimesEight=
;
</span><span class=3D"cx">=20
</span></span></pre></div>
<a id=3D"trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h"></a>
<div class=3D"modfile"><h4>Modified: trunk/Source/JavaScriptCore/assemble=
r/MacroAssemblerARMv7.h (171122 =3D> 171123)</h4>
<pre class=3D"diff"><span>
<span class=3D"info">--- trunk/Source/JavaScriptCore/assembler/MacroAssem=
blerARMv7.h 2014-07-15 23:12:00 UTC (rev 171122)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2014-07-1=
5 23:59:14 UTC (rev 171123)
</span><span class=3D"lines">@@ -62,12 +62,11 @@
</span><span class=3D"cx">=20
</span><span class=3D"cx"> Vector<LinkRecord, 0, UnsafeVectorOverf=
low>& jumpsToLink() { return m_assembler.jumpsToLink(); }
</span><span class=3D"cx"> void* unlinkedCode() { return m_assembler.=
unlinkedCode(); }
</span><del>- bool canCompact(JumpType jumpType) { return m_assembler.=
canCompact(jumpType); }
- JumpLinkType computeJumpType(JumpType jumpType, const uint8_t* from,=
const uint8_t* to) { return m_assembler.computeJumpType(jumpType, from, =
to); }
- JumpLinkType computeJumpType(LinkRecord& record, const uint8_t* =
from, const uint8_t* to) { return m_assembler.computeJumpType(record, fro=
m, to); }
- void recordLinkOffsets(int32_t regionStart, int32_t regionEnd, int32=
_t offset) {return m_assembler.recordLinkOffsets(regionStart, regionEnd, =
offset); }
- int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkType) { re=
turn m_assembler.jumpSizeDelta(jumpType, jumpLinkType); }
- void link(LinkRecord& record, uint8_t* from, uint8_t* to) { retu=
rn m_assembler.link(record, from, to); }
</del><ins>+ static bool canCompact(JumpType jumpType) { return ARMv7A=
ssembler::canCompact(jumpType); }
+ static JumpLinkType computeJumpType(JumpType jumpType, const uint8_t=
* from, const uint8_t* to) { return ARMv7Assembler::computeJumpType(jumpT=
ype, from, to); }
+ static JumpLinkType computeJumpType(LinkRecord& record, const ui=
nt8_t* from, const uint8_t* to) { return ARMv7Assembler::computeJumpType(=
record, from, to); }
+ static int jumpSizeDelta(JumpType jumpType, JumpLinkType jumpLinkTyp=
e) { return ARMv7Assembler::jumpSizeDelta(jumpType, jumpLinkType); }
+ static void link(LinkRecord& record, uint8_t* from, uint8_t* to)=
{ return ARMv7Assembler::link(record, from, to); }
</ins><span class=3D"cx">=20
</span><span class=3D"cx"> struct ArmAddress {
</span><span class=3D"cx"> enum AddressType {
</span></span></pre>
</div>
</div>
</body>
</html>
More information about the webkit-changes
mailing list