Defer the writing of the source position data to the relocation information...

src/codegen-ia32.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 2638 matching lines @@
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     __ j(below, deferred->enter(), not_taken);
     __ bind(deferred->exit());
   }
 }
 
 
 void Ia32CodeGenerator::VisitBlock(Block* node) {
   Comment cmnt(masm_, "[ Block");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
   VisitStatements(node->statements());
   __ bind(node->break_target());
 }
 
 
 void Ia32CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   __ push(Immediate(pairs));
   __ push(Operand(esi));
   __ push(Immediate(Smi::FromInt(is_eval() ? 1 : 0)));
@@ skipping 57 matching lines @@
     Load(val);
     SetValue(&target);
     // Get rid of the assigned value (declarations are statements).
     __ pop(eax);  // Pop(no_reg);
   }
 }
 
 
 void Ia32CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) {
   Comment cmnt(masm_, "[ ExpressionStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   Expression* expression = node->expression();
   expression->MarkAsStatement();
   Load(expression);
   __ pop(eax);  // remove the lingering expression result from the top of stack
 }
 
 
 void Ia32CodeGenerator::VisitEmptyStatement(EmptyStatement* node) {
   Comment cmnt(masm_, "// EmptyStatement");
   // nothing to do
 }
 
 
 void Ia32CodeGenerator::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);
+  RecordStatementPosition(node);
   Label exit;
   if (has_then_stm && has_else_stm) {
     Label then;
     Label else_;
     // if (cond)
     LoadCondition(node->condition(), CodeGenState::LOAD, &then, &else_, true);
     Branch(false, &else_);
     // then
     __ bind(&then);
     Visit(node->then_statement());
@@ skipping 43 matching lines @@
 void Ia32CodeGenerator::CleanStack(int num_bytes) {
   ASSERT(num_bytes >= 0);
   if (num_bytes > 0) {
     __ add(Operand(esp), Immediate(num_bytes));
   }
 }
 
 
 void Ia32CodeGenerator::VisitContinueStatement(ContinueStatement* node) {
   Comment cmnt(masm_, "[ ContinueStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
   __ jmp(node->target()->continue_target());
 }
 
 
 void Ia32CodeGenerator::VisitBreakStatement(BreakStatement* node) {
   Comment cmnt(masm_, "[ BreakStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
   __ jmp(node->target()->break_target());
 }
 
 
 void Ia32CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
   Comment cmnt(masm_, "[ ReturnStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   Load(node->expression());
 
   // Move the function result into eax
   __ pop(eax);
 
   // If we're inside a try statement or the return instruction
   // sequence has been generated, we just jump to that
   // point. Otherwise, we generate the return instruction sequence and
   // bind the function return label.
   if (is_inside_try_ || function_return_.is_bound()) {
@@ skipping 17 matching lines @@
     // Check that the size of the code used for returning matches what is
     // expected by the debugger.
     ASSERT_EQ(Debug::kIa32JSReturnSequenceLength,
               __ SizeOfCodeGeneratedSince(&check_exit_codesize));
   }
 }
 
 
 void Ia32CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
   Comment cmnt(masm_, "[ WithEnterStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   Load(node->expression());
   __ CallRuntime(Runtime::kPushContext, 1);
 
   if (kDebug) {
     Label verified_true;
     // Verify eax and esi are the same in debug mode
     __ cmp(eax, Operand(esi));
     __ j(equal, &verified_true);
     __ int3();
     __ bind(&verified_true);
   }
 
   // Update context local.
   __ mov(Operand(ebp, StandardFrameConstants::kContextOffset), esi);
 }
 
 
 void Ia32CodeGenerator::VisitWithExitStatement(WithExitStatement* node) {
   Comment cmnt(masm_, "[ WithExitStatement");
   // Pop context.
   __ mov(esi, ContextOperand(esi, Context::PREVIOUS_INDEX));
   // Update context local.
   __ mov(Operand(ebp, StandardFrameConstants::kContextOffset), esi);
 }
 
 
 void Ia32CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   Comment cmnt(masm_, "[ SwitchStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
 
   Load(node->tag());
 
   Label next, fall_through, default_case;
   ZoneList<CaseClause*>* cases = node->cases();
   int length = cases->length();
 
   for (int i = 0; i < length; i++) {
     CaseClause* clause = cases->at(i);
@@ skipping 43 matching lines @@
     __ pop(eax);
   }
 
   __ bind(&fall_through);
   __ bind(node->break_target());
 }
 
 
 void Ia32CodeGenerator::VisitLoopStatement(LoopStatement* node) {
   Comment cmnt(masm_, "[ LoopStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(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 20 matching lines @@
   __ bind(&loop);
   CheckStack();  // TODO(1222600): ignore if body contains calls.
   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());
+    RecordStatementPosition(node);
+    __ RecordPosition(node->statement_pos());
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     Visit(node->next());
   }
 
   // cond
   __ bind(&entry);
   switch (info) {
     case ALWAYS_TRUE:
       __ jmp(&loop);
       break;
     case ALWAYS_FALSE:
       break;
     case DONT_KNOW:
       LoadCondition(node->cond(), CodeGenState::LOAD, &loop,
                     node->break_target(), true);
       Branch(true, &loop);
       break;
   }
 
   // exit
   __ bind(node->break_target());
 }
 
 
 void Ia32CodeGenerator::VisitForInStatement(ForInStatement* node) {
   Comment cmnt(masm_, "[ ForInStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(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 end_del_check, fixed_array;
@@ skipping 391 matching lines @@
   __ push(eax);  // undo pop from above
   __ CallRuntime(Runtime::kReThrow, 1);
 
   // Done.
   __ bind(&exit);
 }
 
 
 void Ia32CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) {
   Comment cmnt(masm_, "[ DebuggerStatement");
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
   __ CallRuntime(Runtime::kDebugBreak, 1);
   __ push(eax);
 }
 
 
 void Ia32CodeGenerator::InstantiateBoilerplate(Handle<JSFunction> boilerplate) {
   ASSERT(boilerplate->IsBoilerplate());
 
   // Push the boilerplate on the stack.
   __ push(Immediate(boilerplate));
@@ skipping 342 matching lines @@
 bool Ia32CodeGenerator::IsInlineSmi(Literal* literal) {
   if (literal == NULL || !literal->handle()->IsSmi()) return false;
   int int_value = Smi::cast(*literal->handle())->value();
   return is_intn(int_value, kMaxSmiInlinedBits);
 }
 
 
 void Ia32CodeGenerator::VisitAssignment(Assignment* node) {
   Comment cmnt(masm_, "[ Assignment");
 
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(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 {
     GetValue(&target);
@@ skipping 47 matching lines @@
     GetValue(&property);
   }
 }
 
 
 void Ia32CodeGenerator::VisitCall(Call* node) {
   Comment cmnt(masm_, "[ Call");
 
   ZoneList<Expression*>* args = node->arguments();
 
-  if (FLAG_debug_info) RecordStatementPosition(node);
+  RecordStatementPosition(node);
 
   // 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.
   // ---
   // According to ECMA-262, section 11.2.3, page 44, the function to call
@@ skipping 1508 matching lines @@
                                      bool is_eval) {
   Handle<Code> code = Ia32CodeGenerator::MakeCode(fun, script, is_eval);
   if (!code.is_null()) {
     Counters::total_compiled_code_size.Increment(code->instruction_size());
   }
   return code;
 }
 
 
 } }  // namespace v8::internal