fix bug and some cleanup

es/enter_code.h

@@ -170,6 +170,7 @@ void DeclarationBindingInstantiation(
   Error* e, ExecutionContext* context, AST* code, CodeType code_type,
   Handle<FunctionObject> f = Handle<FunctionObject>(), std::vector<Handle<JSValue>> args = {}
 ) {
+  log::PrintSource("enter DeclarationBindingInstantiation");
   Handle<EnvironmentRecord> env = context->variable_env().val()->env_rec();  // 1
   bool configurable_bindings = false;
   ProgramOrFunctionBody* body = static_cast<ProgramOrFunctionBody*>(code);

es/eval.h

@@ -103,6 +103,7 @@ Completion EvalProgram(AST* ast) {
 }
 
 Completion EvalStatement(AST* ast) {
+  log::PrintSource("EvalStatement ", ast->source().substr(0, 50));
   HandleScope scope;
   switch(ast->type()) {
     case AST::AST_STMT_BLOCK:

es/gc/base.h

@@ -25,19 +25,20 @@ class GC {
     Header* header = static_cast<Header*>(ref);
     header->size = size_with_header;
     header->flag = flag;
-    header->forward_address_ = nullptr;
+    header->forward_address = nullptr;
     void* body = static_cast<Header*>(ref) + 1;
+    assert(ForwardAddress(body) == nullptr);
     return body;
   }
 
   void* ForwardAddress(void* ref) {
     Header* header = H(ref);
-    return static_cast<Header*>(header)->forward_address_;
+    return header->forward_address;
   }
 
   void SetForwardAddress(void* ref, void* forward_address) {
     Header* header = H(ref);
-    static_cast<Header*>(header)->forward_address_ = forward_address;
+    header->forward_address = forward_address;
   }
 
  private:

es/gc/copy_collection.h

@@ -39,32 +39,28 @@ class CopyCollection : public GC {
 
   void Collect() override {
 #ifdef GC_DEBUG
-    if (log::Debugger::On())
-      std::cout << "enter CopyCollection::Collect" << std::endl;
+    std::cout << "enter CopyCollection::Collect " << free_ - tospace_ << std::endl;
 #endif
     Flip();
     Initialise(worklist_);
     auto root_pointers = Runtime::Global()->Pointers();
     assert(root_pointers.size() > 0);
 #ifdef GC_DEBUG
-    if (log::Debugger::On())
-      std::cout << "root_pointers size: " << root_pointers.size() << std::endl;
+    std::cout << "root_pointers size: " << root_pointers.size() << std::endl;
 #endif
     for (HeapObject** fld : root_pointers) {
       Process(fld);
     }
 #ifdef GC_DEBUG
-    if (log::Debugger::On())
-      std::cout << "finish root_pointers" << std::endl;
+    std::cout << "finish root_pointers" << std::endl;
 #endif
     while (!IsEmpty(worklist_)) {
       void* ref = Remove(worklist_);
       Scan(ref);
     }
     memset(fromspace_, 0, extent_);
 #ifdef GC_DEBUG
-    if (log::Debugger::On())
-      std::cout << "exit CopyCollection::Collect " << free_ - tospace_ << std::endl;
+    std::cout << "exit CopyCollection::Collect " << free_ - tospace_ << std::endl;
 #endif
   }
 
@@ -78,65 +74,70 @@ class CopyCollection : public GC {
   void Scan(void* ref) {
     HeapObject* heap_ref = static_cast<HeapObject*>(ref);
     assert(heap_ref != nullptr);
-#ifdef GC_DEBUG
-    // if (log::Debugger::On())
-    //   std::cout << "Scanning: " << heap_ref->ToString() << " " << ref << std::endl;
-#endif
     auto ref_pointers = heap_ref->Pointers();
     for (HeapObject** fld : ref_pointers) {
       Process(fld);
     }
-#ifdef GC_DEBUG
-    // if (log::Debugger::On())
-    //   std::cout << "exit Scan" << std::endl;
-#endif
   }
 
   void Process(HeapObject** fld) {
     if (*fld == nullptr || (Flag(*fld) & GCFlag::CONST))
       return;
     HeapObject* from_ref = *fld;
+#ifdef GC_DEBUG
     assert(from_ref != nullptr);
-    if (tospace_ < (void*)from_ref && (void*)from_ref < tospace_ + extent_) {
+#endif
+    if (InToSpace(from_ref)) {
       return;
     }
-    assert(fromspace_ < (char*)from_ref && (char*)from_ref < fromspace_ + extent_);
 #ifdef GC_DEBUG
-    // if (log::Debugger::On())
-    //   std::cout << "Processing: " << from_ref->ToString() << std::endl;
+    assert(InFromSpace(from_ref));
 #endif
     *fld = static_cast<HeapObject*>(Forward(from_ref));
-#ifdef GC_DEBUG
-    // if (log::Debugger::On())
-    //   std::cout << "exit Process" << std::endl;
-#endif
   }
 
   void* Forward(void* from_ref) {
     void* to_ref = ForwardAddress(from_ref);
-    if (to_ref == nullptr)
+    if (to_ref == nullptr) {
       to_ref = Copy(from_ref);
-    assert(tospace_ < to_ref && to_ref < tospace_ + extent_);
+    }
+#ifdef GC_DEBUG
+    assert(InToSpace(to_ref));
+#endif
     return to_ref;
   }
 
   void* Copy(void* from_ref) {
-    assert(fromspace_ < from_ref && from_ref < fromspace_ + extent_);
+    assert(InFromSpace(from_ref));
     char* to_ref = free_ + sizeof(Header);
     size_t size = Size(from_ref);
+    free_ += size;
 #ifdef GC_DEBUG
-    // if (log::Debugger::On())
-    //   std::cout << "copy " << size << " to free: " << free_ - tospace_ << std::endl;
+    assert(InToSpace(free_) || free_ == tospace_ + extent_);
+    assert(ForwardAddress(from_ref) == nullptr);
 #endif
-    free_ += size;
-    assert(tospace_ < free_ && free_ < tospace_ + extent_);
-    SetForwardAddress(from_ref, nullptr);
     memcpy(H(to_ref), H(from_ref), size);
     SetForwardAddress(from_ref, to_ref);
+#ifdef GC_DEBUG
+    assert(ForwardAddress(to_ref) == nullptr);
+    assert(InToSpace(ForwardAddress(from_ref)));
+#endif
     Add(worklist_, to_ref);
     return to_ref;
   }
 
+  bool InToSpace(void* ptr) {
+    return tospace_ <= ptr && ptr < tospace_ + extent_;
+  }
+
+  bool InFromSpace(void* ptr) {
+    return fromspace_ <= ptr && ptr < fromspace_ + extent_;
+  }
+
+  bool InHeap(void* ptr) {
+    return heap_start_ <= ptr && ptr < heap_end_;
+  }
+
   char* heap_start_;
   char* heap_end_;
 

es/gc/handle.h

@@ -132,12 +132,12 @@ class Handle {
  public:
   explicit Handle(T* value) {
     if (value != nullptr) {
-#ifdef GC_DEBUG
-      if (log::Debugger::On()) {
-        Handle<T> tmp;
-        std::cout << "Add " << typeid(tmp).name() << std::endl;
-      }
-#endif
+// #ifdef GC_DEBUG
+//       if (log::Debugger::On()) {
+//         Handle<T> tmp;
+//         std::cout << "Add " << typeid(tmp).name() << std::endl;
+//       }
+// #endif
       ptr_ = reinterpret_cast<T**>(HandleScope::Add(value));
     } else {
       ptr_ = nullptr;

es/gc/header.h

@@ -14,7 +14,7 @@ typedef uint8_t flag_t;
 struct Header {
   flag_t flag = 0;
   uint32_t size = 0;
-  void* forward_address_ = nullptr;
+  void* forward_address = nullptr;
 };
 
 Header* H(void* ref) { return static_cast<Header*>(ref) - 1; }

es/gc/heap.h

@@ -6,7 +6,7 @@
 
 namespace es {
 
-constexpr size_t kNewSpaceSize = 20 * 1024 * 1024;  // 20MB
+constexpr size_t kNewSpaceSize = 500 * 1024 * 1024;  // 500MB
 constexpr size_t kConstantSegmentSize = 10 * 1024 * 1024;  // 10MB
 constexpr size_t kBigObjectSegmentSize = 1024 * 1024 * 1024;  // 1GB
 constexpr size_t kBigObjectThres = 10 * 1024 * 1024;  // 10MB

es/impl/environment_record-impl.h

@@ -71,7 +71,7 @@ void SetMutableBinding(
 void SetMutableBinding__Declarative(
   Error* e, Handle<DeclarativeEnvironmentRecord> env_rec, Handle<String> N, Handle<JSValue> V, bool S
 ) {
-  log::PrintSource("enter SetMutableBinding ", N.val()->data(), " to " + V.ToString());
+  log::PrintSource("enter SetMutableBinding__Declarative ", N.val()->data(), " to " + V.ToString());
   assert(V.val()->IsLanguageType());
   assert(HasBinding(env_rec, N));
   // NOTE(zhuzilin) If we do note b = bindings_[N] and change b.value,
@@ -87,7 +87,7 @@ void SetMutableBinding__Declarative(
 void SetMutableBinding__Object(
   Error* e, Handle<ObjectEnvironmentRecord> env_rec, Handle<String> N, Handle<JSValue> V, bool S
 ) {
-  log::PrintSource("enter SetMutableBinding " + N.ToString() + " to " + V.ToString());
+  log::PrintSource("enter SetMutableBinding__Object " + N.ToString() + " to " + V.ToString());
   assert(V.val()->IsLanguageType());
   Put(e, env_rec.val()->bindings(), N, V, S);
 }
@@ -107,6 +107,7 @@ Handle<JSValue> GetBindingValue(
 Handle<JSValue> GetBindingValue__Declarative(
   Error* e, Handle<DeclarativeEnvironmentRecord> env_rec, Handle<String> N, bool S
 ) {
+  log::PrintSource("enter GetBindingValue__Declarative " + N.ToString());
   assert(HasBinding(env_rec, N));
   DeclarativeEnvironmentRecord::Binding* b = env_rec.val()->bindings()->GetRaw(N);
   if (b->value().val()->IsUndefined() && !b->is_mutable()) {
@@ -126,6 +127,7 @@ Handle<JSValue> GetBindingValue__Declarative(
 Handle<JSValue> GetBindingValue__Object(
   Error* e, Handle<ObjectEnvironmentRecord> env_rec, Handle<String> N, bool S
 ) {
+  log::PrintSource("enter GetBindingValue__Object " + N.ToString());
   bool value = HasBinding(env_rec, N);
   if (!value) {
     if (S) {

es/impl/object-impl.h

@@ -90,6 +90,7 @@ Handle<JSValue> GetProperty(Handle<JSObject> O, Handle<String> P) {
 
 // [[Get]]
 Handle<JSValue> Get(Error* e, Handle<JSObject> O, Handle<String> P) {
+  log::PrintSource("enter Get " + P.ToString() + " from " + std::to_string(O.val()->obj_type()));
   if (O.val()->IsFunctionObject()) {
     return Get__Function(e, static_cast<Handle<FunctionObject>>(O), P);
   } else if (O.val()->IsArgumentsObject()) {
@@ -195,6 +196,7 @@ bool CanPut(Handle<JSObject> O, Handle<String> P) {
 // [[Put]]
 // 8.12.5 [[Put]] ( P, V, Throw )
 void Put(Error* e, Handle<JSObject> O, Handle<String> P, Handle<JSValue> V, bool throw_flag) {
+  log::PrintSource("enter Put " + P.ToString() + " to " + O.ToString() + " with value " + V.ToString());
   assert(V.val()->IsLanguageType());
   if (!CanPut(O, P)) {  // 1
     if (throw_flag) {  // 1.a
@@ -320,6 +322,7 @@ Handle<JSValue> DefaultValue(Error* e, Handle<JSObject> O, std::u16string hint)
 bool DefineOwnProperty(
   Error* e, Handle<JSObject> O, Handle<String> P, Handle<PropertyDescriptor> desc, bool throw_flag
 ) {
+  log::PrintSource("enter DefineOwnProperty " + P.ToString());
   if (O.val()->IsArrayObject()) {
     return DefineOwnProperty__Array(e, static_cast<Handle<ArrayObject>>(O), P, desc, throw_flag);
   } else if (O.val()->IsArgumentsObject()) {
@@ -586,6 +589,7 @@ void AddValueProperty(
   Handle<JSObject> O, Handle<String> name, Handle<JSValue> value, bool writable,
   bool enumerable, bool configurable
 ) {
+  log::PrintSource("AddValueProperty " + name.ToString() + " to " + value.ToString());
   Handle<PropertyDescriptor> desc = PropertyDescriptor::New();
   desc.val()->SetDataDescriptor(value, writable, enumerable, configurable);
   // This should just like named_properties_[name] = desc

es/types/base.h

@@ -315,11 +315,7 @@ class String : public JSValue {
     return singleton;
   }
 
-  inline std::string ToString() override {
-    if (size() > 100)
-      return log::ToString(data().substr(0, 100)) + "...";
-    return log::ToString(data());
-  }
+  inline std::string ToString() override { return log::ToString(data()); }
   inline std::vector<HeapObject**> Pointers() override { return {}; }
 
  private:

es/types/builtin/function_object.h

@@ -108,10 +108,11 @@ class FunctionObject : public JSObject {
       OBJ_FUNC, u"Function", true, Handle<JSValue>(), true, true, nullptr,
       kFunctionObjectOffset - kJSObjectOffset + size
     );
-    Handle<FixedArray<String>> formal_parameter = FixedArray<String>::New(names.size());
+    std::vector<Handle<String>> name_handles(names.size());
     for (size_t i = 0; i < names.size(); i++) {
-      formal_parameter.val()->Set(i, String::New(names[i]));
+      name_handles[i] = String::New(names[i]);
     }
+    Handle<FixedArray<String>> formal_parameter = FixedArray<String>::New(name_handles);
 
     SET_HANDLE_VALUE(jsobj.val(), kFormalParametersOffset, formal_parameter, FixedArray<String>);
     bool strict = Runtime::TopContext()->strict();

es/types/completion.h

@@ -22,19 +22,25 @@ class Completion {
   Completion() : Completion(NORMAL, Handle<JSValue>(), u"") {}
 
   Completion(Type type, Handle<JSValue> value, std::u16string target) :
-    type_(type), value_(value.val()), target_(target) {}
+    type_(type), value_(value), target_(target) {}
 
   Type type() { return type_; }
-  Handle<JSValue> value() { return Handle<JSValue>(value_); }
+  Handle<JSValue> value() {
+    // TODO(zhuzilin) Reset the HandleScope to current when value is asked.
+    // this is prevent the creation handle was destructed. However, this may
+    // not be correct...
+    value_ = Handle<JSValue>(value_.val());
+    return value_;
+  }
   std::u16string target() { return target_; }
 
   bool IsAbruptCompletion() { return type_ != NORMAL; }
   bool IsThrow() { return type_ == THROW; }
-  bool IsEmpty() { return value_ == nullptr; }
+  bool IsEmpty() { return value_.IsNullptr(); }
 
  private:
   Type type_;
-  JSValue* value_;
+  Handle<JSValue> value_;
   std::u16string target_;
 };
 

es/utils/fixed_array.h

@@ -34,21 +34,6 @@ class FixedArray : public HeapObject {
     return pointers;
   }
 
-  static Handle<FixedArray<T>> New(size_t n) {
-#ifdef GC_DEBUG
-    if (log::Debugger::On())
-      std::cout << "FixedArray::New " << n << std::endl;
-#endif
-    Handle<HeapObject> heap_obj = HeapObject::New(kIntSize + n * kPtrSize);
-
-    SET_VALUE(heap_obj.val(), kSizeOffset, n, size_t);
-    for (size_t i = 0; i < n; i++) {
-      SET_HANDLE_VALUE(heap_obj.val(), kElementOffset + i * kPtrSize, Handle<T>(), T);
-    }
-
-    return Handle<FixedArray<T>>(new (heap_obj.val()) FixedArray<T>());
-  }
-
   size_t size() { return READ_VALUE(this, kSizeOffset, size_t); }
   Handle<T> Get(size_t i) { return READ_HANDLE_VALUE(this, kElementOffset + i * kPtrSize, T); }
   T* GetRaw(size_t i) { return READ_VALUE(this, kElementOffset + i * kPtrSize, T*); }