OLD type

src/globals.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.
 
 #ifndef V8_GLOBALS_H_
 #define V8_GLOBALS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 235 matching lines @@
   STRONG_BIT = 1 << 1,
   LANGUAGE_END,
 
   // Shorthands for some common language modes.
   SLOPPY = 0,
   STRICT = STRICT_BIT,
   STRONG = STRICT_BIT | STRONG_BIT
 };
 
 
+enum AsmMode {
+  ASM_FUNCTION_BIT = 1 << 0,
+  ASM_MODULE_BIT = 1 << 1,
+  ASM_END,
+
+  ASM_NO = 0,
+  ASM_FUNCTION = ASM_FUNCTION_BIT,
+  ASM_MODULE = ASM_MODULE_BIT
+};
+
+
 inline std::ostream& operator<<(std::ostream& os, const LanguageMode& mode) {
   switch (mode) {
     case SLOPPY:
       return os << "sloppy";
     case STRICT:
       return os << "strict";
     case STRONG:
       return os << "strong";
     default:
       return os << "unknown";
@@ skipping 24 matching lines @@
 
 inline LanguageMode construct_language_mode(bool strict_bit, bool strong_bit) {
   int language_mode = 0;
   if (strict_bit) language_mode |= STRICT_BIT;
   if (strong_bit) language_mode |= STRONG_BIT;
   DCHECK(is_valid_language_mode(language_mode));
   return static_cast<LanguageMode>(language_mode);
 }
 
 
+inline bool is_valid_asm_mode(int asm_mode) {
+  return asm_mode == ASM_NO || asm_mode == ASM_FUNCTION ||
+         asm_mode == ASM_MODULE;
+}
+
+
+inline AsmMode construct_asm_mode(bool asm_function, bool asm_module) {
+  int asm_mode = 0;
+  if (asm_function) asm_mode |= ASM_FUNCTION_BIT;
+  if (asm_module) asm_mode |= ASM_MODULE_BIT;
+  DCHECK(is_valid_asm_mode(asm_mode));
+  return static_cast<AsmMode>(asm_mode);
+}
+
+
 inline ObjectStrength strength(LanguageMode language_mode) {
   return is_strong(language_mode) ? FIRM : WEAK;
 }
 
 
 // Mask for the sign bit in a smi.
 const intptr_t kSmiSignMask = kIntptrSignBit;
 
 const int kObjectAlignmentBits = kPointerSizeLog2;
 const intptr_t kObjectAlignment = 1 << kObjectAlignmentBits;
@@ skipping 660 matching lines @@
 inline FunctionKind WithObjectLiteralBit(FunctionKind kind) {
   kind = static_cast<FunctionKind>(kind | FunctionKind::kInObjectLiteral);
   DCHECK(IsValidFunctionKind(kind));
   return kind;
 }
 } }  // namespace v8::internal
 
 namespace i = v8::internal;
 
 #endif  // V8_GLOBALS_H_