Remove experimental fast-codegen. We are no longer working on this

src/compiler.h

 // 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 23 matching lines @@
 #include "register-allocator.h"
 #include "zone.h"
 
 namespace v8 {
 namespace internal {
 
 // CompilationInfo encapsulates some information known at compile time.  It
 // is constructed based on the resources available at compile-time.
 class CompilationInfo BASE_EMBEDDED {
  public:
-  // Compilation mode.  Either the compiler is used as the primary
-  // compiler and needs to setup everything or the compiler is used as
-  // the secondary compiler for split compilation and has to handle
-  // bailouts.
-  enum Mode {
-    PRIMARY,
-    SECONDARY
-  };
-
-  // A description of the compilation state at a bailout to the secondary
-  // code generator.
-  //
-  // The state is currently simple: there are no parameters or local
-  // variables to worry about ('this' can be found in the stack frame).
-  // There are at most two live values.
-  //
-  // There is a label that should be bound to the beginning of the bailout
-  // stub code.
-  class Bailout : public ZoneObject {
-   public:
-    Bailout(Register left, Register right) : left_(left), right_(right) {}
-
-    Label* label() { return &label_; }
-
-   private:
-    Register left_;
-    Register right_;
-    Label label_;
-  };
-
-
   // Lazy compilation of a JSFunction.
   CompilationInfo(Handle<JSFunction> closure,
                   int loop_nesting,
                   Handle<Object> receiver)
       : closure_(closure),
         function_(NULL),
         is_eval_(false),
         loop_nesting_(loop_nesting),
         receiver_(receiver) {
     Initialize();
@@ skipping 53 matching lines @@
   // There should always be a function literal, but it may be set after
   // construction (for lazy compilation).
   FunctionLiteral* function() { return function_; }
   void set_function(FunctionLiteral* literal) { function_ = literal; }
 
   // Simple accessors.
   bool is_eval() { return is_eval_; }
   int loop_nesting() { return loop_nesting_; }
   bool has_receiver() { return !receiver_.is_null(); }
   Handle<Object> receiver() { return receiver_; }
-  List<Bailout*>* bailouts() { return &bailouts_; }
-
-  // Accessors for mutable fields (possibly set by analysis passes) with
-  // default values given by Initialize.
-  Mode mode() { return mode_; }
-  void set_mode(Mode mode) { mode_ = mode; }
 
   bool has_this_properties() { return has_this_properties_; }
   void set_has_this_properties(bool flag) { has_this_properties_ = flag; }
 
   bool has_global_object() {
     return !closure().is_null() && (closure()->context()->global() != NULL);
   }
 
   GlobalObject* global_object() {
     return has_global_object() ? closure()->context()->global() : NULL;
   }
 
   bool has_globals() { return has_globals_; }
   void set_has_globals(bool flag) { has_globals_ = flag; }
 
   // Derived accessors.
   Scope* scope() { return function()->scope(); }
 
-  // Add a bailout with two live values.
-  Label* AddBailout(Register left, Register right) {
-    Bailout* bailout = new Bailout(left, right);
-    bailouts_.Add(bailout);
-    return bailout->label();
-  }
-
-  // Add a bailout with no live values.
-  Label* AddBailout() { return AddBailout(no_reg, no_reg); }
-
  private:
   void Initialize() {
-    mode_ = PRIMARY;
     has_this_properties_ = false;
     has_globals_ = false;
   }
 
   Handle<JSFunction> closure_;
   Handle<SharedFunctionInfo> shared_info_;
   Handle<Script> script_;
 
   FunctionLiteral* function_;
-  Mode mode_;
 
   bool is_eval_;
   int loop_nesting_;
 
   Handle<Object> receiver_;
 
   bool has_this_properties_;
   bool has_globals_;
 
-  // An ordered list of bailout points encountered during fast-path
-  // compilation.
-  List<Bailout*> bailouts_;
-
   DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
 };
 
 
 // The V8 compiler
 //
 // General strategy: Source code is translated into an anonymous function w/o
 // parameters which then can be executed. If the source code contains other
 // functions, they will be compiled and allocated as part of the compilation
 // of the source code.
@@ skipping 72 matching lines @@
       FrameElement::ClearConstantList();
       Result::ClearConstantList();
     }
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_COMPILER_H_