Rename member variables and functions and clarify comments to try to...

src/assembler.h

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 30 matching lines @@
 
 namespace v8 { namespace internal {
 
 
 // -----------------------------------------------------------------------------
 // Labels represent pc locations; they are typically jump or call targets.
 // After declaration, a label can be freely used to denote known or (yet)
 // unknown pc location. Assembler::bind() is used to bind a label to the
 // current pc. A label can be bound only once.
 
-class Label : public ZoneObject {  // ShadowLables are dynamically allocated.
+class Label : public ZoneObject {  // ShadowedLabels are dynamically allocated.

[iposva, 2008/10/22 18:34:33]

ShadowedLabels reads like a C++ class to me. You probably meant to either say
"shadowed Labels or "LabelShadows" here.

  public:
   INLINE(Label())                 { Unuse(); }
   INLINE(~Label())                { ASSERT(!is_linked()); }
 
   INLINE(void Unuse())            { pos_ = 0; }
 
   INLINE(bool is_bound()  const)  { return pos_ <  0; }
   INLINE(bool is_unused() const)  { return pos_ == 0; }
   INLINE(bool is_linked() const)  { return pos_ >  0; }
 
@@ skipping 18 matching lines @@
     pos_ =  pos + 1;
     ASSERT(is_linked());
   }
 
   friend class Assembler;
   friend class Displacement;
   friend class LabelShadow;
 };
 
 
-// A LabelShadow is a label that temporarily shadows another label. It
-// is used to catch linking and binding of labels in certain scopes,
-// e.g. try blocks. LabelShadows are themselves labels which can be
-// used (only) after they are not shadowing anymore.
+// A LabelShadow represents a label that is temporarily shadowed by another
+// label (represented by the original label during shadowing). They are used
+// to catch jumps to labels in certain contexts, e.g. try blocks.  After
+// shadowing ends, the formerly shadowed label is again represented by the
+// original label and the LabelShadow can be used as a label in its own
+// right, representing the formerly shadowing label.
 class LabelShadow: public Label {
  public:
-  explicit LabelShadow(Label* shadowed) {
-    ASSERT(shadowed != NULL);
-    shadowed_ = shadowed;
-    shadowed_pos_ = shadowed->pos_;
-    shadowed->Unuse();
+  explicit LabelShadow(Label* original) {
+    ASSERT(original != NULL);
+    original_label_ = original;
+    original_pos_ = original->pos_;
+    original->Unuse();
 #ifdef DEBUG
     is_shadowing_ = true;
 #endif
   }
 
   ~LabelShadow() {
     ASSERT(!is_shadowing_);
   }
 
   void StopShadowing() {
     ASSERT(is_shadowing_ && is_unused());
-    pos_ = shadowed_->pos_;
-    shadowed_->pos_ = shadowed_pos_;
+    pos_ = original_label_->pos_;
+    original_label_->pos_ = original_pos_;
 #ifdef DEBUG
     is_shadowing_ = false;
 #endif
   }
 
-  Label* shadowed() const { return shadowed_; }
+  Label* original_label() const { return original_label_; }
 
  private:
-  Label* shadowed_;
-  int shadowed_pos_;
+  // During shadowing, the currently shadowing label.  After shadowing, the
+  // label that was shadowed.
+  Label* original_label_;
+
+  // During shadowing, the saved state of the original label.
+  int original_pos_;
+
 #ifdef DEBUG
   bool is_shadowing_;
 #endif
 };
 
 
 // -----------------------------------------------------------------------------
 // Relocation information
 
 
@@ skipping 326 matching lines @@
 static inline bool is_uint4(int x)  { return is_uintn(x, 4); }
 static inline bool is_uint5(int x)  { return is_uintn(x, 5); }
 static inline bool is_uint8(int x)  { return is_uintn(x, 8); }
 static inline bool is_uint12(int x)  { return is_uintn(x, 12); }
 static inline bool is_uint16(int x)  { return is_uintn(x, 16); }
 static inline bool is_uint24(int x)  { return is_uintn(x, 24); }
 
 } }  // namespace v8::internal
 
 #endif  // V8_ASSEMBLER_H_