[V8][asm.js] Adds support to global const variables.

src/asmjs/asm-typer.h

 // Copyright 2016 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.
 
 #ifndef SRC_ASMJS_ASM_TYPER_H_
 #define SRC_ASMJS_ASM_TYPER_H_
 
 #include <cstdint>
 #include <string>
 #include <unordered_set>
@@ skipping 84 matching lines @@
 
  private:
   friend class v8::internal::wasm::AsmTyperHarnessBuilder;
 
   class VariableInfo : public ZoneObject {
    public:
     enum Mutability {
       kInvalidMutability,
       kLocal,
       kMutableGlobal,
+      // *VIOLATION* We support const variables in asm.js, as per the
+      //
+      // https://discourse.wicg.io/t/allow-const-global-variables/684
+      //
+      // Global const variables are treated as if they were numeric literals,
+      // and can be used anywhere a literal can be used.
+      kConstGlobal,
       kImmutableGlobal,
     };
 
     explicit VariableInfo(AsmType* t) : type_(t) {}
 
     VariableInfo* Clone(Zone* zone) const;
 
     bool IsMutable() const {
       return mutability_ == kLocal || mutability_ == kMutableGlobal;
     }
 
     bool IsGlobal() const {
-      return mutability_ == kImmutableGlobal || mutability_ == kMutableGlobal;
+      return mutability_ == kImmutableGlobal || mutability_ == kConstGlobal ||
+             mutability_ == kMutableGlobal;
     }
 
     bool IsStdlib() const { return standard_member_ == kStdlib; }
     bool IsFFI() const { return standard_member_ == kFFI; }
     bool IsHeap() const { return standard_member_ == kHeap; }
 
     void MarkDefined() { missing_definition_ = false; }
     void FirstForwardUseIs(VariableProxy* var);
 
     StandardMember standard_member() const { return standard_member_; }
@@ skipping 172 matching lines @@
   bool IsCallToFround(Call* call);
   AsmType* ValidateFloatCoercion(Call* call);
 
   // 5.1 ParameterTypeAnnotations
   AsmType* ParameterTypeAnnotations(Variable* parameter,
                                     Expression* annotation);
   // 5.2 ReturnTypeAnnotations
   AsmType* ReturnTypeAnnotations(ReturnStatement* statement);
   // 5.4 VariableTypeAnnotations
   // 5.5 GlobalVariableTypeAnnotations
-  AsmType* VariableTypeAnnotations(Expression* initializer,
-                                   bool global = false);
+  AsmType* VariableTypeAnnotations(
+      Expression* initializer,
+      VariableInfo::Mutability global = VariableInfo::kLocal);
   AsmType* ImportExpression(Property* import);
   AsmType* NewHeapView(CallNew* new_heap_view);
 
   Isolate* isolate_;
   Zone* zone_;
   Script* script_;
   FunctionLiteral* root_;
   bool in_function_ = false;
 
   AsmType* return_type_ = nullptr;
@@ skipping 22 matching lines @@
   StdlibSet stdlib_uses_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AsmTyper);
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // SRC_ASMJS_ASM_TYPER_H_