Load runtime entries from the Thread instead of the ObjectPool.

runtime/vm/runtime_entry.h

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_RUNTIME_ENTRY_H_
 #define VM_RUNTIME_ENTRY_H_
 
 #include "vm/allocation.h"
 #include "vm/flags.h"
 #include "vm/native_arguments.h"
+#include "vm/runtime_entry_list.h"
 #include "vm/tags.h"
 
 namespace dart {
 
 class Assembler;
 
 DECLARE_FLAG(bool, trace_runtime_calls);
 
 typedef void (*RuntimeFunction)(NativeArguments arguments);
 
-#define RUNTIME_ENTRY_LIST(V)                                                  \

[Florian Schneider, 2015/09/01 06:19:05]

Why move this to a separate file?

[rmacnak, 2015/09/01 17:26:54]

Breaking an include cycle (allocation, thread, runtime_entry).

[Florian Schneider, 2015/09/02 08:22:03]

I see - fine as a last resort if there is no way of breaking this cycle by
introducing forward declarations instead of including.

-  V(AllocateArray)                                                             \
-  V(AllocateContext)                                                           \
-  V(AllocateObject)                                                            \
-  V(BreakpointRuntimeHandler)                                                  \
-  V(SingleStepHandler)                                                         \
-  V(CloneContext)                                                              \
-  V(FixCallersTarget)                                                          \
-  V(FixAllocationStubTarget)                                                   \
-  V(InlineCacheMissHandlerOneArg)                                              \
-  V(InlineCacheMissHandlerTwoArgs)                                             \
-  V(InlineCacheMissHandlerThreeArgs)                                           \
-  V(StaticCallMissHandlerOneArg)                                               \
-  V(StaticCallMissHandlerTwoArgs)                                              \
-  V(Instanceof)                                                                \
-  V(TypeCheck)                                                                 \
-  V(BadTypeError)                                                              \
-  V(NonBoolTypeError)                                                          \
-  V(InstantiateType)                                                           \
-  V(InstantiateTypeArguments)                                                  \
-  V(InvokeClosureNoSuchMethod)                                                 \
-  V(InvokeNoSuchMethodDispatcher)                                              \
-  V(MegamorphicCacheMissHandler)                                               \
-  V(OptimizeInvokedFunction)                                                   \
-  V(TraceICCall)                                                               \
-  V(PatchStaticCall)                                                           \
-  V(ReThrow)                                                                   \
-  V(StackOverflow)                                                             \
-  V(Throw)                                                                     \
-  V(TraceFunctionEntry)                                                        \
-  V(TraceFunctionExit)                                                         \
-  V(DeoptimizeMaterialize)                                                     \
-  V(UpdateFieldCid)                                                            \
-  V(InitStaticField)                                                           \
-  V(GrowRegExpStack)                                                           \
-  V(CompileFunction)                                                           \
-
-#define LEAF_RUNTIME_ENTRY_LIST(V)                                             \
-  V(void, PrintStopMessage, const char*)                                       \
-  V(intptr_t, DeoptimizeCopyFrame, uword)                                      \
-  V(void, DeoptimizeFillFrame, uword)                                          \
-  V(void, StoreBufferBlockProcess, Thread*)                                    \
-  V(intptr_t, BigintCompare, RawBigint*, RawBigint*)                           \
-
-
 enum RuntimeFunctionId {
   kNoRuntimeFunctionId = -1,
 #define DECLARE_ENUM_VALUE(name) \
   k##name##Id,
   RUNTIME_ENTRY_LIST(DECLARE_ENUM_VALUE)
 #undef DECLARE_ENUM_VALUE
 
 #define DECLARE_LEAF_ENUM_VALUE(type, name, ...) \
   k##name##Id,
   LEAF_RUNTIME_ENTRY_LIST(DECLARE_LEAF_ENUM_VALUE)
@@ skipping 16 matching lines @@
     // Strip off const for registration.
     VMTag::RegisterRuntimeEntry(const_cast<RuntimeEntry*>(this));
   }
   ~RuntimeEntry() {}
 
   const char* name() const { return name_; }
   RuntimeFunction function() const { return function_; }
   intptr_t argument_count() const { return argument_count_; }
   bool is_leaf() const { return is_leaf_; }
   bool is_float() const { return is_float_; }
-  uword GetEntryPoint() const { return reinterpret_cast<uword>(function()); }
+  uword GetEntryPoint() const;
 
   // Generate code to call the runtime entry.
   void Call(Assembler* assembler, intptr_t argument_count) const;
 
   void set_next(const RuntimeEntry* next) { next_ = next; }
   const RuntimeEntry* next() const { return next_; }
 
   static inline uword AddressFromId(RuntimeFunctionId id);
   static inline RuntimeFunctionId RuntimeFunctionIdFromAddress(uword address);
 
@@ skipping 47 matching lines @@
   extern "C" type DLRT_##name(__VA_ARGS__);                                    \
   extern const RuntimeEntry k##name##RuntimeEntry(                             \
       "DLRT_"#name, reinterpret_cast<RuntimeFunction>(&DLRT_##name),           \
       argument_count, true, false);                                            \
   type DLRT_##name(__VA_ARGS__) {                                              \
     CHECK_STACK_ALIGNMENT;                                                     \
     NoSafepointScope no_safepoint_scope;                                       \
 
 #define END_LEAF_RUNTIME_ENTRY }
 
