Attachment #240993 for bug #138395

View Details Raw Unified Return to Bug 138395



2014-11-04  Gyuyoung Kim  <gyuyoung.kim@samsung.com>

        Use std::unique_ptr in CodeBlock class
        https://bugs.webkit.org/show_bug.cgi?id=138395

        Reviewed by NOBODY (OOPS!).

        * bytecode/CodeBlock.h: Use std::unique_ptr.
        (JSC::CodeBlock::setJITCodeMap):
        * jit/CompactJITCodeMap.h: Use std::unique_ptr instead of OwnPtr|PassOwnPtr.
        (JSC::CompactJITCodeMap::CompactJITCodeMap):
        (JSC::CompactJITCodeMap::Encoder::finish): Use std::unique_ptr instead of PassOwnPtr.

2014-11-04  Joseph Pecoraro  <pecoraro@apple.com>

        Web Inspector: Pause on exceptions should show the actual exception




    void linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo*);

    void setJITCodeMap(std::unique_ptr<CompactJITCodeMap> jitCodeMap)
    {
        m_jitCodeMap = WTF::move(jitCodeMap);
    }
    CompactJITCodeMap* jitCodeMap()
    {

    Bag<CallLinkInfo> m_callLinkInfos;
    SentinelLinkedList<CallLinkInfo, BasicRawSentinelNode<CallLinkInfo>> m_incomingCalls;
#endif
    std::unique_ptr<CompactJITCodeMap> m_jitCodeMap;
#if ENABLE(DFG_JIT)
    // This is relevant to non-DFG code blocks that serve as the profiled code block
    // for DFG code blocks.



#include <wtf/Assertions.h>
#include <wtf/FastMalloc.h>
#include <wtf/FastMalloc.h>
#include <wtf/OwnPtr.h>
#include <wtf/PassOwnPtr.h>
#include <wtf/Vector.h>

namespace JSC {

// CompactJITCodeMap::Encoder encoder(map);
// encoder.append(a, b);
// encoder.append(c, d); // preconditions: c >= a, d >= b
// auto map = encoder.finish();
//
// At some later time:
//

class CompactJITCodeMap {
    WTF_MAKE_FAST_ALLOCATED;
public:
    CompactJITCodeMap(uint8_t* buffer, unsigned size, unsigned numberOfEntries)
        : m_buffer(buffer)
#if !ASSERT_DISABLED
        , m_size(size)
#endif
        , m_numberOfEntries(numberOfEntries)
    {
        UNUSED_PARAM(size);
    }

    ~CompactJITCodeMap()
    {
        if (m_buffer)

    void decode(Vector<BytecodeAndMachineOffset>& result) const;
    
private:
    CompactJITCodeMap(uint8_t* buffer, unsigned size, unsigned numberOfEntries)
        : m_buffer(buffer)
#if !ASSERT_DISABLED
        , m_size(size)
#endif
        , m_numberOfEntries(numberOfEntries)
    {
        UNUSED_PARAM(size);
    }
    
    uint8_t at(unsigned index) const
    {
        ASSERT(index < m_size);

        
        void ensureCapacityFor(unsigned numberOfEntriesToAdd);
        void append(unsigned bytecodeIndex, unsigned machineCodeOffset);
        std::unique_ptr<CompactJITCodeMap> finish();

    private:
        void appendByte(uint8_t value);
        void encodeNumber(uint32_t value);

    m_numberOfEntries++;
}

inline std::unique_ptr<CompactJITCodeMap> CompactJITCodeMap::Encoder::finish()
{
    m_capacity = m_size;
    m_buffer = static_cast<uint8_t*>(fastRealloc(m_buffer, m_capacity));
    auto result = std::make_unique<CompactJITCodeMap>(m_buffer, m_size, m_numberOfEntries);
    m_buffer = 0;
    m_size = 0;
    m_capacity = 0;
    m_numberOfEntries = 0;
    m_previousBytecodeIndex = 0;
    m_previousMachineCodeOffset = 0;
    return result;
}
        
inline void CompactJITCodeMap::Encoder::appendByte(uint8_t value)

Return to Bug 138395

Lines 239-247 public: a/Source/JavaScriptCore/bytecode/CodeBlock.h_sec1
- a/Source/JavaScriptCore/bytecode/CodeBlock.h -3 / +3 lines
239		239
240	void linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo*);	240	void linkIncomingCall(ExecState* callerFrame, LLIntCallLinkInfo*);
241		241
242	void setJITCodeMap(PassOwnPtr<CompactJITCodeMap> jitCodeMap)	242	void setJITCodeMap(std::unique_ptr<CompactJITCodeMap> jitCodeMap)
243	{	243	{
244	m_jitCodeMap = jitCodeMap;	244	m_jitCodeMap = WTF::move(jitCodeMap);
245	}	245	}
246	CompactJITCodeMap* jitCodeMap()	246	CompactJITCodeMap* jitCodeMap()
247	{	247	{
Lines 1054-1060 private: a/Source/JavaScriptCore/bytecode/CodeBlock.h_sec2
1054	Bag<CallLinkInfo> m_callLinkInfos;	1054	Bag<CallLinkInfo> m_callLinkInfos;
1055	SentinelLinkedList<CallLinkInfo, BasicRawSentinelNode<CallLinkInfo>> m_incomingCalls;	1055	SentinelLinkedList<CallLinkInfo, BasicRawSentinelNode<CallLinkInfo>> m_incomingCalls;
1056	#endif	1056	#endif
1057	OwnPtr<CompactJITCodeMap> m_jitCodeMap;	1057	std::unique_ptr<CompactJITCodeMap> m_jitCodeMap;
1058	#if ENABLE(DFG_JIT)	1058	#if ENABLE(DFG_JIT)
1059	// This is relevant to non-DFG code blocks that serve as the profiled code block	1059	// This is relevant to non-DFG code blocks that serve as the profiled code block
1060	// for DFG code blocks.	1060	// for DFG code blocks.

Lines 32-39 a/Source/JavaScriptCore/jit/CompactJITCodeMap.h_sec1
- a/Source/JavaScriptCore/jit/CompactJITCodeMap.h -18 / +16 lines
32	#include <wtf/Assertions.h>	32	#include <wtf/Assertions.h>
33	#include <wtf/FastMalloc.h>	33	#include <wtf/FastMalloc.h>
34	#include <wtf/FastMalloc.h>	34	#include <wtf/FastMalloc.h>
35	#include <wtf/OwnPtr.h>
36	#include <wtf/PassOwnPtr.h>
37	#include <wtf/Vector.h>	35	#include <wtf/Vector.h>
38		36
39	namespace JSC {	37	namespace JSC {
Lines 47-53 namespace JSC { a/Source/JavaScriptCore/jit/CompactJITCodeMap.h_sec2
47	// CompactJITCodeMap::Encoder encoder(map);	45	// CompactJITCodeMap::Encoder encoder(map);
48	// encoder.append(a, b);	46	// encoder.append(a, b);
49	// encoder.append(c, d); // preconditions: c >= a, d >= b	47	// encoder.append(c, d); // preconditions: c >= a, d >= b
50	// OwnPtr<CompactJITCodeMap> map = encoder.finish();	48	// auto map = encoder.finish();
51	//	49	//
52	// At some later time:	50	// At some later time:
53	//	51	//
Lines 80-85 struct BytecodeAndMachineOffset { a/Source/JavaScriptCore/jit/CompactJITCodeMap.h_sec3
80	class CompactJITCodeMap {	78	class CompactJITCodeMap {
81	WTF_MAKE_FAST_ALLOCATED;	79	WTF_MAKE_FAST_ALLOCATED;
82	public:	80	public:
		81	CompactJITCodeMap(uint8_t* buffer, unsigned size, unsigned numberOfEntries)
		82	: m_buffer(buffer)
		83	#if !ASSERT_DISABLED
		84	, m_size(size)
		85	#endif
		86	, m_numberOfEntries(numberOfEntries)
		87	{
		88	UNUSED_PARAM(size);
		89	}
		90
83	~CompactJITCodeMap()	91	~CompactJITCodeMap()
84	{	92	{
85	if (m_buffer)	93	if (m_buffer)
Lines 94-109 public: a/Source/JavaScriptCore/jit/CompactJITCodeMap.h_sec4
94	void decode(Vector<BytecodeAndMachineOffset>& result) const;	102	void decode(Vector<BytecodeAndMachineOffset>& result) const;
95		103
96	private:	104	private:
97	CompactJITCodeMap(uint8_t* buffer, unsigned size, unsigned numberOfEntries)
98	: m_buffer(buffer)
99	#if !ASSERT_DISABLED
100	, m_size(size)
101	#endif
102	, m_numberOfEntries(numberOfEntries)
103	{
104	UNUSED_PARAM(size);
105	}
106
107	uint8_t at(unsigned index) const	105	uint8_t at(unsigned index) const
108	{	106	{
109	ASSERT(index < m_size);	107	ASSERT(index < m_size);
Lines 138-145 public: a/Source/JavaScriptCore/jit/CompactJITCodeMap.h_sec5
138		136
139	void ensureCapacityFor(unsigned numberOfEntriesToAdd);	137	void ensureCapacityFor(unsigned numberOfEntriesToAdd);
140	void append(unsigned bytecodeIndex, unsigned machineCodeOffset);	138	void append(unsigned bytecodeIndex, unsigned machineCodeOffset);
141	PassOwnPtr<CompactJITCodeMap> finish();	139	std::unique_ptr<CompactJITCodeMap> finish();
142		140
143	private:	141	private:
144	void appendByte(uint8_t value);	142	void appendByte(uint8_t value);
145	void encodeNumber(uint32_t value);	143	void encodeNumber(uint32_t value);
Lines 212-229 inline void CompactJITCodeMap::Encoder::append(unsigned bytecodeIndex, unsigned a/Source/JavaScriptCore/jit/CompactJITCodeMap.h_sec6
212	m_numberOfEntries++;	210	m_numberOfEntries++;
213	}	211	}
214		212
215	inline PassOwnPtr<CompactJITCodeMap> CompactJITCodeMap::Encoder::finish()	213	inline std::unique_ptr<CompactJITCodeMap> CompactJITCodeMap::Encoder::finish()
216	{	214	{
217	m_capacity = m_size;	215	m_capacity = m_size;
218	m_buffer = static_cast<uint8_t*>(fastRealloc(m_buffer, m_capacity));	216	m_buffer = static_cast<uint8_t*>(fastRealloc(m_buffer, m_capacity));
219	OwnPtr<CompactJITCodeMap> result = adoptPtr(new CompactJITCodeMap(m_buffer, m_size, m_numberOfEntries));	217	auto result = std::make_unique<CompactJITCodeMap>(m_buffer, m_size, m_numberOfEntries);
220	m_buffer = 0;	218	m_buffer = 0;
221	m_size = 0;	219	m_size = 0;
222	m_capacity = 0;	220	m_capacity = 0;
223	m_numberOfEntries = 0;	221	m_numberOfEntries = 0;
224	m_previousBytecodeIndex = 0;	222	m_previousBytecodeIndex = 0;
225	m_previousMachineCodeOffset = 0;	223	m_previousMachineCodeOffset = 0;
226	return result.release();	224	return result;
227	}	225	}
228		226
229	inline void CompactJITCodeMap::Encoder::appendByte(uint8_t value)	227	inline void CompactJITCodeMap::Encoder::appendByte(uint8_t value)

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +13 lines
		1	2014-11-04 Gyuyoung Kim <gyuyoung.kim@samsung.com>
		2
		3	Use std::unique_ptr in CodeBlock class
		4	https://bugs.webkit.org/show_bug.cgi?id=138395
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* bytecode/CodeBlock.h: Use std::unique_ptr.
		9	(JSC::CodeBlock::setJITCodeMap):
		10	* jit/CompactJITCodeMap.h: Use std::unique_ptr instead of OwnPtr\|PassOwnPtr.
		11	(JSC::CompactJITCodeMap::CompactJITCodeMap):
		12	(JSC::CompactJITCodeMap::Encoder::finish): Use std::unique_ptr instead of PassOwnPtr.
		13
1	2014-11-04 Joseph Pecoraro <pecoraro@apple.com>	14	2014-11-04 Joseph Pecoraro <pecoraro@apple.com>
2		15
3	Web Inspector: Pause on exceptions should show the actual exception	16	Web Inspector: Pause on exceptions should show the actual exception