Refactored the recording of source position in the generated code. The code g...

src/codegen-arm.cc

 // 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 1025 matching lines @@
 
 // Call the function on the stack with the given arguments.
 void CodeGenerator::CallWithArguments(ZoneList<Expression*>* args,
                                          int position) {
   // Push the arguments ("left-to-right") on the stack.
   for (int i = 0; i < args->length(); i++) {
     Load(args->at(i));
   }
 
   // Record the position for debugging purposes.
-  __ RecordPosition(position);
+  CodeForSourcePosition(position);
 
   // Use the shared code stub to call the function.
   CallFunctionStub call_function(args->length());
   __ CallStub(&call_function);
 
   // Restore context and pop function from the stack.
   __ ldr(cp, frame_->Context());
   frame_->Pop();  // discard the TOS
 }
 
@@ skipping 10 matching lines @@
   if (FLAG_check_stack) {
     Comment cmnt(masm_, "[ check stack");
     StackCheckStub stub;
     __ CallStub(&stub);
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
   Comment cmnt(masm_, "[ Block");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
   VisitStatements(node->statements());
   __ bind(node->break_target());
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   __ mov(r0, Operand(pairs));
   frame_->Push(r0);
   frame_->Push(cp);
   __ mov(r0, Operand(Smi::FromInt(is_eval() ? 1 : 0)));
   frame_->Push(r0);
   __ CallRuntime(Runtime::kDeclareGlobals, 3);
   // The result is discarded.
 }
 
 
 void CodeGenerator::VisitDeclaration(Declaration* node) {
   Comment cmnt(masm_, "[ Declaration");
+  CodeForStatement(node);
   Variable* var = node->proxy()->var();
   ASSERT(var != NULL);  // must have been resolved
   Slot* slot = var->slot();
 
   // If it was not possible to allocate the variable at compile time,
   // we need to "declare" it at runtime to make sure it actually
   // exists in the local context.
   if (slot != NULL && slot->type() == Slot::LOOKUP) {
     // Variables with a "LOOKUP" slot were introduced as non-locals
     // during variable resolution and must have mode DYNAMIC.
@@ skipping 45 matching lines @@
     // safe to pop the value lying on top of the reference before unloading
     // the reference itself (which preserves the top of stack) because we
     // know it is a zero-sized reference.
     frame_->Pop();
   }
 }
 
 
 void CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) {
   Comment cmnt(masm_, "[ ExpressionStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   Expression* expression = node->expression();
   expression->MarkAsStatement();
   Load(expression);
   frame_->Pop();
 }
 
 
 void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) {
   Comment cmnt(masm_, "// EmptyStatement");
+  CodeForStatement(node);
   // nothing to do
 }
 
 
 void CodeGenerator::VisitIfStatement(IfStatement* node) {
   Comment cmnt(masm_, "[ IfStatement");
   // Generate different code depending on which
   // parts of the if statement are present or not.
   bool has_then_stm = node->HasThenStatement();
   bool has_else_stm = node->HasElseStatement();
 
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
 
   Label exit;
   if (has_then_stm && has_else_stm) {
     Comment cmnt(masm_, "[ IfThenElse");
     Label then;
     Label else_;
     // if (cond)
     LoadCondition(node->condition(), NOT_INSIDE_TYPEOF, &then, &else_, true);
     Branch(false, &else_);
     // then
@@ skipping 44 matching lines @@
 
 
 void CodeGenerator::CleanStack(int num_bytes) {
   ASSERT(num_bytes % kPointerSize == 0);
   frame_->Drop(num_bytes / kPointerSize);
 }
 
 
 void CodeGenerator::VisitContinueStatement(ContinueStatement* node) {
   Comment cmnt(masm_, "[ ContinueStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
   __ b(node->target()->continue_target());
 }
 
 
 void CodeGenerator::VisitBreakStatement(BreakStatement* node) {
   Comment cmnt(masm_, "[ BreakStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
   __ b(node->target()->break_target());
 }
 
 
 void CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
   Comment cmnt(masm_, "[ ReturnStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   Load(node->expression());
   // Move the function result into r0.
   frame_->Pop(r0);
 
   __ b(&function_return_);
 }
 
 
 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
   Comment cmnt(masm_, "[ WithEnterStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   Load(node->expression());
   __ CallRuntime(Runtime::kPushContext, 1);
   if (kDebug) {
     Label verified_true;
     __ cmp(r0, Operand(cp));
     __ b(eq, &verified_true);
     __ stop("PushContext: r0 is expected to be the same as cp");
     __ bind(&verified_true);
   }
   // Update context local.
   __ str(cp, frame_->Context());
 }
 
 
 void CodeGenerator::VisitWithExitStatement(WithExitStatement* node) {
   Comment cmnt(masm_, "[ WithExitStatement");
+  CodeForStatement(node);
   // Pop context.
   __ ldr(cp, ContextOperand(cp, Context::PREVIOUS_INDEX));
   // Update context local.
   __ str(cp, frame_->Context());
 }
 
 
 int CodeGenerator::FastCaseSwitchMaxOverheadFactor() {
     return kFastSwitchMaxOverheadFactor;
 }
@@ skipping 46 matching lines @@
   __ cmp(r0, Operand(Smi::FromInt(range)));
   __ b(ge, fail_label);
   __ SmiJumpTable(r0, case_targets);
 
   GenerateFastCaseSwitchCases(node, case_labels);
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   Comment cmnt(masm_, "[ SwitchStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
 
   Load(node->tag());
 
   if (TryGenerateFastCaseSwitchStatement(node)) {
       return;
   }
 
   Label next, fall_through, default_case;
   ZoneList<CaseClause*>* cases = node->cases();
@@ skipping 47 matching lines @@
     frame_->Pop();
   }
 
   __ bind(&fall_through);
   __ bind(node->break_target());
 }
 
 
 void CodeGenerator::VisitLoopStatement(LoopStatement* node) {
   Comment cmnt(masm_, "[ LoopStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   node->set_break_stack_height(break_stack_height_);
 
   // simple condition analysis
   enum { ALWAYS_TRUE, ALWAYS_FALSE, DONT_KNOW } info = DONT_KNOW;
   if (node->cond() == NULL) {
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     info = ALWAYS_TRUE;
   } else {
     Literal* lit = node->cond()->AsLiteral();
     if (lit != NULL) {
@@ skipping 19 matching lines @@
   // body
   __ bind(&loop);
   Visit(node->body());
 
   // next
   __ bind(node->continue_target());
   if (node->next() != NULL) {
     // Record source position of the statement as this code which is after the
     // code for the body actually belongs to the loop statement and not the
     // body.
-    if (FLAG_debug_info) __ RecordPosition(node->statement_pos());
+    CodeForStatement(node);
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     Visit(node->next());
   }
 
   // cond
   __ bind(&entry);
   switch (info) {
     case ALWAYS_TRUE:
       CheckStack();  // TODO(1222600): ignore if body contains calls.
       __ b(&loop);
@@ skipping 11 matching lines @@
       break;
   }
 
   // exit
   __ bind(node->break_target());
 }
 
 
 void CodeGenerator::VisitForInStatement(ForInStatement* node) {
   Comment cmnt(masm_, "[ ForInStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
 
   // We keep stuff on the stack while the body is executing.
   // Record it, so that a break/continue crossing this statement
   // can restore the stack.
   const int kForInStackSize = 5 * kPointerSize;
   break_stack_height_ += kForInStackSize;
   node->set_break_stack_height(break_stack_height_);
 
   Label loop, next, entry, cleanup, exit, primitive, jsobject;
   Label filter_key, end_del_check, fixed_array, non_string;
@@ skipping 167 matching lines @@
 
   // Exit.
   __ bind(&exit);
 
   break_stack_height_ -= kForInStackSize;
 }
 
 
 void CodeGenerator::VisitTryCatch(TryCatch* node) {
   Comment cmnt(masm_, "[ TryCatch");
+  CodeForStatement(node);
 
   Label try_block, exit;
 
   __ bl(&try_block);
   // --- Catch block ---
   frame_->Push(r0);
 
   // Store the caught exception in the catch variable.
   { Reference ref(this, node->catch_var());
     ASSERT(ref.is_slot());
@@ skipping 76 matching lines @@
       __ b(shadows[i]->original_label());
     }
   }
 
   __ bind(&exit);
 }
 
 
 void CodeGenerator::VisitTryFinally(TryFinally* node) {
   Comment cmnt(masm_, "[ TryFinally");
+  CodeForStatement(node);
 
   // State: Used to keep track of reason for entering the finally
   // block. Should probably be extended to hold information for
   // break/continue from within the try block.
   enum { FALLING, THROWING, JUMPING };
 
   Label exit, unlink, try_block, finally_block;
 
   __ bl(&try_block);
 
@@ skipping 121 matching lines @@
   frame_->Push(r0);
   __ CallRuntime(Runtime::kReThrow, 1);
 
   // Done.
   __ bind(&exit);
 }
 
 
 void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) {
   Comment cmnt(masm_, "[ DebuggerStatament");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
   __ CallRuntime(Runtime::kDebugBreak, 0);
   // Ignore the return value.
 }
 
 
 void CodeGenerator::InstantiateBoilerplate(Handle<JSFunction> boilerplate) {
   ASSERT(boilerplate->IsBoilerplate());
 
   // Push the boilerplate on the stack.
   __ mov(r0, Operand(boilerplate));
@@ skipping 287 matching lines @@
       // Update the write barrier for the array address.
       __ mov(r3, Operand(offset));
       __ RecordWrite(r1, r3, r2);
     }
   }
 }
 
 
 void CodeGenerator::VisitAssignment(Assignment* node) {
   Comment cmnt(masm_, "[ Assignment");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  CodeForStatement(node);
 
   Reference target(this, node->target());
   if (target.is_illegal()) return;
 
   if (node->op() == Token::ASSIGN ||
       node->op() == Token::INIT_VAR ||
       node->op() == Token::INIT_CONST) {
     Load(node->value());
 
   } else {
@@ skipping 10 matching lines @@
     }
   }
 
   Variable* var = node->target()->AsVariableProxy()->AsVariable();
   if (var != NULL &&
       (var->mode() == Variable::CONST) &&
       node->op() != Token::INIT_VAR && node->op() != Token::INIT_CONST) {
     // Assignment ignored - leave the value on the stack.
 
   } else {
-    __ RecordPosition(node->position());
+    CodeForSourcePosition(node->position());
     if (node->op() == Token::INIT_CONST) {
       // Dynamic constant initializations must use the function context
       // and initialize the actual constant declared. Dynamic variable
       // initializations are simply assignments and use SetValue.
       target.SetValue(CONST_INIT);
     } else {
       target.SetValue(NOT_CONST_INIT);
     }
   }
 }
 
 
 void CodeGenerator::VisitThrow(Throw* node) {
   Comment cmnt(masm_, "[ Throw");
 
   Load(node->exception());
-  __ RecordPosition(node->position());
+  CodeForSourcePosition(node->position());
   __ CallRuntime(Runtime::kThrow, 1);
   frame_->Push(r0);
 }
 
 
 void CodeGenerator::VisitProperty(Property* node) {
   Comment cmnt(masm_, "[ Property");
 
   Reference property(this, node);
   property.GetValue(typeof_state());
 }
 
 
 void CodeGenerator::VisitCall(Call* node) {
   Comment cmnt(masm_, "[ Call");
 
   ZoneList<Expression*>* args = node->arguments();
 
-  RecordStatementPosition(node);
+  CodeForStatement(node);
   // Standard function call.
 
   // Check if the function is a variable or a property.
   Expression* function = node->expression();
   Variable* var = function->AsVariableProxy()->AsVariable();
   Property* property = function->AsProperty();
 
   // ------------------------------------------------------------------------
   // Fast-case: Use inline caching.
   // ---
@@ skipping 15 matching lines @@
     // Pass the global object as the receiver and let the IC stub
     // patch the stack to use the global proxy as 'this' in the
     // invoked function.
     LoadGlobal();
 
     // Load the arguments.
     for (int i = 0; i < args->length(); i++) Load(args->at(i));
 
     // Setup the receiver register and call the IC initialization code.
     Handle<Code> stub = ComputeCallInitialize(args->length());
-    __ RecordPosition(node->position());
+    CodeForSourcePosition(node->position());
     __ Call(stub, RelocInfo::CODE_TARGET_CONTEXT);
     __ ldr(cp, frame_->Context());
     // Remove the function from the stack.
     frame_->Pop();
     frame_->Push(r0);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     // ----------------------------------
     // JavaScript example: 'with (obj) foo(1, 2, 3)'  // foo is in obj
@@ skipping 26 matching lines @@
       // Push the name of the function and the receiver onto the stack.
       __ mov(r0, Operand(literal->handle()));
       frame_->Push(r0);
       Load(property->obj());
 
       // Load the arguments.
       for (int i = 0; i < args->length(); i++) Load(args->at(i));
 
       // Set the receiver register and call the IC initialization code.
       Handle<Code> stub = ComputeCallInitialize(args->length());
-      __ RecordPosition(node->position());
+      CodeForSourcePosition(node->position());
       __ Call(stub, RelocInfo::CODE_TARGET);
       __ ldr(cp, frame_->Context());
 
       // Remove the function from the stack.
       frame_->Pop();
 
       frame_->Push(r0);  // push after get rid of function from the stack
 
     } else {
       // -------------------------------------------
@@ skipping 33 matching lines @@
 void CodeGenerator::VisitCallEval(CallEval* node) {
   Comment cmnt(masm_, "[ CallEval");
 
   // In a call to eval, we first call %ResolvePossiblyDirectEval to resolve
   // the function we need to call and the receiver of the call.
   // Then we call the resolved function using the given arguments.
 
   ZoneList<Expression*>* args = node->arguments();
   Expression* function = node->expression();
 
-  RecordStatementPosition(node);
+  CodeForStatement(node);
 
   // Prepare stack for call to resolved function.
   Load(function);
   __ mov(r2, Operand(Factory::undefined_value()));
   __ push(r2);  // Slot for receiver
   for (int i = 0; i < args->length(); i++) {
     Load(args->at(i));
   }
 
   // Prepare stack for call to ResolvePossiblyDirectEval.
   __ ldr(r1, MemOperand(sp, args->length() * kPointerSize + kPointerSize));
   __ push(r1);
   if (args->length() > 0) {
     __ ldr(r1, MemOperand(sp, args->length() * kPointerSize));
     __ push(r1);
   } else {
     __ push(r2);
   }
 
   // Resolve the call.
   __ CallRuntime(Runtime::kResolvePossiblyDirectEval, 2);
 
   // Touch up stack with the right values for the function and the receiver.
   __ ldr(r1, FieldMemOperand(r0, FixedArray::kHeaderSize));
   __ str(r1, MemOperand(sp, (args->length() + 1) * kPointerSize));
   __ ldr(r1, FieldMemOperand(r0, FixedArray::kHeaderSize + kPointerSize));
   __ str(r1, MemOperand(sp, args->length() * kPointerSize));
 
   // Call the function.
-  __ RecordPosition(node->position());
+  CodeForSourcePosition(node->position());
 
   CallFunctionStub call_function(args->length());
   __ CallStub(&call_function);
 
   __ ldr(cp, frame_->Context());
   // Remove the function from the stack.
   frame_->Pop();
   frame_->Push(r0);
 }
 
 
 void CodeGenerator::VisitCallNew(CallNew* node) {
   Comment cmnt(masm_, "[ CallNew");
+  CodeForStatement(node);
 
   // According to ECMA-262, section 11.2.2, page 44, the function
   // expression in new calls must be evaluated before the
   // arguments. This is different from ordinary calls, where the
   // actual function to call is resolved after the arguments have been
   // evaluated.
 
   // Compute function to call and use the global object as the
   // receiver. There is no need to use the global proxy here because
   // it will always be replaced with a newly allocated object.
   Load(node->expression());
   LoadGlobal();
 
   // Push the arguments ("left-to-right") on the stack.
   ZoneList<Expression*>* args = node->arguments();
   for (int i = 0; i < args->length(); i++) Load(args->at(i));
 
   // r0: the number of arguments.
   __ mov(r0, Operand(args->length()));
 
   // Load the function into r1 as per calling convention.
   __ ldr(r1, frame_->Element(args->length() + 1));
 
   // Call the construct call builtin that handles allocation and
   // constructor invocation.
-  __ RecordPosition(RelocInfo::POSITION);
+  CodeForSourcePosition(node->position());
   __ Call(Handle<Code>(Builtins::builtin(Builtins::JSConstructCall)),
           RelocInfo::CONSTRUCT_CALL);
 
   // Discard old TOS value and push r0 on the stack (same as Pop(), push(r0)).
   __ str(r0, frame_->Top());
 }
 
 
 void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
@@ skipping 685 matching lines @@
       __ tst(r0, Operand(r0));
       cc_reg_ = eq;
       break;
 
     default:
       UNREACHABLE();
   }
 }
 
 
-void CodeGenerator::RecordStatementPosition(Node* node) {
-  if (FLAG_debug_info) {
-    int statement_pos = node->statement_pos();
-    if (statement_pos == RelocInfo::kNoPosition) return;
-    __ RecordStatementPosition(statement_pos);
-  }
-}
-
-
 #undef __
 #define __ masm->
 
 Handle<String> Reference::GetName() {
   ASSERT(type_ == NAMED);
   Property* property = expression_->AsProperty();
   if (property == NULL) {
     // Global variable reference treated as a named property reference.
     VariableProxy* proxy = expression_->AsVariableProxy();
     ASSERT(proxy->AsVariable() != NULL);
     ASSERT(proxy->AsVariable()->is_global());
     return proxy->name();
   } else {
     Literal* raw_name = property->key()->AsLiteral();
     ASSERT(raw_name != NULL);
     return Handle<String>(String::cast(*raw_name->handle()));
   }
 }
 
 
 void Reference::GetValue(TypeofState typeof_state) {
   ASSERT(!is_illegal());
   ASSERT(!cgen_->has_cc());
   MacroAssembler* masm = cgen_->masm();
   VirtualFrame* frame = cgen_->frame();
   Property* property = expression_->AsProperty();
   if (property != NULL) {
-    __ RecordPosition(property->position());
+    cgen_->CodeForSourcePosition(property->position());
   }
 
   switch (type_) {
     case SLOT: {
       Comment cmnt(masm, "[ Load from Slot");
       Slot* slot = expression_->AsVariableProxy()->AsVariable()->slot();
       ASSERT(slot != NULL);
       cgen_->LoadFromSlot(slot, typeof_state);
       break;
     }
@@ skipping 45 matching lines @@
 }
 
 
 void Reference::SetValue(InitState init_state) {
   ASSERT(!is_illegal());
   ASSERT(!cgen_->has_cc());
   MacroAssembler* masm = cgen_->masm();
   VirtualFrame* frame = cgen_->frame();
   Property* property = expression_->AsProperty();
   if (property != NULL) {
-    __ RecordPosition(property->position());
+    cgen_->CodeForSourcePosition(property->position());
   }
 
   switch (type_) {
     case SLOT: {
       Comment cmnt(masm, "[ Store to Slot");
       Slot* slot = expression_->AsVariableProxy()->AsVariable()->slot();
       ASSERT(slot != NULL);
       if (slot->type() == Slot::LOOKUP) {
         ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
@@ skipping 82 matching lines @@
       Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
       __ Call(ic, RelocInfo::CODE_TARGET);
       frame->Push(r0);
       break;
     }
 
     case KEYED: {
       Comment cmnt(masm, "[ Store to keyed Property");
       Property* property = expression_->AsProperty();
       ASSERT(property != NULL);
-      __ RecordPosition(property->position());
+      cgen_->CodeForSourcePosition(property->position());
 
       // Call IC code.
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
       // TODO(1222589): Make the IC grab the values from the stack.
       frame->Pop(r0);  // value
       __ Call(ic, RelocInfo::CODE_TARGET);
       frame->Push(r0);
       break;
     }
 
@@ skipping 905 matching lines @@
   __ mov(r2, Operand(0));
   __ GetBuiltinEntry(r3, Builtins::CALL_NON_FUNCTION);
   __ Jump(Handle<Code>(Builtins::builtin(Builtins::ArgumentsAdaptorTrampoline)),
           RelocInfo::CODE_TARGET);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal