Switch from AST node ids to computation ids (cid). In addition to computations,…

runtime/vm/flow_graph_compiler_x64.cc

 // Copyright (c) 2012, 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_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 274 matching lines @@
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
 // - RDX: optional instantiator type arguments.
 // Destroys RCX and RDX.
 // Returns:
 // - object in RAX for successful assignable check (or throws TypeError).
 // Performance notes: positive checks must be quick, negative checks can be slow
 // as they throw an exception.
-void FlowGraphCompiler::GenerateAssertAssignable(intptr_t node_id,
+void FlowGraphCompiler::GenerateAssertAssignable(intptr_t cid,
                                                  intptr_t token_index,
                                                  intptr_t try_index,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name) {
   ASSERT(FLAG_enable_type_checks);
   ASSERT(token_index >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
   ASSERT(dst_type.IsMalformed() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
@@ skipping 11 matching lines @@
     const Error& error = Error::Handle(dst_type.malformed_error());
     const String& error_message = String::ZoneHandle(
         String::NewSymbol(error.ToErrorCString()));
     __ PushObject(Object::ZoneHandle());  // Make room for the result.
     const Immediate location =
         Immediate(reinterpret_cast<int64_t>(Smi::New(token_index)));
     __ pushq(location);  // Push the source location.
     __ pushq(RAX);  // Push the source object.
     __ PushObject(dst_name);  // Push the name of the destination.
     __ PushObject(error_message);
-    GenerateCallRuntime(node_id,
+    GenerateCallRuntime(cid,
                         token_index,
                         try_index,
                         kMalformedTypeErrorRuntimeEntry);
     // We should never return here.
     __ int3();
 
     __ Bind(&is_assignable);  // For a null object.
     return;
   }
 
   // Generate inline type check, linking to runtime call if not assignable.
   GenerateInlineInstanceof(dst_type, &is_assignable, &runtime_call);
 
   __ Bind(&runtime_call);
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   const Immediate location =
       Immediate(reinterpret_cast<int64_t>(Smi::New(token_index)));
-  const Immediate node_id_as_smi =
-      Immediate(reinterpret_cast<int64_t>(Smi::New(node_id)));
+  const Immediate cid_as_smi =
+      Immediate(reinterpret_cast<int64_t>(Smi::New(cid)));
   __ pushq(location);  // Push the source location.
-  __ pushq(node_id_as_smi);  // node-id.
+  __ pushq(cid_as_smi);  // node-id.
   __ pushq(RAX);  // Push the source object.
   __ PushObject(dst_type);  // Push the type of the destination.
   if (!dst_type.IsInstantiated()) {
     __ pushq(RDX);  // Instantiator type arguments.
   } else {
     __ pushq(raw_null);  // Null instantiator.
   }
   __ PushObject(dst_name);  // Push the name of the destination.
-  GenerateCallRuntime(node_id,
+  GenerateCallRuntime(cid,
                       token_index,
                       try_index,
                       kTypeCheckRuntimeEntry);
   // Pop the parameters supplied to the runtime entry. The result of the
   // type check runtime call is the checked value.
   __ addq(RSP, Immediate(6 * kWordSize));
   __ popq(RAX);
 
   __ Bind(&is_assignable);
 }
@@ skipping 28 matching lines @@
 void FlowGraphCompiler::VisitConstant(ConstantVal* val) {
   LoadValue(RAX, val);
 }
 
 
 void FlowGraphCompiler::VisitAssertAssignable(AssertAssignableComp* comp) {
   if (comp->instantiator_type_arguments() != NULL) {
     __ popq(RDX);
   }
   LoadValue(RAX, comp->value());
-  GenerateAssertAssignable(comp->node_id(),
+  GenerateAssertAssignable(comp->cid(),
                            comp->token_index(),
                            comp->try_index(),
                            comp->dst_type(),
                            comp->dst_name());
 }
 
 
 void FlowGraphCompiler::VisitAssertBoolean(AssertBooleanComp* comp) {
   LoadValue(RAX, comp->value());
   // Check that the type of the value is allowed in conditional context.
   // Call the runtime if the object is not bool::true or bool::false.
   Label done;
   __ CompareObject(RAX, Bool::ZoneHandle(Bool::True()));
   __ j(EQUAL, &done, Assembler::kNearJump);
   __ CompareObject(RAX, Bool::ZoneHandle(Bool::False()));
   __ j(EQUAL, &done, Assembler::kNearJump);
 
   const Immediate location =
       Immediate(reinterpret_cast<int64_t>(Smi::New(comp->token_index())));
   __ pushq(location);  // Push the source location.
   __ pushq(RAX);  // Push the source object.
-  GenerateCallRuntime(comp->node_id(),
+  GenerateCallRuntime(comp->cid(),
                       comp->token_index(),
                       comp->try_index(),
                       kConditionTypeErrorRuntimeEntry);
   // We should never return here.
   __ int3();
 
   __ Bind(&done);
 }
 
 
@@ skipping 22 matching lines @@
 
 // Truee iff. the v2 is above v1 on stack, or one of them is constant.
 static bool VerifyValues(Value* v1, Value* v2) {
   if (v1->IsTemp() && v2->IsTemp()) {
     return (v1->AsTemp()->index() + 1) == v2->AsTemp()->index();
   }
   return true;
 }
 
 
-void FlowGraphCompiler::EmitInstanceCall(intptr_t node_id,
+void FlowGraphCompiler::EmitInstanceCall(intptr_t cid,
                                          intptr_t token_index,
                                          intptr_t try_index,
                                          const String& function_name,
                                          intptr_t argument_count,
                                          const Array& argument_names,
                                          intptr_t checked_argument_count) {
   ICData& ic_data =
       ICData::ZoneHandle(ICData::New(parsed_function_.function(),
                                      function_name,
-                                     node_id,
+                                     cid,
                                      checked_argument_count));
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count, argument_names);
   __ LoadObject(RBX, ic_data);
   __ LoadObject(R10, arguments_descriptor);
 
   uword label_address = 0;
   switch (checked_argument_count) {
     case 1:
       label_address = StubCode::OneArgCheckInlineCacheEntryPoint();
       break;
     case 2:
       label_address = StubCode::TwoArgsCheckInlineCacheEntryPoint();
       break;
     default:
       UNIMPLEMENTED();
   }
   ExternalLabel target_label("InlineCache", label_address);
   __ call(&target_label);
-  AddCurrentDescriptor(PcDescriptors::kIcCall, node_id, token_index, try_index);
+  AddCurrentDescriptor(PcDescriptors::kIcCall, cid, token_index, try_index);
   __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
 void FlowGraphCompiler::EmitStaticCall(intptr_t token_index,
                                        intptr_t try_index,
                                        const Function& function,
                                        intptr_t argument_count,
                                        const Array& argument_names) {
   const Array& arguments_descriptor =
@@ skipping 35 matching lines @@
                comp->try_index(),
                &StubCode::CallClosureFunctionLabel(),
                PcDescriptors::kOther);
   __ addq(RSP, Immediate(argument_count * kWordSize));
   __ popq(CTX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceCall(InstanceCallComp* comp) {
   ASSERT(VerifyCallComputation(comp));
-  EmitInstanceCall(comp->node_id(),
+  EmitInstanceCall(comp->cid(),
                    comp->token_index(),
                    comp->try_index(),
                    comp->function_name(),
                    comp->ArgumentCount(),
                    comp->argument_names(),
                    comp->checked_argument_count());
 }
 
 
 void FlowGraphCompiler::VisitStrictCompare(StrictCompareComp* comp) {
@@ skipping 36 matching lines @@
   __ jmp(&done);
 
   __ Bind(&non_null_compare);
   __ pushq(RAX);
   __ pushq(RDX);
   const String& operator_name = String::ZoneHandle(String::NewSymbol("=="));
   const int kNumberOfArguments = 2;
   const Array& kNoArgumentNames = Array::Handle();
   const int kNumArgumentsChecked = 1;
 
-  EmitInstanceCall(comp->node_id(),
+  EmitInstanceCall(comp->cid(),
                    comp->token_index(),
                    comp->try_index(),
                    operator_name,
                    kNumberOfArguments,
                    kNoArgumentNames,
                    kNumArgumentsChecked);
   __ Bind(&done);
 }
 
 
@@ skipping 106 matching lines @@
       String::ZoneHandle(String::NewSymbol(Token::Str(Token::kASSIGN_INDEX)));
 
   // Insert a copy of the third (last) argument under the arguments.
   __ popq(RAX);  // Value.
   __ popq(RBX);  // Index.
   __ popq(RCX);  // Receiver.
   __ pushq(RAX);
   __ pushq(RCX);
   __ pushq(RBX);
   __ pushq(RAX);
-  EmitInstanceCall(comp->node_id(),
+  EmitInstanceCall(comp->cid(),
                    comp->token_index(),
                    comp->try_index(),
                    function_name,
                    3,
                    Array::ZoneHandle(),
                    1);
   __ popq(RAX);
 }
 
 
 void FlowGraphCompiler::VisitInstanceSetter(InstanceSetterComp* comp) {
   // Preserve the second argument under the arguments as the result of the
   // computation, then call the setter.
   const String& function_name =
       String::ZoneHandle(Field::SetterSymbol(comp->field_name()));
 
   // Insert a copy of the second (last) argument under the arguments.
   __ popq(RAX);  // Value.
   __ popq(RBX);  // Receiver.
   __ pushq(RAX);
   __ pushq(RBX);
   __ pushq(RAX);
-  EmitInstanceCall(comp->node_id(),
+  EmitInstanceCall(comp->cid(),
                    comp->token_index(),
                    comp->try_index(),
                    function_name,
                    2,
                    Array::ZoneHandle(),
                    1);
   __ popq(RAX);
 }
 
 
@@ skipping 29 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:
 // - RAX: object.
 // - RDX: optional instantiator type arguments.
 // Destroys RCX and RDX.
 // Returns:
 // - true or false in RAX.
-void FlowGraphCompiler::GenerateInstanceOf(intptr_t node_id,
+void FlowGraphCompiler::GenerateInstanceOf(intptr_t cid,
                                            intptr_t token_index,
                                            intptr_t try_index,
                                            const AbstractType& type,
                                            bool negate_result) {
   ASSERT(type.IsFinalized() && !type.IsMalformed());
   const Bool& bool_true = Bool::ZoneHandle(Bool::True());
   const Bool& bool_false = Bool::ZoneHandle(Bool::False());
 
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
@@ skipping 12 matching lines @@
     __ j(EQUAL, &is_not_instance);
   }
 
   // Generate inline instanceof test.
   GenerateInlineInstanceof(type, &is_instance, &is_not_instance);
 
   // Generate runtime call.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   const Immediate location =
       Immediate(reinterpret_cast<int64_t>(Smi::New(token_index)));
-  const Immediate node_id_as_smi =
-      Immediate(reinterpret_cast<int64_t>(Smi::New(node_id)));
+  const Immediate cid_as_smi =
+      Immediate(reinterpret_cast<int64_t>(Smi::New(cid)));
   __ pushq(location);  // Push the source location.
-  __ pushq(node_id_as_smi);
+  __ pushq(cid_as_smi);
   __ pushq(RAX);  // Push the instance.
   __ PushObject(type);  // Push the type.
   if (!type.IsInstantiated()) {
     __ pushq(RDX);  // Instantiator type arguments.
   } else {
     __ pushq(raw_null);  // Null instantiator.
   }
-  GenerateCallRuntime(node_id, token_index, try_index, kInstanceofRuntimeEntry);
+  GenerateCallRuntime(cid, token_index, try_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.
   __ addq(RSP, Immediate(5 * kWordSize));
   Label done;
   if (negate_result) {
     __ popq(RDX);
     __ LoadObject(RAX, bool_true);
     __ cmpq(RDX, RAX);
     __ j(NOT_EQUAL, &done, Assembler::kNearJump);
     __ LoadObject(RAX, bool_false);
@@ skipping 10 matching lines @@
   __ LoadObject(RAX, negate_result ? bool_false : bool_true);
   __ Bind(&done);
 }
 
 
 void FlowGraphCompiler::VisitInstanceOf(InstanceOfComp* comp) {
   if (comp->type_arguments() != NULL) {
     __ popq(RDX);
   }
   LoadValue(RAX, comp->value());
-  GenerateInstanceOf(comp->node_id(),
+  GenerateInstanceOf(comp->cid(),
                      comp->token_index(),
                      comp->try_index(),
                      comp->type(),
                      comp->negate_result());
 }
 
 
 void FlowGraphCompiler::VisitAllocateObject(AllocateObjectComp* comp) {
   const Class& cls = Class::ZoneHandle(comp->constructor().owner());
   const Code& stub = Code::Handle(StubCode::GetAllocationStubForClass(cls));
@@ skipping 85 matching lines @@
     __ cmpq(FieldAddress(RAX, TypeArguments::length_offset()),
         arguments_length);
     __ j(EQUAL, &type_arguments_instantiated, Assembler::kNearJump);
     __ Bind(&type_arguments_uninstantiated);
   }
   // A runtime call to instantiate the type arguments is required before
   // calling the factory.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ PushObject(comp->type_arguments());
   __ pushq(RAX);  // Push instantiator type arguments.
-  GenerateCallRuntime(comp->node_id(),
+  GenerateCallRuntime(comp->cid(),
                       comp->token_index(),
                       comp->try_index(),
                       kInstantiateTypeArgumentsRuntimeEntry);
   __ popq(RAX);  // Pop instantiator type arguments.
   __ popq(RAX);  // Pop uninstantiated type arguments.
   __ popq(RAX);  // Pop instantiated type arguments.
   __ Bind(&type_arguments_instantiated);
   // RAX: Instantiated type arguments.
 }
 
@@ skipping 111 matching lines @@
                      CTX);
   // Set new context as current context.
   __ movq(CTX, RAX);
 }
 
 
 void FlowGraphCompiler::VisitCloneContext(CloneContextComp* comp) {
   __ popq(RAX);  // Get context value from stack.
   __ PushObject(Object::ZoneHandle());  // Make room for the result.
   __ pushq(RAX);
-  GenerateCallRuntime(comp->node_id(),
+  GenerateCallRuntime(comp->cid(),
                       comp->token_index(),
                       comp->try_index(),
                       kCloneContextRuntimeEntry);
   __ popq(RAX);  // Remove argument.
   __ popq(RAX);  // Get result (cloned context).
 }
 
 
 // Restore stack and initialize the two exception variables:
 // exception and stack trace variables.
@@ skipping 111 matching lines @@
   // return pattern with a call to the debug stub.
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   __ nop(1);
   AddCurrentDescriptor(PcDescriptors::kReturn,
-                       instr->node_id(),
+                       instr->cid(),
                        instr->token_index(),
                        CatchClauseNode::kInvalidTryIndex);  // try-index.
 }
 
 
 void FlowGraphCompiler::VisitThrow(ThrowInstr* instr) {
   LoadValue(RAX, instr->exception());
   __ pushq(RAX);
-  GenerateCallRuntime(instr->node_id(),
+  GenerateCallRuntime(instr->cid(),
                       instr->token_index(),
                       instr->try_index(),
                       kThrowRuntimeEntry);
   __ int3();
 }
 
 
 void FlowGraphCompiler::VisitReThrow(ReThrowInstr* instr) {
   LoadValue(RAX, instr->exception());
   __ pushq(RAX);
   LoadValue(RAX, instr->stack_trace());
   __ pushq(RAX);
-  GenerateCallRuntime(instr->node_id(),
+  GenerateCallRuntime(instr->cid(),
                       instr->token_index(),
                       instr->try_index(),
                       kReThrowRuntimeEntry);
   __ int3();
 }
 
 
 
 void FlowGraphCompiler::VisitBranch(BranchInstr* instr) {
   // Determine if the true branch is fall through (!negated) or the false
@@ skipping 367 matching lines @@
 // Infrastructure copied from class CodeGenerator.
 void FlowGraphCompiler::GenerateCall(intptr_t token_index,
                                      intptr_t try_index,
                                      const ExternalLabel* label,
                                      PcDescriptors::Kind kind) {
   __ call(label);
   AddCurrentDescriptor(kind, AstNode::kNoId, token_index, try_index);
 }
 
 
-void FlowGraphCompiler::GenerateCallRuntime(intptr_t node_id,
+void FlowGraphCompiler::GenerateCallRuntime(intptr_t cid,
                                             intptr_t token_index,
                                             intptr_t try_index,
                                             const RuntimeEntry& entry) {
   __ CallRuntime(entry);
-  AddCurrentDescriptor(PcDescriptors::kOther, node_id, token_index, try_index);
+  AddCurrentDescriptor(PcDescriptors::kOther, cid, token_index, try_index);
 }
 
 
 // Uses current pc position and try-index.
 void FlowGraphCompiler::AddCurrentDescriptor(PcDescriptors::Kind kind,
-                                             intptr_t node_id,
+                                             intptr_t cid,
                                              intptr_t token_index,
                                              intptr_t try_index) {
   pc_descriptors_list_->AddDescriptor(kind,
                                       assembler_->CodeSize(),
-                                      node_id,
+                                      cid,
                                       token_index,
                                       try_index);
 }
 
 
 void FlowGraphCompiler::FinalizePcDescriptors(const Code& code) {
   ASSERT(pc_descriptors_list_ != NULL);
   const PcDescriptors& descriptors = PcDescriptors::Handle(
       pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
   descriptors.Verify(parsed_function_.function().is_optimizable());
@@ skipping 18 matching lines @@
   ASSERT(exception_handlers_list_ != NULL);
   const ExceptionHandlers& handlers = ExceptionHandlers::Handle(
       exception_handlers_list_->FinalizeExceptionHandlers(code.EntryPoint()));
   code.set_exception_handlers(handlers);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64