Add virtual destructors to address a gcc warning.

src/cfg.h

 // 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 20 matching lines @@
 #include "ast.h"
 
 namespace v8 {
 namespace internal {
 
 // Values appear in instructions.  They represent trivial source
 // expressions: ones with no side effects and that do not require code to be
 // generated.
 class Value : public ZoneObject {
  public:
+  virtual ~Value() {}
+
   virtual void ToRegister(MacroAssembler* masm, Register reg) = 0;
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 };
 
 
 // A compile-time constant that appeared as a literal in the source AST.
 class Constant : public Value {
  public:
   explicit Constant(Handle<Object> handle) : handle_(handle) {}
 
-  virtual void ToRegister(MacroAssembler* masm, Register reg);
+  virtual ~Constant() {}
+
+  void ToRegister(MacroAssembler* masm, Register reg);
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   Handle<Object> handle_;
 };
 
 
 // Instructions are computations.  The represent non-trivial source
 // expressions: typically ones that have side effects and require code to
 // be generated.
 class Instruction : public ZoneObject {
  public:
+  virtual ~Instruction() {}
+
   virtual void Compile(MacroAssembler* masm) = 0;
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 };
 
 
 // Return a value.
 class ReturnInstr : public Instruction {
  public:
   explicit ReturnInstr(Value* value) : value_(value) {}
 
+  virtual ~ReturnInstr() {}
+
   void Compile(MacroAssembler* masm);
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   Value* value_;
 };
 
 
 // Nodes make up control-flow graphs.  They contain single-entry,
 // single-exit blocks of instructions and administrative nodes making up the
 // graph structure.
 class CfgNode : public ZoneObject {
  public:
   CfgNode() : is_marked_(false) {
 #ifdef DEBUG
     number_ = -1;
 #endif
   }
 
+  virtual ~CfgNode() {}
+
   bool is_marked() { return is_marked_; }
 
   static void Reset();
 
   virtual bool is_block() { return false; }
 
   virtual void Unmark() = 0;
 
   virtual void Compile(MacroAssembler* masm) = 0;
 
@@ skipping 15 matching lines @@
   static int node_counter_;
 #endif
 };
 
 
 // A block is a single-entry, single-exit block of instructions.
 class InstructionBlock : public CfgNode {
  public:
   InstructionBlock() : successor_(NULL), instructions_(4) {}
 
+  virtual ~InstructionBlock() {}
+
   static InstructionBlock* cast(CfgNode* node) {
     ASSERT(node->is_block());
     return reinterpret_cast<InstructionBlock*>(node);
   }
 
   void set_successor(CfgNode* succ) {
     ASSERT(successor_ == NULL);
     successor_ = succ;
   }
 
@@ skipping 15 matching lines @@
 };
 
 
 // The CFG for a function has a distinguished entry node.  It has no
 // predecessors and a single successor.  The successor is the block
 // containing the function's first instruction.
 class EntryNode : public CfgNode {
  public:
   EntryNode(FunctionLiteral* fun, InstructionBlock* succ);
 
+  virtual ~EntryNode() {}
+
   void Unmark();
 
   void Compile(MacroAssembler* masm);
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   InstructionBlock* successor_;
   int local_count_;
 };
 
 
 // The CFG for a function has a distinguished exit node.  It has no
 // successor and arbitrarily many predecessors.  The predecessors are all
 // the blocks returning from the function.
 class ExitNode : public CfgNode {
  public:
   explicit ExitNode(FunctionLiteral* fun);
 
+  virtual ~ExitNode() {}
+
   void Unmark();
 
   void Compile(MacroAssembler* masm);
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   int parameter_count_;
@@ skipping 96 matching lines @@
 #undef DECLARE_VISIT
 
  private:
   Cfg* cfg_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CFG_H_