Collect type information based on stack allocated values for OSR.

src/typing.cc

 // Copyright 2013 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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "typing.h"
 
+#include "frames.h"
+#include "frames-inl.h"
 #include "parser.h"  // for CompileTimeValue; TODO(rossberg): should move
 #include "scopes.h"
 
 namespace v8 {
 namespace internal {
 
 
 AstTyper::AstTyper(CompilationInfo* info)
     : info_(info),
       oracle_(
           Handle<Code>(info->closure()->shared()->code()),
           Handle<Context>(info->closure()->context()->native_context()),
           info->isolate(),
           info->zone()),
-      store_(info->zone()) {
+      store_(info->zone()),
+      parameter_types_(NULL),
+      stack_local_types_(NULL) {
   InitializeAstVisitor(info->isolate());
+  if (info_->is_osr()) ObserveTypesOnStack();
 }
 
 
 #define RECURSE(call)                         \
   do {                                        \
     ASSERT(!visitor->HasStackOverflow());     \
     call;                                     \
     if (visitor->HasStackOverflow()) return;  \
   } while (false)
 
 void AstTyper::Run(CompilationInfo* info) {
   AstTyper* visitor = new(info->zone()) AstTyper(info);
   Scope* scope = info->scope();
 
   // Handle implicit declaration of the function name in named function
   // expressions before other declarations.
   if (scope->is_function_scope() && scope->function() != NULL) {
     RECURSE(visitor->VisitVariableDeclaration(scope->function()));
   }
   RECURSE(visitor->VisitDeclarations(scope->declarations()));
   RECURSE(visitor->VisitStatements(info->function()->body()));
 }
 
 #undef RECURSE
 
+
+Handle<Type> AstTyper::ObserveType(Object* value) {
+  if (value->IsUndefined() || value->IsTheHole()) {
+    return Handle<Type>(Type::None(), isolate());
+  } else {
+    return Handle<Type>(Type::OfCurrently(Handle<Object>(value, isolate())),
+                        isolate());
+  }
+}
+
+
+void AstTyper::ObserveTypesOnStack() {
+  DisallowHeapAllocation no_gc;
+  JavaScriptFrameIterator it(isolate());
+  JavaScriptFrame* frame = it.frame();
+  Scope* scope = info_->scope();
+
+  // Assert that the frame on the stack belongs to the function we want to OSR.
+  ASSERT_EQ(*info_->closure(), frame->function());
+
+  int params = scope->num_parameters();
+  int locals = scope->num_stack_slots();
+
+  parameter_types_ = new(zone()) ZoneList<Handle<Type> >(params + 1, zone());
+  stack_local_types_ = new(zone()) ZoneList<Handle<Type> >(locals, zone());
+
+  // The receiver ('this') is a parameter with index -1.  We store it as
+  // element 0 and shift other params up by 1.
+  parameter_types_->Add(ObserveType(frame->receiver()), zone());
+  for (int i = 0; i < params; i++) {
+    parameter_types_->Add(ObserveType(frame->GetParameter(i)), zone());
+  }
+
+  // This includes the function var, if it is stored as a stack local.
+  for (int i = 0; i < locals; i++) {
+    stack_local_types_->Add(ObserveType(frame->GetExpression(i)), zone());
+  }
+}
+
+
+Handle<Type> AstTyper::GetObservedType(Variable* var) {
+  ASSERT(info_->is_osr());
+  ZoneList<Handle<Type> >* list;
+  int index = var->index();
+
+  if (var->IsParameter()) {
+    index += 1;
+    list = parameter_types_;
+  } else {
+    ASSERT(var->IsStackLocal());
+    list = stack_local_types_;
+  }
+
+  // We could also observe the type of context allocated values.  We would go
+  // up the function's scope chain until we find the variable's scope, go up
+  // the context chain at the same time, and load the value from the context
+  // slot stored as variable index.  But this seems not to be worth the effort.
+
+  ASSERT(0 <= index && index < list->length());

[Jakob Kummerow, 2013/12/12 13:46:46]

Unnecessary -- List::at() contains the same check.

+  Handle<Type> result = list->at(index);
+
+  if (FLAG_trace_osr && FLAG_print_scopes) {
+    PrintF("  observed %s : ", var->IsParameter() ? "param" : "local");
+    var->name()->Print();
+    PrintF(" -> ");
+    result->TypePrint();
+  }
+
+  return result;
+}
+
+
 #define RECURSE(call)                \
   do {                               \
     ASSERT(!HasStackOverflow());     \
     call;                            \
     if (HasStackOverflow()) return;  \
   } while (false)
 
 
 void AstTyper::VisitStatements(ZoneList<Statement*>* stmts) {
   for (int i = 0; i < stmts->length(); ++i) {
@@ skipping 251 matching lines @@
   NarrowType(expr, Bounds::Either(
       expr->then_expression()->bounds(),
       expr->else_expression()->bounds(), isolate_));
 }
 
 
 void AstTyper::VisitVariableProxy(VariableProxy* expr) {
   Variable* var = expr->var();
   if (var->IsStackAllocated()) {
     NarrowType(expr, store_.LookupBounds(variable_index(var)));
+    if (info_->is_osr()) NarrowLowerType(expr, GetObservedType(var));
   }
 }
 
 
 void AstTyper::VisitLiteral(Literal* expr) {
   Type* type = Type::Constant(expr->value(), isolate_);
   NarrowType(expr, Bounds(type, isolate_));
 }
 
 
@@ skipping 383 matching lines @@
 void AstTyper::VisitModuleUrl(ModuleUrl* module) {
 }
 
 
 void AstTyper::VisitModuleStatement(ModuleStatement* stmt) {
   RECURSE(Visit(stmt->body()));
 }
 
 
 } }  // namespace v8::internal