Handle stack frames differently inside and on the boundary of wasm.

src/objects.h

Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index 724c4d0f593782250aaa845c6ec38108ddd4a2b3..eafa22576c880ad5db676b2b687e63fc27bb6dd0 100644
--- a/src/objects.h
+++ b/src/objects.h
@@ -4907,6 +4907,13 @@ class Code: public HeapObject {
     FAST
   };
 
+  // Types of wasm functions.
+  enum WasmFunctionType {

[titzer, 2016/03/03 22:48:21]

After having a look at this, I think it's actually cleaner to have separate
Code::Kind's for each of the different cases. It probably means that the code
kind is going to occupy another bit, but that saves this extra part of the enum.
It's less impact everywhere else, too.

[bradn, 2016/03/03 23:17:29]

Done.

And it has the added benefit of rendering the prior debate moot :-)

+    WASM_INNER_FUNCTION,
+    WASM_TO_JS,
+    JS_TO_WASM,
+  };
+
   static const int kPrologueOffsetNotSet = -1;
 
 #ifdef ENABLE_DISASSEMBLER
@@ -4984,6 +4991,8 @@ class Code: public HeapObject {
 
   inline StubType type();  // Only valid for monomorphic IC stubs.
 
+  inline WasmFunctionType wasm_function_type();  // Only valid for wasm.
+
   // Testers for IC stub kinds.
   inline bool is_inline_cache_stub();
   inline bool is_debug_stub();
@@ -5140,7 +5149,11 @@ class Code: public HeapObject {
   static inline Flags ComputeFlags(
       Kind kind, InlineCacheState ic_state = UNINITIALIZED,
       ExtraICState extra_ic_state = kNoExtraICState, StubType type = NORMAL,
-      CacheHolderFlag holder = kCacheOnReceiver);
+      CacheHolderFlag holder = kCacheOnReceiver,
+      WasmFunctionType = WASM_INNER_FUNCTION);
+
+  static inline Flags ComputeWasmFlags(Kind kind,
+                                       WasmFunctionType = WASM_INNER_FUNCTION);
 
   static inline Flags ComputeMonomorphicFlags(
       Kind kind, ExtraICState extra_ic_state = kNoExtraICState,
@@ -5152,6 +5165,7 @@ class Code: public HeapObject {
 
   static inline InlineCacheState ExtractICStateFromFlags(Flags flags);
   static inline StubType ExtractTypeFromFlags(Flags flags);
+  static inline WasmFunctionType ExtractWasmFunctionTypeFromFlags(Flags flags);
   static inline CacheHolderFlag ExtractCacheHolderFromFlags(Flags flags);
   static inline Kind ExtractKindFromFlags(Flags flags);
   static inline ExtraICState ExtractExtraICStateFromFlags(Flags flags);
@@ -5323,8 +5337,10 @@ class Code: public HeapObject {
   class TypeField : public BitField<StubType, 3, 1> {};
   class CacheHolderField : public BitField<CacheHolderFlag, 4, 2> {};
   class KindField : public BitField<Kind, 6, 5> {};
-  class ExtraICStateField: public BitField<ExtraICState, 11,
-      PlatformSmiTagging::kSmiValueSize - 11 + 1> {};  // NOLINT
+  class WasmFunctionTypeField : public BitField<WasmFunctionType, 11, 2> {};
+  class ExtraICStateField
+      : public BitField<ExtraICState, 13, PlatformSmiTagging::kSmiValueSize -
+                                              13 + 1> {};  // NOLINT
 
   // KindSpecificFlags1 layout (STUB and OPTIMIZED_FUNCTION)
   static const int kStackSlotsFirstBit = 0;