Retry "Templatise type representation" after making clang happy

src/ic.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 979 matching lines @@
   }
 
   Handle<Code> ic = isolate()->stub_cache()->ComputePolymorphicIC(
       &types, &handlers, number_of_valid_types, name, extra_ic_state());
   set_target(*ic);
   return true;
 }
 
 
 Handle<Type> IC::CurrentTypeOf(Handle<Object> object, Isolate* isolate) {
-  Type* type = object->IsJSGlobalObject()
-      ? Type::Constant(Handle<JSGlobalObject>::cast(object))
-      : Type::OfCurrently(object);
-  return handle(type, isolate);
+  return object->IsJSGlobalObject()
+      ? Type::Constant(Handle<JSGlobalObject>::cast(object), isolate)
+      : Type::OfCurrently(object, isolate);
 }
 
 
 Handle<Map> IC::TypeToMap(Type* type, Isolate* isolate) {
   if (type->Is(Type::Number())) return isolate->factory()->heap_number_map();
   if (type->Is(Type::Boolean())) return isolate->factory()->oddball_map();
   if (type->IsConstant()) {
     return handle(Handle<JSGlobalObject>::cast(type->AsConstant())->map());
   }
   ASSERT(type->IsClass());
   return type->AsClass();
 }
 
 
-Type* IC::MapToType(Handle<Map> map) {
-  if (map->instance_type() == HEAP_NUMBER_TYPE) return Type::Number();
+Handle<Type> IC::MapToType(Handle<Map> map) {
+  Isolate* isolate = map->GetIsolate();
+  if (map->instance_type() == HEAP_NUMBER_TYPE) return Type::Number(isolate);
   // The only oddballs that can be recorded in ICs are booleans.
-  if (map->instance_type() == ODDBALL_TYPE) return Type::Boolean();
-  return Type::Class(map);
+  if (map->instance_type() == ODDBALL_TYPE) return Type::Boolean(isolate);
+  return Type::Class(map, isolate);
 }
 
 
 void IC::UpdateMonomorphicIC(Handle<Type> type,
                              Handle<Code> handler,
                              Handle<String> name) {
   if (!handler->is_handler()) return set_target(*handler);
   Handle<Code> ic = isolate()->stub_cache()->ComputeMonomorphicIC(
       name, type, handler, extra_ic_state());
   set_target(*ic);
 }
 
 
 void IC::CopyICToMegamorphicCache(Handle<String> name) {
   TypeHandleList types;
   CodeHandleList handlers;
   target()->FindAllTypes(&types);
   if (!target()->FindHandlers(&handlers, types.length())) return;
   for (int i = 0; i < types.length(); i++) {
     UpdateMegamorphicCache(*types.at(i), *name, *handlers.at(i));
   }
 }
 
 
-bool IC::IsTransitionOfMonomorphicTarget(Type* type) {
+bool IC::IsTransitionOfMonomorphicTarget(Handle<Type> type) {
   if (!type->IsClass()) return false;
   Map* receiver_map = *type->AsClass();
   Map* current_map = target()->FindFirstMap();
   ElementsKind receiver_elements_kind = receiver_map->elements_kind();
   bool more_general_transition =
       IsMoreGeneralElementsKindTransition(
         current_map->elements_kind(), receiver_elements_kind);
   Map* transitioned_map = more_general_transition
       ? current_map->LookupElementsTransitionMap(receiver_elements_kind)
       : NULL;
@@ skipping 11 matching lines @@
     case MONOMORPHIC_PROTOTYPE_FAILURE:
       UpdateMonomorphicIC(type, code, name);
       break;
     case MONOMORPHIC: {
       // For now, call stubs are allowed to rewrite to the same stub. This
       // happens e.g., when the field does not contain a function.
       ASSERT(target()->is_call_stub() ||
              target()->is_keyed_call_stub() ||
              !target().is_identical_to(code));
       Code* old_handler = target()->FindFirstHandler();
-      if (old_handler == *code && IsTransitionOfMonomorphicTarget(*type)) {
+      if (old_handler == *code && IsTransitionOfMonomorphicTarget(type)) {
         UpdateMonomorphicIC(type, code, name);
         break;
       }
       // Fall through.
     }
     case POLYMORPHIC:
       if (!target()->is_keyed_stub()) {
         if (UpdatePolymorphicIC(type, name, code)) break;
         CopyICToMegamorphicCache(name);
       }
@@ skipping 1523 matching lines @@
   GENERATE(Token::MOD, SMI, 2048, SMI, NO_OVERWRITE);
 #undef GENERATE
 }
 
 
 Handle<Type> BinaryOpIC::State::GetResultType(Isolate* isolate) const {
   Kind result_kind = result_kind_;
   if (HasSideEffects()) {
     result_kind = NONE;
   } else if (result_kind == GENERIC && op_ == Token::ADD) {
-    return handle(Type::Union(handle(Type::Number(), isolate),
-                              handle(Type::String(), isolate)), isolate);
+    return Type::Union(Type::Number(isolate), Type::String(isolate), isolate);
   } else if (result_kind == NUMBER && op_ == Token::SHR) {
-    return handle(Type::Unsigned32(), isolate);
+    return Type::Unsigned32(isolate);
   }
   ASSERT_NE(GENERIC, result_kind);
   return KindToType(result_kind, isolate);
 }
 
 
 void BinaryOpIC::State::Print(StringStream* stream) const {
   stream->Add("(%s", Token::Name(op_));
   if (mode_ == OVERWRITE_LEFT) stream->Add("_ReuseLeft");
   else if (mode_ == OVERWRITE_RIGHT) stream->Add("_ReuseRight");
@@ skipping 114 matching lines @@
     case STRING: return "String";
     case GENERIC: return "Generic";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 // static
 Handle<Type> BinaryOpIC::State::KindToType(Kind kind, Isolate* isolate) {
-  Type* type = NULL;
   switch (kind) {
-    case NONE: type = Type::None(); break;
-    case SMI: type = Type::Smi(); break;
-    case INT32: type = Type::Signed32(); break;
-    case NUMBER: type = Type::Number(); break;
-    case STRING: type = Type::String(); break;
-    case GENERIC: type = Type::Any(); break;
+    case NONE: return Type::None(isolate);
+    case SMI: return Type::Smi(isolate);
+    case INT32: return Type::Signed32(isolate);
+    case NUMBER: return Type::Number(isolate);
+    case STRING: return Type::String(isolate);
+    case GENERIC: return Type::Any(isolate);
   }
-  return handle(type, isolate);
+  UNREACHABLE();
+  return Handle<Type>();
 }
 
 
 MaybeObject* BinaryOpIC::Transition(Handle<AllocationSite> allocation_site,
                                     Handle<Object> left,
                                     Handle<Object> right) {
   State state(target()->extended_extra_ic_state());
 
   // Compute the actual result using the builtin for the binary operation.
   Object* builtin = isolate()->js_builtins_object()->javascript_builtin(
@@ skipping 114 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 Handle<Type> CompareIC::StateToType(
     Isolate* isolate,
     CompareIC::State state,
     Handle<Map> map) {
   switch (state) {
-    case CompareIC::UNINITIALIZED:
-      return handle(Type::None(), isolate);
-    case CompareIC::SMI:
-      return handle(Type::Smi(), isolate);
-    case CompareIC::NUMBER:
-      return handle(Type::Number(), isolate);
-    case CompareIC::STRING:
-      return handle(Type::String(), isolate);
+    case CompareIC::UNINITIALIZED: return Type::None(isolate);
+    case CompareIC::SMI: return Type::Smi(isolate);
+    case CompareIC::NUMBER: return Type::Number(isolate);
+    case CompareIC::STRING: return Type::String(isolate);
     case CompareIC::INTERNALIZED_STRING:
-      return handle(Type::InternalizedString(), isolate);
-    case CompareIC::UNIQUE_NAME:
-      return handle(Type::UniqueName(), isolate);
-    case CompareIC::OBJECT:
-      return handle(Type::Receiver(), isolate);
+      return Type::InternalizedString(isolate);
+    case CompareIC::UNIQUE_NAME: return Type::UniqueName(isolate);
+    case CompareIC::OBJECT: return Type::Receiver(isolate);
     case CompareIC::KNOWN_OBJECT:
-      return handle(
-          map.is_null() ? Type::Receiver() : Type::Class(map), isolate);
-    case CompareIC::GENERIC:
-      return handle(Type::Any(), isolate);
+      return map.is_null()
+          ? Type::Receiver(isolate) : Type::Class(map, isolate);
+    case CompareIC::GENERIC: return Type::Any(isolate);
   }
   UNREACHABLE();
   return Handle<Type>();
 }
 
 
 void CompareIC::StubInfoToType(int stub_minor_key,
                                Handle<Type>* left_type,
                                Handle<Type>* right_type,
                                Handle<Type>* overall_type,
@@ skipping 295 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal