A first stab at using the top of stack as the...

src/virtual-frame-ia32.cc

 // Copyright 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 17 matching lines @@
 #include "v8.h"
 
 #include "codegen.h"
 #include "codegen-inl.h"
 #include "virtual-frame.h"
 
 namespace v8 { namespace internal {
 
 #define __ masm_->
 
+
+// -------------------------------------------------------------------------
+// Result implementation.
+
+
+Result::Result(Register reg, CodeGenerator* cgen)
+  : type_(REGISTER),
+    cgen_(cgen) {
+  data_.reg_ = reg;
+  ASSERT(!reg().is(no_reg));
+  cgen_->allocator()->Use(reg);
+}
+
+
+void Result::Unuse() {
+  ASSERT(!reg().is(no_reg));
+  cgen_->allocator()->Unuse(reg());
+  data_.reg_ = no_reg;
+}
+
+
 // -------------------------------------------------------------------------
 // VirtualFrame implementation.
 
 // On entry to a function, the virtual frame already contains the receiver,
 // the parameters, and a return address.  All frame elements are in memory.
 VirtualFrame::VirtualFrame(CodeGenerator* cgen)
     : cgen_(cgen),
       masm_(cgen->masm()),
       elements_(0),
       parameter_count_(cgen->scope()->num_parameters()),
@@ skipping 539 matching lines @@
     if (dropped.is_register()) {
       Unuse(dropped.reg());
     }
   }
 }
 
 
 void VirtualFrame::Drop() { Drop(1); }
 
 
+/*
+We need comparison with literal to work.
+It will get Result, is register or constant.
+Pop gives it this, from register, constant, memory, or
+reference to slot.
+
+In comparison to literal, we need register case to work.
+We need non-smi stub to exit and return with a non-spilled frame.
+*/
+
+
+Result VirtualFrame::Pop() {
+  FrameElement popped = elements_.RemoveLast();
+  bool pop_needed = (stack_pointer_ == elements_.length());
+
+  if (popped.is_constant()) {
+    if (pop_needed) {
+      stack_pointer_--;
+      __ add(Operand(esp), Immediate(kPointerSize));
+    }
+    return Result(popped.handle(), cgen_);
+  } else if (popped.is_register()) {
+    Unuse(popped.reg());
+    if (pop_needed) {
+      stack_pointer_--;
+      __ add(Operand(esp), Immediate(kPointerSize));
+    }
+    return Result(popped.reg(), cgen_);
+  } else {
+    ASSERT(popped.is_memory());
+    Register temp = cgen_->allocator()->Allocate();
+    ASSERT(!temp.is(no_reg));
+    ASSERT(pop_needed);
+    stack_pointer_--;
+    __ pop(temp);
+    // The register temp is double counted, by Allocate and Result(temp).
+    cgen_->allocator()->Unuse(temp);
+    return Result(temp, cgen_);
+  }
+}
+
 void VirtualFrame::EmitPop(Register reg) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
   stack_pointer_--;
   elements_.RemoveLast();
   __ pop(reg);
 }
 
 
 void VirtualFrame::EmitPop(Operand operand) {
   ASSERT(stack_pointer_ == elements_.length() - 1);
@@ skipping 48 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal