JavaScriptCore-7600.1.4.16.1.tar.gz

[apple/javascriptcore.git] / jit / JITThunks.cpp

diff --git a/jit/JITThunks.cpp b/jit/JITThunks.cpp
index a241143356746f811a703aa4e00a3f99f92cbd1c..a0694f533d3eb614c3b66fc21534007f331ca511 100644 (file)
--- a/jit/JITThunks.cpp
+++ b/jit/JITThunks.cpp
@@ -1,5 +1,5 @@
 /*
 /*

- * Copyright (C) 2012 Apple Inc. All rights reserved.
+ * Copyright (C) 2012, 2013 Apple Inc. All rights reserved.

  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions


@@ -31,7 +31,7 @@
 #include "Executable.h"
 #include "JIT.h"
 #include "VM.h"
 #include "Executable.h"
 #include "JIT.h"
 #include "VM.h"

-#include "Operations.h"
+#include "JSCInlines.h"

 
 namespace JSC {
 
 
 namespace JSC {
 


@@ -46,55 +46,73 @@ JITThunks::~JITThunks()
 
 MacroAssemblerCodePtr JITThunks::ctiNativeCall(VM* vm)
 {
 
 MacroAssemblerCodePtr JITThunks::ctiNativeCall(VM* vm)
 {

-#if ENABLE(LLINT)

     if (!vm->canUseJIT())
         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_call_trampoline);
     if (!vm->canUseJIT())
         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_call_trampoline);

-#endif

     return ctiStub(vm, nativeCallGenerator).code();
 }
     return ctiStub(vm, nativeCallGenerator).code();
 }

+

 MacroAssemblerCodePtr JITThunks::ctiNativeConstruct(VM* vm)
 {
 MacroAssemblerCodePtr JITThunks::ctiNativeConstruct(VM* vm)
 {

-#if ENABLE(LLINT)

     if (!vm->canUseJIT())
         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_construct_trampoline);
     if (!vm->canUseJIT())
         return MacroAssemblerCodePtr::createLLIntCodePtr(llint_native_construct_trampoline);

-#endif

     return ctiStub(vm, nativeConstructGenerator).code();
 }
 
     return ctiStub(vm, nativeConstructGenerator).code();
 }
 

+MacroAssemblerCodePtr JITThunks::ctiNativeTailCall(VM* vm)
+{
+    ASSERT(vm->canUseJIT());
+    return ctiStub(vm, nativeTailCallGenerator).code();
+}
+

 MacroAssemblerCodeRef JITThunks::ctiStub(VM* vm, ThunkGenerator generator)
 {
 MacroAssemblerCodeRef JITThunks::ctiStub(VM* vm, ThunkGenerator generator)
 {

+    Locker locker(m_lock);

     CTIStubMap::AddResult entry = m_ctiStubMap.add(generator, MacroAssemblerCodeRef());
     CTIStubMap::AddResult entry = m_ctiStubMap.add(generator, MacroAssemblerCodeRef());

-    if (entry.isNewEntry)
+    if (entry.isNewEntry) {
+        // Compilation thread can only retrieve existing entries.
+        ASSERT(!isCompilationThread());

         entry.iterator->value = generator(vm);
         entry.iterator->value = generator(vm);

+    }

     return entry.iterator->value;
 }
 
 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, NativeFunction constructor)
 {
     return entry.iterator->value;
 }
 
 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, NativeFunction constructor)
 {

-    if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(std::make_pair(*function, *constructor)))
+    ASSERT(!isCompilationThread());
+
+    if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(std::make_pair(function, constructor)))

         return nativeExecutable;
 
         return nativeExecutable;
 

-    NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, JIT::compileCTINativeCall(vm, function), function, MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), constructor, NoIntrinsic);
-    weakAdd(*m_hostFunctionStubMap, std::make_pair(*function, *constructor), PassWeak<NativeExecutable>(nativeExecutable));
+    NativeExecutable* nativeExecutable = NativeExecutable::create(
+        *vm,
+        adoptRef(new NativeJITCode(JIT::compileCTINativeCall(vm, function), JITCode::HostCallThunk)),
+        function,
+        adoptRef(new NativeJITCode(MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), JITCode::HostCallThunk)),
+        constructor, NoIntrinsic);
+    weakAdd(*m_hostFunctionStubMap, std::make_pair(function, constructor), Weak<NativeExecutable>(nativeExecutable));

     return nativeExecutable;
 }
 
 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, ThunkGenerator generator, Intrinsic intrinsic)
 {
     return nativeExecutable;
 }
 
 NativeExecutable* JITThunks::hostFunctionStub(VM* vm, NativeFunction function, ThunkGenerator generator, Intrinsic intrinsic)
 {

-    if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(std::make_pair(*function, *callHostFunctionAsConstructor)))
+    ASSERT(!isCompilationThread());    
+
+    if (NativeExecutable* nativeExecutable = m_hostFunctionStubMap->get(std::make_pair(function, &callHostFunctionAsConstructor)))

         return nativeExecutable;
 
         return nativeExecutable;
 

-    MacroAssemblerCodeRef code;
+    RefPtr<JITCode> forCall;

     if (generator) {
     if (generator) {

-        if (vm->canUseJIT())
-            code = generator(vm);
-        else
-            code = MacroAssemblerCodeRef();
+        if (vm->canUseJIT()) {
+            MacroAssemblerCodeRef entry = generator(vm);
+            forCall = adoptRef(new DirectJITCode(entry, entry.code(), JITCode::HostCallThunk));
+        }

     } else
     } else

-        code = JIT::compileCTINativeCall(vm, function);
-
-    NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, code, function, MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), callHostFunctionAsConstructor, intrinsic);
-    weakAdd(*m_hostFunctionStubMap, std::make_pair(*function, *callHostFunctionAsConstructor), PassWeak<NativeExecutable>(nativeExecutable));
+        forCall = adoptRef(new NativeJITCode(JIT::compileCTINativeCall(vm, function), JITCode::HostCallThunk));
+    
+    RefPtr<JITCode> forConstruct = adoptRef(new NativeJITCode(MacroAssemblerCodeRef::createSelfManagedCodeRef(ctiNativeConstruct(vm)), JITCode::HostCallThunk));
+    
+    NativeExecutable* nativeExecutable = NativeExecutable::create(*vm, forCall, function, forConstruct, callHostFunctionAsConstructor, intrinsic);
+    weakAdd(*m_hostFunctionStubMap, std::make_pair(function, &callHostFunctionAsConstructor), Weak<NativeExecutable>(nativeExecutable));

     return nativeExecutable;
 }
 
     return nativeExecutable;
 }