Rename TypeRecording...Stub into ...Stub.

src/type-info.cc

 // Copyright 2011 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 240 matching lines @@
   CompareIC::State state = static_cast<CompareIC::State>(code->compare_state());
   return state == CompareIC::SYMBOLS;
 }
 
 
 TypeInfo TypeFeedbackOracle::UnaryType(UnaryOperation* expr) {
   Handle<Object> object = GetInfo(expr->id());
   TypeInfo unknown = TypeInfo::Unknown();
   if (!object->IsCode()) return unknown;
   Handle<Code> code = Handle<Code>::cast(object);
-  ASSERT(code->is_type_recording_unary_op_stub());
-  TRUnaryOpIC::TypeInfo type = static_cast<TRUnaryOpIC::TypeInfo>(
-      code->type_recording_unary_op_type());
+  ASSERT(code->is_unary_op_stub());
+  UnaryOpIC::TypeInfo type = static_cast<UnaryOpIC::TypeInfo>(
+      code->unary_op_type());
   switch (type) {
-    case TRUnaryOpIC::SMI:
+    case UnaryOpIC::SMI:
       return TypeInfo::Smi();
-    case TRUnaryOpIC::HEAP_NUMBER:
+    case UnaryOpIC::HEAP_NUMBER:
       return TypeInfo::Double();
     default:
       return unknown;
   }
 }
 
 
 TypeInfo TypeFeedbackOracle::BinaryType(BinaryOperation* expr) {
   Handle<Object> object = GetInfo(expr->id());
   TypeInfo unknown = TypeInfo::Unknown();
   if (!object->IsCode()) return unknown;
   Handle<Code> code = Handle<Code>::cast(object);
-  if (code->is_type_recording_binary_op_stub()) {
-    TRBinaryOpIC::TypeInfo type = static_cast<TRBinaryOpIC::TypeInfo>(
-        code->type_recording_binary_op_type());
-    TRBinaryOpIC::TypeInfo result_type = static_cast<TRBinaryOpIC::TypeInfo>(
-        code->type_recording_binary_op_result_type());
+  if (code->is_binary_op_stub()) {
+    BinaryOpIC::TypeInfo type = static_cast<BinaryOpIC::TypeInfo>(
+        code->binary_op_type());
+    BinaryOpIC::TypeInfo result_type = static_cast<BinaryOpIC::TypeInfo>(
+        code->binary_op_result_type());
 
     switch (type) {
-      case TRBinaryOpIC::UNINITIALIZED:
+      case BinaryOpIC::UNINITIALIZED:
         // Uninitialized means never executed.
         // TODO(fschneider): Introduce a separate value for never-executed ICs
         return unknown;
-      case TRBinaryOpIC::SMI:
+      case BinaryOpIC::SMI:
         switch (result_type) {
-          case TRBinaryOpIC::UNINITIALIZED:
-          case TRBinaryOpIC::SMI:
+          case BinaryOpIC::UNINITIALIZED:
+          case BinaryOpIC::SMI:
             return TypeInfo::Smi();
-          case TRBinaryOpIC::INT32:
+          case BinaryOpIC::INT32:
             return TypeInfo::Integer32();
-          case TRBinaryOpIC::HEAP_NUMBER:
+          case BinaryOpIC::HEAP_NUMBER:
             return TypeInfo::Double();
           default:
             return unknown;
         }
-      case TRBinaryOpIC::INT32:
+      case BinaryOpIC::INT32:
         if (expr->op() == Token::DIV ||
-            result_type == TRBinaryOpIC::HEAP_NUMBER) {
+            result_type == BinaryOpIC::HEAP_NUMBER) {
           return TypeInfo::Double();
         }
         return TypeInfo::Integer32();
-      case TRBinaryOpIC::HEAP_NUMBER:
+      case BinaryOpIC::HEAP_NUMBER:
         return TypeInfo::Double();
-      case TRBinaryOpIC::BOTH_STRING:
+      case BinaryOpIC::BOTH_STRING:
         return TypeInfo::String();
-      case TRBinaryOpIC::STRING:
-      case TRBinaryOpIC::GENERIC:
+      case BinaryOpIC::STRING:
+      case BinaryOpIC::GENERIC:
         return unknown;
      default:
         return unknown;
     }
   }
   return unknown;
 }
 
 
 TypeInfo TypeFeedbackOracle::SwitchType(CaseClause* clause) {
@@ skipping 21 matching lines @@
       return unknown;
   }
 }
 
 
 TypeInfo TypeFeedbackOracle::IncrementType(CountOperation* expr) {
   Handle<Object> object = GetInfo(expr->CountId());
   TypeInfo unknown = TypeInfo::Unknown();
   if (!object->IsCode()) return unknown;
   Handle<Code> code = Handle<Code>::cast(object);
-  if (!code->is_type_recording_binary_op_stub()) return unknown;
+  if (!code->is_binary_op_stub()) return unknown;
 
-  TRBinaryOpIC::TypeInfo type = static_cast<TRBinaryOpIC::TypeInfo>(
-      code->type_recording_binary_op_type());
+  BinaryOpIC::TypeInfo type = static_cast<BinaryOpIC::TypeInfo>(
+      code->binary_op_type());
   switch (type) {
-    case TRBinaryOpIC::UNINITIALIZED:
-    case TRBinaryOpIC::SMI:
+    case BinaryOpIC::UNINITIALIZED:
+    case BinaryOpIC::SMI:
       return TypeInfo::Smi();
-    case TRBinaryOpIC::INT32:
+    case BinaryOpIC::INT32:
       return TypeInfo::Integer32();
-    case TRBinaryOpIC::HEAP_NUMBER:
+    case BinaryOpIC::HEAP_NUMBER:
       return TypeInfo::Double();
-    case TRBinaryOpIC::BOTH_STRING:
-    case TRBinaryOpIC::STRING:
-    case TRBinaryOpIC::GENERIC:
+    case BinaryOpIC::BOTH_STRING:
+    case BinaryOpIC::STRING:
+    case BinaryOpIC::GENERIC:
       return unknown;
     default:
       return unknown;
   }
   UNREACHABLE();
   return unknown;
 }
 
 
 ZoneMapList* TypeFeedbackOracle::CollectReceiverTypes(unsigned ast_id,
@@ skipping 53 matching lines @@
   ASSERT(ast_ids.length() == length);
   for (int i = 0; i < length; i++) {
     AssertNoAllocation no_allocation;
     RelocInfo info(code->instruction_start() + code_positions[i],
                    RelocInfo::CODE_TARGET, 0);
     Code* target = Code::GetCodeFromTargetAddress(info.target_address());
     unsigned id = ast_ids[i];
     InlineCacheState state = target->ic_state();
     Code::Kind kind = target->kind();
 
-    if (kind == Code::TYPE_RECORDING_BINARY_OP_IC ||
-        kind == Code::TYPE_RECORDING_UNARY_OP_IC ||
+    if (kind == Code::BINARY_OP_IC ||
+        kind == Code::UNARY_OP_IC ||
         kind == Code::COMPARE_IC) {
       SetInfo(id, target);
     } else if (state == MONOMORPHIC) {
       if (kind == Code::KEYED_LOAD_IC ||
           kind == Code::KEYED_STORE_IC) {
         SetInfo(id, target);
       } else if (kind != Code::CALL_IC ||
                  target->check_type() == RECEIVER_MAP_CHECK) {
         Map* map = target->FindFirstMap();
         if (map == NULL) {
@@ skipping 21 matching lines @@
                                     List<unsigned>* ast_ids) {
   AssertNoAllocation no_allocation;
   int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET_WITH_ID);
   for (RelocIterator it(code, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     ASSERT(RelocInfo::IsCodeTarget(info->rmode()));
     Code* target = Code::GetCodeFromTargetAddress(info->target_address());
     if (target->is_inline_cache_stub()) {
       InlineCacheState state = target->ic_state();
       Code::Kind kind = target->kind();
-      if (kind == Code::TYPE_RECORDING_BINARY_OP_IC) {
-        if (target->type_recording_binary_op_type() ==
-            TRBinaryOpIC::GENERIC) {
+      if (kind == Code::BINARY_OP_IC) {
+        if (target->binary_op_type() ==
+            BinaryOpIC::GENERIC) {
           continue;
         }
       } else if (kind == Code::COMPARE_IC) {
         if (target->compare_state() == CompareIC::GENERIC) continue;
       } else {
         if (state != MONOMORPHIC && state != MEGAMORPHIC) continue;
       }
       code_positions->Add(
           static_cast<int>(info->pc() - code->instruction_start()));
       ASSERT(ast_ids->length() == 0 ||
              (*ast_ids)[ast_ids->length()-1] !=
              static_cast<unsigned>(info->data()));
       ast_ids->Add(static_cast<unsigned>(info->data()));
     }
   }
 }
 
 } }  // namespace v8::internal