Refactor the enum RelocMode changing the naming scheme from lower case to...

src/objects.cc

 // Copyright 2006-2008 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 3986 matching lines @@
   IteratePointer(v, kDebugInfoOffset);
 }
 
 
 void ObjectVisitor::BeginCodeIteration(Code* code) {
   ASSERT(code->ic_flag() == Code::IC_TARGET_IS_OBJECT);
 }
 
 
 void ObjectVisitor::VisitCodeTarget(RelocInfo* rinfo) {
-  ASSERT(is_code_target(rinfo->rmode()));
+  ASSERT(RelocInfo::IsCodeTarget(rinfo->rmode()));
   VisitPointer(rinfo->target_object_address());
 }
 
 
 void ObjectVisitor::VisitDebugTarget(RelocInfo* rinfo) {
-  ASSERT(is_js_return(rinfo->rmode()) && rinfo->is_call_instruction());
+  ASSERT(RelocInfo::IsJSReturn(rinfo->rmode()) && rinfo->is_call_instruction());
   VisitPointer(rinfo->call_object_address());
 }
 
 
 // Convert relocatable targets from address to code object address. This is
 // mainly IC call targets but for debugging straight-line code can be replaced
 // with a call instruction which also has to be relocated.
 void Code::ConvertICTargetsFromAddressToObject() {
   ASSERT(ic_flag() == IC_TARGET_IS_ADDRESS);
 
   for (RelocIterator it(this, RelocInfo::kCodeTargetMask);
        !it.done(); it.next()) {
     Address ic_addr = it.rinfo()->target_address();
     ASSERT(ic_addr != NULL);
     HeapObject* code = HeapObject::FromAddress(ic_addr - Code::kHeaderSize);
     ASSERT(code->IsHeapObject());
     it.rinfo()->set_target_object(code);
   }
 
   if (Debug::has_break_points()) {
-    for (RelocIterator it(this, RelocMask(js_return)); !it.done(); it.next()) {
+    for (RelocIterator it(this, RelocInfo::ModeMask(RelocInfo::JS_RETURN));
+         !it.done();
+         it.next()) {
       if (it.rinfo()->is_call_instruction()) {
         Address addr = it.rinfo()->call_address();
         ASSERT(addr != NULL);
         HeapObject* code = HeapObject::FromAddress(addr - Code::kHeaderSize);
         ASSERT(code->IsHeapObject());
         it.rinfo()->set_call_object(code);
       }
     }
   }
   set_ic_flag(IC_TARGET_IS_OBJECT);
 }
 
 
 void Code::CodeIterateBody(ObjectVisitor* v) {
   v->BeginCodeIteration(this);
 
   int mode_mask = RelocInfo::kCodeTargetMask |
-                  RelocMask(embedded_object) |
-                  RelocMask(external_reference) |
-                  RelocMask(js_return) |
-                  RelocMask(runtime_entry);
+                  RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
+                  RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
+                  RelocInfo::ModeMask(RelocInfo::JS_RETURN) |
+                  RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);
 
   for (RelocIterator it(this, mode_mask); !it.done(); it.next()) {
-    RelocMode rmode = it.rinfo()->rmode();
-    if (rmode == embedded_object) {
+    RelocInfo::Mode rmode = it.rinfo()->rmode();
+    if (rmode == RelocInfo::EMBEDDED_OBJECT) {
       v->VisitPointer(it.rinfo()->target_object_address());
-    } else if (is_code_target(rmode)) {
+    } else if (RelocInfo::IsCodeTarget(rmode)) {
       v->VisitCodeTarget(it.rinfo());
-    } else if (rmode == external_reference) {
+    } else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
       v->VisitExternalReference(it.rinfo()->target_reference_address());
     } else if (Debug::has_break_points() &&
-               is_js_return(rmode) && it.rinfo()->is_call_instruction()) {
+               RelocInfo::IsJSReturn(rmode) &&
+               it.rinfo()->is_call_instruction()) {
       v->VisitDebugTarget(it.rinfo());
-    } else if (rmode == runtime_entry) {
+    } else if (rmode == RelocInfo::RUNTIME_ENTRY) {
       v->VisitRuntimeEntry(it.rinfo());
     }
   }
 
   ScopeInfo<>::IterateScopeInfo(this, v);
 
   v->EndCodeIteration(this);
 }
 
 
 void Code::ConvertICTargetsFromObjectToAddress() {
   ASSERT(ic_flag() == IC_TARGET_IS_OBJECT);
 
   for (RelocIterator it(this, RelocInfo::kCodeTargetMask);
        !it.done(); it.next()) {
     // We cannot use the safe cast (Code::cast) here, because we may be in
     // the middle of relocating old objects during GC and the map pointer in
     // the code object may be mangled
     Code* code = reinterpret_cast<Code*>(it.rinfo()->target_object());
     ASSERT((code != NULL) && code->IsHeapObject());
     it.rinfo()->set_target_address(code->instruction_start());
   }
 
   if (Debug::has_break_points()) {
-    for (RelocIterator it(this, RelocMask(js_return)); !it.done(); it.next()) {
+    for (RelocIterator it(this, RelocInfo::ModeMask(RelocInfo::JS_RETURN));
+         !it.done();
+         it.next()) {
       if (it.rinfo()->is_call_instruction()) {
         Code* code = reinterpret_cast<Code*>(it.rinfo()->call_object());
         ASSERT((code != NULL) && code->IsHeapObject());
         it.rinfo()->set_call_address(code->instruction_start());
       }
     }
   }
   set_ic_flag(IC_TARGET_IS_ADDRESS);
 }
 
@@ skipping 19 matching lines @@
   }
 
   // copy reloc info
   memmove(relocation_start(),
           desc.buffer + desc.buffer_size - desc.reloc_size,
           desc.reloc_size);
 
   // unbox handles and relocate
   int delta = instruction_start() - desc.buffer;
   int mode_mask = RelocInfo::kCodeTargetMask |
