Emit node id at every call to runtime.

runtime/vm/code_generator_ia32.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/code_generator.h"
 
 #include "lib/error.h"
@@ skipping 247 matching lines @@
     AstPrinter::PrintFunctionNodes(parsed_function_);
   }
   if (FLAG_trace_functions) {
     // Preserve ECX (ic-data array or object) and EDX (arguments descriptor).
     __ pushl(ECX);
     __ pushl(EDX);
     const Function& function =
         Function::ZoneHandle(parsed_function_.function().raw());
     __ LoadObject(EAX, function);
     __ pushl(EAX);
-    GenerateCallRuntime(0, kTraceFunctionEntryRuntimeEntry);
+    GenerateCallRuntime(AstNode::kNoId,
+                        0,
+                        kTraceFunctionEntryRuntimeEntry);
     __ popl(EAX);
     __ popl(EDX);
     __ popl(ECX);
   }
 
   const bool code_generation_finished = TryIntrinsify();
   // In some cases intrinsifier can generate all code and no AST based
   // code generation is needed. In some cases slow-paths (e.g., overflows) are
   // implemented by the AST based code generation and 'code_generation_finished'
   // is false.
@@ skipping 12 matching lines @@
     parsed_function_.node_sequence()->Visit(this);
   }
   // End of code.
   __ int3();
   GenerateDeferredCode();
 
   // Emit function patching code. This will be swapped with the first 5 bytes
   // at entry point.
   pc_descriptors_list_->AddDescriptor(PcDescriptors::kPatchCode,
                                       assembler_->CodeSize(),
-                                      AstNode::kInvalidId,
+                                      AstNode::kNoId,
                                       0,
                                       -1);
   __ jmp(&StubCode::FixCallersTargetLabel());
 }
 
 
 void CodeGenerator::GenerateDeferredCode() {
 }
 
 
@@ skipping 50 matching lines @@
     if (FLAG_trace_compiler) {
       OS::Print("Not checking pc decriptors, length %d\n",
                 descriptors.Length());
     }
     return;
   }
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     intptr_t pc = descriptors.PC(i);
     PcDescriptors::Kind kind = descriptors.DescriptorKind(i);
     // 'node_id' is set for kDeopt and kIcCall and must be unique for one kind.
-    intptr_t node_id = AstNode::kInvalidId;
+    intptr_t node_id = AstNode::kNoId;
     if (check_ids) {
       if ((descriptors.DescriptorKind(i) == PcDescriptors::kDeopt) ||
           (descriptors.DescriptorKind(i) == PcDescriptors::kIcCall)) {
         node_id = descriptors.NodeId(i);
       }
     }
     for (intptr_t k = i + 1; k < descriptors.Length(); k++) {
       if (kind == descriptors.DescriptorKind(k)) {
-        if (node_id != AstNode::kInvalidId) {
+        if (node_id != AstNode::kNoId) {
           ASSERT(descriptors.NodeId(k) != node_id);
         }
         ASSERT(pc != descriptors.PC(k));
       }
     }
   }
 #endif  // DEBUG
 }
 
 
