Remove instruction summaries and provide a LIR-interface for the register all...

src/ia32/lithium-ia32.h

 // Copyright 2011 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 273 matching lines @@
 
 #define DECLARE_HYDROGEN_ACCESSOR(type)     \
   H##type* hydrogen() const {               \
     return H##type::cast(hydrogen_value()); \
   }
 
 
 class LInstruction: public ZoneObject {
  public:
   LInstruction()
-      : hydrogen_value_(NULL) { }
+      : hydrogen_value_(NULL), is_call_(false), is_save_doubles_(false) { }
   virtual ~LInstruction() { }
 
   virtual void CompileToNative(LCodeGen* generator) = 0;
   virtual const char* Mnemonic() const = 0;
   virtual void PrintTo(StringStream* stream);
   virtual void PrintDataTo(StringStream* stream) = 0;
   virtual void PrintOutputOperandTo(StringStream* stream) = 0;
 
   // Declare virtual type testers.
 #define DECLARE_DO(type) virtual bool Is##type() const { return false; }
   LITHIUM_ALL_INSTRUCTION_LIST(DECLARE_DO)
 #undef DECLARE_DO
 
   virtual bool IsControl() const { return false; }
   virtual void SetBranchTargets(int true_block_id, int false_block_id) { }
 
   void set_environment(LEnvironment* env) { environment_.set(env); }
   LEnvironment* environment() const { return environment_.get(); }
   bool HasEnvironment() const { return environment_.is_set(); }
 
   void set_pointer_map(LPointerMap* p) { pointer_map_.set(p); }
   LPointerMap* pointer_map() const { return pointer_map_.get(); }
   bool HasPointerMap() const { return pointer_map_.is_set(); }
 
-  virtual bool HasResult() const = 0;
 
   void set_hydrogen_value(HValue* value) { hydrogen_value_ = value; }
   HValue* hydrogen_value() const { return hydrogen_value_; }
 
   void set_deoptimization_environment(LEnvironment* env) {
     deoptimization_environment_.set(env);
   }
   LEnvironment* deoptimization_environment() const {
     return deoptimization_environment_.get();
   }
   bool HasDeoptimizationEnvironment() const {
     return deoptimization_environment_.is_set();
   }
 
+  void MarkAsCall() { is_call_ = true; }
+  void MarkAsSaveDoubles() { is_save_doubles_ = true; }
+
+  // Interface to the register allocator and iterators.
+  bool IsMarkedAsCall() const { return is_call_; }
+  bool IsSaveDoubles() const { return is_save_doubles_; }

[Kevin Millikin (Chromium), 2011/01/20 12:20:30]

These two names are not entirely consistent: is_thing_ vs. is_action_;
MarkAsThing vs. MarkAsAction; and IsMarkedAsThing vs. IsAction.

I usually suggest is_thing_/IsThing() and should_action_/ShouldAction().  And
IsMarkedAsThing() is just a longer way to say IsThing().

[fschneider, 2011/01/20 17:13:08]

IsCall is already taken as the name of the type-tester - i can make both
IsMarkedAs...

+
+  virtual bool HasResult() const  = 0;

[Kevin Millikin (Chromium), 2011/01/20 12:20:30]

const doesn't care if it has extra spaces around it, but I do!

[fschneider, 2011/01/20 17:13:08]

Done.

+  virtual LOperand* result() = 0;
+
+  virtual int InputCount() = 0;
+  virtual LOperand* InputAt(int i) = 0;
+  virtual int TempCount() = 0;
+  virtual LOperand* TempAt(int i) = 0;
+
+  TempIterator GetTempIterator();
+  UseIterator GetUseIterator();
+  LOperand* FirstInput() { return InputAt(0); }
+  LOperand* Output() { return HasResult() ? result() : NULL; }
+
+#ifdef DEBUG
+  void VerifyCall();
+#endif
+
  private:
   SetOncePointer<LEnvironment> environment_;
   SetOncePointer<LPointerMap> pointer_map_;
   HValue* hydrogen_value_;
   SetOncePointer<LEnvironment> deoptimization_environment_;
+  bool is_call_;
+  bool is_save_doubles_;
 };
 
 
 template<typename T, int N>
 class OperandContainer {
  public:
   OperandContainer() {
     for (int i = 0; i < N; i++) elems_[i] = NULL;
   }
   int length() { return N; }
   T& operator[](int i) {
     ASSERT(i < length());
     return elems_[i];
   }
   void PrintOperandsTo(StringStream* stream);
 
  private:
   T elems_[N];
 };
 
 
 template<typename T>
 class OperandContainer<T, 0> {
  public:
   int length() { return 0; }
   void PrintOperandsTo(StringStream* stream) { }
+  T& operator[](int i) {
+    UNREACHABLE();
+    static T t = NULL;

[Kevin Millikin (Chromium), 2011/01/20 12:20:30]

Do we really write NULL and not 0 to initialize a T?

[fschneider, 2011/01/20 17:13:08]

Done.

+    return t;
+  }
 };
 
 
 template<int R, int I, int T = 0>
 class LTemplateInstruction: public LInstruction {
  public:
   // Allow 0 or 1 output operands.
   STATIC_ASSERT(R == 0 || R == 1);
   virtual bool HasResult() const { return R != 0; }
   void set_result(LOperand* operand) { results_[0] = operand; }
@@ skipping 1643 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_IA32_LITHIUM_IA32_H_