-                  RelocMask(embedded_object) |
+                  RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
                   RelocInfo::kApplyMask;
   for (RelocIterator it(this, mode_mask); !it.done(); it.next()) {
-    RelocMode mode = it.rinfo()->rmode();
-    if (mode == embedded_object) {
+    RelocInfo::Mode mode = it.rinfo()->rmode();
+    if (mode == RelocInfo::EMBEDDED_OBJECT) {
       Object** p = reinterpret_cast<Object**>(it.rinfo()->target_object());
       it.rinfo()->set_target_object(*p);
-    } else if (is_code_target(mode)) {
+    } else if (RelocInfo::IsCodeTarget(mode)) {
       // rewrite code handles in inline cache targets to direct
       // pointers to the first instruction in the code object
       Object** p = reinterpret_cast<Object**>(it.rinfo()->target_object());
       Code* code = Code::cast(*p);
       it.rinfo()->set_target_address(code->instruction_start());
     } else {
       it.rinfo()->apply(delta);
     }
   }
   CPU::FlushICache(instruction_start(), instruction_size());
 }
 
 
 // Locate the source position which is closest to the address in the code. This
 // is using the source position information embedded in the relocation info.
 // The position returned is relative to the beginning of the script where the
 // source for this function is found.
 int Code::SourcePosition(Address pc) {
   int distance = kMaxInt;
-  int position = kNoPosition;  // Initially no position found.
+  int position = RelocInfo::kNoPosition;  // Initially no position found.
   // Run through all the relocation info to find the best matching source
   // position. All the code needs to be considered as the sequence of the
   // instructions in the code does not necessarily follow the same order as the
   // source.
   RelocIterator it(this, RelocInfo::kPositionMask);
   while (!it.done()) {
     // Only look at positions after the current pc.
     if (it.rinfo()->pc() < pc) {
       // Get position and distance.
       int dist = pc - it.rinfo()->pc();
@@ skipping 16 matching lines @@
 // Same as Code::SourcePosition above except it only looks for statement
 // positions.
 int Code::SourceStatementPosition(Address pc) {
   // First find the position as close as possible using all position
   // information.
   int position = SourcePosition(pc);
   // Now find the closest statement position before the position.
   int statement_position = 0;
   RelocIterator it(this, RelocInfo::kPositionMask);
   while (!it.done()) {
-    if (is_statement_position(it.rinfo()->rmode())) {
+    if (RelocInfo::IsStatementPosition(it.rinfo()->rmode())) {
       int p = it.rinfo()->data();
       if (statement_position < p && p <= position) {
         statement_position = p;
       }
     }
     it.next();
   }
   return statement_position;
 }
 
@@ skipping 2097 matching lines @@
   // No break point.
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 
 
 } }  // namespace v8::internal