Style cleanup of switches over Slot::Type in the nonoptimizing code...

src/arm/fast-codegen-arm.cc

 // Copyright 2009 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 234 matching lines @@
     }
   }
 }
 
 
 template <>
 MemOperand FastCodeGenerator::CreateSlotOperand<MemOperand>(
     Slot* source,
     Register scratch) {
   switch (source->type()) {
-    case Slot::PARAMETER:
+    case Slot::PARAMETER:  // Fall through.

[Lasse Reichstein, 2010/01/05 06:16:57]

I think two cases immediately after each other is a known idion, and doesn't
need the "Fall through" comment.
I would reserve that for falling through a case that actually does something.

[Lasse Reichstein, 2010/01/05 06:17:52]

"Idiom", even.

     case Slot::LOCAL:
       return MemOperand(fp, SlotOffset(source));
     case Slot::CONTEXT: {
       int context_chain_length =
           function_->scope()->ContextChainLength(source->var()->scope());
       __ LoadContext(scratch, context_chain_length);
       return CodeGenerator::ContextOperand(scratch, source->index());
-      break;
     }
     case Slot::LOOKUP:
       UNIMPLEMENTED();
-      // Fall-through.
-    default:
-      UNREACHABLE();
-      return MemOperand(r0, 0);  // Dead code to make the compiler happy.
   }
+  UNREACHABLE();
+  return MemOperand(r0, 0);
 }
 
 
 void FastCodeGenerator::Move(Register dst, Slot* source) {
   // Use dst as scratch.
   MemOperand location = CreateSlotOperand<MemOperand>(source, dst);
   __ ldr(dst, location);
 }
 
 
@@ skipping 48 matching lines @@
           function_->scope()->ContextChainLength(dst->var()->scope());
       __ LoadContext(scratch1, context_chain_length);
       int index = Context::SlotOffset(dst->index());
       __ mov(scratch2, Operand(index));
       __ str(src, MemOperand(scratch1, index));
       __ RecordWrite(scratch1, scratch2, src);
       break;
     }
     case Slot::LOOKUP:
       UNIMPLEMENTED();
-    default:
-      UNREACHABLE();
   }
 }
 
 
 
 void FastCodeGenerator::DropAndMove(Expression::Context context,
                                     Register source,
                                     int drop_count) {
   ASSERT(drop_count > 0);
   switch (context) {
@@ skipping 204 matching lines @@
     __ ldr(ip, CodeGenerator::GlobalObject());
     __ push(ip);
     __ mov(r2, Operand(var->name()));
     Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
     DropAndMove(context, r0);
   } else if (rewrite->AsSlot() != NULL) {
     Slot* slot = rewrite->AsSlot();
     if (FLAG_debug_code) {
       switch (slot->type()) {
-        case Slot::LOCAL:
+        case Slot::LOCAL:  // Fall through.
         case Slot::PARAMETER: {
           Comment cmnt(masm_, "Stack slot");
           break;
         }
         case Slot::CONTEXT: {
           Comment cmnt(masm_, "Context slot");
           break;
         }
         case Slot::LOOKUP:
           UNIMPLEMENTED();
           break;
-        default:
-          UNREACHABLE();
       }
     }
     Move(context, slot, r0);
   } else {
     // A variable has been rewritten into an explicit access to
     // an object property.
     Property* property = rewrite->AsProperty();
     ASSERT_NOT_NULL(property);
 
     // Currently the only parameter expressions that can occur are
@@ skipping 1141 matching lines @@
   __ pop(result_register());
   ASSERT_EQ(1, kSmiTagSize + kSmiShiftSize);
   __ mov(r1, Operand(r1, ASR, 1));  // Un-smi-tag value.
   __ add(pc, r1, Operand(masm_->CodeObject()));
 }
 
 
 #undef __
 
 } }  // namespace v8::internal