+// TODO(rmacnak): Fix alignment issue on simarm and simmips and use
+// DEFINE_LEAF_RUNTIME_ENTRY instead.
+#define DEFINE_RAW_LEAF_RUNTIME_ENTRY(name, argument_count, is_float, func)    \
+  extern const RuntimeEntry k##name##RuntimeEntry(                             \
+      "DFLRT_"#name, func, argument_count, true, is_float)                     \
+
 #define DECLARE_LEAF_RUNTIME_ENTRY(type, name, ...)                            \
   extern const RuntimeEntry k##name##RuntimeEntry;                             \
   extern "C" type DLRT_##name(__VA_ARGS__);                                    \
 
 
 // Declare all runtime functions here.
 RUNTIME_ENTRY_LIST(DECLARE_RUNTIME_ENTRY)
 LEAF_RUNTIME_ENTRY_LIST(DECLARE_LEAF_RUNTIME_ENTRY)
 
 
 // Declare all runtime functions here.
 RUNTIME_ENTRY_LIST(DECLARE_RUNTIME_ENTRY)
 LEAF_RUNTIME_ENTRY_LIST(DECLARE_LEAF_RUNTIME_ENTRY)
 
 
 uword RuntimeEntry::AddressFromId(RuntimeFunctionId id) {
     switch (id) {
 #define DEFINE_RUNTIME_CASE(name)                                              \
-    case k##name##Id: return reinterpret_cast<uword>(&DRT_##name);
+    case k##name##Id: return k##name##RuntimeEntry.GetEntryPoint();
     RUNTIME_ENTRY_LIST(DEFINE_RUNTIME_CASE)
 #undef DEFINE_RUNTIME_CASE
 
 #define DEFINE_LEAF_RUNTIME_CASE(type, name, ...)                              \
-    case k##name##Id: return reinterpret_cast<uword>(&DLRT_##name);
+    case k##name##Id: return k##name##RuntimeEntry.GetEntryPoint();
     LEAF_RUNTIME_ENTRY_LIST(DEFINE_LEAF_RUNTIME_CASE)
 #undef DEFINE_LEAF_RUNTIME_CASE
     default:
       break;
   }
   return 0;
 }
 
 
 RuntimeFunctionId RuntimeEntry::RuntimeFunctionIdFromAddress(uword address) {
 #define CHECK_RUNTIME_ADDRESS(name)                                            \
-  if (address == reinterpret_cast<uword>(&DRT_##name)) return k##name##Id;
+  if (address == k##name##RuntimeEntry.GetEntryPoint()) return k##name##Id;
   RUNTIME_ENTRY_LIST(CHECK_RUNTIME_ADDRESS)
 #undef CHECK_RUNTIME_ADDRESS
 
 #define CHECK_LEAF_RUNTIME_ADDRESS(type, name, ...)                            \
-  if (address == reinterpret_cast<uword>(&DLRT_##name)) return k##name##Id;
+  if (address == k##name##RuntimeEntry.GetEntryPoint()) return k##name##Id;
   LEAF_RUNTIME_ENTRY_LIST(CHECK_LEAF_RUNTIME_ADDRESS)
 #undef CHECK_LEAF_RUNTIME_ADDRESS
   return kNoRuntimeFunctionId;
 }
 
 }  // namespace dart
 
 #endif  // VM_RUNTIME_ENTRY_H_