@@ skipping 177 matching lines @@
       __ movl(EAX, FieldAddress(EDX, Array::data_offset()));
       if (num_opt_params == 0) {
         __ cmpl(EAX, Immediate(Smi::RawValue(num_fixed_params)));
         __ j(EQUAL, &argc_in_range, Assembler::kNearJump);
       } else {
         __ subl(EAX, Immediate(Smi::RawValue(num_fixed_params)));
         __ cmpl(EAX, Immediate(Smi::RawValue(num_opt_params)));
         __ j(BELOW_EQUAL, &argc_in_range, Assembler::kNearJump);
       }
       if (function.IsClosureFunction()) {
-        GenerateCallRuntime(function.token_index(),
+        GenerateCallRuntime(AstNode::kNoId,
+                            function.token_index(),
                             kClosureArgumentMismatchRuntimeEntry);
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&argc_in_range);
     }
   } else {
     ASSERT(first_param_index == -1);
     // Copy positional arguments.
     // Check that no fewer than num_fixed_params positional arguments are passed
@@ skipping 103 matching lines @@
     }
     delete[] opt_param;
     delete[] opt_param_position;
     // Check that EDI now points to the null terminator in the array descriptor.
     Label all_arguments_processed;
     __ cmpl(Address(EDI, 0), raw_null);
     __ j(EQUAL, &all_arguments_processed, Assembler::kNearJump);
 
     __ Bind(&wrong_num_arguments);
     if (function.IsClosureFunction()) {
-      GenerateCallRuntime(function.token_index(),
+      GenerateCallRuntime(AstNode::kNoId,
+                          function.token_index(),
                           kClosureArgumentMismatchRuntimeEntry);
     } else {
       // Invoke noSuchMethod function.
       ICData ic_data(String::Handle(function.name()), 1);
       __ LoadObject(ECX, Array::ZoneHandle(ic_data.data()));
       // EBP : points to previous frame pointer.
       // EBP + 4 : points to return address.
       // EBP + 8 : address of last argument (arg n-1).
       // ESP + 8 + 4*(n-1) : address of first argument (arg 0).
       // ECX : ic-data array.
       // EDX : arguments descriptor array.
       __ call(&StubCode::CallNoSuchMethodFunctionLabel());
     }
 
     if (FLAG_trace_functions) {
       __ pushl(EAX);  // Preserve result.
       __ PushObject(function);
-      GenerateCallRuntime(0, kTraceFunctionExitRuntimeEntry);
+      GenerateCallRuntime(AstNode::kNoId,
+                          0,
+                          kTraceFunctionExitRuntimeEntry);
       __ popl(EAX);  // Remove argument.
       __ popl(EAX);  // Restore result.
     }
     __ LeaveFrame();
     __ ret();
 
     __ Bind(&all_arguments_processed);
     // Nullify originally passed arguments only after they have been copied and
     // checked, otherwise noSuchMethod would not see their original values.
     // This step can be skipped in case we decide that formal parameters are
@@ skipping 51 matching lines @@
       __ LoadObject(EAX, literal);
     }
   } else {
     // Pop the previously evaluated result value into EAX.
     __ popl(EAX);
   }
 
   // Generate type check.
   if (FLAG_enable_type_checks) {
     GenerateAssertAssignable(
+        node->id(),
         node->value()->token_index(),
         Type::ZoneHandle(parsed_function().function().result_type()),
         String::ZoneHandle(String::NewSymbol("function result")));
   }
   // Unchain the context(s) up to context level 0.
   int context_level = state()->context_level();
   ASSERT(context_level >= 0);
   while (context_level-- > 0) {
     __ movl(CTX, FieldAddress(CTX, Context::parent_offset()));
   }
 #ifdef DEBUG
   // Check that the entry stack size matches the exit stack size.
   __ movl(EDX, EBP);
   __ subl(EDX, ESP);
   ASSERT(locals_space_size() >= 0);
   __ cmpl(EDX, Immediate(locals_space_size()));
   Label wrong_stack;
   __ j(NOT_EQUAL, &wrong_stack, Assembler::kNearJump);
 #endif  // DEBUG.
 
   if (FLAG_trace_functions) {
     __ pushl(EAX);  // Preserve result.
     const Function& function =
         Function::ZoneHandle(parsed_function_.function().raw());
     __ LoadObject(EBX, function);
     __ pushl(EBX);
-    GenerateCallRuntime(0, kTraceFunctionExitRuntimeEntry);
+    GenerateCallRuntime(AstNode::kNoId,
+                        0,
+                        kTraceFunctionExitRuntimeEntry);
     __ popl(EAX);  // Remove argument.
     __ popl(EAX);  // Restore result.
   }
   __ LeaveFrame();
   __ ret();
 
 #ifdef DEBUG
   __ Bind(&wrong_stack);
   __ Stop("Exit stack size does not match the entry stack size.");
 #endif  // DEBUG.
