git.saurik.com Git - apple/javascriptcore.git/blob - assembler/MacroAssemblerCodeRef.h

1 /*

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. ``AS IS'' AND ANY

14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR

17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

18 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

19 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

20 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

21 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

24 */

26 #ifndef MacroAssemblerCodeRef_h

27 #define MacroAssemblerCodeRef_h

29 #include "Disassembler.h"

30 #include "ExecutableAllocator.h"

31 #include "LLIntData.h"

32 #include <wtf/DataLog.h>

33 #include <wtf/PassRefPtr.h>

34 #include <wtf/PrintStream.h>

35 #include <wtf/RefPtr.h>

37 // ASSERT_VALID_CODE_POINTER checks that ptr is a non-null pointer, and that it is a valid

38 // instruction address on the platform (for example, check any alignment requirements).

39 #if CPU(ARM_THUMB2) && ENABLE(JIT)

40 // ARM instructions must be 16-bit aligned. Thumb2 code pointers to be loaded into

41 // into the processor are decorated with the bottom bit set, while traditional ARM has

42 // the lower bit clear. Since we don't know what kind of pointer, we check for both

43 // decorated and undecorated null.

44 #define ASSERT_VALID_CODE_POINTER(ptr) \

45 ASSERT(reinterpret_cast<intptr_t>(ptr) & ~1)

46 #define ASSERT_VALID_CODE_OFFSET(offset) \

47 ASSERT(!(offset & 1)) // Must be multiple of 2.

48 #else

49 #define ASSERT_VALID_CODE_POINTER(ptr) \

50 ASSERT(ptr)

51 #define ASSERT_VALID_CODE_OFFSET(offset) // Anything goes!

52 #endif

54 #if CPU(X86) && OS(WINDOWS)

55 #define CALLING_CONVENTION_IS_STDCALL 1

56 #ifndef CDECL

57 #if COMPILER(MSVC)

58 #define CDECL __cdecl

59 #else

60 #define CDECL __attribute__ ((__cdecl))

61 #endif // COMPILER(MSVC)

62 #endif // CDECL

63 #else

64 #define CALLING_CONVENTION_IS_STDCALL 0

65 #endif

67 #if CPU(X86)

68 #define HAS_FASTCALL_CALLING_CONVENTION 1

69 #ifndef FASTCALL

70 #if COMPILER(MSVC)

71 #define FASTCALL __fastcall

72 #else

73 #define FASTCALL __attribute__ ((fastcall))

74 #endif // COMPILER(MSVC)

75 #endif // FASTCALL

76 #else

77 #define HAS_FASTCALL_CALLING_CONVENTION 0

78 #endif // CPU(X86)

80 namespace JSC {

82 // FunctionPtr:

83 //

84 // FunctionPtr should be used to wrap pointers to C/C++ functions in JSC

85 // (particularly, the stub functions).

86 class FunctionPtr {

87 public:

88 FunctionPtr()

         : m_value(0)

90 {

91 }

93 template<typename returnType>

     FunctionPtr(returnType(*value)())

         : m_value((void*)value)

96 {

97 ASSERT_VALID_CODE_POINTER(m_value);

98 }

100 template<typename returnType, typename argType1>

     FunctionPtr(returnType(*value)(argType1))

         : m_value((void*)value)

103 {

104 ASSERT_VALID_CODE_POINTER(m_value);

105 }

106

     template<typename returnType, typename argType1, typename argType2>

     FunctionPtr(returnType(*value)(argType1, argType2))

         : m_value((void*)value)

110 {

111 ASSERT_VALID_CODE_POINTER(m_value);

112 }

113

     template<typename returnType, typename argType1, typename argType2, typename argType3>

     FunctionPtr(returnType(*value)(argType1, argType2, argType3))

         : m_value((void*)value)

117 {

118 ASSERT_VALID_CODE_POINTER(m_value);

119 }

120

     template<typename returnType, typename argType1, typename argType2, typename argType3, typename argType4>

     FunctionPtr(returnType(*value)(argType1, argType2, argType3, argType4))

         : m_value((void*)value)

124 {

125 ASSERT_VALID_CODE_POINTER(m_value);

126 }

127

     template<typename returnType, typename argType1, typename argType2, typename argType3, typename argType4, typename argType5>

     FunctionPtr(returnType(*value)(argType1, argType2, argType3, argType4, argType5))

         : m_value((void*)value)

131 {

132 ASSERT_VALID_CODE_POINTER(m_value);

133 }

134

     template<typename returnType, typename argType1, typename argType2, typename argType3, typename argType4, typename argType5, typename argType6>

     FunctionPtr(returnType(*value)(argType1, argType2, argType3, argType4, argType5, argType6))

         : m_value((void*)value)

138 {

139 ASSERT_VALID_CODE_POINTER(m_value);

140 }

141 // MSVC doesn't seem to treat functions with different calling conventions as

142 // different types; these methods already defined for fastcall, below.

143 #if CALLING_CONVENTION_IS_STDCALL && !OS(WINDOWS)

144

145 template<typename returnType>

     FunctionPtr(returnType (CDECL *value)())

         : m_value((void*)value)

148 {

149 ASSERT_VALID_CODE_POINTER(m_value);

150 }

151

152 template<typename returnType, typename argType1>

     FunctionPtr(returnType (CDECL *value)(argType1))

         : m_value((void*)value)

155 {

156 ASSERT_VALID_CODE_POINTER(m_value);

157 }

158

     template<typename returnType, typename argType1, typename argType2>

     FunctionPtr(returnType (CDECL *value)(argType1, argType2))

         : m_value((void*)value)

162 {

163 ASSERT_VALID_CODE_POINTER(m_value);

164 }

165

     template<typename returnType, typename argType1, typename argType2, typename argType3>

     FunctionPtr(returnType (CDECL *value)(argType1, argType2, argType3))

         : m_value((void*)value)

169 {

170 ASSERT_VALID_CODE_POINTER(m_value);

171 }

172

     template<typename returnType, typename argType1, typename argType2, typename argType3, typename argType4>

     FunctionPtr(returnType (CDECL *value)(argType1, argType2, argType3, argType4))

         : m_value((void*)value)

176 {

177 ASSERT_VALID_CODE_POINTER(m_value);

178 }

179 #endif

180

181 #if HAS_FASTCALL_CALLING_CONVENTION

182

183 template<typename returnType>

     FunctionPtr(returnType (FASTCALL *value)())

         : m_value((void*)value)

186 {

187 ASSERT_VALID_CODE_POINTER(m_value);

188 }

189

190 template<typename returnType, typename argType1>

     FunctionPtr(returnType (FASTCALL *value)(argType1))

         : m_value((void*)value)

193 {

194 ASSERT_VALID_CODE_POINTER(m_value);

195 }

196

     template<typename returnType, typename argType1, typename argType2>

     FunctionPtr(returnType (FASTCALL *value)(argType1, argType2))

         : m_value((void*)value)

200 {

201 ASSERT_VALID_CODE_POINTER(m_value);

202 }

203

     template<typename returnType, typename argType1, typename argType2, typename argType3>

     FunctionPtr(returnType (FASTCALL *value)(argType1, argType2, argType3))

         : m_value((void*)value)

207 {

208 ASSERT_VALID_CODE_POINTER(m_value);

209 }

210

     template<typename returnType, typename argType1, typename argType2, typename argType3, typename argType4>

     FunctionPtr(returnType (FASTCALL *value)(argType1, argType2, argType3, argType4))

         : m_value((void*)value)

214 {

215 ASSERT_VALID_CODE_POINTER(m_value);

216 }

217 #endif

218

219 template<typename FunctionType>

220 explicit FunctionPtr(FunctionType* value)

221 // Using a C-ctyle cast here to avoid compiler error on RVTC:

222 // Error: #694: reinterpret_cast cannot cast away const or other type qualifiers

223 // (I guess on RVTC function pointers have a different constness to GCC/MSVC?)

         : m_value((void*)value)

225 {

226 ASSERT_VALID_CODE_POINTER(m_value);

227 }

228

     void* value() const { return m_value; }

     void* executableAddress() const { return m_value; }

231

232

233 private:

234 void* m_value;

235 };

236

237 // ReturnAddressPtr:

238 //

239 // ReturnAddressPtr should be used to wrap return addresses generated by processor

240 // 'call' instructions exectued in JIT code. We use return addresses to look up

241 // exception and optimization information, and to repatch the call instruction

242 // that is the source of the return address.

243 class ReturnAddressPtr {

244 public:

245 ReturnAddressPtr()

         : m_value(0)

247 {

248 }

249

     explicit ReturnAddressPtr(void* value)

251 : m_value(value)

252 {

253 ASSERT_VALID_CODE_POINTER(m_value);

254 }

255

256 explicit ReturnAddressPtr(FunctionPtr function)

         : m_value(function.value())

258 {

259 ASSERT_VALID_CODE_POINTER(m_value);

260 }

261

     void* value() const { return m_value; }

263

     void dump(PrintStream& out) const

265 {

         out.print(RawPointer(m_value));

267 }

268

269 private:

270 void* m_value;

271 };

272

273 // MacroAssemblerCodePtr:

274 //

275 // MacroAssemblerCodePtr should be used to wrap pointers to JIT generated code.

276 class MacroAssemblerCodePtr {

277 public:

278 MacroAssemblerCodePtr()

         : m_value(0)

280 {

281 }

282

     explicit MacroAssemblerCodePtr(void* value)

284 #if CPU(ARM_THUMB2)

285 // Decorate the pointer as a thumb code pointer.

         : m_value(reinterpret_cast<char*>(value) + 1)

287 #else

288 : m_value(value)

289 #endif

290 {

291 ASSERT_VALID_CODE_POINTER(m_value);

292 }

293

     static MacroAssemblerCodePtr createFromExecutableAddress(void* value)

295 {

296 ASSERT_VALID_CODE_POINTER(value);

297 MacroAssemblerCodePtr result;

298 result.m_value = value;

299 return result;

300 }

301

302 static MacroAssemblerCodePtr createLLIntCodePtr(OpcodeID codeId)

303 {

         return createFromExecutableAddress(LLInt::getCodePtr(codeId));

305 }

306

307 explicit MacroAssemblerCodePtr(ReturnAddressPtr ra)

         : m_value(ra.value())

309 {

310 ASSERT_VALID_CODE_POINTER(m_value);

311 }

312

     void* executableAddress() const { return m_value; }

314 #if CPU(ARM_THUMB2)

315 // To use this pointer as a data address remove the decoration.

     void* dataLocation() const { ASSERT_VALID_CODE_POINTER(m_value); return reinterpret_cast<char*>(m_value) - 1; }

317 #else

     void* dataLocation() const { ASSERT_VALID_CODE_POINTER(m_value); return m_value; }

319 #endif

320

     explicit operator bool() const { return m_value; }

322

     bool operator==(const MacroAssemblerCodePtr& other) const

324 {

325 return m_value == other.m_value;

326 }

327

     void dumpWithName(const char* name, PrintStream& out) const

329 {

         if (executableAddress() == dataLocation()) {

             out.print(name, "(", RawPointer(executableAddress()), ")");

332 return;

333 }

         out.print(name, "(executable = ", RawPointer(executableAddress()), ", dataLocation = ", RawPointer(dataLocation()), ")");

335 }

336

     void dump(PrintStream& out) const

338 {

         dumpWithName("CodePtr", out);

340 }

341

342 enum EmptyValueTag { EmptyValue };

343 enum DeletedValueTag { DeletedValue };

344

345 MacroAssemblerCodePtr(EmptyValueTag)

         : m_value(emptyValue())

347 {

348 }

349

350 MacroAssemblerCodePtr(DeletedValueTag)

         : m_value(deletedValue())

352 {

353 }

354

     bool isEmptyValue() const { return m_value == emptyValue(); }

     bool isDeletedValue() const { return m_value == deletedValue(); }

357

     unsigned hash() const { return PtrHash<void*>::hash(m_value); }

359

360 private:

     static void* emptyValue() { return bitwise_cast<void*>(static_cast<intptr_t>(1)); }

     static void* deletedValue() { return bitwise_cast<void*>(static_cast<intptr_t>(2)); }

363

364 void* m_value;

365 };

366

367 struct MacroAssemblerCodePtrHash {

     static unsigned hash(const MacroAssemblerCodePtr& ptr) { return ptr.hash(); }

     static bool equal(const MacroAssemblerCodePtr& a, const MacroAssemblerCodePtr& b)

370 {

371 return a == b;

372 }

373 static const bool safeToCompareToEmptyOrDeleted = true;

374 };

375

376 // MacroAssemblerCodeRef:

377 //

378 // A reference to a section of JIT generated code. A CodeRef consists of a

379 // pointer to the code, and a ref pointer to the pool from within which it

380 // was allocated.

381 class MacroAssemblerCodeRef {

382 private:

383 // This is private because it's dangerous enough that we want uses of it

384 // to be easy to find - hence the static create method below.

385 explicit MacroAssemblerCodeRef(MacroAssemblerCodePtr codePtr)

386 : m_codePtr(codePtr)

387 {

388 ASSERT(m_codePtr);

389 }

390

391 public:

392 MacroAssemblerCodeRef()

393 {

394 }

395

     MacroAssemblerCodeRef(PassRefPtr<ExecutableMemoryHandle> executableMemory)

         : m_codePtr(executableMemory->start())

398 , m_executableMemory(executableMemory)

399 {

         ASSERT(m_executableMemory->isManaged());

         ASSERT(m_executableMemory->start());

402 ASSERT(m_codePtr);

403 }

404

405 // Use this only when you know that the codePtr refers to code that is

406 // already being kept alive through some other means. Typically this means

407 // that codePtr is immortal.

408 static MacroAssemblerCodeRef createSelfManagedCodeRef(MacroAssemblerCodePtr codePtr)

409 {

410 return MacroAssemblerCodeRef(codePtr);

411 }

412

413 // Helper for creating self-managed code refs from LLInt.

414 static MacroAssemblerCodeRef createLLIntCodeRef(OpcodeID codeId)

415 {

         return createSelfManagedCodeRef(MacroAssemblerCodePtr::createFromExecutableAddress(LLInt::getCodePtr(codeId)));

417 }

418

419 ExecutableMemoryHandle* executableMemory() const

420 {

421 return m_executableMemory.get();

422 }

423

424 MacroAssemblerCodePtr code() const

425 {

426 return m_codePtr;

427 }

428

429 size_t size() const

430 {

431 if (!m_executableMemory)

432 return 0;

433 return m_executableMemory->sizeInBytes();

434 }

435

     bool tryToDisassemble(const char* prefix) const

437 {

         return JSC::tryToDisassemble(m_codePtr, size(), prefix, WTF::dataFile());

439 }

440

     explicit operator bool() const { return !!m_codePtr; }

442

     void dump(PrintStream& out) const

444 {

         m_codePtr.dumpWithName("CodeRef", out);

446 }

447

448 private:

449 MacroAssemblerCodePtr m_codePtr;

450 RefPtr<ExecutableMemoryHandle> m_executableMemory;

451 };

452

453 } // namespace JSC

454

455 namespace WTF {

456

 template<typename T> struct DefaultHash;

 template<> struct DefaultHash<JSC::MacroAssemblerCodePtr> {

459 typedef JSC::MacroAssemblerCodePtrHash Hash;

460 };

461

 template<typename T> struct HashTraits;

 template<> struct HashTraits<JSC::MacroAssemblerCodePtr> : public CustomHashTraits<JSC::MacroAssemblerCodePtr> { };

464

465 } // namespace WTF

466

467 #endif // MacroAssemblerCodeRef_h