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

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 4716 matching lines @@
 ExtraICState Code::extra_ic_state() {
   DCHECK(is_inline_cache_stub() || ic_state() == DEBUG_STUB);
   return ExtractExtraICStateFromFlags(flags());
 }
 
 
 Code::StubType Code::type() {
   return ExtractTypeFromFlags(flags());
 }
 
+Code::WasmFunctionType Code::wasm_function_type() {
+  return ExtractWasmFunctionTypeFromFlags(flags());
+}
 
 // For initialization.
 void Code::set_raw_kind_specific_flags1(int value) {
   WRITE_INT_FIELD(this, kKindSpecificFlags1Offset, value);
 }
 
 
 void Code::set_raw_kind_specific_flags2(int value) {
   WRITE_INT_FIELD(this, kKindSpecificFlags2Offset, value);
 }
@@ skipping 261 matching lines @@
   Address constant_pool = NULL;
   if (FLAG_enable_embedded_constant_pool) {
     int offset = constant_pool_offset();
     if (offset < instruction_size()) {
       constant_pool = FIELD_ADDR(this, kHeaderSize + offset);
     }
   }
   return constant_pool;
 }
 
-
 Code::Flags Code::ComputeFlags(Kind kind, InlineCacheState ic_state,
                                ExtraICState extra_ic_state, StubType type,
-                               CacheHolderFlag holder) {
+                               CacheHolderFlag holder,
+                               WasmFunctionType wasm_type) {
   // Compute the bit mask.
-  unsigned int bits = KindField::encode(kind)
-      | ICStateField::encode(ic_state)
-      | TypeField::encode(type)
-      | ExtraICStateField::encode(extra_ic_state)
-      | CacheHolderField::encode(holder);
+  unsigned int bits = KindField::encode(kind) | ICStateField::encode(ic_state) |
+                      TypeField::encode(type) |
+                      ExtraICStateField::encode(extra_ic_state) |
+                      WasmFunctionTypeField::encode(wasm_type) |
+                      CacheHolderField::encode(holder);
   return static_cast<Flags>(bits);
 }
 
+Code::Flags Code::ComputeWasmFlags(Kind kind, WasmFunctionType wasm_type) {
+  return ComputeFlags(kind, UNINITIALIZED, kNoExtraICState, NORMAL,
+                      kCacheOnReceiver, wasm_type);
+}
 
 Code::Flags Code::ComputeMonomorphicFlags(Kind kind,
                                           ExtraICState extra_ic_state,
                                           CacheHolderFlag holder,
                                           StubType type) {
   return ComputeFlags(kind, MONOMORPHIC, extra_ic_state, type, holder);
 }
 
 
 Code::Flags Code::ComputeHandlerFlags(Kind handler_kind, StubType type,
@@ skipping 14 matching lines @@
 
 ExtraICState Code::ExtractExtraICStateFromFlags(Flags flags) {
   return ExtraICStateField::decode(flags);
 }
 
 
 Code::StubType Code::ExtractTypeFromFlags(Flags flags) {
   return TypeField::decode(flags);
 }
 
+Code::WasmFunctionType Code::ExtractWasmFunctionTypeFromFlags(Flags flags) {
+  return WasmFunctionTypeField::decode(flags);
+}
 
 CacheHolderFlag Code::ExtractCacheHolderFromFlags(Flags flags) {
   return CacheHolderField::decode(flags);
 }
 
 
 Code::Flags Code::RemoveTypeFromFlags(Flags flags) {
   int bits = flags & ~TypeField::kMask;
   return static_cast<Flags>(bits);
 }
@@ skipping 2675 matching lines @@
 #undef WRITE_INT64_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_INL_H_