WIP Atomics

src/compiler/typer.cc

 // Copyright 2014 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.
 
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/node-properties.h"
@@ skipping 13 matching lines @@
   V(Uint32)             \
   V(Float32)            \
   V(Float64)
 
 enum LazyCachedType {
   kNumberFunc0,
   kNumberFunc1,
   kNumberFunc2,
   kImulFunc,
   kClz32Func,
+  kAtomicsLoadFunc,
   kArrayBufferFunc,
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   k##Type, k##Type##Array, k##Type##ArrayFunc,
   TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
       kNumLazyCachedTypes
 };
 
 
 // Constructs and caches types lazily.
@@ skipping 39 matching lines @@
       case kNumberFunc1:
         return Type::Function(Type::Number(), Type::Number(), zone());
       case kNumberFunc2:
         return Type::Function(Type::Number(), Type::Number(), Type::Number(),
                               zone());
       case kImulFunc:
         return Type::Function(Type::Signed32(), Type::Integral32(),
                               Type::Integral32(), zone());
       case kClz32Func:
         return Type::Function(CreateRange(0, 32), Type::Number(), zone());
+      case kAtomicsLoadFunc:
+        return Type::Function(
+            Type::Union(Type::Number(), Type::Undefined(), zone()),
+            Type::Object(zone()), Type::Unsigned32(), zone());
       case kArrayBufferFunc:
         return Type::Function(Type::Object(zone()), Type::Unsigned32(), zone());
 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
   case k##Type##Array:                                  \
     return CreateArray(Get(k##Type));                   \
   case k##Type##ArrayFunc:                              \
     return CreateArrayFunction(Get(k##Type##Array));
         TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
       case kNumLazyCachedTypes:
@@ skipping 1704 matching lines @@
   UNREACHABLE();
   return Bounds();
 }
 
 
 Bounds Typer::Visitor::TypeLoadElement(Node* node) {
   return Bounds(ElementAccessOf(node->op()).type);
 }
 
 
+Bounds Typer::Visitor::TypeLoadElementAtomic(Node* node) {
+  return Bounds(ElementAccessOf(node->op()).type);
+}
+
+
 Bounds Typer::Visitor::TypeStoreField(Node* node) {
   UNREACHABLE();
   return Bounds();
 }
 
 
 Bounds Typer::Visitor::TypeStoreBuffer(Node* node) {
   UNREACHABLE();
   return Bounds();
 }
@@ skipping 15 matching lines @@
 }
 
 
 // Machine operators.
 
 Bounds Typer::Visitor::TypeLoad(Node* node) {
   return Bounds::Unbounded(zone());
 }
 
 
+Bounds Typer::Visitor::TypeLoadAtomic(Node* node) {
+  return Bounds::Unbounded(zone());
+}
+
+
 Bounds Typer::Visitor::TypeStore(Node* node) {
   UNREACHABLE();
   return Bounds();
 }
 
 
 Bounds Typer::Visitor::TypeWord32And(Node* node) {
   return Bounds(Type::Integral32());
 }
 
@@ skipping 463 matching lines @@
         // Binary math functions.
         case kMathAtan2:
         case kMathPow:
         case kMathMax:
         case kMathMin:
           return typer_->cache_->Get(kNumberFunc2);
         case kMathImul:
           return typer_->cache_->Get(kImulFunc);
         case kMathClz32:
           return typer_->cache_->Get(kClz32Func);
+        case kAtomicsLoad:
+          return typer_->cache_->Get(kAtomicsLoadFunc);
         default:
           break;
       }
     } else if (JSFunction::cast(*value)->IsBuiltin() && !context().is_null()) {
       Handle<Context> native =
           handle(context().ToHandleChecked()->native_context(), isolate());
       if (*value == native->array_buffer_fun()) {
         return typer_->cache_->Get(kArrayBufferFunc);
       } else if (*value == native->int8_array_fun()) {
         return typer_->cache_->Get(kInt8ArrayFunc);
@@ skipping 21 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8