Make ASan build not depend on asan.xcconfig
[WebKit-https.git] / Source / JavaScriptCore / heap / ConservativeRoots.cpp
1 /*
2  * Copyright (C) 2011 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "ConservativeRoots.h"
28
29 #include "CodeBlock.h"
30 #include "CodeBlockSet.h"
31 #include "CopiedSpace.h"
32 #include "CopiedSpaceInlines.h"
33 #include "JSCell.h"
34 #include "JSObject.h"
35 #include "JSCInlines.h"
36 #include "Structure.h"
37
38 namespace JSC {
39
40 ConservativeRoots::ConservativeRoots(const MarkedBlockSet* blocks, CopiedSpace* copiedSpace)
41     : m_roots(m_inlineRoots)
42     , m_size(0)
43     , m_capacity(inlineCapacity)
44     , m_blocks(blocks)
45     , m_copiedSpace(copiedSpace)
46 {
47 }
48
49 ConservativeRoots::~ConservativeRoots()
50 {
51     if (m_roots != m_inlineRoots)
52         OSAllocator::decommitAndRelease(m_roots, m_capacity * sizeof(JSCell*));
53 }
54
55 void ConservativeRoots::grow()
56 {
57     size_t newCapacity = m_capacity == inlineCapacity ? nonInlineCapacity : m_capacity * 2;
58     JSCell** newRoots = static_cast<JSCell**>(OSAllocator::reserveAndCommit(newCapacity * sizeof(JSCell*)));
59     memcpy(newRoots, m_roots, m_size * sizeof(JSCell*));
60     if (m_roots != m_inlineRoots)
61         OSAllocator::decommitAndRelease(m_roots, m_capacity * sizeof(JSCell*));
62     m_capacity = newCapacity;
63     m_roots = newRoots;
64 }
65
66 template<typename MarkHook>
67 inline void ConservativeRoots::genericAddPointer(void* p, TinyBloomFilter filter, MarkHook& markHook)
68 {
69     markHook.mark(p);
70
71     m_copiedSpace->pinIfNecessary(p);
72     
73     MarkedBlock* candidate = MarkedBlock::blockFor(p);
74     if (filter.ruleOut(reinterpret_cast<Bits>(candidate))) {
75         ASSERT(!candidate || !m_blocks->set().contains(candidate));
76         return;
77     }
78
79     if (!MarkedBlock::isAtomAligned(p))
80         return;
81
82     if (!m_blocks->set().contains(candidate))
83         return;
84
85     if (!candidate->isLiveCell(p))
86         return;
87
88     if (m_size == m_capacity)
89         grow();
90
91     m_roots[m_size++] = static_cast<JSCell*>(p);
92 }
93
94 template<typename MarkHook>
95 SUPPRESS_ASAN
96 void ConservativeRoots::genericAddSpan(void* begin, void* end, MarkHook& markHook)
97 {
98     if (begin > end) {
99         void* swapTemp = begin;
100         begin = end;
101         end = swapTemp;
102     }
103
104     RELEASE_ASSERT(isPointerAligned(begin));
105     RELEASE_ASSERT(isPointerAligned(end));
106
107     TinyBloomFilter filter = m_blocks->filter(); // Make a local copy of filter to show the compiler it won't alias, and can be register-allocated.
108     for (char** it = static_cast<char**>(begin); it != static_cast<char**>(end); ++it)
109         genericAddPointer(*it, filter, markHook);
110 }
111
112 class DummyMarkHook {
113 public:
114     void mark(void*) { }
115 };
116
117 void ConservativeRoots::add(void* begin, void* end)
118 {
119     DummyMarkHook dummy;
120     genericAddSpan(begin, end, dummy);
121 }
122
123 void ConservativeRoots::add(void* begin, void* end, JITStubRoutineSet& jitStubRoutines)
124 {
125     genericAddSpan(begin, end, jitStubRoutines);
126 }
127
128 template<typename T, typename U>
129 class CompositeMarkHook {
130 public:
131     CompositeMarkHook(T& first, U& second)
132         : m_first(first)
133         , m_second(second)
134     {
135     }
136     
137     void mark(void* address)
138     {
139         m_first.mark(address);
140         m_second.mark(address);
141     }
142
143 private:
144     T& m_first;
145     U& m_second;
146 };
147
148 void ConservativeRoots::add(
149     void* begin, void* end, JITStubRoutineSet& jitStubRoutines, CodeBlockSet& codeBlocks)
150 {
151     CompositeMarkHook<JITStubRoutineSet, CodeBlockSet> markHook(jitStubRoutines, codeBlocks);
152     genericAddSpan(begin, end, markHook);
153 }
154
155 } // namespace JSC