@@ skipping 171 matching lines @@
   if (IsResultNeeded(node)) {
     GeneratePushVariable(node->local(), EAX);
   }
 }
 
 
 void CodeGenerator::VisitStoreLocalNode(StoreLocalNode* node) {
   node->value()->Visit(this);
   __ popl(EAX);
   if (FLAG_enable_type_checks) {
-    GenerateAssertAssignable(node->value()->token_index(),
+    GenerateAssertAssignable(node->id(),
+                             node->value()->token_index(),
                              node->local().type(),
                              node->local().name());
   }
   GenerateStoreVariable(node->local(), EAX, EDX);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitLoadInstanceFieldNode(LoadInstanceFieldNode* node) {
   node->instance()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   __ popl(EAX);  // Instance.
   __ movl(EAX, FieldAddress(EAX, node->field().Offset()));
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStoreInstanceFieldNode(StoreInstanceFieldNode* node) {
   node->instance()->Visit(this);
   node->value()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   __ popl(EAX);  // Value.
   if (FLAG_enable_type_checks) {
-    GenerateAssertAssignable(node->value()->token_index(),
+    GenerateAssertAssignable(node->id(),
+                             node->value()->token_index(),
                              Type::ZoneHandle(node->field().type()),
                              String::ZoneHandle(node->field().name()));
   }
   __ popl(EDX);  // Instance.
   __ StoreIntoObject(EDX, FieldAddress(EDX, node->field().Offset()), EAX);
   if (IsResultNeeded(node)) {
     // The result is the input value.
     __ pushl(EAX);
   }
 }
@@ skipping 80 matching lines @@
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitStoreStaticFieldNode(StoreStaticFieldNode* node) {
   node->value()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   __ popl(EAX);  // Value.
   if (FLAG_enable_type_checks) {
-    GenerateAssertAssignable(node->value()->token_index(),
+    GenerateAssertAssignable(node->id(),
+                             node->value()->token_index(),
                              Type::ZoneHandle(node->field().type()),
                              String::ZoneHandle(node->field().name()));
   }
   __ LoadObject(EDX, node->field());
   __ StoreIntoObject(EDX, FieldAddress(EDX, Field::value_offset()), EAX);
   if (IsResultNeeded(node)) {
     // The result is the input value.
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::GenerateLogicalNotOp(UnaryOpNode* node) {
   // Generate false if operand is true, otherwise generate true.
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   node->operand()->Visit(this);
   MarkDeoptPoint(node->id(), node->token_index());
   Label done;
-  GenerateConditionTypeCheck(node->operand()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->operand()->token_index());
   __ popl(EDX);
   __ LoadObject(EAX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, &done, Assembler::kNearJump);
   __ LoadObject(EAX, bool_false);
   __ Bind(&done);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
@@ skipping 41 matching lines @@
     // Preserve as result.
     __ pushl(EAX);
   }
   const Immediate value = Immediate(reinterpret_cast<int32_t>(Smi::New(1)));
   const char* operator_name = (node->kind() == Token::kINCR) ? "+" : "-";
   __ pushl(EAX);
   __ pushl(value);
   GenerateBinaryOperatorCall(node->id(), node->token_index(), operator_name);
   // result is in EAX.
   if (FLAG_enable_type_checks) {
-    GenerateAssertAssignable(
-        node->token_index(), node->local().type(), node->local().name());
+    GenerateAssertAssignable(node->id(),
+                             node->token_index(),
+                             node->local().type(),
+                             node->local().name());
   }
   GenerateStoreVariable(node->local(), EAX, EDX);
   if (node->prefix() && IsResultNeeded(node)) {
     __ pushl(EAX);
   }
 }
 
 
 void CodeGenerator::VisitIncrOpInstanceFieldNode(
     IncrOpInstanceFieldNode* node) {
@@ skipping 62 matching lines @@
   }
   if (node->field().IsNull()) {
     __ pushl(EAX);
     // It is not necessary to generate a type test of the assigned value here,
     // because the setter will check the type of its incoming arguments.
     GenerateStaticSetterCall(node->token_index(),
                              node->field_class(),
                              node->field_name());
   } else {
     if (FLAG_enable_type_checks) {
-      GenerateAssertAssignable(node->token_index(),
+      GenerateAssertAssignable(node->id(),
+                               node->token_index(),
                                Type::ZoneHandle(node->field().type()),
                                String::ZoneHandle(node->field().name()));
     }
     __ LoadObject(EDX, node->field());
     __ StoreIntoObject(EDX, FieldAddress(EDX, Field::value_offset()), EAX);
   }
 }
 
 
 void CodeGenerator::VisitIncrOpIndexedNode(IncrOpIndexedNode* node) {
@@ skipping 31 matching lines @@
 
 // Optimize instanceof type test by adding inlined tests for:
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX.
 // Returns:
 // - true or false on stack.
-void CodeGenerator::GenerateInstanceOf(intptr_t token_index,
+void CodeGenerator::GenerateInstanceOf(intptr_t node_id,
+                                       intptr_t token_index,
                                        const Type& type,
                                        bool negate_result) {
   ASSERT(type.IsFinalized());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   // All instances are of type Object.
   const Type& object_type =
       Type::Handle(Isolate::Current()->object_store()->object_type());
   if (type.IsInstantiated() && object_type.IsSubtypeOf(type)) {
@@ skipping 56 matching lines @@
   }
   const Object& result = Object::ZoneHandle();
   __ PushObject(result);  // Make room for the result of the runtime call.
   __ pushl(EAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (!type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushl(raw_null);  // Null instantiator.
   }
-  GenerateCallRuntime(token_index, kInstanceofRuntimeEntry);
+  GenerateCallRuntime(node_id, token_index, kInstanceofRuntimeEntry);
   // Pop the two parameters supplied to the runtime entry. The result of the
   // instanceof runtime call will be left as the result of the operation.
   __ addl(ESP, Immediate(3 * kWordSize));
   if (negate_result) {
     Label negate_done;
     __ popl(EDX);
     __ LoadObject(EAX, bool_true);
     __ cmpl(EDX, EAX);
     __ j(NOT_EQUAL, &negate_done, Assembler::kNearJump);
     __ LoadObject(EAX, bool_false);
@@ skipping 19 matching lines @@
 
 // Optimize assignable type check by adding inlined tests for:
 // - NULL -> return NULL.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - EAX: object.
 // Destroys ECX and EDX.
 // Returns:
 // - object in EAX for successful assignable check (or throws TypeError).
-void CodeGenerator::GenerateAssertAssignable(intptr_t token_index,
+void CodeGenerator::GenerateAssertAssignable(intptr_t node_id,
+                                             intptr_t token_index,
                                              const Type& dst_type,
                                              const String& dst_name) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(token_index >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
 
   // Any expression is assignable to the DynamicType. Skip the test.
   if (dst_type.IsDynamicType()) {
     return;
@@ skipping 97 matching lines @@
       Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
   __ pushl(location);  // Push the source location.
   __ pushl(EAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   if (!dst_type.IsInstantiated()) {
     GenerateInstantiatorTypeArguments(token_index);
   } else {
     __ pushl(raw_null);  // Null instantiator.
   }
   __ PushObject(dst_name);  // Push the name of the destination.
-  GenerateCallRuntime(token_index, kTypeCheckRuntimeEntry);
+  GenerateCallRuntime(node_id, token_index, kTypeCheckRuntimeEntry);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ addl(ESP, Immediate(5 * kWordSize));
   __ popl(EAX);
 
   __ Bind(&done);
 }
 
 
 void CodeGenerator::GenerateArgumentTypeChecks() {
   const Function& function = parsed_function_.function();
   LocalScope* scope = parsed_function_.node_sequence()->scope();
   const int num_fixed_params = function.num_fixed_parameters();
   const int num_opt_params = function.num_optional_parameters();
   ASSERT(num_fixed_params + num_opt_params <= scope->num_variables());
   for (int i = 0; i < num_fixed_params + num_opt_params; i++) {
     LocalVariable* parameter = scope->VariableAt(i);
     GenerateLoadVariable(EAX, *parameter);
-    GenerateAssertAssignable(
-        parameter->token_index(), parameter->type(), parameter->name());
+    GenerateAssertAssignable(AstNode::kNoId,
+                             parameter->token_index(),
+                             parameter->type(),
+                             parameter->name());
   }
 }
 
 
-void CodeGenerator::GenerateConditionTypeCheck(intptr_t token_index) {
+void CodeGenerator::GenerateConditionTypeCheck(intptr_t node_id,
+                                               intptr_t token_index) {
   if (!FLAG_enable_type_checks) {
     return;
   }
 
   // Check that the type of the object on the stack is allowed in conditional
   // context.
   // Call the runtime if the object is null or not of type bool.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label runtime_call, done;
@@ skipping 11 matching lines @@
   __ CompareObject(ECX, bool_class);
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   __ Bind(&runtime_call);
   const Object& result = Object::ZoneHandle();
   __ PushObject(result);  // Make room for the result of the runtime call.
   const Immediate location =
       Immediate(reinterpret_cast<int32_t>(Smi::New(token_index)));
   __ pushl(location);  // Push the source location.
   __ pushl(EAX);  // Push the source object.
-  GenerateCallRuntime(token_index, kConditionTypeErrorRuntimeEntry);
+  GenerateCallRuntime(node_id, token_index, kConditionTypeErrorRuntimeEntry);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ addl(ESP, Immediate(3 * kWordSize));
 
   __ Bind(&done);
 }
 
 
 void CodeGenerator::VisitComparisonNode(ComparisonNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   node->left()->Visit(this);
 
   // The instanceof operator needs special handling.
   if (Token::IsInstanceofOperator(node->kind())) {
     __ popl(EAX);  // Left operand.
     ASSERT(node->right()->IsTypeNode());
-    GenerateInstanceOf(node->token_index(),
+    GenerateInstanceOf(node->id(),
+                       node->token_index(),
                        node->right()->AsTypeNode()->type(),
                        (node->kind() == Token::kISNOT));
     if (!IsResultNeeded(node)) {
       __ popl(EAX);  // Pop the result of the instanceof operation.
     }
     return;
   }
 
   node->right()->Visit(this);
   // Both left and right values on stack.
@@ skipping 111 matching lines @@
   __ movl(FieldAddress(EAX, Function::invocation_counter_offset()), EBX);
   __ Bind(&done);
 }
 
 
 void CodeGenerator::VisitWhileNode(WhileNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   SourceLabel* label = node->label();
   __ Bind(label->continue_label());
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, label->break_label());
   node->body()->Visit(this);
   CountBackwardLoop();
   __ jmp(label->continue_label());
   __ Bind(label->break_label());
 }
 
 
 void CodeGenerator::VisitDoWhileNode(DoWhileNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   SourceLabel* label = node->label();
   Label loop;
   __ Bind(&loop);
   node->body()->Visit(this);
   CountBackwardLoop();
   __ Bind(label->continue_label());
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(EQUAL, &loop);
   __ Bind(label->break_label());
 }
 
 
 void CodeGenerator::VisitForNode(ForNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   node->initializer()->Visit(this);
   SourceLabel* label = node->label();
   Label loop;
   __ Bind(&loop);
   if (node->condition() != NULL) {
     node->condition()->Visit(this);
-    GenerateConditionTypeCheck(node->condition()->token_index());
+    GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
     __ popl(EAX);
     __ LoadObject(EDX, bool_true);
     __ cmpl(EAX, EDX);
     __ j(NOT_EQUAL, label->break_label());
   }
   node->body()->Visit(this);
   CountBackwardLoop();
   __ Bind(label->continue_label());
   node->increment()->Visit(this);
   __ jmp(&loop);
@@ skipping 31 matching lines @@
   } else {
     __ jmp(label->continue_label());
   }
 }
 
 
 void CodeGenerator::VisitConditionalExprNode(ConditionalExprNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Label false_label, done;
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, &false_label);
   node->true_expr()->Visit(this);
   __ jmp(&done);
   __ Bind(&false_label);
   node->false_expr()->Visit(this);
   __ Bind(&done);
   if (!IsResultNeeded(node)) {
@@ skipping 39 matching lines @@
   __ Bind(&case_statements);
   node->statements()->Visit(this);
   __ Bind(&end_case);
 }
 
 
 void CodeGenerator::VisitIfNode(IfNode* node) {
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   Label false_label;
   node->condition()->Visit(this);
-  GenerateConditionTypeCheck(node->condition()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->condition()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(NOT_EQUAL, &false_label);
   node->true_branch()->Visit(this);
   if (node->false_branch() != NULL) {
     Label done;
     __ jmp(&done);
     __ Bind(&false_label);
     node->false_branch()->Visit(this);
     __ Bind(&done);
   } else {
     __ Bind(&false_label);
   }
 }
 
 
 // Operators '&&' and '||' are not overloadabled, inline them.
 void CodeGenerator::GenerateLogicalAndOrOp(BinaryOpNode* node) {
   // Generate true if (left == true) op (right == true), otherwise generate
   // false, with op being either || or &&.
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
   Label load_false, done;
   node->left()->Visit(this);
-  GenerateConditionTypeCheck(node->left()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->left()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   if (node->kind() == Token::kAND) {
     __ j(NOT_EQUAL, &load_false);
   } else {
     ASSERT(node->kind() == Token::kOR);
     __ j(EQUAL, &done);
   }
   node->right()->Visit(this);
-  GenerateConditionTypeCheck(node->right()->token_index());
+  GenerateConditionTypeCheck(node->id(), node->right()->token_index());
   __ popl(EAX);
   __ LoadObject(EDX, bool_true);
   __ cmpl(EAX, EDX);
   __ j(EQUAL, &done);
   __ Bind(&load_false);
   __ LoadObject(EAX, bool_false);
   __ Bind(&done);
   if (IsResultNeeded(node)) {
     __ pushl(EAX);
   }
@@ skipping 252 matching lines @@
       __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     }
     __ Bind(&type_arguments_uninstantiated);
     if (node->constructor().IsFactory()) {
       // A runtime call to instantiate the type arguments is required before
       // calling the factory.
       const Object& result = Object::ZoneHandle();
       __ PushObject(result);  // Make room for the result of the runtime call.
       __ PushObject(node->type_arguments());
       __ pushl(EAX);  // Push instantiator type arguments.
-      GenerateCallRuntime(node->token_index(),
+      GenerateCallRuntime(node->id(),
+                          node->token_index(),
                           kInstantiateTypeArgumentsRuntimeEntry);
       __ popl(EAX);  // Pop instantiator type arguments.
       __ popl(EAX);  // Pop uninstantiated type arguments.
       __ popl(EAX);  // Pop instantiated type arguments.
       __ Bind(&type_arguments_instantiated);
       __ pushl(EAX);  // Instantiated type arguments.
     } else {
       // In the non-factory case, we rely on the allocation stub to
       // instantiate the type arguments.
       __ PushObject(node->type_arguments());
@@ skipping 296 matching lines @@
 
 
 void CodeGenerator::VisitThrowNode(ThrowNode* node) {
   const Object& result = Object::ZoneHandle();
   node->exception()->Visit(this);
   __ popl(EAX);  // Exception object is now in EAX.
   if (node->stacktrace() != NULL) {
     __ PushObject(result);  // Make room for the result of the runtime call.
     __ pushl(EAX);  // Push the exception object.
     node->stacktrace()->Visit(this);
-    GenerateCallRuntime(node->token_index(), kReThrowRuntimeEntry);
+    GenerateCallRuntime(node->id(), node->token_index(), kReThrowRuntimeEntry);
   } else {
     __ PushObject(result);  // Make room for the result of the runtime call.
     __ pushl(EAX);  // Push the exception object.
-    GenerateCallRuntime(node->token_index(), kThrowRuntimeEntry);
+    GenerateCallRuntime(node->id(), node->token_index(), kThrowRuntimeEntry);
   }
   // We should never return here.
   __ int3();
 }
 
 
 void CodeGenerator::VisitInlinedFinallyNode(InlinedFinallyNode* node) {
   int try_index = state()->try_index();
   if (try_index >= 0) {
     // We are about to generate code for an inlined finally block. Exceptions
     // thrown in this block of code should be treated as though they are
     // thrown not from the current try block but the outer try block if any.
     // the code generator state.
     state()->set_try_index((try_index - 1));
   }
 
   // Restore CTX from local variable ':saved_context'.
   GenerateLoadVariable(CTX, node->context_var());
   node->finally_block()->Visit(this);
 
   if (try_index >= 0) {
     state()->set_try_index(try_index);
   }
 }
 
 
 void CodeGenerator::GenerateCall(intptr_t token_index,
                                  const ExternalLabel* ext_label) {
   __ call(ext_label);
-  AddCurrentDescriptor(PcDescriptors::kOther, AstNode::kInvalidId, token_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, AstNode::kNoId, token_index);
 }
 
 
-void CodeGenerator::GenerateCallRuntime(intptr_t token_index,
+void CodeGenerator::GenerateCallRuntime(intptr_t node_id,
+                                        intptr_t token_index,
                                         const RuntimeEntry& entry) {
   __ CallRuntimeFromDart(entry);
-  AddCurrentDescriptor(PcDescriptors::kOther, AstNode::kInvalidId, token_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index);
 }
 
 
 void CodeGenerator::MarkDeoptPoint(intptr_t node_id,
                                    intptr_t token_index) {
-  ASSERT(node_id != AstNode::kInvalidId);
+  ASSERT(node_id != AstNode::kNoId);
   AddCurrentDescriptor(PcDescriptors::kDeopt, node_id, token_index);
 }
 
 
 // Uses current pc position and try-index.
 void CodeGenerator::AddCurrentDescriptor(PcDescriptors::Kind kind,
                                          intptr_t node_id,
                                          intptr_t token_index) {
   pc_descriptors_list_->AddDescriptor(kind,
                                       assembler_->CodeSize(),
@@ skipping 10 matching lines @@
   const Class& cls = Class::Handle(parsed_function_.function().owner());
   const Script& script = Script::Handle(cls.script());
   Parser::ReportMsg(script, token_index, "Error", error_msg, format, args);
   Isolate::Current()->long_jump_base()->Jump(1, error_msg);
   UNREACHABLE();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32